vibecodingmachine-cli 2025.12.25-25 → 2026.1.22-1441

package/src/utils/interactive.js

@@ -5,11 +5,12 @@ const path = require('path');
 const os = require('os');
 const fs = require('fs-extra');
 const readline = require('readline');
+const { execSync } = require('child_process');
 const repo = require('../commands/repo');
 const auto = require('../commands/auto');
 const status = require('../commands/status');
 const requirements = require('../commands/requirements');
-const { getRepoPath, readConfig, writeConfig, getAutoConfig } = require('./config');
+const { getRepoPath, readConfig, writeConfig, getAutoConfig, getProviderCache, setProviderCache } = require('./config');
 const { getProviderPreferences, saveProviderPreferences, getProviderDefinitions } = require('../utils/provider-registry');
 const { checkAutoModeStatus } = require('./auto-mode');
 const {
@@ -20,14 +21,127 @@ const {
   isComputerNameEnabled,
   t,
   detectLocale,
-  setLocale
+  setLocale,
+  AppleScriptManager,
+  IDEHealthTracker,
+  HealthReporter
 } = require('vibecodingmachine-core');
+const { promptWithDefaultsOnce } = require('./prompt-helper');
+const { formatResetsAtLabel } = require('./date-formatter');
 
 // Initialize locale detection for interactive mode
 const detectedLocale = detectLocale();
 setLocale(detectedLocale);
 const pkg = require('../../package.json');
 
+const { exec } = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(exec);
+
+async function checkVSCodeExtension(extensionId) {
+  // Check if a VS Code extension is installed
+  try {
+    const { stdout } = await execAsync('code --list-extensions', { timeout: 5000 });
+    const extensions = stdout.toLowerCase().split('\n').map(e => e.trim());
+
+    // Map common extension IDs to their actual extension IDs
+    const extensionMap = {
+      'github-copilot': 'github.copilot',
+      'amazon-q': 'amazonwebservices.amazon-q-vscode'
+    };
+
+    const actualExtensionId = extensionMap[extensionId] || extensionId;
+    return extensions.includes(actualExtensionId.toLowerCase());
+  } catch (error) {
+    // If code CLI is not available or command fails, return false
+    return false;
+  }
+}
+
+async function checkAppOrBinary(names = [], binaries = []) {
+  // names: app bundle base names (e.g., 'Cursor' -> /Applications/Cursor.app)
+  // binaries: CLI binary names to check on PATH (e.g., 'code')
+  const platform = os.platform();
+  // Check common application directories
+  if (platform === 'darwin') {
+    const appDirs = ['/Applications', path.join(os.homedir(), 'Applications')];
+    for (const appName of names) {
+      for (const dir of appDirs) {
+        try {
+          const p = path.join(dir, `${appName}.app`);
+          if (await fs.pathExists(p)) {
+            // Ensure this is a real application bundle (has Contents/MacOS executable)
+            try {
+              const macosDir = path.join(p, 'Contents', 'MacOS');
+              const exists = await fs.pathExists(macosDir);
+              if (exists) {
+                const files = await fs.readdir(macosDir);
+                if (files && files.length > 0) {
+                  // Prefer to ensure the app is usable: use spctl to assess, fallback to quarantine xattr
+                  try {
+                    // spctl returns non-zero on rejected/invalid apps
+                    // Use async exec to avoid blocking the event loop
+                    await execAsync(`spctl --assess -v "${p}"`, { timeout: 5000 });
+
+                    // additionally validate codesign quickly (timeout to avoid hangs)
+                    try {
+                      await execAsync(`codesign -v --deep --strict "${p}"`, { timeout: 5000 });
+                      return true;
+                    } catch (csErr) {
+                      // codesign failed or timed out — treat as not usable/damaged
+                      return false;
+                    }
+                  } catch (e) {
+                    // spctl failed or timed out — check if app has quarantine attribute
+                    try {
+                      const { stdout } = await execAsync(`xattr -p com.apple.quarantine "${p}" 2>/dev/null || true`, { encoding: 'utf8' });
+                      const out = stdout.trim();
+                      if (!out) {
+                        // no quarantine attribute but spctl failed — be conservative and treat as not installed
+                        return false;
+                      }
+                      // If quarantine attribute exists, treat as not installed (damaged/not allowed)
+                      return false;
+                    } catch (e2) {
+                      return false;
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              // if we can't stat inside, be conservative and continue searching
+            }
+          }
+        } catch (e) {
+          /* ignore */
+        }
+      }
+    }
+  }
+
+  // Check PATH for known binaries
+  for (const bin of binaries) {
+    try {
+      await execAsync(`which ${bin}`, { timeout: 2000 });
+      return true;
+    } catch (e) {
+      /* not found */
+    }
+  }
+
+  // Check common Homebrew bin locations
+  const brewPaths = ['/opt/homebrew/bin', '/usr/local/bin'];
+  for (const bin of binaries) {
+    for (const brew of brewPaths) {
+      try {
+        if (await fs.pathExists(path.join(brew, bin))) return true;
+      } catch (e) { /* ignore */ }
+    }
+  }
+
+  return false;
+}
+
 /**
  * Translate workflow stage names
  */
@@ -248,6 +362,39 @@ async function countRequirements() {
   }
 }
 
+async function getSyncStatus() {
+  try {
+    const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+    const syncEngine = new SyncEngine();
+    await syncEngine.initialize();
+    const status = syncEngine.getStatus();
+    syncEngine.stop();
+
+    if (!status.isOnline && status.queuedChanges > 0) {
+      return `[Offline: ${status.queuedChanges} queued]`;
+    } else if (!status.isOnline) {
+      return '[Offline]';
+    } else if (status.isSyncing) {
+      return '[Syncing...]';
+    } else if (status.lastSyncTime) {
+      const timeSinceSync = Date.now() - status.lastSyncTime;
+      const minutesAgo = Math.floor(timeSinceSync / (1000 * 60));
+      if (minutesAgo < 1) {
+        return '[Sync: ✓ just now]';
+      } else if (minutesAgo < 60) {
+        return `[Sync: ✓ ${minutesAgo}m ago]`;
+      } else {
+        const hoursAgo = Math.floor(minutesAgo / 60);
+        return `[Sync: ✓ ${hoursAgo}h ago]`;
+      }
+    } else {
+      return '[Never synced]';
+    }
+  } catch (error) {
+    return '[Sync unavailable]';
+  }
+}
+
 async function getCurrentProgress() {
   try {
     const { getRequirementsPath } = require('vibecodingmachine-core');
@@ -319,7 +466,7 @@ async function showWelcomeScreen() {
 
   // Display welcome banner with version
   console.log('\n' + boxen(
-    chalk.bold.cyan('Vibe Coding Machine') + '\n' +
+    chalk.bold.cyan('Vibe Coding Machine!') + '\n' +
     chalk.gray(version) + '\n' +
     chalk.gray(t('banner.tagline')),
     {
@@ -330,9 +477,28 @@ async function showWelcomeScreen() {
     }
   ));
 
+  // Display feedback hint at the top of every screen
+  console.log(chalk.gray('💡 Press F for feedback - Share your thoughts anytime'));
+
   // Display repository and system info
   console.log();
   console.log(chalk.gray(t('system.repo').padEnd(25)), formatPath(repoPath));
+
+  // Display git branch if in a git repo
+  try {
+    const { isGitRepo, getCurrentBranch, hasUncommittedChanges } = require('vibecodingmachine-core');
+    if (isGitRepo(repoPath)) {
+      const branch = getCurrentBranch(repoPath);
+      if (branch) {
+        const isDirty = hasUncommittedChanges(repoPath);
+        const branchDisplay = isDirty ? `${chalk.cyan(branch)} ${chalk.yellow(t('system.git.status.dirty'))}` : chalk.cyan(branch);
+        console.log(chalk.gray(t('system.git.branch').padEnd(25)), branchDisplay);
+      }
+    }
+  } catch (error) {
+    // Ignore git display errors
+  }
+
   console.log(chalk.gray(t('system.computer.name').padEnd(25)), chalk.cyan(hostname));
 
   // Display auto mode progress if running
@@ -402,10 +568,14 @@ function indexToLetter(index) {
   return String.fromCharCode(97 + index); // 97 is 'a'
 }
 
+// Parse requirements from file content for a given section (supports ###, PACKAGE:, and '- ' bullets)
+const { parseRequirementsFromContent } = require('./requirements-parser');
+
 // Tree-style requirements navigator
 async function showRequirementsTree() {
   console.log(chalk.bold.cyan('\n📋 ' + t('requirements.navigator.title') + '\n'));
   console.log(chalk.gray(t('requirements.navigator.basic.instructions') + '\n'));
+  console.log(chalk.gray('💡 Press F for feedback - Share your thoughts anytime\n'));
 
   const tree = {
     expanded: { root: true },
@@ -432,16 +602,16 @@ async function showRequirementsTree() {
       };
 
       // Create localized labels
-      const localizedTodoLabel = todoCount > 0 ? 
-        `⏳ ${t('requirements.section.todo')} (${todoCount} - ${Math.round((todoCount / total) * 100)}%)` : 
+      const localizedTodoLabel = todoCount > 0 ?
+        `⏳ ${t('requirements.section.todo')} (${todoCount} - ${Math.round((todoCount / total) * 100)}%)` :
         `⏳ ${t('requirements.section.todo')} (0 - 0%)`;
-      
-      const localizedToVerifyLabel = toVerifyCount > 0 ? 
-        `✅ ${t('requirements.section.to.verify')} (${toVerifyCount} - ${Math.round((toVerifyCount / total) * 100)}%)` : 
+
+      const localizedToVerifyLabel = toVerifyCount > 0 ?
+        `✅ ${t('requirements.section.to.verify')} (${toVerifyCount} - ${Math.round((toVerifyCount / total) * 100)}%)` :
         `✅ ${t('requirements.section.to.verify')} (0 - 0%)`;
-      
-      const localizedVerifiedLabel = verifiedCount > 0 ? 
-        `🎉 ${t('requirements.section.verified')} (${verifiedCount} - ${Math.round((verifiedCount / total) * 100)}%)` : 
+
+      const localizedVerifiedLabel = verifiedCount > 0 ?
+        `🎉 ${t('requirements.section.verified')} (${verifiedCount} - ${Math.round((verifiedCount / total) * 100)}%)` :
         `🎉 ${t('requirements.section.verified')} (0 - 0%)`;
 
       const verifiedReqs = tree.verifiedReqs || [];
@@ -450,6 +620,10 @@ async function showRequirementsTree() {
       const todoReqs = tree.todoReqs || [];
       const recycledReqs = tree.recycledReqs || [];
 
+      // Calculate percentages for clarification and recycled sections
+      const clarificationPercent = total > 0 ? Math.round((clarificationReqs.length / total) * 100) : 0;
+      const recycledPercent = total > 0 ? Math.round((recycledReqs.length / total) * 100) : 0;
+
       // VERIFIED section (first) - only show if has requirements
       if (verifiedReqs.length > 0 || verifiedCount > 0) {
         tree.items.push({ level: 1, type: 'section', label: localizedVerifiedLabel, key: 'verified' });
@@ -517,136 +691,14 @@ async function showRequirementsTree() {
     }
 
     const content = await fs.readFile(reqPath, 'utf8');
-    const lines = content.split('\n');
-
-    let inSection = false;
-    const requirements = [];
-
-    // For TO VERIFY section, check multiple possible section titles
-    const sectionTitles = sectionKey === 'verify'
-      ? ['🔍 TO VERIFY BY HUMAN', 'TO VERIFY BY HUMAN', '🔍 TO VERIFY', 'TO VERIFY', '✅ Verified by AI screenshot', 'Verified by AI screenshot', 'Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG']
-      : [sectionTitle];
-
-    // For TO VERIFY, we need to find the exact section header
-    // The section header is: ## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG
-    const toVerifySectionHeader = '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG';
 
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-
-      // Check if this line matches any of the section titles
-      // IMPORTANT: Only check section headers (lines starting with ##), not requirement text
-      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
-        // Reset inSection if we hit a section header that's not our target section
-        if (sectionKey === 'verify' && inSection) {
-          // Check if this is still a TO VERIFY section header
-          if (!isStillToVerify) {
-            // This will be handled by the "leaving section" check below, but ensure we don't process it as entering
-          }
-        }
-        if (sectionKey === 'verify') {
-          // For TO VERIFY, check for the specific section header with exact matching
-          // Must match the exact TO VERIFY section header, not just any line containing "TO VERIFY"
-          const isToVerifyHeader = trimmed === '## 🔍 TO VERIFY BY HUMAN' ||
-            trimmed.startsWith('## 🔍 TO VERIFY BY HUMAN') ||
-            trimmed === '## 🔍 TO VERIFY' ||
-            trimmed.startsWith('## 🔍 TO VERIFY') ||
-            trimmed === '## TO VERIFY' ||
-            trimmed.startsWith('## TO VERIFY') ||
-            trimmed === '## ✅ TO VERIFY' ||
-            trimmed.startsWith('## ✅ TO VERIFY') ||
-            trimmed === toVerifySectionHeader ||
-            (trimmed.startsWith(toVerifySectionHeader) && trimmed.includes('Needs Human to Verify'));
-
-          if (isToVerifyHeader) {
-            // Make sure it's not a VERIFIED section (without TO VERIFY)
-            if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
-              inSection = true;
-              continue;
-            }
-          } else {
-            // If we hit a different section header and we're looking for TO VERIFY, make sure we're not in section
-            // This prevents incorrectly reading from TODO or other sections
-            if (trimmed.includes('⏳ Requirements not yet completed') ||
-              trimmed.includes('Requirements not yet completed') ||
-              trimmed === '## 📝 VERIFIED' ||
-              trimmed.startsWith('## 📝 VERIFIED')) {
-              // We're in TODO or VERIFIED section, not TO VERIFY - reset
-              inSection = false;
-            }
-          }
-        } else if (sectionTitles.some(title => trimmed.includes(title))) {
-          inSection = true;
-          continue;
-        }
-      }
-
-      // Check if we're leaving the section (new section header that doesn't match)
-      if (inSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
-        // If this is a new section header and it's not one of our section titles, we've left the section
-        if (sectionKey === 'verify') {
-          // For TO VERIFY, only break if this is clearly a different section
-          // Check for specific section headers that indicate we've left TO VERIFY
-
-          if (isVerifiedSection || isTodoSection || isRecycledSection || isClarificationSection) {
-            break; // Different section, we've left TO VERIFY
-          }
-          // Otherwise, continue - might be REJECTED or CHANGELOG which are not section boundaries for TO VERIFY
-        } else {
-          // For other sections, break if it's a new section header that doesn't match
-          if (!sectionTitles.some(title => trimmed.includes(title))) {
-            break;
-          }
-        }
-      }
-
-      // Read requirements in new format (### header)
-      if (inSection && line.trim().startsWith('###')) {
-        const title = line.trim().replace(/^###\s*/, '').trim();
-
-        // Skip malformed requirements (title is just a package name, empty, or too short)
-        // Common package names that shouldn't be requirement titles
-        const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
-        if (!title || title.length === 0 || packageNames.includes(title.toLowerCase())) {
-          continue; // Skip this malformed requirement
-        }
-
-        const details = [];
-        let pkg = null;
-
-        // Read package and description
-        for (let j = i + 1; j < lines.length; j++) {
-          const nextLine = lines[j].trim();
-          // Stop if we hit another requirement or section
-          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
-            break;
-          }
-          // Check for PACKAGE line
-          if (nextLine.startsWith('PACKAGE:')) {
-            pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
-          } else if (nextLine && !nextLine.startsWith('PACKAGE:')) {
-            // Description line
-            details.push(nextLine);
-          }
-        }
-
-        requirements.push({ title, details, pkg, lineIndex: i });
-      }
-    }
+    // Delegate to reusable parser
+    const allReqs = parseRequirementsFromContent(content, sectionKey, sectionTitle);
 
-    // 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);
-      }
-    }
+    // For TODO section, only show primary heading requirements (those marked from '###' titles)
+    if (sectionKey === 'todo') return allReqs.filter(r => r.source === 'heading');
 
-    return uniqueRequirements;
+    return allReqs;
   };
 
   // Load VERIFIED requirements from CHANGELOG
@@ -708,49 +760,99 @@ async function showRequirementsTree() {
 
     let inSection = false;
     const requirements = [];
-    let currentReq = null;
 
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
+      const trimmed = line.trim();
 
-      if (line.includes('❓ Requirements needing manual feedback')) {
+      // Check if we're entering the clarification section
+      if (trimmed.includes('❓ Requirements needing manual feedback')) {
         inSection = true;
         continue;
       }
 
-      if (inSection && line.startsWith('##') && !line.includes('❓ Requirements needing manual feedback')) {
-        if (currentReq) requirements.push(currentReq);
+      // Check if we're leaving the section (hit another ## section)
+      if (inSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
         break;
       }
 
-      if (inSection && line.trim().startsWith('- ')) {
-        if (currentReq) requirements.push(currentReq);
-
-        const title = line.trim().substring(2);
-        currentReq = { title, questions: [], findings: null, lineIndex: i };
-      } else if (inSection && currentReq && line.trim()) {
-        // Check for AI findings section
-        if (line.trim().startsWith('**AI found in codebase:**')) {
-          continue; // Skip the header, capture next line as findings
-        } else if (!currentReq.findings && !line.trim().startsWith('**Clarifying questions:**') && !line.trim().match(/^\d+\./)) {
-          // This is the findings content (comes after "AI found in codebase:")
-          currentReq.findings = line.trim();
-        } else if (line.trim().startsWith('**Clarifying questions:**')) {
-          continue; // Skip the questions header
-        } else if (line.trim().match(/^\d+\./)) {
-          // This is a question
-          currentReq.questions.push({ question: line.trim(), response: null });
-        } else if (currentReq.questions.length > 0) {
-          // This might be a response to the last question
-          const lastQuestion = currentReq.questions[currentReq.questions.length - 1];
-          if (!lastQuestion.response) {
-            lastQuestion.response = line.trim();
+      // Read requirements in new format (### header)
+      if (inSection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+
+        // Skip empty titles
+        if (!title || title.length === 0) {
+          continue;
+        }
+
+        const details = [];
+        const questions = [];
+        let pkg = null;
+        let findings = null;
+        let currentQuestion = null;
+
+        // Read package, description, and clarifying questions
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+
+          // Stop if we hit another requirement or section
+          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+            break;
+          }
+
+          // Check for PACKAGE line
+          if (nextLine.startsWith('PACKAGE:')) {
+            pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+          }
+          // Check for AI findings
+          else if (nextLine.startsWith('**AI found in codebase:**')) {
+            // Next line will be the findings
+            continue;
+          }
+          else if (nextLine.startsWith('**What went wrong')) {
+            // Description line
+            details.push(nextLine);
+          }
+          else if (nextLine.startsWith('**Clarifying questions:**')) {
+            // Start of questions section
+            continue;
+          }
+          else if (nextLine.match(/^\d+\./)) {
+            // Save previous question if exists
+            if (currentQuestion) {
+              questions.push(currentQuestion);
+            }
+            // This is a new question
+            currentQuestion = { question: nextLine, response: null };
+          }
+          else if (currentQuestion && nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+            // This might be a response to the current question or description/findings
+            if (!findings && !currentQuestion.response && questions.length === 0 && !nextLine.match(/^\d+\./)) {
+              // This is findings content
+              findings = nextLine;
+            } else if (currentQuestion && !currentQuestion.response) {
+              // This is a response to the current question
+              currentQuestion.response = nextLine;
+            } else {
+              // Description line
+              details.push(nextLine);
+            }
+          }
+          else if (nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+            // Description line
+            details.push(nextLine);
           }
         }
+
+        // Save last question if exists
+        if (currentQuestion) {
+          questions.push(currentQuestion);
+        }
+
+        requirements.push({ title, details, pkg, questions, findings, lineIndex: i });
       }
     }
 
-    if (currentReq) requirements.push(currentReq);
     return requirements;
   };
 
@@ -945,6 +1047,10 @@ async function showRequirementsTree() {
         tree.todoReqs = await loadSection('todo', '⏳ Requirements not yet completed');
         await buildTree();
       }
+    } else if (key.name === 'f') {
+      // Feedback button ( megaphone 📣 )
+      await handleFeedbackSubmission();
+      await buildTree();
     } else if (key.name === 'r') {
       const current = tree.items[tree.selected];
       if (!current) continue; // Safety check
@@ -1021,6 +1127,90 @@ async function showRequirementsTree() {
   process.stdin.pause();
 }
 
+/**
+ * Handle feedback submission
+ */
+async function handleFeedbackSubmission() {
+  console.log(chalk.bold.cyan('\n📣 ' + t('interactive.feedback.title')));
+  console.log(chalk.gray(t('interactive.feedback.instructions') + '\n'));
+
+  const { getUserProfile } = require('./auth');
+  const userProfile = await getUserProfile();
+  const userEmail = userProfile ? userProfile.email : 'anonymous';
+
+  console.log(chalk.gray('\n' + t('interactive.feedback.comment.instructions') + '\n'));
+
+  const commentLines = [];
+  let emptyLineCount = 0;
+  let isFirstLine = true;
+
+  while (true) {
+    try {
+      const { line } = await inquirer.prompt([{
+        type: 'input',
+        name: 'line',
+        message: isFirstLine ? t('interactive.feedback.comment') : ''
+      }]);
+
+      isFirstLine = false;
+
+      if (line.trim() === '') {
+        emptyLineCount++;
+        if (emptyLineCount >= 2) break;
+      } else {
+        emptyLineCount = 0;
+        commentLines.push(line);
+      }
+    } catch (err) {
+      break;
+    }
+  }
+
+  const comment = commentLines.join('\n');
+
+  if (!comment || comment.trim().length === 0) {
+    console.log(chalk.yellow('\n⚠️  ' + t('interactive.feedback.cancelled')));
+    return;
+  }
+
+  try {
+    console.log(chalk.gray('\n' + t('interactive.feedback.submitting') + '...'));
+
+    const auth = require('./auth');
+    const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
+    const userDb = new UserDatabase();
+
+    // Set auth token for API requests
+    const token = await auth.getAuthToken();
+    if (token) {
+      userDb.setAuthToken(token);
+    }
+
+    await userDb.submitFeedback({
+      email: userEmail,
+      comment: comment,
+      interface: 'cli',
+      version: pkg.version
+    });
+
+    console.log(chalk.green('\n✓ ' + t('interactive.feedback.success')));
+  } catch (error) {
+    console.log(chalk.red('\n✗ ' + t('interactive.feedback.error') + ': ') + error.message);
+  }
+
+  console.log(chalk.gray(`\n${t('interactive.press.enter.continue')}`));
+  await new Promise(resolve => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question('', () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
 // Helper to show goodbye message
 function showGoodbyeMessage() {
   const hour = new Date().getHours();
@@ -1369,6 +1559,7 @@ async function showClarificationActions(req, tree, loadClarification) {
   const actions = [
     { label: '✍️  Add/Edit Responses', value: 'edit-responses' },
     { label: '↩️  Move back to TODO (after clarification)', value: 'move-to-todo' },
+    { label: '📣 Feedback', value: 'feedback' },
     { label: '🗑️  Delete', value: 'delete' }
   ];
 
@@ -1399,7 +1590,8 @@ async function showClarificationActions(req, tree, loadClarification) {
     });
 
     // Display menu
-    console.log(chalk.gray('\nWhat would you like to do? (↑/↓/Enter to select, ESC/← to go back)\n'));
+    console.log(chalk.gray('\n💡 Press F for feedback - Share your thoughts anytime'));
+    console.log(chalk.gray('What would you like to do? (↑/↓/Enter to select, ESC/← to go back)\n'));
     actions.forEach((action, idx) => {
       if (idx === selected) {
         console.log(chalk.cyan(`❯ ${action.label}`));
@@ -1430,6 +1622,10 @@ async function showClarificationActions(req, tree, loadClarification) {
       selected = Math.max(0, selected - 1);
     } else if (key.name === 'down') {
       selected = Math.min(actions.length - 1, selected + 1);
+    } else if (key.name === 'f') {
+      // Feedback button ( megaphone 📣 )
+      await handleFeedbackSubmission();
+      return;
     } else if (key.name === 'return' || key.name === 'space') {
       const action = actions[selected].value;
 
@@ -1441,6 +1637,9 @@ async function showClarificationActions(req, tree, loadClarification) {
         await moveClarificationToTodo(req, tree);
         tree.clarificationReqs = await loadClarification();
         return;
+      } else if (action === 'feedback') {
+        await handleFeedbackSubmission();
+        return;
       } else if (action === 'delete') {
         await deleteClarification(req, tree);
         tree.clarificationReqs = await loadClarification();
@@ -1458,6 +1657,7 @@ async function showRequirementActions(req, sectionKey, tree) {
     { label: '👎 Thumbs down (demote to TODO)', value: 'thumbs-down' },
     { label: '⬆️  Move up', value: 'move-up' },
     { label: '⬇️  Move down', value: 'move-down' },
+    { label: '📣 Feedback', value: 'feedback' },
     { label: '🗑️  Delete', value: 'delete' }
   ];
 
@@ -1487,6 +1687,7 @@ async function showRequirementActions(req, sectionKey, tree) {
 
     // Display menu (always reprinted)
     console.log();
+    console.log(chalk.gray('💡 Press F for feedback - Share your thoughts anytime'));
     console.log(chalk.gray('What would you like to do? (↑/↓/Enter to select, ESC/← to go back)'));
     console.log();
     menuLines += 3; // Blank line + help text + blank line
@@ -1531,6 +1732,10 @@ async function showRequirementActions(req, sectionKey, tree) {
       process.exit(0);
     } else if (key.name === 'escape' || key.name === 'left') {
       return; // Go back
+    } else if (key.name === 'f') {
+      // Feedback button ( megaphone 📣 )
+      await handleFeedbackSubmission();
+      return;
     } else if (key.name === 'up') {
       selected = Math.max(0, selected - 1);
     } else if (key.name === 'down') {
@@ -1591,6 +1796,9 @@ async function performRequirementAction(action, req, sectionKey, tree) {
     case 'rename':
       await renameRequirement(req, sectionKey, tree);
       break;
+    case 'feedback':
+      await handleFeedbackSubmission();
+      break;
   }
 
   await new Promise(resolve => setTimeout(resolve, 1000));
@@ -2357,7 +2565,7 @@ async function showRequirementsBySection(sectionTitle) {
           }
           break;
         case 'delete':
-          const { confirmDelete } = await inquirer.prompt([{
+          const { confirmDelete } = await promptWithDefaultsOnce([{
             type: 'confirm',
             name: 'confirmDelete',
             message: 'Are you sure you want to delete this requirement?',
@@ -2383,6 +2591,104 @@ async function showRequirementsBySection(sectionTitle) {
   }
 }
 
+// Helper to move a requirement to the Recycled section
+async function moveToRecycled(reqPath, requirementTitle, fromSectionTitle) {
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  let inFromSection = false;
+  let inRecycledSection = false;
+  let reqStartIndex = -1;
+  let reqEndIndex = -1;
+  let recycledSectionIndex = -1;
+  let requirement = null;
+
+  // Find the requirement in the source section
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Track if we're in the source section
+    if (line.includes(fromSectionTitle)) {
+      inFromSection = true;
+      continue;
+    }
+
+    // Exit source section at next ## header
+    if (inFromSection && line.startsWith('## ') && !line.startsWith('###') && !line.includes(fromSectionTitle)) {
+      inFromSection = false;
+    }
+
+    // Find the requirement
+    if (inFromSection && line.trim() === `### ${requirementTitle}`) {
+      reqStartIndex = i;
+      requirement = { title: requirementTitle, details: [], package: null };
+
+      // Read requirement details
+      for (let j = i + 1; j < lines.length; j++) {
+        const nextLine = lines[j];
+        // Stop at next requirement or section
+        if (nextLine.startsWith('###') || (nextLine.startsWith('## ') && !nextLine.startsWith('###'))) {
+          reqEndIndex = j;
+          break;
+        }
+        // Check for package
+        if (nextLine.startsWith('PACKAGE:')) {
+          requirement.package = nextLine.replace('PACKAGE:', '').trim();
+        } else if (nextLine.trim()) {
+          requirement.details.push(nextLine);
+        }
+      }
+
+      if (reqEndIndex === -1) {
+        reqEndIndex = lines.length;
+      }
+      break;
+    }
+
+    // Find Recycled section
+    if (line.includes('♻️ Recycled') || line.includes('## Recycled')) {
+      recycledSectionIndex = i;
+      inRecycledSection = true;
+    }
+  }
+
+  if (!requirement || reqStartIndex === -1) {
+    throw new Error(`Requirement "${requirementTitle}" not found in ${fromSectionTitle}`);
+  }
+
+  // If Recycled section doesn't exist, create it at the end
+  if (recycledSectionIndex === -1) {
+    recycledSectionIndex = lines.length;
+    lines.push('', '## ♻️ Recycled', '');
+  }
+
+  // Remove requirement from source section
+  const removedLines = lines.splice(reqStartIndex, reqEndIndex - reqStartIndex);
+
+  // Find where to insert in Recycled section (after the section header)
+  let insertIndex = recycledSectionIndex + 1;
+  while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+    insertIndex++;
+  }
+
+  // Build requirement lines
+  const reqLines = [`### ${requirement.title}`];
+  if (requirement.package && requirement.package !== 'all') {
+    reqLines.push(`PACKAGE: ${requirement.package}`);
+  }
+  requirement.details.forEach(line => {
+    if (line.trim()) {
+      reqLines.push(line);
+    }
+  });
+  reqLines.push('');
+
+  // Insert into Recycled section
+  lines.splice(insertIndex, 0, ...reqLines);
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+}
+
 // Helper to save reordered requirements back to file
 async function saveRequirementsOrder(reqPath, sectionTitle, requirements) {
   const content = await fs.readFile(reqPath, 'utf8');
@@ -2481,6 +2787,9 @@ async function showRequirementsFromChangelog() {
   }
 }
 
+// Input suppression timestamp to avoid immediate re-entry into menus after cancel
+let menuSuppressUntil = 0;
+
 // Custom menu with both arrow keys and letter shortcuts
 async function showQuickMenu(items, initialSelectedIndex = 0) {
   return new Promise((resolve) => {
@@ -2492,6 +2801,7 @@ 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) => {
@@ -2631,19 +2941,42 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
       process.stdin.setRawMode(true);
     }
 
-    const onKeypress = async (str, key) => {
-      if (!key) return;
+    // Ignore spurious keypresses for a short debounce window after the menu opens
+    // This prevents accidental immediate re-entry when returning from sub-menus.
+    const IGNORE_INPUT_MS = 300; // milliseconds
+    // If a recent menu cancel occurred, extend the ignore window to avoid key repeat re-opening
+    let ignoreInputUntil = Math.max(Date.now() + IGNORE_INPUT_MS, menuSuppressUntil || 0);
 
-      // Ctrl+C to exit
-      if (key.ctrl && key.name === 'c') {
+    const onKeypress = async (str, key) => {
+      if (process.env.VCM_DEBUG_MENU === '1') {
+        const msg = `[DEBUG-MENU ${new Date().toISOString()}] onKeypress: str=${JSON.stringify(str)} key=${JSON.stringify(key)} now=${Date.now()}\n`;
+        console.log(msg);
+        try { require('fs').appendFileSync('/tmp/vcm-menu-debug.log', msg); } catch (e) { }
+      }
+      // Always allow Ctrl+C to pass through immediately
+      if (key && key.ctrl && key.name === 'c') {
         cleanup();
         process.exit(0);
         return;
       }
 
-      // ESC or left arrow to exit with confirmation
-      if (key.name === 'escape' || key.name === 'left') {
-        cleanup();
+      // Debounce: ignore inputs until the short window passes
+      if (Date.now() < ignoreInputUntil) {
+        return;
+      }
+
+      if (!key) return;
+
+      // Ctrl+C to exit
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        process.exit(0);
+        return;
+      }
+
+      // ESC or left arrow to exit with confirmation
+      if (key.name === 'escape' || key.name === 'left') {
+        cleanup();
         // Don't clear screen for exit - keep status visible
         resolve({ value: 'exit', selectedIndex });
         return;
@@ -2653,6 +2986,7 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
       if (str && str.length === 1) {
         if (str === 'x') {
           // 'x' always maps to exit (will trigger confirmAndExit)
+          if (process.env.VCM_DEBUG_MENU === '1') console.log(`[DEBUG-MENU ${new Date().toISOString()}] quickMenu: 'x' pressed (exit)`);
           cleanup();
           // Don't clear screen for exit - keep status visible
           resolve({ value: 'exit', selectedIndex });
@@ -2712,6 +3046,11 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
 }
 
 async function showProviderManagerMenu() {
+  if (process.env.VCM_DEBUG_MENU === '1') {
+    const msg = `[DEBUG-MENU ${new Date().toISOString()}] showProviderManagerMenu() called\n` + new Error().stack.split('\n').slice(1, 6).join('\n') + '\n';
+    console.log(msg);
+    try { require('fs').appendFileSync('/tmp/vcm-menu-debug.log', msg); } catch (e) { }
+  }
   const definitions = getProviderDefinitions();
   const defMap = new Map(definitions.map(def => [def.id, def]));
   const prefs = await getProviderPreferences();
@@ -2721,6 +3060,8 @@ async function showProviderManagerMenu() {
   let dirty = false;
 
   const { fetchQuotaForAgent } = require('vibecodingmachine-core/src/quota-management');
+  const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
+  const providerManager = new ProviderManager();
 
   const debugQuota = process.env.VCM_DEBUG_QUOTA === '1' || process.env.VCM_DEBUG_QUOTA === 'true';
 
@@ -2736,14 +3077,76 @@ async function showProviderManagerMenu() {
     return `${seconds}s`;
   };
 
+  const formatTimeAmPm = (date) => {
+    const hours24 = date.getHours();
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const ampm = hours24 >= 12 ? 'pm' : 'am';
+    const hours12 = (hours24 % 12) || 12;
+    return `${hours12}:${minutes} ${ampm}`;
+  };
+
+
+
+  // Pre-fetch data to avoid lag in render loop
+  const sharedAuth = require('vibecodingmachine-core/src/auth/shared-auth-storage');
+
+  // Initialize caches from persistent storage
+  const savedCache = await getProviderCache();
+
+  // Hydrate local maps from saved cache
+  const installationStatus = new Map();
+  const agentQuotas = new Map();
+
+  Object.keys(savedCache).forEach(id => {
+    if (savedCache[id].installed !== undefined) {
+      installationStatus.set(id, savedCache[id].installed);
+    }
+    if (savedCache[id].quota) {
+      agentQuotas.set(id, savedCache[id].quota);
+    }
+  });
+
+  // Also prefill agent quotas from the ProviderManager rate-limit file so the UI can
+  // display `[Resets at ...]` instantly (best-effort, read-only).
+  try {
+    const { getProviderRateLimitedQuotas } = require('./provider-rate-cache');
+    const prefetched = getProviderRateLimitedQuotas(definitions);
+    for (const [id, q] of prefetched) {
+      // Only set if we don't already have a richer quota cached
+      const existing = agentQuotas.get(id);
+      if (!existing || existing.type !== 'rate-limit') {
+        agentQuotas.set(id, q);
+      }
+    }
+  } catch (e) {
+    // Ignore — this is a non-critical optimization
+  }
+
+  // Default values while loading
+  let quotaInfo = { maxIterations: 10, todayUsage: 0 };
+  let autoConfig = {};
+  // Active flag to prevent background render after menu is closed
+  let isMenuActive = true;
+
+  // Load health metrics for all IDEs (load once at startup, not on every render)
+  let healthMetricsMap = new Map();
+  try {
+    const healthTracker = new IDEHealthTracker();
+    await healthTracker.load();
+    healthMetricsMap = await healthTracker.getAllHealthMetrics();
+  } catch (error) {
+    // Silently ignore health loading errors - health display is optional
+  }
+
+  // Clear loading message
+  // process.stdout.write('\r\x1b[K'); // Removed as per diff
+
   const render = async () => {
+    if (!isMenuActive) return; // Prevent rendering after menu closed
     process.stdout.write('\x1Bc');
     console.log(chalk.bold.cyan('⚙ ' + t('provider.title') + '\n'));
 
-    // Fetch quota info
-    const sharedAuth = require('vibecodingmachine-core/src/auth/shared-auth-storage');
-    const autoConfig = await getAutoConfig();
-    const quotaInfo = await sharedAuth.canRunAutoMode();
+    // Use cached quota info
     const remaining = Math.max(0, (quotaInfo.maxIterations || 10) - (quotaInfo.todayUsage || 0));
 
     // Calculate time until reset (midnight)
@@ -2754,15 +3157,65 @@ async function showProviderManagerMenu() {
     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)
+    // Display quota, accounting for per-agent rate limits to avoid showing "10/10" when some
+    // providers are rate-limited. We avoid surfacing agent-specific "[Resets at ...]" labels in
+    // the top-level overall quota row and instead show a compact partial-availability message.
     let quotaDisplay;
+
+    // Detect how many agents are currently rate-limited
+    const rateLimitedAgents = Array.from(agentQuotas.values()).filter(q => {
+      if (!q) return false;
+      if (q.type !== 'rate-limit') return false;
+      if (typeof q.isExceeded === 'function') return q.isExceeded();
+      if (q.remaining !== undefined) return q.remaining <= 0;
+      return false;
+    });
+    const rateLimitedCount = rateLimitedAgents.length;
+
     if (remaining === 0) {
-      // Rate limit active - show when it resets (in red)
+      // Overall rate limit active - show when it resets (in red)
       quotaDisplay = chalk.gray('  ' + t('provider.overall.quota') + ': ') + chalk.red(`⏰ ${t('provider.rate.limit.resets')} ${hoursUntilReset}h ${minsUntilReset}m`);
+    } else if (rateLimitedCount > 0) {
+      // Some providers are rate-limited — show partial availability instead of full 10/10
+      const effectiveRemaining = Math.max(0, remaining - rateLimitedCount);
+
+      // If one or more rate-limited agents provide a specific reset time, show that instead
+      // of a generic "Resets in Xh Ym" message to match per-agent rows (e.g., "[Resets at 5:00 pm]").
+      const earliestReset = rateLimitedAgents.reduce((min, q) => {
+        if (!q || !q.resetsAt) return min;
+        try {
+          const d = new Date(q.resetsAt);
+          if (Number.isNaN(d.getTime())) return min;
+          if (!min) return q.resetsAt;
+          return d.getTime() < new Date(min).getTime() ? q.resetsAt : min;
+        } catch (e) {
+          return min;
+        }
+      }, null);
+
+      const resetLabel = earliestReset ? formatResetsAtLabel(earliestReset) : null;
+
+      quotaDisplay = chalk.gray('  ' + t('provider.overall.quota') + ': ') + chalk.yellow(`⚠️  ${t('provider.available')} (${effectiveRemaining}/${quotaInfo.maxIterations})`) + chalk.gray(` • ${rateLimitedCount} provider${rateLimitedCount > 1 ? 's' : ''} limited`);
+
+      if (resetLabel) {
+        quotaDisplay += ' ' + chalk.red(`[${resetLabel}]`);
+      } else {
+        quotaDisplay += chalk.gray(' • ' + t('provider.resets.in') + ' ') + chalk.cyan(`${hoursUntilReset}h ${minsUntilReset}m`);
+      }
     } else {
       // Quota available - show when it resets (in green)
-      quotaDisplay = chalk.gray('  ' + t('provider.overall.quota') + ': ') + chalk.green(`✓ ${t('provider.available')} (${remaining}/${quotaInfo.maxIterations})`) + chalk.gray(' • ' + t('provider.resets.in') + ' ') + chalk.cyan(`${hoursUntilReset}h ${minsUntilReset}m`);
+      // If the quota is full (no usage), don't show the reset time — it's unnecessary and
+      // can be confusing when nothing is rate-limited.
+      const fullQuota = remaining === (quotaInfo.maxIterations || 10);
+      quotaDisplay = chalk.gray('  ' + t('provider.overall.quota') + ': ') + chalk.green(`✓ ${t('provider.available')} (${remaining}/${quotaInfo.maxIterations})`);
+      if (!fullQuota) {
+        quotaDisplay += chalk.gray(' • ' + t('provider.resets.in') + ' ') + chalk.cyan(`${hoursUntilReset}h ${minsUntilReset}m`);
+      }
     }
+
+    // Display Legend
+    console.log(chalk.gray('  Interface types: 🖥️  GUI Automation  ⚡  Direct Automation'));
+    console.log(chalk.gray('  Provider type: ☁️  Cloud  🏠  Local (Slow, Requires lots of memory and CPU, Private)'));
     console.log(quotaDisplay);
     console.log(chalk.gray('  ' + t('provider.instructions') + '\n'));
 
@@ -2773,75 +3226,137 @@ async function showProviderManagerMenu() {
       const isSelected = idx === selectedIndex;
       const isEnabled = enabled[id] !== false;
 
-      // Check for Kiro installation
-      let isInstalled = true;
-      if (id === 'kiro') {
-        try {
-          const { isKiroInstalled } = require('./kiro-installer');
-          isInstalled = isKiroInstalled();
-        } catch (e) {
-          // Ignore error provider checks
-        }
-      }
+      // Use cached installation status (default to false if not found in cache)
+      // For LLMs, we consider them always "installed" (cloud)
+      let isInstalled = def.type === 'ide' ? (installationStatus.get(id) === true) : true;
+      let quota = agentQuotas.get(id);
+
+      // Determine status emoji based on user requirements:
+      // ⬜ (Grey Square): Not installed
+      // ⚠️ (Yellow Triangle): Installed but (Quota limit OR Not verified)
+      // 🚫 (Red Circle): Disabled
+      // 🛑 (Red Stop Sign): Not working/Error
+      // 🟢 (Green Circle): Available/Working
 
-      // Determine status emoji: disabled = red alert, rate limited = green circle, enabled = green circle
       let statusEmoji;
-      if (id === 'kiro' && !isInstalled) {
-        statusEmoji = '🟡'; // Yellow for not installed
+      let statusText = '';
+
+      if (!isEnabled) {
+        statusEmoji = '🚫'; // Disabled
+      } else if (!isInstalled) {
+        statusEmoji = '⬜'; // Not installed
       } else {
-        statusEmoji = !isEnabled ? '🚨' : '🟢';
-      }
+        // Installed and Enabled, assume Green unless quota or error
+        statusEmoji = '🟢';
 
-      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}`;
+        if (def.type === 'ide') {
+          // TODO: Add actual "verified" check if available. For now assuming installed = verified.
+          // If we had a verification check:
+          // if (!isVerified) statusEmoji = '⚠️';
+        }
 
-      // 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;
+        // Check Quota
+        if (quota) {
+          // Handle both Quota class instances and plain JSON objects from cache
+          let isExceeded = false;
+          if (typeof quota.isExceeded === 'function') {
+            isExceeded = quota.isExceeded();
+          } else if (quota.remaining !== undefined) {
+            isExceeded = quota.remaining <= 0;
+          }
+
+          if (quota.type === 'rate-limit' && isExceeded) {
+            statusEmoji = '⚠️ ';
+            if (quota.resetsAt) {
+              const label = formatResetsAtLabel(quota.resetsAt);
+              statusText = label ? ` ${chalk.red(`⏰ ${label}`)}` : ` ${chalk.red('[Rate limited]')}`;
+            } else {
+              statusText = ` ${chalk.red('[Rate limited]')}`;
+            }
+          }
         }
+      }
 
-        const agentId = `${id}:${model}`;
-        const quota = await fetchQuotaForAgent(agentId);
+      // Determine Interface Type Icon (GUI vs Direct Automation)
+      let interfaceIcon = '⚡'; // Default to Direct Automation
+      if (def.type === 'ide') {
+        interfaceIcon = '🖥️'; // GUI Automation for IDEs
+      }
+
+      // Determine Provider Type Icon (Cloud vs Local)
+      let providerTypeIcon = '☁️'; // Default to Cloud (IDEs and most LLMs)
+      if (def.type === 'direct' && def.category === 'llm' && def.id === 'ollama') {
+        providerTypeIcon = '🏠'; // Local (only for Ollama)
+      }
 
-        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'}`);
+      // Trim emojis to remove any hidden characters and ensure clean spacing
+      interfaceIcon = interfaceIcon.trim();
+      providerTypeIcon = providerTypeIcon.trim();
+      const isWarningEmoji = statusEmoji.includes('⚠️');
+      statusEmoji = statusEmoji.trim();
+
+      // Determine spacing based on interface icon type and provider type
+      // Multi-char icons (🖥️) need double spaces, single-char icons (⚡) use single space after interface icon
+      const isMultiCharInterface = interfaceIcon.length > 1;
+      const spaceAfterInterface = isMultiCharInterface ? '  ' : ' ';
+      // Local provider (🏠) uses single space, others use double space after provider icon
+      const isLocalProvider = providerTypeIcon === '🏠';
+      const spaceAfterProvider = isLocalProvider ? ' ' : '  ';
+
+      // Adjust spacing after status emoji - warning emoji needs extra space
+      const spaceAfterStatus = isWarningEmoji ? '   ' : '  ';
+
+      const prefix = isSelected ? chalk.cyan('❯') + ' ' : '  ';
+
+      // Get health metrics for this IDE (if available)
+      let healthCounters = '';
+      const ideMetrics = healthMetricsMap.get(def.id);
+      if (ideMetrics) {
+        const counters = HealthReporter.formatInlineCounters(ideMetrics);
+        if (counters) {
+          // Color code the counters: green for +N, red for -M
+          const coloredCounters = counters
+            .split(' ')
+            .map(part => part.startsWith('+') ? chalk.green(part) : chalk.red(part))
+            .join(' ');
+          healthCounters = ` ${coloredCounters}`;
         }
+      }
 
-        if (quota.type === 'infinite') {
-          line += ` ${chalk.gray('[' + t('provider.status.quota.infinite') + ']')}`;
-        } else if (quota.type === 'rate-limit') {
-          if (quota.isExceeded()) {
-            if (quota.resetsAt) {
-              const msUntilReset = new Date(quota.resetsAt).getTime() - Date.now();
-              line += ` ${chalk.red(`[⏳ resets in ${formatDuration(msUntilReset)}]`)}`;
+      // Status emoji is now first, followed by interface icon and provider type icon
+      let line = `${prefix}${statusEmoji}${spaceAfterStatus}${interfaceIcon}${spaceAfterInterface}${providerTypeIcon}${spaceAfterProvider}  ${idx + 1}. ${def.name} ${chalk.gray(`(${def.id})`)}${healthCounters}${statusText}`;
+      if (debugQuota && quota) {
+        // Append extra debug info if needed
+        const resetMs = quota?.resetsAt ? (new Date(quota.resetsAt).getTime() - Date.now()) : null;
+        line += chalk.gray(` [D: type=${quota?.type} rem=${quota?.remaining} lim=${quota?.limit} resetIn=${resetMs !== null ? formatDuration(resetMs) : 'null'}]`);
+      }
+      console.log(line);
+
+      if (Array.isArray(def.subAgents) && def.subAgents.length > 0) {
+        for (const sub of def.subAgents) {
+          const info = providerManager.getRateLimitInfo(def.id, sub.model);
+          let subStatusEmoji;
+          let subStatusText = '';
+
+          if (!isEnabled) {
+            subStatusEmoji = '🚫';
+          } else if (!isInstalled) {
+            subStatusEmoji = '⬜';
+          } else if (info && info.isRateLimited) {
+            subStatusEmoji = '⚠️';
+            if (info.resetTime) {
+              const label = formatResetsAtLabel(info.resetTime);
+              subStatusText = label ? ` ${chalk.red(`⏰ ${label}`)}` : ` ${chalk.red('[Rate limited]')}`;
             } else {
-              line += ` ${chalk.red('[Rate limited]')}`;
+              subStatusText = ` ${chalk.red('[Rate limited]')}`;
             }
           } else {
-            // Show time until rate limit starts (when it resets)
-            if (quota.resetsAt) {
-              const msUntilReset = new Date(quota.resetsAt).getTime() - Date.now();
-              line += ` ${chalk.green(`[✓ ${t('provider.status.available.resets')} ${formatDuration(msUntilReset)}]`)}`;
-            } else {
-              line += ` ${chalk.green('[' + t('provider.status.available') + ']')}`;
-            }
+            subStatusEmoji = '🟢';
           }
+
+          console.log(`      ${subStatusEmoji} ${chalk.gray('↳')} ${sub.name} ${chalk.gray(`(${sub.model})`)}${subStatusText}`);
         }
-      } catch (e) {
-        // Silently skip if quota fetch fails
       }
-
-      console.log(line);
     }
 
     console.log();
@@ -2852,6 +3367,143 @@ async function showProviderManagerMenu() {
     }
   };
 
+  // Background loading function
+  const loadDataInBackground = async () => {
+    try {
+      // 1. Load config and auth info
+      const [config, quota] = await Promise.all([
+        getAutoConfig(),
+        sharedAuth.canRunAutoMode()
+      ]);
+      autoConfig = config;
+      quotaInfo = quota;
+      if (typeof render === 'function') await render();
+
+      // 2. Check installation status in parallel
+      const installPromises = definitions.map(async (def) => {
+        let isInstalled = true;
+        if (def.type === 'ide') {
+          try {
+            if (def.id === 'kiro') {
+              const { isKiroInstalled } = require('./kiro-installer');
+              isInstalled = isKiroInstalled();
+            } else if (def.id === 'cursor') {
+              isInstalled = await checkAppOrBinary(['Cursor'], ['cursor']);
+            } else if (def.id === 'windsurf') {
+              isInstalled = await checkAppOrBinary(['Windsurf'], ['windsurf']);
+            } else if (def.id === 'vscode') {
+              isInstalled = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+            } else if (def.id === 'github-copilot' || def.id === 'amazon-q') {
+              // Check if VS Code is installed AND the extension is installed
+              const vscodeInstalled = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+              if (vscodeInstalled) {
+                isInstalled = await checkVSCodeExtension(def.id);
+              } else {
+                isInstalled = false;
+              }
+            } else if (def.id === 'replit') {
+              // Replit is web-based, always considered "installed"
+              isInstalled = true;
+            } else if (def.id === 'antigravity') {
+              isInstalled = await checkAppOrBinary(['Antigravity'], ['antigravity']);
+            } else {
+              isInstalled = await checkAppOrBinary([], [def.id]);
+            }
+          } catch (e) {
+            isInstalled = false;
+          }
+        }
+        installationStatus.set(def.id, isInstalled);
+        return { id: def.id, installed: isInstalled };
+      });
+
+      const installResults = await Promise.all(installPromises);
+
+      // Update cache
+      let newCache = {};
+      installResults.forEach(r => {
+        newCache[r.id] = { ...(savedCache[r.id] || {}), installed: r.installed };
+      });
+      await setProviderCache(newCache);
+
+      if (typeof render === 'function') await render();
+
+      // 3. Check quotas in parallel
+      const quotaPromises = definitions.map(async (def) => {
+        try {
+          let model = def.defaultModel || def.id;
+          if (def.id === 'groq') model = autoConfig.groqModel || model;
+          else if (def.id === 'anthropic') model = autoConfig.anthropicModel || model;
+          else if (def.id === 'ollama') {
+            const preferredModel = autoConfig.llmModel && autoConfig.llmModel.includes('ollama/')
+              ? autoConfig.llmModel.split('/')[1]
+              : autoConfig.llmModel || autoConfig.aiderModel;
+            model = (preferredModel && preferredModel !== def.id) ? preferredModel : model;
+          }
+
+          const agentId = `${def.id}:${model}`;
+          const quota = await fetchQuotaForAgent(agentId);
+
+          // Merge cautiously: if we already have an active rate-limit prefetched from
+          // ProviderManager, avoid overwriting it with a non-rate-limit result which
+          // could make the UI lose the reset information briefly. If both are rate-limits,
+          // prefer the earliest reset time.
+          try {
+            const existing = agentQuotas.get(def.id);
+            const existingIsActiveRateLimit = existing && existing.type === 'rate-limit' && new Date(existing.resetsAt).getTime() > Date.now();
+            const newIsRateLimit = quota && quota.type === 'rate-limit';
+
+            if (existingIsActiveRateLimit && !newIsRateLimit) {
+              // Keep the existing active rate-limit and don't overwrite
+            } else if (existingIsActiveRateLimit && newIsRateLimit) {
+              // Both rate-limited: keep the one with the earliest reset
+              const existingReset = new Date(existing.resetsAt).getTime();
+              const newReset = quota && quota.resetsAt ? new Date(quota.resetsAt).getTime() : null;
+              if (!newReset || existingReset <= newReset) {
+                // keep existing
+              } else {
+                agentQuotas.set(def.id, quota);
+              }
+            } else {
+              // No active existing rate limit — set/overwrite normally
+              agentQuotas.set(def.id, quota);
+            }
+          } catch (e) {
+            // On any error, set the quota to avoid leaving stale state
+            agentQuotas.set(def.id, quota);
+          }
+
+          return { id: def.id, quota };
+        } catch (e) {
+          return null;
+        }
+      });
+
+      const quotaResults = await Promise.all(quotaPromises);
+
+      // Update cache with quotas
+      newCache = {};
+      quotaResults.forEach(r => {
+        if (r) {
+          newCache[r.id] = { ...(savedCache[r.id] || {}), quota: r.quota };
+          // Preserve installed status if we just set it
+          if (installationStatus.has(r.id)) {
+            newCache[r.id].installed = installationStatus.get(r.id);
+          }
+        }
+      });
+      await setProviderCache(newCache);
+
+      if (typeof render === 'function') await render();
+
+    } catch (error) {
+      // Silently fail in background
+    }
+  };
+
+  // Start background loading
+  loadDataInBackground();
+
   if (process.env.VCM_RENDER_ONCE === '1' || process.env.VCM_RENDER_ONCE === 'true') {
     await render();
     return;
@@ -2859,6 +3511,8 @@ async function showProviderManagerMenu() {
 
   return new Promise(async (resolve) => {
     const cleanup = () => {
+      // Mark menu as inactive so background loaders stop rendering
+      isMenuActive = false;
       if (process.stdin.isTTY && process.stdin.setRawMode) {
         process.stdin.setRawMode(false);
       }
@@ -2895,6 +3549,13 @@ async function showProviderManagerMenu() {
     };
 
     const cancel = () => {
+      // Suppress input for a short period to avoid buffered key repeats reopening menus
+      menuSuppressUntil = Date.now() + 1000; // 1 second
+      if (process.env.VCM_DEBUG_MENU === '1') {
+        const msg = `[DEBUG-MENU ${new Date().toISOString()}] menu cancelled; suppress until ${new Date(menuSuppressUntil).toISOString()}\n`;
+        console.log(msg);
+        try { require('fs').appendFileSync('/tmp/vcm-menu-debug.log', msg); } catch (e) { }
+      }
       cleanup();
       console.log('\n');
       resolve(null);
@@ -2926,12 +3587,104 @@ async function showProviderManagerMenu() {
       await render();
     };
 
+    const installSelected = async () => {
+      const id = order[selectedIndex];
+      const def = defMap.get(id);
+
+      if (!def) return;
+
+      // Only IDE providers can be installed
+      if (def.type !== 'ide') {
+        console.log(chalk.yellow('\n⚠️  Installation is only available for IDE providers.\n'));
+        await render();
+        return;
+      }
+
+      // Check if already installed
+      const isInstalled = installationStatus.get(id);
+      if (isInstalled) {
+        console.log(chalk.yellow(`\n⚠️  ${def.name} is already installed.\n`));
+        await render();
+        return;
+      }
+
+      console.log(chalk.cyan(`\n🔧 Installing ${def.name}...\n`));
+
+      try {
+        const appleScriptManager = new AppleScriptManager();
+        const repoPath = await getRepoPath();
+
+        // Use openIDE method which handles installation
+        await appleScriptManager.openIDE(id, repoPath);
+
+        // Re-check installation status
+        let newStatus = true;
+        try {
+          if (id === 'kiro') {
+            const { isKiroInstalled } = require('./kiro-installer');
+            newStatus = isKiroInstalled();
+          } else if (id === 'cursor') {
+            newStatus = await checkAppOrBinary(['Cursor'], ['cursor']);
+          } else if (id === 'windsurf') {
+            newStatus = await checkAppOrBinary(['Windsurf'], ['windsurf']);
+          } else if (id === 'vscode') {
+            newStatus = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+          } else if (id === 'github-copilot' || id === 'amazon-q') {
+            // Check if VS Code is installed AND the extension is installed
+            const vscodeInstalled = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+            if (vscodeInstalled) {
+              newStatus = await checkVSCodeExtension(id);
+            } else {
+              newStatus = false;
+            }
+          } else if (id === 'antigravity') {
+            newStatus = await checkAppOrBinary(['Antigravity'], ['antigravity']);
+          } else if (id === 'replit') {
+            // Replit is web-based, always considered "installed"
+            newStatus = true;
+          } else {
+            newStatus = await checkAppOrBinary([], [id]);
+          }
+        } catch (e) {
+          newStatus = false;
+        }
+
+        installationStatus.set(id, newStatus);
+
+        // Update cache
+        const savedCache = await getProviderCache();
+        const newCache = {
+          ...savedCache,
+          [id]: { ...(savedCache[id] || {}), installed: newStatus }
+        };
+        await setProviderCache(newCache);
+
+        if (newStatus) {
+          console.log(chalk.green(`\n✓ ${def.name} installed successfully!\n`));
+        } else {
+          console.log(chalk.yellow(`\n⚠️  Installation may have completed, but ${def.name} was not detected. Please check manually.\n`));
+        }
+      } catch (error) {
+        console.log(chalk.red(`\n✗ Installation failed: ${error.message}\n`));
+      }
+
+      await render();
+    };
+
+    // Ignore spurious keypresses for a short debounce window after opening the menu
+    const IGNORE_INPUT_MS = 300; // milliseconds
+    let ignoreInputUntil = Date.now() + IGNORE_INPUT_MS;
+
     const onKeypress = async (str, key = {}) => {
+      // Allow immediate Ctrl+C regardless of debounce
       if (key.ctrl && key.name === 'c') {
         cancel();
         return;
       }
 
+      // Debounce: ignore inputs that happen too soon after the menu opens
+      if (Date.now() < ignoreInputUntil) return;
+
       switch (key.name) {
         case 'up':
           await moveSelection(-1);
@@ -2951,15 +3704,22 @@ async function showProviderManagerMenu() {
         case 'd':
           await toggle(false);
           break;
+        case 'i':
+          await installSelected();
+          break;
         case 'space':
           await toggle(!(enabled[order[selectedIndex]] !== false));
           break;
         case 'return':
           saveAndExit(order[selectedIndex]);
           break;
-        case 'escape':
         case 'left':
+          // Left arrow: save any pending changes and exit (match Enter's save behavior for order)
+          saveAndExit();
+          break;
+        case 'escape':
         case 'x':
+          // Escape or 'x' should cancel without persisting pending changes
           cancel();
           break;
         default:
@@ -2978,23 +3738,54 @@ async function showProviderManagerMenu() {
   });
 }
 
-/* async function showSettings() {
-  console.log(chalk.bold.cyan('\n⚙️  Settings\n'));
+/**
+ * Get health metrics for IDE choices
+ */
+async function getIDEHealthMetrics() {
+  try {
+    const healthTracker = new IDEHealthTracker();
+    const allMetrics = await healthTracker.getAllHealthMetrics();
+    return allMetrics;
+  } catch (error) {
+    // Health tracking not available, return empty metrics
+    return new Map();
+  }
+}
 
+/**
+ * Format IDE name with health metrics
+ */
+async function formatIDEChoiceWithHealth(ideName, ideValue, allMetrics) {
+  const metrics = allMetrics.get(ideValue);
+  
+  if (!metrics || metrics.totalInteractions === 0) {
+    return ideName; // No health data available
+  }
+
+  const successCount = metrics.successCount || 0;
+  const failureCount = metrics.failureCount || 0;
+  const healthIndicator = metrics.consecutiveFailures === 0 ? '✅' : '⚠️';
+  
+  return `${ideName} ${healthIndicator} +${successCount} -${failureCount}`;
+}
+
+async function showSettings() {
+  console.log(chalk.bold.cyan('\n⚙️  Settings\n'));
+ 
   const { setConfigValue } = require('vibecodingmachine-core');
   const { getAutoConfig, setAutoConfig } = require('./config');
   const currentHostnameEnabled = await isComputerNameEnabled();
   const hostname = getHostname();
   const autoConfig = await getAutoConfig();
   const currentIDE = autoConfig.ide || 'claude-code';
-
+ 
   // Show current settings
   console.log(chalk.gray('Current settings:'));
   console.log(chalk.gray('  Computer Name:            '), chalk.cyan(hostname));
   console.log(chalk.gray('  Current IDE:              '), chalk.cyan(formatIDEName(currentIDE)));
   console.log(chalk.gray('  Use Hostname in Req File: '), currentHostnameEnabled ? chalk.green('Enabled ✓') : chalk.yellow('Disabled ○'));
   console.log();
-
+ 
   const { action } = await inquirer.prompt([
     {
       type: 'list',
@@ -3016,54 +3807,59 @@ async function showProviderManagerMenu() {
       ]
     }
   ]);
+ 
+  /**
+ * Get health metrics for IDE choices
+ */
+async function getIDEHealthMetrics() {
+  try {
+    const healthTracker = new IDEHealthTracker();
+    const allMetrics = await healthTracker.getAllHealthMetrics();
+    return allMetrics;
+  } catch (error) {
+    // Health tracking not available, return empty metrics
+    return new Map();
+  }
+}
 
-  if (action === 'change-ide') {
-    const { ide } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'ide',
-        message: 'Select IDE:',
-        choices: [
-          { name: 'Claude Code CLI (recommended - Anthropic Claude)', value: 'claude-code' },
-          { name: 'Aider CLI (best for Ollama & Bedrock)', value: 'aider' },
-          { name: 'Continue CLI (Ollama support, but --auto mode doesn\'t execute code)', value: 'continue' },
-          { name: 'Cline CLI (local AI alternative, but has Ollama connection issues)', value: 'cline' },
-          { name: 'Cursor', value: 'cursor' },
-          { name: 'VS Code', value: 'vscode' },
-          { name: 'Windsurf', value: 'windsurf' }
-        ],
-        default: currentIDE
-      }
-    ]);
+/**
+ * Format IDE name with health metrics
+ */
+async function formatIDEChoiceWithHealth(ideName, ideValue, allMetrics) {
+  const metrics = allMetrics.get(ideValue);
+  
+  if (!metrics || metrics.totalInteractions === 0) {
+    return ideName; // No health data available
+  }
 
-    // Save to config
-    const newConfig = { ...autoConfig, ide };
-    await setAutoConfig(newConfig);
+  const successCount = metrics.successCount || 0;
+  const failureCount = metrics.failureCount || 0;
+  const healthIndicator = metrics.consecutiveFailures === 0 ? '✅' : '⚠️';
+  
+  return `${ideName} ${healthIndicator} +${successCount} -${failureCount}`;
+}
 
-    console.log(chalk.green('\n✓'), `IDE changed to ${chalk.cyan(formatIDEName(ide))}`);
-    console.log(chalk.gray('  Note: This will be used for the next Auto Mode session.'));
-    console.log();
-  } else if (action === 'toggle-hostname') {
+async function showSettings() {
     const newValue = !currentHostnameEnabled;
-
+ 
     // Save to shared config (same location as Electron app)
     await setConfigValue('computerNameEnabled', newValue);
-
+ 
     const statusText = newValue ? chalk.green('enabled') : chalk.yellow('disabled');
     console.log(chalk.green('\n✓'), `Hostname in requirements file ${statusText}`);
-
+ 
     if (newValue) {
       console.log(chalk.gray('\n  Requirements file will be:'), chalk.cyan(`REQUIREMENTS-${hostname}.md`));
     } else {
       console.log(chalk.gray('\n  Requirements file will be:'), chalk.cyan('REQUIREMENTS.md'));
     }
-
+ 
     console.log(chalk.gray('\n  Note: You may need to rename your existing requirements file.'));
     console.log(chalk.gray('  Note: This setting is now synced with the Electron app.'));
     console.log();
   }
 }
-
+ 
 /**
  * Show cloud sync management menu
  */
@@ -3451,24 +4247,13 @@ async function startInteractive() {
             const provider = displayAgent === 'ollama' ? 'ollama' : displayAgent;
 
             if (checkModel) {
-              const timeUntilReset = providerManager.getTimeUntilReset(provider, checkModel);
-
-              if (timeUntilReset) {
-                // 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`;
-                }
+              const info = providerManager.getRateLimitInfo(provider, checkModel);
 
-                agentDisplay += ` ${chalk.red('⏰ Rate limit resets in ' + timeStr)}`;
+              if (info && info.isRateLimited && info.resetTime) {
+                const label = formatResetsAtLabel(info.resetTime);
+                if (label) {
+                  agentDisplay += ` ${chalk.red('⏰ ' + label)}`;
+                }
               }
             }
           }
@@ -3516,7 +4301,9 @@ async function startInteractive() {
 
       // Add Requirements as a selectable setting with counts
       const hasRequirements = await requirementsExists();
-      const counts = hasRequirements ? await countRequirements() : null;
+      const { getComputerFilter } = require('./config');
+      const computerFilter = await getComputerFilter();
+      const counts = hasRequirements ? await countRequirements(computerFilter) : null;
       let requirementsText = t('interactive.requirements') + ': ';
       if (counts) {
         // Use actual counts for display (not capped by maxChats)
@@ -3538,11 +4325,19 @@ async function startInteractive() {
       if (requirementsText !== '') {
         items.push({
           type: 'setting',
-          name: requirementsText,
+          name: requirementsText + ` ${chalk.blue('Sync Status: ' + (await getSyncStatus()))}`,
           value: 'setting:requirements'
         });
       }
 
+      // Add requirement filtering by computer
+      const filterText = computerFilter ? chalk.cyan(computerFilter) : chalk.gray('All Computers');
+      items.push({
+        type: 'setting',
+        name: `  └─ Filter Requirements by Computer: ${filterText}`,
+        value: 'setting:filter-requirements'
+      });
+
       items.push({
         type: 'setting',
         name: `  └─ ${t('interactive.hostname.enabled')}: ${useHostname ? chalk.green('✓') : chalk.red('🛑')} ${useHostname ? '✓ ENABLED' : '🛑 ' + t('interactive.hostname.disabled')}`,
@@ -3559,44 +4354,33 @@ async function startInteractive() {
         value: 'setting:stages'
       });
 
-      // Cloud Sync Status
-      try {
-        const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
-        const syncEngine = new SyncEngine();
+      items.push({
+        type: 'setting',
+        name: `Start Auto: Switch to Console tab and save updated agent list on exit (Left arrow to exit agent list will also save)`,
+        value: 'setting:start-auto'
+      });
 
-        // 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 ? t('interactive.online') : t('interactive.offline');
-          const queueText = syncStatus.queuedChanges > 0 ? chalk.yellow(` (${syncStatus.queuedChanges} queued)`) : '';
-
-          items.push({
-            type: 'setting',
-            name: `${t('interactive.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'
-        });
-      }
+      items.push({
+        type: 'setting',
+        name: `  └─ ${t('interactive.feedback')}: ${chalk.cyan('📣 Press Ctrl+F for feedback')}`,
+        value: 'setting:feedback'
+      });
 
-      // Add "Next TODO Requirement" as a separate menu item if there are TODO items
+      // TODO: Implement getNextTodoRequirement function
+      // if (counts && counts.todoCount > 0) {
+      //   const { getNextTodoRequirement } = require('./auto-mode');
+      //   const nextRequirement = await getNextTodoRequirement();
+      //   if (nextRequirement) {
+      //     const requirementPreview = nextRequirement.length > 80 
+      //       ? nextRequirement.substring(0, 77) + '...' 
+      //       : nextRequirement;
+      //     items.push({
+      //       type: 'info',
+      //       name: `  └─ ${t('interactive.next.requirement')}: ${chalk.cyan(requirementPreview)}`,
+      //       value: 'info:next-requirement'
+      //     });
+      //   }
+      // }
       if (counts && counts.todoCount > 0) {
         // Get the actual next requirement text (new header format)
         let nextReqText = '...';
@@ -3605,6 +4389,9 @@ async function startInteractive() {
           const hostname = await getHostname();
           const reqFilename = await getRequirementsFilename(hostname);
           const reqPath = path.join(repoPath, '.vibecodingmachine', reqFilename);
+          // Increase the delay to prevent flashing and repaint
+          await new Promise(resolve => setTimeout(resolve, 1000));
+
 
           if (await fs.pathExists(reqPath)) {
             const reqContent = await fs.readFile(reqPath, 'utf8');
@@ -3714,10 +4501,20 @@ async function startInteractive() {
 
       switch (actionStr) {
         case 'setting:agent': {
+          if (process.env.VCM_DEBUG_MENU === '1') {
+            const msg = `[DEBUG-MENU ${new Date().toISOString()}] Main menu handling 'setting:agent' - invoking showProviderManagerMenu()\n` + new Error().stack.split('\n').slice(1, 6).join('\n') + '\n';
+            console.log(msg);
+            try { require('fs').appendFileSync('/tmp/vcm-menu-debug.log', msg); } catch (e) { }
+          }
           await showProviderManagerMenu();
           await showWelcomeScreen();
           break;
         }
+        case 'setting:feedback': {
+          await handleFeedbackSubmission();
+          await showWelcomeScreen();
+          break;
+        }
         case 'setting:provider': {
           // Switch AI provider - run provider setup only, don't start auto mode
           // Note: Continue CLI doesn't have provider setup - models are configured in ~/.continue/config.yaml
@@ -3920,6 +4717,69 @@ async function startInteractive() {
           await showWelcomeScreen();
           break;
         }
+        case 'setting:filter-requirements': {
+          // Configure requirement filtering by computer
+          const { getComputerFilter, setComputerFilter } = require('./config');
+          const inquirer = require('inquirer');
+          const repoPath = await getRepoPath();
+
+          if (!repoPath) {
+            console.log(chalk.yellow('No repository configured. Use repo:init or repo:set first.'));
+            await showWelcomeScreen();
+            break;
+          }
+
+          // Find all REQUIREMENTS-*.md files to get available computers
+          const vibeDir = path.join(repoPath, '.vibecodingmachine');
+          const files = await fs.pathExists(vibeDir) ? await fs.readdir(vibeDir) : [];
+          const reqFiles = files.filter(f => f.startsWith('REQUIREMENTS') && f.endsWith('.md'));
+
+          const computers = [];
+          for (const file of reqFiles) {
+            const filePath = path.join(vibeDir, file);
+            const content = await fs.readFile(filePath, 'utf8');
+            const hostnameMatch = content.match(/- \*\*Hostname\*\*:\s*(.+)/);
+            if (hostnameMatch) {
+              computers.push(hostnameMatch[1].trim());
+            }
+          }
+
+          if (computers.length === 0) {
+            console.log(chalk.yellow('No computers found in requirements files.'));
+            await showWelcomeScreen();
+            break;
+          }
+
+          const currentFilter = await getComputerFilter();
+
+          console.log(chalk.cyan(`\n🖥️  ${t('interactive.filter.requirements.by.computer')}\n`));
+          console.log(chalk.gray('Select which computer\'s requirements to show, or "All Computers" to show all.\n'));
+
+          const { selectedComputer } = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'selectedComputer',
+              message: t('interactive.select.computer'),
+              choices: [
+                { name: chalk.gray('All Computers'), value: null },
+                ...computers.map(c => ({
+                  name: c === currentFilter ? chalk.cyan(`${c} (current)`) : c,
+                  value: c
+                }))
+              ],
+              default: currentFilter || null,
+              loop: false,
+              pageSize: 15
+            }
+          ]);
+
+          await setComputerFilter(selectedComputer);
+
+          const filterText = selectedComputer ? chalk.cyan(selectedComputer) : chalk.gray('All Computers');
+          console.log(chalk.green('\n✓'), `Requirements filter set to: ${filterText}\n`);
+          await showWelcomeScreen();
+          break;
+        }
         case 'setting:stages': {
           // Configure stages
           const { getStages, setStages, DEFAULT_STAGES } = require('./config');
@@ -3927,11 +4787,11 @@ async function startInteractive() {
 
           // Override inquirer's checkbox help text for current locale
           const CheckboxPrompt = require('inquirer/lib/prompts/checkbox');
-          const originalGetHelpText = CheckboxPrompt.prototype.getHelp || function() {
+          const originalGetHelpText = CheckboxPrompt.prototype.getHelp || function () {
             return '(Press <space> to select, <a> to toggle all, <i> to invert selection, and <enter> to proceed)';
           };
 
-          CheckboxPrompt.prototype.getHelp = function() {
+          CheckboxPrompt.prototype.getHelp = function () {
             const locale = detectLocale();
             if (locale === 'es') {
               return '(Presiona <espacio> para seleccionar, <a> para alternar todo, <i> para invertir selección, y <enter> para proceder)';
@@ -4013,8 +4873,29 @@ async function startInteractive() {
               const { getAutoConfig } = require('./config');
               const currentConfig = await getAutoConfig();
 
+              // Get first enabled agent from provider preferences (this is what user expects)
+              const { getProviderPreferences } = require('../utils/provider-registry');
+              const prefs = await getProviderPreferences();
+              console.log(chalk.gray('[DEBUG] Provider preferences:'), JSON.stringify(prefs, null, 2));
+              let firstEnabledAgent = null;
+              for (const agentId of prefs.order) {
+                if (prefs.enabled[agentId] !== false) {
+                  firstEnabledAgent = agentId;
+                  console.log(chalk.gray('[DEBUG] Found first enabled agent:'), firstEnabledAgent);
+                  break;
+                }
+              }
+              const agentToUse = firstEnabledAgent || currentIDE;
+              console.log(chalk.gray('[DEBUG] Agent to use:'), agentToUse, '(firstEnabled:', firstEnabledAgent, ', fallback:', currentIDE, ')');
+
               // Use saved maxChats/neverStop settings
-              const options = { ide: currentIDE };
+              const options = { ide: agentToUse };
+              
+              // Set extension for VS Code extensions from saved config
+              if (agentToUse === 'amazon-q' || agentToUse === 'github-copilot') {
+                options.extension = agentToUse;
+              }
+              
               if (currentConfig.neverStop) {
                 options.neverStop = true;
               } else if (currentConfig.maxChats) {
@@ -4034,10 +4915,9 @@ async function startInteractive() {
                 }
 
                 // ALWAYS use auto:direct (supports both LLM and IDE agents with proper looping)
-                const currentAgent = currentConfig.agent || currentConfig.ide || 'ollama';
-                console.log(chalk.gray('[DEBUG] Using auto:direct for agent:', currentAgent));
+                console.log(chalk.gray('[DEBUG] Using auto:direct for agent:', agentToUse));
                 const { handleAutoStart: handleDirectAutoStart } = require('../commands/auto-direct');
-                await handleDirectAutoStart({ maxChats: options.maxChats });
+                await handleDirectAutoStart(options);
 
                 // Prompt user before returning to menu (so they can read the output)
                 console.log('');
@@ -4252,8 +5132,11 @@ async function startInteractive() {
                 { name: 'Continue CLI (Ollama support, but --auto mode doesn\'t execute code)', value: 'continue' },
                 { name: 'Cline CLI (local AI alternative, but has Ollama connection issues)', value: 'cline' },
                 { name: 'Cursor', value: 'cursor' },
-                { name: 'VS Code', value: 'vscode' },
-                { name: 'Windsurf', value: 'windsurf' }
+                { name: 'VS Code (with Amazon Q Developer)', value: 'amazon-q' },
+                { name: 'VS Code (with GitHub Copilot)', value: 'github-copilot' },
+                { name: 'VS Code (plain)', value: 'vscode' },
+                { name: 'Windsurf', value: 'windsurf' },
+                { name: 'Google Antigravity', value: 'antigravity' }
               ],
               default: 'claude-code'
             },
@@ -4264,7 +5147,42 @@ async function startInteractive() {
               default: ''
             }
           ]);
+
+          let ideModel = null;
+          if (ide === 'windsurf' || ide === 'antigravity') {
+            const { selectedModel } = await inquirer.prompt([
+              {
+                type: 'list',
+                name: 'selectedModel',
+                message: `Select ${ide === 'windsurf' ? 'Windsurf' : 'Antigravity'} agent/model:`,
+                choices: (ide === 'windsurf' ? [
+                  { name: 'Default', value: 'default' },
+                  { name: 'SWE-1-lite', value: 'swe-1-lite' }
+                ] : [
+                  { name: 'Default', value: 'antigravity' },
+                  { name: 'Gemini 3 Pro (Low)', value: 'Gemini 3 Pro (Low)' },
+                  { name: 'Claude Sonnet 4.5', value: 'Claude Sonnet 4.5' },
+                  { name: 'Claude Sonnet 4.5 (Thinking)', value: 'Claude Sonnet 4.5 (Thinking)' },
+                  { name: 'GPT-OSS 120B (Medium)', value: 'GPT-OSS 120B (Medium)' }
+                ]),
+                default: 'default'
+              }
+            ]);
+            ideModel = selectedModel;
+          }
+
           const options = { ide };
+          if (ideModel) {
+            options.ideModel = ideModel;
+          }
+          
+          // Set extension for VS Code extensions
+          if (ide === 'amazon-q') {
+            options.extension = 'amazon-q';
+          } else if (ide === 'github-copilot') {
+            options.extension = 'github-copilot';
+          }
+          
           if (maxChats && maxChats.trim() !== '0') {
             options.maxChats = parseInt(maxChats);
           } else {
@@ -4286,6 +5204,21 @@ async function startInteractive() {
             const hostname = getHostname();
             console.log('[DEBUG] Repo:', repoPath, 'Hostname:', hostname);
 
+            // Get current git branch if in a git repo
+            let currentBranch = '';
+            if (repoPath) {
+              try {
+                const { execSync } = require('child_process');
+                currentBranch = execSync('git branch --show-current', {
+                  cwd: repoPath,
+                  encoding: 'utf8'
+                }).trim();
+              } catch (err) {
+                // Not a git repo or git not available
+                currentBranch = '';
+              }
+            }
+
             // Build menu content for header
             const menuContent = `╭───────────────────────────────────────────────────────╮
 │                                                        │
@@ -4295,7 +5228,7 @@ async function startInteractive() {
 ╰───────────────────────────────────────────────────────╯
 
 ${t('system.repo').padEnd(25)} ${repoPath || 'Not set'}
-${t('system.computer.name').padEnd(25)} ${hostname}
+${currentBranch ? t('system.git.branch').padEnd(25) + ' ' + currentBranch + '\n' : ''}${t('system.computer.name').padEnd(25)} ${hostname}
 Current IDE:              ${formatIDEName(ide)}
 AI Provider:              ${getCurrentAIProvider(ide) || 'N/A'}
 Max Chats:                ${maxChats || 'Never stop'}`;
@@ -4343,6 +5276,60 @@ Max Chats:                ${maxChats || 'Never stop'}`;
               });
             }
 
+            // Helper to parse requirements file content
+            const parseRequirementsFile = (content) => {
+              const lines = content.split('\n');
+              let currentRequirement = null;
+              let currentStatus = null;
+
+              // Find current requirement (first one under TODO section)
+              let inTodoSection = false;
+              for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.trim();
+
+                // Check if we're in TODO section
+                if (trimmed.includes('⏳ Requirements not yet completed') || trimmed.includes('Requirements not yet completed')) {
+                  inTodoSection = true;
+                  continue;
+                }
+
+                // Exit TODO section at next ## header
+                if (inTodoSection && trimmed.startsWith('## ') && !trimmed.startsWith('###')) {
+                  break;
+                }
+
+                // Get first requirement in TODO section
+                if (inTodoSection && trimmed.startsWith('### ')) {
+                  currentRequirement = trimmed.replace(/^###\s*/, '').trim();
+                  break;
+                }
+              }
+
+              // Find current status
+              for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.trim();
+
+                if (trimmed.includes('🚦 Current Status') || trimmed.includes('Current Status')) {
+                  // Look for status in next few lines
+                  for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+                    const statusLine = lines[j].trim();
+                    if (statusLine.match(/^(PREPARE|CREATE|ACT|CLEAN UP|VERIFY|DONE)$/i)) {
+                      currentStatus = statusLine.toUpperCase();
+                      break;
+                    }
+                  }
+                  break;
+                }
+              }
+
+              return {
+                currentRequirement: currentRequirement || 'No active requirement',
+                currentStatus: currentStatus || 'PREPARE'
+              };
+            };
+
             // Watch requirements file for changes
             const watcher = chokidar.watch(reqPath, { persistent: true });
             watcher.on('change', async () => {
@@ -4466,7 +5453,49 @@ Max Chats:                ${maxChats || 'Never stop'}`;
   }
 }
 
-module.exports = { startInteractive };
+async function bootstrapProjectIfInHomeDir() {
+  const { checkVibeCodingMachineExists, getRequirementsFilename } = require('vibecodingmachine-core');
+  const exists = await checkVibeCodingMachineExists();
+  const home = os.homedir();
+
+  // If a VibeCodingMachine project already exists nearby, do nothing
+  if (exists && (exists.insideExists || exists.siblingExists)) return;
+
+  // Only bootstrap when we're sitting at the user's home directory (resolve symlinks)
+  try {
+    const cwdResolved = await fs.realpath(process.cwd());
+    const homeResolved = await fs.realpath(home);
+    if (cwdResolved !== homeResolved) return;
+  } catch (e) {
+    // If we can't resolve, fallback to path.resolve comparison
+    if (path.resolve(process.cwd()) !== path.resolve(home)) return;
+  }
+
+  const inquirer = require('inquirer');
+  const { shouldCreateCodeDir } = await inquirer.prompt({ type: 'confirm', name: 'shouldCreateCodeDir', message: t('interactive.should.create.code.dir') });
+  if (!shouldCreateCodeDir) return;
+
+  const { projectName } = await inquirer.prompt({ type: 'input', name: 'projectName', message: t('interactive.project.name') });
+  const slug = (projectName || 'my-project-name').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '') || 'my-project-name';
+  const codeDir = path.join(home, 'code');
+  await fs.ensureDir(codeDir);
+
+  const projectDir = path.join(codeDir, slug);
+  await fs.ensureDir(projectDir);
+
+  process.chdir(projectDir);
+
+  // Create .vibecodingmachine and REQUIREMENTS file if missing
+  const vcmDir = path.join(projectDir, '.vibecodingmachine');
+  await fs.ensureDir(vcmDir);
+  const reqFilename = await getRequirementsFilename();
+  const reqPath = path.join(vcmDir, reqFilename);
+  if (!await fs.pathExists(reqPath)) {
+    await fs.writeFile(reqPath, `# ${projectName}\n\n## ⏳ Requirements not yet completed\n\n`, 'utf8');
+  }
+}
+
+module.exports = { startInteractive, showProviderManagerMenu, /* exported for tests */ parseRequirementsFromContent, bootstrapProjectIfInHomeDir };