vibecodingmachine-cli 2025.12.1-534 → 2025.12.22-2230

package/src/utils/interactive.js

@@ -8,7 +8,8 @@ const readline = require('readline');
 const repo = require('../commands/repo');
 const auto = require('../commands/auto');
 const status = require('../commands/status');
-const { getRepoPath, readConfig, writeConfig } = require('./config');
+const requirements = require('../commands/requirements');
+const { getRepoPath, readConfig, writeConfig, getAutoConfig } = require('./config');
 const { getProviderPreferences, saveProviderPreferences, getProviderDefinitions } = require('../utils/provider-registry');
 const { checkAutoModeStatus } = require('./auto-mode');
 const {
@@ -18,6 +19,7 @@ const {
   requirementsExists,
   isComputerNameEnabled
 } = require('vibecodingmachine-core');
+const pkg = require('../../package.json');
 
 /**
  * Format IDE name for display
@@ -32,7 +34,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 +55,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
@@ -210,95 +214,9 @@ function formatPath(fullPath) {
 
 async function countRequirements() {
   try {
-    const { getRequirementsPath, getVibeCodingMachineDir } = require('vibecodingmachine-core');
+    const { getProjectRequirementStats } = require('vibecodingmachine-core');
     const repoPath = await getRepoPath();
-    const reqPath = await getRequirementsPath(repoPath);
-
-    if (!reqPath || !await fs.pathExists(reqPath)) {
-      return null;
-    }
-
-    const content = await fs.readFile(reqPath, 'utf8');
-
-    // Count requirements in each section
-    let todoCount = 0;
-    let toVerifyCount = 0;
-    let verifiedCount = 0;
-
-    // Split by sections
-    const lines = content.split('\n');
-    let currentSection = '';
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      // Check for requirement headers first (###), then section headers (##)
-      // This prevents ### from being treated as section headers
-      if (trimmed.startsWith('###')) {
-        // Count requirements (### headers in new format)
-        // IMPORTANT: Only count if we're in a recognized section
-        if (currentSection) {
-          const requirementText = trimmed.replace(/^###\s*/, '').trim();
-          if (requirementText) { // Only count if requirement text is not empty
-            if (currentSection === 'todo') {
-              todoCount++;
-            } else if (currentSection === 'toverify') {
-              toVerifyCount++;
-            }
-          }
-        }
-      } else if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
-        // Detect section headers (must start with ## but not ###)
-        if (trimmed.includes('⏳ Requirements not yet completed') ||
-          trimmed.includes('Requirements not yet completed')) {
-          currentSection = 'todo';
-        } else if (trimmed.includes('🔍 TO VERIFY BY HUMAN') ||
-          trimmed.includes('TO VERIFY BY HUMAN') ||
-          trimmed.includes('🔍 TO VERIFY') ||
-          trimmed.includes('TO VERIFY') ||
-          trimmed.includes('✅ Verified by AI') ||
-          trimmed.includes('Verified by AI')) {
-          currentSection = 'toverify';
-        } else {
-          // Any other section header clears the current section
-          currentSection = '';
-        }
-      }
-    }
-
-    // Count verified requirements from CHANGELOG.md (at repository root)
-    const allnightDir = await getVibeCodingMachineDir();
-    if (allnightDir) {
-      // CHANGELOG.md is at the repository root
-      // If .vibecodingmachine is inside repo: go up one level
-      // If .vibecodingmachine is sibling (../.vibecodingmachine-reponame): go up one level then into repo
-      let changelogPath;
-      const allnightStatus = await require('vibecodingmachine-core').checkVibeCodingMachineExists();
-
-      if (allnightStatus.insideExists) {
-        // .vibecodingmachine is inside repo, so go up one level
-        changelogPath = path.join(path.dirname(allnightDir), 'CHANGELOG.md');
-      } else if (allnightStatus.siblingExists) {
-        // .vibecodingmachine is sibling, use current working directory
-        changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
-      }
-
-      if (changelogPath && await fs.pathExists(changelogPath)) {
-        const changelogContent = await fs.readFile(changelogPath, 'utf8');
-        // Count entries that look like completed requirements
-        // Each entry typically starts with "- " followed by date/description
-        const changelogLines = changelogContent.split('\n');
-        for (const line of changelogLines) {
-          const trimmed = line.trim();
-          // Count lines that start with "- " and have substantial content (not just empty bullets)
-          if (trimmed.startsWith('- ') && trimmed.length > 10) {
-            verifiedCount++;
-          }
-        }
-      }
-    }
-
-    return { todoCount, toVerifyCount, verifiedCount };
+    return await getProjectRequirementStats(repoPath);
   } catch (error) {
     return null;
   }
@@ -350,36 +268,27 @@ async function getCurrentProgress() {
 }
 
 async function showWelcomeScreen() {
+
+
   const repoPath = process.cwd(); // Always use current working directory
   const autoStatus = await checkAutoModeStatus();
-  const allnightStatus = await checkVibeCodingMachineExists();
   const hostname = getHostname();
-  const requirementsFilename = await getRequirementsFilename();
-  const useHostname = await isComputerNameEnabled();
 
   // Get current IDE from config
   const { getAutoConfig } = require('./config');
   const autoConfig = await getAutoConfig();
-  const currentIDE = autoConfig.ide || autoStatus.ide || 'claude-code';
 
   // Check for requirements file
   const hasRequirements = await requirementsExists();
-  let requirementsLocation = '';
-
-  if (allnightStatus.insideExists) {
-    requirementsLocation = '.vibecodingmachine';
-  } else if (allnightStatus.siblingExists) {
-    requirementsLocation = path.basename(allnightStatus.siblingDir);
-  }
 
   // Count requirements if file exists
   const counts = hasRequirements ? await countRequirements() : null;
 
-  // Clear the screen
+  // 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 pkg = require('../../package.json');
   const version = `v${pkg.version}`;
 
   // Display welcome banner with version
@@ -419,14 +328,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
         }
       ));
     }
@@ -475,7 +388,7 @@ async function showRequirementsTree() {
   };
 
   // Build tree structure
-  const buildTree = () => {
+  const buildTree = async () => {
     tree.items = [];
 
     // Root: Requirements
@@ -485,63 +398,72 @@ async function showRequirementsTree() {
       tree.items.push({ level: 1, type: 'add', label: '➕ Add new requirement', key: 'add-one' });
       tree.items.push({ level: 1, type: 'add', label: '➕ Add multiple requirements', key: 'add-many' });
 
-      // Calculate counts and percentages
+      // 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%)'
+      };
+
       const verifiedReqs = tree.verifiedReqs || [];
       const verifyReqs = tree.verifyReqs || [];
       const clarificationReqs = tree.clarificationReqs || [];
       const todoReqs = tree.todoReqs || [];
       const recycledReqs = tree.recycledReqs || [];
-      const total = verifiedReqs.length + verifyReqs.length + clarificationReqs.length + todoReqs.length + recycledReqs.length;
-
-      const verifiedPercent = total > 0 ? Math.round((verifiedReqs.length / total) * 100) : 0;
-      const verifyPercent = total > 0 ? Math.round((verifyReqs.length / total) * 100) : 0;
-      const clarificationPercent = total > 0 ? Math.round((clarificationReqs.length / total) * 100) : 0;
-      const todoPercent = total > 0 ? Math.round((todoReqs.length / total) * 100) : 0;
-      const recycledPercent = total > 0 ? Math.round((recycledReqs.length / total) * 100) : 0;
 
-      // VERIFIED section (first)
-      tree.items.push({ level: 1, type: 'section', label: `🎉 VERIFIED (${verifiedReqs.length} - ${verifiedPercent}%)`, key: 'verified' });
+      // VERIFIED section (first) - only show if has requirements
+      if (verifiedReqs.length > 0 || verifiedCount > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `🎉 ${verifiedLabel}`, 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 || toVerifyCount > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `✅ ${toVerifyLabel}`, 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 || todoCount > 0) {
+        tree.items.push({ level: 1, type: 'section', label: `⏳ ${todoLabel}`, 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,27 +485,96 @@ 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
+          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
+
+          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;
+        let pkg = null;
 
         // Read package and description
         for (let j = i + 1; j < lines.length; j++) {
@@ -594,18 +585,29 @@ async function showRequirementsTree() {
           }
           // Check for PACKAGE line
           if (nextLine.startsWith('PACKAGE:')) {
-            package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+            pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
           } else if (nextLine && !nextLine.startsWith('PACKAGE:')) {
             // Description line
             details.push(nextLine);
           }
         }
 
-        requirements.push({ title, details, package, lineIndex: i });
+        requirements.push({ title, details, pkg, lineIndex: i });
       }
     }
 
-    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
@@ -721,7 +723,7 @@ async function showRequirementsTree() {
   tree.recycledReqs = await loadSection('recycled', '♻️ Recycled');
 
   let inTree = true;
-  buildTree();
+  await buildTree();
 
   while (inTree) {
     console.clear();
@@ -828,7 +830,7 @@ async function showRequirementsTree() {
       if (tree.expanded[current.key]) {
         // Collapse expanded section
         tree.expanded[current.key] = false;
-        buildTree();
+        await buildTree();
       } else if (current.level > 0) {
         // Go to parent
         for (let i = tree.selected - 1; i >= 0; i--) {
@@ -841,10 +843,12 @@ async function showRequirementsTree() {
         // At root level, go back to main menu
         inTree = false;
       }
-    } else if (key.name === 'up') {
+    } else if (key.name === 'k' || key.name === 'up') {
       tree.selected = Math.max(0, tree.selected - 1);
-    } else if (key.name === 'down') {
+      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
@@ -861,19 +865,19 @@ async function showRequirementsTree() {
           } else if (current.key === 'recycled') {
             tree.recycledReqs = await loadSection(current.key, current.section);
           }
-          buildTree();
+          await buildTree();
         } else {
           tree.expanded[current.key] = false;
-          buildTree();
+          await buildTree();
         }
       } else if (current.type === 'requirement') {
         // Show requirement actions
         await showRequirementActions(current.req, current.sectionKey, tree);
-        buildTree();
+        await buildTree();
       } else if (current.type === 'clarification') {
         // Show clarification requirement with questions
         await showClarificationActions(current.req, tree, loadClarification);
-        buildTree();
+        await buildTree();
       } else if (current.type === 'verified') {
         // Show verified item details (read-only)
         console.clear();
@@ -900,7 +904,7 @@ async function showRequirementsTree() {
         await handleAddRequirement(current.key);
         // Reload TODO section
         tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
-        buildTree();
+        await buildTree();
       }
     } else if (key.name === 'r') {
       const current = tree.items[tree.selected];
@@ -908,15 +912,21 @@ async function showRequirementsTree() {
 
       if (current.type === 'requirement') {
         await deleteRequirement(current.req, current.sectionKey, tree);
-        buildTree();
+        // 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();
-        buildTree();
+        await 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();
+        await buildTree();
       }
     } else if (key.name === 'j') {
       const current = tree.items[tree.selected];
@@ -924,7 +934,7 @@ async function showRequirementsTree() {
 
       if (current.type === 'requirement') {
         await moveRequirementDown(current.req, current.sectionKey, tree);
-        buildTree();
+        await buildTree();
         // Move selection down to follow the item
         if (tree.selected < tree.items.length - 1) {
           tree.selected++;
@@ -936,7 +946,7 @@ async function showRequirementsTree() {
 
       if (current.type === 'requirement') {
         await moveRequirementUp(current.req, current.sectionKey, tree);
-        buildTree();
+        await buildTree();
         // Move selection up to follow the item
         if (tree.selected > 0) {
           tree.selected--;
@@ -948,7 +958,7 @@ async function showRequirementsTree() {
 
       if (current.type === 'requirement') {
         await promoteRequirement(current.req, current.sectionKey, tree, loadSection, loadVerified);
-        buildTree();
+        await buildTree();
       }
     } else if (key.name === 'd') {
       const current = tree.items[tree.selected];
@@ -959,12 +969,12 @@ async function showRequirementsTree() {
         await moveClarificationToTodo(current.req, tree);
         tree.clarificationReqs = await loadClarification();
         tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
-        buildTree();
+        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);
-        buildTree();
+        await buildTree();
       }
     }
   }
@@ -1404,8 +1414,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 +1488,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 +1549,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 +1718,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 === 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');
@@ -1573,7 +1786,7 @@ async function moveRequirementToRecycled(reqPath, requirementTitle, fromSection)
     const line = lines[i].trim();
     if (line.startsWith('###')) {
       const title = line.replace(/^###\s*/, '').trim();
-      if (title && title.includes(requirementTitle)) {
+      if (title && title === requirementTitle) {
         requirementStartIndex = i;
         // Find the end of this requirement (next ### or ## header)
         for (let j = i + 1; j < lines.length; j++) {
@@ -1600,8 +1813,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 +1933,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 +1997,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;
 
-          if (line.trim() === '') {
-            emptyLineCount++;
-            if (emptyLineCount >= 2) {
-              break; // Two empty lines = done
+          // 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;
             }
-          } 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
     }
@@ -1826,7 +2107,7 @@ async function handleAddRequirement(type) {
       while (!done) {
         try {
           // Ask for package
-          const { package } = await inquirer.prompt([{
+          const { package: pkg } = await inquirer.prompt([{
             type: 'list',
             name: 'package',
             message: `Package for requirement ${requirements.length + 1}:`,
@@ -1875,7 +2156,7 @@ async function handleAddRequirement(type) {
             }
 
             const description = descriptionLines.join('\n');
-            requirements.push({ name, package, description });
+            requirements.push({ name, package: pkg, description });
           }
         } catch (err) {
           done = true;
@@ -1986,6 +2267,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 +2308,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',
@@ -2162,7 +2453,6 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
     if (selectedIndex >= items.length) selectedIndex = 0;
 
     let isFirstRender = true;
-    let lastLinesPrinted = 0;
 
     // Helper to calculate visual lines occupied by text
     const getVisualLineCount = (text) => {
@@ -2187,12 +2477,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 +2592,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
@@ -2342,21 +2638,27 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
 
       // Arrow keys for navigation
       if (key.name === 'up') {
-        // Skip blank and info lines when navigating
-        let newIndex = selectedIndex > 0 ? selectedIndex - 1 : items.length - 1;
-        while ((items[newIndex].type === 'blank' || items[newIndex].type === 'info') && newIndex !== selectedIndex) {
-          newIndex = newIndex > 0 ? newIndex - 1 : items.length - 1;
+        // 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--;
         }
-        selectedIndex = newIndex;
-        displayMenu();
       } else if (key.name === 'down') {
-        // Skip blank and info lines when navigating
-        let newIndex = selectedIndex < items.length - 1 ? selectedIndex + 1 : 0;
-        while ((items[newIndex].type === 'blank' || items[newIndex].type === 'info') && newIndex !== selectedIndex) {
-          newIndex = newIndex < items.length - 1 ? newIndex + 1 : 0;
+        // 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++;
         }
-        selectedIndex = newIndex;
-        displayMenu();
       } else if (key.name === 'return' || key.name === 'right') {
         // Don't allow selecting blank or info lines
         if (items[selectedIndex].type !== 'blank' && items[selectedIndex].type !== 'info') {
@@ -2379,44 +2681,129 @@ async function showProviderManagerMenu() {
   let selectedIndex = 0;
   let dirty = false;
 
-  // Initialize ProviderManager to check rate limits
-  const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
-  const providerManager = new ProviderManager();
+  const { fetchQuotaForAgent } = require('vibecodingmachine-core/src/quota-management');
+
+  const debugQuota = process.env.VCM_DEBUG_QUOTA === '1' || process.env.VCM_DEBUG_QUOTA === 'true';
 
-  const render = () => {
+  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('⚙ Provider Order & Availability\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('  Overall Quota: ') + chalk.red(`⏰ Rate limit resets in ${hoursUntilReset}h ${minsUntilReset}m`);
+    } else {
+      // Quota available - show when it resets (in green)
+      quotaDisplay = chalk.gray('  Overall Quota: ') + chalk.green(`✓ Available (${remaining}/${quotaInfo.maxIterations})`) + chalk.gray(' • Resets in ') + chalk.cyan(`${hoursUntilReset}h ${minsUntilReset}m`);
+    }
+    console.log(quotaDisplay);
     console.log(chalk.gray('  ↑/↓ move selection    j/k reorder    e enable    d disable    Space toggle    Enter save/select    Esc cancel\n'));
 
-    order.forEach((id, idx) => {
+    for (let idx = 0; idx < order.length; idx++) {
+      const id = order[idx];
       const def = defMap.get(id);
-      if (!def) return;
+      if (!def) continue;
       const isSelected = idx === selectedIndex;
       const isEnabled = enabled[id] !== false;
-      const statusLabel = isEnabled ? chalk.green('ENABLED') : chalk.red('DISABLED');
+
+      // 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} ${idx + 1}. ${def.name} ${chalk.gray(`(${def.id})`)}  ${typeLabel}  ${statusLabel}`;
-
-      // Check for rate limits
-      const timeUntilReset = providerManager.getTimeUntilReset(id, def.model || id);
-      if (timeUntilReset) {
-        const resetTime = Date.now() + timeUntilReset;
-        const resetDate = new Date(resetTime);
-        const timeStr = resetDate.toLocaleString('en-US', {
-          weekday: 'short',
-          month: 'short',
-          day: 'numeric',
-          hour: 'numeric',
-          minute: '2-digit',
-          hour12: true,
-          timeZoneName: 'short'
-        });
-        line += ` ${chalk.red('⏰ Rate limited until ' + timeStr)}`;
+      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('[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(`[✓ available • resets in ${formatDuration(msUntilReset)}]`)}`;
+            } else {
+              line += ` ${chalk.green('[Available]')}`;
+            }
+          }
+        }
+      } catch (e) {
+        // Silently skip if quota fetch fails
       }
 
       console.log(line);
-    });
+    }
 
     console.log();
     if (dirty) {
@@ -2426,7 +2813,12 @@ async function showProviderManagerMenu() {
     }
   };
 
-  return new Promise((resolve) => {
+  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);
@@ -2441,6 +2833,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);
@@ -2457,15 +2861,15 @@ async function showProviderManagerMenu() {
       resolve(null);
     };
 
-    const moveSelection = (delta) => {
+    const moveSelection = async (delta) => {
       const next = selectedIndex + delta;
       if (next >= 0 && next < order.length) {
         selectedIndex = next;
-        render();
+        await render();
       }
     };
 
-    const reorder = (delta) => {
+    const reorder = async (delta) => {
       const target = selectedIndex + delta;
       if (target < 0 || target >= order.length) return;
       const temp = order[selectedIndex];
@@ -2473,17 +2877,17 @@ async function showProviderManagerMenu() {
       order[target] = temp;
       selectedIndex = target;
       dirty = true;
-      render();
+      await render();
     };
 
-    const toggle = (value) => {
+    const toggle = async (value) => {
       const id = order[selectedIndex];
       enabled[id] = value;
       dirty = true;
-      render();
+      await render();
     };
 
-    const onKeypress = (str, key = {}) => {
+    const onKeypress = async (str, key = {}) => {
       if (key.ctrl && key.name === 'c') {
         cancel();
         return;
@@ -2491,30 +2895,31 @@ async function showProviderManagerMenu() {
 
       switch (key.name) {
         case 'up':
-          moveSelection(-1);
+          await moveSelection(-1);
           break;
         case 'down':
-          moveSelection(1);
+          await moveSelection(1);
           break;
         case 'j':
-          reorder(1);
+          await reorder(1);
           break;
         case 'k':
-          reorder(-1);
+          await reorder(-1);
           break;
         case 'e':
-          toggle(true);
+          await toggle(true);
           break;
         case 'd':
-          toggle(false);
+          await toggle(false);
           break;
         case 'space':
-          toggle(!(enabled[order[selectedIndex]] !== false));
+          await toggle(!(enabled[order[selectedIndex]] !== false));
           break;
         case 'return':
           saveAndExit(order[selectedIndex]);
           break;
         case 'escape':
+        case 'left':
         case 'x':
           cancel();
           break;
@@ -2530,11 +2935,11 @@ async function showProviderManagerMenu() {
     process.stdin.on('keypress', onKeypress);
     process.stdin.resume();
 
-    render();
+    await render();
   });
 }
 
-async function showSettings() {
+/* async function showSettings() {
   console.log(chalk.bold.cyan('\n⚙️  Settings\n'));
 
   const { setConfigValue } = require('vibecodingmachine-core');
@@ -2620,6 +3025,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';
@@ -2660,6 +3335,11 @@ async function startInteractive() {
 
   await showWelcomeScreen();
 
+  if (process.env.VCM_OPEN_PROVIDER_MENU === '1' || process.env.VCM_OPEN_PROVIDER_MENU === 'true') {
+    await showProviderManagerMenu();
+    return;
+  }
+
   let exit = false;
   let lastSelectedIndex = 0; // Track last selected menu item
   while (!exit) {
@@ -2679,12 +3359,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 +3389,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 +3447,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 +3468,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 +3508,57 @@ 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'
       });
 
+      // Add Stages configuration
+      const { getStages } = require('./config');
+      const configuredStages = await getStages();
+      const stagesCount = configuredStages.length;
+      items.push({
+        type: 'setting',
+        name: `  └─ Configure Stages: ${chalk.cyan(stagesCount + ' stages')}`,
+        value: 'setting:stages'
+      });
+
+      // 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 +3605,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 +3643,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' });
 
@@ -2968,7 +3689,6 @@ async function startInteractive() {
               const path = require('path');
               const os = require('os');
               const yaml = require('js-yaml');
-              const { spawn } = require('child_process');
               const configPath = path.join(os.homedir(), '.continue', 'config.yaml');
 
               if (fs.existsSync(configPath)) {
@@ -3159,6 +3879,53 @@ async function startInteractive() {
           await showWelcomeScreen();
           break;
         }
+        case 'setting:stages': {
+          // Configure stages
+          const { getStages, setStages, DEFAULT_STAGES } = require('./config');
+          const inquirer = require('inquirer');
+
+          const currentStages = await getStages();
+
+          console.log(chalk.cyan('\n🔨 Configure Workflow Stages\n'));
+          console.log(chalk.gray('Select the stages you want to include in the auto-mode workflow.'));
+          console.log(chalk.gray('Stages will be executed in the order shown.\n'));
+
+          const { selectedStages } = await inquirer.prompt([
+            {
+              type: 'checkbox',
+              name: 'selectedStages',
+              message: 'Select stages:',
+              choices: DEFAULT_STAGES.map(stage => ({
+                name: stage,
+                checked: currentStages.includes(stage)
+              })),
+              validate: (answer) => {
+                if (answer.length < 1) {
+                  return 'You must select at least one stage.';
+                }
+                return true;
+              },
+              loop: false,
+              pageSize: 15
+            }
+          ]);
+
+          // Preserve order from DEFAULT_STAGES for selected items
+          // This ensures stages always run in the correct logical order
+          const newStages = DEFAULT_STAGES.filter(stage => selectedStages.includes(stage));
+
+          await setStages(newStages);
+          console.log(chalk.green('\n✓'), `Stages configuration updated: ${newStages.join(' → ')}\n`);
+
+          const { continue: _ } = await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to return to menu...'
+          }]);
+
+          await showWelcomeScreen();
+          break;
+        }
         case 'setting:auto-start': {
           try {
             console.log(chalk.bold.cyan('\n🚀 Starting Auto Mode...\n'));
@@ -3313,13 +4080,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 +4103,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 +4199,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;