vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/auto-mode/AutoModeBusinessLogic.js

@@ -0,0 +1,836 @@
+/**
+ * Shared Auto Mode Business Logic
+ * Common auto mode functionality used by both CLI and GUI
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Try to require the actual modules, fall back to mocks if not available
+let AppleScriptManager, ClineCLIManager, AiderCLIManager, ClaudeCodeCLIManager, logIDEMessage, runContinueCLIAutoMode, CDPManager, QuotaDetector, ChatManager;
+
+try {
+  const applescriptManager = require('../ide-integration/applescript-manager.cjs');
+  AppleScriptManager = applescriptManager.AppleScriptManager;
+  ClineCLIManager = applescriptManager.ClineCLIManager;
+  AiderCLIManager = applescriptManager.AiderCLIManager;
+  ClaudeCodeCLIManager = applescriptManager.ClaudeCodeCLIManager;
+  logIDEMessage = applescriptManager.logIDEMessage;
+  runContinueCLIAutoMode = applescriptManager.runContinueCLIAutoMode;
+} catch (e) {
+  // Mock implementations
+  AppleScriptManager = class MockAppleScriptManager {};
+  ClineCLIManager = class MockClineCLIManager {};
+  AiderCLIManager = class MockAiderCLIManager {};
+  ClaudeCodeCLIManager = class MockClaudeCodeCLIManager {};
+  logIDEMessage = () => {};
+  runContinueCLIAutoMode = () => {};
+}
+
+try {
+  CDPManager = require('../ide-integration/cdp-manager.cjs').CDPManager;
+} catch (e) {
+  CDPManager = class MockCDPManager {};
+}
+
+try {
+  QuotaDetector = require('../ide-integration/quota-detector.cjs').QuotaDetector;
+} catch (e) {
+  QuotaDetector = class MockQuotaDetector {};
+}
+
+try {
+  ChatManager = require('../chat-management/chat-manager.cjs').ChatManager;
+} catch (e) {
+  ChatManager = class MockChatManager {};
+}
+
+class AutoModeBusinessLogic {
+  constructor() {
+    this.state = {
+      isAutoMode: false,
+      currentIDE: 'vscode',
+      chatCounter: 0,
+      maxChats: 100,
+      neverStop: false,
+      autoModeEvent: null,
+      currentMode: 'requirements', // 'spec' | 'requirements'
+      currentSpecPath: null,
+      currentSpecId: null,
+      specsList: null,
+      currentSpecIndex: 0,
+      powerSaveBlockerId: null
+    };
+  }
+
+  /**
+   * Get available LLM providers from config and environment variables
+   * @param {Object} savedConfig - Config object
+   * @returns {Array<{provider: string, model: string, apiKey?: string}>}
+   */
+  getAvailableProviders(savedConfig) {
+    const providers = [];
+
+    // Check for Groq (current primary)
+    const groqApiKey = process.env.GROQ_API_KEY || savedConfig.groqApiKey;
+    if (groqApiKey && groqApiKey.trim()) {
+      providers.push({
+        provider: 'groq',
+        model: savedConfig.aiderModel || 'groq/llama-3.3-70b-versatile',
+        apiKey: groqApiKey
+      });
+    }
+
+    // Check for Anthropic (Claude)
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY || savedConfig.anthropicApiKey;
+    if (anthropicApiKey && anthropicApiKey.trim()) {
+      providers.push({
+        provider: 'anthropic',
+        model: 'claude-3-5-sonnet-20241022',
+        apiKey: anthropicApiKey
+      });
+    }
+
+    // Check for OpenAI
+    const openaiApiKey = process.env.OPENAI_API_KEY || savedConfig.openaiApiKey;
+    if (openaiApiKey && openaiApiKey.trim()) {
+      providers.push({
+        provider: 'openai',
+        model: 'gpt-4-turbo-2024-04-09',
+        apiKey: openaiApiKey
+      });
+    }
+
+    // Always add Ollama as fallback (local, no API key needed)
+    providers.push({
+      provider: 'ollama',
+      model: 'qwen2.5-coder:32b'
+    });
+
+    return providers;
+  }
+
+  /**
+   * Check if current requirement is DONE and actually completed
+   * @param {string} repoPath - Repository path
+   * @returns {Promise<{isDone: boolean, actuallyComplete: boolean, reason?: string}>}
+   */
+  async isRequirementDone(repoPath) {
+    try {
+      const { getRequirementsPath } = require('../index');
+      const reqPath = await getRequirementsPath(repoPath);
+
+      if (!reqPath || !await fs.pathExists(reqPath)) {
+        return { isDone: false, actuallyComplete: false };
+      }
+
+      const content = await fs.readFile(reqPath, 'utf8');
+      const lines = content.split('\n');
+
+      // Check RESPONSE section for "Status updated from VERIFY to DONE"
+      let inResponseSection = false;
+      let responseContent = '';
+      let statusIsDone = false;
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        if (trimmed.includes('## RESPONSE FROM LAST CHAT')) {
+          inResponseSection = true;
+          continue;
+        }
+
+        if (inResponseSection) {
+          if (trimmed.startsWith('##') && !trimmed.includes('RESPONSE')) {
+            break;
+          }
+          if (trimmed && !trimmed.startsWith('###')) {
+            responseContent += trimmed + ' ';
+
+            // Check for status progression completion
+            const upperLine = trimmed.toUpperCase();
+            if (upperLine.includes('STATUS UPDATED FROM VERIFY TO DONE') ||
+                upperLine.includes('STATUS: DONE') ||
+                upperLine.includes('MOVED TO VERIFIED')) {
+              statusIsDone = true;
+            }
+          }
+        }
+      }
+
+      if (!statusIsDone) {
+        return { isDone: false, actuallyComplete: false };
+      }
+
+      // Check if response shows actual work was done
+      const responseUpper = responseContent.toUpperCase();
+      const hasSubstantialResponse = responseContent.length > 100 && (
+        responseUpper.includes('COMPLETE') ||
+        responseUpper.includes('IMPLEMENTED') ||
+        responseUpper.includes('CREATED') ||
+        responseUpper.includes('UPDATED') ||
+        responseUpper.includes('ADDED') ||
+        responseUpper.includes('FIXED') ||
+        responseUpper.includes('VERIFIED') ||
+        responseUpper.match(/DONE.*-.*completed/i) ||
+        responseUpper.includes('100') && responseUpper.includes('REQUIREMENT') // For "create 100 requirements"
+      );
+
+      // Also check for vague responses that indicate incomplete work
+      const isVagueResponse = responseUpper.includes('I WILL') ||
+        responseUpper.includes('I\'LL') ||
+        responseUpper.includes('LET ME') ||
+        responseUpper.includes('I CAN') ||
+        responseUpper.includes('I SHOULD') ||
+        (responseUpper.includes('READ') && !responseUpper.includes('CREATED')) ||
+        (responseUpper.includes('UNDERSTAND') && !responseUpper.includes('IMPLEMENTED'));
+
+      if (statusIsDone && hasSubstantialResponse && !isVagueResponse) {
+        return { isDone: true, actuallyComplete: true };
+      }
+
+      if (statusIsDone && (!hasSubstantialResponse || isVagueResponse)) {
+        return {
+          isDone: true,
+          actuallyComplete: false,
+          reason: isVagueResponse ? 'Vague response detected' : 'No substantial work in response'
+        };
+      }
+
+      return { isDone: false, actuallyComplete: false };
+    } catch (error) {
+      return { isDone: false, actuallyComplete: false };
+    }
+  }
+
+  /**
+   * Move a requirement from Verified back to Requirements not yet completed
+   * @param {string} repoPath - Repository path
+   * @param {string} requirementText - The requirement text to move back
+   * @returns {Promise<{success: boolean, error?: string}>}
+   */
+  async moveRequirementBackToTodo(repoPath, requirementText) {
+    try {
+      const { getRequirementsPath } = require('../index');
+      const reqPath = await getRequirementsPath(repoPath);
+
+      if (!reqPath || !await fs.pathExists(reqPath)) {
+        return { success: false, error: 'Requirements file not found' };
+      }
+
+      const content = await fs.readFile(reqPath, 'utf8');
+      const lines = content.split('\n');
+      const updatedLines = [];
+
+      let inVerifiedSection = false;
+      let requirementFound = false;
+      let inNotYetCompleted = false;
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+
+        // Find verified section
+        if (line.includes('## ✅ Verified by AI screenshot')) {
+          inVerifiedSection = true;
+          updatedLines.push(line);
+          continue;
+        }
+
+        // Find not yet completed section
+        if (line.includes('## ⏳ Requirements not yet completed')) {
+          inNotYetCompleted = true;
+          inVerifiedSection = false;
+          updatedLines.push(line);
+          continue;
+        }
+
+        // Check if we're in verified section and this is requirement to move
+        if (inVerifiedSection && trimmed.startsWith('- ')) {
+          const lineRequirement = line.substring(2).trim();
+          // Remove date prefix if present (format: "2025-11-05: **requirement**")
+          const cleanRequirement = lineRequirement.replace(/^\d{4}-\d{2}-\d{2}:\s*\*\*/, '').replace(/\*\*$/, '').trim();
+          const cleanRequirementText = requirementText.replace(/\*\*/g, '').trim();
+
+          if (lineRequirement.includes(requirementText) || cleanRequirement === cleanRequirementText) {
+            // Skip this line (don't add it to updatedLines)
+            requirementFound = true;
+            continue;
+          }
+        }
+
+        // If we're in not yet completed section and haven't added requirement yet, add it at the top
+        if (inNotYetCompleted && !requirementFound && trimmed.startsWith('- ')) {
+          // Add the requirement before the first existing requirement
+          const newUpdatedLines = lines.slice(0, i);
+          newUpdatedLines.push(`- ${requirementText}`);
+          newUpdatedLines.push('');
+          newUpdatedLines.push(...lines.slice(i));
+          await fs.writeFile(reqPath, newUpdatedLines.join('\n'));
+          return { success: true };
+        }
+
+        // Reset section flags when hitting new sections
+        if (trimmed.startsWith('##')) {
+          inVerifiedSection = false;
+          inNotYetCompleted = false;
+        }
+
+        updatedLines.push(line);
+      }
+
+      // If requirement wasn't found in verified section, try to add it to not yet completed anyway
+      if (!requirementFound) {
+        // Find the not yet completed section and add requirement at the top
+        const newUpdatedLines = lines.slice();
+        for (let i = 0; i < updatedLines.length; i++) {
+          if (updatedLines[i].includes('## ⏳ Requirements not yet completed')) {
+            // Find the first requirement line after this section
+            let insertIndex = i + 1;
+            while (insertIndex < updatedLines.length &&
+              (updatedLines[insertIndex].trim() === '' || updatedLines[insertIndex].trim().startsWith('#'))) {
+              insertIndex++;
+            }
+            updatedLines.splice(insertIndex, 0, `- ${requirementText}`, '');
+            await fs.writeFile(reqPath, updatedLines.join('\n'));
+            return { success: true };
+          }
+        }
+      }
+
+      return { success: false, error: 'Requirement not found in verified section' };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Move a requirement from TODO to "Requirements needing manual feedback" section
+   * @param {string} repoPath - Repository path
+   * @param {string} requirementText - The requirement text to move
+   * @param {string} questions - Clarifying questions to add
+   * @returns {Promise<{success: boolean, error?: string}>}
+   */
+  async moveRequirementToFeedback(repoPath, requirementText, questions, findings = null) {
+    try {
+      const { getRequirementsPath } = require('../index');
+      const reqPath = await getRequirementsPath(repoPath);
+
+      if (!reqPath || !await fs.pathExists(reqPath)) {
+        return { success: false, error: 'Requirements file not found' };
+      }
+
+      const content = await fs.readFile(reqPath, 'utf8');
+      const lines = content.split('\n');
+
+      let inTodoSection = false;
+      let requirementRemoved = false;
+      let feedbackAdded = false;
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        // Find TODO section
+        if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
+          inTodoSection = true;
+          continue;
+        }
+
+        // Find "Requirements needing manual feedback" section
+        if (trimmed.startsWith('##') && (trimmed.includes('Requirements needing manual feedback') || trimmed.includes('❓ Requirements needing'))) {
+          inTodoSection = false;
+          const updatedLines = lines.slice(0, lines.indexOf(line));
+          updatedLines.push(line);
+
+          // Add blank line if not already present
+          if (updatedLines[updatedLines.length - 2]?.trim() !== '') {
+            updatedLines.push('');
+          }
+
+          // Add requirement with findings and questions at the top of feedback section
+          if (!feedbackAdded) {
+            const today = new Date().toISOString().split('T')[0];
+            updatedLines.push(`- ${today}: **${requirementText}**`);
+
+            // Add AI findings if available
+            if (findings) {
+              updatedLines.push('  **AI found in codebase:**');
+              updatedLines.push(`  ${findings}`);
+              updatedLines.push('');
+            }
+
+            updatedLines.push('  **Clarifying questions:**');
+            const questionLines = questions.split('\n');
+            for (const q of questionLines) {
+              updatedLines.push(`  ${q}`);
+            }
+            updatedLines.push('');
+            feedbackAdded = true;
+          }
+
+          updatedLines.push(...lines.slice(lines.indexOf(line) + 1));
+          await fs.writeFile(reqPath, updatedLines.join('\n'));
+          return { success: true };
+        }
+
+        // Stop sections at next header
+        if (trimmed.startsWith('##')) {
+          inTodoSection = false;
+        }
+
+        // Remove requirement from TODO section (match first occurrence)
+        if (inTodoSection && !requirementRemoved && trimmed.startsWith('- ')) {
+          const reqText = trimmed.substring(2).trim();
+          // Clean both for comparison
+          const cleanReq = reqText.replace(/\*\*/g, '').replace(/^\d{4}-\d{2}-\d{2}:\s*/, '').trim();
+          const cleanTarget = requirementText.replace(/\*\*/g, '').trim();
+
+          if (cleanReq === cleanTarget || reqText.includes(requirementText) || requirementText.includes(cleanReq)) {
+            requirementRemoved = true;
+            continue; // Skip this line
+          }
+        }
+
+        updatedLines.push(line);
+      }
+
+      // If feedback section doesn't exist, create it
+      if (!feedbackAdded) {
+        // Find where to insert the feedback section (after TODO, before VERIFIED)
+        let insertIndex = -1;
+        for (let i = 0; i < updatedLines.length; i++) {
+          if (updatedLines[i].includes('## ✅ Verified by AI') || updatedLines[i].includes('---')) {
+            insertIndex = i;
+            break;
+          }
+        }
+
+        if (insertIndex === -1) {
+          insertIndex = updatedLines.length;
+        }
+
+        const today = new Date().toISOString().split('T')[0];
+        const feedbackSection = [
+          '',
+          '## ❓ Requirements needing manual feedback',
+          '',
+          `- ${today}: **${requirementText}**`
+        ];
+
+        // Add AI findings if available
+        if (findings) {
+          feedbackSection.push('  **AI found in codebase:**');
+          feedbackSection.push(`  ${findings}`);
+          feedbackSection.push('');
+        }
+
+        feedbackSection.push('  **Clarifying questions:**');
+
+        const questionLines = questions.split('\n');
+        for (const q of questionLines) {
+          feedbackSection.push(`  ${q}`);
+        }
+        feedbackSection.push('');
+
+        updatedLines.splice(insertIndex, 0, ...feedbackSection);
+        feedbackAdded = true;
+      }
+
+      await fs.writeFile(reqPath, updatedLines.join('\n'));
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Move completed requirement from TODO to TO VERIFY section (for human verification)
+   * @param {string} repoPath - Repository path
+   * @param {string} completedRequirement - The completed requirement text
+   * @returns {Promise<{success: boolean, error?: string}>}
+   */
+  async moveCompletedRequirement(repoPath, completedRequirement) {
+    try {
+      const { getRequirementsPath } = require('../index');
+      const reqPath = await getRequirementsPath(repoPath);
+
+      if (!reqPath || !await fs.pathExists(reqPath)) {
+        return { success: false, error: 'Requirements file not found' };
+      }
+
+      const content = await fs.readFile(reqPath, 'utf8');
+      const lines = content.split('\n');
+
+      // First, check if requirement is already in TO VERIFY section
+      const verifySectionVariants = [
+        '## 🔍 TO VERIFY BY HUMAN',
+        '## 🔍 TO VERIFY',
+        '## TO VERIFY',
+        '## ✅ TO VERIFY',
+        '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG'
+      ];
+
+      let inVerifySection = false;
+      let alreadyInVerify = false;
+      const normalizedCompleted = completedRequirement.trim();
+      const snippet = normalizedCompleted.substring(0, 80);
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+
+        // Check if we're entering TO VERIFY section
+        if (trimmed.startsWith('##')) {
+          inVerifySection = verifySectionVariants.some(variant => {
+            const variantTrimmed = variant.trim();
+            return trimmed === variantTrimmed || trimmed.startsWith(variantTrimmed);
+          }) && !trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i);
+
+          if (inVerifySection && (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot'))) {
+            continue;
+          }
+        }
+
+        // Check if we're leaving TO VERIFY section
+        if (inVerifySection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+          const isVerifyHeader = verifySectionVariants.some(variant => {
+            const variantTrimmed = variant.trim();
+            return trimmed === variantTrimmed || trimmed.startsWith(variantTrimmed);
+          });
+          if (!isVerifyHeader) {
+            inVerifySection = false;
+          }
+        }
+
+        // Check if requirement is already in TO VERIFY
+        if (inVerifySection && trimmed.startsWith('###')) {
+          const title = trimmed.replace(/^###\s*/, '').trim();
+          if (title) {
+            const normalizedTitle = title.trim();
+            if (normalizedTitle === normalizedCompleted ||
+              normalizedTitle.includes(normalizedCompleted) ||
+              normalizedCompleted.includes(normalizedTitle) ||
+              normalizedTitle.includes(snippet) ||
+              snippet.includes(normalizedTitle.substring(0, 80))) {
+              alreadyInVerify = true;
+              break;
+            }
+          }
+        }
+      }
+
+      if (alreadyInVerify) {
+        return { success: true }; // Already in TO VERIFY, nothing to do
+      }
+
+      // Find requirement by its title (in ### header format)
+      // Normalize completed requirement text for matching
+      let requirementStartIndex = -1;
+      let requirementEndIndex = -1;
+
+      // Try to find the requirement in TODO section first
+      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;
+        }
+
+        // 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();
+            const titleSnippet = normalizedTitle.substring(0, 80);
+
+            // Exact match
+            if (normalizedTitle === normalizedCompleted) {
+              requirementStartIndex = i;
+            }
+            // Check if either contains the other (for partial matches)
+            else if (normalizedTitle.includes(normalizedCompleted) || normalizedCompleted.includes(normalizedTitle)) {
+              requirementStartIndex = i;
+            }
+            // Check snippet matches
+            else if (normalizedTitle.includes(snippet) || snippet.includes(titleSnippet)) {
+              requirementStartIndex = i;
+            }
+            // Check if they start with the same (for REGRESSION: prefix issues)
+            else if (normalizedTitle.replace(/^REGRESSION:\s*/i, '') === normalizedCompleted.replace(/^REGRESSION:\s*/i, '') ||
+              normalizedTitle.replace(/^REGRESSION:\s*/i, '').includes(snippet.replace(/^REGRESSION:\s*/i, '')) ||
+              snippet.replace(/^REGRESSION:\s*/i, '').includes(normalizedTitle.replace(/^REGRESSION:\s*/i, ''))) {
+              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 (requirementStartIndex === -1) {
+        return { success: false, error: `Could not find requirement "${completedRequirement.substring(0, 60)}..." in TODO section` };
+      }
+
+      // Extract the entire requirement block
+      const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+
+      // Remove the requirement from its current location
+      lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+
+      // Find or create TO VERIFY BY HUMAN section (reuse the variants we defined earlier)
+      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'))) {
+              verifyIndex = 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;
+        }
+
+        const block = [];
+        if (insertionIndex > 0 && lines[insertionIndex - 1].trim() !== '') {
+          block.push('');
+        }
+        block.push('## 🔍 TO VERIFY BY HUMAN', '');
+        lines.splice(insertionIndex, 0, ...block);
+        verifyIndex = lines.findIndex(line => {
+          const trimmed = line.trim();
+          return trimmed === '## 🔍 TO VERIFY BY HUMAN' || trimmed.startsWith('## 🔍 TO VERIFY BY HUMAN');
+        });
+
+        if (verifyIndex === -1) {
+          return { success: false, error: 'Failed to create TO VERIFY BY HUMAN section' };
+        }
+      }
+
+      // 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'))) {
+        return { success: false, error: 'Attempted to insert into VERIFIED section instead of TO VERIFY' };
+      }
+
+      // Insert requirement block at the 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++;
+      }
+
+      // 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, '');
+      }
+
+      // Write the file
+      await fs.writeFile(reqPath, lines.join('\n'));
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Handle sending text to IDE with proper error handling and session limits
+   * @param {Object} event - Event object
+   * @param {string} ide - IDE name
+   * @param {string} text - Text to send
+   * @param {string} extension - Extension name
+   * @returns {Promise<Object>} Send result
+   */
+  async handleSendText(event, ide, text, extension) {
+    try {
+      const manager = new AppleScriptManager();
+
+      // IMPORTANT: Distinguish between 'windsurf' IDE and 'vscode' with windsurf extension
+      // If ide is 'windsurf', use the standalone Windsurf IDE, NOT VS Code with extension
+      // Only route to VS Code if ide is explicitly 'vscode' with windsurf extension
+      let result;
+      if (ide === 'vscode' && extension === 'windsurf') {
+        // Use VS Code with Windsurf extension
+        result = await manager.sendText(text, 'vscode', global.currentRepoPath);
+      } else if (ide === 'windsurf') {
+        // For standalone Windsurf IDE, send directly to Windsurf
+        result = await manager.sendText(text, 'windsurf', global.currentRepoPath);
+      } else {
+        result = await manager.sendText(text, ide, global.currentRepoPath);
+      }
+
+      // Handle Claude session limit
+      if (ide === 'claude' && result.success) {
+        // Wait a moment for Claude to respond
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        const sessionCheck = await manager.checkClaudeSessionLimit();
+
+        if (sessionCheck.sessionLimitReached) {
+          // Notify renderer process
+          if (global.mainWindow && global.mainWindow.webContents) {
+            global.mainWindow.webContents.send('claude-session-limit-reached', {
+              message: sessionCheck.message,
+              note: sessionCheck.note,
+              resetTime: sessionCheck.resetTime,  // Pass reset time to UI
+              recentOutput: sessionCheck.recentOutput
+            });
+          }
+
+          // Pause auto mode if it's running
+          if (this.state.isAutoMode) {
+            this.state.isAutoMode = false;
+          }
+
+          return {
+            success: false,
+            sessionLimitReached: true,
+            error: 'Claude session limit reached',
+            ...sessionCheck
+          };
+        }
+      }
+
+      // Handle other IDE quota limits
+      if (result.success) {
+        const quotaChecks = [
+          { ide: 'antigravity', checkMethod: 'checkAntigravityQuotaLimit', eventName: 'antigravity-quota-limit-reached' },
+          { ide: 'cursor', checkMethod: 'checkCursorQuotaLimit', eventName: 'cursor-quota-limit-reached' },
+          { ide: 'kiro', checkMethod: 'checkKiroQuotaLimit', eventName: 'kiro-quota-limit-reached' },
+          { ide: 'windsurf', checkMethod: 'checkWindsurfRateLimit', eventName: 'windsurf-rate-limit-reached' }
+        ];
+
+        for (const { ide: targetIde, checkMethod, eventName } of quotaChecks) {
+          if (ide === targetIde) {
+            try {
+              await new Promise(resolve => setTimeout(resolve, 2000));
+              const quotaCheck = await manager[checkMethod]();
+
+              if (quotaCheck && quotaCheck.isRateLimited) {
+                // Notify renderer process
+                if (global.mainWindow && global.mainWindow.webContents) {
+                  global.mainWindow.webContents.send(eventName, {
+                    message: quotaCheck.message,
+                    resumeAt: quotaCheck.resumeAt || null
+                  });
+                }
+
+                // Pause auto mode if it's running
+                if (this.state.isAutoMode) {
+                  this.state.isAutoMode = false;
+                }
+
+                return {
+                  success: false,
+                  rateLimited: true,
+                  error: `${targetIde} quota limit reached`,
+                  ...quotaCheck
+                };
+              }
+            } catch (quotaErr) {
+              // Continue on quota check errors
+            }
+          }
+        }
+      }
+
+      return result;
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Update auto mode state
+   * @param {Object} newState - New state to merge
+   */
+  updateState(newState) {
+    Object.assign(this.state, newState);
+  }
+
+  /**
+   * Get current auto mode state
+   * @returns {Object} Current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+
+  /**
+   * Reset auto mode state
+   */
+  resetState() {
+    this.state = {
+      isAutoMode: false,
+      currentIDE: 'vscode',
+      chatCounter: 0,
+      maxChats: 100,
+      neverStop: false,
+      autoModeEvent: null,
+      currentMode: 'requirements',
+      currentSpecPath: null,
+      currentSpecId: null,
+      specsList: null,
+      currentSpecIndex: 0
+    };
+  }
+}
+
+module.exports = AutoModeBusinessLogic;