vibecodingmachine-cli 2025.12.25-25 → 2026.1.22-1441

package/src/commands/auto-direct.js

@@ -5,7 +5,7 @@
  */
 
 const chalk = require('chalk');
-const { DirectLLMManager, AppleScriptManager, t, detectLocale, setLocale } = require('vibecodingmachine-core');
+const { DirectLLMManager, AppleScriptManager, QuotaDetector, IDEHealthTracker, t, detectLocale, setLocale } = require('vibecodingmachine-core');
 
 // Initialize locale detection for auto mode
 const detectedLocale = detectLocale();
@@ -17,11 +17,13 @@ const path = require('path');
 const { spawn } = require('child_process');
 const chokidar = require('chokidar');
 const stringWidth = require('string-width');
-const { getProviderPreferences, getProviderDefinition } = require('../utils/provider-registry');
+const { getProviderPreferences, getProviderDefinition, saveProviderPreferences } = require('../utils/provider-registry');
 const { createKeyboardHandler } = require('../utils/keyboard-handler');
 const logger = require('../utils/logger');
 const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
 const { checkAntigravityRateLimit, handleAntigravityRateLimit } = require('../utils/antigravity-js-handler');
+const { checkKiroRateLimit, handleKiroRateLimit } = require('../utils/kiro-js-handler');
+const { startAutoMode, stopAutoMode, updateAutoModeStatus } = require('../utils/auto-mode');
 
 // Status management will use in-process tracking instead of external file
 const CLI_ENTRY_POINT = path.join(__dirname, '../../bin/vibecodingmachine.js');
@@ -29,6 +31,16 @@ const CLI_ENTRY_POINT = path.join(__dirname, '../../bin/vibecodingmachine.js');
 // CRITICAL: Shared ProviderManager instance to track rate limits across all function calls
 const sharedProviderManager = new ProviderManager();
 
+// CRITICAL: Shared IDEHealthTracker instance to track IDE reliability across all iterations
+const sharedHealthTracker = new IDEHealthTracker();
+
+// Listen for consecutive failures to warn user
+sharedHealthTracker.on('consecutive-failures', ({ ideId, count, lastError }) => {
+  console.log(chalk.yellow(`\n⚠️  WARNING: ${ideId} has failed ${count} times consecutively`));
+  console.log(chalk.yellow(`   Last error: ${lastError}`));
+  console.log(chalk.yellow(`   Consider switching to a different IDE\n`));
+});
+
 // Configured stages (will be loaded in handleAutoStart)
 let configuredStages = DEFAULT_STAGES;
 
@@ -45,6 +57,22 @@ function getTimestamp() {
   }) + ' MST';
 }
 
+/**
+ * Get a human-friendly timestamp for log prefixes that includes date, time, and timezone
+ * Example: "2025-01-02 3:45 PM MST"
+ */
+function getLogTimestamp(date = new Date()) {
+  const datePart = date.toISOString().split('T')[0]; // YYYY-MM-DD
+  const timePart = date.toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+    timeZone: 'America/Denver',
+    timeZoneName: 'short'
+  });
+  return `${datePart} ${timePart}`;
+}
+
 /**
  * Translate workflow stage names
  */
@@ -378,6 +406,11 @@ async function moveRequirementToVerify(repoPath, requirementText) {
 
     const content = await fs.readFile(reqPath, 'utf8');
     const lines = content.split('\n');
+
+    // Get computer filter from config
+    const { getComputerFilter } = require('../utils/config');
+    const computerFilter = await getComputerFilter();
+
     // Find the requirement by its title (in ### header format)
     // Only look in TODO section
     const normalizedRequirement = requirementText.trim();
@@ -469,175 +502,227 @@ async function moveRequirementToVerify(repoPath, requirementText) {
 
       // Check if we found a requirement in TODO section
       if (inTodoSection && line.startsWith('###')) {
-        hasMoreTodoRequirements = true;
-        break;
+        const title = line.replace(/^###\s*/, '').trim();
+        if (title && title.includes(computerFilter)) {
+          hasMoreTodoRequirements = true;
+          break;
+        }
       }
     }
 
     // If no more TODO requirements, log message
     if (!hasMoreTodoRequirements) {
       console.log(chalk.green(`🎉 ${t('auto.direct.requirement.no.more.todo')}`));
+      // Add a new requirement to the TODO section
+      const newRequirement = '### R14: TESTREQ1';
+      lines.push(newRequirement);
     }
-
-
-
-    // Add AWS Kiro AI IDE GUI and CLI support
-    const kiroAiIdeGuiSupport = '### AWS Kiro AI IDE GUI Support\n\nThis requirement has been moved to the TO VERIFY BY HUMAN section for further review.';
-    const kiroAiIdeCliSupport = '### AWS Kiro AI IDE CLI Support\n\nThis requirement has been moved to the TO VERIFY BY HUMAN section for further review using the CLI.';
-    lines.push(kiroAiIdeGuiSupport);
-    lines.push(kiroAiIdeCliSupport);
-
-    // Check if the requirement is in the Recycled section
-    const recycledIndex = lines.findIndex(line => line.trim() === '## 📦 RECYCLED');
-    if (recycledIndex !== -1) {
-      const recycledBlock = lines.slice(recycledIndex + 1);
-      const requirementIndexInRecycled = recycledBlock.findIndex(line => line.trim().startsWith('###') && line.trim().includes(snippet));
-      if (requirementIndexInRecycled !== -1) {
-        lines.splice(recycledIndex + 1 + requirementIndexInRecycled, 1);
+// Find or create TO VERIFY BY HUMAN section with conflict resolution
+// IMPORTANT: Do NOT match VERIFIED sections - only match TO VERIFY sections
+const verifySectionVariants = [
+  '## 🔍 TO VERIFY BY HUMAN',
+  '## 🔍 TO VERIFY',
+  '## TO VERIFY',
+  '## ✅ TO VERIFY',
+  '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
+  '## 📊 CROSS-COMPUTER REQUIREMENT ASSIGNMENT',
+  '## 🖥️ COMPUTER FOCUS AREA MANAGEMENT',
+  '## 🔍 spec-kit: TO VERIFY BY HUMAN'
+];
+
+let verifyIndex = -1;
+for (let i = 0; i < lines.length; i++) {
+  const line = lines[i];
+  const trimmed = line.trim();
+
+  // Check each variant more carefully
+  for (const variant of verifySectionVariants) {
+    const variantTrimmed = variant.trim();
+    // Exact match or line starts with variant
+    if (trimmed === variantTrimmed || trimmed.startsWith(variantTrimmed)) {
+      // Double-check: make sure it's NOT a VERIFIED section (without TO VERIFY)
+      if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) &&
+        (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot') || trimmed.includes('CROSS-COMPUTER REQUIREMENT ASSIGNMENT') || trimmed.includes('COMPUTER FOCUS AREA MANAGEMENT') || trimmed.includes('spec-kit'))) {
+        verifyIndex = i;
+        break;
       }
     }
+  }
+  if (verifyIndex !== -1) break;
+}
 
-    // Find or create TO VERIFY BY HUMAN section
-    // IMPORTANT: Do NOT match VERIFIED sections - only match TO VERIFY sections
-    const verifySectionVariants = [
-      '## 🔍 TO VERIFY BY HUMAN',
-      '## 🔍 TO VERIFY',
-      '## TO VERIFY',
-      '## ✅ TO VERIFY',
-      '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG'
-    ];
+if (verifyIndex === -1) {
+  // Create TO VERIFY section - place it BEFORE VERIFIED section if one exists, otherwise before CHANGELOG
+  const verifiedIndex = lines.findIndex(line => {
+    const trimmed = line.trim();
+    return trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED') ||
+      (trimmed.startsWith('##') && trimmed.includes('VERIFIED') && !trimmed.includes('TO VERIFY'));
+  });
+  const changelogIndex = lines.findIndex(line => line.includes('## CHANGELOG'));
+  const manualFeedbackIndex = lines.findIndex(line => line.trim().startsWith('## ❓'));
+
+  // Prefer: before VERIFIED > before CHANGELOG > before manual feedback > at end
+  let insertionIndex = lines.length;
+  if (verifiedIndex > 0) {
+    insertionIndex = verifiedIndex;
+  } else if (changelogIndex > 0) {
+    insertionIndex = changelogIndex;
+  } else if (manualFeedbackIndex > 0) {
+    insertionIndex = manualFeedbackIndex;
+  }
 
-    let verifyIndex = -1;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
+  const block = [];
+  if (insertionIndex > 0 && lines[insertionIndex - 1].trim() !== '') {
+    block.push('');
+  }
+  block.push('## 🔍 spec-kit: TO VERIFY BY HUMAN', '### Automatic Registration and Tracking', '### User Registration', '');
+  block.push('## 📊 CROSS-COMPUTER REQUIREMENT ASSIGNMENT');
+  block.push('## 🖥️ COMPUTER FOCUS AREA MANAGEMENT');
+  lines.splice(insertionIndex, 0, ...block);
+  verifyIndex = lines.findIndex(line => {
+    const trimmed = line.trim();
+    return trimmed === '## 🔍 spec-kit: TO VERIFY BY HUMAN' || trimmed.startsWith('## 🔍 spec-kit: TO VERIFY BY HUMAN');
+  });
 
-      // Check each variant more carefully
-      for (const variant of verifySectionVariants) {
-        const variantTrimmed = variant.trim();
-        // Exact match or line starts with variant
-        if (trimmed === variantTrimmed || trimmed.startsWith(variantTrimmed)) {
-          // Double-check: make sure it's NOT a VERIFIED section (without TO VERIFY)
-          if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) &&
-            (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot'))) {
-            verifyIndex = i;
-            break;
-          }
-        }
-      }
-      if (verifyIndex !== -1) break;
-    }
+  // Safety check: verifyIndex should be valid
+  if (verifyIndex === -1) {
+    console.error(t('auto.direct.verify.section.create.failed'));
+    return false;
+  }
+}
 
-    if (verifyIndex === -1) {
-      // Create TO VERIFY section - place it BEFORE VERIFIED section if one exists, otherwise before CHANGELOG
-      const verifiedIndex = lines.findIndex(line => {
-        const trimmed = line.trim();
-        return trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED') ||
-          (trimmed.startsWith('##') && trimmed.includes('VERIFIED') && !trimmed.includes('TO VERIFY'));
-      });
-      const changelogIndex = lines.findIndex(line => line.includes('## CHANGELOG'));
-      const manualFeedbackIndex = lines.findIndex(line => line.trim().startsWith('## ❓'));
-
-      // Prefer: before VERIFIED > before CHANGELOG > before manual feedback > at end
-      let insertionIndex = lines.length;
-      if (verifiedIndex > 0) {
-        insertionIndex = verifiedIndex;
-      } else if (changelogIndex > 0) {
-        insertionIndex = changelogIndex;
-      } else if (manualFeedbackIndex > 0) {
-        insertionIndex = manualFeedbackIndex;
-      }
+// Safety check: verify we're not inserting into a VERIFIED section
+const verifyLine = lines[verifyIndex] || '';
+if (verifyLine.includes('## 📝 VERIFIED') || (verifyLine.trim().startsWith('##') && verifyLine.includes('VERIFIED') && !verifyLine.includes('TO VERIFY'))) {
+  console.error('ERROR: Attempted to insert into VERIFIED section instead of TO VERIFY');
+  return false;
+}
 
-      const block = [];
-      if (insertionIndex > 0 && lines[insertionIndex - 1].trim() !== '') {
-        block.push('');
-      }
-      block.push('## 🔍 TO VERIFY BY HUMAN', '');
-      lines.splice(insertionIndex, 0, ...block);
-      verifyIndex = lines.findIndex(line => {
-        const trimmed = line.trim();
-        return trimmed === '## 🔍 TO VERIFY BY HUMAN' || trimmed.startsWith('## 🔍 TO VERIFY BY HUMAN');
-      });
+// Remove any existing duplicate of this requirement in TO VERIFY section
+// Find the next section header after TO VERIFY
+let nextSectionIndex = lines.length;
+for (let i = verifyIndex + 1; i < lines.length; i++) {
+  const trimmed = lines[i].trim();
+  if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+    nextSectionIndex = i;
+    break;
+  }
+}
 
-      // Safety check: verifyIndex should be valid
-      if (verifyIndex === -1) {
-        console.error(t('auto.direct.verify.section.create.failed'));
-        return false;
+// Search for duplicate requirement in TO VERIFY section
+const requirementTitle = requirementBlock[0].trim().replace(/^###\s*/, '').trim();
+for (let i = verifyIndex + 1; i < nextSectionIndex; i++) {
+  const line = lines[i];
+  const trimmed = line.trim();
+
+  if (trimmed.startsWith('###')) {
+    const existingTitle = trimmed.replace(/^###\s*/, '').trim();
+
+    // Check if this is a duplicate (exact match or contains/contained by)
+    if (existingTitle === requirementTitle ||
+      existingTitle.includes(requirementTitle) ||
+      requirementTitle.includes(existingTitle)) {
+
+      // Find the end of this existing requirement
+      let existingEndIndex = nextSectionIndex;
+      for (let j = i + 1; j < nextSectionIndex; j++) {
+        const nextLine = lines[j].trim();
+        if (nextLine.startsWith('###') || nextLine.startsWith('##')) {
+          existingEndIndex = j;
+          break;
+        }
       }
-    }
-
 
-    // Safety check: verify we're not inserting into a VERIFIED section
-    const verifyLine = lines[verifyIndex] || '';
-    if (verifyLine.includes('## 📝 VERIFIED') || (verifyLine.trim().startsWith('##') && verifyLine.includes('VERIFIED') && !verifyLine.includes('TO VERIFY'))) {
-      console.error('ERROR: Attempted to insert into VERIFIED section instead of TO VERIFY');
-      return false;
-    }
+      // Remove the duplicate
+      lines.splice(i, existingEndIndex - i);
 
-    // Remove any existing duplicate of this requirement in TO VERIFY section
-    // Find the next section header after TO VERIFY
-    let nextSectionIndex = lines.length;
-    for (let i = verifyIndex + 1; i < lines.length; i++) {
-      const trimmed = lines[i].trim();
-      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
-        nextSectionIndex = i;
-        break;
-      }
+      // Adjust nextSectionIndex if needed
+      nextSectionIndex -= (existingEndIndex - i);
+      break;
     }
+  }
+}
 
-    // Search for duplicate requirement in TO VERIFY section
-    const requirementTitle = requirementBlock[0].trim().replace(/^###\s*/, '').trim();
-    for (let i = verifyIndex + 1; i < nextSectionIndex; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
+// Insert requirement block at TOP of TO VERIFY section (right after section header)
+let insertIndex = verifyIndex + 1;
 
-      if (trimmed.startsWith('###')) {
-        const existingTitle = trimmed.replace(/^###\s*/, '').trim();
+// Ensure there's a blank line after the section header
+if (lines[insertIndex]?.trim() !== '') {
+  lines.splice(insertIndex, 0, '');
+  insertIndex++;
+}
 
-        // Check if this is a duplicate (exact match or contains/contained by)
-        if (existingTitle === requirementTitle ||
-          existingTitle.includes(requirementTitle) ||
-          requirementTitle.includes(existingTitle)) {
+// If a Conflict Resolution header already exists immediately after the section header, reuse it
+const conflictHeader = '### Conflict Resolution:';
+if (lines[insertIndex]?.trim().startsWith(conflictHeader)) {
+  // Move insertion point to after the existing header
+  insertIndex++;
+  // Ensure there's a blank line after the header before inserting the requirement
+  if (lines[insertIndex]?.trim() !== '') {
+    lines.splice(insertIndex, 0, '');
+    insertIndex++;
+  }
+} else {
+  // Insert the conflict header
+  lines.splice(insertIndex, 0, conflictHeader);
+  insertIndex++;
+  // Ensure a blank line after the header
+  if (lines[insertIndex]?.trim() !== '') {
+    lines.splice(insertIndex, 0, '');
+    insertIndex++;
+  }
+}
 
-          // Find the end of this existing requirement
-          let existingEndIndex = nextSectionIndex;
-          for (let j = i + 1; j < nextSectionIndex; j++) {
-            const nextLine = lines[j].trim();
-            if (nextLine.startsWith('###') || nextLine.startsWith('##')) {
-              existingEndIndex = j;
-              break;
-            }
-          }
+// Insert the requirement block
+lines.splice(insertIndex, 0, ...requirementBlock);
 
-          // Remove the duplicate
-          lines.splice(i, existingEndIndex - i);
+// Ensure there's a blank line after the requirement block
+const afterIndex = insertIndex + requirementBlock.length;
+if (afterIndex < lines.length && lines[afterIndex]?.trim() !== '') {
+  lines.splice(afterIndex, 0, '');
+}
 
-          // Adjust nextSectionIndex if needed
-          nextSectionIndex -= (existingEndIndex - i);
-          break;
-        }
-      }
+// Move the requirement to the VERIFIED section
+const verifiedSectionVariants = [
+  '## 📝 VERIFIED',
+  '## VERIFIED'
+];
+let verifiedIndex = -1;
+for (let i = 0; i < lines.length; i++) {
+  const line = lines[i];
+  const trimmed = line.trim();
+
+  // Check each variant more carefully
+  for (const variant of verifiedSectionVariants) {
+    const variantTrimmed = variant.trim();
+    // Exact match or line starts with variant
+    if (trimmed === variantTrimmed || trimmed.startsWith(variantTrimmed)) {
+      verifiedIndex = i;
+      break;
     }
+  }
+  if (verifiedIndex !== -1) break;
+}
 
-    // Insert requirement block at TOP of TO VERIFY section (right after section header)
-    // Always insert immediately after the section header with proper blank line spacing
-    let insertIndex = verifyIndex + 1;
+if (verifiedIndex === -1) {
+  // Create VERIFIED section - place it after TO VERIFY section
+  const block = [];
+  block.push('## 📝 VERIFIED');
+  lines.splice(verifyIndex + 1, 0, ...block);
+  verifiedIndex = lines.findIndex(line => {
+    const trimmed = line.trim();
+    return trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED');
+  });
+}
 
-    // Ensure there's a blank line after the section header
-    if (lines[insertIndex]?.trim() !== '') {
-      lines.splice(insertIndex, 0, '');
-      insertIndex++;
-    }
+// Insert the requirement block at the end of the VERIFIED section
+let insertIndexVerified = verifiedIndex + 1;
+while (insertIndexVerified < lines.length && lines[insertIndexVerified].trim().startsWith('###')) {
+  insertIndexVerified++;
+}
+lines.splice(insertIndexVerified, 0, ...requirementBlock);
 
-    // Insert the requirement block with image paste ability
-    const imagePaste = '### Image Paste\n\nYou can paste an image here by using the following format: ![image](image-url)\n\nExample: ![image](https://example.com/image.png)';
-    lines.splice(insertIndex, 0, ...requirementBlock, imagePaste);
 
-    // Ensure there's a blank line after the requirement block
-    const afterIndex = insertIndex + requirementBlock.length + 1;
-    if (afterIndex < lines.length && lines[afterIndex]?.trim() !== '') {
-      lines.splice(afterIndex, 0, '');
-    }
 
     // Write the file
     await fs.writeFile(reqPath, lines.join('\n'));
@@ -793,8 +878,31 @@ async function getAllAvailableProviders() {
       case 'windsurf':
       case 'vscode':
       case 'kiro':
-      case 'antigravity': {
-        providers.push(base);
+      case 'antigravity':
+      case 'github-copilot':
+      case 'amazon-q':
+      case 'replit': {
+        console.log(chalk.gray(`[DEBUG] Processing provider: ${providerId}, extension: ${def.extension}`));
+        if (Array.isArray(def.subAgents) && def.subAgents.length > 0) {
+          for (const sub of def.subAgents) {
+            providers.push({
+              ...base,
+              model: sub.model,
+              subAgentId: sub.id,
+              subAgentName: sub.name,
+              displayName: `${def.name} (${sub.name})`,
+              extension: def.extension
+            });
+          }
+        } else {
+          const providerObj = {
+            ...base,
+            model: def.defaultModel || providerId,
+            extension: def.extension
+          };
+          console.log(chalk.gray(`[DEBUG] Created provider object for ${providerId}:`, JSON.stringify(providerObj, null, 2)));
+          providers.push(providerObj);
+        }
         break;
       }
       case 'ollama': {
@@ -829,7 +937,49 @@ async function getProviderConfig(excludeProvider = null) {
   const config = await getAutoConfig();
   const providerManager = sharedProviderManager; // Use shared instance to persist rate limit state
   const providers = await getAllAvailableProviders();
-  const savedAgent = config.agent || config.ide;
+  const prefs = await getProviderPreferences();
+
+  // Clear any incorrect rate limits for web-based IDEs that were marked due to platform issues
+  for (const provider of providers) {
+    if (provider.provider === 'replit' && providerManager.isRateLimited('replit', 'replit')) {
+      const rateLimitInfo = providerManager.rateLimits['replit:replit'];
+      if (rateLimitInfo) {
+        const now = Date.now();
+        const timeSinceMarked = now - (rateLimitInfo.markedAt || 0);
+        const minutesSinceMarked = timeSinceMarked / (1000 * 60);
+        
+        // Clear rate limit if:
+        // 1. It was marked due to platform issues, OR
+        // 2. It was marked within the last 5 minutes (likely a recent platform issue)
+        const isPlatformError = rateLimitInfo.reason && 
+            (rateLimitInfo.reason.includes('xdg-open') || 
+             rateLimitInfo.reason.includes('command not found') || 
+             rateLimitInfo.reason.includes('Unable to find application'));
+        
+        if (isPlatformError || minutesSinceMarked < 5) {
+          console.log(chalk.yellow(`⚠️  Clearing incorrect rate limit for Replit (marked ${minutesSinceMarked.toFixed(1)} minutes ago: ${isPlatformError ? 'platform error' : 'recent error'})`));
+          delete providerManager.rateLimits['replit:replit'];
+        }
+      }
+    }
+  }
+
+  // Get first ENABLED agent from provider preferences (same logic as interactive menu)
+  let firstEnabledAgent = null;
+  for (const agentId of prefs.order) {
+    if (prefs.enabled[agentId] !== false) {
+      firstEnabledAgent = agentId;
+      break;
+    }
+  }
+  const savedAgent = firstEnabledAgent || config.agent || config.ide;
+  
+  if (process.env.DEBUG_PROVIDER_SELECTION) {
+    console.log(chalk.gray(`[DEBUG] firstEnabledAgent: ${firstEnabledAgent}`));
+    console.log(chalk.gray(`[DEBUG] config.agent: ${config.agent}`));
+    console.log(chalk.gray(`[DEBUG] config.ide: ${config.ide}`));
+    console.log(chalk.gray(`[DEBUG] savedAgent: ${savedAgent}`));
+  }
 
   if (providers.length === 0) {
     return { status: 'no_providers', providers: [] };
@@ -845,17 +995,147 @@ async function getProviderConfig(excludeProvider = null) {
   const availableProviders = enabledProviders.filter(p => {
     // Exclude the specified provider and rate-limited providers
     if (excludeProvider && p.provider === excludeProvider) {
+      if (process.env.DEBUG_PROVIDER_SELECTION) {
+        console.log(chalk.gray(`[DEBUG] Excluding ${p.provider} due to excludeProvider=${excludeProvider}`));
+      }
       return false;
     }
-    return !providerManager.isRateLimited(p.provider, p.model);
+    
+    // For IDE providers, only consider them rate limited if they've actually been used
+    // IDE providers that haven't been used yet should always be available for launch/installation
+    if (p.type === 'ide') {
+      // Check if this IDE provider has been used before by looking for any rate limit entries
+      const hasBeenUsed = providerManager.rateLimits[`${p.provider}:`] || 
+                         Object.keys(providerManager.rateLimits).some(key => key.startsWith(`${p.provider}:`));
+      
+      // Debug: Log IDE provider status
+      if (process.env.DEBUG_PROVIDER_SELECTION) {
+        console.log(chalk.gray(`[DEBUG] IDE Provider ${p.provider}: hasBeenUsed=${hasBeenUsed}, isRateLimited=${providerManager.isRateLimited(p.provider, p.model)}`));
+        console.log(chalk.gray(`[DEBUG] Rate limits for ${p.provider}:`, JSON.stringify(providerManager.rateLimits, null, 2)));
+      }
+      
+      // If it has been used, check if it's currently rate limited
+      if (hasBeenUsed) {
+        const isRateLimited = providerManager.isRateLimited(p.provider, p.model);
+        if (process.env.DEBUG_PROVIDER_SELECTION && isRateLimited) {
+          console.log(chalk.gray(`[DEBUG] ${p.provider} is rate limited, excluding`));
+        }
+        return !isRateLimited;
+      }
+      // If it hasn't been used yet, it's always available
+      if (process.env.DEBUG_PROVIDER_SELECTION) {
+        console.log(chalk.gray(`[DEBUG] ${p.provider} hasn't been used yet, including`));
+      }
+      return true;
+    }
+    
+    // For non-IDE providers, check rate limits normally
+    const isRateLimited = providerManager.isRateLimited(p.provider, p.model);
+    if (process.env.DEBUG_PROVIDER_SELECTION && isRateLimited) {
+      console.log(chalk.gray(`[DEBUG] Non-IDE provider ${p.provider} is rate limited, excluding`));
+    }
+    return !isRateLimited;
   });
 
+  // If no providers are available, try to enable some IDE providers that haven't been used yet
+  if (availableProviders.length === 0) {
+    const allProviders = await getAllAvailableProviders();
+    const unusedIdeProviders = allProviders.filter(p => 
+      p.type === 'ide' && 
+      !enabledProviders.some(ep => ep.provider === p.provider) &&
+      !providerManager.rateLimits[`${p.provider}:`] && 
+      !Object.keys(providerManager.rateLimits).some(key => key.startsWith(`${p.provider}:`))
+    );
+    
+    if (unusedIdeProviders.length > 0) {
+      console.log(chalk.yellow(`⚠️  No enabled providers available. Auto-enabling unused IDE providers...`));
+      const prefs = await getProviderPreferences();
+      
+      // Enable the first few unused IDE providers
+      const providersToEnable = unusedIdeProviders.slice(0, 3);
+      for (const provider of providersToEnable) {
+        prefs.enabled[provider.provider] = true;
+        console.log(chalk.gray(`  ✓ Enabled ${provider.displayName}`));
+      }
+      
+      await saveProviderPreferences(prefs.order, prefs.enabled);
+      
+      // Recalculate available providers with the newly enabled ones
+      const newlyEnabledProviders = allProviders.filter(p => 
+        prefs.enabled[p.provider] !== false
+      );
+      
+      const newlyAvailableProviders = newlyEnabledProviders.filter(p => {
+        // Exclude the specified provider
+        if (excludeProvider && p.provider === excludeProvider) {
+          return false;
+        }
+        
+        // For newly enabled IDE providers, they haven't been used yet, so they're always available
+        if (p.type === 'ide') {
+          return true;
+        }
+        
+        // For non-IDE providers, check rate limits normally
+        return !providerManager.isRateLimited(p.provider, p.model);
+      });
+      
+      // Add the newly available providers to the list
+      availableProviders.push(...newlyAvailableProviders);
+    }
+  }
+
+  // Debug: Log provider selection details
+  if (process.env.DEBUG_PROVIDER_SELECTION || true) { // Force debug for now
+    console.log(chalk.gray(`[DEBUG] Total providers: ${providers.length}`));
+    console.log(chalk.gray(`[DEBUG] Enabled providers: ${enabledProviders.length}`));
+    console.log(chalk.gray(`[DEBUG] Available providers: ${availableProviders.length}`));
+    console.log(chalk.gray(`[DEBUG] Available provider names: ${availableProviders.map(p => p.provider).join(', ')}`));
+    console.log(chalk.gray(`[DEBUG] Enabled provider names: ${enabledProviders.map(p => p.provider).join(', ')}`));
+    console.log(chalk.gray(`[DEBUG] Excluding provider: ${excludeProvider}`));
+    console.log(chalk.gray(`[DEBUG] Looking for savedAgent: ${savedAgent}`));
+  }
+
   let selection = null;
   if (savedAgent && savedAgent !== excludeProvider) {
     selection = availableProviders.find(p => p.provider === savedAgent);
+    if (process.env.DEBUG_PROVIDER_SELECTION) {
+      console.log(chalk.gray(`[DEBUG] Looking for savedAgent: ${savedAgent}`));
+      console.log(chalk.gray(`[DEBUG] Found selection: ${selection ? selection.provider : 'null'}`));
+    }
   }
-  if (!selection) {
-    selection = availableProviders[0] || null;
+  
+  // If no selection or the selected provider is rate limited, try to find an unused IDE provider
+  if (!selection || (selection.type === 'ide' && providerManager.isRateLimited(selection.provider, selection.model))) {
+    if (process.env.DEBUG_PROVIDER_SELECTION) {
+      console.log(chalk.gray(`[DEBUG] No valid selection, trying unused IDE providers`));
+      console.log(chalk.gray(`[DEBUG] Reason: ${!selection ? 'no selection' : 'selection is rate limited'}`));
+    }
+    
+    // Prioritize newly enabled IDE providers that haven't been used
+    const unusedIdeProviders = availableProviders.filter(p => 
+      p.type === 'ide' && 
+      !providerManager.rateLimits[`${p.provider}:`] && 
+      !Object.keys(providerManager.rateLimits).some(key => key.startsWith(`${p.provider}:`))
+    );
+    
+    if (process.env.DEBUG_PROVIDER_SELECTION) {
+      console.log(chalk.gray(`[DEBUG] Unused IDE providers: ${unusedIdeProviders.map(p => p.provider).join(', ')}`));
+    }
+    
+    if (unusedIdeProviders.length > 0) {
+      selection = unusedIdeProviders[0];
+      console.log(chalk.green(`✓ Selected unused IDE provider: ${selection.displayName}`));
+    } else if (availableProviders.length > 0) {
+      selection = availableProviders[0];
+      if (process.env.DEBUG_PROVIDER_SELECTION) {
+        console.log(chalk.gray(`[DEBUG] Selected first available provider: ${selection.provider}`));
+      }
+    }
+  } else if (selection) {
+    if (process.env.DEBUG_PROVIDER_SELECTION) {
+      console.log(chalk.gray(`[DEBUG] Using savedAgent selection: ${selection.provider}`));
+    }
   }
 
   if (selection) {
@@ -879,10 +1159,16 @@ async function getProviderConfig(excludeProvider = null) {
   };
 }
 
-async function acquireProviderConfig(excludeProvider = null) {
+async function acquireProviderConfig(excludeProvider = null, excludeModel = null) {
   while (true) {
     const selection = await getProviderConfig(excludeProvider);
     if (selection.status === 'ok') {
+      // If we have a specific model to exclude (for same-IDE failover), skip it
+      if (excludeModel && selection.provider.model === excludeModel) {
+        console.log(chalk.yellow(`⚠️  Excluding rate-limited sub-agent: ${selection.provider.displayName}\n`));
+        // Retry with the same provider excluded to force picking another sub-agent
+        return acquireProviderConfig(selection.provider.provider, selection.provider.model);
+      }
       return selection.provider;
     }
 
@@ -1329,6 +1615,13 @@ async function runIdeProviderIteration(providerConfig, repoPath) {
     console.log(chalk.cyan(`⚙️  ${t('auto.direct.provider.launching', { provider: providerConfig.displayName })}\n`));
 
     const args = [CLI_ENTRY_POINT, 'auto:start', '--ide', providerConfig.ide || providerConfig.provider, '--max-chats', String(providerConfig.maxChats || 1)];
+    if (providerConfig.model) {
+      args.push('--ide-model', String(providerConfig.model));
+    }
+    // Pass extension information for VS Code extensions
+    if (providerConfig.extension) {
+      args.push('--extension', String(providerConfig.extension));
+    }
     const child = spawn(process.execPath, args, {
       cwd: repoPath,
       env: process.env,
@@ -1363,13 +1656,15 @@ async function runIdeProviderIteration(providerConfig, repoPath) {
       } else {
         const message = `${providerConfig.displayName} exited with code ${code}`;
         const antigravityRateLimit = checkAntigravityRateLimit(combinedOutput);
+        const kiroRateLimit = checkKiroRateLimit(combinedOutput);
 
         resolve({
           success: false,
           error: combinedOutput ? `${message}\n${combinedOutput}` : message,
           output: combinedOutput,
-          rateLimited: isRateLimitMessage(combinedOutput) || antigravityRateLimit.isRateLimited,
-          antigravityRateLimited: antigravityRateLimit.isRateLimited
+          rateLimited: isRateLimitMessage(combinedOutput) || antigravityRateLimit.isRateLimited || kiroRateLimit.isRateLimited,
+          antigravityRateLimited: antigravityRateLimit.isRateLimited,
+          kiroRateLimited: kiroRateLimit.isRateLimited
         });
       }
     });
@@ -1412,7 +1707,7 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
         let foundInVerified = false;
 
         for (const line of lines) {
-          if (line.includes('## ✅ Verified by AI screenshot')) {
+          if (line.includes('## ✅ Verified by AI')) {
             inVerifiedSection = true;
             continue;
           }
@@ -1442,6 +1737,10 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
         for (const line of lines) {
           if (line.includes('🚦 Current Status')) {
             inStatusSection = true;
+            if (line.includes('DONE')) {
+              statusContainsDone = true;
+              break;
+            }
             continue;
           }
 
@@ -1463,21 +1762,72 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
           return;
         }
 
-        // Check 3: Quota limit detection for Antigravity (after 2 minutes of waiting)
-        const elapsed = Date.now() - startTime;
-        if (ideType === 'antigravity' && !quotaHandled && elapsed >= 120000) {
-          console.log(chalk.yellow('\n⚠️  Antigravity quota limit detected after 2 minutes\n'));
-          console.log(chalk.cyan('   Switching to next available IDE agent...\n'));
+        // Check 3: Detect rate-limit messages written into the REQUIREMENTS file
+        // Examples:
+        //  - "You have reached the quota limit for this model. You can resume using this model at 1/19/2026, 4:07:27 PM."
+        //  - "Please try again in 15m5.472s"
+        //  - "Spending cap reached resets Jan 17 at 12pm"
+        //  - "Usage cap reached. Try again in 15 minutes."
+        //  - "You've reached your monthly chat messages quota" (GitHub Copilot)
+        //  - "Upgrade to Copilot Pro" (GitHub Copilot)
+        //  - "wait for your allowance to renew" (GitHub Copilot)
+        const rateLimitPattern = /(quota limit|you have reached( the)? quota|you can resume using this model at|please try again in|try again in|spending cap reached|usage cap( reached)?|you\'ve hit( the)? usage limit|you\u2019ve hit( the)? usage limit|cap reached|limit exceeded|exceeded (quota|limit)|monthly.*quota|upgrade to.*pro|allowance to renew|chat messages quota)/i;
+        // Avoid matching requirement headings or bullets (these may mention "rate limit" as part of the requirement text)
+        const matchedLine = lines.find(l => rateLimitPattern.test(l) && !l.trim().startsWith('###') && !l.trim().startsWith('-'));
+        if (matchedLine) {
+          // Mark the provider as rate limited (if we can) and signal a rate-limited completion
+          try {
+            if (ideType && sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+              sharedProviderManager.markRateLimited(ideType, undefined, matchedLine);
+            }
+          } catch (e) {
+            // Ignore errors from marking rate-limited
+          }
+
           watcher.close();
-          resolve({
-            success: false,
-            reason: 'antigravity-quota',
-            antigravityRateLimited: true  // This triggers switching to next provider
-          });
+          console.log(chalk.yellow(`\n⚠️  Rate limit message detected from IDE: ${matchedLine}\n`));
+          // Return a generic rateLimited flag and include the matched line for diagnostics
+          resolve({ success: false, rateLimited: true, providerRateLimited: ideType || undefined, matchedLine });
           return;
         }
 
-        // Check 4: Timeout
+        // Check 4: Active quota detection via CDP (for VS Code, Cursor, github-copilot, amazon-q)
+        // This actively checks the IDE UI for quota warnings, not just the REQUIREMENTS file
+        if (!quotaHandled && ideType && (ideType === 'vscode' || ideType === 'cursor' || ideType === 'github-copilot' || ideType === 'amazon-q')) {
+          try {
+            const quotaDetector = new QuotaDetector();
+            const ideToCheck = ideType === 'github-copilot' || ideType === 'amazon-q' ? 'vscode' : ideType;
+            const quotaResult = await quotaDetector.detectQuotaWarning(ideToCheck);
+
+            if (quotaResult && quotaResult.hasQuotaWarning) {
+              quotaHandled = true;
+              const quotaMessage = quotaResult.matchedText || 'Quota limit detected in IDE UI';
+
+              // Mark the provider as rate limited
+              try {
+                if (sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
+                  sharedProviderManager.markRateLimited(ideType, undefined, quotaMessage);
+                }
+              } catch (e) {
+                // Ignore errors from marking rate-limited
+              }
+
+              watcher.close();
+              console.log(chalk.yellow(`\n⚠️  Quota warning detected in ${ideToCheck} UI: ${quotaMessage.substring(0, 100)}...\n`));
+              resolve({ success: false, rateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+              return;
+            }
+          } catch (quotaError) {
+            // Quota detection failed - this is non-fatal, continue waiting
+            // Only log errors every 30 seconds to avoid spam
+            if (Date.now() - lastCheckTime >= 30000) {
+              console.log(chalk.gray(`   (Quota detection check failed: ${quotaError.message})`));
+            }
+          }
+        }
+
+        // Check 5: Timeout
+        const elapsed = Date.now() - startTime;
         if (elapsed >= timeoutMs) {
           watcher.close();
           console.log(chalk.yellow(`\n⚠️  Timeout after ${Math.floor(elapsed / 60000)} minutes\n`));
@@ -1532,30 +1882,110 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
 
   if (!ideResult.success) {
     if (ideResult.antigravityRateLimited) {
-      await handleAntigravityRateLimit();
-      return { success: false, error: 'Antigravity rate limit detected, retrying with next provider.', shouldRetry: true };
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+      const switchResult = await handleAntigravityRateLimit();
+      if (switchResult && switchResult.modelSwitched) {
+        return { success: false, error: `Antigravity switched to ${switchResult.nextModel}, retrying.`, shouldRetry: true };
+      }
+      return { success: false, error: 'Antigravity rate limit reached, retrying with next provider.', shouldRetry: true };
     }
+    
     // CRITICAL: Mark provider as unavailable for ANY error so acquireProviderConfig() will skip it
-    providerManager.markRateLimited(providerConfig.provider, providerConfig.model, ideResult.output || ideResult.error || 'IDE provider failed');
+    // EXCEPT for web-based IDEs where the error is platform/browser related
+    const error = ideResult.output || ideResult.error || 'IDE provider failed';
+    const isWebBasedIDE = providerConfig.provider === 'replit';
+    const isPlatformError = error.includes('xdg-open') || error.includes('command not found') || error.includes('Unable to find application');
+    
+    if (!isWebBasedIDE || !isPlatformError) {
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, error);
+    } else {
+      // For web-based IDEs with platform errors, don't mark as rate limited
+      // Just log the error and let the system try the next provider
+      console.log(chalk.yellow(`⚠️  Web-based IDE ${providerConfig.provider} failed due to platform issue: ${error}`));
+    }
+    
     return { success: false, error: ideResult.error || 'IDE provider failed' };
   }
 
   console.log(chalk.green(`✓ ${t('auto.direct.ide.prompt.sent')}`));
 
   // Wait for IDE agent to complete the work (IDE will update status to DONE itself)
+  const ideCompletionStartTime = Date.now();
   const completionResult = await waitForIdeCompletion(repoPath, requirement.text, providerConfig.ide || providerConfig.provider);
+  const ideResponseTime = Date.now() - ideCompletionStartTime;
+
+  // Track IDE health metrics based on completion result
+  const ideType = providerConfig.ide || providerConfig.provider;
+  if (completionResult.success) {
+    // Record success with response time
+    await sharedHealthTracker.recordSuccess(ideType, ideResponseTime, {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+      continuationPromptsDetected: 0, // Will be updated when continuation detection is implemented
+    });
+  } else if (completionResult.rateLimited) {
+    // Record quota event (does NOT increment success/failure counters per FR-008)
+    await sharedHealthTracker.recordQuota(ideType, completionResult.matchedLine || 'Quota limit detected', {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+    });
+  } else if (completionResult.reason === 'timeout') {
+    // Record failure due to timeout
+    await sharedHealthTracker.recordFailure(ideType, 'Timeout exceeded', {
+      timeoutUsed: 30 * 60 * 1000, // Default 30 minutes, will be adaptive later
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+    });
+  } else {
+    // Record other failure
+    await sharedHealthTracker.recordFailure(ideType, completionResult.error || 'Unknown error', {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+    });
+  }
 
   if (!completionResult.success) {
+    // Special-case behavior for Antigravity CLI installs (they have special handling)
     if (completionResult.antigravityRateLimited) {
       console.log(chalk.yellow(`⚠️  ${t('auto.direct.provider.quota.exhausted', { provider: 'Antigravity' })}\n`));
       providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+
+      const switchResult = await handleAntigravityRateLimit();
+      if (switchResult && switchResult.modelSwitched) {
+        return { success: false, error: `Antigravity switched to ${switchResult.nextModel}, retrying.`, shouldRetry: true };
+      }
+
       return { success: false, error: 'Antigravity quota limit', shouldRetry: true };
     }
 
+    // Special-case behavior for Kiro IDE (they have special handling)
+    if (completionResult.kiroRateLimited) {
+      console.log(chalk.yellow(`⚠️  ${t('auto.direct.provider.quota.exhausted', { provider: 'AWS Kiro' })}\n`));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+
+      const switchResult = await handleKiroRateLimit();
+      if (switchResult && switchResult.success) {
+        return { success: false, error: `AWS Kiro switched to ${switchResult.nextProvider}, retrying.`, shouldRetry: true };
+      }
+
+      return { success: false, error: 'AWS Kiro quota limit', shouldRetry: true };
+    }
+
+    // Generic rate-limited behavior: if the completion detected a rate-limited message in REQUIREMENTS,
+    // mark the provider as rate-limited and retry with the next available provider.
+    if (completionResult.rateLimited) {
+      console.log(chalk.yellow(`⚠️  Provider ${providerConfig.provider} reported quota/exhaustion: ${completionResult.matchedLine || ''}\n`));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, completionResult.matchedLine || 'Quota limit detected');
+      return { success: false, error: 'Provider quota limit', shouldRetry: true };
+    }
+
     const errorMsg = completionResult.reason === 'timeout'
       ? 'IDE agent timed out'
       : 'IDE agent failed to complete';
     providerManager.markRateLimited(providerConfig.provider, providerConfig.model, errorMsg);
+
+    // Automatically retry with next IDE on timeout (T024: automatic IDE switching)
+    if (completionResult.reason === 'timeout') {
+      console.log(chalk.yellow(`⏰ Timeout detected - switching to next available IDE\n`));
+      return { success: false, error: errorMsg, shouldRetry: true };
+    }
+
     return { success: false, error: errorMsg };
   }
 
@@ -1624,7 +2054,10 @@ async function runIteration(requirement, providerConfig, repoPath) {
   // ═══════════════════════════════════════════════════════════
   printStatusCard(requirement.text, 'ACT');
 
-  console.log(chalk.cyan('🤖 Asking LLM for implementation...\n'));
+  console.log(chalk.cyan(` ${getLogTimestamp()} - 🤖 Asking LLM for implementation...\n`));
+  console.log(chalk.gray('─'.repeat(80)));
+  console.log(chalk.yellow('💭 LLM Response (streaming):'));
+  console.log(chalk.gray('─'.repeat(80)));
 
   // Build context with actual file snippets
   let contextSection = '';
@@ -1743,27 +2176,97 @@ if (counts.todoCount === 0) {
 Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
 
   let fullResponse = '';
+  let chunkCount = 0;
+  let totalChars = 0;
+
+  // Show spinner while waiting for first chunk
+  const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let spinnerIndex = 0;
+  let spinnerInterval = null;
+  let receivedFirstChunk = false;
+
+  const startSpinner = () => {
+    process.stdout.write(chalk.cyan('⏳ Waiting for response'));
+    spinnerInterval = setInterval(() => {
+      process.stdout.write(`\r${chalk.cyan('⏳ Waiting for response')} ${chalk.yellow(spinnerFrames[spinnerIndex])}`);
+      spinnerIndex = (spinnerIndex + 1) % spinnerFrames.length;
+    }, 100);
+  };
+
+  const stopSpinner = () => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+      spinnerInterval = null;
+      process.stdout.write('\r\x1b[K'); // Clear the line
+    }
+  };
+
+  startSpinner();
 
   const result = await llm.call(providerConfig, prompt, {
     temperature: 0.1,
     maxTokens: 4096,
     onChunk: (chunk) => {
-      process.stdout.write(chalk.gray(chunk));
+      chunkCount++;
+      totalChars += chunk.length;
+      // Show first chunk arrival to confirm streaming started
+      if (chunkCount === 1) {
+        stopSpinner();
+        receivedFirstChunk = true;
+        process.stdout.write(chalk.green('✓ Streaming started...\n'));
+      }
+      // Use white text for better visibility instead of gray
+      process.stdout.write(chalk.white(chunk));
       fullResponse += chunk;
     },
     onComplete: () => {
-      console.log('\n');
+      stopSpinner();
+      if (chunkCount > 0) {
+        console.log(chalk.green(`\n✓ Received ${totalChars} characters in ${chunkCount} chunks`));
+      } else {
+        console.log(chalk.yellow('\n⚠️  No streaming response received (using complete response)'));
+      }
+      console.log(chalk.gray('─'.repeat(80)));
+      console.log();
     },
     onError: (error) => {
+      stopSpinner();
       console.error(chalk.red(`\n✗ Error: ${error}`));
     }
   });
 
+  // Ensure spinner is stopped even if callbacks didn't fire
+  stopSpinner();
+
   if (!result.success) {
     const combinedError = [result.error, fullResponse].filter(Boolean).join('\n').trim() || 'Unknown error';
     console.log(chalk.red(`\n✗ LLM call failed: ${combinedError}`));
     // CRITICAL: Mark provider as rate-limited for ANY error so acquireProviderConfig() will skip it
     providerManager.markRateLimited(providerConfig.provider, providerConfig.model, combinedError);
+
+    // Track health metrics for failed direct providers
+    const providerType = providerConfig.provider;
+    const duration = Date.now() - startTime;
+    try {
+      // Detect quota/rate limit errors vs other failures
+      const quotaPattern = /(quota|rate.?limit|usage.?limit|spending.?cap|allowance|exceeded|overloaded)/i;
+      const isQuotaError = quotaPattern.test(combinedError);
+
+      if (isQuotaError) {
+        await sharedHealthTracker.recordQuota(providerType, combinedError, {
+          requirementId: requirement.id || requirement.text.substring(0, 50),
+        });
+      } else {
+        await sharedHealthTracker.recordFailure(providerType, combinedError, {
+          timeoutUsed: duration,
+          requirementId: requirement.id || requirement.text.substring(0, 50),
+        });
+      }
+    } catch (healthError) {
+      // Don't fail the iteration if health tracking fails
+      console.log(chalk.gray(`⚠️  Health tracking error: ${healthError.message}`));
+    }
+
     return { success: false, error: combinedError };
   }
 
@@ -1890,6 +2393,18 @@ Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
   const duration = Date.now() - startTime;
   providerManager.recordPerformance(providerConfig.provider, providerConfig.model, duration);
 
+  // Track health metrics for direct providers (IDE providers tracked in runIdeFallbackIteration)
+  const providerType = providerConfig.provider;
+  try {
+    await sharedHealthTracker.recordSuccess(providerType, duration, {
+      requirementId: requirement.id || requirement.text.substring(0, 50),
+      continuationPromptsDetected: 0,
+    });
+  } catch (healthError) {
+    // Don't fail the iteration if health tracking fails
+    console.log(chalk.gray(`⚠️  Health tracking error: ${healthError.message}`));
+  }
+
   console.log();
   console.log(chalk.gray('─'.repeat(80)));
   console.log();
@@ -1920,10 +2435,6 @@ async function handleAutoStart(options) {
     console.log(chalk.gray('═'.repeat(80)));
     console.log();
 
-    // Get repo path
-    // Load configured stages
-    configuredStages = await getStages();
-
     const repoPath = await getRepoPath();
     if (!repoPath) {
       console.log(chalk.red('✗ No repository configured'));
@@ -1931,14 +2442,25 @@ async function handleAutoStart(options) {
       return;
     }
 
-    console.log(chalk.white(t('auto.repository')), chalk.cyan(repoPath));
+    // Start Auto Mode status tracking
+    const config = await getAutoConfig();
+    
+    // Save extension to config if provided
+    if (options.extension) {
+      config.extension = options.extension;
+      await setAutoConfig(config);
+    }
+    
+    await startAutoMode(repoPath, { ide: options.ide || config.ide });
+
+    // Also load configured stages here since we already have the config
+    configuredStages = await getStages();
 
-    // Get effective agent using centralized selector
-    const { getEffectiveAgent } = require('../utils/agent-selector');
-    const { PROVIDER_DEFINITIONS } = require('../utils/provider-registry');
-    const PROVIDER_DEFINITION_MAP = new Map(PROVIDER_DEFINITIONS.map(def => [def.id, def]));
+    console.log(chalk.white(t('auto.repository')), chalk.cyan(repoPath));
 
-    const { effectiveAgent } = await getEffectiveAgent(options, PROVIDER_DEFINITIONS, PROVIDER_DEFINITION_MAP);
+    // Use the agent that was already determined by provider preferences in interactive.js
+    // No need to call getEffectiveAgent since we already have the correct agent
+    const effectiveAgent = options.ide;
 
     // Get provider configuration for the selected agent
     let providerConfig = await acquireProviderConfig(effectiveAgent);
@@ -1948,11 +2470,13 @@ async function handleAutoStart(options) {
 
     console.log(chalk.white('Provider:'), chalk.cyan(providerConfig.displayName));
 
-    // Get max chats
-    const config = await getAutoConfig();
+    // Get max chats (use already loaded config)
     const unlimited = !options.maxChats && !config.maxChats && config.neverStop;
     const maxChats = unlimited ? Number.MAX_SAFE_INTEGER : (options.maxChats || config.maxChats || 1);
     console.log(chalk.white(`${t('auto.direct.config.max.iterations')}`), unlimited ? chalk.cyan('∞ (never stop)') : chalk.cyan(maxChats));
+
+    // Update initial status
+    await updateAutoModeStatus(repoPath, { chatCount: 0, maxChats: unlimited ? 0 : maxChats });
     console.log();
     console.log(chalk.gray('═'.repeat(80)));
 
@@ -1963,6 +2487,9 @@ async function handleAutoStart(options) {
     // Main loop
     let completedCount = 0;
     let failedCount = 0;
+    let providerAttempts = 0; // Track attempts for current requirement
+    let lastRequirementText = null; // Track which requirement we're on
+    const MAX_PROVIDER_ATTEMPTS = 3; // Maximum times to try different providers for same requirement
 
     for (let i = 0; i < maxChats; i++) {
       // Get current requirement first to check if there are any TODO items
@@ -1973,6 +2500,32 @@ async function handleAutoStart(options) {
         break;
       }
 
+      // Check if this is a new requirement or the same one we're retrying
+      if (requirement.text !== lastRequirementText) {
+        // New requirement - reset attempt counter
+        providerAttempts = 0;
+        lastRequirementText = requirement.text;
+      }
+
+      // Increment attempt counter
+      providerAttempts++;
+
+      // Check if we've exceeded maximum attempts for this requirement
+      if (providerAttempts > MAX_PROVIDER_ATTEMPTS) {
+        console.log(chalk.red(`\n✗ Maximum provider attempts (${MAX_PROVIDER_ATTEMPTS}) reached for this requirement`));
+        console.log(chalk.yellow('  All available providers have failed or are rate limited'));
+        console.log(chalk.gray('  Skipping this requirement and moving to next...\n'));
+
+        // Mark requirement as failed and move on
+        failedCount++;
+        providerAttempts = 0;
+        lastRequirementText = null;
+
+        // Move requirement to a "Failed" or "Needs Review" section
+        // For now, just continue to next iteration without decrementing i
+        continue;
+      }
+
       // Calculate current requirement number consistently (before processing)
       // This represents which requirement we're working on (1-based)
       const currentReqNumber = completedCount + failedCount + 1;
@@ -1981,11 +2534,16 @@ async function handleAutoStart(options) {
       console.log(chalk.bold.magenta(`  ${t('auto.direct.requirement.header', { current: currentReqNumber, total: initialEffectiveMax })}`));
       console.log(chalk.bold.magenta(`${'━'.repeat(80)}\n`));
 
+      // Update Auto Mode status with current iteration
+      await updateAutoModeStatus(repoPath, { chatCount: currentReqNumber });
+
       // Run iteration with full workflow
       const result = await runIteration(requirement, providerConfig, repoPath);
 
       if (result.success) {
         completedCount++;
+        providerAttempts = 0; // Reset attempts on success
+        lastRequirementText = null;
         console.log(chalk.bold.green(`✅ Requirement ${currentReqNumber}/${initialEffectiveMax} COMPLETE`));
         console.log(chalk.gray('Moving to next requirement...\n'));
 
@@ -2021,6 +2579,7 @@ async function handleAutoStart(options) {
           await new Promise(resolve => setTimeout(resolve, 300));
 
           // Exit this process - child continues with terminal
+          await stopAutoMode('restarting');
           process.exit(0);
         } else {
           // Small delay before next iteration (if not restarting)
@@ -2038,7 +2597,7 @@ async function handleAutoStart(options) {
 
         console.log(chalk.yellow(`⚠️  ${errorType} detected, switching to next provider in your list...\n`));
 
-        const newProviderConfig = await acquireProviderConfig(providerConfig.provider);
+        const newProviderConfig = await acquireProviderConfig(providerConfig.provider, providerConfig.model);
         if (newProviderConfig) {
           providerConfig = newProviderConfig;
           console.log(chalk.yellow(`⚠️  ${failedProvider} hit ${errorType.toLowerCase()}`));
@@ -2079,14 +2638,20 @@ async function handleAutoStart(options) {
       console.log(chalk.bold.green(`🎉 ${t('auto.direct.summary.final.message', { count: completedCount, plural: completedCount > 1 ? 's' : '' })}`));
     }
 
+    // Stop Auto Mode status tracking
+    await stopAutoMode('completed');
+
   } catch (error) {
     console.error(chalk.red('\n' + t('auto.fatal.error')), error.message);
     if (error.stack) {
       console.log(chalk.gray(error.stack));
     }
+
+    // Stop Auto Mode status tracking on fatal error
+    await stopAutoMode('error');
     process.exit(1);
   }
 }
 
-module.exports = { handleAutoStart };
+module.exports = { handleAutoStart, waitForIdeCompletion, acquireProviderConfig };