vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/interactive.js

@@ -1,12 +1,68 @@
 const { TRUINavigation } = require('./trui-navigation');
 const { checkVibeCodingMachineExists, getHostname, requirementsExists, t, isComputerNameEnabled } = require('vibecodingmachine-core');
-const os = require('os');
-const path = require('path');
 const chalk = require('chalk');
 const { checkAutoModeStatus } = require('./auto-mode');
 const pkg = require('../../package.json');
-const boxen = require('boxen');
-const inquirer = require('inquirer');
+
+// Import refactored modules
+const {
+  translateStage,
+  normalizeProjectDirName,
+  bootstrapProjectIfInHomeDir,
+  formatIDEName,
+  getCurrentAIProvider,
+  getAgentDisplayName,
+  formatPath,
+  countRequirements,
+  getRepoPath,
+  getSyncStatus,
+  getCurrentProgress,
+  showGoodbyeMessage,
+  indexToLetter
+} = require('./interactive/core-ui');
+
+const {
+  showRequirementsTree,
+  getSectionTitle,
+  getRequirementList,
+  handleAddRequirement
+} = require('./interactive/requirements-navigation');
+
+const {
+  confirmAction,
+  confirmAndExit,
+  performRequirementAction
+} = require('./interactive/requirement-actions');
+
+const {
+  showWelcomeScreen,
+  showMainMenu,
+  showSettingsMenu,
+  showComputerNameSettings,
+  showStatistics,
+  showSyncStatus,
+  searchRequirements,
+  showConfirmDialog,
+  showInputDialog,
+  showSelectDialog,
+  showMultiSelectDialog,
+  showError,
+  showSuccess,
+  showWarning,
+  showInfo
+} = require('./interactive/interactive-prompts');
+
+const {
+  showRequirementsBySection,
+  showRequirementsFromChangelog,
+  createBackup,
+  restoreFromBackup,
+  listBackups,
+  validateRequirementsFile,
+  getRequirementsStats,
+  exportRequirements,
+  importRequirements
+} = require('./interactive/file-operations');
 
 /**
  * Start TRUI interface
@@ -20,3522 +76,397 @@ async function startInteractive() {
  * Expose showProviderManagerMenu for external callers (Electron, tests)
  */
 async function showProviderManagerMenu() {
-  const { showProviderManagerMenu: show } = require('./trui-provider-manager');
+  const { showProviderManagerMenu: show } = require('./provider-manager');
   return show();
 }
 
-
 /**
- * Translate workflow stage names
+ * Main interactive loop
  */
-function translateStage(stage) {
-  const stageMap = {
-    'PREPARE': 'workflow.stage.prepare',
-    'REPRODUCE': 'workflow.stage.reproduce',
-    'CREATE UNIT TEST': 'workflow.stage.create.unit.test',
-    'ACT': 'workflow.stage.act',
-    'CLEAN UP': 'workflow.stage.clean.up',
-    'VERIFY': 'workflow.stage.verify',
-    'RUN UNIT TESTS': 'workflow.stage.run.unit.tests',
-    'DONE': 'workflow.stage.done'
-  };
-
-  const key = stageMap[stage];
-  return key ? t(key) : stage;
-}
-
-function normalizeProjectDirName(input) {
-  const s = String(input || '').trim().toLowerCase();
-  const replaced = s.replace(/\s+/g, '-');
-  const cleaned = replaced.replace(/[^a-z0-9._-]/g, '-');
-  const collapsed = cleaned.replace(/-+/g, '-').replace(/^[-._]+|[-._]+$/g, '');
-  return collapsed || 'my-project';
-}
-
-async function bootstrapProjectIfInHomeDir() {
-  let cwdResolved = path.resolve(process.cwd());
-  let homeResolved = path.resolve(os.homedir());
-
-  try {
-    cwdResolved = await fs.realpath(cwdResolved);
-  } catch (err) {
-    // Ignore
-  }
-
+async function main() {
   try {
-    homeResolved = await fs.realpath(homeResolved);
-  } catch (err) {
-    // Ignore
-  }
-
-  if (cwdResolved !== homeResolved) {
-    return;
-  }
-
-  const codeDir = path.join(homeResolved, 'code');
-  const codeDirExists = await fs.pathExists(codeDir);
-
-  if (!codeDirExists) {
-    const { shouldCreateCodeDir } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'shouldCreateCodeDir',
-        message: `No code directory found at ${codeDir}. Would you like to create it?`,
-        default: true
+    // Bootstrap project if in home directory
+    await bootstrapProjectIfInHomeDir();
+    
+    // Show welcome screen
+    await showWelcomeScreen();
+    
+    // Main menu loop
+    while (true) {
+      const choice = await showMainMenu();
+      
+      switch (choice) {
+        case 'requirements':
+          await showRequirementsTree();
+          break;
+          
+        case 'search':
+          await searchRequirements();
+          break;
+          
+        case 'add':
+          await handleAddRequirement();
+          break;
+          
+        case 'stats':
+          await showStatistics();
+          break;
+          
+        case 'settings':
+          await handleSettings();
+          break;
+          
+        case 'sync':
+          await showSyncStatus();
+          break;
+          
+        case 'auto-mode':
+          await handleAutoMode();
+          break;
+          
+        case 'exit':
+          showGoodbyeMessage();
+          return;
       }
-    ]);
-
-    if (!shouldCreateCodeDir) {
-      return;
-    }
-
-    await fs.ensureDir(codeDir);
-  }
-
-  const { projectName } = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'projectName',
-      message: 'What is the project name you want to create?',
-      validate: (value) => {
-        const trimmed = String(value || '').trim();
-        return trimmed.length > 0 || 'Please enter a project name.';
+      
+      // Pause before showing menu again
+      if (choice !== 'exit') {
+        console.log(chalk.gray('\nPress Enter to continue...'));
+        await new Promise(resolve => {
+          process.stdin.once('data', resolve);
+        });
+        console.clear();
       }
     }
-  ]);
-
-  const dirName = normalizeProjectDirName(projectName);
-  const projectDir = path.join(codeDir, dirName);
-  await fs.ensureDir(projectDir);
-
-  process.chdir(projectDir);
-  try {
-    await writeConfig({ ...(await readConfig()), repoPath: projectDir });
-  } catch (err) {
-    // Best-effort: interactive mode will still use process.cwd()
+    
+  } catch (error) {
+    showError('An error occurred in the interactive interface', error);
+    process.exit(1);
   }
 }
 
 /**
- * Format IDE name for display
- * @param {string} ide - Internal IDE identifier
- * @returns {string} Display name for IDE
+ * Handle settings menu
  */
-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',
-    'kiro': 'AWS Kiro'
-  };
-  return ideNames[ide] || ide;
+async function handleSettings() {
+  while (true) {
+    const choice = await showSettingsMenu();
+    
+    switch (choice) {
+      case 'computer-name':
+        await showComputerNameSettings();
+        break;
+        
+      case 'language':
+        await handleLanguageSettings();
+        break;
+        
+      case 'statistics':
+        await handleStatisticsSettings();
+        break;
+        
+      case 'sync':
+        await handleSyncSettings();
+        break;
+        
+      case 'back':
+        return;
+    }
+  }
 }
 
 /**
- * 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
+ * Handle language settings
  */
+async function handleLanguageSettings() {
+  console.log(chalk.bold('\n🌐 Language Settings\n'));
+  console.log(chalk.gray('Language settings are controlled by environment variables\n'));
+  console.log(chalk.gray('Set LANG environment variable to change language\n'));
+  
+  const currentLang = process.env.LANG || 'en_US.UTF-8';
+  console.log(chalk.yellow(`Current language: ${currentLang}\n`));
+}
+
 /**
- * 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)"
+ * Handle statistics settings
  */
-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 === 'kiro') return 'AWS Kiro AI 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', 'vibecodingmachine', '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';
+async function handleStatisticsSettings() {
+  console.log(chalk.bold('\n📊 Statistics Settings\n'));
+  
+  const choices = [
+    { name: '📈 Show detailed statistics', value: 'detailed' },
+    { name: '📋 Export statistics', value: 'export' },
+    { name: '🔄 Refresh statistics cache', value: 'refresh' },
+    { name: '⬅️  Back', value: 'back' }
+  ];
+  
+  const choice = await showSelectDialog('Statistics options:', choices);
+  
+  switch (choice) {
+    case 'detailed':
+      await showDetailedStatistics();
+      break;
+    case 'export':
+      await exportStatistics();
+      break;
+    case 'refresh':
+      await refreshStatistics();
+      break;
   }
-
-  // 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', 'vibecodingmachine', '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';
-    }
+/**
+ * Handle sync settings
+ */
+async function handleSyncSettings() {
+  console.log(chalk.bold('\n🔄 Sync Settings\n'));
+  
+  const choices = [
+    { name: '🔄 Force sync now', value: 'force-sync' },
+    { name: '⚙️  Sync configuration', value: 'config' },
+    { name: '📊 Sync history', value: 'history' },
+    { name: '⬅️  Back', value: 'back' }
+  ];
+  
+  const choice = await showSelectDialog('Sync options:', choices);
+  
+  switch (choice) {
+    case 'force-sync':
+      await forceSync();
+      break;
+    case 'config':
+      await showSyncConfig();
+      break;
+    case 'history':
+      await showSyncHistory();
+      break;
   }
+}
 
+/**
+ * Handle auto mode
+ */
+async function handleAutoMode() {
   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';
+    const autoModeStatus = await checkAutoModeStatus();
+    
+    if (autoModeStatus.running) {
+      const confirmed = await showConfirmDialog('Stop auto mode?');
+      if (confirmed) {
+        // TODO: Implement stop auto mode
+        showSuccess('Auto mode stopped');
+      }
+    } else {
+      const confirmed = await showConfirmDialog('Start auto mode?');
+      if (confirmed) {
+        // TODO: Implement start auto mode
+        showSuccess('Auto mode started');
       }
-      return 'OpenAI Native';
     }
-
-    return apiProvider;
   } catch (error) {
-    return 'Unknown';
+    showError('Error handling auto mode', error);
   }
 }
 
-function formatPath(fullPath) {
-  const homeDir = os.homedir();
-  if (fullPath.startsWith(homeDir)) {
-    return fullPath.replace(homeDir, '~');
-  }
-  return fullPath;
-}
-
-async function countRequirements() {
+/**
+ * Show detailed statistics
+ */
+async function showDetailedStatistics() {
+  console.log(chalk.bold('\n📈 Detailed Statistics\n'));
+  
   try {
-    const { getProjectRequirementStats } = require('vibecodingmachine-core');
-    const repoPath = await getRepoPath();
-    return await getProjectRequirementStats(repoPath);
+    const stats = await getRequirementsStats();
+    if (stats) {
+      console.log(chalk.yellow('File Statistics:'));
+      console.log(chalk.gray(`  • Total lines: ${stats.totalLines}`));
+      console.log(chalk.gray(`  • Last modified: ${stats.lastModified.toLocaleString()}\n`));
+      
+      console.log(chalk.yellow('Requirement Distribution:'));
+      console.log(chalk.gray(`  • Todo: ${stats.todoCount}`));
+      console.log(chalk.gray(`  • Verified: ${stats.verifyCount}`));
+      console.log(chalk.gray(`  • Needs clarification: ${stats.clarificationCount}`));
+      console.log(chalk.gray(`  • Recycled: ${stats.recycledCount}`));
+      console.log(chalk.gray(`  • Total: ${stats.totalRequirements}\n`));
+    }
   } catch (error) {
-    return null;
+    showError('Error getting detailed statistics', error);
   }
 }
 
-async function getSyncStatus() {
+/**
+ * Export statistics
+ */
+async function exportStatistics() {
+  const formats = ['json', 'csv', 'txt'];
+  const format = await showSelectDialog('Export format:', formats);
+  
   try {
-    const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
-    const syncEngine = new SyncEngine();
-    await syncEngine.initialize();
-    const status = syncEngine.getStatus();
-    syncEngine.stop();
-
-    if (!status.isOnline && status.queuedChanges > 0) {
-      return `[Offline: ${status.queuedChanges} queued]`;
-    } else if (!status.isOnline) {
-      return '[Offline]';
-    } else if (status.isSyncing) {
-      return '[Syncing...]';
-    } else if (status.lastSyncTime) {
-      const timeSinceSync = Date.now() - status.lastSyncTime;
-      const minutesAgo = Math.floor(timeSinceSync / (1000 * 60));
-      if (minutesAgo < 1) {
-        return '[Sync: ✓ just now]';
-      } else if (minutesAgo < 60) {
-        return `[Sync: ✓ ${minutesAgo}m ago]`;
-      } else {
-        const hoursAgo = Math.floor(minutesAgo / 60);
-        return `[Sync: ✓ ${hoursAgo}h ago]`;
-      }
-    } else {
-      return '[Never synced]';
-    }
+    await exportRequirements(format);
   } catch (error) {
-    return '[Sync unavailable]';
+    showError('Error exporting statistics', error);
   }
 }
 
-async function getCurrentProgress() {
+/**
+ * Refresh statistics cache
+ */
+async function refreshStatistics() {
   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;
+    // TODO: Implement cache refresh
+    showSuccess('Statistics cache refreshed');
   } catch (error) {
-    return null;
+    showError('Error refreshing statistics', error);
   }
 }
 
-async function showWelcomeScreen() {
-
-
-  const repoPath = process.cwd(); // Always use current working directory
-  const autoStatus = await checkAutoModeStatus();
-  const hostname = getHostname();
-
-  // Get current IDE from config
-  const { getAutoConfig } = require('./config');
-  const autoConfig = await getAutoConfig();
-
-  // Check for requirements file
-  const hasRequirements = await requirementsExists();
-
-  // Count requirements if file exists
-  const counts = hasRequirements ? await countRequirements() : null;
-
-  // Clear the screen using console.clear() for better cross-platform compatibility
-  // This ensures proper screen refresh and prevents text overlap
-  console.clear();
-
-  // Get version from package.json
-  const version = `v${pkg.version}`;
-
-  // Display welcome banner with version
-  console.log('\n' + boxen(
-    chalk.bold.cyan('Vibe Coding Machine') + '\n' +
-    chalk.gray(version) + '\n' +
-    chalk.gray(t('banner.tagline')),
-    {
-      padding: 1,
-      margin: 0,
-      borderStyle: 'round',
-      borderColor: 'cyan'
-    }
-  ));
-
-  // Display repository and system info
-  console.log();
-  console.log(chalk.gray(t('system.repo').padEnd(25)), formatPath(repoPath));
-
-  // Display git branch if in a git repo
+/**
+ * Force sync
+ */
+async function forceSync() {
   try {
-    const { isGitRepo, getCurrentBranch, hasUncommittedChanges } = require('vibecodingmachine-core');
-    if (isGitRepo(repoPath)) {
-      const branch = getCurrentBranch(repoPath);
-      if (branch) {
-        const isDirty = hasUncommittedChanges(repoPath);
-        const branchDisplay = isDirty ? `${chalk.cyan(branch)} ${chalk.yellow(t('system.git.status.dirty'))}` : chalk.cyan(branch);
-        console.log(chalk.gray(t('system.git.branch').padEnd(25)), branchDisplay);
-      }
-    }
+    // TODO: Implement force sync
+    showSuccess('Sync completed');
   } catch (error) {
-    // Ignore git display errors
-  }
-
-  console.log(chalk.gray(t('system.computer.name').padEnd(25)), 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;
-
-      // Truncate requirement text first, THEN apply color to fix box alignment
-      const requirementText = progress.requirement ? progress.requirement.substring(0, 60) + (progress.requirement.length > 60 ? '...' : '') : 'No requirement';
-
-      console.log(boxen(
-        statusColor.bold(`${icon} ${progress.status}`) + '\n' +
-        chalk.gray(requirementText),
-        {
-          padding: { left: 1, right: 1, top: 0, bottom: 0 },
-          margin: 0,
-          borderStyle: 'round',
-          borderColor: 'magenta',
-          width: 70
-        }
-      ));
-    }
-
-    // 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 || '');
-      });
-    }
+    showError('Error forcing sync', error);
   }
-
-  console.log();
 }
 
-// Helper to convert index to letter (0->a, 1->b, etc.)
-function indexToLetter(index) {
-  return String.fromCharCode(97 + index); // 97 is 'a'
+/**
+ * Show sync configuration
+ */
+async function showSyncConfig() {
+  console.log(chalk.bold('\n⚙️  Sync Configuration\n'));
+  console.log(chalk.gray('Sync configuration is stored in .vibecodingmachine/config.json\n'));
+  // TODO: Show actual config
 }
 
-// Tree-style requirements navigator
-async function showRequirementsTree() {
-  console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
-  console.log(chalk.gray(t('requirements.navigator.basic.instructions') + '\n'));
-
-  const tree = {
-    expanded: { root: true },
-    selected: 0,
-    items: []
-  };
-
-  // Build tree structure
-  const buildTree = async () => {
-    tree.items = [];
-
-    // Root: Requirements
-    tree.items.push({ level: 0, type: 'root', label: `📋 ${t('requirements.menu.label')}`, key: 'root' });
-
-    if (tree.expanded.root) {
-      tree.items.push({ level: 1, type: 'add', label: '➕ ' + t('requirements.add.new'), key: 'add-one' });
-      tree.items.push({ level: 1, type: 'add', label: '➕ ' + t('requirements.add.multiple'), key: 'add-many' });
-
-      // Use pre-calculated stats and labels from shared logic
-      const stats = await countRequirements();
-      const { todoCount, toVerifyCount, verifiedCount, total, todoLabel, toVerifyLabel, verifiedLabel } = stats || {
-        todoCount: 0, toVerifyCount: 0, verifiedCount: 0, total: 0,
-        todoLabel: '⏳ TODO (0 - 0%)', toVerifyLabel: '✅ TO VERIFY (0 - 0%)', verifiedLabel: '🎉 VERIFIED (0 - 0%)'
-      };
-
-      // Create localized labels
-      const localizedTodoLabel = todoCount > 0 ?
-        `⏳ ${t('requirements.section.todo')} (${todoCount} - ${Math.round((todoCount / total) * 100)}%)` :
-        `⏳ ${t('requirements.section.todo')} (0 - 0%)`;
-
-      const localizedToVerifyLabel = toVerifyCount > 0 ?
-        `✅ ${t('requirements.section.to.verify')} (${toVerifyCount} - ${Math.round((toVerifyCount / total) * 100)}%)` :
-        `✅ ${t('requirements.section.to.verify')} (0 - 0%)`;
-
-      const localizedVerifiedLabel = verifiedCount > 0 ?
-        `🎉 ${t('requirements.section.verified')} (${verifiedCount} - ${Math.round((verifiedCount / total) * 100)}%)` :
-        `🎉 ${t('requirements.section.verified')} (0 - 0%)`;
-
-      const verifiedReqs = tree.verifiedReqs || [];
-      const verifyReqs = tree.verifyReqs || [];
-      const clarificationReqs = tree.clarificationReqs || [];
-      const todoReqs = tree.todoReqs || [];
-      const recycledReqs = tree.recycledReqs || [];
-
-      // Calculate percentages for clarification and recycled sections
-      const clarificationPercent = total > 0 ? Math.round((clarificationReqs.length / total) * 100) : 0;
-      const recycledPercent = total > 0 ? Math.round((recycledReqs.length / total) * 100) : 0;
-
-      // VERIFIED section (first) - only show if has requirements
-      if (verifiedReqs.length > 0 || verifiedCount > 0) {
-        tree.items.push({ level: 1, type: 'section', label: localizedVerifiedLabel, 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) - only show if has requirements
-      if (verifyReqs.length > 0 || toVerifyCount > 0) {
-        tree.items.push({ level: 1, type: 'section', label: localizedToVerifyLabel, 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) - only show if has requirements
-      if (clarificationReqs.length > 0) {
-        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) - only show if has requirements
-      if (todoReqs.length > 0 || todoCount > 0) {
-        tree.items.push({ level: 1, type: 'section', label: localizedTodoLabel, 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) - only show if has requirements
-      if (recycledReqs.length > 0) {
-        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', 'Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG']
-      : [sectionTitle];
-
-    // For TO VERIFY, we need to find the exact section header
-    // The section header is: ## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG
-    const toVerifySectionHeader = '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG';
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-
-      // Check if this line matches any of the section titles
-      // IMPORTANT: Only check section headers (lines starting with ##), not requirement text
-      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
-        // Reset inSection if we hit a section header that's not our target section
-        if (sectionKey === 'verify' && inSection) {
-          // Check if this is still a TO VERIFY section header
-          if (!isStillToVerify) {
-            // This will be handled by the "leaving section" check below, but ensure we don't process it as entering
-          }
-        }
-        if (sectionKey === 'verify') {
-          // For TO VERIFY, check for the specific section header with exact matching
-          // Must match the exact TO VERIFY section header, not just any line containing "TO VERIFY"
-          const isToVerifyHeader = trimmed === '## 🔍 TO VERIFY BY HUMAN' ||
-            trimmed.startsWith('## 🔍 TO VERIFY BY HUMAN') ||
-            trimmed === '## 🔍 TO VERIFY' ||
-            trimmed.startsWith('## 🔍 TO VERIFY') ||
-            trimmed === '## TO VERIFY' ||
-            trimmed.startsWith('## TO VERIFY') ||
-            trimmed === '## ✅ TO VERIFY' ||
-            trimmed.startsWith('## ✅ TO VERIFY') ||
-            trimmed === toVerifySectionHeader ||
-            (trimmed.startsWith(toVerifySectionHeader) && trimmed.includes('Needs Human to Verify'));
-
-          if (isToVerifyHeader) {
-            // Make sure it's not a VERIFIED section (without TO VERIFY)
-            if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
-              inSection = true;
-              continue;
-            }
-          } else {
-            // If we hit a different section header and we're looking for TO VERIFY, make sure we're not in section
-            // This prevents incorrectly reading from TODO or other sections
-            if (trimmed.includes('⏳ Requirements not yet completed') ||
-              trimmed.includes('Requirements not yet completed') ||
-              trimmed === '## 📝 VERIFIED' ||
-              trimmed.startsWith('## 📝 VERIFIED')) {
-              // We're in TODO or VERIFIED section, not TO VERIFY - reset
-              inSection = false;
-            }
-          }
-        } else if (sectionTitles.some(title => trimmed.includes(title))) {
-          inSection = true;
-          continue;
-        }
-      }
-
-      // Check if we're leaving the section (new section header that doesn't match)
-      if (inSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
-        // If this is a new section header and it's not one of our section titles, we've left the section
-        if (sectionKey === 'verify') {
-          // For TO VERIFY, only break if this is clearly a different section
-          // Check for specific section headers that indicate we've left TO VERIFY
-
-          if (isVerifiedSection || isTodoSection || isRecycledSection || isClarificationSection) {
-            break; // Different section, we've left TO VERIFY
-          }
-          // Otherwise, continue - might be REJECTED or CHANGELOG which are not section boundaries for TO VERIFY
-        } else {
-          // For other sections, break if it's a new section header that doesn't match
-          if (!sectionTitles.some(title => trimmed.includes(title))) {
-            break;
-          }
-        }
-      }
-
-      // Read requirements in new format (### header)
-      if (inSection && line.trim().startsWith('###')) {
-        const title = line.trim().replace(/^###\s*/, '').trim();
-
-        // Skip malformed requirements (title is just a package name, empty, or too short)
-        // Common package names that shouldn't be requirement titles
-        const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
-        if (!title || title.length === 0 || packageNames.includes(title.toLowerCase())) {
-          continue; // Skip this malformed requirement
-        }
-
-        const details = [];
-        let pkg = 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:')) {
-            pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
-          } else if (nextLine && !nextLine.startsWith('PACKAGE:')) {
-            // Description line
-            details.push(nextLine);
-          }
-        }
-
-        requirements.push({ title, details, pkg, lineIndex: i });
-      }
-    }
-
-    // Remove duplicates based on title (keep first occurrence)
-    const seenTitles = new Set();
-    const uniqueRequirements = [];
-    for (const req of requirements) {
-      const normalizedTitle = req.title.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
-      if (!seenTitles.has(normalizedTitle)) {
-        seenTitles.add(normalizedTitle);
-        uniqueRequirements.push(req);
-      }
-    }
-
-    return uniqueRequirements;
-  };
-
-  // 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();
+/**
+ * Show sync history
+ */
+async function showSyncHistory() {
+  console.log(chalk.bold('\n📊 Sync History\n'));
+  console.log(chalk.gray('Sync history is stored in .vibecodingmachine/logs/sync.log\n'));
+  // TODO: Show actual history
+}
 
-    if (!reqPath || !await fs.pathExists(reqPath)) {
-      return [];
+/**
+ * Handle keyboard shortcuts
+ */
+function setupKeyboardShortcuts() {
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+  
+  process.stdin.on('data', (key) => {
+    // Handle Ctrl+C
+    if (key === '\u0003') {
+      confirmAndExit();
+    }
+    
+    // Handle 'q' for quit
+    if (key === 'q') {
+      confirmAndExit();
+    }
+    
+    // Handle '?' for help
+    if (key === '?') {
+      showHelp();
     }
+  });
+}
 
-    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];
-      const trimmed = line.trim();
-
-      // Check if we're entering the clarification section
-      if (trimmed.includes('❓ Requirements needing manual feedback')) {
-        inSection = true;
-        continue;
-      }
-
-      // Check if we're leaving the section (hit another ## section)
-      if (inSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
-        break;
-      }
-
-      // Read requirements in new format (### header)
-      if (inSection && trimmed.startsWith('###')) {
-        const title = trimmed.replace(/^###\s*/, '').trim();
-
-        // Skip empty titles
-        if (!title || title.length === 0) {
-          continue;
-        }
-
-        const details = [];
-        const questions = [];
-        let pkg = null;
-        let findings = null;
-        let currentQuestion = null;
-
-        // Read package, description, and clarifying questions
-        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:')) {
-            pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
-          }
-          // Check for AI findings
-          else if (nextLine.startsWith('**AI found in codebase:**')) {
-            // Next line will be the findings
-            continue;
-          }
-          else if (nextLine.startsWith('**What went wrong')) {
-            // Description line
-            details.push(nextLine);
-          }
-          else if (nextLine.startsWith('**Clarifying questions:**')) {
-            // Start of questions section
-            continue;
-          }
-          else if (nextLine.match(/^\d+\./)) {
-            // Save previous question if exists
-            if (currentQuestion) {
-              questions.push(currentQuestion);
-            }
-            // This is a new question
-            currentQuestion = { question: nextLine, response: null };
-          }
-          else if (currentQuestion && nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
-            // This might be a response to the current question or description/findings
-            if (!findings && !currentQuestion.response && questions.length === 0 && !nextLine.match(/^\d+\./)) {
-              // This is findings content
-              findings = nextLine;
-            } else if (currentQuestion && !currentQuestion.response) {
-              // This is a response to the current question
-              currentQuestion.response = nextLine;
-            } else {
-              // Description line
-              details.push(nextLine);
-            }
-          }
-          else if (nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
-            // Description line
-            details.push(nextLine);
-          }
-        }
-
-        // Save last question if exists
-        if (currentQuestion) {
-          questions.push(currentQuestion);
-        }
-
-        requirements.push({ title, details, pkg, questions, findings, lineIndex: i });
-      }
-    }
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(chalk.bold('\n❓ Help\n'));
+  console.log(chalk.yellow('Keyboard shortcuts:'));
+  console.log(chalk.gray('  • Ctrl+C or q: Quit'));
+  console.log(chalk.gray('  • ?: Show this help'));
+  console.log(chalk.gray('  • Enter: Select menu item'));
+  console.log(chalk.gray('  • Arrow keys: Navigate menus\n'));
+}
 
-    return requirements;
-  };
+/**
+ * Cleanup function
+ */
+function cleanup() {
+  process.stdin.setRawMode(false);
+  process.stdin.pause();
+}
 
-  // 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');
+// Handle process termination
+process.on('SIGINT', () => {
+  confirmAndExit();
+});
 
-  let inTree = true;
-  await buildTree();
+process.on('SIGTERM', () => {
+  showGoodbyeMessage();
+  process.exit(0);
+});
 
-  while (inTree) {
-    console.clear();
-    console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
-    console.log(chalk.gray(t('requirements.navigator.instructions') + '\n'));
+// Export main functions
+module.exports = {
+  startInteractive,
+  showProviderManagerMenu,
+  main,
+  
+  // Re-export utility functions for backward compatibility
+  translateStage,
+  normalizeProjectDirName,
+  formatIDEName,
+  getCurrentAIProvider,
+  getAgentDisplayName,
+  formatPath,
+  countRequirements,
+  getRepoPath,
+  getSyncStatus,
+  getCurrentProgress,
+  showGoodbyeMessage,
+  indexToLetter,
+  
+  // Navigation functions
+  showRequirementsTree,
+  getSectionTitle,
+  getRequirementList,
+  
+  // Action functions
+  confirmAction,
+  confirmAndExit,
+  performRequirementAction,
+  
+  // Prompt functions
+  showWelcomeScreen,
+  showMainMenu,
+  showSettingsMenu,
+  showStatistics,
+  showSyncStatus,
+  searchRequirements,
+  showConfirmDialog,
+  showInputDialog,
+  showSelectDialog,
+  showMultiSelectDialog,
+  
+  // File operations
+  showRequirementsBySection,
+  showRequirementsFromChangelog,
+  createBackup,
+  restoreFromBackup,
+  listBackups,
+  validateRequirementsFile,
+  getRequirementsStats,
+  exportRequirements,
+  importRequirements
+};
 
-    // Safety check: ensure tree.selected is within bounds
-    if (tree.items.length === 0) {
-      console.log(chalk.yellow('No items to display.'));
-      const inquirer = require('inquirer');
-      await inquirer.prompt([{
-        type: 'input',
-        name: 'continue',
-        message: `${t('interactive.press.any.key.return')}`
-      }]);
-      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;
-        await 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 === 'k' || key.name === 'up') {
-      tree.selected = Math.max(0, tree.selected - 1);
-      await buildTree();
-    } else if (key.name === 'j' || key.name === 'down') {
-      tree.selected = Math.min(tree.items.length - 1, tree.selected + 1);
-      await buildTree();
-    } 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);
-          }
-          await buildTree();
-        } else {
-          tree.expanded[current.key] = false;
-          await buildTree();
-        }
-      } else if (current.type === 'requirement') {
-        // Show requirement actions
-        await showRequirementActions(current.req, current.sectionKey, tree);
-        await buildTree();
-      } else if (current.type === 'clarification') {
-        // Show clarification requirement with questions
-        await showClarificationActions(current.req, tree, loadClarification);
-        await 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(`\n${t('interactive.press.any.key.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');
-        await 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);
-        // Reload the section that the requirement was deleted from
-        if (current.sectionKey === 'todo') {
-          tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
-        } else if (current.sectionKey === 'verify') {
-          tree.verifyReqs = await loadSection('verify', '✅ Verified by AI screenshot');
-        }
-        await buildTree();
-      } else if (current.type === 'clarification') {
-        await deleteClarification(current.req, tree);
-        tree.clarificationReqs = await loadClarification();
-        await buildTree();
-      } else if (current.type === 'recycled') {
-        await permanentlyDeleteRequirement(current.req, current.sectionKey, tree);
-        tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
-        await 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);
-        await 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);
-        await 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);
-        await 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');
-        await 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);
-        await buildTree();
-      }
-    }
-  }
-
-  process.stdin.pause();
-}
-
-// Helper to show goodbye message
-function showGoodbyeMessage() {
-  const hour = new Date().getHours();
-  const message = hour < 21
-    ? '\n👋 ' + t('interactive.goodbye') + '\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(`${t('interactive.confirm.exit')} `));
-
-  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: '✏️  Rename/Edit', value: 'rename' },
-    { label: '👍 Thumbs up (promote to Verified)', value: 'thumbs-up' },
-    { label: '👎 Thumbs down (demote to TODO)', 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') {
-      process.exit(0);
-    } else if (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;
-    case 'rename':
-      await renameRequirement(req, sectionKey, tree);
-      break;
-  }
-
-  await new Promise(resolve => setTimeout(resolve, 1000));
-}
-
-// Helper to rename requirement (title and description)
-async function renameRequirement(req, sectionKey, tree) {
-  const { getRequirementsPath } = require('vibecodingmachine-core');
-  const reqPath = await getRequirementsPath();
-
-  console.log(chalk.cyan('\n✏️  Rename/Edit Requirement\n'));
-  console.log(chalk.gray('Current title:'), chalk.white(req.title));
-  if (req.details.length > 0) {
-    console.log(chalk.gray('Current description:'));
-    req.details.forEach(line => console.log(chalk.white('  ' + line)));
-  }
-  console.log();
-
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'title',
-      message: 'New title (leave blank to keep current):',
-      default: ''
-    }
-  ]);
-
-  const newTitle = answers.title.trim() || req.title;
-
-  // Ask for description using multi-line input
-  console.log(chalk.gray('\nEnter new description (leave blank to keep current).'));
-  console.log(chalk.gray('Press Enter twice on empty line to finish:\n'));
-
-  const descriptionLines = [];
-  let emptyLineCount = 0;
-  let isFirstLine = true;
-  let newDescription = '';
-  let keptCurrent = false;
-
-  while (true) {
-    try {
-      const { line } = await inquirer.prompt([{
-        type: 'input',
-        name: 'line',
-        message: isFirstLine ? 'Description:' : ''
-      }]);
-
-      if (isFirstLine && line.trim() === '') {
-        // If first line is empty, keep current description
-        keptCurrent = true;
-        break;
-      }
-
-      isFirstLine = false;
-
-      if (line.trim() === '') {
-        emptyLineCount++;
-        if (emptyLineCount >= 2) break;
-      } else {
-        emptyLineCount = 0;
-        descriptionLines.push(line);
-      }
-    } catch (err) {
-      break;
-    }
-  }
-
-  if (!keptCurrent) {
-    newDescription = descriptionLines.join('\n');
-  }
-
-  // Read the requirements file
-  const content = await fs.readFile(reqPath, 'utf8');
-  const lines = content.split('\n');
-
-  // Find the requirement block
-  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 === req.title) {
-        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 rename'));
-    return;
-  }
-
-  // Build new requirement block
-  const newBlock = [`### ${newTitle}`];
-
-  // If new description provided, use it; otherwise keep existing details
-  if (newDescription) {
-    newDescription.split('\n').forEach(line => {
-      if (line.trim()) {
-        newBlock.push(line);
-      }
-    });
-  } else {
-    // Keep existing details (skip the ### header line)
-    for (let i = requirementStartIndex + 1; i < requirementEndIndex; i++) {
-      const line = lines[i];
-      // Skip empty lines at the start and PACKAGE lines if we want to preserve them
-      if (line.trim()) {
-        newBlock.push(line);
-      }
-    }
-  }
-
-  newBlock.push(''); // Blank line after requirement
-
-  // Replace the old block with the new one
-  lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex, ...newBlock);
-
-  // Save
-  await fs.writeFile(reqPath, lines.join('\n'));
-  console.log(chalk.green('\n✓ Requirement renamed/updated\n'));
-
-  // Update the tree data
-  const reqList = getRequirementList(tree, sectionKey);
-  const reqIndex = reqList.findIndex(r => r.title === req.title);
-  if (reqIndex !== -1) {
-    reqList[reqIndex].title = newTitle;
-    if (newDescription) {
-      reqList[reqIndex].details = newDescription.split('\n').filter(line => line.trim());
-    }
-  }
-}
-
-// 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 permanently delete requirement from file (used for recycled items)
-async function permanentlyDeleteRequirement(req, sectionKey, tree) {
-  const reqList = getRequirementList(tree, 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(`Permanently delete? (r/y/N)`)) {
-    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 === req.title) {
-          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 delete'));
-      return;
-    }
-
-    // Remove the requirement from the file completely
-    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
-
-    // Save
-    await fs.writeFile(reqPath, lines.join('\n'));
-    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 === 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
-  // Also remove any trailing blank lines that might be left behind
-  lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
-
-  // Clean up: remove any orphaned blank lines or malformed entries left after removal
-  // Check if there's a blank line followed by a malformed requirement (just "cli", "core", etc.)
-  if (requirementStartIndex < lines.length) {
-    const nextLine = lines[requirementStartIndex]?.trim();
-    const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
-    // If the next line is just a package name (likely orphaned), remove it
-    if (nextLine && packageNames.includes(nextLine.toLowerCase()) &&
-      !nextLine.startsWith('###') && !nextLine.startsWith('PACKAGE:')) {
-      lines.splice(requirementStartIndex, 1);
-    }
-    // Remove any blank lines left after removal
-    while (requirementStartIndex < lines.length && lines[requirementStartIndex]?.trim() === '') {
-      lines.splice(requirementStartIndex, 1);
-    }
-  }
-
-  // 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') {
-    // Prompt for explanation of what went wrong
-    // Prompt for explanation of what went wrong
-    console.log(chalk.gray('\nWhat went wrong? (This will be added to help the AI agent)'));
-    console.log(chalk.gray('Press Enter twice on empty line to finish:\n'));
-
-    const explanationLines = [];
-    let emptyLineCount = 0;
-    let isFirstLine = true;
-
-    while (true) {
-      try {
-        const { line } = await inquirer.prompt([{
-          type: 'input',
-          name: 'line',
-          message: isFirstLine ? 'Explanation:' : ''
-        }]);
-
-        isFirstLine = false;
-
-        if (line.trim() === '') {
-          emptyLineCount++;
-          if (emptyLineCount >= 2) break;
-        } else {
-          emptyLineCount = 0;
-          explanationLines.push(line);
-        }
-      } catch (err) {
-        break;
-      }
-    }
-
-    const explanation = explanationLines.join('\n');
-
-    // TO VERIFY -> TODO: Use shared function with explanation
-    const success = await demoteVerifyToTodo(reqPath, reqTitle, explanation);
-    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];
-
-      while (true) {
-        const pkgDisplay = selectedPackage.join(', ');
-
-        // Custom menu to allow "Up arrow" to select package
-        // Default to "Enter Requirement Name" (index 1) so user can just type
-        const { action } = await inquirer.prompt([{
-          type: 'list',
-          name: 'action',
-          message: 'New Requirement:',
-          choices: [
-            { name: `📦 Package: ${pkgDisplay}`, value: 'package' },
-            { name: '📝 Enter Requirement Name', value: 'name' },
-            { name: '❌ Cancel', value: 'cancel' }
-          ],
-          default: 1
-        }]);
-
-        if (action === 'cancel') return;
-
-        if (action === 'package') {
-          // When showing checkboxes, if "all" is currently selected along with specific packages,
-          // unselect "all" first so user sees only specific packages checked
-          let displayPackages = selectedPackage;
-          if (selectedPackage.includes('all') && selectedPackage.length > 1) {
-            displayPackages = selectedPackage.filter(p => p !== 'all');
-          }
-
-          const { pkg } = await inquirer.prompt([{
-            type: 'checkbox',
-            name: 'pkg',
-            message: 'Select package(s):',
-            choices: packages.map(p => ({
-              name: p,
-              value: p,
-              checked: displayPackages.includes(p)
-            })),
-            validate: (answer) => {
-              if (answer.length < 1) return 'You must choose at least one package.';
-              return true;
-            }
-          }]);
-
-          // When selecting specific packages, unselect "all"
-          let finalPackage = pkg;
-          // If both "all" and specific packages are selected, keep only specific packages
-          if (pkg.includes('all') && pkg.length > 1) {
-            finalPackage = pkg.filter(p => p !== 'all');
-          }
-
-          selectedPackage = finalPackage;
-          config.lastPackage = selectedPackage;
-          await writeConfig(config);
-          continue;
-        }
-
-        if (action === 'name') {
-          const { name } = await inquirer.prompt([{
-            type: 'input',
-            name: 'name',
-            message: `Enter requirement name (Package: ${pkgDisplay}):`
-          }]);
-
-          if (!name || !name.trim()) continue;
-
-          // 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');
-          await reqCommands.add(name, selectedPackage, description);
-          await new Promise(resolve => setTimeout(resolve, 1000));
-          return;
-        }
-      }
-    } 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: pkg } = 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: pkg, 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: '♻️  Recycle (move to Recycled)', value: 'recycle' },
-          { 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 'recycle':
-          const recycledReq = requirements.splice(selectedIndex, 1)[0];
-          await moveToRecycled(reqPath, recycledReq.title, sectionTitle);
-          console.log(chalk.cyan('\n✓ Moved to Recycled section\n'));
-          if (requirements.length === 0) {
-            console.log(chalk.gray('No more requirements in this section.\n'));
-            inRequirementsList = false;
-          }
-          break;
-        case 'delete':
-          const { confirmDelete } = await promptWithDefaultsOnce([{
-            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;
-
-    // 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 = async () => {
-      // Only clear and redraw on first render, not on arrow navigation
-      if (isFirstRender) {
-        // Clear entire screen only on first render
-        console.clear();
-        // Reprint the banner and status info
-        try {
-          await showWelcomeScreen();
-        } catch (err) {
-          console.error('Error displaying banner:', err);
-        }
-      } else {
-        // For arrow navigation, just move cursor to menu start position
-        // and clear only the menu area, not the entire screen
-        if (lastLinesPrinted > 0) {
-          // Move cursor up to the start of the menu and clear menu area
-          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  ${t('interactive.navigation.help', { letters: 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 = async (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') {
-        // Search backwards for the previous selectable item
-        let testIndex = selectedIndex - 1;
-        while (testIndex >= 0) {
-          if (items[testIndex].type !== 'blank' && items[testIndex].type !== 'info') {
-            selectedIndex = testIndex;
-            await displayMenu();
-            break;
-          }
-          testIndex--;
-        }
-      } else if (key.name === 'down') {
-        // Search forwards for the next selectable item
-        let testIndex = selectedIndex + 1;
-        while (testIndex < items.length) {
-          if (items[testIndex].type !== 'blank' && items[testIndex].type !== 'info') {
-            selectedIndex = testIndex;
-            await displayMenu();
-            break;
-          }
-          testIndex++;
-        }
-      } 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;
-
-  const { fetchQuotaForAgent } = require('vibecodingmachine-core/src/quota-management');
-
-  const debugQuota = process.env.VCM_DEBUG_QUOTA === '1' || process.env.VCM_DEBUG_QUOTA === 'true';
-
-  const formatDuration = (ms) => {
-    if (!ms || ms <= 0) return 'now';
-    const totalSeconds = Math.ceil(ms / 1000);
-    const hours = Math.floor(totalSeconds / 3600);
-    const minutes = Math.floor((totalSeconds % 3600) / 60);
-    const seconds = totalSeconds % 60;
-
-    if (hours > 0) return `${hours}h ${minutes}m`;
-    if (minutes > 0) return `${minutes}m ${seconds}s`;
-    return `${seconds}s`;
-  };
-
-  const render = async () => {
-    process.stdout.write('\x1Bc');
-    console.log(chalk.bold.cyan('⚙ ' + t('provider.title') + '\n'));
-
-    // Fetch quota info
-    const sharedAuth = require('vibecodingmachine-core/src/auth/shared-auth-storage');
-    const autoConfig = await getAutoConfig();
-    const quotaInfo = await sharedAuth.canRunAutoMode();
-    const remaining = Math.max(0, (quotaInfo.maxIterations || 10) - (quotaInfo.todayUsage || 0));
-
-    // Calculate time until reset (midnight)
-    const now = new Date();
-    const tonight = new Date(now);
-    tonight.setHours(24, 0, 0, 0);
-    const msUntilReset = tonight.getTime() - now.getTime();
-    const hoursUntilReset = Math.floor(msUntilReset / (1000 * 60 * 60));
-    const minsUntilReset = Math.floor((msUntilReset % (1000 * 60 * 60)) / (1000 * 60));
-
-    // Display quota as time-based instead of numeric (0/1 or 1/1 format)
-    let quotaDisplay;
-    if (remaining === 0) {
-      // Rate limit active - show when it resets (in red)
-      quotaDisplay = chalk.gray('  ' + t('provider.overall.quota') + ': ') + chalk.red(`⏰ ${t('provider.rate.limit.resets')} ${hoursUntilReset}h ${minsUntilReset}m`);
-    } else {
-      // Quota available - show when it resets (in green)
-      quotaDisplay = chalk.gray('  ' + t('provider.overall.quota') + ': ') + chalk.green(`✓ ${t('provider.available')} (${remaining}/${quotaInfo.maxIterations})`) + chalk.gray(' • ' + t('provider.resets.in') + ' ') + chalk.cyan(`${hoursUntilReset}h ${minsUntilReset}m`);
-    }
-    console.log(quotaDisplay);
-    console.log(chalk.gray('  ' + t('provider.instructions') + '\n'));
-
-    for (let idx = 0; idx < order.length; idx++) {
-      const id = order[idx];
-      const def = defMap.get(id);
-      if (!def) continue;
-      const isSelected = idx === selectedIndex;
-      const isEnabled = enabled[id] !== false;
-
-      // Check installation status for all IDEs
-      let isInstalled = true;
-      if (def.type === 'ide') {
-        try {
-          if (id === 'kiro') {
-            const { isKiroInstalled } = require('./kiro-installer');
-            isInstalled = isKiroInstalled();
-          } else if (id === 'cursor') {
-            isInstalled = await checkAppOrBinary(['Cursor'], ['cursor']);
-          } else if (id === 'windsurf') {
-            isInstalled = await checkAppOrBinary(['Windsurf'], ['windsurf']);
-          } else if (id === 'vscode') {
-            isInstalled = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
-          } else if (id === 'antigravity') {
-            isInstalled = await checkAppOrBinary(['Antigravity'], ['antigravity']);
-          } else {
-            // For other IDEs, try binary name same as id
-            isInstalled = await checkAppOrBinary([], [id]);
-          }
-        } catch (e) {
-          // If detection fails, assume not installed
-          isInstalled = false;
-        }
-      }
-
-      // Determine status emoji: disabled = red alert, not installed = yellow, enabled = green
-      let statusEmoji;
-      if (!isEnabled) {
-        statusEmoji = '🚨'; // Red for disabled
-      } else if (def.type === 'ide' && !isInstalled) {
-        statusEmoji = '🟡'; // Yellow for not installed
-      } else {
-        statusEmoji = '🟢'; // Green for enabled and installed (or LLM)
-      }
-
-      const typeLabel = def.type === 'ide' ? chalk.cyan('IDE') : chalk.cyan('LLM');
-      const prefix = isSelected ? chalk.cyan('❯') : ' ';
-      let line = `${prefix} ${statusEmoji} ${idx + 1}. ${def.name} ${chalk.gray(`(${def.id})`)}  ${typeLabel}`;
-
-      // Fetch and display specific quota for this agent
-      try {
-        // Find the active model for this provider if possible
-        let model = def.defaultModel || id;
-        if (id === 'groq') model = autoConfig.groqModel || model;
-        else if (id === 'anthropic') model = autoConfig.anthropicModel || model;
-        else if (id === 'ollama') {
-          const preferredModel = autoConfig.llmModel && autoConfig.llmModel.includes('ollama/')
-            ? autoConfig.llmModel.split('/')[1]
-            : autoConfig.llmModel || autoConfig.aiderModel;
-          model = (preferredModel && preferredModel !== id) ? preferredModel : model;
-        }
-
-        const agentId = `${id}:${model}`;
-        const quota = await fetchQuotaForAgent(agentId);
-
-        if (debugQuota) {
-          const resetMs = quota?.resetsAt ? (new Date(quota.resetsAt).getTime() - Date.now()) : null;
-          console.error(`[VCM_DEBUG_QUOTA] provider=${id} model=${model} type=${quota?.type} remaining=${quota?.remaining} limit=${quota?.limit} resetsAt=${quota?.resetsAt ? new Date(quota.resetsAt).toISOString() : 'null'} resetIn=${resetMs !== null ? formatDuration(resetMs) : 'null'}`);
-        }
-
-        if (quota.type === 'infinite') {
-          line += ` ${chalk.gray('[' + t('provider.status.quota.infinite') + ']')}`;
-        } else if (quota.type === 'rate-limit') {
-          if (quota.isExceeded()) {
-            if (quota.resetsAt) {
-              const msUntilReset = new Date(quota.resetsAt).getTime() - Date.now();
-              line += ` ${chalk.red(`[⏳ resets in ${formatDuration(msUntilReset)}]`)}`;
-            } else {
-              line += ` ${chalk.red('[Rate limited]')}`;
-            }
-          } else {
-            // Show time until rate limit starts (when it resets)
-            if (quota.resetsAt) {
-              const msUntilReset = new Date(quota.resetsAt).getTime() - Date.now();
-              line += ` ${chalk.green(`[✓ ${t('provider.status.available.resets')} ${formatDuration(msUntilReset)}]`)}`;
-            } else {
-              line += ` ${chalk.green('[' + t('provider.status.available') + ']')}`;
-            }
-          }
-        }
-      } catch (e) {
-        // Silently skip if quota fetch fails
-      }
-
-      console.log(line);
-    }
-
-    console.log();
-    if (dirty) {
-      console.log(chalk.yellow(t('provider.pending.changes')));
-    } else {
-      console.log(chalk.gray(t('provider.no.pending.changes')));
-    }
-  };
-
-  if (process.env.VCM_RENDER_ONCE === '1' || process.env.VCM_RENDER_ONCE === 'true') {
-    await render();
-    return;
-  }
-
-  return new Promise(async (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) {
-        // Check for Kiro installation if selected
-        if (selectedId === 'kiro') {
-          try {
-            const { isKiroInstalled, installKiro } = require('./kiro-installer');
-            if (!isKiroInstalled()) {
-              await installKiro();
-            }
-          } catch (e) {
-            console.log(chalk.red('Error checking/installing Kiro: ' + e.message));
-          }
-        }
-
-        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 = async (delta) => {
-      const next = selectedIndex + delta;
-      if (next >= 0 && next < order.length) {
-        selectedIndex = next;
-        await render();
-      }
-    };
-
-    const reorder = async (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;
-      await render();
-    };
-
-    const toggle = async (value) => {
-      const id = order[selectedIndex];
-      enabled[id] = value;
-      dirty = true;
-      await render();
-    };
-
-    const onKeypress = async (str, key = {}) => {
-      if (key.ctrl && key.name === 'c') {
-        cancel();
-        return;
-      }
-
-      switch (key.name) {
-        case 'up':
-          await moveSelection(-1);
-          break;
-        case 'down':
-          await moveSelection(1);
-          break;
-        case 'j':
-          await reorder(1);
-          break;
-        case 'k':
-          await reorder(-1);
-          break;
-        case 'e':
-          await toggle(true);
-          break;
-        case 'd':
-          await toggle(false);
-          break;
-        case 'space':
-          await toggle(!(enabled[order[selectedIndex]] !== false));
-          break;
-        case 'return':
-          saveAndExit(order[selectedIndex]);
-          break;
-        case 'escape':
-        case 'left':
-        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();
-
-    await render();
+// Run main function if this file is executed directly
+if (require.main === module) {
+  setupKeyboardShortcuts();
+  
+  main().catch(error => {
+    showError('Fatal error', error);
+    process.exit(1);
+  }).finally(() => {
+    cleanup();
   });
 }
-
-/* 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();
-  }
-}
-
-/**
- * Show cloud sync management menu
- */
-async function showCloudSyncMenu() {
-  console.clear();
-  console.log(chalk.bold.cyan(`\n☁️  ${t('cloud.sync.title')}\n`));
-
-  // Check if cloud sync is configured
-  try {
-    const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
-    const testEngine = new SyncEngine();
-    await testEngine.initialize();
-    testEngine.stop();
-  } catch (error) {
-    console.log(chalk.yellow(`⚠️  ${t('cloud.sync.not.configured')}\n`));
-    console.log(chalk.white(`${t('cloud.sync.setup.title')}\n`));
-    console.log(chalk.gray(`1. ${t('cloud.sync.setup.step1')} `) + chalk.cyan('./scripts/setup-cloud-sync.sh'));
-    console.log(chalk.gray(`2. ${t('cloud.sync.setup.step2')}`));
-    console.log(chalk.gray(`3. ${t('cloud.sync.setup.step3')}\n`));
-    console.log(chalk.gray(`${t('cloud.sync.setup.info')} `) + chalk.cyan('docs/CLOUD_SYNC.md\n'));
-
-    console.log(chalk.gray(t('interactive.press.enter.return')));
-    await new Promise(resolve => {
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-      rl.question('', () => {
-        rl.close();
-        resolve();
-      });
-    });
-    return;
-  }
-
-  const computerCommands = require('../commands/computers');
-  const syncCommands = require('../commands/sync');
-
-  const choices = [
-    { name: t('cloud.sync.menu.view.computers'), value: 'computers' },
-    { name: t('cloud.sync.menu.manage.remote'), value: 'manage-remote' },
-    { name: t('cloud.sync.menu.sync.now'), value: 'sync-now' },
-    { name: t('cloud.sync.menu.sync.status'), value: 'sync-status' },
-    { name: t('cloud.sync.menu.sync.history'), value: 'sync-history' },
-    { name: t('cloud.sync.menu.offline.queue'), value: 'sync-queue' },
-    { name: t('cloud.sync.menu.register'), value: 'register' },
-    { name: t('cloud.sync.menu.update.focus'), value: 'update-focus' },
-    { name: chalk.gray(t('interactive.back.to.menu')), value: 'back' }
-  ];
-
-  const { action } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'action',
-      message: t('interactive.select.option'),
-      choices: choices
-    }
-  ]);
-
-  switch (action) {
-    case 'computers':
-      try {
-        await computerCommands.listComputers();
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-        console.log(chalk.gray('\nTip: Make sure AWS credentials are configured and DynamoDB tables exist.'));
-      }
-      console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
-      await new Promise(resolve => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        rl.question('', () => {
-          rl.close();
-          resolve();
-        });
-      });
-      await showCloudSyncMenu();
-      break;
-
-    case 'manage-remote':
-      try {
-        // First, get list of computers
-        const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
-        const { ScanCommand } = require('@aws-sdk/lib-dynamodb');
-
-        const syncEngine = new SyncEngine();
-        await syncEngine.initialize();
-
-        const tableName = 'vibecodingmachine-computers';
-        const command = new ScanCommand({ TableName: tableName });
-        const response = await syncEngine.dynamoClient.send(command);
-        const computers = response.Items || [];
-
-        syncEngine.stop();
-
-        if (computers.length === 0) {
-          console.log(chalk.yellow(`\n⚠ ${t('computers.no.computers')}\n`));
-        } else {
-          // Let user select a computer
-          const computerChoices = computers.map(c => ({
-            name: `${c.hostname || c.computerId} - ${c.focusArea || t('computers.no.focus')}`,
-            value: c.computerId
-          }));
-          computerChoices.push({ name: chalk.gray(t('computers.cancel')), value: null });
-
-          const { selectedComputer } = await inquirer.prompt([
-            {
-              type: 'list',
-              name: 'selectedComputer',
-              message: t('computers.select.to.manage'),
-              choices: computerChoices
-            }
-          ]);
-
-          if (selectedComputer) {
-            const remoteReqCommands = require('../commands/requirements-remote');
-            await remoteReqCommands.manageRemoteRequirements(selectedComputer);
-          }
-        }
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-      }
-      await showCloudSyncMenu();
-      break;
-
-    case 'sync-now':
-      try {
-        await syncCommands.syncNow();
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-      }
-      console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
-      await new Promise(resolve => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        rl.question('', () => {
-          rl.close();
-          resolve();
-        });
-      });
-      await showCloudSyncMenu();
-      break;
-
-    case 'sync-status':
-      try {
-        await syncCommands.syncStatus();
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-      }
-      console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
-      await new Promise(resolve => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        rl.question('', () => {
-          rl.close();
-          resolve();
-        });
-      });
-      await showCloudSyncMenu();
-      break;
-
-    case 'sync-history':
-      try {
-        await syncCommands.viewHistory({ limit: 50 });
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-      }
-      console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
-      await new Promise(resolve => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        rl.question('', () => {
-          rl.close();
-          resolve();
-        });
-      });
-      await showCloudSyncMenu();
-      break;
-
-    case 'sync-queue':
-      try {
-        await syncCommands.viewQueue();
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-      }
-      console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
-      await new Promise(resolve => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        rl.question('', () => {
-          rl.close();
-          resolve();
-        });
-      });
-      await showCloudSyncMenu();
-      break;
-
-    case 'register':
-      try {
-        const { focusArea } = await inquirer.prompt([
-          {
-            type: 'input',
-            name: 'focusArea',
-            message: t('computers.register.focus.prompt'),
-            default: t('computers.register.focus.default')
-          }
-        ]);
-        await computerCommands.registerComputer(focusArea);
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-      }
-      console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
-      await new Promise(resolve => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        rl.question('', () => {
-          rl.close();
-          resolve();
-        });
-      });
-      await showCloudSyncMenu();
-      break;
-
-    case 'update-focus':
-      try {
-        const { newFocus } = await inquirer.prompt([
-          {
-            type: 'input',
-            name: 'newFocus',
-            message: 'Enter new focus area:'
-          }
-        ]);
-        if (newFocus) {
-          await computerCommands.updateFocus(newFocus);
-        }
-      } catch (error) {
-        console.log(chalk.red('\n✗ Error: ') + error.message);
-      }
-      console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
-      await new Promise(resolve => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout
-        });
-        rl.question('', () => {
-          rl.close();
-          resolve();
-        });
-      });
-      await showCloudSyncMenu();
-      break;
-
-    case 'back':
-      // Return to main menu
-      break;
-  }
-}
-
-
-module.exports = { 
-  startInteractive, 
-  bootstrapProjectIfInHomeDir, 
-  showProviderManagerMenu,
-  translateStage,
-  normalizeProjectDirName
-};