vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-426

package/src/commands/auto-direct.js

@@ -10,7 +10,7 @@ const { DirectLLMManager, AppleScriptManager, QuotaDetector, IDEHealthTracker, t
 // Initialize locale detection for auto mode
 const detectedLocale = detectLocale();
 setLocale(detectedLocale);
-const { getRepoPath, getAutoConfig, setAutoConfig, getStages, DEFAULT_STAGES } = require('../utils/config');
+const { getRepoPath, getEffectiveRepoPath, getAutoConfig, setAutoConfig, getStages, DEFAULT_STAGES } = require('../utils/config');
 const { getRequirementsPath, readRequirements } = require('vibecodingmachine-core');
 const fs = require('fs-extra');
 const path = require('path');
@@ -23,11 +23,56 @@ 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 { checkClineRateLimit, handleClineRateLimit } = require('../utils/cline-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');
 
+/**
+ * Auto-install Cline CLI if not available
+ * @param {boolean} forceInstall - Force installation even if already available
+ * @returns {Promise<boolean>} - Returns true if Cline CLI is available after installation
+ */
+async function ensureClineInstalled(forceInstall = false) {
+  const { DirectLLMManager } = require('vibecodingmachine-core');
+  const llm = new DirectLLMManager();
+  
+  // Check if already available
+  if (!forceInstall && await llm.isClineAvailable()) {
+    return true;
+  }
+
+  const ora = require('ora');
+  const { execSync } = require('child_process');
+  
+  const spinner = ora('Installing Cline CLI...').start();
+  
+  try {
+    // Install Cline CLI globally
+    execSync('npm install -g cline', { stdio: 'pipe', encoding: 'utf8' });
+    
+    // Verify installation
+    const isAvailable = await llm.isClineAvailable();
+    
+    if (isAvailable) {
+      spinner.succeed('Cline CLI installed successfully');
+      console.log(chalk.green('✓ Cline CLI is now ready to use'));
+      return true;
+    } else {
+      spinner.fail('Cline CLI installation failed');
+      console.log(chalk.yellow('⚠️  Installation completed but Cline CLI not found in PATH'));
+      console.log(chalk.gray('   You may need to restart your terminal or manually add npm global bin to PATH'));
+      return false;
+    }
+  } catch (error) {
+    spinner.fail('Cline CLI installation failed');
+    console.log(chalk.red('✗ Failed to install Cline CLI:'), error.message);
+    console.log(chalk.yellow('   You can manually install with: npm install -g cline'));
+    return false;
+  }
+}
+
 // CRITICAL: Shared ProviderManager instance to track rate limits across all function calls
 const sharedProviderManager = new ProviderManager();
 
@@ -280,6 +325,8 @@ async function getCurrentRequirement(repoPath) {
 
     const content = await fs.readFile(reqPath, 'utf8');
 
+    // Always skip DISABLED: requirements (user can toggle via TRUI Space key)
+
     // Extract first TODO requirement (new header format)
     const lines = content.split('\n');
     let inTodoSection = false;
@@ -304,6 +351,11 @@ async function getCurrentRequirement(repoPath) {
         const title = line.replace(/^###\s*/, '').trim();
         // Skip empty titles
         if (title && title.length > 0) {
+          // Always skip DISABLED: requirements
+          if (title.startsWith('DISABLED:')) {
+            continue;
+          }
+
           // Read package and description (optional)
           let pkg = null;
           let description = '';
@@ -334,7 +386,8 @@ async function getCurrentRequirement(repoPath) {
             text: title,
             fullLine: lines[i],
             package: pkg,
-            description: description
+            description: description,
+            disabled: false
           };
         }
       }
@@ -406,117 +459,113 @@ async function moveRequirementToVerify(repoPath, requirementText) {
 
     const content = await fs.readFile(reqPath, 'utf8');
     const lines = content.split('\n');
+// Find the requirement by its title (in ### header format)
+// Only look in TODO section
+const normalizedRequirement = requirementText.trim();
+const snippet = normalizedRequirement.substring(0, 80);
+let requirementStartIndex = -1;
+let requirementEndIndex = -1;
+let inTodoSection = false;
 
-    // Get computer filter from config
-    const { getComputerFilter } = require('../utils/config');
-    const computerFilter = await getComputerFilter();
+for (let i = 0; i < lines.length; i++) {
+  const line = lines[i];
+  const trimmed = line.trim();
 
-    // Find the requirement by its title (in ### header format)
-    // Only look in TODO section
-    const normalizedRequirement = requirementText.trim();
-    const snippet = normalizedRequirement.substring(0, 80);
-    let requirementStartIndex = -1;
-    let requirementEndIndex = -1;
-    let inTodoSection = false;
+  // Check if we're entering TODO section
+  if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
+    inTodoSection = true;
+    continue;
+  }
 
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
+  // Check if we're leaving TODO section
+  if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
+    inTodoSection = false;
+  }
 
-      // Check if we're entering TODO section
-      if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
-        inTodoSection = true;
-        continue;
-      }
+  // Only look for requirements in TODO section
+  if (inTodoSection && trimmed.startsWith('###')) {
+    const title = trimmed.replace(/^###\s*/, '').trim();
+    if (title) {
+      // Try multiple matching strategies
+      const normalizedTitle = title.trim();
 
-      // Check if we're leaving TODO section
-      if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
-        inTodoSection = false;
+      // Exact match
+      if (normalizedTitle === normalizedRequirement) {
+        requirementStartIndex = i;
+      }
+      // Check if either contains the other (for partial matches)
+      else if (normalizedTitle.includes(normalizedRequirement) || normalizedRequirement.includes(normalizedTitle)) {
+        requirementStartIndex = i;
+      }
+      // Check snippet matches
+      else if (normalizedTitle.includes(snippet) || snippet.includes(normalizedTitle.substring(0, 80))) {
+        requirementStartIndex = i;
       }
 
-      // Only look for requirements in TODO section
-      if (inTodoSection && trimmed.startsWith('###')) {
-        const title = trimmed.replace(/^###\s*/, '').trim();
-        if (title) {
-          // Try multiple matching strategies
-          const normalizedTitle = title.trim();
-
-          // Exact match
-          if (normalizedTitle === normalizedRequirement) {
-            requirementStartIndex = i;
-          }
-          // Check if either contains the other (for partial matches)
-          else if (normalizedTitle.includes(normalizedRequirement) || normalizedRequirement.includes(normalizedTitle)) {
-            requirementStartIndex = i;
-          }
-          // Check snippet matches
-          else if (normalizedTitle.includes(snippet) || snippet.includes(normalizedTitle.substring(0, 80))) {
-            requirementStartIndex = i;
-          }
-
-          if (requirementStartIndex !== -1) {
-            // Find the end of this requirement (next ### or ## header)
-            for (let j = i + 1; j < lines.length; j++) {
-              const nextLine = lines[j].trim();
-              if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
-                requirementEndIndex = j;
-                break;
-              }
-            }
-            if (requirementEndIndex === -1) {
-              requirementEndIndex = lines.length;
-            }
+      if (requirementStartIndex !== -1) {
+        // Find the end of this requirement (next ### or ## header)
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+            requirementEndIndex = j;
             break;
           }
         }
+        if (requirementEndIndex === -1) {
+          requirementEndIndex = lines.length;
+        }
+        break;
       }
     }
+  }
+}
 
-    if (requirementStartIndex === -1) {
-      console.log(chalk.yellow(`⚠️  ${t('auto.direct.requirement.not.found.todo', { requirement: requirementText.substring(0, 60) + '...' })}`));
-      return false;
-    }
+if (requirementStartIndex === -1) {
+  console.log(chalk.yellow(`⚠️  ${t('auto.direct.requirement.not.found.todo', { requirement: requirementText.substring(0, 60) + '...' })}`));
+  return false;
+}
 
-    // Extract the entire requirement block
-    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+// Extract the entire requirement block
+const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
 
-    // Remove the requirement from its current location
-    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+// Remove the requirement from its current location
+lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
 
-    // Check if there are any more requirements in TODO section after removal
-    let hasMoreTodoRequirements = false;
-    inTodoSection = false; // Reset the existing variable
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
+// Check if there are any more requirements in TODO section after removal
+let hasMoreTodoRequirements = false;
+inTodoSection = false; // Reset the existing variable
+for (let i = 0; i < lines.length; i++) {
+  const line = lines[i].trim();
 
-      // Check if we're entering TODO section
-      if (line.startsWith('##') && line.includes('Requirements not yet completed')) {
-        inTodoSection = true;
-        continue;
-      }
+  // Check if we're entering TODO section
+  if (line.startsWith('##') && line.includes('Requirements not yet completed')) {
+    inTodoSection = true;
+    continue;
+  }
 
-      // Check if we're leaving TODO section
-      if (inTodoSection && line.startsWith('##') && !line.startsWith('###') && !line.includes('Requirements not yet completed')) {
-        break;
-      }
+  // Check if we're leaving TODO section
+  if (inTodoSection && line.startsWith('##') && !line.startsWith('###') && !line.includes('Requirements not yet completed')) {
+    break;
+  }
 
-      // Check if we found a requirement in TODO section
-      if (inTodoSection && line.startsWith('###')) {
-        const title = line.replace(/^###\s*/, '').trim();
-        if (title && title.includes(computerFilter)) {
-          hasMoreTodoRequirements = true;
-          break;
-        }
-      }
+  // Check if we found a requirement in TODO section
+  if (inTodoSection && line.startsWith('###')) {
+    const title = line.replace(/^###\s*/, '').trim();
+    if (title) {
+      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 with promo code FRIENDSANDFAMILYROCK';
+  lines.push(newRequirement);
+}
 
-    // 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);
-    }
 // Find or create TO VERIFY BY HUMAN section with conflict resolution
 // IMPORTANT: Do NOT match VERIFIED sections - only match TO VERIFY sections
 const verifySectionVariants = [
@@ -801,8 +850,10 @@ async function moveRequirementToRecycle(repoPath, requirementText) {
 async function getAllAvailableProviders() {
   const config = await getAutoConfig();
   const prefs = await getProviderPreferences();
+
   const llm = new DirectLLMManager(sharedProviderManager); // Pass shared instance
   const providers = [];
+  const skipped = [];
 
   const groqKey = process.env.GROQ_API_KEY || config.groqApiKey;
   const anthropicKey = process.env.ANTHROPIC_API_KEY || config.anthropicApiKey;
@@ -810,6 +861,7 @@ async function getAllAvailableProviders() {
   const awsAccessKey = process.env.AWS_ACCESS_KEY_ID || config.awsAccessKeyId;
   const awsSecretKey = process.env.AWS_SECRET_ACCESS_KEY || config.awsSecretAccessKey;
   const claudeCodeAvailable = await llm.isClaudeCodeAvailable();
+  const clineAvailable = await llm.isClineAvailable();
   const ollamaAvailable = await llm.isOllamaAvailable();
   let ollamaModels = [];
   if (ollamaAvailable) {
@@ -834,7 +886,10 @@ async function getAllAvailableProviders() {
 
     switch (providerId) {
       case 'groq': {
-        if (!groqKey) continue;
+        if (!groqKey) {
+          skipped.push({ provider: providerId, displayName: def.name, enabled, reason: 'API key required — set GROQ_API_KEY or configure in settings' });
+          continue;
+        }
         const model = config.groqModel || def.defaultModel;
         providers.push({
           ...base,
@@ -845,7 +900,10 @@ async function getAllAvailableProviders() {
         break;
       }
       case 'anthropic': {
-        if (!anthropicKey) continue;
+        if (!anthropicKey) {
+          skipped.push({ provider: providerId, displayName: def.name, enabled, reason: 'API key required — set ANTHROPIC_API_KEY or configure in settings' });
+          continue;
+        }
         const model = config.anthropicModel || def.defaultModel;
         providers.push({
           ...base,
@@ -856,7 +914,10 @@ async function getAllAvailableProviders() {
         break;
       }
       case 'bedrock': {
-        if (!awsRegion || !awsAccessKey || !awsSecretKey) continue;
+        if (!awsRegion || !awsAccessKey || !awsSecretKey) {
+          skipped.push({ provider: providerId, displayName: def.name, enabled, reason: 'AWS credentials required — set AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY' });
+          continue;
+        }
         providers.push({
           ...base,
           model: def.defaultModel,
@@ -867,7 +928,27 @@ async function getAllAvailableProviders() {
         break;
       }
       case 'claude-code': {
-        if (!claudeCodeAvailable) continue;
+        if (!claudeCodeAvailable) {
+          skipped.push({ provider: providerId, displayName: def.name, enabled, reason: 'Claude Code CLI not installed or not found in PATH' });
+          continue;
+        }
+        providers.push({
+          ...base,
+          model: def.defaultModel
+        });
+        break;
+      }
+      case 'cline': {
+        // Auto-install Cline CLI if not available and enabled
+        if (!clineAvailable && enabled) {
+          console.log(chalk.yellow(`\n🔧 Cline CLI not found, auto-installing...`));
+          clineAvailable = await ensureClineInstalled();
+        }
+        
+        if (!clineAvailable) {
+          skipped.push({ provider: providerId, displayName: def.name, enabled, reason: 'Cline CLI not installed — run: npm install -g cline' });
+          continue;
+        }
         providers.push({
           ...base,
           model: def.defaultModel
@@ -882,17 +963,17 @@ async function getAllAvailableProviders() {
       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({
+            const providerObj = {
               ...base,
               model: sub.model,
               subAgentId: sub.id,
               subAgentName: sub.name,
               displayName: `${def.name} (${sub.name})`,
               extension: def.extension
-            });
+            };
+            providers.push(providerObj);
           }
         } else {
           const providerObj = {
@@ -900,13 +981,15 @@ async function getAllAvailableProviders() {
             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': {
-        if (!ollamaAvailable || ollamaModels.length === 0) continue;
+        if (!ollamaAvailable || ollamaModels.length === 0) {
+          skipped.push({ provider: providerId, displayName: def.name, enabled, reason: 'Ollama not running or no models installed' });
+          continue;
+        }
         const preferredModel = config.llmModel && config.llmModel.includes('ollama/')
           ? config.llmModel.split('/')[1]
           : config.llmModel || config.aiderModel;
@@ -927,7 +1010,7 @@ async function getAllAvailableProviders() {
     }
   }
 
-  return providers;
+  return { providers, skipped };
 }
 
 /**
@@ -936,7 +1019,7 @@ async function getAllAvailableProviders() {
 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 { providers, skipped } = await getAllAvailableProviders();
   const prefs = await getProviderPreferences();
 
   // Clear any incorrect rate limits for web-based IDEs that were marked due to platform issues
@@ -982,14 +1065,14 @@ async function getProviderConfig(excludeProvider = null) {
   }
 
   if (providers.length === 0) {
-    return { status: 'no_providers', providers: [] };
+    return { status: 'no_providers', providers: [], skipped };
   }
 
   const enabledProviders = providers.filter(p => p.enabled);
   const disabledProviders = providers.filter(p => !p.enabled);
 
   if (enabledProviders.length === 0) {
-    return { status: 'no_enabled', disabledProviders };
+    return { status: 'no_enabled', disabledProviders, skipped };
   }
 
   const availableProviders = enabledProviders.filter(p => {
@@ -1039,8 +1122,8 @@ async function getProviderConfig(excludeProvider = null) {
 
   // 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 => 
+    const { providers: allProviders } = await getAllAvailableProviders();
+    const unusedIdeProviders = allProviders.filter(p =>
       p.type === 'ide' && 
       !enabledProviders.some(ep => ep.provider === p.provider) &&
       !providerManager.rateLimits[`${p.provider}:`] && 
@@ -1086,7 +1169,7 @@ async function getProviderConfig(excludeProvider = null) {
   }
 
   // Debug: Log provider selection details
-  if (process.env.DEBUG_PROVIDER_SELECTION || true) { // Force debug for now
+  if (process.env.DEBUG_PROVIDER_SELECTION) {
     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}`));
@@ -1159,7 +1242,32 @@ async function getProviderConfig(excludeProvider = null) {
   };
 }
 
-async function acquireProviderConfig(excludeProvider = null, excludeModel = null) {
+async function acquireProviderConfig(excludeProvider = null, excludeModel = null, forcedProvider = null) {
+  // If a specific provider is forced, bypass normal selection
+  if (forcedProvider) {
+    // Special handling for Cline CLI - auto-install if not available
+    if (forcedProvider === 'cline') {
+      const { DirectLLMManager } = require('vibecodingmachine-core');
+      const llm = new DirectLLMManager();
+      
+      if (!await llm.isClineAvailable()) {
+        console.log(chalk.yellow(`\n🔧 Cline CLI not found, auto-installing...`));
+        const installed = await ensureClineInstalled();
+        if (!installed) {
+          console.log(chalk.red(`\n✗ Provider "${forcedProvider}" could not be installed\n`));
+          return null;
+        }
+      }
+    }
+    
+    const { providers } = await getAllAvailableProviders();
+    const match = providers.find(p => p.provider === forcedProvider);
+    if (match) return match;
+    // Provider not in available list — try building it directly from definitions
+    console.log(chalk.red(`\n✗ Provider "${forcedProvider}" is not available (missing credentials or not installed)\n`));
+    return null;
+  }
+
   while (true) {
     const selection = await getProviderConfig(excludeProvider);
     if (selection.status === 'ok') {
@@ -1174,11 +1282,26 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
 
     if (selection.status === 'no_providers') {
       console.log(chalk.red(`\n✗ ${t('auto.direct.provider.none.available')}\n`));
+      if (selection.skipped && selection.skipped.length > 0) {
+        const enabledSkipped = selection.skipped.filter(s => s.enabled);
+        if (enabledSkipped.length > 0) {
+          console.log(chalk.yellow('  Enabled providers skipped due to missing configuration:'));
+          enabledSkipped.forEach(s => console.log(chalk.gray(`    • ${s.displayName}: ${s.reason}`)));
+          console.log();
+        }
+      }
       return null;
     }
 
     if (selection.status === 'no_enabled') {
-      console.log(chalk.red(`\n✗ ${t('auto.direct.provider.all.disabled')}\n`));
+      const enabledSkipped = (selection.skipped || []).filter(s => s.enabled);
+      if (enabledSkipped.length > 0) {
+        console.log(chalk.red(`\n✗ Enabled providers are missing required configuration:\n`));
+        enabledSkipped.forEach(s => console.log(chalk.yellow(`  • ${s.displayName}: ${s.reason}`)));
+        console.log();
+      } else {
+        console.log(chalk.red(`\n✗ ${t('auto.direct.provider.all.disabled')}\n`));
+      }
       return null;
     }
 
@@ -1657,14 +1780,16 @@ async function runIdeProviderIteration(providerConfig, repoPath) {
         const message = `${providerConfig.displayName} exited with code ${code}`;
         const antigravityRateLimit = checkAntigravityRateLimit(combinedOutput);
         const kiroRateLimit = checkKiroRateLimit(combinedOutput);
+        const clineRateLimit = checkClineRateLimit(combinedOutput);
 
         resolve({
           success: false,
           error: combinedOutput ? `${message}\n${combinedOutput}` : message,
           output: combinedOutput,
-          rateLimited: isRateLimitMessage(combinedOutput) || antigravityRateLimit.isRateLimited || kiroRateLimit.isRateLimited,
+          rateLimited: isRateLimitMessage(combinedOutput) || antigravityRateLimit.isRateLimited || kiroRateLimit.isRateLimited || clineRateLimit.isRateLimited,
           antigravityRateLimited: antigravityRateLimit.isRateLimited,
-          kiroRateLimited: kiroRateLimit.isRateLimited
+          kiroRateLimited: kiroRateLimit.isRateLimited,
+          clineRateLimited: clineRateLimit.isRateLimited
         });
       }
     });
@@ -1686,7 +1811,9 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
     let startTime = Date.now();
     let lastCheckTime = Date.now();
     let quotaHandled = false;
+    let lastQuotaCheckTime = 0; // Throttle quota checks to every 30 seconds
     const checkIntervalMs = 2000; // Check every 2 seconds
+    const quotaCheckIntervalMs = 30000; // Check quota every 30 seconds
 
     console.log(chalk.gray(`\n⏳ ${t('auto.direct.ide.waiting')}`));
     console.log(chalk.gray(`   ${t('auto.direct.ide.monitoring', { filename: path.basename(reqPath) })}`));
@@ -1791,38 +1918,178 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
           return;
         }
 
-        // 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')) {
+        // Check 4: Active quota detection (throttled to every 30 seconds)
+        // For Kiro: ONLY AppleScript (CDP doesn't work with webviews)
+        // For others: CDP only
+        const now = Date.now();
+        if (!quotaHandled && ideType && (now - lastQuotaCheckTime >= quotaCheckIntervalMs)) {
+          lastQuotaCheckTime = now;
+
           try {
-            const quotaDetector = new QuotaDetector();
-            const ideToCheck = ideType === 'github-copilot' || ideType === 'amazon-q' ? 'vscode' : ideType;
-            const quotaResult = await quotaDetector.detectQuotaWarning(ideToCheck);
+            // For Kiro: ONLY AppleScript detection (CDP doesn't work)
+            if (ideType === 'kiro' || ideType === 'amazon-q') {
+              try {
+                const appleScriptManager = new AppleScriptManager();
+                const screenshotResult = await appleScriptManager.detectQuotaWarning('kiro');
 
-            if (quotaResult && quotaResult.hasQuotaWarning) {
-              quotaHandled = true;
-              const quotaMessage = quotaResult.matchedText || 'Quota limit detected in IDE UI';
+                if (screenshotResult && screenshotResult.hasQuotaWarning) {
+                  quotaHandled = true;
+                  const quotaMessage = screenshotResult.matchedText || screenshotResult.note || 'Kiro quota limit detected via AppleScript';
 
-              // Mark the provider as rate limited
+                  // 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 via AppleScript for Kiro: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, kiroRateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
+                }
+              } catch (screenshotError) {
+                console.log(chalk.red(`❌ AppleScript quota detection failed for Kiro: ${screenshotError.message}`));
+              }
+            }
+            // For Antigravity: AppleScript quota detection
+            else if (ideType === 'antigravity') {
+              try {
+                const appleScriptManager = new AppleScriptManager();
+                const antigravityQuotaResult = await appleScriptManager.checkAntigravityQuotaLimit();
+
+                if (antigravityQuotaResult && antigravityQuotaResult.isRateLimited) {
+                  quotaHandled = true;
+                  const quotaMessage = antigravityQuotaResult.message || 'Antigravity quota limit detected via AppleScript';
+                  
+                  // 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 via AppleScript for Antigravity: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, antigravityRateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
+                }
+            } catch (appleScriptError) {
+              console.log(chalk.red(`❌ AppleScript quota detection failed for Antigravity: ${appleScriptError.message}`));
+            }
+            }
+            // For Windsurf: AppleScript quota detection
+            else if (ideType === 'windsurf') {
+              try {
+                const appleScriptManager = new AppleScriptManager();
+                const windsurfQuotaResult = await appleScriptManager.checkWindsurfQuotaLimit();
+                
+                if (windsurfQuotaResult && windsurfQuotaResult.hasQuotaWarning) {
+                  quotaHandled = true;
+                  const quotaMessage = windsurfQuotaResult.matchedText || 'Windsurf quota limit detected';
+                  
+                  // 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⚠️  Windsurf quota warning detected: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, windsurfRateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
+                }
+              } catch (windsurfAppleScriptError) {
+                console.log(chalk.red(`❌ AppleScript quota detection failed for Windsurf: ${windsurfAppleScriptError.message}`));
+              }
+            }
+            // For Cursor: Skip CDP and go directly to AppleScript
+            else if (ideType === 'cursor') {
               try {
-                if (sharedProviderManager && typeof sharedProviderManager.markRateLimited === 'function') {
-                  sharedProviderManager.markRateLimited(ideType, undefined, quotaMessage);
+                const appleScriptManager = new AppleScriptManager();
+                const cursorQuotaResult = await appleScriptManager.checkCursorQuotaLimit();
+
+                if (cursorQuotaResult && cursorQuotaResult.isRateLimited) {
+                  quotaHandled = true;
+                  const quotaMessage = cursorQuotaResult.message || 'Cursor quota limit detected via AppleScript';
+                  
+                  // 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 via AppleScript for Cursor: ${quotaMessage.substring(0, 100)}...\n`));
+                  resolve({ success: false, rateLimited: true, providerRateLimited: ideType, matchedLine: quotaMessage });
+                  return;
                 }
-              } catch (e) {
-                // Ignore errors from marking rate-limited
+              } catch (appleScriptError) {
+                console.log(chalk.red(`❌ AppleScript quota detection failed for Cursor: ${appleScriptError.message}`));
               }
+            }
+            // For other IDEs: use CDP
+            else if (ideType === 'vscode' || ideType === 'github-copilot' || ideType === 'amazon-q') {
+              const quotaDetector = new QuotaDetector();
+              const ideToCheck = ideType === 'github-copilot' || ideType === 'amazon-q' ? 'vscode' : ideType;
+              
+              try {
+                const quotaResult = await quotaDetector.detectQuotaWarning(ideToCheck);
+
+                if (quotaResult && quotaResult.hasQuotaWarning) {
+                  quotaHandled = true;
+                  const quotaMessage = quotaResult.matchedText || 'Quota limit detected in IDE UI';
+
+                  // Check if this might be Kiro quota warning even when ideType is amazon-q
+                  const isKiroPattern = quotaMessage.toLowerCase().includes('out of credits') || 
+                                       quotaMessage.toLowerCase().includes('upgrade plan') ||
+                                       quotaMessage.toLowerCase().includes('monthly usage limit');
+
+                  // 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;
+                  watcher.close();
+                  console.log(chalk.yellow(`\n⚠️  Quota warning detected via CDP in ${ideToCheck} UI: ${quotaMessage.substring(0, 100)}...\n`));
+                  
+                  // If this looks like Kiro quota, set kiroRateLimited flag too
+                  const resolveObj = { 
+                    success: false, 
+                    rateLimited: true, 
+                    providerRateLimited: ideType, 
+                    matchedLine: quotaMessage 
+                  };
+                  
+                  if (ideType === 'amazon-q' && isKiroPattern) {
+                    resolveObj.kiroRateLimited = true;
+                    console.log(chalk.magenta(`💡 Detected potential Kiro quota warning despite amazon-q ideType`));
+                  }
+                  
+                  resolve(resolveObj);
+                  return;
+                }
+              } catch (cdpError) {
+                console.log(chalk.yellow(`⚠️ CDP quota detection failed for ${ideToCheck}: ${cdpError.message}`));
+              }
             }
           } 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})`));
-            }
+            console.log(chalk.red(`❌ [DEBUG] Quota detection check failed: ${quotaError.message}`));
+            console.log(chalk.gray(`   Stack: ${quotaError.stack}`));
           }
         }
 
@@ -1911,11 +2178,11 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
 
   // 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 completionResult = await waitForIdeCompletion(repoPath, requirement.text, providerConfig.provider || providerConfig.ide);
   const ideResponseTime = Date.now() - ideCompletionStartTime;
 
   // Track IDE health metrics based on completion result
-  const ideType = providerConfig.ide || providerConfig.provider;
+  const ideType = providerConfig.provider || providerConfig.ide;
   if (completionResult.success) {
     // Record success with response time
     await sharedHealthTracker.recordSuccess(ideType, ideResponseTime, {
@@ -1967,6 +2234,19 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
       return { success: false, error: 'AWS Kiro quota limit', shouldRetry: true };
     }
 
+    // Special-case behavior for Cline IDE
+    if (completionResult.clineRateLimited) {
+      console.log(chalk.yellow(`⚠️  ${t('auto.direct.provider.quota.exhausted', { provider: 'Cline' })}\n`));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+
+      const switchResult = await handleClineRateLimit();
+      if (switchResult && switchResult.success) {
+        return { success: false, error: `Cline switched to ${switchResult.nextProvider}, retrying.`, shouldRetry: true };
+      }
+
+      return { success: false, error: 'Cline 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) {
@@ -1999,8 +2279,6 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
   const moved = await moveRequirementToVerify(repoPath, requirement.text);
   if (moved) {
     console.log(chalk.green(`✓ ${t('auto.direct.status.verification.pending')}`));
-  } else {
-    console.log(chalk.yellow('⚠️  Requirement still pending verification in REQUIREMENTS file'));
   }
 
   console.log();
@@ -2010,6 +2288,214 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
   return { success: true, changes: [] };
 }
 
+/**
+ * Run a spec iteration using an IDE provider (AppleScript).
+ * Sends the full spec instruction to the IDE and polls tasks.md for
+ * progress (any new checkbox ticked), instead of spawning vcm auto:start.
+ *
+ * @param {Object} spec        - Spec object with .path, .directory, .hasTasks, .hasPlan, .hasPlanPrompt
+ * @param {string} taskText    - Text of the NEXT unchecked task (for display)
+ * @param {string} taskLine    - Full line from tasks.md (used if this is a continuation)
+ * @param {Object} providerConfig - Provider config with .provider/.ide and .displayName
+ * @returns {Promise<{success: boolean, error?: string, shouldRetry?: boolean}>}
+ */
+async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
+  const ideType = providerConfig.provider || providerConfig.ide;
+  const { done: doneBefore, total: totalBefore } = countSpecCheckboxes(spec.path);
+  const pctBefore = totalBefore > 0 ? Math.round((doneBefore / totalBefore) * 100) : 0;
+
+  // Build the full spec instruction (mirrors buildSpecInstruction from Electron app)
+  // This lets the agent work through multiple tasks autonomously rather than one at a time.
+  let instruction;
+  if (spec.hasTasks) {
+    instruction = `Implement all remaining tasks in ${spec.path}/tasks.md. Current progress: ${doneBefore}/${totalBefore} tasks (${pctBefore}%) complete. Check off each task (change "[ ]" to "[x]") as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are checked off, report "COMPLETION: 100%".`;
+  } else if (spec.hasPlan) {
+    instruction = `Read ${spec.path}/plan.md, generate tasks.md for this spec, then implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are done, report "COMPLETION: 100%".`;
+  } else {
+    const planPromptNote = spec.hasPlanPrompt
+      ? `Use plan prompt from ${spec.path}/plan-prompt.md to guide planning. ` : '';
+    instruction = `Read ${spec.path}/spec.md. ${planPromptNote}Run speckit workflow: (1) read spec.md, (2) generate plan.md, (3) generate tasks.md, (4) implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are done, report "COMPLETION: 100%".`;
+  }
+
+  // Send the spec instruction to the IDE via AppleScript.
+  // For Windsurf: use a single combined synchronous AppleScript that activates Windsurf,
+  // opens a fresh Cascade conversation, pastes the instruction, and submits — all in one
+  // atomic execSync call. This eliminates the timing race where a detached AppleScript
+  // fires 3 seconds later after VS Code has regained focus.
+  console.log(chalk.cyan(`📤 Sending spec instruction to ${providerConfig.displayName}...\n`));
+
+  if (ideType === 'windsurf') {
+    try {
+      const { execSync } = require('child_process');
+      const { writeFileSync, unlinkSync: _unlinkSync } = require('fs');
+      const { tmpdir } = require('os');
+
+      // Write instruction to a temp file so we can read it from AppleScript
+      // without any escaping issues with quotes or special characters.
+      const ts = Date.now();
+      const tmpTextFile = path.join(tmpdir(), `spec_instr_${ts}.txt`);
+      const tmpScpt = path.join(tmpdir(), `send_cascade_${ts}.scpt`);
+
+      writeFileSync(tmpTextFile, instruction, 'utf8');
+
+      // Single combined script: activate Windsurf → verify it is frontmost →
+      // focus Cascade → paste → submit.
+      // Both Windsurf AND VS Code report process name "Electron" to System Events,
+      // so we MUST use bundle identifier "com.exafunction.windsurf" to distinguish them.
+      const combinedScript = `
+set instructionText to (do shell script "cat " & quoted form of "${tmpTextFile}")
+
+-- Step 1: bring Windsurf to front
+tell application "Windsurf"
+  activate
+  delay 1.5
+end tell
+
+-- Step 2: verify Windsurf is the frontmost app by BUNDLE ID (not name — both
+--         Windsurf and VS Code report process name "Electron" to System Events).
+set maxTries to 3
+set tries to 0
+repeat
+  set tries to tries + 1
+  tell application "System Events"
+    set frontBundleID to bundle identifier of first process whose frontmost is true
+  end tell
+  if frontBundleID is "com.exafunction.windsurf" then exit repeat
+  if tries >= maxTries then
+    error "Windsurf did not become frontmost (frontmost bundle ID: " & frontBundleID & ")"
+  end if
+  tell application "Windsurf"
+    activate
+  end tell
+  delay 1.0
+end repeat
+
+-- Step 3: send keystrokes to Windsurf using bundle ID (required to distinguish
+--         Windsurf from VS Code since both run as "Electron" processes)
+tell application "System Events"
+  set windsurfProc to first process whose bundle identifier is "com.exafunction.windsurf"
+  tell windsurfProc
+    set frontmost to true
+    delay 0.5
+    -- ESC: defocus any editor/terminal input that might intercept keystrokes
+    key code 53
+    delay 0.5
+    -- Cmd+Shift+L: focus Cascade chat input (proven approach from sendText())
+    keystroke "l" using {command down, shift down}
+    delay 2.0
+    -- Clear any auto-inserted context text (e.g. @terminal:zsh)
+    keystroke "a" using {command down}
+    delay 0.3
+    key code 51
+    delay 0.3
+    -- Paste the spec instruction
+    set the clipboard to instructionText
+    keystroke "v" using {command down}
+    delay 0.5
+    -- Submit
+    key code 36
+    delay 1.0
+  end tell
+end tell
+`;
+
+      writeFileSync(tmpScpt, combinedScript, 'utf8');
+      try {
+        execSync(`osascript "${tmpScpt}"`, { stdio: 'pipe', timeout: 30000 });
+      } finally {
+        try { _unlinkSync(tmpScpt); } catch (_) {}
+        try { _unlinkSync(tmpTextFile); } catch (_) {}
+      }
+    } catch (err) {
+      console.log(chalk.red(`✗ AppleScript error: ${err.message}`));
+      return { success: false, error: err.message };
+    }
+  } else {
+    // Non-Windsurf IDEs: use AppleScriptManager
+    try {
+      const appleScriptManager = new AppleScriptManager();
+      let sendResult;
+      // Prefer sendTextWithThreadClosure when available (.js build), fall back to sendText (.cjs build)
+      if (typeof appleScriptManager.sendTextWithThreadClosure === 'function') {
+        sendResult = await appleScriptManager.sendTextWithThreadClosure(instruction, ideType);
+      } else {
+        sendResult = await appleScriptManager.sendText(instruction, ideType);
+      }
+      if (!sendResult || !sendResult.success) {
+        const errorMsg = (sendResult && sendResult.error) || `Failed to send text to ${providerConfig.displayName}`;
+        console.log(chalk.red(`✗ ${errorMsg}`));
+        return { success: false, error: errorMsg };
+      }
+    } catch (err) {
+      console.log(chalk.red(`✗ AppleScript error: ${err.message}`));
+      return { success: false, error: err.message };
+    }
+  }
+
+  console.log(chalk.green(`✓ Spec instruction sent to ${providerConfig.displayName}`));
+  console.log(chalk.gray(`⏳ Polling tasks.md every 30s for checkbox progress...\n`));
+
+  const POLL_INTERVAL_MS = 30 * 1000;        // 30 seconds
+  const CONTINUE_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+  const TIMEOUT_MS = 30 * 60 * 1000;          // 30 minutes
+
+  const startTime = Date.now();
+  let lastContinueSent = Date.now();
+
+  return new Promise((resolve) => {
+    let interval = null;
+
+    const cleanup = (result) => {
+      if (interval) { clearInterval(interval); interval = null; }
+      process.off('SIGINT', onSigint);
+      resolve(result);
+    };
+
+    // Handle Ctrl+C gracefully: stop polling and exit cleanly
+    const onSigint = () => {
+      console.log(chalk.yellow('\n⚠️  Interrupted — stopping spec task polling\n'));
+      cleanup({ success: false, error: 'interrupted' });
+      // Re-emit to trigger normal process exit after cleanup
+      process.exit(0);
+    };
+    process.once('SIGINT', onSigint);
+
+    interval = setInterval(async () => {
+      const elapsed = Date.now() - startTime;
+
+      if (elapsed >= TIMEOUT_MS) {
+        cleanup({ success: false, error: 'timeout', shouldRetry: true });
+        console.log(chalk.yellow(`⏰ Timeout (30min) — ${providerConfig.displayName} did not check off any tasks\n`));
+        return;
+      }
+
+      // Detect any new checkbox ticked since we started
+      const { done: doneNow, total: totalNow } = countSpecCheckboxes(spec.path);
+      if (doneNow > doneBefore) {
+        const pctNow = totalNow > 0 ? Math.round((doneNow / totalNow) * 100) : 0;
+        console.log(chalk.green(`✓ Progress detected: ${doneNow}/${totalNow} tasks (${pctNow}%) complete\n`));
+        cleanup({ success: true, changes: [] });
+        return;
+      }
+
+      // Send continuation prompt every 5 minutes if no progress
+      const sinceLastContinue = Date.now() - lastContinueSent;
+      if (sinceLastContinue >= CONTINUE_INTERVAL_MS) {
+        lastContinueSent = Date.now();
+        const pctNow = totalNow > 0 ? Math.round((doneNow / totalNow) * 100) : 0;
+        const mins = Math.round(elapsed / 60000);
+        const continueMsg = `Continue implementing spec "${spec.directory}". Current progress: ${doneNow}/${totalNow} tasks (${pctNow}%) complete. Keep working until ALL tasks in tasks.md are checked off. Next task: "${taskText}". (${mins}min elapsed)`;
+        try {
+          const appleScriptManager = new AppleScriptManager();
+          // Use plain sendText for continuations (no need to open new thread)
+          await appleScriptManager.sendText(continueMsg, ideType);
+          console.log(chalk.gray(`📤 Sent continuation prompt to ${providerConfig.displayName} (${mins}min elapsed)\n`));
+        } catch (_) { /* ignore continuation errors */ }
+      }
+    }, POLL_INTERVAL_MS);
+  });
+}
+
 /**
  * Run one iteration of autonomous mode with full workflow
  */
@@ -2412,6 +2898,64 @@ Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
   return { success: true, changes };
 }
 
+// ─── Spec mode helpers ────────────────────────────────────────────────────────
+
+/**
+ * Count done/total checkboxes in a spec's tasks.md.
+ */
+function countSpecCheckboxes(specPath) {
+  try {
+    const tasksFile = path.join(specPath, 'tasks.md');
+    if (!fs.existsSync(tasksFile)) return { done: 0, total: 0 };
+    const content = fs.readFileSync(tasksFile, 'utf8');
+    const totalMatches = content.match(/^- \[[ x]\]/gmi) || [];
+    const doneMatches = content.match(/^- \[x\]/gmi) || [];
+    return { done: doneMatches.length, total: totalMatches.length };
+  } catch (_) {
+    return { done: 0, total: 0 };
+  }
+}
+
+/**
+ * Get the next unchecked task line from tasks.md.
+ * Returns { text, line } or null when all done.
+ */
+function getNextSpecTask(specPath) {
+  try {
+    const tasksFile = path.join(specPath, 'tasks.md');
+    if (!fs.existsSync(tasksFile)) return null;
+    const content = fs.readFileSync(tasksFile, 'utf8');
+    for (const line of content.split('\n')) {
+      if (/^- \[ \]/.test(line)) {
+        return { text: line.replace(/^- \[ \]\s*/, '').trim(), line: line.trim() };
+      }
+    }
+    return null;
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Load all enabled specs that have incomplete tasks (or no tasks.md yet).
+ */
+async function loadEnabledIncompleteSpecs(repoPath) {
+  try {
+    const { getAllSpecifications } = require('vibecodingmachine-core');
+    const specs = await getAllSpecifications(repoPath, { skipDisabled: true });
+    return specs.filter(spec => {
+      if (!spec.hasTasks) return true; // No tasks.md = needs planning + implementation
+      const counts = countSpecCheckboxes(spec.path);
+      return counts.total === 0 || counts.done < counts.total;
+    });
+  } catch (err) {
+    console.log(chalk.yellow(`⚠️  Error loading specs: ${err.message}`));
+    return [];
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
 /**
  * Main auto mode command handler
  */
@@ -2435,7 +2979,7 @@ async function handleAutoStart(options) {
     console.log(chalk.gray('═'.repeat(80)));
     console.log();
 
-    const repoPath = await getRepoPath();
+    const repoPath = await getEffectiveRepoPath();
     if (!repoPath) {
       console.log(chalk.red('✗ No repository configured'));
       console.log(chalk.gray(t('auto.direct.config.repo.not.set')));
@@ -2462,8 +3006,8 @@ async function handleAutoStart(options) {
     // 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);
+    // Get provider configuration — options.provider forces a specific provider
+    let providerConfig = await acquireProviderConfig(null, null, options.provider || null);
     if (!providerConfig) {
       return;
     }
@@ -2484,9 +3028,246 @@ async function handleAutoStart(options) {
     const initialTodoCount = await countTodoRequirements(repoPath);
     const initialEffectiveMax = unlimited ? initialTodoCount : Math.min(maxChats, initialTodoCount);
 
-    // Main loop
+    // Main loop counters (shared across spec + requirements phases)
     let completedCount = 0;
     let failedCount = 0;
+
+    // ── Phase 1: Process incomplete enabled specs ─────────────────────────────
+    const incompleteSpecs = await loadEnabledIncompleteSpecs(repoPath);
+    if (incompleteSpecs.length > 0) {
+      console.log(chalk.bold.cyan(`\n📋 Processing ${incompleteSpecs.length} incomplete spec(s) before requirements...\n`));
+
+      for (const spec of incompleteSpecs) {
+        const { done: doneStart, total: totalStart } = countSpecCheckboxes(spec.path);
+        console.log(chalk.bold.magenta(`\n${'━'.repeat(80)}`));
+        console.log(chalk.bold.magenta(`  📋 SPEC: ${spec.directory}  (${spec.title || spec.directory})`));
+        if (totalStart > 0) {
+          const pctStart = Math.round((doneStart / totalStart) * 100);
+          console.log(chalk.bold.magenta(`  Progress: ${doneStart}/${totalStart} tasks (${pctStart}%) complete`));
+        } else {
+          console.log(chalk.bold.magenta('  No tasks.md yet — will plan and implement'));
+        }
+        console.log(chalk.bold.magenta(`${'━'.repeat(80)}\n`));
+
+        let specProviderAttempts = 0;
+        const MAX_SPEC_TASK_ATTEMPTS = 3;
+        let lastSpecTaskText = null;
+        let sameTaskAttempts = 0;
+
+        // If spec has no tasks.md yet, add a special planning task
+        if (!spec.hasTasks) {
+          console.log(chalk.cyan('📝 No tasks.md yet — planning spec first...\n'));
+          const planningText = [
+            `Plan and create tasks.md for spec "${spec.directory}".`,
+            `Read ${spec.path}/spec.md${spec.hasPlanPrompt ? ` and ${spec.path}/plan-prompt.md` : ''}.`,
+            `Then create ${spec.path}/tasks.md with implementation tasks as checkboxes (- [ ] task).`
+          ].join('\n');
+
+          let planResult;
+          if (providerConfig.type === 'ide') {
+            // Send planning instruction via AppleScript, poll for tasks.md creation
+            console.log(chalk.cyan(`📤 Sending planning task to ${providerConfig.displayName}...\n`));
+            const ideTypeForPlan = providerConfig.provider || providerConfig.ide;
+            // For Windsurf: single combined synchronous AppleScript to avoid timing race
+            const sendPlanToIde = async () => {
+              if (ideTypeForPlan === 'windsurf') {
+                const { execSync: _execSync2 } = require('child_process');
+                const { writeFileSync: _writeFileSync2, unlinkSync: _unlinkSync2 } = require('fs');
+                const { tmpdir: _tmpdir2 } = require('os');
+                const _ts2 = Date.now();
+                const _tmpText2 = path.join(_tmpdir2(), `plan_instr_${_ts2}.txt`);
+                const _tmpScpt2 = path.join(_tmpdir2(), `send_cascade_plan_${_ts2}.scpt`);
+                _writeFileSync2(_tmpText2, planningText, 'utf8');
+                const _combinedPlanScript = `
+set planText to (do shell script "cat " & quoted form of "${_tmpText2}")
+tell application "Windsurf"
+  activate
+  delay 1.5
+end tell
+set maxTries to 3
+set tries to 0
+repeat
+  set tries to tries + 1
+  tell application "System Events"
+    set frontBundleID to bundle identifier of first process whose frontmost is true
+  end tell
+  if frontBundleID is "com.exafunction.windsurf" then exit repeat
+  if tries >= maxTries then
+    error "Windsurf did not become frontmost (frontmost bundle ID: " & frontBundleID & ")"
+  end if
+  tell application "Windsurf"
+    activate
+  end tell
+  delay 1.0
+end repeat
+tell application "System Events"
+  set windsurfProc to first process whose bundle identifier is "com.exafunction.windsurf"
+  tell windsurfProc
+    set frontmost to true
+    delay 0.5
+    key code 53
+    delay 0.5
+    keystroke "l" using {command down, shift down}
+    delay 2.0
+    keystroke "a" using {command down}
+    delay 0.3
+    key code 51
+    delay 0.3
+    set the clipboard to planText
+    keystroke "v" using {command down}
+    delay 0.5
+    key code 36
+    delay 1.0
+  end tell
+end tell
+`;
+                _writeFileSync2(_tmpScpt2, _combinedPlanScript, 'utf8');
+                try {
+                  _execSync2(`osascript "${_tmpScpt2}"`, { stdio: 'pipe', timeout: 30000 });
+                  return { success: true };
+                } finally {
+                  try { _unlinkSync2(_tmpScpt2); } catch (_) {}
+                  try { _unlinkSync2(_tmpText2); } catch (_) {}
+                }
+              } else {
+                const appleScriptManager = new AppleScriptManager();
+                const sendResult = typeof appleScriptManager.sendTextWithThreadClosure === 'function'
+                  ? await appleScriptManager.sendTextWithThreadClosure(planningText, ideTypeForPlan)
+                  : await appleScriptManager.sendText(planningText, ideTypeForPlan);
+                if (!sendResult || !sendResult.success) {
+                  throw new Error((sendResult && sendResult.error) || 'send failed');
+                }
+                return { success: true };
+              }
+            };
+            try {
+              const sendPlanResult = await sendPlanToIde();
+              if (!sendPlanResult || !sendPlanResult.success) {
+                console.log(chalk.red(`✗ Failed to send to ${providerConfig.displayName}`));
+                planResult = { success: false, error: 'send failed' };
+              } else {
+                console.log(chalk.green(`✓ Planning task sent. Waiting for tasks.md to be created...`));
+                // Poll for tasks.md existence
+                const tasksFilePath = path.join(spec.path, 'tasks.md');
+                const POLL_MS = 30 * 1000;
+                const TIMEOUT_MS = 30 * 60 * 1000;
+                const planStart = Date.now();
+                planResult = await new Promise((resolve) => {
+                  const iv = setInterval(() => {
+                    if (fs.existsSync(tasksFilePath)) {
+                      clearInterval(iv);
+                      console.log(chalk.green('✓ tasks.md created!\n'));
+                      resolve({ success: true });
+                    } else if (Date.now() - planStart >= TIMEOUT_MS) {
+                      clearInterval(iv);
+                      console.log(chalk.yellow('⏰ Timeout waiting for tasks.md\n'));
+                      resolve({ success: false, error: 'timeout' });
+                    }
+                  }, POLL_MS);
+                });
+              }
+            } catch (err) {
+              planResult = { success: false, error: err.message };
+            }
+          } else {
+            const planRequirement = { text: planningText, package: null, disabled: false };
+            planResult = await runIteration(planRequirement, providerConfig, repoPath);
+          }
+
+          if (planResult.success) {
+            completedCount++;
+            console.log(chalk.green('✓ tasks.md created — proceeding with implementation\n'));
+            // Re-check if spec now has tasks
+            spec.hasTasks = fs.existsSync(path.join(spec.path, 'tasks.md'));
+          } else {
+            console.log(chalk.red('✗ Failed to create tasks.md — skipping spec\n'));
+            failedCount++;
+            continue; // Skip to next spec
+          }
+        }
+
+        // Loop until spec is done or stalled
+        while (true) {
+          const task = getNextSpecTask(spec.path);
+          if (!task) {
+            // All tasks checked off
+            const { done: doneFinal, total: totalFinal } = countSpecCheckboxes(spec.path);
+            console.log(chalk.bold.green(`\n✅ Spec "${spec.directory}" complete! (${doneFinal}/${totalFinal} tasks)\n`));
+            break;
+          }
+
+          // Detect same task repeated (LLM not checking it off)
+          if (task.text === lastSpecTaskText) {
+            sameTaskAttempts++;
+            if (sameTaskAttempts >= MAX_SPEC_TASK_ATTEMPTS) {
+              console.log(chalk.red(`\n✗ Task "${task.text}" not completing after ${MAX_SPEC_TASK_ATTEMPTS} attempts — skipping spec\n`));
+              break;
+            }
+          } else {
+            sameTaskAttempts = 0;
+            lastSpecTaskText = task.text;
+          }
+
+          const { done: doneCurrent, total: totalCurrent } = countSpecCheckboxes(spec.path);
+          const pctCurrent = totalCurrent > 0 ? Math.round((doneCurrent / totalCurrent) * 100) : 0;
+
+          console.log(chalk.cyan(`\n📌 Task ${doneCurrent + 1}/${totalCurrent || '?'}: ${task.text}`));
+          console.log(chalk.gray(`   Spec progress: ${doneCurrent}/${totalCurrent} (${pctCurrent}%)\n`));
+
+          // Route spec tasks differently depending on provider type.
+          // IDE providers (Windsurf, Cursor, etc.) must NOT go through runIdeFallbackIteration
+          // because that spawns "vcm auto:start" which is designed for requirements mode only.
+          // Instead, use runSpecIdeIteration which sends text directly via AppleScript
+          // and polls tasks.md for checkbox completion.
+          let result;
+          if (providerConfig.type === 'ide') {
+            result = await runSpecIdeIteration(spec, task.text, task.line, providerConfig);
+          } else {
+            // Direct LLM providers: wrap task in a requirement object and use standard iteration
+            const specTaskText = [
+              task.text,
+              `[Spec: ${spec.directory} — task ${doneCurrent + 1}/${totalCurrent || '?'}]`,
+              `[After implementing, mark the task done in ${spec.path}/tasks.md:`,
+              `  change: ${task.line}`,
+              `  to:     - [x] ${task.text}]`
+            ].join('\n');
+            const specRequirement = { text: specTaskText, package: null, disabled: false };
+            result = await runIteration(specRequirement, providerConfig, repoPath);
+          }
+
+          if (result.success) {
+            specProviderAttempts = 0;
+            completedCount++;
+            const { done, total } = countSpecCheckboxes(spec.path);
+            const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+            console.log(chalk.bold.green(`📊 Spec progress: ${done}/${total} tasks (${pct}%) complete`));
+          } else {
+            const isRateLimitError = isRateLimitMessage(result.error);
+            const errorType = isRateLimitError ? 'Rate limit' : 'Error';
+
+            specProviderAttempts++;
+            failedCount++;
+
+            if (specProviderAttempts > MAX_SPEC_TASK_ATTEMPTS) {
+              console.log(chalk.red(`\n✗ Max provider attempts reached — moving to next spec\n`));
+              break;
+            }
+
+            console.log(chalk.yellow(`⚠️  ${errorType} on spec task, switching provider...`));
+            const newProviderConfig = await acquireProviderConfig(providerConfig.provider, providerConfig.model);
+            if (newProviderConfig) {
+              providerConfig = newProviderConfig;
+              console.log(chalk.green(`✓ Switched to: ${providerConfig.displayName}\n`));
+            }
+          }
+        }
+      }
+
+      console.log(chalk.bold.cyan('\n📋 All specs processed. Continuing to requirements...\n'));
+      console.log(chalk.gray('═'.repeat(80)));
+    }
+
+    // ── Phase 2: Requirements mode ─────────────────────────────────────────────
     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
@@ -2495,7 +3276,11 @@ async function handleAutoStart(options) {
       // Get current requirement first to check if there are any TODO items
       const requirement = await getCurrentRequirement(repoPath);
       if (!requirement) {
-        console.log(chalk.bold.yellow('\n🎉 All requirements completed!'));
+        if (completedCount > 0 || failedCount > 0) {
+          console.log(chalk.bold.yellow('\n🎉 All requirements completed!'));
+        } else {
+          console.log(chalk.bold.yellow('\n🎉 No requirements to process.'));
+        }
         console.log(chalk.gray(`${t('auto.direct.no.more.todo.items')}\n`));
         break;
       }
@@ -2653,5 +3438,5 @@ async function handleAutoStart(options) {
   }
 }
 
-module.exports = { handleAutoStart, waitForIdeCompletion, acquireProviderConfig };
+module.exports = { handleAutoStart, waitForIdeCompletion, acquireProviderConfig, getCurrentRequirement };