vibecodingmachine-cli 2025.12.1-534 → 2025.12.6-1702

package/src/utils/interactive.js

@@ -8,6 +8,7 @@ const readline = require('readline');
 const repo = require('../commands/repo');
 const auto = require('../commands/auto');
 const status = require('../commands/status');
+const requirements = require('../commands/requirements');
 const { getRepoPath, readConfig, writeConfig } = require('./config');
 const { getProviderPreferences, saveProviderPreferences, getProviderDefinitions } = require('../utils/provider-registry');
 const { checkAutoModeStatus } = require('./auto-mode');
@@ -32,7 +33,8 @@ function formatIDEName(ide) {
     'cline': 'Cline CLI',
     'cursor': 'Cursor',
     'vscode': 'VS Code',
-    'windsurf': 'Windsurf'
+    'windsurf': 'Windsurf',
+    'kiro': 'AWS Kiro'
   };
   return ideNames[ide] || ide;
 }
@@ -52,6 +54,7 @@ function getAgentDisplayName(agentType) {
   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
@@ -350,6 +353,8 @@ async function getCurrentProgress() {
 }
 
 async function showWelcomeScreen() {
+
+
   const repoPath = process.cwd(); // Always use current working directory
   const autoStatus = await checkAutoModeStatus();
   const allnightStatus = await checkVibeCodingMachineExists();
@@ -375,7 +380,8 @@ async function showWelcomeScreen() {
   // Count requirements if file exists
   const counts = hasRequirements ? await countRequirements() : null;
 
-  // Clear the screen
+  // 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
@@ -419,14 +425,18 @@ async function showWelcomeScreen() {
       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(progress.requirement ? progress.requirement.substring(0, 60) + (progress.requirement.length > 60 ? '...' : '') : 'No requirement'),
+        chalk.gray(requirementText),
         {
           padding: { left: 1, right: 1, top: 0, bottom: 0 },
           margin: 0,
           borderStyle: 'round',
-          borderColor: 'magenta'
+          borderColor: 'magenta',
+          width: 70
         }
       ));
     }
@@ -499,49 +509,59 @@ async function showRequirementsTree() {
       const todoPercent = total > 0 ? Math.round((todoReqs.length / total) * 100) : 0;
       const recycledPercent = total > 0 ? Math.round((recycledReqs.length / total) * 100) : 0;
 
-      // VERIFIED section (first)
-      tree.items.push({ level: 1, type: 'section', label: `🎉 VERIFIED (${verifiedReqs.length} - ${verifiedPercent}%)`, key: 'verified' });
+      // VERIFIED section (first) - only show if has requirements
+      if (verifiedReqs.length > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `🎉 VERIFIED (${verifiedReqs.length} - ${verifiedPercent}%)`, key: 'verified' });
 
-      if (tree.expanded.verified) {
-        verifiedReqs.forEach((req, idx) => {
-          tree.items.push({ level: 2, type: 'verified', label: req, key: `verified-${idx}` });
-        });
+        if (tree.expanded.verified) {
+          verifiedReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'verified', label: req, key: `verified-${idx}` });
+          });
+        }
       }
 
-      // TO VERIFY section (second)
-      tree.items.push({ level: 1, type: 'section', label: `✅ TO VERIFY (${verifyReqs.length} - ${verifyPercent}%)`, key: 'verify', section: '✅ Verified by AI screenshot' });
+      // TO VERIFY section (second) - only show if has requirements
+      if (verifyReqs.length > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `✅ TO VERIFY (${verifyReqs.length} - ${verifyPercent}%)`, key: 'verify', section: '✅ Verified by AI screenshot' });
 
-      if (tree.expanded.verify) {
-        verifyReqs.forEach((req, idx) => {
-          tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `verify-${idx}`, req, sectionKey: 'verify' });
-        });
+        if (tree.expanded.verify) {
+          verifyReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `verify-${idx}`, req, sectionKey: 'verify' });
+          });
+        }
       }
 
-      // NEEDING CLARIFICATION section (third)
-      tree.items.push({ level: 1, type: 'section', label: `❓ NEEDING CLARIFICATION (${clarificationReqs.length} - ${clarificationPercent}%)`, key: 'clarification', section: '❓ Requirements needing manual feedback' });
+      // 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' });
-        });
+        if (tree.expanded.clarification) {
+          clarificationReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'clarification', label: req.title, key: `clarification-${idx}`, req, sectionKey: 'clarification' });
+          });
+        }
       }
 
-      // TODO section (fourth)
-      tree.items.push({ level: 1, type: 'section', label: `⏳ TODO (${todoReqs.length} - ${todoPercent}%)`, key: 'todo', section: '⏳ Requirements not yet completed' });
+      // TODO section (fourth) - only show if has requirements
+      if (todoReqs.length > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `⏳ TODO (${todoReqs.length} - ${todoPercent}%)`, key: 'todo', section: '⏳ Requirements not yet completed' });
 
-      if (tree.expanded.todo) {
-        todoReqs.forEach((req, idx) => {
-          tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `todo-${idx}`, req, sectionKey: 'todo' });
-        });
+        if (tree.expanded.todo) {
+          todoReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'requirement', label: req.title, key: `todo-${idx}`, req, sectionKey: 'todo' });
+          });
+        }
       }
 
-      // RECYCLED section (last)
-      tree.items.push({ level: 1, type: 'section', label: `♻️ RECYCLED (${recycledReqs.length} - ${recycledPercent}%)`, key: 'recycled', section: '♻️ Recycled' });
+      // 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' });
-        });
+        if (tree.expanded.recycled) {
+          recycledReqs.forEach((req, idx) => {
+            tree.items.push({ level: 2, type: 'recycled', label: req.title, key: `recycled-${idx}`, req, sectionKey: 'recycled' });
+          });
+        }
       }
     }
   };
@@ -563,25 +583,110 @@ async function showRequirementsTree() {
 
     // 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']
+      ? ['🔍 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
-      if (sectionTitles.some(title => line.includes(title))) {
-        inSection = true;
-        continue;
+      // 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
+          const isStillToVerify = 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 === '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG' ||
+            (trimmed.startsWith('## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG') &&
+              trimmed.includes('Needs Human to Verify'));
+          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;
+        }
       }
 
-      if (inSection && line.startsWith('## ') && !line.startsWith('###') && !sectionTitles.some(title => line.includes(title))) {
-        break;
+      // 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
+          const isVerifiedSection = trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED');
+          const isTodoSection = trimmed.includes('⏳ Requirements not yet completed') || trimmed.includes('Requirements not yet completed');
+          const isRecycledSection = trimmed === '## ♻️ RECYCLED' || trimmed.startsWith('## ♻️ RECYCLED') ||
+            trimmed === '## 📦 RECYCLED' || trimmed.startsWith('## 📦 RECYCLED');
+          const isClarificationSection = trimmed.includes('## ❓ Requirements needing') || trimmed.includes('❓ Requirements needing');
+
+          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*/, '');
+        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 package = null;
 
@@ -605,7 +710,18 @@ async function showRequirementsTree() {
       }
     }
 
-    return requirements;
+    // 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
@@ -908,13 +1024,19 @@ async function showRequirementsTree() {
 
       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');
+        }
         buildTree();
       } else if (current.type === 'clarification') {
         await deleteClarification(current.req, tree);
         tree.clarificationReqs = await loadClarification();
         buildTree();
       } else if (current.type === 'recycled') {
-        await deleteRequirement(current.req, current.sectionKey, tree);
+        await permanentlyDeleteRequirement(current.req, current.sectionKey, tree);
         tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
         buildTree();
       }
@@ -1404,8 +1526,9 @@ async function showClarificationActions(req, tree, loadClarification) {
 }
 async function showRequirementActions(req, sectionKey, tree) {
   const actions = [
-    { label: '👍 Thumbs up (move to top)', value: 'thumbs-up' },
-    { label: '👎 Thumbs down (move to bottom)', value: 'thumbs-down' },
+    { label: '✏️  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' }
@@ -1477,7 +1600,9 @@ async function showRequirementActions(req, sectionKey, tree) {
 
     if (!key) continue;
 
-    if ((key.ctrl && key.name === 'c') || key.name === 'escape' || key.name === 'left') {
+    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);
@@ -1536,11 +1661,156 @@ async function performRequirementAction(action, req, sectionKey, tree) {
         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);
@@ -1560,6 +1830,61 @@ async function deleteRequirement(req, sectionKey, tree) {
   }
 }
 
+// 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.includes(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');
@@ -1600,8 +1925,25 @@ async function moveRequirementToRecycled(reqPath, requirementTitle, fromSection)
   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++) {
@@ -1703,8 +2045,41 @@ async function demoteRequirement(reqTitle, sectionKey, tree, loadSection, loadVe
   const reqPath = await getRequirementsPath();
 
   if (sectionKey === 'verify') {
-    // TO VERIFY -> TODO: Use shared function
-    const success = await demoteVerifyToTodo(reqPath, reqTitle);
+    // 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');
@@ -1734,86 +2109,104 @@ async function handleAddRequirement(type) {
       // Ensure it's an array
       if (typeof selectedPackage === 'string') selectedPackage = [selectedPackage];
 
-      let askPackage = !config.lastPackage;
-      let name = '';
-      let pkg = selectedPackage;
-
       while (true) {
-        if (askPackage) {
-          const answer = await inquirer.prompt([{
+        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: pkg.includes(p)
+              checked: displayPackages.includes(p)
             })),
             validate: (answer) => {
               if (answer.length < 1) return 'You must choose at least one package.';
               return true;
             }
           }]);
-          pkg = answer.pkg;
 
-          // Save to config
-          config.lastPackage = pkg;
-          await writeConfig(config);
-          askPackage = false;
-        }
-
-        // Ask for requirement name
-        const pkgDisplay = pkg.join(', ');
-        const nameAnswer = await inquirer.prompt([{
-          type: 'input',
-          name: 'name',
-          message: `Enter requirement name (Package: ${pkgDisplay}) [Type < to change package]:`
-        }]);
-
-        name = nameAnswer.name;
+          // 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');
+          }
 
-        if (name === '<') {
-          askPackage = true;
+          selectedPackage = finalPackage;
+          config.lastPackage = selectedPackage;
+          await writeConfig(config);
           continue;
         }
 
-        break;
-      }
-
-      // Then ask for multiline description (press Enter twice to finish)
-      console.log(chalk.gray('\nEnter description (press Enter twice on empty line to finish):\n'));
-      const descriptionLines = [];
-      let emptyLineCount = 0;
-      let isFirstLine = true;
-
-      while (true) {
-        try {
-          const { line } = await inquirer.prompt([{
+        if (action === 'name') {
+          const { name } = await inquirer.prompt([{
             type: 'input',
-            name: 'line',
-            message: isFirstLine ? 'Description:' : ''
+            name: 'name',
+            message: `Enter requirement name (Package: ${pkgDisplay}):`
           }]);
 
-          isFirstLine = false;
+          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; // Two empty lines = done
+              if (line.trim() === '') {
+                emptyLineCount++;
+                if (emptyLineCount >= 2) break;
+              } else {
+                emptyLineCount = 0;
+                descriptionLines.push(line);
+              }
+            } catch (err) {
+              break;
             }
-          } else {
-            emptyLineCount = 0;
-            descriptionLines.push(line);
           }
-        } catch (err) {
-          break; // ESC pressed
+
+          const description = descriptionLines.join('\n');
+          await reqCommands.add(name, selectedPackage, description);
+          await new Promise(resolve => setTimeout(resolve, 1000));
+          return;
         }
       }
-
-      const description = descriptionLines.join('\n');
-      await reqCommands.add(name, pkg, description);
-      // Message already printed by reqCommands.add()
-      await new Promise(resolve => setTimeout(resolve, 1000));
     } catch (err) {
       // ESC pressed
     }
@@ -1986,6 +2379,7 @@ async function showRequirementsBySection(sectionTitle) {
           { 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' }
         ]
       }]);
@@ -2026,6 +2420,15 @@ async function showRequirementsBySection(sectionTitle) {
             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 inquirer.prompt([{
             type: 'confirm',
@@ -2187,12 +2590,18 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
       return lineCount;
     };
 
-    const displayMenu = () => {
-      // Clear previous menu (move cursor up and clear lines) - but not on first render
-      if (!isFirstRender && lastLinesPrinted > 0) {
-        // Move cursor up by the number of lines we printed last time
-        readline.moveCursor(process.stdout, 0, -lastLinesPrinted);
-        readline.clearScreenDown(process.stdout);
+    const displayMenu = async () => {
+      // Clear entire screen on navigation to prevent text overlap with banner
+      if (!isFirstRender) {
+        // No need to console.clear() here as showWelcomeScreen does it, 
+        // but ensuring it clears before we start waiting is fine too.
+        console.clear();
+        // Reprint the banner and status info
+        try {
+          await showWelcomeScreen();
+        } catch (err) {
+          console.error('Error displaying banner:', err);
+        }
       }
       isFirstRender = false;
 
@@ -2296,7 +2705,7 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
       process.stdin.setRawMode(true);
     }
 
-    const onKeypress = (str, key) => {
+    const onKeypress = async (str, key) => {
       if (!key) return;
 
       // Ctrl+C to exit
@@ -2348,7 +2757,7 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
           newIndex = newIndex > 0 ? newIndex - 1 : items.length - 1;
         }
         selectedIndex = newIndex;
-        displayMenu();
+        await displayMenu();
       } else if (key.name === 'down') {
         // Skip blank and info lines when navigating
         let newIndex = selectedIndex < items.length - 1 ? selectedIndex + 1 : 0;
@@ -2356,7 +2765,8 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
           newIndex = newIndex < items.length - 1 ? newIndex + 1 : 0;
         }
         selectedIndex = newIndex;
-        displayMenu();
+        await displayMenu();
+
       } else if (key.name === 'return' || key.name === 'right') {
         // Don't allow selecting blank or info lines
         if (items[selectedIndex].type !== 'blank' && items[selectedIndex].type !== 'info') {
@@ -2393,26 +2803,73 @@ async function showProviderManagerMenu() {
       if (!def) return;
       const isSelected = idx === selectedIndex;
       const isEnabled = enabled[id] !== false;
-      const statusLabel = isEnabled ? chalk.green('ENABLED') : chalk.red('DISABLED');
-      const typeLabel = def.type === 'ide' ? chalk.cyan('IDE') : chalk.cyan('LLM');
-      const prefix = isSelected ? chalk.cyan('❯') : ' ';
-      let line = `${prefix} ${idx + 1}. ${def.name} ${chalk.gray(`(${def.id})`)}  ${typeLabel}  ${statusLabel}`;
 
       // Check for rate limits
       const timeUntilReset = providerManager.getTimeUntilReset(id, def.model || id);
-      if (timeUntilReset) {
-        const resetTime = Date.now() + timeUntilReset;
-        const resetDate = new Date(resetTime);
-        const timeStr = resetDate.toLocaleString('en-US', {
-          weekday: 'short',
-          month: 'short',
-          day: 'numeric',
+
+      // Check for Kiro installation
+      let isInstalled = true;
+      if (id === 'kiro') {
+        try {
+          const { isKiroInstalled } = require('./kiro-installer');
+          isInstalled = isKiroInstalled();
+        } catch (e) {
+          // Ignore error provider checks
+        }
+      }
+
+      // Determine status emoji: disabled = red alert, rate limited = green circle, enabled = green circle
+      let statusEmoji;
+      if (id === 'kiro' && !isInstalled) {
+        statusEmoji = '🟡'; // Yellow for not installed
+      } else {
+        statusEmoji = !isEnabled ? '🚨' : '🟢';
+      }
+
+      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}`;
+
+      // Add rate limit time if applicable
+      if (timeUntilReset && isEnabled) {
+        // Calculate reset time
+        const now = new Date();
+        const resetTime = new Date(now.getTime() + timeUntilReset);
+
+        // Format reset time in human-readable format
+        const timeFormatter = new Intl.DateTimeFormat('en-US', {
           hour: 'numeric',
           minute: '2-digit',
-          hour12: true,
           timeZoneName: 'short'
         });
-        line += ` ${chalk.red('⏰ Rate limited until ' + timeStr)}`;
+        const timeStr = timeFormatter.format(resetTime);
+
+        // Determine if it's today, tomorrow, or a specific date
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const resetDate = new Date(resetTime);
+        resetDate.setHours(0, 0, 0, 0);
+        const tomorrow = new Date(today);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+
+        let dateStr = '';
+        if (resetDate.getTime() === today.getTime()) {
+          // Today - just show time
+          dateStr = timeStr;
+        } else if (resetDate.getTime() === tomorrow.getTime()) {
+          // Tomorrow
+          dateStr = `tomorrow, ${timeStr}`;
+        } else {
+          // Specific date - show date and time
+          const dateFormatter = new Intl.DateTimeFormat('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric'
+          });
+          dateStr = `${timeStr} ${dateFormatter.format(resetTime)}`;
+        }
+
+        line += ` ${chalk.red('rate limited until ' + dateStr)}`;
       }
 
       console.log(line);
@@ -2441,6 +2898,18 @@ async function showProviderManagerMenu() {
         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);
@@ -2515,6 +2984,7 @@ async function showProviderManagerMenu() {
           saveAndExit(order[selectedIndex]);
           break;
         case 'escape':
+        case 'left':
         case 'x':
           cancel();
           break;
@@ -2620,6 +3090,276 @@ async function showSettings() {
   }
 }
 
+/**
+ * Show cloud sync management menu
+ */
+async function showCloudSyncMenu() {
+  console.clear();
+  console.log(chalk.bold.cyan('\n☁️  Cloud Sync Management\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('⚠️  Cloud sync is not configured.\n'));
+    console.log(chalk.white('To set up cloud sync:\n'));
+    console.log(chalk.gray('1. Run: ') + chalk.cyan('./scripts/setup-cloud-sync.sh'));
+    console.log(chalk.gray('2. Add AWS configuration to your .env file'));
+    console.log(chalk.gray('3. Restart vcm\n'));
+    console.log(chalk.gray('For more info, see: ') + chalk.cyan('docs/CLOUD_SYNC.md\n'));
+    
+    console.log(chalk.gray('Press Enter to return to main menu...'));
+    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: '📊 View All Computers', value: 'computers' },
+    { name: '🖥️  Manage Another Computer\'s Requirements', value: 'manage-remote' },
+    { name: '🔄 Sync Now', value: 'sync-now' },
+    { name: '📈 Sync Status', value: 'sync-status' },
+    { name: '📜 Sync History', value: 'sync-history' },
+    { name: '📋 View Offline Queue', value: 'sync-queue' },
+    { name: '🖥️  Register This Computer', value: 'register' },
+    { name: '🎯 Update Focus Area', value: 'update-focus' },
+    { name: chalk.gray('← Back to Main Menu'), value: 'back' }
+  ];
+  
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Select an 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('\nPress Enter to 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⚠ No computers registered yet.\n'));
+        } else {
+          // Let user select a computer
+          const computerChoices = computers.map(c => ({
+            name: `${c.hostname || c.computerId} - ${c.focusArea || 'No focus'}`,
+            value: c.computerId
+          }));
+          computerChoices.push({ name: chalk.gray('← Cancel'), value: null });
+          
+          const { selectedComputer } = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'selectedComputer',
+              message: 'Select computer 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('\nPress Enter to 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('\nPress Enter to 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('\nPress Enter to 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('\nPress Enter to 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: 'Enter focus area for this computer:',
+            default: 'General Development'
+          }
+        ]);
+        await computerCommands.registerComputer(focusArea);
+      } catch (error) {
+        console.log(chalk.red('\n✗ Error: ') + error.message);
+      }
+      console.log(chalk.gray('\nPress Enter to 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('\nPress Enter to 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;
+  }
+}
+
 async function startInteractive() {
   // STRICT AUTH CHECK (only if enabled)
   const authEnabled = process.env.AUTH_ENABLED === 'true';
@@ -2679,12 +3419,22 @@ async function startInteractive() {
       // Build dynamic menu items - settings at top (gray, no letters), actions below (with letters)
       const items = [];
 
-      // Get current agent (unified IDE + LLM)
-      const currentAgent = autoConfig.agent || autoConfig.ide || 'ollama';
-      let agentDisplay = `Current Agent: ${chalk.cyan(getAgentDisplayName(currentAgent))}`;
+      // Get first ENABLED agent from provider preferences
+      const { getProviderPreferences } = require('../utils/provider-registry');
+      const prefs = await getProviderPreferences();
+      let firstEnabledAgent = null;
+      for (const agentId of prefs.order) {
+        if (prefs.enabled[agentId] !== false) {
+          firstEnabledAgent = agentId;
+          break;
+        }
+      }
+      // Fallback to current agent if no enabled agents found
+      const displayAgent = firstEnabledAgent || autoConfig.agent || autoConfig.ide || 'ollama';
+      let agentDisplay = `First Agent: ${chalk.cyan(getAgentDisplayName(displayAgent))}`;
 
       // Check for rate limits (for LLM-based agents and Claude Code)
-      if (currentAgent === 'ollama' || currentAgent === 'groq' || currentAgent === 'anthropic' || currentAgent === 'bedrock' || currentAgent === 'claude-code') {
+      if (displayAgent === 'ollama' || displayAgent === 'groq' || displayAgent === 'anthropic' || displayAgent === 'bedrock' || displayAgent === 'claude-code') {
         try {
           const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
           const providerManager = new ProviderManager();
@@ -2699,44 +3449,47 @@ async function startInteractive() {
 
             // Get the model based on the current agent type
             let model;
-            if (currentAgent === 'groq') {
+            if (displayAgent === 'groq') {
               model = config.auto?.groqModel || config.auto?.aiderModel || config.auto?.llmModel;
               // Remove groq/ prefix if present
               if (model && model.includes('groq/')) {
                 model = model.split('/')[1];
               }
-            } else if (currentAgent === 'anthropic') {
+            } else if (displayAgent === 'anthropic') {
               model = config.auto?.anthropicModel || config.auto?.aiderModel || config.auto?.llmModel;
-            } else if (currentAgent === 'ollama') {
+            } else if (displayAgent === 'ollama') {
               const rawModel = config.auto?.llmModel || config.auto?.aiderModel;
               // Only use if it doesn't have groq/ prefix
               model = rawModel && !rawModel.includes('groq/') ? rawModel : null;
-            } else if (currentAgent === 'bedrock') {
+            } else if (displayAgent === 'bedrock') {
               model = 'anthropic.claude-sonnet-4-v1';
-            } else if (currentAgent === 'claude-code') {
+            } else if (displayAgent === 'claude-code') {
               model = 'claude-code-cli';
             }
 
             // For Claude Code, use fixed model name
-            const checkModel = currentAgent === 'claude-code' ? 'claude-code-cli' : model;
-            const provider = currentAgent === 'ollama' ? 'ollama' : currentAgent;
+            const checkModel = displayAgent === 'claude-code' ? 'claude-code-cli' : model;
+            const provider = displayAgent === 'ollama' ? 'ollama' : displayAgent;
 
             if (checkModel) {
               const timeUntilReset = providerManager.getTimeUntilReset(provider, checkModel);
 
               if (timeUntilReset) {
-                const resetTime = Date.now() + timeUntilReset;
-                const resetDate = new Date(resetTime);
-                const timeStr = resetDate.toLocaleString('en-US', {
-                  weekday: 'short',
-                  month: 'short',
-                  day: 'numeric',
-                  hour: 'numeric',
-                  minute: '2-digit',
-                  hour12: true,
-                  timeZoneName: 'short'
-                });
-                agentDisplay += ` ${chalk.red('⏰ Rate limited until ' + timeStr)}`;
+                // Format time remaining in human-readable format
+                const hours = Math.floor(timeUntilReset / (1000 * 60 * 60));
+                const minutes = Math.floor((timeUntilReset % (1000 * 60 * 60)) / (1000 * 60));
+                const seconds = Math.floor((timeUntilReset % (1000 * 60)) / 1000);
+
+                let timeStr = '';
+                if (hours > 0) {
+                  timeStr = `${hours}h ${minutes}m`;
+                } else if (minutes > 0) {
+                  timeStr = `${minutes}m ${seconds}s`;
+                } else {
+                  timeStr = `${seconds}s`;
+                }
+
+                agentDisplay += ` ${chalk.red('⏰ Rate limit resets in ' + timeStr)}`;
               }
             }
           }
@@ -2754,9 +3507,6 @@ async function startInteractive() {
         autoConfig.maxChats ? `Stop after ${autoConfig.maxChats}` :
           'Never Stop';
 
-      // Get restart CLI setting from autoConfig
-      const restartCLI = autoConfig.restartCLI ? chalk.green('Enabled ✓') : chalk.yellow('Disabled ○');
-
       if (autoStatus.running) {
         items.push({
           type: 'setting',
@@ -2778,45 +3528,27 @@ async function startInteractive() {
         value: 'setting:auto-stop-condition'
       });
 
-      // Add restart CLI setting
-      items.push({
-        type: 'setting',
-        name: `  └─ Restart CLI after each completed requirement: ${restartCLI}`,
-        value: 'setting:restart-cli'
-      });
-
-      // Add setup alias setting
-      items.push({
-        type: 'setting',
-        name: `  └─ Setup 'vcm' alias`,
-        value: 'setting:setup-alias'
-      });
-
-      // Add current agent setting
+      // Add current agent setting (rate limit info already included in agentDisplay if applicable)
       items.push({
         type: 'setting',
         name: `  └─ ${agentDisplay}`,
         value: 'setting:agent'
       });
 
-
-
       // Add Requirements as a selectable setting with counts
       const hasRequirements = await requirementsExists();
       const counts = hasRequirements ? await countRequirements() : null;
       let requirementsText = 'Requirements: ';
       if (counts) {
+        // Calculate actual iterations: lesser of stop after number and TODO requirements
+        const actualIterations = autoConfig.neverStop ? counts.todoCount :
+          Math.min(autoConfig.maxChats || counts.todoCount, counts.todoCount);
         const total = counts.todoCount + counts.toVerifyCount + counts.verifiedCount;
         if (total > 0) {
-          const todoPercent = Math.round((counts.todoCount / total) * 100);
+          const todoPercent = Math.round((actualIterations / total) * 100);
           const toVerifyPercent = Math.round((counts.toVerifyCount / total) * 100);
           const verifiedPercent = Math.round((counts.verifiedCount / total) * 100);
-          requirementsText += `${chalk.yellow(counts.todoCount + ' (' + todoPercent + '%) TODO')}, ${chalk.cyan(counts.toVerifyCount + ' (' + toVerifyPercent + '%) TO VERIFY')}, ${chalk.green(counts.verifiedCount + ' (' + verifiedPercent + '%) VERIFIED')}`;
-
-          // Add warning if no TODO requirements
-          if (counts.todoCount === 0) {
-            requirementsText += ` ${chalk.red('⚠️ No requirements to work on')}`;
-          }
+          requirementsText += `${chalk.yellow(actualIterations + ' (' + todoPercent + '%) TODO')}, ${chalk.cyan(counts.toVerifyCount + ' (' + toVerifyPercent + '%) TO VERIFY')}, ${chalk.green(counts.verifiedCount + ' (' + verifiedPercent + '%) VERIFIED')}`;
         } else {
           requirementsText = '';
         }
@@ -2836,10 +3568,47 @@ async function startInteractive() {
 
       items.push({
         type: 'setting',
-        name: `  └─ Use Hostname in Req File: ${useHostname ? chalk.green('Enabled ✓') : chalk.yellow('Disabled ○')}`,
+        name: `  └─ Use Hostname in Req File: ${useHostname ? chalk.green('✓') : chalk.red('🛑')} ${useHostname ? '✓ ENABLED' : '🛑 DISABLED'}`,
         value: 'setting:hostname'
       });
 
+      // Cloud Sync Status
+      try {
+        const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+        const syncEngine = new SyncEngine();
+        
+        // Try to initialize, but don't fail if AWS not configured
+        try {
+          await syncEngine.initialize();
+          const syncStatus = syncEngine.getStatus();
+          syncEngine.stop();
+          
+          const onlineIcon = syncStatus.isOnline ? chalk.green('●') : chalk.red('●');
+          const onlineText = syncStatus.isOnline ? 'Online' : 'Offline';
+          const queueText = syncStatus.queuedChanges > 0 ? chalk.yellow(` (${syncStatus.queuedChanges} queued)`) : '';
+          
+          items.push({
+            type: 'setting',
+            name: `Cloud Sync: ${onlineIcon} ${onlineText}${queueText}`,
+            value: 'setting:cloud-sync'
+          });
+        } catch (initError) {
+          // Initialization failed - AWS not configured or credentials missing
+          items.push({
+            type: 'setting',
+            name: `Cloud Sync: ${chalk.gray('● Not configured')}`,
+            value: 'setting:cloud-sync-setup'
+          });
+        }
+      } catch (error) {
+        // Module not found or other error - show disabled
+        items.push({
+          type: 'setting',
+          name: `Cloud Sync: ${chalk.gray('● Disabled')}`,
+          value: 'setting:cloud-sync-setup'
+        });
+      }
+
       // Add "Next TODO Requirement" as a separate menu item if there are TODO items
       if (counts && counts.todoCount > 0) {
         // Get the actual next requirement text (new header format)
@@ -2886,32 +3655,32 @@ async function startInteractive() {
                     if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
                       break;
                     }
+
                     description += nextLine + '\n';
                   }
-                  nextReqText = title;
+                  nextReqText = title + '\n' + description;
                   break;
                 }
               }
             }
+            items.push({
+              type: 'info',
+              name: `     └─ Next TODO Requirement: ${nextReqText}`,
+              value: 'info:next-requirement'
+            });
           }
         } catch (err) {
-          console.error('Error getting next requirement:', err.message);
+          console.error('Error reading requirements file:', err.message);
         }
-
-        // Add "Next TODO Requirement" to the menu
-        items.push({
-          type: 'info',
-          name: `Next TODO Requirement: ${nextReqText}`,
-          value: 'next-req'
-        });
       }
 
+
       // Add warning message if no TODO requirements and Auto Mode is stopped
       if (counts && counts.todoCount === 0 && !autoStatus.running) {
         items.push({
-          type: 'setting',
+          type: 'info',
           name: chalk.red('  ⚠️  No requirements to work on - cannot start Auto Mode'),
-          value: 'setting:no-requirements'
+          value: 'info:no-requirements'
         });
       }
 
@@ -2924,6 +3693,8 @@ async function startInteractive() {
         items.push({ type: 'action', name: 'Initialize repository (.vibecodingmachine)', value: 'repo:init' });
       }
 
+      items.push({ type: 'action', name: 'View All Computers', value: 'computers:list' });
+      items.push({ type: 'action', name: 'Sync Now', value: 'sync:now' });
       items.push({ type: 'action', name: 'Logout', value: 'logout' });
       items.push({ type: 'action', name: 'Exit', value: 'exit' });
 
@@ -3313,13 +4084,13 @@ async function startInteractive() {
             const { maxChats } = await inquirer.prompt([{
               type: 'input',
               name: 'maxChats',
-              message: 'Max chats (leave empty for never stop):',
+              message: 'Max chats (0 for never stop):',
               default: defaultMaxChats
             }]);
 
             // Update config
             const newConfig = { ...currentConfig };
-            if (maxChats && maxChats.trim() !== '') {
+            if (maxChats && maxChats.trim() !== '' && maxChats.trim() !== '0') {
               newConfig.maxChats = parseInt(maxChats);
               newConfig.neverStop = false;
               console.log(chalk.green('\n✓'), `Stop condition updated: ${chalk.cyan(`Stop after ${newConfig.maxChats}`)}\n`);
@@ -3336,43 +4107,82 @@ async function startInteractive() {
           await showWelcomeScreen();
           break;
         }
-        case 'setting:restart-cli': {
-          // Toggle restart CLI setting
-          try {
-            const { getAutoConfig, setAutoConfig } = require('./config');
-            const currentConfig = await getAutoConfig();
-            const newConfig = { ...currentConfig, restartCLI: !currentConfig.restartCLI };
-            await setAutoConfig(newConfig);
-            const statusText = newConfig.restartCLI ? chalk.green('enabled') : chalk.yellow('disabled');
-            console.log(chalk.green('\n✓'), `Restart CLI after each completed requirement ${statusText}\n`);
-          } catch (error) {
-            console.log(chalk.red('\n✗ Error updating restart CLI setting:', error.message));
-          }
+        case 'setting:requirements': {
+          // Show tree-style requirements navigator
+          await showRequirementsTree();
           await showWelcomeScreen();
           break;
         }
-        case 'setting:setup-alias': {
-          const { setupAlias } = require('../commands/setup');
-          await setupAlias();
-          console.log(chalk.gray('\nPress Enter to return to menu...'));
-          const inquirer = require('inquirer');
-          await inquirer.prompt([{
-            type: 'input',
-            name: 'continue',
-            message: ''
-          }]);
+        case 'repo:init':
+          await repo.initRepo();
+          break;
+        
+        case 'computers:list': {
+          const computerCommands = require('../commands/computers');
+          await computerCommands.listComputers();
+          console.log(chalk.gray('\nPress Enter to continue...'));
+          await new Promise(resolve => {
+            const rl = readline.createInterface({
+              input: process.stdin,
+              output: process.stdout
+            });
+            rl.question('', () => {
+              rl.close();
+              resolve();
+            });
+          });
           await showWelcomeScreen();
           break;
         }
-        case 'setting:requirements': {
-          // Show tree-style requirements navigator
-          await showRequirementsTree();
+        
+        case 'sync:now': {
+          const syncCommands = require('../commands/sync');
+          await syncCommands.syncNow();
+          console.log(chalk.gray('\nPress Enter to continue...'));
+          await new Promise(resolve => {
+            const rl = readline.createInterface({
+              input: process.stdin,
+              output: process.stdout
+            });
+            rl.question('', () => {
+              rl.close();
+              resolve();
+            });
+          });
           await showWelcomeScreen();
           break;
         }
-        case 'repo:init':
-          await repo.initRepo();
+        
+        case 'setting:cloud-sync': {
+          await showCloudSyncMenu();
+          await showWelcomeScreen();
           break;
+        }
+        
+        case 'setting:cloud-sync-setup': {
+          console.clear();
+          console.log(chalk.bold.cyan('\n☁️  Cloud Sync Setup\n'));
+          console.log(chalk.yellow('Cloud sync is not configured yet.\n'));
+          console.log(chalk.white('To set up cloud sync:\n'));
+          console.log(chalk.gray('1. Run: ') + chalk.cyan('./scripts/setup-cloud-sync.sh'));
+          console.log(chalk.gray('2. Add AWS configuration to your .env file'));
+          console.log(chalk.gray('3. Register this computer with: ') + chalk.cyan('vcm computer:register "<focus>"'));
+          console.log(chalk.gray('\nFor more info, see: ') + chalk.cyan('docs/CLOUD_SYNC.md\n'));
+          
+          console.log(chalk.gray('Press Enter to continue...'));
+          await new Promise(resolve => {
+            const rl = readline.createInterface({
+              input: process.stdin,
+              output: process.stdout
+            });
+            rl.question('', () => {
+              rl.close();
+              resolve();
+            });
+          });
+          await showWelcomeScreen();
+          break;
+        }
         case 'auto:start': {
           const { ide, maxChats } = await inquirer.prompt([
             {
@@ -3393,12 +4203,12 @@ async function startInteractive() {
             {
               type: 'input',
               name: 'maxChats',
-              message: 'Max chats (leave empty for never stop):',
+              message: 'Max chats (0 for never stop):',
               default: ''
             }
           ]);
           const options = { ide };
-          if (maxChats) {
+          if (maxChats && maxChats.trim() !== '0') {
             options.maxChats = parseInt(maxChats);
           } else {
             options.neverStop = true;