vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/commands/auto-direct.js

@@ -5,7 +5,25 @@
  */
 
 const chalk = require('chalk');
-const { DirectLLMManager, AppleScriptManager, QuotaDetector, IDEHealthTracker, t, detectLocale, setLocale } = require('vibecodingmachine-core');
+const vibecodingmachineCore = require('vibecodingmachine-core');
+const {
+  DirectLLMManager,
+  AppleScriptManager,
+  QuotaDetector,
+  IDEHealthTracker,
+  TimeoutCalculator,
+  t,
+  detectLocale,
+  setLocale
+} = vibecodingmachineCore;
+
+// Extract requirement management classes
+const {
+  RequirementFileParser,
+  RequirementSequencer,
+  DefaultRequirementManager,
+  JSONStorage
+} = vibecodingmachineCore;
 
 // Initialize locale detection for auto mode
 const detectedLocale = detectLocale();
@@ -26,6 +44,9 @@ const { checkKiroRateLimit, handleKiroRateLimit } = require('../utils/kiro-js-ha
 const { checkClineRateLimit, handleClineRateLimit } = require('../utils/cline-js-handler');
 const { startAutoMode, stopAutoMode, updateAutoModeStatus } = require('../utils/auto-mode');
 
+// Global keyboard handler reference for cleanup
+let keyboardHandler = null;
+
 // Status management will use in-process tracking instead of external file
 const CLI_ENTRY_POINT = path.join(__dirname, '../../bin/vibecodingmachine.js');
 
@@ -37,7 +58,7 @@ const CLI_ENTRY_POINT = path.join(__dirname, '../../bin/vibecodingmachine.js');
 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;
@@ -45,16 +66,16 @@ async function ensureClineInstalled(forceInstall = false) {
 
   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'));
@@ -459,317 +480,317 @@ 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;
-
-for (let i = 0; i < lines.length; i++) {
-  const line = lines[i];
-  const trimmed = line.trim();
-
-  // Check if we're entering TODO section
-  if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
-    inTodoSection = true;
-    continue;
-  }
-
-  // Check if we're leaving TODO section
-  if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
-    inTodoSection = false;
-  }
+    // 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;
 
-  // 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();
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.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 if we're entering TODO section
+      if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
       }
-      // Check snippet matches
-      else if (normalizedTitle.includes(snippet) || snippet.includes(normalizedTitle.substring(0, 80))) {
-        requirementStartIndex = i;
+
+      // Check if we're leaving TODO section
+      if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
+        inTodoSection = false;
       }
 
-      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;
+      // 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;
+            }
             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) {
-      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 with promo code FRIENDSANDFAMILYROCK';
+      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 = [
+      '## 🔍 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 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;
+    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;
+      }
+
+      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');
+      });
+
+      // Safety check: verifyIndex should be valid
+      if (verifyIndex === -1) {
+        console.error(t('auto.direct.verify.section.create.failed'));
+        return false;
+      }
+    }
+
+    // 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 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;
       }
     }
-  }
-  if (verifyIndex !== -1) break;
-}
 
-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;
-  }
+    // 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();
 
-  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');
-  });
+      if (trimmed.startsWith('###')) {
+        const existingTitle = trimmed.replace(/^###\s*/, '').trim();
 
-  // Safety check: verifyIndex should be valid
-  if (verifyIndex === -1) {
-    console.error(t('auto.direct.verify.section.create.failed'));
-    return false;
-  }
-}
+        // Check if this is a duplicate (exact match or contains/contained by)
+        if (existingTitle === requirementTitle ||
+          existingTitle.includes(requirementTitle) ||
+          requirementTitle.includes(existingTitle)) {
 
-// 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;
-}
+          // 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;
+            }
+          }
 
-// 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;
-  }
-}
+          // Remove the duplicate
+          lines.splice(i, existingEndIndex - i);
 
-// 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;
+          // Adjust nextSectionIndex if needed
+          nextSectionIndex -= (existingEndIndex - i);
           break;
         }
       }
-
-      // Remove the duplicate
-      lines.splice(i, existingEndIndex - i);
-
-      // Adjust nextSectionIndex if needed
-      nextSectionIndex -= (existingEndIndex - i);
-      break;
     }
-  }
-}
 
-// Insert requirement block at TOP of TO VERIFY section (right after section header)
-let insertIndex = verifyIndex + 1;
+    // Insert requirement block at TOP of TO VERIFY section (right after section header)
+    let insertIndex = verifyIndex + 1;
 
-// Ensure there's a blank line after the section header
-if (lines[insertIndex]?.trim() !== '') {
-  lines.splice(insertIndex, 0, '');
-  insertIndex++;
-}
+    // Ensure there's a blank line after the section header
+    if (lines[insertIndex]?.trim() !== '') {
+      lines.splice(insertIndex, 0, '');
+      insertIndex++;
+    }
 
-// 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++;
-  }
-}
+    // 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++;
+      }
+    }
 
-// Insert the requirement block
-lines.splice(insertIndex, 0, ...requirementBlock);
+    // Insert the requirement block
+    lines.splice(insertIndex, 0, ...requirementBlock);
 
-// 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, '');
-}
+    // 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, '');
+    }
 
-// 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;
+    // 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;
     }
-  }
-  if (verifiedIndex !== -1) break;
-}
 
-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');
-  });
-}
+    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');
+      });
+    }
 
-// 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 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);
 
 
 
@@ -862,6 +883,7 @@ async function getAllAvailableProviders() {
   const awsSecretKey = process.env.AWS_SECRET_ACCESS_KEY || config.awsSecretAccessKey;
   const claudeCodeAvailable = await llm.isClaudeCodeAvailable();
   const clineAvailable = await llm.isClineAvailable();
+  const openCodeAvailable = await llm.isOpenCodeAvailable();
   const ollamaAvailable = await llm.isOllamaAvailable();
   let ollamaModels = [];
   if (ollamaAvailable) {
@@ -944,7 +966,7 @@ async function getAllAvailableProviders() {
           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;
@@ -955,6 +977,17 @@ async function getAllAvailableProviders() {
         });
         break;
       }
+      case 'opencode': {
+        if (!openCodeAvailable) {
+          skipped.push({ provider: providerId, displayName: def.name, enabled, reason: 'OpenCode CLI not installed — visit https://opencode.ai to install' });
+          continue;
+        }
+        providers.push({
+          ...base,
+          model: def.defaultModel
+        });
+        break;
+      }
       case 'cursor':
       case 'windsurf':
       case 'vscode':
@@ -1030,15 +1063,15 @@ async function getProviderConfig(excludeProvider = null) {
         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'));
-        
+        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'];
@@ -1056,7 +1089,7 @@ async function getProviderConfig(excludeProvider = null) {
     }
   }
   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}`));
@@ -1076,42 +1109,33 @@ async function getProviderConfig(excludeProvider = null) {
   }
 
   const availableProviders = enabledProviders.filter(p => {
-    // Exclude the specified provider and rate-limited providers
+    // Exclude 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;
     }
-    
+
     // 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
+      const hasBeenUsed = providerManager.rateLimits[`${p.provider}:`] ||
+        Object.keys(providerManager.rateLimits).some(key => key.startsWith(`${p.provider}:`));
+
       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`));
+          console.log(chalk.gray(`[DEBUG] IDE Provider ${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`));
+        console.log(chalk.gray(`[DEBUG] IDE Provider ${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) {
@@ -1120,53 +1144,7 @@ async function getProviderConfig(excludeProvider = null) {
     return !isRateLimited;
   });
 
-  // If no providers are available, try to enable some IDE providers that haven't been used yet
-  if (availableProviders.length === 0) {
-    const { providers: 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) {
@@ -1187,25 +1165,25 @@ async function getProviderConfig(excludeProvider = null) {
       console.log(chalk.gray(`[DEBUG] Found selection: ${selection ? selection.provider : '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}:`] && 
+    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}`));
@@ -1229,16 +1207,30 @@ async function getProviderConfig(excludeProvider = null) {
     return { status: 'ok', provider: selection, disabledProviders };
   }
 
-  const waits = enabledProviders
+  const waits = availableProviders
     .map(p => providerManager.getTimeUntilReset(p.provider, p.model))
     .filter(Boolean);
   const nextResetMs = waits.length ? Math.min(...waits) : null;
 
+  // Only return all_rate_limited if there are available providers and ALL of them are rate limited
+  const allAvailableRateLimited = availableProviders.length > 0 &&
+    availableProviders.every(p => providerManager.isRateLimited(p.provider, p.model));
+
+  if (allAvailableRateLimited) {
+    return {
+      status: 'all_rate_limited',
+      enabledProviders,
+      disabledProviders,
+      nextResetMs
+    };
+  }
+
+  // If we reach here, no providers are available (filtered out by excludeProvider or other conditions)
   return {
-    status: 'all_rate_limited',
+    status: 'no_available',
     enabledProviders,
     disabledProviders,
-    nextResetMs
+    skipped
   };
 }
 
@@ -1249,7 +1241,7 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
     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();
@@ -1259,7 +1251,7 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
         }
       }
     }
-    
+
     const { providers } = await getAllAvailableProviders();
     const match = providers.find(p => p.provider === forcedProvider);
     if (match) return match;
@@ -1270,6 +1262,13 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
 
   while (true) {
     const selection = await getProviderConfig(excludeProvider);
+
+    // Handle case where getProviderConfig returns undefined/null
+    if (!selection) {
+      console.log(chalk.red(`\n✗ ${t('auto.direct.provider.none.available')}\n`));
+      return null;
+    }
+
     if (selection.status === 'ok') {
       // If we have a specific model to exclude (for same-IDE failover), skip it
       if (excludeModel && selection.provider.model === excludeModel) {
@@ -1317,6 +1316,14 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
       continue;
     }
 
+    if (selection.status === 'no_available') {
+      console.log(chalk.red(`\n✗ No available providers after filtering\n`));
+      if (selection.disabledProviders && selection.disabledProviders.length > 0) {
+        console.log(chalk.gray(`  Enable more providers in Settings to continue\n`));
+      }
+      return null;
+    }
+
     return null;
   }
 }
@@ -1963,7 +1970,7 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
                 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') {
@@ -1978,20 +1985,20 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
                   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}`));
-            }
+              } 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') {
@@ -2000,7 +2007,7 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
                   } 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 });
@@ -2019,7 +2026,7 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
                 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') {
@@ -2042,7 +2049,7 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
             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);
 
@@ -2051,9 +2058,9 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
                   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');
+                  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 {
@@ -2066,20 +2073,20 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
 
                   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 
+                  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;
                 }
@@ -2093,7 +2100,76 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
           }
         }
 
-        // Check 5: Timeout
+        // Check 5: Continuation detection (check every 2 seconds)
+        if (elapsed > 30000 && elapsed % 2000 < 2000) { // Start checking after 30 seconds, every 2 seconds
+          try {
+            let continuationDetected = false;
+            let continuationClicked = false;
+
+            // Use CDP for web-based IDEs
+            if (ideType === 'vscode' || ideType === 'cursor' || ideType === 'windsurf') {
+              const { CDPManager } = require('vibecodingmachine-core');
+              const cdpManager = new CDPManager();
+
+              try {
+                const continuationResult = await cdpManager.checkForContinuation(ideType);
+                if (continuationResult.continuationDetected) {
+                  console.log(chalk.yellow(`🔄 Continuation prompt detected in ${ideType}, clicking button...`));
+                  const clickResult = await cdpManager.clickContinuationButton(ideType);
+                  if (clickResult.success && clickResult.clicked) {
+                    continuationDetected = true;
+                    continuationClicked = true;
+                    console.log(chalk.green(`✅ Continuation button clicked successfully`));
+                  } else {
+                    console.log(chalk.yellow(`⚠️  Failed to click continuation button: ${clickResult.message || 'Unknown error'}`));
+                  }
+                }
+              } catch (cdpError) {
+                console.log(chalk.gray(`   Continuation detection via CDP failed: ${cdpError.message}`));
+              }
+            }
+            // Use AppleScript for desktop IDEs
+            else if (ideType === 'cline' || ideType === 'claude-code') {
+              const { AppleScriptManager } = require('vibecodingmachine-core');
+              const appleScriptManager = new AppleScriptManager();
+
+              try {
+                const continuationResult = await appleScriptManager.checkForContinuation(ideType);
+                if (continuationResult.continuationDetected) {
+                  console.log(chalk.yellow(`🔄 Continuation prompt detected in ${ideType}, clicking button...`));
+                  const clickResult = await appleScriptManager.clickContinuationButton(ideType);
+                  if (clickResult.success && clickResult.clicked) {
+                    continuationDetected = true;
+                    continuationClicked = true;
+                    console.log(chalk.green(`✅ Continuation button clicked successfully`));
+                  } else {
+                    console.log(chalk.yellow(`⚠️  Failed to click continuation button: ${clickResult.error || 'Unknown error'}`));
+                  }
+                }
+              } catch (appleScriptError) {
+                console.log(chalk.gray(`   Continuation detection via AppleScript failed: ${appleScriptError.message}`));
+              }
+            }
+
+            // Record continuation detection in health tracker
+            if (continuationDetected) {
+              try {
+                // Update the interaction record to include continuation detection
+                const currentMetrics = sharedHealthTracker.getHealthMetrics(ideType);
+                if (currentMetrics && currentMetrics.interactions && currentMetrics.interactions.length > 0) {
+                  const lastInteraction = currentMetrics.interactions[currentMetrics.interactions.length - 1];
+                  lastInteraction.continuationPromptsDetected = (lastInteraction.continuationPromptsDetected || 0) + 1;
+                }
+              } catch (trackerError) {
+                console.log(chalk.gray(`   Failed to record continuation detection: ${trackerError.message}`));
+              }
+            }
+          } catch (error) {
+            console.log(chalk.gray(`   Continuation detection error: ${error.message}`));
+          }
+        }
+
+        // Check 6: Timeout
         const elapsed = Date.now() - startTime;
         if (elapsed >= timeoutMs) {
           watcher.close();
@@ -2102,6 +2178,45 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
           return;
         }
 
+        // Check 7: Text pattern matching fallback for continuation prompts
+        const fileContent = await fs.readFile(reqPath, 'utf-8');
+        const continuationPatterns = [
+          /continue.*generation/i,
+          /keep.*going/i,
+          /continue.*writing/i,
+          /continue.*coding/i,
+          /proceed/i,
+          /next.*step/i,
+          /continue/i
+        ];
+
+        const hasContinuationPrompt = continuationPatterns.some(pattern => pattern.test(fileContent));
+        if (hasContinuationPrompt && elapsed > 30000) { // Only check for text patterns after 30 seconds
+          console.log(chalk.yellow(`🔄 Continuation prompt detected in text, attempting to continue...`));
+          // This is a fallback - we can't click buttons via text patterns, but we can log it
+          try {
+            const currentMetrics = sharedHealthTracker.getHealthMetrics(ideType);
+            if (currentMetrics && currentMetrics.interactions && currentMetrics.interactions.length > 0) {
+              const lastInteraction = currentMetrics.interactions[currentMetrics.interactions.length - 1];
+              lastInteraction.continuationPromptsDetected = (lastInteraction.continuationPromptsDetected || 0) + 1;
+            }
+          } catch (trackerError) {
+            console.log(chalk.gray(`   Failed to record text continuation detection: ${trackerError.message}`));
+          }
+        }
+        // Check 8: Memory monitoring
+        if (elapsed > 60000 && elapsed % 30000 < 30000) { // Check memory every 30 seconds after 1 minute
+          const memoryUsage = process.memoryUsage();
+          const heapUsedMB = Math.round(memoryUsage.heapUsed / 1024 / 1024);
+          const heapTotalMB = Math.round(memoryUsage.heapTotal / 1024 / 1024);
+          const heapUsedPercent = Math.round((memoryUsage.heapUsed / memoryUsage.heapTotal) * 100);
+
+          if (heapUsedMB > 500) { // Warn at 500MB
+            console.log(chalk.yellow(`⚠️  High memory usage detected: ${heapUsedMB}MB heap (${heapUsedPercent}% of ${heapTotalMB}MB)`));
+            console.log(chalk.gray(`   RSS: ${Math.round(memoryUsage.rss / 1024 / 1024)}MB, External: ${Math.round(memoryUsage.external / 1024 / 1024)}MB`));
+          }
+        }
+
         // Log progress every 30 seconds
         if (Date.now() - lastCheckTime >= 30000) {
           const elapsedMin = Math.floor(elapsed / 60000);
@@ -2156,13 +2271,13 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
       }
       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
     // 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 {
@@ -2170,19 +2285,37 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
       // 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')}`));
 
+  // Calculate adaptive timeout based on IDE's historical performance
+  const ideType = providerConfig.provider || providerConfig.ide;
+  const healthMetrics = sharedHealthTracker.getHealthMetrics(ideType);
+  let adaptiveTimeoutMs = 30 * 60 * 1000; // Default 30 minutes
+
+  if (healthMetrics && healthMetrics.responseTimes.length > 0) {
+    // Use adaptive timeout calculation if we have historical data
+    const stats = TimeoutCalculator.calculateTimeout(healthMetrics.responseTimes, {
+      defaultTimeout: 30 * 60 * 1000,
+      minTimeout: 5 * 60 * 1000, // 5 minutes minimum
+      maxTimeout: 60 * 60 * 1000, // 60 minutes maximum
+      bufferPercentage: 0.5 // 50% buffer
+    });
+    adaptiveTimeoutMs = stats.timeout;
+    console.log(chalk.gray(`   Using adaptive timeout: ${Math.floor(adaptiveTimeoutMs / 60000)} minutes (based on ${healthMetrics.responseTimes.length} historical response times)`));
+  } else {
+    console.log(chalk.gray(`   Using default timeout: ${Math.floor(adaptiveTimeoutMs / 60000)} minutes (no historical data for ${ideType})`));
+  }
+
   // 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.provider || providerConfig.ide);
+  const completionResult = await waitForIdeCompletion(repoPath, requirement.text, ideType, adaptiveTimeoutMs);
   const ideResponseTime = Date.now() - ideCompletionStartTime;
 
   // Track IDE health metrics based on completion result
-  const ideType = providerConfig.provider || providerConfig.ide;
   if (completionResult.success) {
     // Record success with response time
     await sharedHealthTracker.recordSuccess(ideType, ideResponseTime, {
@@ -2197,7 +2330,7 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
   } 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
+      timeoutUsed: adaptiveTimeoutMs, // Use the adaptive timeout that was actually used
       requirementId: requirement.id || requirement.text.substring(0, 50),
     });
   } else {
@@ -2293,6 +2426,13 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
  * Sends the full spec instruction to the IDE and polls tasks.md for
  * progress (any new checkbox ticked), instead of spawning vcm auto:start.
  *
+ * COORDINATION STRATEGY:
+ * - Wait for agent completion signals instead of just detecting any progress
+ * - Implement 2-minute cooldown after progress detection to prevent rapid spawning
+ * - Only consider iteration complete when all tasks are done AND agent signals completion
+ * - Use STATUS:WAITING and PLEASE RESPOND signals from agent to coordinate handoff
+ * - Prevent multiple agents from working on the same spec simultaneously
+ *
  * @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)
@@ -2304,107 +2444,40 @@ async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
   const { done: doneBefore, total: totalBefore } = countSpecCheckboxes(spec.path);
   const pctBefore = totalBefore > 0 ? Math.round((doneBefore / totalBefore) * 100) : 0;
 
+  // Get configurable timeouts from auto config
+  const autoConfig = await getAutoConfig();
+  const PROGRESS_TIMEOUT_MS = (autoConfig.specProgressTimeoutMinutes || 15) * 60 * 1000; // Configurable, default 15 minutes
+  const MAX_IDE_ATTEMPTS = autoConfig.maxIdeAttempts || 3; // Configurable, default 3 attempts
+
   // 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%".`;
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. 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. Whenever you stop and wait for user response, say "STATUS:WAITING" followed by "PLEASE RESPOND". When ALL tasks are checked off, report "COMPLETION: 100%", then say "STATUS:WAITING" and "PLEASE RESPOND".`;
   } 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%".`;
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. 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. Whenever you stop and wait for user response, say "STATUS:WAITING" followed by "PLEASE RESPOND". When ALL tasks are done, report "COMPLETION: 100%", then say "STATUS:WAITING" and "PLEASE RESPOND".`;
   } 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%".`;
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. 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. Whenever you stop and wait for user response, say "STATUS:WAITING" followed by "PLEASE RESPOND". When ALL tasks are done, report "COMPLETION: 100%", then say "STATUS:WAITING" and "PLEASE RESPOND".`;
   }
 
   // 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.
+  // Uses the shared AppleScriptManager with detached execution for proper timing.
   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 (_) {}
+      const appleScriptManager = new AppleScriptManager();
+      const sendResult = await appleScriptManager.sendText(instruction, 'windsurf');
+      
+      if (sendResult && sendResult.success) {
+        console.log(chalk.green(`✓ Spec instruction sent to ${providerConfig.displayName}`));
+        console.log(chalk.gray(`⏳ Polling tasks.md every 30s for checkbox progress...\n`));
+        console.log(chalk.gray(`🔄 Coordination: Will wait for agent completion signals before sending new tasks\n`));
+      } else {
+        console.log(chalk.red(`✗ Failed to send instruction to Windsurf: ${sendResult?.error || 'Unknown error'}`));
+        return { success: false, error: sendResult?.error || 'Unknown error' };
       }
     } catch (err) {
       console.log(chalk.red(`✗ AppleScript error: ${err.message}`));
@@ -2434,13 +2507,19 @@ end tell
 
   console.log(chalk.green(`✓ Spec instruction sent to ${providerConfig.displayName}`));
   console.log(chalk.gray(`⏳ Polling tasks.md every 30s for checkbox progress...\n`));
+  console.log(chalk.gray(`🔄 Coordination: Will wait for agent completion signals before sending new tasks\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 TIMEOUT_MS = PROGRESS_TIMEOUT_MS;      // Use configurable progress timeout
+  const PROGRESS_COOLDOWN_MS = 2 * 60 * 1000; // 2 minutes cooldown after progress
 
   const startTime = Date.now();
   let lastContinueSent = Date.now();
+  let lastProgressTime = Date.now(); // Track when we last saw progress
+  let lastProgressDetectionTime = 0; // Track when we last detected progress to implement cooldown
+  let totalAttempts = (spec.totalIdeAttempts || 0) + 1; // Track attempts across IDEs
+  let agentSignaledCompletion = false; // Track if agent signaled completion
 
   return new Promise((resolve) => {
     let interval = null;
@@ -2464,27 +2543,91 @@ end tell
       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`));
+        console.log(chalk.yellow(`⏰ Overall timeout reached - but continuing to monitor existing Windsurf instance\n`));
+        // Don't create new instance - just reset timer and continue monitoring
+        startTime = Date.now(); // Reset the overall timer
         return;
       }
 
-      // Detect any new checkbox ticked since we started
+      // Detect progress AND check if IDE agent is done working
       const { done: doneNow, total: totalNow } = countSpecCheckboxes(spec.path);
+      const currentTime = Date.now();
+
       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`));
+
+        // Update progress tracking
+        lastProgressTime = currentTime;
+        lastProgressDetectionTime = currentTime;
+
+        // Check if all tasks are complete - if so, wait for agent completion signal
+        if (doneNow >= totalNow && totalNow > 0) {
+          console.log(chalk.green(`🎯 All tasks checked off! Waiting for agent completion signal...\n`));
+          // Don't immediately return - wait for STATUS:WAITING signal or timeout
+          agentSignaledCompletion = true; // Flag that we're waiting for completion signal
+        }
+
+        // If progress detected but not all tasks done, continue waiting for agent to finish current work
+        return; // Continue polling, don't send new task yet
+      }
+
+      // If agent signaled completion (all tasks done) and we've waited a reasonable time, consider it complete
+      if (agentSignaledCompletion && (currentTime - lastProgressDetectionTime) >= 30 * 1000) {
+        console.log(chalk.green(`✅ Agent completed all tasks! Finishing iteration.\n`));
         cleanup({ success: true, changes: [] });
         return;
       }
 
-      // Send continuation prompt every 5 minutes if no progress
+      // Implement cooldown period after progress detection to prevent rapid spawning
+      if (lastProgressDetectionTime > 0 && (currentTime - lastProgressDetectionTime) < PROGRESS_COOLDOWN_MS) {
+        const cooldownRemaining = Math.round((PROGRESS_COOLDOWN_MS - (currentTime - lastProgressDetectionTime)) / 1000);
+        console.log(chalk.gray(`⏱️  In cooldown period (${cooldownRemaining}s remaining) - allowing agent time to complete work\n`));
+        return;
+      }
+
+      // Check for no progress timeout (configurable, default 15 minutes)
+      const timeSinceLastProgress = Date.now() - lastProgressTime;
+      if (timeSinceLastProgress >= PROGRESS_TIMEOUT_MS) {
+        console.log(chalk.yellow(`⚠️  No progress detected for ${Math.round(timeSinceLastProgress / 60000)} minutes on ${providerConfig.displayName}\n`));
+
+        // Check if we've exceeded max IDE attempts
+        if (totalAttempts >= MAX_IDE_ATTEMPTS) {
+          console.log(chalk.red(`✗ Maximum IDE attempts (${MAX_IDE_ATTEMPTS}) reached. Stopping auto mode.\n`));
+          // Stop auto mode - call async function properly
+          stopAutoMode().then(() => {
+            cleanup({ success: false, error: 'max_ide_attempts_exceeded', shouldRetry: false });
+          }).catch((err) => {
+            console.error('Error stopping auto mode:', err);
+            cleanup({ success: false, error: 'max_ide_attempts_exceeded', shouldRetry: false });
+          });
+          return;
+        }
+
+        // Don't create new instance - just continue monitoring and send continuation messages
+        // Reset the progress timer to allow more time for the existing instance
+        lastProgressTime = Date.now();
+        totalAttempts++;
+        console.log(chalk.yellow(`⚠️  Allowing more time for existing Windsurf instance (attempt ${totalAttempts}/${MAX_IDE_ATTEMPTS})\n`));
+        return;
+      }
+
+      // Send continuation prompt every 5 minutes if no progress OR if waiting for completion signal
       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)`;
+
+        let continueMsg;
+        if (agentSignaledCompletion) {
+          // All tasks done, waiting for completion signal
+          continueMsg = `All tasks appear to be completed (${doneNow}/${totalNow} tasks). If you are truly finished, please report "COMPLETION: 100%" followed by "STATUS:WAITING" and "PLEASE RESPOND". If you need more time, continue working and report progress. (${mins}min elapsed) PLEASE RESPOND`;
+        } else {
+          // Normal continuation prompt
+          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) PLEASE RESPOND`;
+        }
+
         try {
           const appleScriptManager = new AppleScriptManager();
           // Use plain sendText for continuations (no need to open new thread)
@@ -2956,10 +3099,88 @@ async function loadEnabledIncompleteSpecs(repoPath) {
 
 // ─────────────────────────────────────────────────────────────────────────────
 
+/**
+ * Process default requirement until completion
+ * @param {RequirementSequencer} sequencer - Requirement sequencer
+ * @param {DefaultRequirementManager} defaultManager - Default requirement manager
+ * @param {Object} providerConfig - Provider configuration
+ * @param {string} repoPath - Repository path
+ */
+async function processDefaultRequirement(sequencer, defaultManager, providerConfig, repoPath) {
+  const requirementsPath = await getRequirementsPath(repoPath);
+  let iterationCount = 0;
+
+  while (true) {
+    // Check if default requirement should stop
+    const shouldStop = await defaultManager.shouldStop();
+    if (shouldStop) {
+      const status = await defaultManager.getStatus();
+      console.log(chalk.bold.green(`\n✅ Default Requirement Complete`));
+      console.log(chalk.gray(`Status: ${status.completionReason || 'Completed'}\n`));
+      break;
+    }
+
+    // Check if regular requirements were added (should pause default)
+    const currentState = await sequencer.getCurrentState(requirementsPath);
+    if (currentState.hasRegularRequirements) {
+      console.log(chalk.bold.yellow('\n⏸️  Default Requirement Paused'));
+      console.log(chalk.gray('New regular requirements detected, pausing default requirement...\n'));
+      await defaultManager.pause();
+      break;
+    }
+
+    // Get current default requirement status
+    const defaultStatus = await defaultManager.getStatus();
+    iterationCount = defaultStatus.iterationCount + 1;
+
+    console.log(chalk.bold.cyan(`\n${'━'.repeat(80)}`));
+    console.log(chalk.bold.cyan(`  ⭐ DEFAULT REQUIREMENT - Iteration ${iterationCount}/${defaultStatus.maxIterations}`));
+    console.log(chalk.bold.cyan(`  ${defaultStatus.title}`));
+    console.log(chalk.bold.cyan(`${'━'.repeat(80)}\n`));
+
+    // Create a synthetic requirement object for the default requirement
+    const defaultRequirement = {
+      text: defaultStatus.description,
+      number: iterationCount,
+      isDefault: true
+    };
+
+    // Run iteration with default requirement
+    const result = await runIteration(defaultRequirement, providerConfig, repoPath);
+
+    if (result.success) {
+      // Increment iteration count
+      await defaultManager.incrementIteration();
+      console.log(chalk.bold.green(`✅ Default Requirement Iteration ${iterationCount}/${defaultStatus.maxIterations} COMPLETE`));
+
+      // Small delay between iterations
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    } else {
+      // Record failure
+      await defaultManager.recordFailure();
+      console.log(chalk.bold.red(`❌ Default Requirement Iteration ${iterationCount}/${defaultStatus.maxIterations} FAILED`));
+      console.log(chalk.red(`Error: ${result.error}\n`));
+
+      // Check consecutive failures
+      const updatedStatus = await defaultManager.getStatus();
+      if (updatedStatus.consecutiveFailures >= 5) {
+        console.log(chalk.bold.yellow('\n⚠️  Maximum consecutive failures reached'));
+        await defaultManager.markDone('Stopped due to consecutive failures');
+        break;
+      }
+
+      // Delay longer after failure
+      await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+  }
+}
+
 /**
  * Main auto mode command handler
  */
 async function handleAutoStart(options) {
+  let stopMonitoring = null; // Declare outside try block so it's accessible in catch
+
   try {
     // STRICT AUTH CHECK
     const auth = require('../utils/auth');
@@ -2986,20 +3207,68 @@ async function handleAutoStart(options) {
       return;
     }
 
+    // Create keyboard handler for 'x' key exit
+    keyboardHandler = createKeyboardHandler({
+      onExit: () => {
+        // Update status to stopped
+        updateAutoModeStatus(repoPath, { running: false });
+        console.log(chalk.gray('Auto mode stopped'));
+      }
+    });
+
+    // Start keyboard handler
+    keyboardHandler.start();
+
+    // Ensure keyboard handler is cleaned up on exit
+    const cleanup = () => {
+      if (keyboardHandler) {
+        keyboardHandler.stop();
+      }
+    };
+
+    // Handle process termination
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+      cleanup();
+      process.exit(0);
+    });
+
     // 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();
 
+    // Initialize requirement monitoring for default requirement management
+    const requirementsPath = await getRequirementsPath(repoPath);
+    const storage = new JSONStorage();
+    const parser = new RequirementFileParser();
+    const defaultManager = new DefaultRequirementManager(storage);
+    const sequencer = new RequirementSequencer(parser, defaultManager);
+
+    // Start monitoring requirements file for changes
+    stopMonitoring = sequencer.monitorRequirements(requirementsPath, async (changeType, change) => {
+      if (changeType === 'regular-requirements-added') {
+        console.log(chalk.bold.yellow('\n📝 New regular requirements detected'));
+        console.log(chalk.gray('Default requirement will be paused to process regular requirements first\n'));
+      } else if (changeType === 'regular-requirements-completed') {
+        console.log(chalk.bold.green('\n✅ All regular requirements completed'));
+        console.log(chalk.gray('Default requirement will be resumed\n'));
+      }
+    });
+
     console.log(chalk.white(t('auto.repository')), chalk.cyan(repoPath));
 
     // Use the agent that was already determined by provider preferences in interactive.js
@@ -3038,6 +3307,9 @@ async function handleAutoStart(options) {
       console.log(chalk.bold.cyan(`\n📋 Processing ${incompleteSpecs.length} incomplete spec(s) before requirements...\n`));
 
       for (const spec of incompleteSpecs) {
+        // Initialize IDE attempts tracking for this spec
+        spec.totalIdeAttempts = 0;
+
         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})`));
@@ -3126,8 +3398,8 @@ end tell
                   _execSync2(`osascript "${_tmpScpt2}"`, { stdio: 'pipe', timeout: 30000 });
                   return { success: true };
                 } finally {
-                  try { _unlinkSync2(_tmpScpt2); } catch (_) {}
-                  try { _unlinkSync2(_tmpText2); } catch (_) {}
+                  try { _unlinkSync2(_tmpScpt2); } catch (_) { }
+                  try { _unlinkSync2(_tmpText2); } catch (_) { }
                 }
               } else {
                 const appleScriptManager = new AppleScriptManager();
@@ -3186,6 +3458,58 @@ end tell
           }
         }
 
+        // Verify tasks.md has checkbox-format tasks
+        const { done: doneCheck, total: totalCheck } = countSpecCheckboxes(spec.path);
+        if (totalCheck === 0 && spec.hasTasks) {
+          console.log(chalk.yellow(`\n⚠️  tasks.md exists but has no checkbox tasks (narrative format detected)`));
+          console.log(chalk.yellow(`   Regenerating tasks.md with /speckit.tasks...\n`));
+
+          // Send task regeneration instruction to IDE
+          const tasksRegenerationText = `Run /speckit.tasks to regenerate tasks.md for spec "${spec.directory}" in checkbox format (- [ ] task).`;
+
+          let regenResult;
+          if (providerConfig.type === 'ide') {
+            console.log(chalk.cyan(`📤 Sending tasks regeneration request to ${providerConfig.displayName}...\n`));
+            const ideType = providerConfig.provider || providerConfig.ide;
+            const appleScriptManager = new AppleScriptManager();
+            try {
+              const sendResult = typeof appleScriptManager.sendTextWithThreadClosure === 'function'
+                ? await appleScriptManager.sendTextWithThreadClosure(tasksRegenerationText, ideType)
+                : await appleScriptManager.sendText(tasksRegenerationText, ideType);
+
+              if (!sendResult || !sendResult.success) {
+                console.log(chalk.red(`✗ Failed to send to ${providerConfig.displayName}`));
+                regenResult = { success: false };
+              } else {
+                console.log(chalk.green(`✓ Regeneration request sent. Waiting for tasks.md to be updated...`));
+                // Give IDE time to regenerate (30 seconds)
+                await new Promise(resolve => setTimeout(resolve, 30000));
+
+                // Check if tasks now have checkboxes
+                const { total: totalAfterRegen } = countSpecCheckboxes(spec.path);
+                if (totalAfterRegen > 0) {
+                  console.log(chalk.green(`✓ tasks.md regenerated with ${totalAfterRegen} checkbox tasks!\n`));
+                  regenResult = { success: true };
+                } else {
+                  console.log(chalk.yellow(`⚠️  tasks.md still has no checkbox tasks after regeneration\n`));
+                  regenResult = { success: false };
+                }
+              }
+            } catch (err) {
+              regenResult = { success: false, error: err.message };
+            }
+          } else {
+            const regenRequirement = { text: tasksRegenerationText, package: null, disabled: false };
+            regenResult = await runIteration(regenRequirement, providerConfig, repoPath);
+          }
+
+          if (!regenResult.success) {
+            console.log(chalk.red('✗ Failed to regenerate 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);
@@ -3237,27 +3561,53 @@ end tell
 
           if (result.success) {
             specProviderAttempts = 0;
+            spec.totalIdeAttempts = 0; // Reset IDE attempts on success
             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';
+            const isMaxAttemptsExceeded = result.error === 'max_ide_attempts_exceeded';
+            const isNoProgress = result.error === 'no_progress';
+
+            let errorType = 'Error';
+            if (isRateLimitError) errorType = 'Rate limit';
+            else if (isMaxAttemptsExceeded) errorType = 'Max IDE attempts exceeded';
+            else if (isNoProgress) errorType = 'No progress';
+
+            // Update total IDE attempts tracking
+            if (result.totalAttempts) {
+              spec.totalIdeAttempts = result.totalAttempts;
+            }
 
             specProviderAttempts++;
             failedCount++;
 
+            if (isMaxAttemptsExceeded) {
+              // Auto mode was stopped, exit completely
+              console.log(chalk.red(`\n✗ ${errorType} — auto mode stopped\n`));
+              return { completedCount, 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...`));
+            if (isNoProgress) {
+              console.log(chalk.yellow(`⚠️  ${errorType} on ${providerConfig.displayName}, switching IDE...`));
+            } else {
+              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`));
+            } else {
+              console.log(chalk.red(`✗ No alternative providers available\n`));
+              break;
             }
           }
         }
@@ -3276,12 +3626,29 @@ end tell
       // Get current requirement first to check if there are any TODO items
       const requirement = await getCurrentRequirement(repoPath);
       if (!requirement) {
-        if (completedCount > 0 || failedCount > 0) {
-          console.log(chalk.bold.yellow('\n🎉 All requirements completed!'));
+        // Check if we should process default requirement
+        const requirementsPath = await getRequirementsPath(repoPath);
+        const storage = new JSONStorage();
+        const parser = new RequirementFileParser();
+        const defaultManager = new DefaultRequirementManager(storage);
+        const sequencer = new RequirementSequencer(parser, defaultManager);
+
+        const shouldProcessDefault = await sequencer.shouldProcessDefault(requirementsPath);
+
+        if (shouldProcessDefault) {
+          console.log(chalk.bold.cyan('\n⭐ Default Requirement Mode'));
+          console.log(chalk.gray('All regular requirements completed, processing default requirement...\n'));
+
+          // Process default requirement until completion or max iterations
+          await processDefaultRequirement(sequencer, defaultManager, providerConfig, repoPath);
         } else {
-          console.log(chalk.bold.yellow('\n🎉 No requirements to process.'));
+          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`));
         }
-        console.log(chalk.gray(`${t('auto.direct.no.more.todo.items')}\n`));
         break;
       }
 
@@ -3426,12 +3793,32 @@ end tell
     // Stop Auto Mode status tracking
     await stopAutoMode('completed');
 
+    // Clean up keyboard handler
+    if (keyboardHandler) {
+      keyboardHandler.stop();
+    }
+
+    // Stop requirement monitoring
+    if (stopMonitoring) {
+      stopMonitoring();
+    }
+
   } catch (error) {
     console.error(chalk.red('\n' + t('auto.fatal.error')), error.message);
     if (error.stack) {
       console.log(chalk.gray(error.stack));
     }
 
+    // Clean up keyboard handler
+    if (keyboardHandler) {
+      keyboardHandler.stop();
+    }
+
+    // Stop requirement monitoring
+    if (stopMonitoring) {
+      stopMonitoring();
+    }
+
     // Stop Auto Mode status tracking on fatal error
     await stopAutoMode('error');
     process.exit(1);