vibecodingmachine-cli 2026.1.3-2209 → 2026.1.22-1441

package/src/utils/interactive.js

@@ -10,7 +10,7 @@ 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 {
@@ -21,15 +21,43 @@ 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')
@@ -52,10 +80,12 @@ async function checkAppOrBinary(names = [], binaries = []) {
                   // Prefer to ensure the app is usable: use spctl to assess, fallback to quarantine xattr
                   try {
                     // spctl returns non-zero on rejected/invalid apps
-                    execSync(`spctl --assess -v "${p}"`, { stdio: 'ignore', timeout: 5000 });
+                    // 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 {
-                      execSync(`codesign -v --deep --strict "${p}"`, { stdio: 'ignore', timeout: 5000 });
+                      await execAsync(`codesign -v --deep --strict "${p}"`, { timeout: 5000 });
                       return true;
                     } catch (csErr) {
                       // codesign failed or timed out — treat as not usable/damaged
@@ -64,7 +94,8 @@ async function checkAppOrBinary(names = [], binaries = []) {
                   } catch (e) {
                     // spctl failed or timed out — check if app has quarantine attribute
                     try {
-                      const out = execSync(`xattr -p com.apple.quarantine "${p}" 2>/dev/null || true`, { encoding: 'utf8' }).trim();
+                      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;
@@ -91,7 +122,7 @@ async function checkAppOrBinary(names = [], binaries = []) {
   // Check PATH for known binaries
   for (const bin of binaries) {
     try {
-      execSync(`which ${bin}`, { stdio: 'ignore' });
+      await execAsync(`which ${bin}`, { timeout: 2000 });
       return true;
     } catch (e) {
       /* not found */
@@ -130,78 +161,6 @@ function translateStage(stage) {
   return key ? t(key) : stage;
 }
 
-function normalizeProjectDirName(input) {
-  const s = String(input || '').trim().toLowerCase();
-  const replaced = s.replace(/\s+/g, '-');
-  const cleaned = replaced.replace(/[^a-z0-9._-]/g, '-');
-  const collapsed = cleaned.replace(/-+/g, '-').replace(/^[-._]+|[-._]+$/g, '');
-  return collapsed || 'my-project';
-}
-
-async function bootstrapProjectIfInHomeDir() {
-  let cwdResolved = path.resolve(process.cwd());
-  let homeResolved = path.resolve(os.homedir());
-
-  try {
-    cwdResolved = await fs.realpath(cwdResolved);
-  } catch (err) {
-    // Ignore
-  }
-
-  try {
-    homeResolved = await fs.realpath(homeResolved);
-  } catch (err) {
-    // Ignore
-  }
-
-  if (cwdResolved !== homeResolved) {
-    return;
-  }
-
-  const codeDir = path.join(homeResolved, 'code');
-  const codeDirExists = await fs.pathExists(codeDir);
-
-  if (!codeDirExists) {
-    const { shouldCreateCodeDir } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'shouldCreateCodeDir',
-        message: `No code directory found at ${codeDir}. Would you like to create it?`,
-        default: true
-      }
-    ]);
-
-    if (!shouldCreateCodeDir) {
-      return;
-    }
-
-    await fs.ensureDir(codeDir);
-  }
-
-  const { projectName } = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'projectName',
-      message: 'What is the project name you want to create?',
-      validate: (value) => {
-        const trimmed = String(value || '').trim();
-        return trimmed.length > 0 || 'Please enter a project name.';
-      }
-    }
-  ]);
-
-  const dirName = normalizeProjectDirName(projectName);
-  const projectDir = path.join(codeDir, dirName);
-  await fs.ensureDir(projectDir);
-
-  process.chdir(projectDir);
-  try {
-    await writeConfig({ ...(await readConfig()), repoPath: projectDir });
-  } catch (err) {
-    // Best-effort: interactive mode will still use process.cwd()
-  }
-}
-
 /**
  * Format IDE name for display
  * @param {string} ide - Internal IDE identifier
@@ -507,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')),
     {
@@ -518,6 +477,9 @@ 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));
@@ -606,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 },
@@ -725,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
@@ -1203,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
@@ -1279,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();
@@ -1627,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' }
   ];
 
@@ -1657,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}`));
@@ -1688,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;
 
@@ -1699,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();
@@ -1716,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' }
   ];
 
@@ -1745,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
@@ -1789,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') {
@@ -1849,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));
@@ -2641,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');
@@ -2739,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) => {
@@ -2750,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) => {
@@ -2889,7 +2941,30 @@ async function showQuickMenu(items, initialSelectedIndex = 0) {
       process.stdin.setRawMode(true);
     }
 
+    // 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);
+
     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;
+      }
+
+      // Debounce: ignore inputs until the short window passes
+      if (Date.now() < ignoreInputUntil) {
+        return;
+      }
+
       if (!key) return;
 
       // Ctrl+C to exit
@@ -2911,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 });
@@ -2970,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();
@@ -2979,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';
 
@@ -2994,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)
@@ -3012,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'));
 
@@ -3031,91 +3226,137 @@ async function showProviderManagerMenu() {
       const isSelected = idx === selectedIndex;
       const isEnabled = enabled[id] !== false;
 
-      // Check installation status for all IDEs
-      let isInstalled = true;
-      if (def.type === 'ide') {
-        try {
-          if (id === 'kiro') {
-            const { isKiroInstalled } = require('./kiro-installer');
-            isInstalled = isKiroInstalled();
-          } else if (id === 'cursor') {
-            isInstalled = await checkAppOrBinary(['Cursor'], ['cursor']);
-          } else if (id === 'windsurf') {
-            isInstalled = await checkAppOrBinary(['Windsurf'], ['windsurf']);
-          } else if (id === 'vscode') {
-            isInstalled = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
-          } else if (id === 'antigravity') {
-            isInstalled = await checkAppOrBinary(['Antigravity'], ['antigravity']);
-          } else {
-            // For other IDEs, try binary name same as id
-            isInstalled = await checkAppOrBinary([], [id]);
-          }
-        } catch (e) {
-          // If detection fails, assume not installed
-          isInstalled = false;
-        }
-      }
+      // 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, not installed = yellow, enabled = green
       let statusEmoji;
+      let statusText = '';
+
       if (!isEnabled) {
-        statusEmoji = '🚨'; // Red for disabled
-      } else if (def.type === 'ide' && !isInstalled) {
-        statusEmoji = '🟡'; // Yellow for not installed
+        statusEmoji = '🚫'; // Disabled
+      } else if (!isInstalled) {
+        statusEmoji = '⬜'; // Not installed
       } else {
-        statusEmoji = '🟢'; // Green for enabled and installed (or LLM)
-      }
+        // 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
+      }
 
-        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'}`);
+      // 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)
+      }
+
+      // 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();
@@ -3126,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;
@@ -3133,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);
       }
@@ -3169,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);
@@ -3200,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);
@@ -3225,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:
@@ -3252,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',
@@ -3290,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
  */
@@ -3646,36 +4168,8 @@ async function startInteractive() {
   const { stopAutoMode } = require('./auto-mode');
   await stopAutoMode('startup');
 
-  await bootstrapProjectIfInHomeDir();
-
   await showWelcomeScreen();
 
-  // Check if .vibecodingmachine directory exists, offer to create if not
-  const allnightStatusCheck = await checkVibeCodingMachineExists();
-  if (!allnightStatusCheck.insideExists && !allnightStatusCheck.siblingExists) {
-    console.log(chalk.yellow('\n⚠️  No .vibecodingmachine directory found'));
-    console.log(chalk.gray('This directory is needed to save requirements and track progress.\n'));
-    
-    const { shouldInit } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'shouldInit',
-        message: 'Would you like to create the .vibecodingmachine directory now?',
-        default: true
-      }
-    ]);
-    
-    if (shouldInit) {
-      // Use the initRepo function to create the directory
-      const { initRepo } = require('../commands/repo');
-      await initRepo({ location: 'inside' });
-      console.log('');
-    } else {
-      console.log(chalk.yellow('\n⚠️  Warning: Without the .vibecodingmachine directory, requirements cannot be saved.'));
-      console.log(chalk.gray('You can create it later by running: ') + chalk.cyan('vcm repo:init\n'));
-    }
-  }
-
   if (process.env.VCM_OPEN_PROVIDER_MENU === '1' || process.env.VCM_OPEN_PROVIDER_MENU === 'true') {
     await showProviderManagerMenu();
     return;
@@ -3753,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)}`;
+                }
               }
             }
           }
@@ -3871,181 +4354,18 @@ async function startInteractive() {
         value: 'setting:stages'
       });
 
-      // Add Admin Dashboard - Multi-Computer Dashboard
-      items.push({
-        type: 'setting',
-        name: `  └─ Admin Dashboard: ${chalk.cyan('Multi-Computer Dashboard')}`,
-        value: 'setting:admin-dashboard-multi-computer'
-      });
-
-      // Add Admin Dashboard - Compliance and Terms Tracking
-      items.push({
-        type: 'setting',
-        name: `  └─ Admin Dashboard: ${chalk.cyan('Compliance and Terms Tracking')}`,
-        value: 'setting:admin-dashboard-compliance'
-      });
-
-      // Add Admin Dashboard - Authentication and Security
-      items.push({
-        type: 'setting',
-        name: `  └─ Admin Dashboard: ${chalk.cyan('Authentication and Security')}`,
-        value: 'setting:admin-dashboard-auth'
-      });
-
-      // Add Admin Dashboard - Terms and Privacy Policy
-      items.push({
-        type: 'setting',
-        name: `  └─ Admin Dashboard: ${chalk.cyan('Terms and Privacy Policy')}`,
-        value: 'setting:admin-dashboard-terms'
-      });
-
-      // Add Admin Dashboard - Deployment and Infrastructure
-      items.push({
-        type: 'setting',
-        name: `  └─ Admin Dashboard: ${chalk.cyan('Deployment and Infrastructure')}`,
-        value: 'setting:admin-dashboard-deployment'
-      });
-
-      // Add Cloud Sync Infrastructure - AWS DynamoDB Setup
-      items.push({
-        type: 'setting',
-        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('AWS DynamoDB Setup')}`,
-        value: 'setting:cloud-sync-dynamodb'
-      });
-
-      // Add Cloud Sync Infrastructure - Lambda Functions
-      items.push({
-        type: 'setting',
-        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('Lambda Functions')}`,
-        value: 'setting:cloud-sync-lambda'
-      });
-
-      // Add Cloud Sync Infrastructure - API Gateway Setup
-      items.push({
-        type: 'setting',
-        name: `  └─ Cloud Sync: ${chalk.cyan('AWS DynamoDB Setup')}`,
-        value: 'setting:cloud-sync-dynamodb'
-      });
-
-      // Add Cloud Sync Infrastructure - AWS API Gateway
-      items.push({
-        type: 'setting',
-        name: `  └─ Cloud Sync: ${chalk.cyan('AWS API Gateway')}`,
-        value: 'setting:cloud-sync-api-gateway'
-      });
-
-      // Add Cloud Sync Infrastructure - AWS Cognito Authentication
-      items.push({
-        type: 'setting',
-        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('AWS Cognito Authentication')}`,
-        value: 'setting:cloud-sync-cognito'
-      });
-
-      // Add Cloud Sync Infrastructure - AWS DynamoDB Setup
       items.push({
         type: 'setting',
-        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('AWS DynamoDB Setup')}`,
-        value: 'setting:cloud-sync-dynamodb'
+        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'
       });
 
-      // Cloud Sync Status
-      try {
-        const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
-        const syncEngine = new SyncEngine();
-
-        // Try to initialize, but don't fail if AWS not configured
-        try {
-          await syncEngine.initialize();
-          const syncStatus = syncEngine.getStatus();
-          syncEngine.stop();
-
-          const onlineIcon = syncStatus.isOnline ? chalk.green('●') : chalk.red('●');
-          const onlineText = syncStatus.isOnline ? 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'
-        });
-      }
-
-      // Computer and Usage Tracking Status
-      try {
-        const os = require('os');
-        const hostname = os.hostname();
-        const platform = os.platform();
-        const arch = os.arch();
-        const usageIcon = chalk.blue('●');
-        const trackingText = `${hostname} (${platform}/${arch})`;
-
-        items.push({
-          type: 'setting',
-          name: `${t('interactive.usage.tracking') || 'Usage Tracking'}: ${usageIcon} ${chalk.cyan(trackingText)}`,
-          value: 'setting:usage-tracking'
-        });
-      } catch (error) {
-        // Tracking info unavailable
-        items.push({
-          type: 'setting',
-          name: `Usage Tracking: ${chalk.gray('● Unavailable')}`,
-          value: 'setting:usage-tracking'
-        });
-      }
-
-      // Add requirement number tracking status
       items.push({
         type: 'setting',
-        name: `  └─ ${t('interactive.requirements.tracking')}: ${counts ? chalk.green('✓ ENABLED') : chalk.red('🛑 DISABLED')}`,
-        value: 'setting:requirements-tracking'
+        name: `  └─ ${t('interactive.feedback')}: ${chalk.cyan('📣 Press Ctrl+F for feedback')}`,
+        value: 'setting:feedback'
       });
-      const { readConfig } = require('./config');
-      const config = await readConfig();
-      const lastReqNumber = config.lastRequirementNumber || 0;
-      items.push({
-        type: 'setting',
-        name: `  └─ ${t('interactive.last.requirement.number')}: ${chalk.cyan('R' + lastReqNumber)}`,
-        value: 'setting:req-number'
-      });
-
-      // Add "Next TODO Requirement" as a separate menu item if there are TODO items
-      if (counts && counts.todoCount > 0) {
-        items.push({
-          type: 'setting',
-          name: `  └─ ${t('interactive.next.todo.requirement')}`,
-          value: 'setting:next-todo-requirement'
-        });
-      }
 
-      // Save last tab opened
-      const lastTabOpened = config.lastTabOpened;
-      if (lastTabOpened) {
-        items.push({
-          type: 'setting',
-          name: `  └─ ${t('interactive.last.tab.opened')}: ${lastTabOpened}`,
-          value: 'setting:last-tab-opened'
-        });
-      }
-      items.push({
-        type: 'setting',
-        name: `Start Auto: Switch to Console tab`,
-        value: 'setting:start-auto'
-      });
       // TODO: Implement getNextTodoRequirement function
       // if (counts && counts.todoCount > 0) {
       //   const { getNextTodoRequirement } = require('./auto-mode');
@@ -4069,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');
@@ -4178,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
@@ -4557,6 +4890,12 @@ async function startInteractive() {
 
               // Use saved maxChats/neverStop settings
               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) {
@@ -4578,7 +4917,7 @@ async function startInteractive() {
                 // ALWAYS use auto:direct (supports both LLM and IDE agents with proper looping)
                 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('');
@@ -4793,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'
             },
@@ -4805,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 {
@@ -4899,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 () => {
@@ -5022,11 +5453,49 @@ Max Chats:                ${maxChats || 'Never stop'}`;
   }
 }
 
-module.exports = {
-  startInteractive,
-  bootstrapProjectIfInHomeDir,
-  normalizeProjectDirName
-};
+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 };