vibecodingmachine-cli 1.0.0

package/src/commands/auto.js

@@ -0,0 +1,4692 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const os = require('os');
+const { AppleScriptManager, ClineCLIManager, AiderCLIManager, ClaudeCodeCLIManager, logIDEMessage, runContinueCLICommand, runContinueCLIAutoMode } = require('@vibecodingmachine/core');
+const { getRepoPath, getAutoConfig, setAutoConfig } = require('../utils/config');
+const { checkAutoModeStatus, startAutoMode, stopAutoMode, updateAutoModeStatus } = require('../utils/auto-mode');
+const logger = require('../utils/logger');
+const { createKeyboardHandler } = require('../utils/keyboard-handler');
+const { getProviderDefinitions, getProviderPreferences } = require('../utils/provider-registry');
+const PROVIDER_DEFINITIONS = getProviderDefinitions();
+const DIRECT_AGENT_IDS = PROVIDER_DEFINITIONS.filter(def => def.type === 'direct').map(def => def.id);
+const PROVIDER_DEFINITION_MAP = new Map(PROVIDER_DEFINITIONS.map(def => [def.id, def]));
+const { handleAutoStart: handleDirectAutoStart } = require('./auto-direct');
+
+const DEFAULT_INSTRUCTION_TEXT = 'Follow INSTRUCTIONS.md from .vibecodingmachine directory.\n\nCRITICAL FOR IDE AGENTS: You MUST work through ALL stages (ACT → CLEAN UP → VERIFY → DONE) without stopping. Update the "🚦 Current Status" section in the REQUIREMENTS file as you progress through each stage. DO NOT stop after acknowledging stages - you must COMPLETE the work and set status to DONE in the requirements file. The CLI is monitoring the file and waiting for you to finish.';
+
+/**
+ * Get available LLM providers from config and environment variables
+ * @param {Object} savedConfig - Config object from getAutoConfig()
+ * @returns {Array<{provider: string, model: string, apiKey?: string}>}
+ */
+function 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 function isRequirementDone(repoPath) {
+  try {
+    const { getRequirementsPath } = require('@vibecodingmachine/core');
+    const fs = require('fs-extra');
+    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 function moveRequirementBackToTodo(repoPath, requirementText) {
+  try {
+    const { getRequirementsPath } = require('@vibecodingmachine/core');
+    const fs = require('fs-extra');
+    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];
+
+      // 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 the requirement to move
+      if (inVerifiedSection && line.trim().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;
+        }
+        updatedLines.push(line);
+        continue;
+      }
+
+      // If we're in not yet completed section and haven't added the requirement yet, add it at the top
+      if (inNotYetCompleted && !requirementFound && line.trim().startsWith('- ')) {
+        // Add the requirement before the first existing requirement
+        updatedLines.push(`- ${requirementText}`);
+        updatedLines.push('');
+        requirementFound = true; // Mark as added so we don't add it again
+      }
+
+      // Reset section flags when hitting new sections
+      if (line.trim().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
+      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}`, '');
+          requirementFound = true;
+          break;
+        }
+      }
+    }
+
+    if (requirementFound) {
+      await fs.writeFile(reqPath, updatedLines.join('\n'));
+      return { success: true };
+    } else {
+      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 function moveRequirementToFeedback(repoPath, requirementText, questions, findings = null) {
+  try {
+    const { getRequirementsPath } = require('@vibecodingmachine/core');
+    const fs = require('fs-extra');
+    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 inTodoSection = false;
+    let inFeedbackSection = 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;
+        inFeedbackSection = false;
+        updatedLines.push(line);
+        continue;
+      }
+
+      // Find "Requirements needing manual feedback" section
+      if (trimmed.startsWith('##') && (trimmed.includes('Requirements needing manual feedback') || trimmed.includes('❓ Requirements needing'))) {
+        inTodoSection = false;
+        inFeedbackSection = true;
+        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;
+        }
+        continue;
+      }
+
+      // Stop sections at next header
+      if (trimmed.startsWith('##')) {
+        inTodoSection = false;
+        inFeedbackSection = 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 function moveCompletedRequirement(repoPath, completedRequirement) {
+  try {
+    const { getRequirementsPath } = require('@vibecodingmachine/core');
+    const fs = require('fs-extra');
+    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 inTodoSection = false;
+    let inVerifiedSection = false;
+    let removedCompleted = false;
+    let addedToVerified = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Find TODO section
+      if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        inVerifiedSection = false;
+        updatedLines.push(line);
+        continue;
+      }
+
+      // Find TO VERIFY section
+      if (trimmed.startsWith('##') && (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot'))) {
+        inTodoSection = false;
+        inVerifiedSection = true;
+        updatedLines.push(line);
+
+        // Add completed requirement at the top of TO VERIFY section
+        if (!addedToVerified) {
+          const today = new Date().toISOString().split('T')[0];
+          updatedLines.push(`- ${today}: **${completedRequirement}**`);
+          addedToVerified = true;
+        }
+        continue;
+      }
+
+      // Stop sections at next header
+      if (trimmed.startsWith('##')) {
+        inTodoSection = false;
+        inVerifiedSection = false;
+      }
+
+      // Remove completed requirement from TODO section (match first occurrence)
+      if (inTodoSection && !removedCompleted && trimmed.startsWith('- ')) {
+        const reqText = trimmed.substring(2).trim();
+        // Simple match - just check if this is the completed requirement
+        if (reqText === completedRequirement ||
+          reqText.includes(completedRequirement) ||
+          completedRequirement.includes(reqText)) {
+          removedCompleted = true;
+          continue; // Skip this line
+        }
+      }
+
+      updatedLines.push(line);
+    }
+
+    await fs.writeFile(reqPath, updatedLines.join('\n'));
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+// Helper function to get timestamp for logs
+function getTimestamp() {
+  const now = new Date();
+
+  // Format as 12-hour time with AM/PM
+  let hours = now.getHours();
+  const minutes = now.getMinutes().toString().padStart(2, '0');
+  const ampm = hours >= 12 ? 'PM' : 'AM';
+  hours = hours % 12;
+  hours = hours ? hours : 12; // 0 should be 12
+
+  // Get timezone abbreviation (e.g., MST, EST, PST)
+  const timeZoneString = now.toLocaleTimeString('en-US', { timeZoneName: 'short' });
+  const timezone = timeZoneString.split(' ').pop(); // Get last part (timezone)
+
+  return `${hours}:${minutes} ${ampm} ${timezone}`;
+}
+
+async function start(options) {
+  // STRICT AUTH CHECK
+  const auth = require('../utils/auth');
+  const isAuth = await auth.isAuthenticated();
+  if (!isAuth) {
+    console.log(chalk.cyan('\n🔐 Opening browser for authentication...\n'));
+    try {
+      await auth.login();
+      console.log(chalk.green('\n✓ Authentication successful!\n'));
+    } catch (error) {
+      console.log(chalk.red('\n✗ Authentication failed:'), error.message);
+      process.exit(1);
+    }
+  }
+
+  // Check for pending updates and install if available
+  if (global.pendingUpdate) {
+    const updateSpinner = ora('Installing update...').start();
+    try {
+      const { spawn } = require('child_process');
+
+      // Install update using npm
+      await new Promise((resolve, reject) => {
+        const npmInstall = spawn('npm', ['install', '-g', 'allnightai-cli'], {
+          stdio: 'inherit'
+        });
+
+        npmInstall.on('close', (code) => {
+          if (code === 0) {
+            updateSpinner.succeed('Update installed successfully!');
+            console.log(chalk.green('\n✓ Restarting with new version...\n'));
+
+            // Restart CLI with same arguments
+            const { spawn } = require('child_process');
+            const args = process.argv.slice(2);
+            spawn(process.argv[0], [process.argv[1], ...args], {
+              stdio: 'inherit',
+              detached: true
+            }).unref();
+
+            process.exit(0);
+          } else {
+            reject(new Error(`npm install exited with code ${code}`));
+          }
+        });
+
+        npmInstall.on('error', reject);
+      });
+    } catch (error) {
+      updateSpinner.fail('Update installation failed');
+      console.log(chalk.yellow('⚠️  Continuing with current version...'));
+      console.log(chalk.gray('Error:', error.message));
+      // Continue with auto mode even if update fails
+    }
+  }
+
+  const spinner = ora('Starting autonomous mode...').start();
+
+  try {
+    const repoPath = await getRepoPath();
+    if (!repoPath) {
+      spinner.fail('No repository configured');
+      console.log(chalk.gray('Run'), chalk.cyan('allnightai repo:set <path>'), chalk.gray('or'), chalk.cyan('allnightai repo:init'));
+      throw new Error('No repository configured');
+    }
+
+    // Read saved auto config first, then override with options
+    const savedConfig = await getAutoConfig();
+    const prefs = await getProviderPreferences();
+    const firstEnabledFromPrefs = prefs.order.find(id => prefs.enabled[id] !== false);
+    const fallbackAgent = firstEnabledFromPrefs || 'claude-code';
+    const savedAgent = savedConfig.agent || savedConfig.ide;
+    const requestedAgent = options.ide || savedAgent || fallbackAgent;
+    const providerDef = PROVIDER_DEFINITION_MAP.get(requestedAgent) || PROVIDER_DEFINITION_MAP.get(fallbackAgent);
+    const effectiveAgent = providerDef ? providerDef.id : 'claude-code';
+
+    const resolvedNeverStop = (() => {
+      if (options.neverStop !== undefined) return options.neverStop;
+      if (savedConfig.neverStop !== undefined) return savedConfig.neverStop;
+      if (!options.maxChats && !savedConfig.maxChats) return true;
+      return false;
+    })();
+
+    const resolvedMaxChats = options.maxChats !== undefined
+      ? options.maxChats
+      : savedConfig.maxChats || null;
+
+    const config = {
+      ide: effectiveAgent,
+      agent: effectiveAgent,
+      maxChats: resolvedMaxChats,
+      neverStop: resolvedNeverStop,
+      // Include Aider/Groq config for fallback
+      aiderModel: savedConfig.aiderModel,
+      aiderProvider: savedConfig.aiderProvider,
+      groqApiKey: savedConfig.groqApiKey
+    };
+
+    await setAutoConfig(config);
+
+    const providerType = providerDef?.type || 'direct';
+
+    if (providerType === 'direct') {
+      spinner.stop();
+      console.log(chalk.cyan('\n🤖 Vibe Coding Machine - Direct API Auto Mode\n'));
+      await handleDirectAutoStart({
+        maxChats: config.neverStop ? undefined : (config.maxChats || undefined)
+      });
+      return;
+    }
+
+    // Check if this is just a provider configuration request (for Continue CLI)
+    if (config.ide === 'continue' && options.configureOnly) {
+      spinner.stop();
+      console.log(chalk.cyan('\n🔐 Configure Continue CLI AI Provider\n'));
+      console.log(chalk.gray('  Continue CLI uses models configured in ~/.continue/config.yaml'));
+      console.log();
+
+      const fs = require('fs');
+      const path = require('path');
+      const os = require('os');
+      const inquirer = require('inquirer');
+      const yaml = require('js-yaml');
+      const configPath = path.join(os.homedir(), '.continue', 'config.yaml');
+
+      let currentConfig = null;
+      let models = [];
+
+      if (fs.existsSync(configPath)) {
+        try {
+          currentConfig = yaml.load(fs.readFileSync(configPath, 'utf8'));
+          models = currentConfig.models || [];
+
+          if (models.length > 0) {
+            const firstModel = models[0];
+            console.log(chalk.green('✓ Current configuration:'));
+            console.log(chalk.gray('  Provider:'), chalk.cyan(firstModel.provider || 'unknown'));
+            if (firstModel.model) {
+              console.log(chalk.gray('  Model:'), chalk.cyan(firstModel.model));
+            }
+            console.log();
+          }
+        } catch (error) {
+          console.log(chalk.yellow('  Configuration file exists but could not be read.'));
+          console.log(chalk.gray('  Edit manually:'), chalk.cyan(configPath));
+          console.log();
+          return;
+        }
+      }
+
+      // Provide interactive provider selection
+      const { action } = await inquirer.prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'Open config file in editor', value: 'open' },
+          { name: 'Show configuration instructions', value: 'instructions' },
+          { name: 'Cancel', value: 'cancel' }
+        ]
+      }]);
+
+      if (action === 'open') {
+        const { exec } = require('child_process');
+        const editor = process.env.EDITOR || process.env.VISUAL || (process.platform === 'darwin' ? 'open' : 'nano');
+        console.log(chalk.gray(`\nOpening ${configPath} in ${editor}...\n`));
+
+        // Create directory if it doesn't exist
+        const configDir = path.dirname(configPath);
+        if (!fs.existsSync(configDir)) {
+          fs.mkdirSync(configDir, { recursive: true });
+        }
+
+        // Create default config if it doesn't exist
+        if (!fs.existsSync(configPath)) {
+          const defaultConfig = {
+            models: [
+              {
+                provider: 'ollama',
+                model: 'qwen2.5:1.5b'
+              }
+            ]
+          };
+          fs.writeFileSync(configPath, yaml.dump(defaultConfig));
+          console.log(chalk.green('✓ Created default config file'));
+        }
+
+        // Open in editor (non-blocking)
+        exec(`${editor} "${configPath}"`, (error) => {
+          if (error) {
+            console.log(chalk.red(`\n✗ Failed to open editor: ${error.message}`));
+            console.log(chalk.gray(`  Please manually edit: ${configPath}`));
+          }
+        });
+
+        console.log(chalk.green('\n✓ Config file opened in editor'));
+        console.log(chalk.gray('  After editing, restart Auto Mode to use the new configuration.\n'));
+      } else if (action === 'instructions') {
+        console.log(chalk.yellow('\n  To change the AI provider:'));
+        console.log(chalk.gray('  1. Edit the config file:'), chalk.cyan(configPath));
+        console.log(chalk.gray('  2. Modify the "models" section with your preferred provider'));
+        console.log(chalk.gray('  3. For Ollama, use:'));
+        console.log(chalk.gray('     models:'));
+        console.log(chalk.gray('       - provider: ollama'));
+        console.log(chalk.gray('         model: qwen2.5:1.5b'));
+        console.log();
+        console.log(chalk.gray('  See Continue CLI documentation for other providers.'));
+        console.log();
+      }
+
+      return;
+    }
+
+    // Only start auto mode if not configureOnly
+    if (!options.configureOnly) {
+      await startAutoMode(repoPath, config);
+    }
+
+    // Send initial instruction to IDE or Continue/Cline CLI
+    const textToSend = options.text || DEFAULT_INSTRUCTION_TEXT;
+
+    if (config.ide === 'continue') {
+      // Use Continue CLI with command-line approach
+      spinner.stop();
+      console.log(chalk.cyan('\n🚀 Starting Continue CLI in auto mode...\n'));
+      console.log(chalk.gray('  Continue CLI will use models configured in ~/.continue/config.yaml'));
+      console.log();
+
+      // Start the auto-mode loop for Continue CLI with callbacks
+      let exitReason = 'completed';
+      try {
+        const result = await runContinueCLIAutoMode(repoPath, textToSend, config, {
+          updateAutoModeStatus,
+          isRequirementDone,
+          moveToNextRequirement
+        });
+        exitReason = result?.exitReason || 'completed';
+      } catch (error) {
+        exitReason = 'error';
+        console.log(chalk.red(`\n✗ Auto mode error: ${error.message}\n`));
+      } finally {
+        // Always clean up Auto Mode status when Continue CLI exits
+        await stopAutoMode(exitReason);
+
+        // If there was an error, pause so user can read the messages
+        if (exitReason === 'error') {
+          console.log(chalk.gray('\nPress Enter to return to menu...'));
+          await new Promise(resolve => {
+            process.stdin.once('data', () => resolve());
+          });
+        }
+      }
+    } else if (config.ide === 'claude-code') {
+      // Use Claude Code CLI
+      const claudeCodeManager = new ClaudeCodeCLIManager();
+
+      // Define common variables
+      const maxChats = config.maxChats || 0; // 0 = unlimited
+
+      // Quick check without spinner
+      spinner.stop();
+      const isInstalled = claudeCodeManager.isInstalled();
+
+      if (!isInstalled) {
+        spinner.text = 'Installing Claude Code CLI...';
+        const installResult = await claudeCodeManager.install();
+
+        if (!installResult.success) {
+          spinner.fail('Failed to install Claude Code CLI');
+          console.log(chalk.red('\n✗ Error:'), installResult.error);
+          console.log(chalk.yellow('\n💡 How to fix:'));
+          if (installResult.suggestions) {
+            installResult.suggestions.forEach(suggestion => {
+              console.log(chalk.gray(`  ${suggestion}`));
+            });
+          }
+          console.log(chalk.gray('\n  Or install manually:'));
+          console.log(chalk.cyan('    npm install -g @anthropic-ai/claude-code'));
+          console.log();
+
+          // Fallback to Aider
+          console.log(chalk.yellow('⚠️  Falling back to Aider CLI...\n'));
+          const aiderManager = new AiderCLIManager();
+          config.ide = 'aider';
+          // Continue with Aider below
+        } else {
+          spinner.succeed('Claude Code CLI installed');
+        }
+      } else {
+        spinner.succeed('Claude Code CLI detected');
+        console.log(chalk.gray(`  Version: ${claudeCodeManager.getVersion()}`));
+      }
+
+      // Check if we're still using Claude Code (didn't fallback to Aider)
+      if (config.ide === 'claude-code') {
+        console.log(chalk.green(`\n✓ Using Claude Code CLI for autonomous mode\n`));
+
+        // Claude Code doesn't need provider/model configuration - it uses Anthropic's Claude models
+        console.log(chalk.cyan(`[${getTimestamp()}] 🚀 Starting Auto Mode...`));
+        console.log(chalk.gray(`  Model: Claude (Anthropic)`));
+        if (maxChats > 0) {
+          console.log(chalk.gray(`  Max chats: ${maxChats}`));
+        } else {
+          console.log(chalk.gray(`  Max chats: unlimited (will run until all requirements complete)`));
+        }
+        console.log(chalk.gray(`  To stop: Press x or Ctrl+C, or run 'ana auto:stop'\n`));
+
+        // Initialize control variables
+        let shouldExit = false;
+        let exitReason = '';
+        let chatCount = 0;
+
+        // Set up keyboard handler for 'x' and Ctrl+C
+        const keyboardHandler = createKeyboardHandler({
+          onExit: () => {
+            console.log(chalk.yellow('\n🛑 Exit requested via keyboard...'));
+            shouldExit = true;
+            exitReason = 'user-exit';
+            claudeCodeManager.killAllProcesses();
+
+            setTimeout(async () => {
+              try {
+                await stopAutoMode(exitReason);
+              } catch (err) {
+                // Ignore
+              }
+              process.exit(0);
+            }, 500);
+          }
+        });
+        keyboardHandler.start();
+
+        // Helper function to print status card
+        function printStatusCard(currentTitle, currentStatus) {
+          const statusIcons = {
+            'PREPARE': '🔨',
+            'ACT': '⏳',
+            'CLEAN UP': '⏳',
+            'VERIFY': '⏳',
+            'DONE': '⏳'
+          };
+
+          const stages = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
+          const stageMap = {
+            'PREPARE': 0,
+            'ACT': 1,
+            'CLEAN UP': 2,
+            'VERIFY': 3,
+            'DONE': 4
+          };
+
+          const currentIndex = stageMap[currentStatus] || 0;
+          const workflowLine = stages.map((stage, idx) => {
+            if (idx < currentIndex) {
+              return `✅ ${stage}`;
+            } else if (idx === currentIndex) {
+              return `🔨 ${stage}`;
+            } else {
+              return `⏳ ${stage}`;
+            }
+          }).join(' → ');
+
+          const titleShort = currentTitle?.substring(0, 56) + (currentTitle?.length > 56 ? '...' : '');
+
+          console.log(chalk.magenta('\n╭────────────────────────────────────────────────────────────────╮'));
+          console.log(chalk.magenta('│') + ' '.repeat(64) + chalk.magenta('│'));
+          console.log(chalk.magenta('│ ') + chalk.white(workflowLine.padEnd(62)) + chalk.magenta(' │'));
+          console.log(chalk.magenta('│') + ' '.repeat(64) + chalk.magenta('│'));
+          console.log(chalk.magenta('│ ') + chalk.white('🎯 Working on: ' + titleShort.padEnd(47)) + chalk.magenta(' │'));
+          console.log(chalk.magenta('│') + ' '.repeat(64) + chalk.magenta('│'));
+          console.log(chalk.magenta('╰────────────────────────────────────────────────────────────────╯\n'));
+        }
+
+        // Helper function to get current requirement details
+        async function getCurrentRequirementDetails() {
+          const { getRequirementsPath } = require('@vibecodingmachine/core');
+          const fs = require('fs-extra');
+          const reqPath = await getRequirementsPath(repoPath);
+
+          if (!reqPath || !await fs.pathExists(reqPath)) {
+            return { title: null, status: 'PREPARE' };
+          }
+
+          const content = await fs.readFile(reqPath, 'utf8');
+          const lines = content.split('\n');
+
+          let title = null;
+          let status = 'PREPARE';
+          let inTodoSection = false;
+
+          for (const line of lines) {
+            if (line.includes('Requirements not yet completed') && line.trim().startsWith('##')) {
+              inTodoSection = true;
+              continue;
+            }
+
+            if (inTodoSection && line.trim().startsWith('- ')) {
+              title = line.substring(2).trim();
+              status = 'PREPARE';
+              break;
+            }
+
+            if (inTodoSection && line.trim().startsWith('##')) {
+              break;
+            }
+          }
+
+          return { title, status };
+        }
+
+        // Helper function to count requirements
+        async function getRequirementCounts() {
+          const { getRequirementsPath } = require('@vibecodingmachine/core');
+          const fs = require('fs-extra');
+          const reqPath = await getRequirementsPath(repoPath);
+
+          if (!reqPath || !await fs.pathExists(reqPath)) {
+            return null;
+          }
+
+          const content = await fs.readFile(reqPath, 'utf8');
+          let todoCount = 0;
+          let toVerifyCount = 0;
+          let verifiedCount = 0;
+
+          const lines = content.split('\n');
+          let currentSection = '';
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+
+            if (trimmed.startsWith('##')) {
+              if (trimmed.includes('⏳ Requirements not yet completed') ||
+                trimmed.includes('Requirements not yet completed')) {
+                currentSection = 'todo';
+              } else if (trimmed.includes('✅ Verified by AI') ||
+                trimmed.includes('Verified by AI')) {
+                currentSection = 'verified';
+              } else {
+                currentSection = '';
+              }
+            }
+
+            if (currentSection && trimmed.startsWith('-')) {
+              const requirementText = trimmed.substring(2).trim();
+              if (requirementText) {
+                if (currentSection === 'todo') {
+                  todoCount++;
+                } else if (currentSection === 'verified') {
+                  verifiedCount++;
+                }
+              }
+            }
+          }
+
+          return { todoCount, toVerifyCount, verifiedCount };
+        }
+
+        try {
+          console.log(chalk.gray('[DEBUG] Starting Claude Code auto mode loop'));
+
+          // Get initial requirement counts
+          const initialCounts = await getRequirementCounts();
+          console.log(chalk.gray(`[DEBUG] Initial counts: ${JSON.stringify(initialCounts)}`));
+
+          // Check if there's a current requirement
+          let { title: currentTitle, status: currentStatus } = await getCurrentRequirementDetails();
+          console.log(chalk.gray(`[DEBUG] Current requirement: ${currentTitle || 'none'}, status: ${currentStatus}`));
+
+          if (!currentTitle) {
+            console.log(chalk.yellow('\n⚠️  No requirements found in TODO list.'));
+            console.log(chalk.green('🎉 All requirements are completed or verified.'));
+            exitReason = 'completed';
+            throw new Error('No requirements to process');
+          }
+
+          let requirementsCompleted = 0;
+
+          // Main auto mode loop
+          if (currentTitle) {
+            while (true) {
+              // Check if user requested exit
+              if (shouldExit) {
+                console.log(chalk.yellow(`\n🛑 Exiting Auto Mode...\n`));
+                break;
+              }
+
+              // Check max chats
+              if (maxChats > 0 && chatCount >= maxChats) {
+                console.log(chalk.yellow(`\n⚠️  Maximum chats reached (${maxChats}). Stopping auto mode.`));
+                exitReason = 'max-chats';
+                break;
+              }
+
+              // Get current requirement details
+              const details = await getCurrentRequirementDetails();
+              currentTitle = details.title;
+              currentStatus = details.status;
+
+              // Check if there's a requirement to work on
+              if (!currentTitle) {
+                console.log(chalk.green('\n🎉 No more requirements to work on!'));
+                console.log(chalk.gray('  All requirements are completed or verified.'));
+                exitReason = 'completed';
+                break;
+              }
+
+              chatCount++;
+              if (maxChats > 0) {
+                console.log(chalk.cyan(`\n[${getTimestamp()}] 📝 Chat ${chatCount}/${maxChats}`));
+              } else {
+                console.log(chalk.cyan(`\n[${getTimestamp()}] 📝 Chat ${chatCount}`));
+              }
+
+              console.log(chalk.gray(`   ${requirementsCompleted} requirement(s) completed. ${maxChats > 0 ? `Will stop after ${maxChats} chat(s).` : 'No max set - will continue until all complete.'}`));
+
+              const { getRequirementsPath } = require('@vibecodingmachine/core');
+              const reqPath = await getRequirementsPath(repoPath);
+              const reqFilename = reqPath ? path.basename(reqPath) : 'REQUIREMENTS.md';
+
+              // Display status
+              const statusIcons = {
+                'PREPARE': '📋',
+                'ACT': '🔨',
+                'CLEAN UP': '🧹',
+                'VERIFY': '✅',
+                'DONE': '🎉'
+              };
+              const statusIcon = statusIcons[currentStatus] || '⏳';
+              console.log(chalk.cyan(`\n[${getTimestamp()}] ${statusIcon} Status: ${currentStatus}`));
+              if (currentTitle) {
+                console.log(chalk.white(`   Working on: ${currentTitle.substring(0, 60)}${currentTitle.length > 60 ? '...' : ''}`));
+              }
+
+              // Run Claude Code
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 🤖 Running Claude Code to work on requirement...\n`));
+
+              printStatusCard(currentTitle, currentStatus);
+
+              // Build prompt for Claude Code
+              const promptText = `You are Claude Code, an AI coding assistant. Help implement this requirement:
+
+"${currentTitle}"
+
+INSTRUCTIONS:
+1. Read the relevant code files in this repository
+2. Make the minimal changes needed to implement this requirement
+3. Follow best practices: DRY, KISS, clean code
+4. Do NOT add placeholder code or TODOs
+5. Do NOT edit ${reqFilename} (requirements file)
+6. Test your changes if possible
+
+IMPORTANT:
+- Make only the necessary changes (typically 1-10 lines)
+- Focus on quality over quantity
+- Follow the existing code style
+
+Please implement this requirement now.`;
+
+              console.log(chalk.bold.cyan('\n📤 Prompt sent to Claude Code:'));
+              console.log(chalk.gray('─'.repeat(80)));
+              console.log(chalk.white(promptText));
+              console.log(chalk.gray('─'.repeat(80)));
+              console.log();
+
+              // Send to Claude Code
+              const claudeResult = await claudeCodeManager.sendText(
+                promptText,
+                repoPath,
+                {
+                  onOutput: (output) => {
+                    process.stdout.write(output);
+                  },
+                  onError: (error) => {
+                    console.error(chalk.red(error));
+                  },
+                  timeoutMs: 300000 // 5 minute timeout
+                }
+              );
+
+              if (!claudeResult.success) {
+                const errorMsg = claudeResult.error || '';
+                const fullOutput = claudeResult.output || '';
+                console.log(chalk.red(`\n[${getTimestamp()}] ✗ Claude Code failed: ${errorMsg}`));
+
+                // Check if it's a session limit error (check both error and output)
+                const isSessionLimit = errorMsg.includes('Session limit') ||
+                  errorMsg.includes('session limit') ||
+                  fullOutput.includes('Session limit') ||
+                  fullOutput.includes('session limit');
+
+                // Save session limit for display in menu
+                if (isSessionLimit) {
+                  const ProviderManager = require('@vibecodingmachine/core/src/ide-integration/provider-manager.cjs');
+                  const providerManager = new ProviderManager();
+                  providerManager.markRateLimited('claude-code', 'claude-code-cli', fullOutput || errorMsg);
+                }
+
+                if (isSessionLimit && config.aiderProvider && config.groqApiKey) {
+                  console.log(chalk.yellow(`\n[${getTimestamp()}] 🔄 Session limit detected. Falling back to Groq API via Aider...`));
+
+                  // Switch to Aider mode temporarily
+                  const tempConfig = { ...config, ide: 'aider' };
+
+                  // Re-run this iteration with Aider
+                  console.log(chalk.cyan(`[${getTimestamp()}] 🔄 Retrying with Aider + Groq (${config.aiderModel})...\n`));
+
+                  // We'll break out of the Claude Code loop and restart with Aider
+                  shouldExit = true;
+                  exitReason = 'fallback-to-aider';
+                  keyboardHandler.stop();
+
+                  // Save the config with aider and restart
+                  await setAutoConfig(tempConfig);
+
+                  console.log(chalk.yellow(`\n[${getTimestamp()}] ♻️  Restarting in Aider mode...\n`));
+
+                  // Re-run the command with Aider
+                  const { spawn } = require('child_process');
+                  const proc = spawn(process.argv[0], [
+                    ...process.argv.slice(1)
+                  ], {
+                    stdio: 'inherit',
+                    cwd: process.cwd()
+                  });
+
+                  proc.on('close', (code) => {
+                    process.exit(code);
+                  });
+
+                  return;
+                }
+
+                // Don't exit immediately, just continue to next iteration
+                console.log(chalk.yellow(`\n[${getTimestamp()}] ⚠️  Continuing to next chat...`));
+                continue;
+              }
+
+              console.log(chalk.green(`\n[${getTimestamp()}] ✓ Claude Code completed successfully`));
+
+              // For now, mark as done after each successful chat
+              // TODO: Implement proper status tracking based on Claude's output
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 📝 Marking requirement as DONE...`));
+
+              // Mark as DONE (updateRequirementsStatus is defined as a local function above)
+              // Note: We don't have this function yet in Claude Code section
+              // For now, we'll just log success - proper status updates coming soon
+
+              requirementsCompleted++;
+              console.log(chalk.green(`\n[${getTimestamp()}] ✅ Requirement marked as DONE`));
+            }
+          }
+
+          // Stop auto mode
+          await stopAutoMode(exitReason);
+          keyboardHandler.stop();
+        } catch (error) {
+          if (error.message === 'No requirements to process') {
+            // Not really an error, just no work to do
+            await stopAutoMode('completed');
+          } else {
+            console.error(chalk.red(`\n✗ Error in Claude Code auto mode: ${error.message}`));
+            console.error(chalk.gray(error.stack));
+            await stopAutoMode('error');
+            throw error;
+          }
+        }
+      }
+    } else if (config.ide === 'aider') {
+      // Use Aider CLI
+      const aiderManager = new AiderCLIManager();
+
+      // Quick check without spinner (spinner was causing hang)
+      spinner.stop();
+      const isInstalled = aiderManager.isInstalled();
+
+      if (!isInstalled) {
+        spinner.text = 'Installing Aider CLI...';
+        const installResult = await aiderManager.install();
+
+        if (!installResult.success) {
+          spinner.fail('Failed to install Aider CLI');
+          console.log(chalk.red('\n✗ Error:'), installResult.error);
+          console.log(chalk.yellow('\n💡 How to fix:'));
+          if (installResult.suggestions) {
+            installResult.suggestions.forEach(suggestion => {
+              console.log(chalk.gray(`  ${suggestion}`));
+            });
+          } else {
+            console.log(chalk.gray('  Try installing Python first:'), chalk.cyan('brew install python'));
+            console.log(chalk.gray('  Then install Aider CLI:'), chalk.cyan('pip3 install aider-chat'));
+          }
+          console.log(chalk.gray('\n  Or install manually:'));
+          console.log(chalk.cyan('    pip3 install aider-chat'));
+          console.log(chalk.cyan('    or'));
+          console.log(chalk.cyan('    python3 -m pip install aider-chat'));
+          throw new Error(`Failed to install Aider CLI: ${installResult.error}`);
+        }
+
+        spinner.succeed('Aider CLI installed successfully');
+      } else {
+        // Restart spinner for next step
+        spinner.start();
+      }
+
+      // Check if this is just a provider configuration request
+      if (options.configureOnly) {
+        spinner.stop();
+        console.log(chalk.cyan('\n🤖 Aider CLI AI Provider Configuration\n'));
+
+        // Verify Ollama API is accessible (better check than just command availability)
+        const apiCheck = await aiderManager.verifyOllamaAPI();
+        if (!apiCheck.success) {
+          const hasOllamaCmd = aiderManager.isOllamaInstalled();
+          if (!hasOllamaCmd) {
+            console.log(chalk.yellow('  ⚠️  Ollama is not installed\n'));
+            console.log(chalk.gray('  Install Ollama:'), chalk.cyan('https://ollama.ai/download\n'));
+          } else {
+            console.log(chalk.yellow('  ⚠️  Ollama service is not running\n'));
+            console.log(chalk.gray('  Start Ollama:'), chalk.cyan('ollama serve'));
+            console.log(chalk.gray('  Or open the Ollama app if you installed the desktop version\n'));
+          }
+          const inquirer = require('inquirer');
+          await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to return to menu...',
+          }]);
+          return;
+        }
+
+        // Get installed models
+        const installedModels = await aiderManager.getOllamaModels();
+
+        // Recommended coding models (based on Aider leaderboard)
+        const recommendedModels = [
+          { name: 'qwen2.5-coder:32b', display: 'qwen2.5-coder:32b (74% Aider benchmark - Best)', description: 'Best coding model' },
+          { name: 'deepseek-coder-v2', display: 'deepseek-coder-v2 (73% Aider benchmark)', description: 'Excellent coding model' },
+          { name: 'deepseek-coder:33b', display: 'deepseek-coder:33b (Better instruction following)', description: 'Better at following complex instructions' },
+          { name: 'codellama:34b', display: 'codellama:34b (More reliable for refactoring)', description: 'Reliable for code refactoring tasks' },
+          { name: 'qwen2.5-coder:14b', display: 'qwen2.5-coder:14b (69% Aider benchmark)', description: 'Good coding model' },
+          { name: 'qwen2.5-coder:7b', display: 'qwen2.5-coder:7b (58% Aider benchmark)', description: 'Smaller coding model' },
+          { name: 'llama3.1:8b', display: 'llama3.1:8b (Fallback)', description: 'General purpose model' }
+        ];
+
+        // Build choices with status indicators and rate limit info
+        const inquirer = require('inquirer');
+        const ProviderManager = require('@vibecodingmachine/core/src/ide-integration/provider-manager.cjs');
+        const providerManager = new ProviderManager();
+
+        const choices = recommendedModels.map(model => {
+          const isInstalled = installedModels.includes(model.name);
+          const statusIcon = isInstalled ? chalk.green('✓') : chalk.yellow('⚠');
+          let statusText = isInstalled ? chalk.gray('(installed)') : chalk.yellow('(needs download)');
+
+          // Check for rate limits on Ollama models
+          const timeUntilReset = providerManager.getTimeUntilReset('ollama', model.name);
+          if (timeUntilReset) {
+            const resetTime = Date.now() + timeUntilReset;
+            const resetDate = new Date(resetTime);
+            const timeStr = resetDate.toLocaleString('en-US', {
+              weekday: 'short',
+              month: 'short',
+              day: 'numeric',
+              hour: 'numeric',
+              minute: '2-digit',
+              hour12: true,
+              timeZoneName: 'short'
+            });
+            statusText += ` ${chalk.red('⏰ Rate limited until ' + timeStr)}`;
+          }
+
+          return {
+            name: `${statusIcon} ${model.display} ${statusText}`,
+            value: { name: model.name, isInstalled }
+          };
+        });
+
+        // Add option to see all installed models
+        if (installedModels.length > 0) {
+          choices.push({ name: chalk.gray('─────────────────────────────'), disabled: true });
+          choices.push({ name: chalk.cyan('View all installed models'), value: { name: '__view_all__' } });
+        }
+
+        choices.push({ name: chalk.gray('← Back to menu'), value: null });
+
+        const { selection } = await inquirer.prompt([{
+          type: 'list',
+          name: 'selection',
+          message: 'Select model to use:',
+          choices: choices
+        }]);
+
+        if (!selection) {
+          return;
+        }
+
+        if (selection.name === '__view_all__') {
+          console.log(chalk.cyan('\n📋 Installed Models:\n'));
+          installedModels.forEach(model => {
+            console.log(chalk.gray('  •'), chalk.cyan(model));
+          });
+          console.log();
+          await inquirer.prompt([{
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to return to menu...',
+          }]);
+          return;
+        }
+
+        const { name: selectedModel, isInstalled } = selection;
+
+        // If not installed, download it first
+        if (!isInstalled) {
+          console.log(chalk.cyan(`\n📥 Downloading ${selectedModel}...\n`));
+          console.log(chalk.gray('This may take a few minutes depending on model size...\n'));
+
+          // Use Ollama HTTP API for model download
+          const http = require('http');
+          await new Promise((resolve) => {
+            const downloadRequest = http.request({
+              hostname: 'localhost',
+              port: 11434,
+              path: '/api/pull',
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              }
+            }, (res) => {
+              let lastStatus = '';
+              res.on('data', (chunk) => {
+                try {
+                  const lines = chunk.toString().split('\n').filter(l => l.trim());
+                  lines.forEach(line => {
+                    const data = JSON.parse(line);
+                    if (data.status) {
+                      if (data.total && data.completed) {
+                        // Show progress bar with percentage
+                        const percent = Math.round((data.completed / data.total) * 100);
+                        const completedMB = Math.round(data.completed / 1024 / 1024);
+                        const totalMB = Math.round(data.total / 1024 / 1024);
+                        const remainingMB = totalMB - completedMB;
+
+                        // Create progress bar (50 chars wide)
+                        const barWidth = 50;
+                        const filledWidth = Math.round((percent / 100) * barWidth);
+                        const emptyWidth = barWidth - filledWidth;
+                        const bar = chalk.green('█'.repeat(filledWidth)) + chalk.gray('░'.repeat(emptyWidth));
+
+                        process.stdout.write(`\r${bar} ${chalk.cyan(percent + '%')} ${chalk.white(completedMB + 'MB')} / ${chalk.gray(totalMB + 'MB')} ${chalk.yellow('(' + remainingMB + 'MB remaining)')}`);
+                      } else if (data.status !== lastStatus) {
+                        lastStatus = data.status;
+                        process.stdout.write(`\r${chalk.gray(data.status)}`.padEnd(120));
+                      }
+                    }
+                  });
+                } catch (e) {
+                  // Ignore JSON parse errors for streaming responses
+                }
+              });
+            });
+
+            downloadRequest.on('error', (error) => {
+              console.log(chalk.red(`\n\n✗ Download failed: ${error.message}\n`));
+              resolve();
+            });
+
+            downloadRequest.write(JSON.stringify({ name: selectedModel }));
+            downloadRequest.end();
+
+            downloadRequest.on('close', async () => {
+              console.log(chalk.green(`\n\n✓ Successfully downloaded ${selectedModel}\n`));
+              // Save model preference
+              const savedConfig = await getAutoConfig();
+              savedConfig.aiderModel = selectedModel;
+              await setAutoConfig(savedConfig);
+              console.log(chalk.green(`✓ Set ${selectedModel} as default model\n`));
+              resolve();
+            });
+          });
+        } else {
+          // Save model preference
+          const savedConfig = await getAutoConfig();
+          savedConfig.aiderModel = selectedModel;
+          await setAutoConfig(savedConfig);
+          console.log(chalk.green(`✓ Set ${selectedModel} as default model\n`));
+        }
+
+        return;
+      }
+
+      // Determine provider and model
+      // Read provider and model from config
+      const savedConfig = await getAutoConfig();
+      let provider = savedConfig.aiderProvider || 'ollama';  // Default: ollama (local)
+      let modelName = savedConfig.aiderModel || 'qwen2.5-coder:32b';  // Default: Best coding model (74% Aider benchmark)
+      let bedrockEndpoint = null;
+
+      // Quick Ollama check (only for Ollama provider, don't block if it's slow)
+      spinner.stop();
+      if (provider === 'ollama') {
+        try {
+          const hasOllama = aiderManager.isOllamaInstalled();
+          if (hasOllama) {
+            // Try to get models, but don't wait too long
+            const models = await Promise.race([
+              aiderManager.getOllamaModels(),
+              new Promise(resolve => setTimeout(() => resolve([]), 2000))
+            ]);
+
+            if (models.length > 0) {
+              // Check if saved model is installed, otherwise use preferred models
+              const savedModel = savedConfig.aiderModel;
+              if (savedModel && models.includes(savedModel)) {
+                // Use saved model if it's installed
+                modelName = savedModel;
+              } else {
+                // Prefer coding-specialized models (based on Aider leaderboard)
+                const preferredModels = [
+                  'qwen2.5-coder:32b',      // 74% on Aider benchmark
+                  'deepseek-coder-v2',      // 73% on Aider benchmark
+                  'deepseek-coder:33b',     // Better instruction following
+                  'codellama:34b',          // More reliable for refactoring
+                  'qwen2.5-coder:14b',      // 69% on Aider benchmark
+                  'qwen2.5-coder:7b',       // 58% on Aider benchmark
+                  'llama3.1:8b'             // Fallback
+                ];
+
+                // Find first preferred model that's installed
+                for (const preferred of preferredModels) {
+                  if (models.includes(preferred)) {
+                    modelName = preferred;
+                    break;
+                  }
+                }
+              }
+
+              console.log(chalk.green(`✓ Using Ollama with model: ${modelName}`));
+              if (savedModel && savedModel !== modelName) {
+                console.log(chalk.yellow(`  ⚠️  Saved model "${savedModel}" not found, using ${modelName} instead`));
+                console.log(chalk.gray(`  Configure provider to download "${savedModel}"`));
+              }
+            }
+          }
+        } catch (error) {
+          // Use default model if check fails
+          console.log(chalk.gray(`Using default model: ${modelName}`));
+        }
+      } else {
+        // For cloud providers (groq, anthropic, etc.), use configured model directly
+        console.log(chalk.green(`✓ Using ${provider} with model: ${modelName}`));
+
+        // Check for required API keys for cloud providers
+        if (provider === 'groq') {
+          // Check for API key in environment OR config file
+          let groqApiKey = process.env.GROQ_API_KEY;
+          if (!groqApiKey || groqApiKey.trim() === '') {
+            // Try loading from config file
+            if (savedConfig.groqApiKey) {
+              groqApiKey = savedConfig.groqApiKey;
+              process.env.GROQ_API_KEY = groqApiKey; // Set in environment for Aider
+            }
+          }
+
+          if (!groqApiKey || groqApiKey.trim() === '') {
+            console.log(chalk.cyan('\n📋 How to get a FREE Groq API key:\n'));
+            console.log(chalk.white('  1. Go to: ') + chalk.cyan.underline('https://console.groq.com/'));
+            console.log(chalk.white('  2. Sign up (no credit card required!)'));
+            console.log(chalk.white('  3. Click "API Keys" in the top corner'));
+            console.log(chalk.white('  4. Click "Create API Key". Name it whatever you want, like Vibe Coding Machine'));
+            console.log(chalk.white('  5. Copy your key (starts with "gsk_...")'));
+            console.log(chalk.white('\n✨ Groq Free Tier includes:'));
+            console.log(chalk.gray('   • 14,400 requests/day'));
+            console.log(chalk.gray('   • 30 requests/minute'));
+            console.log(chalk.gray('   • Ultra-fast inference (<2s per request)'));
+            console.log(chalk.gray('   • No credit card required!\n'));
+
+            // Offer to open browser
+            const inquirer = require('inquirer');
+            const { openBrowser } = await inquirer.prompt([{
+              type: 'confirm',
+              name: 'openBrowser',
+              message: 'Open Groq Console in your browser?',
+              default: true
+            }]);
+
+            if (openBrowser) {
+              const { execSync } = require('child_process');
+              try {
+                execSync('open "https://console.groq.com/"', { stdio: 'ignore' });
+                console.log(chalk.green('\n✓ Opened browser to Groq Console\n'));
+                console.log(chalk.gray('  After signing up, the API Keys page will be at:'));
+                console.log(chalk.gray('  https://console.groq.com/keys\n'));
+              } catch (error) {
+                console.log(chalk.yellow('\n⚠ Could not open browser automatically.'));
+                console.log(chalk.gray('  Please visit: https://console.groq.com/\n'));
+              }
+            }
+
+            const { continueChoice } = await inquirer.prompt([{
+              type: 'list',
+              name: 'continueChoice',
+              message: 'What would you like to do?',
+              choices: [
+                { name: 'I have my API key - enter it now', value: 'enter' },
+                { name: 'Switch back to Ollama (local)', value: 'ollama' },
+                { name: 'Exit', value: 'exit' }
+              ]
+            }]);
+
+            if (continueChoice === 'exit') {
+              console.log(chalk.gray('\n  Exiting...\n'));
+              return;
+            } else if (continueChoice === 'ollama') {
+              // Switch back to ollama
+              savedConfig.aiderProvider = 'ollama';
+              savedConfig.aiderModel = 'qwen2.5-coder:32b';
+              await setAutoConfig(savedConfig);
+              provider = 'ollama';
+              modelName = 'qwen2.5-coder:32b';
+              console.log(chalk.green('\n✓ Switched to Ollama\n'));
+            } else if (continueChoice === 'enter') {
+              // Prompt for API key
+              const { apiKey } = await inquirer.prompt([{
+                type: 'password',
+                name: 'apiKey',
+                message: 'Paste your Groq API key:',
+                mask: '*',
+                validate: (input) => {
+                  if (!input || input.trim() === '') {
+                    return 'API key cannot be empty';
+                  }
+                  if (!input.startsWith('gsk_')) {
+                    return 'Groq API keys should start with "gsk_"';
+                  }
+                  return true;
+                }
+              }]);
+
+              const trimmedKey = apiKey.trim();
+
+              // Set for current session
+              process.env.GROQ_API_KEY = trimmedKey;
+              console.log(chalk.green('\n✓ API key set for current session\n'));
+
+              // Save to config file for immediate persistence
+              const { setAutoConfig } = require('../utils/config.js');
+              await setAutoConfig({ groqApiKey: trimmedKey });
+              console.log(chalk.green('✓ API key saved to Vibe Coding Machine config\n'));
+
+              // Add to shell profile for persistence
+              const os = require('os');
+              const fs = require('fs-extra');
+              const shell = process.env.SHELL || '';
+              let shellProfile = '';
+
+              if (shell.includes('zsh')) {
+                shellProfile = path.join(os.homedir(), '.zshrc');
+              } else if (shell.includes('bash')) {
+                shellProfile = path.join(os.homedir(), '.bashrc');
+              } else {
+                shellProfile = path.join(os.homedir(), '.profile');
+              }
+
+              try {
+                const exportLine = `export GROQ_API_KEY="${trimmedKey}"`;
+
+                // Check if already exists
+                let profileContent = '';
+                if (await fs.pathExists(shellProfile)) {
+                  profileContent = await fs.readFile(shellProfile, 'utf8');
+                }
+
+                if (profileContent.includes('GROQ_API_KEY')) {
+                  console.log(chalk.yellow('⚠ GROQ_API_KEY already exists in your shell profile'));
+                  const { replaceKey } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'replaceKey',
+                    message: 'Replace existing key with new one?',
+                    default: true
+                  }]);
+
+                  if (replaceKey) {
+                    // Replace existing line
+                    const updatedContent = profileContent.replace(
+                      /export GROQ_API_KEY=.*/g,
+                      exportLine
+                    );
+                    await fs.writeFile(shellProfile, updatedContent, 'utf8');
+                    console.log(chalk.green(`✓ Updated GROQ_API_KEY in ${shellProfile}\n`));
+                  }
+                } else {
+                  // Append new line
+                  await fs.appendFile(shellProfile, `\n# Groq API Key for VibeCodingMachine\n${exportLine}\n`, 'utf8');
+                  console.log(chalk.green(`✓ Added GROQ_API_KEY to ${shellProfile}\n`));
+                }
+
+                console.log(chalk.gray('  Your API key will now persist across terminal sessions.'));
+                console.log(chalk.green('\n✓ Setup complete! Continuing with Groq...\n'));
+              } catch (error) {
+                console.log(chalk.yellow('\n⚠ Could not save to shell profile automatically.'));
+                console.log(chalk.gray('  You can manually add this line to your ~/.zshrc or ~/.bashrc:'));
+                console.log(chalk.gray(`  export GROQ_API_KEY="${trimmedKey}"\n`));
+                console.log(chalk.green('✓ API key set for current session. Continuing...\n'));
+              }
+            }
+          }
+        } else if (provider === 'anthropic') {
+          const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+          if (!anthropicApiKey || anthropicApiKey.trim() === '') {
+            console.log(chalk.red('\n❌ ANTHROPIC_API_KEY not found!'));
+            console.log(chalk.cyan('\n📋 Get your Anthropic API key at: ') + chalk.cyan.underline('https://console.anthropic.com/settings/keys'));
+            console.log(chalk.white('\nSet it with: ') + chalk.gray('export ANTHROPIC_API_KEY="your_key_here"\n'));
+            return;
+          }
+        }
+      }
+
+      // Auto-mode loop for Aider CLI
+      let chatCount = 0;
+      let exitReason = 'completed';
+      const maxChats = config.maxChats || 0; // 0 = unlimited
+      let shouldExit = false;
+      let sigintHandler = null;
+
+      // SIGINT handler for Ctrl+C (works even when child processes are running)
+      sigintHandler = () => {
+        console.log(chalk.yellow('\n🛑 Ctrl+C detected - exiting immediately...'));
+        shouldExit = true;
+        exitReason = 'user-exit';
+
+        // Kill Aider processes
+        try {
+          aiderManager.killAllProcesses();
+        } catch (err) {
+          // Ignore
+        }
+
+        // Force exit after a short delay to allow cleanup
+        setTimeout(async () => {
+          try {
+            await stopAutoMode(exitReason);
+          } catch (err) {
+            // Ignore
+          }
+          process.exit(0);
+        }, 500);
+      };
+      process.on('SIGINT', sigintHandler);
+
+      // Watchdog timer - forcibly exit if shouldExit is set
+      // This runs periodically to check if user wants to exit
+      // (workaround for SIGINT not being processed reliably when blocked on child processes)
+      const fs = require('fs-extra');
+      const stopFilePath = path.join(os.homedir(), '.config', 'allnightai', '.stop');
+
+      const watchdog = setInterval(async () => {
+        // Check for stop file (created by 'vcm auto:stop' or user)
+        if (await fs.pathExists(stopFilePath)) {
+          console.log(chalk.yellow('\n🛑 Stop signal detected (via .stop file)'));
+          shouldExit = true;
+          exitReason = 'user-stop';
+
+          // Remove the stop file
+          try {
+            await fs.unlink(stopFilePath);
+          } catch (err) {
+            // Ignore errors
+          }
+        }
+
+        if (shouldExit) {
+          clearInterval(watchdog);
+          try {
+            aiderManager.killAllProcesses();
+          } catch (err) {
+            // Ignore
+          }
+          // Don't call process.exit() here, just let the loop break naturally
+        }
+      }, 500);
+
+      // Set up keyboard handler for 'x' key (Ctrl+C is handled by SIGINT above)
+      const keyboardHandler = createKeyboardHandler({
+        onExit: () => {
+          console.log(chalk.yellow('\n🛑 Exit requested via keyboard (x key)...'));
+          shouldExit = true;
+          exitReason = 'user-exit';
+          aiderManager.killAllProcesses();
+          clearInterval(watchdog);
+
+          // Force exit after a short delay to allow cleanup (async file operations)
+          setTimeout(async () => {
+            try {
+              await stopAutoMode(exitReason);
+            } catch (err) {
+              // Ignore
+            }
+            process.exit(0);
+          }, 500);
+        }
+      });
+      keyboardHandler.start();
+
+      // Startup message
+      console.log(chalk.cyan(`\n[${getTimestamp()}] 🚀 Starting Auto Mode...`));
+      console.log(chalk.gray(`  Model: ${modelName}`));
+      if (maxChats > 0) {
+        console.log(chalk.gray(`  Max chats: ${maxChats}`));
+      }
+      console.log(chalk.gray(`  To stop: Press `) + chalk.white.bold('x') + chalk.gray(' or ') + chalk.white.bold('Ctrl+C') + chalk.gray(', or run \'ana auto:stop\''));
+      console.log();
+
+      // Helper function to print the purple status card
+      function printStatusCard(currentTitle, currentStatus) {
+        const statusIcons = {
+          'PREPARE': '🔨',
+          'ACT': '⏳',
+          'CLEAN UP': '⏳',
+          'VERIFY': '⏳',
+          'DONE': '⏳'
+        };
+
+        // Build the workflow line with proper icons
+        const stages = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
+        const stageMap = {
+          'PREPARE': 0,
+          'ACT': 1,
+          'CLEAN UP': 2,
+          'VERIFY': 3,
+          'DONE': 4
+        };
+        const currentIndex = stageMap[currentStatus] || 0;
+
+        const workflowLine = stages.map((stage, idx) => {
+          const icon = idx < currentIndex ? '✅' : (idx === currentIndex ? '🔨' : '⏳');
+          const color = idx === currentIndex ? chalk.cyan.bold : chalk.gray;
+          return `${icon} ${color(stage)}`;
+        }).join(' → ');
+
+        // Use string-width library for accurate terminal width calculation
+        const stringWidth = require('string-width');
+
+        // Fixed box width: 64 chars total (including borders)
+        // Content area: 62 chars (64 - 2 for left/right borders)
+        const contentWidth = 62;
+
+        const workflowVisualLen = stringWidth(workflowLine);
+        const workflowPadding = Math.max(0, contentWidth - workflowVisualLen);
+
+        // Build requirement line and truncate to fit
+        const prefix = '🎯 Working on: ';
+        const prefixWidth = stringWidth(chalk.bold.white(prefix));
+        const maxTitleWidth = contentWidth - prefixWidth;
+
+        let displayReq = currentTitle || 'Loading...';
+        while (stringWidth(displayReq) > maxTitleWidth && displayReq.length > 3) {
+          displayReq = displayReq.substring(0, displayReq.length - 4) + '...';
+        }
+
+        const reqLineContent = chalk.bold.white(prefix + displayReq);
+        const reqVisualLen = stringWidth(reqLineContent);
+        const reqPadding = Math.max(0, contentWidth - reqVisualLen);
+
+        console.log(chalk.magenta('\n╭────────────────────────────────────────────────────────────────╮'));
+        console.log(chalk.magenta('│') + '                                                                ' + chalk.magenta('│'));
+        console.log(chalk.magenta('│') + ' ' + workflowLine + ' '.repeat(workflowPadding) + ' ' + chalk.magenta('│'));
+        console.log(chalk.magenta('│') + '                                                                ' + chalk.magenta('│'));
+        console.log(chalk.magenta('│') + ' ' + reqLineContent + ' '.repeat(reqPadding) + ' ' + chalk.magenta('│'));
+        console.log(chalk.magenta('│') + '                                                                ' + chalk.magenta('│'));
+        console.log(chalk.magenta('╰────────────────────────────────────────────────────────────────╯\n'));
+      }
+
+      // Helper function to get current requirement details
+      async function getCurrentRequirementDetails() {
+        const { getRequirementsPath } = require('@vibecodingmachine/core');
+        const fs = require('fs-extra');
+        const reqPath = await getRequirementsPath(repoPath);
+
+        if (!reqPath || !await fs.pathExists(reqPath)) {
+          return { title: null, status: 'PREPARE' };
+        }
+
+        const content = await fs.readFile(reqPath, 'utf8');
+        const lines = content.split('\n');
+
+        let title = null;
+        let status = 'PREPARE';
+        let inTodoSection = false;
+
+        // Read from TODO list instead of "Current In Progress Requirement" section
+        for (const line of lines) {
+          // Find TODO section
+          if (line.includes('Requirements not yet completed') && line.trim().startsWith('##')) {
+            inTodoSection = true;
+            continue;
+          }
+
+          // Get first TODO item
+          if (inTodoSection && line.trim().startsWith('- ')) {
+            title = line.substring(2).trim();
+            // Always start at PREPARE for TODO items
+            status = 'PREPARE';
+            break;
+          }
+
+          // Stop if we hit another section
+          if (inTodoSection && line.trim().startsWith('##')) {
+            break;
+          }
+        }
+
+        return { title, status };
+      }
+
+      // Helper function to directly update REQUIREMENTS file status
+      // This bypasses Aider to preserve file structure
+      async function updateRequirementsStatus(newStatus, responseText) {
+        const { getRequirementsPath } = require('@vibecodingmachine/core');
+        const fs = require('fs-extra');
+        const reqPath = await getRequirementsPath(repoPath);
+
+        if (!reqPath || !await fs.pathExists(reqPath)) {
+          return { success: false, error: 'Requirements file not found' };
+        }
+
+        try {
+          const content = await fs.readFile(reqPath, 'utf8');
+          const lines = content.split('\n');
+          const updatedLines = [];
+          let inResponseSection = false;
+          let responseUpdated = false;
+
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+
+            // Handle response section
+            if (line.includes('## RESPONSE FROM LAST CHAT')) {
+              inResponseSection = true;
+              updatedLines.push(line);
+              continue;
+            }
+
+            // End of response section
+            if (line.trim().startsWith('##') && inResponseSection && !line.includes('RESPONSE')) {
+              inResponseSection = false;
+            }
+
+            // Update response line - append to existing content
+            if (inResponseSection && line.trim() && !line.trim().startsWith('#') && !responseUpdated) {
+              updatedLines.push('');
+              updatedLines.push(responseText);
+              responseUpdated = true;
+              continue;
+            }
+
+            updatedLines.push(line);
+          }
+
+          await fs.writeFile(reqPath, updatedLines.join('\n'));
+          return { success: true };
+        } catch (error) {
+          return { success: false, error: error.message };
+        }
+      }
+
+      // Helper function to count requirements
+      async function getRequirementCounts() {
+        const { getRequirementsPath, getVibeCodingMachineDir } = require('@vibecodingmachine/core');
+        const fs = require('fs-extra');
+        const reqPath = await getRequirementsPath(repoPath);
+
+        if (!reqPath || !await fs.pathExists(reqPath)) {
+          return null;
+        }
+
+        const content = await fs.readFile(reqPath, 'utf8');
+        let todoCount = 0;
+        let toVerifyCount = 0;
+        let verifiedCount = 0;
+
+        const lines = content.split('\n');
+        let currentSection = '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+
+          if (trimmed.startsWith('##')) {
+            if (trimmed.includes('⏳ Requirements not yet completed') ||
+              trimmed.includes('Requirements not yet completed')) {
+              currentSection = 'todo';
+            } else if (trimmed.includes('✅ Verified by AI') ||
+              trimmed.includes('Verified by AI')) {
+              currentSection = 'verified';
+            } else {
+              currentSection = '';
+            }
+          }
+
+          if (currentSection && trimmed.startsWith('-')) {
+            const requirementText = trimmed.substring(2).trim();
+            if (requirementText) {
+              if (currentSection === 'todo') {
+                todoCount++;
+              } else if (currentSection === 'verified') {
+                verifiedCount++;
+              }
+            }
+          }
+        }
+
+        return { todoCount, toVerifyCount, verifiedCount };
+      }
+
+      try {
+        console.log(chalk.gray('[DEBUG] Starting aider auto mode loop'));
+
+        // Get initial requirement counts
+        const initialCounts = await getRequirementCounts();
+        console.log(chalk.gray(`[DEBUG] Initial counts: ${JSON.stringify(initialCounts)}`));
+
+        // Check if there's a current requirement - if not, move the first TODO to current
+        let { title: currentTitle, status: currentStatus } = await getCurrentRequirementDetails();
+        console.log(chalk.gray(`[DEBUG] Current requirement: ${currentTitle || 'none'}, status: ${currentStatus}`));
+
+        if (!currentTitle) {
+          console.log(chalk.yellow('\n⚠️  No requirements found in TODO list.'));
+          console.log(chalk.green('🎉 All requirements are completed or verified.'));
+          exitReason = 'completed';
+          throw new Error('No requirements to process');
+        }
+
+        // Track requirements completed counter
+        let requirementsCompleted = 0;
+
+        // Only start the loop if we have a current requirement
+        if (currentTitle) {
+          while (true) {
+            // Check if user requested exit via Ctrl+C
+            if (shouldExit) {
+              console.log(chalk.yellow(`\n🛑 Exiting Auto Mode...\n`));
+              break;
+            }
+
+            // Check max chats
+            if (maxChats > 0 && chatCount >= maxChats) {
+              console.log(chalk.yellow(`\n⚠️  Maximum chats reached (${maxChats}). Stopping auto mode.`));
+              exitReason = 'max-chats';
+              break;
+            }
+
+            // Get current requirement details BEFORE incrementing chat count
+            const details = await getCurrentRequirementDetails();
+            currentTitle = details.title;
+            currentStatus = details.status;
+
+            // Check if there's a requirement to work on
+            if (!currentTitle) {
+              console.log(chalk.green('\n🎉 No more requirements to work on!'));
+              console.log(chalk.gray('  All requirements are completed or verified.'));
+              exitReason = 'completed';
+              break;
+            }
+
+            chatCount++;
+            // Show progress without verbose prompt text
+            if (maxChats > 0) {
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 📝 Chat ${chatCount}/${maxChats}`));
+            } else {
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 📝 Chat ${chatCount}`));
+            }
+
+            // Show requirements progress
+            if (maxChats > 0) {
+              console.log(chalk.gray(`   ${requirementsCompleted} requirement(s) completed. Will stop after ${maxChats} chat(s).`));
+            } else {
+              console.log(chalk.gray(`   ${requirementsCompleted} requirement(s) completed. No max set - will continue until all complete.`));
+            }
+
+            const { getRequirementsPath } = require('@vibecodingmachine/core');
+            const reqPath = await getRequirementsPath(repoPath);
+            const reqFilename = reqPath ? path.basename(reqPath) : 'REQUIREMENTS.md';
+
+            // Display status progress
+            const statusIcons = {
+              'PREPARE': '📋',
+              'ACT': '🔨',
+              'CLEAN UP': '🧹',
+              'VERIFY': '✅',
+              'DONE': '🎉'
+            };
+            const statusIcon = statusIcons[currentStatus] || '⏳';
+            console.log(chalk.cyan(`\n[${getTimestamp()}] ${statusIcon} Status: ${currentStatus}`));
+            if (currentTitle) {
+              console.log(chalk.white(`   Working on: ${currentTitle.substring(0, 60)}${currentTitle.length > 60 ? '...' : ''}`));
+            }
+
+            // Run Aider to work on the requirement
+            console.log(chalk.cyan(`\n[${getTimestamp()}] 🤖 Running Aider to work on requirement...\n`));
+
+            // Show status card before starting
+            printStatusCard(currentTitle, currentStatus);
+
+            // Update status to ACT (programmatically, before Aider runs)
+            console.log(chalk.cyan(`\n[${getTimestamp()}] 📝 Updating status to ACT...`));
+            await updateRequirementsStatus('ACT', `Starting implementation of: ${currentTitle}`);
+            printStatusCard(currentTitle, 'ACT'); // Show status card after transition
+
+            // META-AI: Ask a fast model to choose the best model for this requirement
+            // ONLY for Ollama (cloud providers use configured model)
+            let selectedModel = modelName; // Default to configured model
+
+            if (provider === 'ollama') {
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 🧠 Selecting optimal model for this requirement...`));
+
+              const modelSelectionPrompt = `You are a model selection expert. Analyze this requirement and choose the BEST model from this list:
+
+REQUIREMENT:
+"${currentTitle}"
+
+AVAILABLE MODELS:
+1. qwen2.5-coder:32b - 74% Aider benchmark, best overall code quality, slower
+2. deepseek-coder:33b - 73% Aider benchmark, better instruction following, good for complex workflows
+3. codellama:34b - More reliable for refactoring tasks
+4. qwen2.5-coder:14b - 69% Aider benchmark, faster, good for simple tasks
+5. qwen2.5-coder:7b - 58% Aider benchmark, fastest, only for trivial tasks
+
+SELECTION CRITERIA:
+- Simple UI changes (add text, display info) → qwen2.5-coder:14b or 7b (fast)
+- Complex refactoring (DRY, extract functions, reorganize) → codellama:34b
+- Multi-step workflows with precise instructions → deepseek-coder:33b
+- Advanced code generation or algorithms → qwen2.5-coder:32b
+- Error fixing, debugging → qwen2.5-coder:32b or deepseek-coder:33b
+
+OUTPUT FORMAT:
+Output ONLY the model name, nothing else. Example outputs:
+qwen2.5-coder:32b
+deepseek-coder:33b
+codellama:34b
+qwen2.5-coder:14b
+qwen2.5-coder:7b
+
+NOW: Analyze the requirement and output the best model name.`;
+
+              try {
+                // Use fast model for selection (7b)
+                const selectorModel = 'qwen2.5-coder:7b';
+                const selectionResult = await aiderManager.sendText(
+                  modelSelectionPrompt,
+                  repoPath,
+                  provider,
+                  selectorModel,
+                  null,
+                  [], // No files needed
+                  null,
+                  null,
+                  30000 // 30 second timeout (increased from 10s to handle initial model loading)
+                );
+
+                if (selectionResult.success && selectionResult.output) {
+                  // Parse the model name from output
+                  const lines = selectionResult.output.split('\n');
+                  for (const line of lines) {
+                    const trimmed = line.trim();
+                    // Look for model names
+                    if (trimmed.match(/^(qwen2\.5-coder:(32b|14b|7b)|deepseek-coder:(33b|v2)|codellama:34b)$/)) {
+                      selectedModel = trimmed;
+                      console.log(chalk.green(`   ✓ Selected model: ${selectedModel}`));
+                      break;
+                    }
+                  }
+                }
+
+                if (selectedModel === modelName) {
+                  console.log(chalk.yellow(`   ⚠ Could not parse model selection, using default: ${modelName}`));
+                }
+              } catch (error) {
+                console.log(chalk.yellow(`   ⚠ Model selection failed, using default: ${modelName}`));
+              }
+            } else {
+              // For cloud providers, use configured model directly
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 🧠 Using configured model: ${modelName}`));
+            }
+
+            // Use the selected model for the rest of the workflow
+            modelName = selectedModel;
+
+            // VIBE CODING: Extract keywords and find relevant files BEFORE calling Aider
+            // This way Aider has the right files in context from the start
+            console.log(chalk.cyan(`\n[${getTimestamp()}] 🔍 Searching codebase for relevant files...`));
+
+            const { execSync } = require('child_process');
+
+            // Extract keywords from requirement: special patterns, quoted strings, function names
+            const extractKeywords = (text) => {
+              const keywords = [];
+
+              // HIGHEST PRIORITY: Extract special patterns like "d/y/n", "r/y/n" (contains slashes/special chars)
+              const specialPatterns = text.match(/\b[a-z]\/[a-z](?:\/[a-z])?/gi);
+              if (specialPatterns) {
+                specialPatterns.forEach(match => {
+                  keywords.push(match);
+                  // Also search for the individual letters
+                  match.split('/').forEach(letter => keywords.push(`'${letter}'`));
+                });
+              }
+
+              // GENERIC CONTEXTUAL INFERENCE: Extract domain concepts from requirement
+              const lowerText = text.toLowerCase();
+
+              // Extract action verbs (what to do)
+              const actionVerbs = ['add', 'display', 'show', 'remove', 'delete', 'update', 'modify', 'change', 'move', 'create'];
+              actionVerbs.forEach(verb => {
+                if (lowerText.includes(verb)) {
+                  keywords.push(verb);
+                }
+              });
+
+              // Extract location context (where to make changes)
+              const locationPhrases = [
+                { pattern: /right below\s+"([^"]+)"/gi, type: 'after-element' },
+                { pattern: /above\s+"([^"]+)"/gi, type: 'before-element' },
+                { pattern: /in\s+the\s+([a-z]+\s+(?:screen|menu|panel|dialog|modal|section))/gi, type: 'in-component' }
+              ];
+
+              locationPhrases.forEach(({ pattern, type }) => {
+                const matches = text.matchAll(pattern);
+                for (const match of matches) {
+                  // Extract the reference element/component
+                  const reference = match[1];
+                  // Extract key nouns from the reference (skip numbers and percentages)
+                  const cleanRef = reference.replace(/\d+\s*\(.*?\)/g, '').replace(/\d+%/g, '').trim();
+                  const nouns = cleanRef.split(/\s+/).filter(word =>
+                    word.length > 3 &&
+                    !['the', 'and', 'or', 'with', 'from', 'to'].includes(word.toLowerCase())
+                  );
+                  nouns.forEach(noun => keywords.push(noun));
+                }
+              });
+
+              // Extract key phrases from quoted text (e.g., "Next TODO Requirement" from Add "Next TODO Requirement: ...")
+              const keyPhraseMatch = text.match(/(?:Add|Display|Show|Create)\s+"([^"]+)"/i);
+              if (keyPhraseMatch) {
+                const phrase = keyPhraseMatch[1];
+                // Extract just the key term (before colons, ellipsis, etc)
+                const cleanPhrase = phrase.replace(/[:.!?]+.*$/, '').replace(/\.\.\.$/, '').trim();
+                if (cleanPhrase.length > 2 && cleanPhrase.length < 30) {
+                  // Split into words and add significant ones
+                  cleanPhrase.split(/\s+/).forEach(word => {
+                    if (word.length > 3 && !/^\d+$/.test(word)) {
+                      keywords.push(word);
+                    }
+                  });
+                }
+              }
+
+              // HIGH PRIORITY: Extract quoted strings, but clean UI output text
+              const quotedMatches = text.match(/"([^"]+)"|'([^']+)'/g);
+              if (quotedMatches) {
+                quotedMatches.forEach(match => {
+                  const cleaned = match.replace(/['"]/g, '');
+                  // Skip UI output text (contains numbers, percentages, or is very long)
+                  if (cleaned.length > 2 && cleaned.length < 50 && !cleaned.match(/\d+\s*\(/) && !cleaned.match(/\d+%/)) {
+                    keywords.push(cleaned);
+                  } else if (cleaned.length >= 50) {
+                    // Extract just the key label from long UI text (e.g., "f) Requirements:" from "f) Requirements: 65 (47%)...")
+                    const labelMatch = cleaned.match(/^([a-z]\)\s*)?([A-Za-z\s]+):/);
+                    if (labelMatch) {
+                      keywords.push(labelMatch[2].trim());
+                    }
+                  }
+                });
+              }
+
+              // Extract common prompt phrases (unquoted)
+              const promptPhrases = ['are you sure', 'confirm', 'Remove', 'Delete'];
+              promptPhrases.forEach(phrase => {
+                if (text.toLowerCase().includes(phrase.toLowerCase())) {
+                  keywords.push(phrase);
+                }
+              });
+
+              // MEDIUM PRIORITY: Extract action-related function names (camelCase)
+              const actionWords = text.match(/\b(confirm|delete|remove|show|prompt|ask|verify|check|validate|handle)[A-Z][a-zA-Z0-9_]*/gi);
+              if (actionWords) {
+                actionWords.forEach(match => keywords.push(match));
+              }
+
+              // Extract potential function suffixes
+              const functionMatches = text.match(/\b[a-z][a-zA-Z0-9_]+(?:Action|Handler|Function|Manager|Component|Modal|Prompt|Dialog)\b/g);
+              if (functionMatches) {
+                functionMatches.forEach(match => {
+                  if (match.length > 5 && !['should', 'would', 'could', 'will', 'that', 'this', 'with', 'from'].includes(match)) {
+                    keywords.push(match);
+                  }
+                });
+              }
+
+              // LOW PRIORITY: UI components (capitalized words)
+              const capitalizedMatches = text.match(/\b[A-Z][a-z]+(?:[A-Z][a-z]+)*\b/g);
+              if (capitalizedMatches) {
+                capitalizedMatches.forEach(match => {
+                  if (match.length > 4 && !['When', 'Then', 'After', 'Before', 'With', 'From', 'Pressing'].includes(match)) {
+                    keywords.push(match);
+                  }
+                });
+              }
+
+              return [...new Set(keywords)]; // Remove duplicates
+            };
+
+            const keywords = extractKeywords(currentTitle);
+            console.log(chalk.gray(`   Keywords: ${keywords.slice(0, 5).join(', ')}${keywords.length > 5 ? ` (+${keywords.length - 5} more)` : ''}`));
+
+            // Use simple keyword grep (Aider search is too slow and unreliable)
+            const fs = require('fs-extra');
+            let filesToAdd = [];
+
+            // Try keyword search directly (fast and reliable)
+            try {
+
+              const searchedFiles = new Set();
+              for (const keyword of keywords.slice(0, 5)) { // Limit to first 5 keywords
+                try {
+                  // Search from repo root, not assuming any specific directory structure
+                  const grepCmd = `grep -ril "${keyword}" "${repoPath}" --exclude-dir={node_modules,.git,dist,build,.next,coverage,vendor,target} --include=\\*.{js,jsx,ts,tsx,cjs,mjs,vue,py,rb,go,rs} 2>/dev/null | head -5`;
+                  const result = execSync(grepCmd, { encoding: 'utf8', timeout: 3000 }).trim();
+
+                  if (result) {
+                    const foundFiles = result.split('\n').filter(f => f.trim());
+                    foundFiles.forEach(file => {
+                      const lowerFile = file.toLowerCase();
+                      const isTestFile =
+                        lowerFile.includes('.spec.') ||
+                        lowerFile.includes('.test.') ||
+                        lowerFile.includes('/test/') ||
+                        lowerFile.includes('/tests/') ||
+                        lowerFile.includes('__tests__') ||
+                        lowerFile.match(/test[^/]*\.js$/);
+                      const isTempFile =
+                        lowerFile.includes('temp_') ||
+                        lowerFile.includes('/temp/') ||
+                        lowerFile.includes('.tmp.');
+                      const isBuildArtifact =
+                        lowerFile.includes('/dist/') ||
+                        lowerFile.includes('/build/') ||
+                        lowerFile.includes('/node_modules/') ||
+                        lowerFile.includes('/.next/') ||
+                        lowerFile.includes('/vendor/') ||
+                        lowerFile.includes('/target/');
+
+                      // Don't assume /src/ structure - just exclude test/temp/build files
+                      // Also exclude this file itself (auto.js contains example keywords)
+                      const isThisFile = file.includes('/commands/auto.js');
+                      if (!isTestFile && !isTempFile && !isBuildArtifact && !isThisFile && !searchedFiles.has(file)) {
+                        searchedFiles.add(file);
+                        filesToAdd.push(file);
+                      }
+                    });
+                  }
+                } catch (error) {
+                  // Grep failed - continue
+                }
+              }
+
+              // Sort files: prioritize utils/ over commands/, then by path length (shorter = more specific)
+              filesToAdd.sort((a, b) => {
+                const aIsUtils = a.includes('/utils/');
+                const bIsUtils = b.includes('/utils/');
+                const aIsCommands = a.includes('/commands/');
+                const bIsCommands = b.includes('/commands/');
+
+                // utils/ files first
+                if (aIsUtils && !bIsUtils) return -1;
+                if (!aIsUtils && bIsUtils) return 1;
+                // commands/ files last
+                if (aIsCommands && !bIsCommands) return 1;
+                if (!aIsCommands && bIsCommands) return -1;
+                // Otherwise sort by path length (shorter = more specific)
+                return a.length - b.length;
+              });
+
+              // Limit to top 3
+              filesToAdd = filesToAdd.slice(0, 3);
+            } catch (error) {
+              console.log(chalk.yellow(`   ⚠ Search failed: ${error.message}, using keyword fallback...`));
+              // Fallback to keywords (code already above)
+            }
+
+            // CRITICAL: Filter out files that are too large (prevent context overflow)
+            // For Groq: 12k token limit means we can only handle small files
+            const MAX_FILE_LINES = provider === 'groq' ? 300 : 500; // Stricter limit for Groq
+            const filteredFiles = [];
+            const skippedFiles = [];
+            for (const file of filesToAdd) {
+              try {
+                const stats = fs.statSync(file);
+                const content = fs.readFileSync(file, 'utf8');
+                const lineCount = content.split('\n').length;
+
+                if (lineCount <= MAX_FILE_LINES) {
+                  filteredFiles.push(file);
+                } else {
+                  const relativePath = path.relative(repoPath, file);
+                  console.log(chalk.yellow(`   ⚠ Skipping ${relativePath} (${lineCount} lines, too large)`));
+                  skippedFiles.push({ file, lineCount });
+                }
+              } catch (error) {
+                // Skip files that can't be read
+              }
+            }
+
+            // Save filtered list for Aider prompt (ONLY small files)
+            const filesToTellAiderToAdd = [...filteredFiles];
+
+            // Don't pre-add files (causes context overflow) - we'll tell Aider to /add them
+            filesToAdd = [];
+            console.log(chalk.yellow(`   ⚠ Skipping file pre-load to avoid context overflow`))
+            if (filteredFiles.length > 0) {
+              console.log(chalk.green(`   ✓ Grep found ${filteredFiles.length} file(s) - will tell Aider to add them:`));
+              filteredFiles.forEach(f => console.log(chalk.gray(`     - ${path.relative(repoPath, f)}`)));
+            }
+
+            // For large files, we'll tell Aider to use /search instead
+            const hasLargeFiles = skippedFiles.length > 0;
+
+            // Build simplified prompt for Aider - files are already in context
+            // Status updates will be handled programmatically
+            const promptText = filesToAdd.length > 0
+              ? `You are a code editor. The relevant files have been added to your context.
+
+"${currentTitle}"
+
+STAGE WORKFLOW (output these markers as you progress):
+1. PREPARE → ACT: Output "STAGE: PREPARE -> ACT" when you start making changes
+2. ACT → CLEAN UP: Output "STAGE: ACT -> CLEAN UP" after implementing
+3. CLEAN UP → VERIFY: Output "STAGE: CLEAN UP -> VERIFY" after cleanup
+4. VERIFY → DONE: Output "STAGE: VERIFY -> DONE" when complete
+
+INSTRUCTIONS:
+1. Review the files in your context
+2. Output: STAGE: PREPARE -> ACT
+3. Make ONLY the specific changes needed (1-10 lines total)
+4. Use search/replace blocks to show exact changes
+5. Output: STAGE: ACT -> CLEAN UP
+6. Clean up: lint, remove duplicates, apply DRY principles
+7. Output: STAGE: CLEAN UP -> VERIFY
+8. Verify the changes work correctly
+9. Output: STAGE: VERIFY -> DONE
+10. Do NOT edit ${reqFilename} (requirements file)
+
+EXAMPLE OUTPUT FORMAT:
+\`\`\`
+STAGE: PREPARE -> ACT
+
+path/to/file.js
+<<<<<<< SEARCH
+old code here
+=======
+new code here
+>>>>>>> REPLACE
+
+STAGE: ACT -> CLEAN UP
+
+STAGE: CLEAN UP -> VERIFY
+
+STAGE: VERIFY -> DONE
+\`\`\`
+
+CRITICAL:
+- The files are already in your context - DO NOT use /search or /add
+- Make minimal, surgical changes to 1-10 lines
+- You MUST output all 4 stage transitions
+- The final "STAGE: VERIFY -> DONE" signals completion
+
+NOW: Make the minimal code changes needed.`
+              : `You are a code editor. Follow these steps to implement this requirement:
+
+"${currentTitle}"
+
+${filesToTellAiderToAdd.length > 0 ? `CRITICAL - SEARCH & ADD FILES:
+${hasLargeFiles ? `Some files are too large to add directly. Use /search first:\n${skippedFiles.map(({ file, lineCount }) => `- ${path.relative(repoPath, file)} (${lineCount} lines - use /search to find specific functions)`).join('\n')}\n\nThen add small files:` : 'Add these files:'}
+${filesToTellAiderToAdd.map(f => `- /add ${path.relative(repoPath, f)}`).join('\n')}
+
+Use /search to find the exact code in large files, then make targeted edits.` : `CRITICAL - SEARCH FIRST:
+Use /search to find relevant files, then /add them before making changes.
+Keywords: ${keywords.slice(0, 5).join(', ')}`}
+
+STAGE WORKFLOW (output these markers as you progress):
+1. PREPARE → ACT: Output "STAGE: PREPARE -> ACT" when you find files and start changes
+2. ACT → CLEAN UP: Output "STAGE: ACT -> CLEAN UP" after implementing
+3. CLEAN UP → VERIFY: Output "STAGE: CLEAN UP -> VERIFY" after cleanup
+4. VERIFY → DONE: Output "STAGE: VERIFY -> DONE" when complete
+
+INSTRUCTIONS:
+1. Use /search to find relevant code
+2. Use /add [filepath] to add the files
+3. Output: STAGE: PREPARE -> ACT
+4. Make ONLY the specific changes needed (1-10 lines total)
+5. Use search/replace blocks
+6. Output: STAGE: ACT -> CLEAN UP
+7. Clean up: lint, remove duplicates, apply DRY
+8. Output: STAGE: CLEAN UP -> VERIFY
+9. Verify changes work
+10. Output: STAGE: VERIFY -> DONE
+11. Do NOT edit ${reqFilename}
+
+CRITICAL:
+- Use /search and /add first to find files
+- Make minimal changes (1-10 lines)
+- Output all 4 stage transitions
+
+NOW: Search for and make the minimal code changes needed.`;
+
+            // ITERATIVE PROMPTING: Send multiple prompts to guide Aider through the task
+            // This prevents file destruction and ensures proper completion
+            const maxIterations = 5;
+            const maxRetries = 2; // Retry up to 2 times on timeout/loop
+            let iteration = 1;
+            let allAiderOutput = '';
+            let implementationComplete = false;
+
+            for (iteration = 1; iteration <= maxIterations; iteration++) {
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 📨 Aider iteration ${iteration}/${maxIterations}...\n`));
+
+              let currentPrompt = promptText;
+              if (iteration > 1) {
+                // Escalating instructions for subsequent iterations
+                const escalation = [
+                  '', // iteration 1 (use original prompt)
+                  '\n\nREMINDER: Make MINIMAL changes. Follow the stage workflow and output ALL stage markers: PREPARE->ACT, ACT->CLEAN UP, CLEAN UP->VERIFY, VERIFY->DONE.',
+                  '\n\nWARNING: You are NOT making progress. Use /add [file] and /search [function] commands. Make ONLY 1-5 line changes. Output ALL stage transitions ending with "STAGE: VERIFY -> DONE".',
+                  '\n\nCRITICAL: You MUST:\n1. Use /add [file] and /search [function] commands\n2. Make 1-2 line changes\n3. Output ALL 4 stage transitions: PREPARE->ACT, ACT->CLEAN UP, CLEAN UP->VERIFY, VERIFY->DONE\n\nDO NOT rewrite entire functions.',
+                  '\n\nFINAL WARNING: Make surgical changes to 1-2 specific lines. You MUST output all stage transitions ending with "STAGE: VERIFY -> DONE" or this will be considered a failure.'
+                ][iteration - 1];
+                currentPrompt = promptText + escalation;
+              }
+
+              // Retry loop for timeout/loop detection
+              let aiderResult;
+              let retryCount = 0;
+
+              while (retryCount <= maxRetries) {
+                // Shorter timeout for later iterations (they should be faster)
+                const timeoutMs = iteration === 1 ? 300000 : 180000; // 5min for first, 3min for others
+
+                // Display the prompt being sent to Aider
+                console.log(chalk.bold.cyan('\n📤 Prompt sent to Aider:'));
+                console.log(chalk.gray('─'.repeat(80)));
+                console.log(chalk.white(currentPrompt));
+                console.log(chalk.gray('─'.repeat(80)));
+                console.log();
+
+                // Run Aider with the current prompt and timeout
+                aiderResult = await aiderManager.sendText(
+                  currentPrompt,
+                  repoPath,
+                  provider,
+                  modelName,
+                  null,
+                  filesToAdd, // Add files to Aider's context
+                  (output) => {
+                    // Show Aider output (already filtered by sendText)
+                    process.stdout.write(output);
+                    allAiderOutput += output;
+                  },
+                  (error) => {
+                    // Show errors
+                    console.error(chalk.red(error));
+                  },
+                  timeoutMs
+                );
+
+                // Check if we need to retry
+                if (aiderResult.timeout || aiderResult.loopDetected) {
+                  retryCount++;
+                  if (retryCount <= maxRetries) {
+                    const reason = aiderResult.timeout ? 'timeout' : 'loop detection';
+                    console.log(chalk.yellow(`\n[${getTimestamp()}] ⚠️  Aider hit ${reason}. Retry ${retryCount}/${maxRetries}...\n`));
+                    await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2s before retry
+                    continue;
+                  } else {
+                    console.log(chalk.red(`\n[${getTimestamp()}] ✗ Max retries (${maxRetries}) reached after ${aiderResult.timeout ? 'timeout' : 'loop detection'}\n`));
+                  }
+                }
+
+                // Success or non-retryable failure - break retry loop
+                break;
+              }
+
+              // Handle rate limit - switch to next available provider
+              if (aiderResult.rateLimitDetected) {
+                console.log(chalk.yellow(`\n[${getTimestamp()}] 🔄 Rate limit detected, checking for alternative providers...\n`));
+
+                // Get all available providers
+                const availableProviders = getAvailableProviders(savedConfig);
+
+                // Use ProviderManager to find an available provider (not rate limited)
+                const ProviderManager = require('@vibecodingmachine/core/src/ide-integration/provider-manager.cjs');
+                const providerManager = new ProviderManager();
+                const nextProvider = providerManager.getAvailableProvider(availableProviders);
+
+                if (nextProvider && (nextProvider.provider !== provider || nextProvider.model !== modelName)) {
+                  console.log(chalk.green(`✓ Switching to ${nextProvider.provider}/${nextProvider.model}`));
+
+                  // Update provider and model for next iteration
+                  provider = nextProvider.provider;
+                  modelName = nextProvider.model;
+
+                  // Set API key in environment if available
+                  if (nextProvider.apiKey) {
+                    if (nextProvider.provider === 'groq') {
+                      process.env.GROQ_API_KEY = nextProvider.apiKey;
+                    } else if (nextProvider.provider === 'anthropic') {
+                      process.env.ANTHROPIC_API_KEY = nextProvider.apiKey;
+                    } else if (nextProvider.provider === 'openai') {
+                      process.env.OPENAI_API_KEY = nextProvider.apiKey;
+                    }
+                  }
+
+                  // Retry with new provider
+                  retryCount++;
+                  if (retryCount <= maxRetries) {
+                    console.log(chalk.yellow(`Retrying with new provider... (${retryCount}/${maxRetries})\n`));
+                    await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2s before retry
+                    continue;
+                  } else {
+                    console.log(chalk.red(`\n✗ Max retries (${maxRetries}) reached\n`));
+                    exitReason = 'error';
+                    break;
+                  }
+                } else {
+                  console.log(chalk.red(`✗ No alternative providers available. All providers are rate limited.`));
+
+                  // Show status of all providers
+                  const statuses = providerManager.getProviderStatus(availableProviders);
+                  console.log(chalk.yellow('\n📊 Provider Status:'));
+                  for (const status of statuses) {
+                    const icon = status.available ? '✓' : '✗';
+                    const resetInfo = status.resetIn ? ` (resets in ${status.resetIn})` : '';
+                    console.log(chalk.gray(`  ${icon} ${status.provider}/${status.model}${resetInfo}`));
+                  }
+                  console.log();
+
+                  exitReason = 'rate-limit';
+                  break;
+                }
+              }
+
+              if (!aiderResult.success) {
+                const isRetryableError = aiderResult.timeout || aiderResult.loopDetected;
+                if (isRetryableError && retryCount > maxRetries) {
+                  console.log(chalk.red(`\n✗ Aider failed after ${retryCount} retries: ${aiderResult.error}`));
+                } else if (!isRetryableError) {
+                  console.log(chalk.red(`\n✗ Aider failed: ${aiderResult.error}`));
+                }
+
+                // For timeout/loop after retries, continue to next iteration instead of stopping
+                if (isRetryableError && iteration < maxIterations) {
+                  console.log(chalk.yellow(`⚠️  Will try next iteration with different approach...\n`));
+                  continue;
+                }
+
+                exitReason = 'error';
+                break;
+              }
+
+              allAiderOutput += aiderResult.output || '';
+
+              // Check for explicit STAGE markers in output (all 5 stages)
+              const stageTransitions = [
+                { marker: 'STAGE: PREPARE -> ACT', from: 'PREPARE', to: 'ACT', icon: '🔨' },
+                { marker: 'STAGE: ACT -> CLEAN UP', from: 'ACT', to: 'CLEAN UP', icon: '🧹' },
+                { marker: 'STAGE: CLEAN UP -> VERIFY', from: 'CLEAN UP', to: 'VERIFY', icon: '🔍' },
+                { marker: 'STAGE: VERIFY -> DONE', from: 'VERIFY', to: 'DONE', icon: '✅' }
+              ];
+
+              // Track current stage and display progress card when stage changes
+              let currentStage = 'PREPARE';
+              const stageOrder = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
+
+              for (const transition of stageTransitions) {
+                if (allAiderOutput.includes(transition.marker)) {
+                  currentStage = transition.to;
+
+                  // Display progress card showing stage change
+                  const currentStageIndex = stageOrder.indexOf(currentStage);
+                  const stageDisplay = stageOrder.map((stage, idx) => {
+                    if (idx < currentStageIndex) {
+                      return `✓ ${stage}`;  // Completed stages
+                    } else if (idx === currentStageIndex) {
+                      return `🔨 ${stage}`;  // Current stage
+                    } else {
+                      return `⏳ ${stage}`;  // Future stages
+                    }
+                  }).join(' → ');
+
+                  console.log(chalk.cyan('\n╭────────────────────────────────────────────────────────────────╮'));
+                  console.log(chalk.cyan('│                                                                │'));
+                  console.log(chalk.cyan(`│ ${stageDisplay.padEnd(62)} │`));
+                  console.log(chalk.cyan('│                                                                │'));
+                  const titlePreview = currentTitle.length > 45 ? currentTitle.substring(0, 42) + '...' : currentTitle;
+                  console.log(chalk.cyan(`│ 🎯 Working on: ${titlePreview.padEnd(45)} │`));
+                  console.log(chalk.cyan('│                                                                │'));
+                  console.log(chalk.cyan('╰────────────────────────────────────────────────────────────────╯\n'));
+
+                  console.log(chalk.green(`✓ Stage transition: ${transition.from} → ${transition.to}\n`));
+                }
+              }
+
+              // Check for completion
+              if (allAiderOutput.includes('STAGE: VERIFY -> DONE')) {
+                implementationComplete = true;
+                break;
+              }
+
+              if (iteration === maxIterations) {
+                console.log(chalk.yellow(`\n⚠️  Maximum iterations (${maxIterations}) reached without completion.\n`));
+                break;
+              }
+
+              console.log(chalk.yellow(`\n⚠️  Iteration ${iteration} incomplete. Sending follow-up prompt...\n`));
+              await new Promise(resolve => setTimeout(resolve, 500));
+            }
+
+            // Only update status through workflow stages if work was actually completed
+            if (implementationComplete) {
+              // Update status through workflow stages programmatically
+              // CLEAN UP phase
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 🧹 Updating status to CLEAN UP...`));
+              await updateRequirementsStatus('CLEAN UP', 'Running linting and cleanup');
+              printStatusCard(currentTitle, 'CLEAN UP'); // Show status card after transition
+              await new Promise(resolve => setTimeout(resolve, 1000));
+
+              // VERIFY phase
+              console.log(chalk.cyan(`\n[${getTimestamp()}] ✅ Updating status to VERIFY...`));
+              await updateRequirementsStatus('VERIFY', 'Verifying implementation');
+              printStatusCard(currentTitle, 'VERIFY'); // Show status card after transition
+              await new Promise(resolve => setTimeout(resolve, 1000));
+
+              // DONE phase
+              console.log(chalk.green(`\n[${getTimestamp()}] 🎉 Updating status to DONE...\n`));
+              await updateRequirementsStatus('DONE', `Implementation complete (${iteration} iteration${iteration > 1 ? 's' : ''})`);
+              printStatusCard(currentTitle, 'DONE'); // Show status card after transition;
+            } else {
+              console.log(chalk.yellow(`\n⚠️  Aider did not complete implementation.\n`));
+
+              // Check if requirement might be too vague by having Aider search the codebase first
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 🔍 Searching codebase for relevant code...\n`));
+
+              // STEP 1: Have Aider search the codebase for relevant files
+              const searchPrompt = `Search the codebase to understand this requirement:
+
+"${currentTitle}"
+
+Use /search commands to find relevant code. Report what you found in 2-3 sentences.
+Focus on: What files/functions are related? What patterns exist?
+
+If you cannot find any relevant code, say "NO RELEVANT CODE FOUND".`;
+
+              const searchResult = await aiderManager.sendText(
+                searchPrompt,
+                repoPath,
+                provider,
+                modelName,
+                null,
+                [], // No files - let Aider search
+                (output) => {
+                  // Show search progress
+                  if (output.includes('Searching') || output.includes('Found')) {
+                    process.stdout.write(chalk.gray(output));
+                  }
+                },
+                () => { },
+                90000 // 1.5 minute timeout for search
+              );
+
+              const searchFindings = searchResult.output || 'Search completed but no findings reported.';
+              console.log(chalk.gray(`\nFindings: ${searchFindings}\n`));
+
+              // STEP 2: Check if requirement is vague and generate questions focused on USER INTENT
+              console.log(chalk.cyan(`\n[${getTimestamp()}] 🤔 Analyzing if clarification is needed...\n`));
+
+              const vagueCheckPrompt = `Based on these findings from the codebase:
+"${searchFindings}"
+
+Analyze if this requirement needs clarification:
+"${currentTitle}"
+
+If you found relevant code and understand what to change, respond with: "REQUIREMENT IS CLEAR"
+
+If the requirement is too vague or you need to know USER INTENT, respond with:
+"REQUIREMENT NEEDS CLARIFICATION"
+
+Then list 2-4 questions about USER INTENT ONLY (NOT about file locations - you already found those):
+1. [Question about desired behavior - should X apply to all cases or just Y?]
+2. [Question about user preference - want option A or option B?]
+3. [Question about scope - should this affect Z as well?]
+
+CRITICAL: Do NOT ask "what file" or "which component" - you already searched for that.
+ONLY ask about what the USER WANTS, not where the code is.
+
+Example GOOD questions:
+- Should this change affect ALL confirmation prompts or just the Remove action?
+- Do you want lowercase 'r/y/n' or uppercase 'R/Y/N'?
+
+Example BAD questions (never ask these):
+- What file contains the confirmation prompt? (You should search for this yourself)
+- Which component needs to be modified? (You should find this yourself)`;
+
+              const vagueCheckResult = await aiderManager.sendText(
+                vagueCheckPrompt,
+                repoPath,
+                provider,
+                modelName,
+                null,
+                [], // No files needed for vague check
+                () => { }, // Silent mode
+                () => { },
+                60000 // 1 minute timeout
+              );
+
+              const vagueCheckOutput = vagueCheckResult.output || '';
+              const isVague = vagueCheckOutput.toUpperCase().includes('REQUIREMENT NEEDS CLARIFICATION');
+
+              if (isVague) {
+                // Extract clarifying questions from output
+                const questionMatch = vagueCheckOutput.match(/\d+\.\s*(.+)/g);
+                const questions = questionMatch ? questionMatch.map(q => q.trim()).join('\n') :
+                  '1. What is the desired behavior for this feature?\n2. Should this apply to all cases or specific scenarios?';
+
+                console.log(chalk.yellow(`\n❓ Requirement flagged as TOO VAGUE. Moving to "Requirements needing manual feedback" section.\n`));
+                console.log(chalk.gray('AI Findings:'));
+                console.log(chalk.white(searchFindings));
+                console.log(chalk.gray('\nClarifying questions:'));
+                console.log(chalk.white(questions));
+
+                // Move requirement to "Requirements needing manual feedback" section with findings
+                const moveToFeedbackResult = await moveRequirementToFeedback(repoPath, currentTitle, questions, searchFindings);
+
+                if (moveToFeedbackResult.success) {
+                  console.log(chalk.green(`\n✓ Requirement moved to feedback section. Please provide clarification.\n`));
+                  requirementsCompleted++; // Count as "completed" so we move to next requirement
+                } else {
+                  console.log(chalk.yellow(`\n⚠️  Could not move requirement: ${moveToFeedbackResult.error}\n`));
+                  console.log(chalk.gray('  Requirement remains in TODO for retry.\n'));
+                }
+              } else {
+                console.log(chalk.cyan(`\n✓ Requirement appears clear. Will retry on next run.\n`));
+              }
+            }
+
+
+            // Only check completion and move requirement if implementation was actually completed
+            if (implementationComplete) {
+              // Re-read the current status after updates
+              const updatedDetails = await getCurrentRequirementDetails();
+              currentStatus = updatedDetails.status;
+
+              // Check if requirement is DONE and actually complete
+              const doneCheck = await isRequirementDone(repoPath);
+
+              if (doneCheck.isDone) {
+                if (doneCheck.actuallyComplete) {
+                  console.log(chalk.green('\n✅ Requirement marked as DONE and verified complete!'));
+
+                  // Move completed requirement to TO VERIFY section (for human verification)
+                  const moveResult = await moveCompletedRequirement(repoPath, currentTitle);
+
+                  if (!moveResult.success) {
+                    console.log(chalk.yellow(`\n⚠️  Error moving requirement: ${moveResult.error}`));
+                    console.log('  Auto mode stopping.');
+                    exitReason = 'error';
+                    break;
+                  }
+
+                  console.log(chalk.green(`\n✓ Moved requirement to TO VERIFY section (awaiting human verification)`));
+
+                  // Increment requirements completed counter
+                  requirementsCompleted++;
+
+                  // Show progress update
+                  const currentCounts = await getRequirementCounts();
+                  if (initialCounts && currentCounts) {
+                    const total = currentCounts.todoCount + currentCounts.toVerifyCount + currentCounts.verifiedCount;
+                    const todoPercent = total > 0 ? Math.round((currentCounts.todoCount / total) * 100) : 0;
+                    const toVerifyPercent = total > 0 ? Math.round((currentCounts.toVerifyCount / total) * 100) : 0;
+                    const verifiedPercent = total > 0 ? Math.round((currentCounts.verifiedCount / total) * 100) : 0;
+
+                    const initialTotal = initialCounts.todoCount + initialCounts.toVerifyCount + initialCounts.verifiedCount;
+                    const initialTodoPercent = initialTotal > 0 ? Math.round((initialCounts.todoCount / initialTotal) * 100) : 0;
+                    const initialVerifiedPercent = initialTotal > 0 ? Math.round((initialCounts.verifiedCount / initialTotal) * 100) : 0;
+
+                    console.log(chalk.bold.green('\n📊 Progress Update:'));
+                    console.log(chalk.gray(`   Before: ${initialCounts.todoCount} (${initialTodoPercent}%) TODO, ${initialCounts.verifiedCount} (${initialVerifiedPercent}%) VERIFIED`));
+                    console.log(chalk.cyan(`   Now:    ${currentCounts.todoCount} (${todoPercent}%) TODO, ${currentCounts.toVerifyCount} (${toVerifyPercent}%) TO VERIFY, ${currentCounts.verifiedCount} (${verifiedPercent}%) VERIFIED`));
+
+                    // Ask if user wants to stop with countdown
+                    const readline = require('readline');
+                    console.log(chalk.yellow('\n⏸️  Continue to next requirement or stop?'));
+                    console.log(chalk.gray('   Press any key to stop, or wait 10 seconds to continue...'));
+
+                    let countdown = 10;
+                    let dots = '.'.repeat(countdown);
+                    process.stdout.write(chalk.cyan(`   ${dots}`));
+
+                    const shouldStop = await new Promise((resolve) => {
+                      let stopped = false;
+                      const countdownInterval = setInterval(() => {
+                        if (stopped) return;
+
+                        countdown--;
+                        dots = '.'.repeat(countdown);
+                        process.stdout.write('\r' + chalk.cyan(`   ${dots}${' '.repeat(10 - countdown)}`));
+
+                        if (countdown <= 0) {
+                          clearInterval(countdownInterval);
+                          if (!stopped) {
+                            stopped = true;
+                            readline.createInterface({ input: process.stdin }).close();
+                            process.stdin.setRawMode(false);
+                            console.log('\n');
+                            resolve(false);
+                          }
+                        }
+                      }, 1000);
+
+                      // Listen for any keypress
+                      process.stdin.setRawMode(true);
+                      process.stdin.resume();
+                      process.stdin.once('data', () => {
+                        if (stopped) return;
+                        stopped = true;
+                        clearInterval(countdownInterval);
+                        process.stdin.setRawMode(false);
+                        console.log(chalk.yellow('\n   Stopping auto mode...'));
+                        resolve(true);
+                      });
+                    });
+
+                    if (shouldStop) {
+                      exitReason = 'user-stop';
+                      break;
+                    }
+
+                    console.log(chalk.green('   Continuing...\n'));
+                  } else {
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                  }
+                } else {
+                  // Status is DONE but work appears incomplete
+                  // For test requirements or status-only updates, consider them complete anyway
+                  console.log(chalk.yellow(`\n⚠️  Status shows DONE: ${doneCheck.reason || 'No substantial work detected'}`));
+                  console.log(chalk.gray('  Marking as complete and moving to next requirement...'));
+
+                  // Move completed requirement to TO VERIFY section (for human verification)
+                  const moveResult = await moveCompletedRequirement(repoPath, currentTitle);
+
+                  if (!moveResult.success) {
+                    console.log(chalk.yellow(`\n⚠️  Error moving requirement: ${moveResult.error}`));
+                    console.log('  Auto mode stopping.');
+                    exitReason = 'error';
+                    break;
+                  }
+
+                  console.log(chalk.green(`\n✓ Moved requirement to TO VERIFY section (awaiting human verification)`));
+
+                  // Increment requirements completed counter
+                  requirementsCompleted++;
+
+                  // Show progress update
+                  const currentCounts = await getRequirementCounts();
+                  if (initialCounts && currentCounts) {
+                    const total = currentCounts.todoCount + currentCounts.toVerifyCount + currentCounts.verifiedCount;
+                    const todoPercent = total > 0 ? Math.round((currentCounts.todoCount / total) * 100) : 0;
+                    const toVerifyPercent = total > 0 ? Math.round((currentCounts.toVerifyCount / total) * 100) : 0;
+                    const verifiedPercent = total > 0 ? Math.round((currentCounts.verifiedCount / total) * 100) : 0;
+
+                    const initialTotal = initialCounts.todoCount + initialCounts.toVerifyCount + initialCounts.verifiedCount;
+                    const initialTodoPercent = initialTotal > 0 ? Math.round((initialCounts.todoCount / initialTotal) * 100) : 0;
+                    const initialVerifiedPercent = initialTotal > 0 ? Math.round((initialCounts.verifiedCount / initialTotal) * 100) : 0;
+
+                    console.log(chalk.bold.green('\n📊 Progress Update:'));
+                    console.log(chalk.gray(`   Before: ${initialCounts.todoCount} (${initialTodoPercent}%) TODO, ${initialCounts.verifiedCount} (${initialVerifiedPercent}%) VERIFIED`));
+                    console.log(chalk.cyan(`   Now:    ${currentCounts.todoCount} (${todoPercent}%) TODO, ${currentCounts.toVerifyCount} (${toVerifyPercent}%) TO VERIFY, ${currentCounts.verifiedCount} (${verifiedPercent}%) VERIFIED`));
+
+                    // Ask if user wants to stop with countdown
+                    const readline = require('readline');
+                    console.log(chalk.yellow('\n⏸️  Continue to next requirement or stop?'));
+                    console.log(chalk.gray('   Press any key to stop, or wait 10 seconds to continue...'));
+
+                    let countdown = 10;
+                    let dots = '.'.repeat(countdown);
+                    process.stdout.write(chalk.cyan(`   ${dots}`));
+
+                    const shouldStop = await new Promise((resolve) => {
+                      let stopped = false;
+                      const countdownInterval = setInterval(() => {
+                        if (stopped) return;
+
+                        countdown--;
+                        dots = '.'.repeat(countdown);
+                        process.stdout.write('\r' + chalk.cyan(`   ${dots}${' '.repeat(10 - countdown)}`));
+
+                        if (countdown <= 0) {
+                          clearInterval(countdownInterval);
+                          if (!stopped) {
+                            stopped = true;
+                            readline.createInterface({ input: process.stdin }).close();
+                            process.stdin.setRawMode(false);
+                            console.log('\n');
+                            resolve(false);
+                          }
+                        }
+                      }, 1000);
+
+                      // Listen for any keypress
+                      process.stdin.setRawMode(true);
+                      process.stdin.resume();
+                      process.stdin.once('data', () => {
+                        if (stopped) return;
+                        stopped = true;
+                        clearInterval(countdownInterval);
+                        process.stdin.setRawMode(false);
+                        console.log(chalk.yellow('\n   Stopping auto mode...'));
+                        resolve(true);
+                      });
+                    });
+
+                    if (shouldStop) {
+                      exitReason = 'user-stop';
+                      break;
+                    }
+
+                    console.log(chalk.green('   Continuing...\n'));
+                  } else {
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                  }
+                }
+              } else {
+                // Status is not DONE yet
+                console.log(chalk.yellow(`\n⚠️  Requirement not yet DONE (current status: ${currentStatus}).`));
+                console.log(chalk.gray('  Continuing to next iteration (Aider may need multiple passes)...'));
+
+                // Continue to next iteration - Aider might need multiple passes to complete
+                // Don't move to next requirement yet - keep working on the same one
+                await new Promise(resolve => setTimeout(resolve, 1000));
+              }
+            } // Close if (implementationComplete)
+          }
+
+          console.log(chalk.green(`\n🏁 Auto mode completed. Processed ${chatCount} chat(s).`));
+        } else {
+          // No current requirement and couldn't move one - auto mode can't start
+          console.log(chalk.yellow('\n⚠️  Auto mode cannot start: No current requirement available.'));
+        }
+
+      } catch (error) {
+        exitReason = 'error';
+        console.log(chalk.red(`\n✗ Auto mode error: ${error.message}`));
+        if (error.stack) {
+          console.log(chalk.gray('\nStack trace:'));
+          console.log(chalk.gray(error.stack.split('\n').slice(0, 15).join('\n')));
+        }
+        // Re-throw so interactive.js can handle it properly
+        throw error;
+      } finally {
+        // Remove SIGINT handler
+        if (sigintHandler) {
+          process.removeListener('SIGINT', sigintHandler);
+        }
+        // Stop keyboard handler
+        if (typeof keyboardHandler !== 'undefined') {
+          keyboardHandler.stop();
+        }
+        // Clear watchdog
+        if (typeof watchdog !== 'undefined') {
+          clearInterval(watchdog);
+        }
+        // Pause stdin
+        try {
+          process.stdin.pause();
+        } catch (err) {
+          // Ignore errors
+        }
+        await stopAutoMode(exitReason);
+      }
+
+    } else if (config.ide === 'cline') {
+      // Use Cline CLI
+      spinner.text = 'Checking Cline CLI installation...';
+      const clineManager = new ClineCLIManager();
+
+      if (!clineManager.isInstalled()) {
+        spinner.text = 'Installing Cline CLI...';
+        const installResult = await clineManager.install();
+
+        if (!installResult.success) {
+          spinner.fail('Failed to install Cline CLI');
+          console.log(chalk.red('\n✗ Error:'), installResult.error);
+          console.log(chalk.gray('  You can manually install with:'), chalk.cyan('npm install -g @yaegaki/cline-cli'));
+          process.exit(1);
+        }
+
+        spinner.succeed('Cline CLI installed successfully');
+      }
+
+      // Check if Cline CLI is configured (with valid API key)
+      // This will also auto-sync keys from saved files if needed
+      const isConfigured = clineManager.isConfigured();
+
+      // If configured but user wants to switch, we can check for a force flag
+      // For now, if not configured or if configured provider is unsupported (like gemini),
+      // we'll prompt for setup
+      if (!isConfigured || (isConfigured && options.forceProviderSetup)) {
+        spinner.stop();
+        console.log(chalk.cyan('\n🔐 Setting up API for Cline CLI'));
+        console.log(chalk.gray('  No valid API key found - setting up now...\n'));
+
+        // Prompt for provider selection
+        const readline = require('readline');
+        const inquirer = require('inquirer');
+
+        // Check if any keys exist or providers are configured
+        const hasOpenRouterKey = !!clineManager.getSavedOpenRouterKey();
+        const hasAnthropicKey = !!clineManager.getSavedAnthropicKey();
+        const hasGeminiKey = !!clineManager.getSavedGeminiKey();
+        const hasOllama = clineManager.isOllamaInstalled();
+
+        // Default to Ollama if nothing is configured (even if not installed - will prompt to install)
+        let provider = 'ollama';
+        let autoOpenBrowser = false;
+
+        if (!hasOpenRouterKey && !hasAnthropicKey && !hasGeminiKey) {
+          // No API keys configured - default to Ollama (100% free, local, no limits!)
+          provider = 'ollama';
+          autoOpenBrowser = false;
+          console.log(chalk.cyan('\n🔐 Setting up AI Provider for Cline CLI'));
+          console.log(chalk.gray('  No provider found. Defaulting to Ollama (100% FREE LOCAL AI!).\n'));
+        } else {
+          // At least one API key exists, ask user to choose
+          const choices = [
+            { name: 'Ollama (100% FREE - Local AI, no limits, offline!)', value: 'ollama' }
+          ];
+
+          // Always offer Gemini as a cloud option
+          choices.push({ name: 'Google Gemini (FREE - Best cloud option, no credit card!)', value: 'gemini' });
+
+          if (hasOpenRouterKey) {
+            choices.push({ name: 'OpenRouter (Free but limited - 20 req/min)', value: 'openrouter' });
+          }
+          if (hasAnthropicKey) {
+            choices.push({ name: 'Anthropic Claude (Requires credit card)', value: 'anthropic' });
+          }
+
+          const { selectedProvider } = await inquirer.prompt([{
+            type: 'list',
+            name: 'selectedProvider',
+            message: 'Select AI provider:',
+            choices,
+            default: hasOllama ? 'ollama' : (hasGeminiKey ? 'gemini' : (hasOpenRouterKey ? 'openrouter' : 'anthropic'))
+          }]);
+          provider = selectedProvider;
+          autoOpenBrowser = false;
+        }
+
+        let apiKey = null;
+        let providerName = '';
+        let modelId = '';
+        let apiKeyUrl = '';
+        let apiKeyPrompt = '';
+        let savedKeyFile = '';
+
+        // Handle Ollama setup separately (no API key needed)
+        if (provider === 'ollama') {
+          spinner.stop();
+          console.log(chalk.cyan('\n🤖 Setting up Ollama (Local AI)'));
+
+          // Check if Ollama is installed
+          if (!clineManager.isOllamaInstalled()) {
+            console.log(chalk.yellow('\n⚠ Ollama is not installed on your system.'));
+            console.log(chalk.gray('  Ollama is a local AI runtime that runs models on your computer.'));
+            console.log(chalk.gray('  Benefits: 100% free, no rate limits, works offline, private\n'));
+
+            // Use list prompt to ensure Enter selects Yes (more reliable than confirm)
+            const { shouldInstallChoice } = await inquirer.prompt([{
+              type: 'list',
+              name: 'shouldInstallChoice',
+              message: 'Would you like to install Ollama now?',
+              choices: [
+                { name: 'Yes', value: true },
+                { name: 'No', value: false }
+              ],
+              default: 0  // Default to first option (Yes)
+            }]);
+
+            const shouldInstall = shouldInstallChoice;
+
+            if (!shouldInstall) {
+              console.log(chalk.yellow('\n⚠ Cannot continue without Ollama. Please choose a different provider.'));
+              process.exit(1);
+            }
+
+            // Install Ollama
+            spinner.start('Installing Ollama (this may take a few minutes)...');
+            const installResult = await clineManager.installOllama();
+
+            if (!installResult.success) {
+              if (installResult.needsManualInstall) {
+                // macOS/Windows - requires manual installation
+                spinner.stop();
+                console.log(chalk.yellow('\n⚠ Ollama requires manual installation on macOS/Windows\n'));
+                console.log(chalk.cyan('Your browser should open to: https://ollama.com/download'));
+                console.log(chalk.gray('\nSteps:'));
+                console.log(chalk.gray('  1. Download Ollama for your platform'));
+                console.log(chalk.gray('  2. Install the application'));
+                console.log(chalk.gray('  3. Run this command again\n'));
+
+                const { continueAnyway } = await inquirer.prompt([{
+                  type: 'confirm',
+                  name: 'continueAnyway',
+                  message: 'Did you install Ollama and want to continue?',
+                  default: true
+                }]);
+
+                if (!continueAnyway) {
+                  console.log(chalk.yellow('\n⚠ Please install Ollama and try again later.'));
+                  console.log(chalk.gray('  Or choose a different provider (Gemini is 100% free and works immediately!)\n'));
+                  process.exit(0);
+                }
+
+                // Verify installation
+                if (!clineManager.isOllamaInstalled()) {
+                  console.log(chalk.red('\n✗ Ollama is still not detected. Please ensure it\'s installed correctly.\n'));
+                  process.exit(1);
+                }
+              } else {
+                spinner.fail('Failed to install Ollama');
+                console.log(chalk.red('\n✗ Error:'), installResult.error);
+                console.log(chalk.gray('\nYou can manually install Ollama from: https://ollama.com'));
+                process.exit(1);
+              }
+            } else {
+              spinner.succeed('Ollama installed successfully');
+            }
+          } else {
+            console.log(chalk.green('✓ Ollama is already installed'));
+          }
+
+          // Get list of installed models
+          const installedModels = await clineManager.getOllamaModels();
+
+          if (installedModels.length === 0) {
+            console.log(chalk.yellow('\n⚠ No Ollama models installed yet.'));
+            console.log(chalk.gray('  You need to download a coding model for autonomous development.\n'));
+
+            // Recommend coding models with tool support for Continue CLI
+            const recommendedModels = [
+              { name: 'qwen2.5:1.5b (Recommended - Tool support, fast, 1GB)', value: 'qwen2.5:1.5b' },
+              { name: 'llama3.1:8b (Tool support, good balance, 4.7GB)', value: 'llama3.1:8b' },
+              { name: 'mistral:7b (Tool support, efficient, 4.1GB)', value: 'mistral:7b' },
+              { name: 'qwen2.5:7b (Tool support, larger, 4.7GB)', value: 'qwen2.5:7b' }
+            ];
+
+            // Retry loop for model download
+            let modelDownloaded = false;
+            while (!modelDownloaded) {
+              const { selectedModel } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selectedModel',
+                message: 'Select a model to download:',
+                choices: recommendedModels
+              }]);
+
+              modelId = selectedModel;
+
+              // Download the model
+              console.log(chalk.cyan(`\n📥 Downloading ${modelId}...`));
+              console.log(chalk.gray('  This may take several minutes depending on your connection.\n'));
+
+              spinner.start(`Pulling ${modelId}...`);
+
+              const pullResult = await clineManager.pullOllamaModel(modelId, (progressInfo) => {
+                if (typeof progressInfo === 'object' && progressInfo.percentage !== undefined) {
+                  // Enhanced progress with size info and progress bar
+                  const { percentage, downloaded, total, progressBar } = progressInfo;
+                  if (total !== 'Unknown') {
+                    spinner.text = `Pulling ${modelId}... ${downloaded} / ${total} (${percentage}%) ${progressBar}`;
+                  } else {
+                    spinner.text = `Pulling ${modelId}... ${percentage}% ${progressBar || ''}`;
+                  }
+                } else {
+                  // Fallback for simple percentage
+                  const percent = typeof progressInfo === 'number' ? progressInfo : (progressInfo || '0');
+                  spinner.text = `Pulling ${modelId}... ${percent}%`;
+                }
+              });
+
+              if (!pullResult.success) {
+                spinner.fail(`Failed to download ${modelId}`);
+                console.log(chalk.red('\n✗ Error:'), pullResult.error);
+
+                if (pullResult.resolution) {
+                  console.log(chalk.yellow('\n💡 How to fix:'));
+                  console.log(chalk.gray(pullResult.resolution));
+                  console.log();
+                } else {
+                  console.log(chalk.gray('\n  Please check your internet connection and try again.'));
+                  console.log(chalk.gray('  If the problem persists, you can manually download the model:'));
+                  console.log(chalk.cyan(`  ollama pull ${modelId}`));
+                  console.log();
+                }
+
+                // Ask if they want to try again or choose a different provider
+                const { action } = await inquirer.prompt([{
+                  type: 'list',
+                  name: 'action',
+                  message: 'What would you like to do?',
+                  choices: [
+                    { name: 'Try downloading again', value: 'retry' },
+                    { name: 'Choose a different AI provider (Gemini/OpenRouter/Anthropic)', value: 'switch' },
+                    { name: 'Exit and fix manually', value: 'exit' }
+                  ]
+                }]);
+
+                if (action === 'retry') {
+                  // Continue loop to retry
+                  continue;
+                } else if (action === 'switch') {
+                  console.log(chalk.yellow('\n⚠ Please restart and choose a different provider.'));
+                  console.log(chalk.gray('  Available providers: Gemini (free), OpenRouter (free), Anthropic'));
+                  process.exit(0);
+                } else {
+                  console.log(chalk.gray('\n  To download manually, run:'));
+                  console.log(chalk.cyan(`  ollama pull ${modelId}`));
+                  console.log(chalk.gray('\n  After downloading, restart this setup to continue.'));
+                  process.exit(0);
+                }
+              } else {
+                spinner.succeed(`Downloaded ${modelId}`);
+                modelDownloaded = true;
+              }
+            }
+          } else {
+            // User has models, let them choose
+            console.log(chalk.green('\n✓ Found installed models:'));
+            installedModels.forEach(model => {
+              console.log(chalk.gray(`  - ${model}`));
+            });
+
+            const modelChoices = installedModels.map(model => ({ name: model, value: model }));
+            modelChoices.push({ name: '📥 Download a new model', value: '_download_new' });
+
+            const { selectedModel } = await inquirer.prompt([{
+              type: 'list',
+              name: 'selectedModel',
+              message: 'Select a model to use:',
+              choices: modelChoices,
+              default: installedModels[0]
+            }]);
+
+            if (selectedModel === '_download_new') {
+              const recommendedModels = [
+                { name: 'qwen2.5:1.5b (Recommended - Tool support, fast, 1GB)', value: 'qwen2.5:1.5b' },
+                { name: 'llama3.1:8b (Tool support, good balance, 4.7GB)', value: 'llama3.1:8b' },
+                { name: 'mistral:7b (Tool support, efficient, 4.1GB)', value: 'mistral:7b' },
+                { name: 'qwen2.5:7b (Tool support, larger, 4.7GB)', value: 'qwen2.5:7b' }
+              ];
+
+              // Retry loop for downloading new model
+              let newModelDownloaded = false;
+              while (!newModelDownloaded) {
+                const { newModel } = await inquirer.prompt([{
+                  type: 'list',
+                  name: 'newModel',
+                  message: 'Select a model to download:',
+                  choices: recommendedModels
+                }]);
+
+                modelId = newModel;
+
+                console.log(chalk.cyan(`\n📥 Downloading ${modelId}...`));
+                spinner.start(`Pulling ${modelId}...`);
+
+                const pullResult = await clineManager.pullOllamaModel(modelId, (progressInfo) => {
+                  if (typeof progressInfo === 'object' && progressInfo.percentage !== undefined) {
+                    // Enhanced progress with size info and progress bar
+                    const { percentage, downloaded, total, progressBar } = progressInfo;
+                    if (total !== 'Unknown') {
+                      spinner.text = `Pulling ${modelId}... ${downloaded} / ${total} (${percentage}%) ${progressBar}`;
+                    } else {
+                      spinner.text = `Pulling ${modelId}... ${percentage}% ${progressBar || ''}`;
+                    }
+                  } else {
+                    // Fallback for simple percentage
+                    const percent = typeof progressInfo === 'number' ? progressInfo : (progressInfo || '0');
+                    spinner.text = `Pulling ${modelId}... ${percent}%`;
+                  }
+                });
+
+                if (!pullResult.success) {
+                  spinner.fail(`Failed to download ${modelId}`);
+                  console.log(chalk.red('\n✗ Error:'), pullResult.error);
+
+                  if (pullResult.resolution) {
+                    console.log(chalk.yellow('\n💡 How to fix:'));
+                    console.log(chalk.gray(pullResult.resolution));
+                    console.log();
+                  } else {
+                    console.log(chalk.gray('\n  Please check your internet connection and try again.'));
+                    console.log(chalk.gray('  If the problem persists, you can manually download the model:'));
+                    console.log(chalk.cyan(`  ollama pull ${modelId}`));
+                    console.log();
+                  }
+
+                  // Ask if they want to try again or use existing model
+                  const { action } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                      { name: 'Try downloading again', value: 'retry' },
+                      { name: 'Use an existing model instead', value: 'use-existing' },
+                      { name: 'Exit and fix manually', value: 'exit' }
+                    ]
+                  }]);
+
+                  if (action === 'retry') {
+                    // Continue loop to retry
+                    continue;
+                  } else if (action === 'use-existing') {
+                    // Break out and go back to model selection
+                    modelId = null;
+                    break;
+                  } else {
+                    console.log(chalk.gray('\n  To download manually, run:'));
+                    console.log(chalk.cyan(`  ollama pull ${modelId}`));
+                    console.log(chalk.gray('\n  After downloading, restart this setup to continue.'));
+                    process.exit(0);
+                  }
+                } else {
+                  spinner.succeed(`Downloaded ${modelId}`);
+                  newModelDownloaded = true;
+                }
+              }
+
+              // If model download was cancelled, go back to model selection
+              if (!newModelDownloaded && modelId === null) {
+                // Re-prompt for model selection
+                const { reselectedModel } = await inquirer.prompt([{
+                  type: 'list',
+                  name: 'reselectedModel',
+                  message: 'Select a model to use:',
+                  choices: installedModels.map(model => ({ name: model, value: model })),
+                  default: installedModels[0]
+                }]);
+                modelId = reselectedModel;
+              }
+            } else {
+              modelId = selectedModel;
+            }
+          }
+
+          // Configure Cline CLI with Ollama
+          spinner.start('Configuring Cline CLI with Ollama...');
+          const configResult = await clineManager.configureWithOllama(modelId);
+
+          if (!configResult.success) {
+            spinner.fail('Failed to configure Cline CLI');
+            console.log(chalk.red('\n✗ Error:'), configResult.error);
+            console.log(chalk.yellow('\n💡 How to fix:'));
+            console.log(chalk.gray('  The configuration failed. This might be due to:'));
+            console.log(chalk.gray('  1. Ollama CLI not being in your PATH'));
+            console.log(chalk.gray('  2. Ollama service not running'));
+            console.log(chalk.gray('\n  Try:'));
+            console.log(chalk.cyan('  1. Launch Ollama.app from /Applications'));
+            console.log(chalk.cyan('  2. Or run: ollama serve'));
+            console.log(chalk.gray('\n  Then restart this setup.'));
+            process.exit(0);
+          }
+
+          spinner.succeed('Cline CLI configured with Ollama');
+          console.log(chalk.green('\n✓ Ollama setup complete!'));
+          console.log(chalk.gray(`  Model: ${modelId}`));
+          console.log(chalk.gray('  Endpoint: http://localhost:11434/v1'));
+          console.log(chalk.gray('  100% local, no API keys, no rate limits!\n'));
+
+          // Skip API key collection since Ollama doesn't need it
+          // Set providerName for display
+          providerName = 'Ollama';
+          apiKey = null; // Explicitly set to null to skip API key prompt
+        } else if (provider === 'gemini') {
+          providerName = 'Google Gemini';
+          modelId = 'gemini-2.0-flash-exp';
+          apiKeyUrl = 'https://aistudio.google.com/apikey';
+          apiKeyPrompt = 'Enter your Google Gemini API Key (starts with "AIza"):';
+          savedKeyFile = 'gemini-api-key.txt';
+          apiKey = clineManager.getSavedGeminiKey();
+        } else if (provider === 'openrouter') {
+          providerName = 'OpenRouter';
+          modelId = 'meta-llama/llama-3.3-70b-instruct:free';
+          apiKeyUrl = 'https://openrouter.ai/keys';
+          apiKeyPrompt = 'Enter your OpenRouter API Key (starts with "sk-or-"):';
+          savedKeyFile = 'openrouter-api-key.txt';
+          apiKey = clineManager.getSavedOpenRouterKey();
+        } else {
+          providerName = 'Anthropic';
+          modelId = 'claude-3-5-sonnet-20241022';
+          apiKeyUrl = 'https://console.anthropic.com/settings/keys';
+          apiKeyPrompt = 'Enter your Anthropic API key:';
+          savedKeyFile = 'anthropic-api-key.txt';
+          apiKey = clineManager.getSavedAnthropicKey();
+        }
+
+        if (!apiKey && provider !== 'ollama') {
+          // Display prominent instructions (Ollama doesn't need API key)
+          console.log('\n╔══════════════════════════════════════════════════════════════════╗');
+          console.log('║                                                                  ║');
+          console.log(`║              ⚠️  SETTING UP ${providerName.toUpperCase().padEnd(25)} ⚠️             ║`);
+          console.log('║                                                                  ║');
+
+          if (provider === 'gemini') {
+            console.log('║  ╔══════════════════════════════════════════════════════════╗  ║');
+            console.log('║  ║  ✓  100% FREE - NO CREDIT CARD EVER!                  ║  ║');
+            console.log('║  ╚══════════════════════════════════════════════════════════╝  ║');
+            console.log('║                                                                  ║');
+            console.log('║  Your browser will open to Google AI Studio.                    ║');
+            console.log('║                                                                  ║');
+            console.log('║  ╔══════════════════════════════════════════════════════════╗  ║');
+            console.log('║  ║  ✓  BEST RATE LIMITS (250K tokens/min!)               ║  ║');
+            console.log('║  ╚══════════════════════════════════════════════════════════╝  ║');
+            console.log('║                                                                  ║');
+            console.log('║  1. Sign in with your Google account                            ║');
+            console.log('║  2. Click "Create API Key" button                               ║');
+            console.log('║  3. Choose an imported project: "Default Gemini Project"        ║');
+            console.log('║  4. Give it a name (e.g., "Vibe Coding Machine")                         ║');
+            console.log('║  5. Click the Copy icon next to the API key                     ║');
+            console.log('║  6. Paste it below when prompted                                ║');
+            console.log('║                                                                  ║');
+            console.log('║  Note: Completely free with excellent rate limits!              ║');
+          } else if (provider === 'openrouter') {
+            console.log('║  ╔═══════════════════════════════════════════════════════════╗    ║');
+            console.log('║  ║  ✓  FREE - NO CREDIT CARD REQUIRED!                    ║    ║');
+            console.log('║  ╚═══════════════════════════════════════════════════════════╝    ║');
+            console.log('║                                                                   ║');
+            console.log('║  Your browser will open to OpenRouter API Keys page.             ║');
+            console.log('║                                                                   ║');
+            console.log('║  ╔═══════════════════════════════════════════════════════════╗    ║');
+            console.log('║  ║  ✓  CREATE API KEY (FREE MODELS AVAILABLE)               ║    ║');
+            console.log('║  ╚═══════════════════════════════════════════════════════════╝    ║');
+            console.log('║                                                                   ║');
+            console.log('║  Step-by-step instructions:                                      ║');
+            console.log('║                                                                   ║');
+            console.log('║  1. Sign up/login to OpenRouter (free account, no CC required)    ║');
+            console.log('║     - Visit https://openrouter.ai if you need to sign up         ║');
+            console.log('║  2. Click "Create API Key" button                                ║');
+            console.log('║  3. Give it a name (e.g., "Vibe Coding Machine")                          ║');
+            console.log('║  4. Leave "Reset limit every..." at "N/A"                      ║');
+            console.log('║  5. Click "Create Key" (or similar button)                      ║');
+            console.log('║  6. Copy the API key that appears (starts with "sk-or-")         ║');
+            console.log('║  7. Paste it below when prompted                                 ║');
+            console.log('║                                                                   ║');
+            console.log('║  ⚠ Important notes:                                              ║');
+            console.log('║     • The key is shown only once - copy it immediately!          ║');
+            console.log('║     • Free keys have usage limits (20 requests/minute)           ║');
+            console.log('║     • You can create unlimited new keys when limits are hit      ║');
+          } else {
+            console.log('║  ╔══════════════════════════════════════════════════════╗       ║');
+            console.log('║  ║  ✓  SELECT WORKSPACE & CREATE API KEY            ║       ║');
+            console.log('║  ╚══════════════════════════════════════════════════════╝       ║');
+            console.log('║                                                                  ║');
+            console.log('║  1. Select a workspace (choose "Default" or create new)         ║');
+            console.log('║  2. Click "+ Create Key" button                                 ║');
+            console.log('║  3. Give it a name (e.g., "Vibe Coding Machine")                         ║');
+            console.log('║  4. Copy the API key that appears                               ║');
+            console.log('║  5. Paste it below when prompted                                ║');
+            console.log('║                                                                  ║');
+            console.log('║  Note: Anthropic requires a credit card for API access.          ║');
+          }
+
+          console.log('║                                                                  ║');
+          console.log('╚══════════════════════════════════════════════════════════════════╝');
+
+          if (autoOpenBrowser) {
+            console.log('\nOpening browser now...\n');
+          } else {
+            console.log('\nOpening browser in 3 seconds...\n');
+            // Give user time to read the instructions
+            await new Promise(resolve => setTimeout(resolve, 3000));
+          }
+
+          // Open browser to API keys page
+          const { execSync } = require('child_process');
+          try {
+            const platform = require('os').platform();
+
+            if (platform === 'darwin') {
+              execSync(`open "${apiKeyUrl}"`);
+            } else if (platform === 'win32') {
+              execSync(`start "${apiKeyUrl}"`);
+            } else {
+              execSync(`xdg-open "${apiKeyUrl}"`);
+            }
+
+            console.log(chalk.green(`✓ Browser opened to ${providerName} API Keys page\n`));
+          } catch (error) {
+            console.log(chalk.yellow('⚠ Could not open browser automatically'));
+            console.log(chalk.gray(`  Please visit: ${apiKeyUrl}\n`));
+          }
+
+          // Prompt for API key
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+
+          apiKey = await new Promise((resolve) => {
+            rl.question(chalk.cyan(apiKeyPrompt + ' '), (answer) => {
+              rl.close();
+              resolve(answer.trim());
+            });
+          });
+
+          if (!apiKey || apiKey.length === 0) {
+            console.log(chalk.red('\n✗ Error: Access Token is required'));
+            console.log(chalk.gray(`  Get an Access Token at: ${apiKeyUrl}`));
+            console.log(chalk.gray(`  The token should start with "hf_"`));
+            process.exit(1);
+          }
+
+          // Validate key format
+          if (provider === 'gemini' && !apiKey.startsWith('AIza')) {
+            console.log(chalk.yellow('\n⚠ Warning: Google Gemini API keys typically start with "AIza"'));
+            console.log(chalk.gray('  Please double-check that you copied the correct key.'));
+            console.log(chalk.gray('  If this is correct, you can continue.\n'));
+          } else if (provider === 'openrouter' && !apiKey.startsWith('sk-or-')) {
+            console.log(chalk.yellow('\n⚠ Warning: OpenRouter API keys typically start with "sk-or-"'));
+            console.log(chalk.gray('  Please double-check that you copied the correct key.'));
+            console.log(chalk.gray('  If this is correct, you can continue.\n'));
+          }
+
+          // Validate API key by making a test API call (skip for Ollama - no API key needed)
+          if (provider !== 'ollama') {
+            spinner.start(`Validating ${providerName} API key...`);
+            const validationResult = await clineManager.validateApiKey(provider, apiKey);
+
+            if (!validationResult.valid) {
+              spinner.fail(`Invalid ${providerName} API key`);
+              console.log(chalk.red(`\n✗ Error: ${validationResult.error}`));
+              console.log(chalk.yellow('\n⚠ The API key you provided is invalid or expired.'));
+              console.log(chalk.gray(`  Please get a new API key from: ${apiKeyUrl}`));
+              if (provider === 'openrouter') {
+                console.log(chalk.gray('  Make sure your key starts with "sk-or-" and you have access to free models.'));
+              }
+              process.exit(1);
+            } else {
+              if (validationResult.warning) {
+                spinner.warn(`Validation incomplete: ${validationResult.warning}`);
+                console.log(chalk.yellow(`  ⚠ ${validationResult.warning}`));
+                console.log(chalk.gray('  Continuing anyway - key format looks correct.'));
+              } else {
+                spinner.succeed(`${providerName} API key is valid`);
+              }
+            }
+          }
+
+          // Save API key (skip for Ollama - no API key needed)
+          if (provider !== 'ollama') {
+            let saveResult = false;
+            if (provider === 'gemini') {
+              saveResult = clineManager.saveGeminiKey(apiKey);
+            } else if (provider === 'openrouter') {
+              saveResult = clineManager.saveOpenRouterKey(apiKey);
+            } else {
+              saveResult = clineManager.saveAnthropicKey(apiKey);
+            }
+
+            if (!saveResult) {
+              console.log(chalk.yellow('⚠ Failed to save API key (will use for this session only)'));
+            } else {
+              console.log(chalk.green(`✓ API key saved to ~/.vibecodingmachine/${savedKeyFile}`));
+            }
+          }
+        } else if (provider !== 'ollama') {
+          console.log(chalk.green(`✓ Using saved API key from ~/.vibecodingmachine/${savedKeyFile}`));
+        }
+
+        // Ollama was already configured above, skip API-based provider setup
+        if (provider !== 'ollama') {
+          // Initialize Cline CLI
+          spinner.start('Initializing Cline CLI...');
+          const initResult = await clineManager.init();
+
+          if (!initResult.success) {
+            spinner.fail('Failed to initialize Cline CLI');
+            console.log(chalk.red('\n✗ Error:'), initResult.error);
+            process.exit(1);
+          }
+
+          // Configure Cline CLI with selected provider
+          spinner.text = `Configuring Cline CLI with ${providerName} API...`;
+          let configResult;
+
+          if (provider === 'gemini') {
+            configResult = await clineManager.configureWithGemini(apiKey, modelId);
+          } else if (provider === 'openrouter') {
+            configResult = await clineManager.configureWithOpenRouter(apiKey, modelId);
+          } else {
+            configResult = await clineManager.configureWithAnthropic(apiKey);
+          }
+
+          if (!configResult.success) {
+            spinner.fail('Failed to configure Cline CLI');
+            console.log(chalk.red('\n✗ Error:'), configResult.error);
+            process.exit(1);
+          }
+
+          spinner.succeed('Cline CLI configured successfully');
+          console.log(chalk.green('\n✓ Setup complete!'));
+          console.log(chalk.gray('  Provider:'), chalk.cyan(providerName));
+          console.log(chalk.gray('  Model:'), chalk.cyan(modelId));
+          if (provider !== 'ollama' && apiKey) {
+            console.log(chalk.gray('  API Key:'), chalk.cyan(apiKey.substring(0, 20) + '...'));
+          }
+          console.log(chalk.gray('  Cline config:'), chalk.cyan(configResult.configPath));
+
+          // If configureOnly flag is set, return here without starting auto mode
+          if (options.configureOnly) {
+            console.log(chalk.gray('\n  Provider configured successfully.\n'));
+            return;
+          }
+
+          console.log(chalk.gray('\n  Starting Cline CLI now...\n'));
+        } else {
+          // Ollama was already configured - show summary
+          console.log(chalk.green('\n✓ Ready to start!'));
+          console.log(chalk.gray('  Provider:'), chalk.cyan('Ollama (Local)'));
+          console.log(chalk.gray('  Model:'), chalk.cyan(modelId || 'configured'));
+          console.log(chalk.gray('  Endpoint:'), chalk.cyan('http://localhost:11434/v1'));
+
+          // If configureOnly flag is set, return here without starting auto mode
+          if (options.configureOnly) {
+            console.log(chalk.gray('\n  Provider configured successfully.\n'));
+            return;
+          }
+
+          console.log(chalk.gray('\n  Starting Cline CLI now...\n'));
+        }
+      }
+
+      // Safety check: if configureOnly is set, stop here
+      if (options.configureOnly) {
+        console.log(chalk.gray('\n  Provider configured successfully.\n'));
+        return;
+      }
+
+      // Check for invalid key markers before running
+      const fs = require('fs');
+      const path = require('path');
+      const os = require('os');
+      const allnightDir = path.join(os.homedir(), '.vibecodingmachine');
+      const anthropicInvalidMarker = path.join(allnightDir, '.anthropic-key-invalid');
+      const openrouterInvalidMarker = path.join(allnightDir, '.openrouter-key-invalid');
+      const geminiInvalidMarker = path.join(allnightDir, '.gemini-key-invalid');
+
+      if (fs.existsSync(anthropicInvalidMarker) || fs.existsSync(openrouterInvalidMarker) || fs.existsSync(geminiInvalidMarker)) {
+        spinner.fail('API key was marked as invalid');
+        console.log(chalk.red('\n✗ Error: Previous API key failed authentication'));
+        console.log(chalk.yellow('\n⚠ You need to set up a new API key.'));
+        console.log(chalk.gray('  Please restart auto mode to be prompted for a new API key.'));
+        console.log(chalk.gray('  You can choose Google Gemini (free, no credit card), OpenRouter (free), or Anthropic.'));
+        process.exit(1);
+      }
+
+      // Double-check configuration before running (in case it changed)
+      // This will also trigger auto-sync if key is in saved file but not config
+      const finalConfigCheck = clineManager.isConfigured();
+      if (!finalConfigCheck) {
+        spinner.fail('Cline CLI is not properly configured');
+        console.log(chalk.red('\n✗ Error: No valid API key found'));
+        console.log(chalk.yellow('\n⚠ Cline CLI config exists but API key is missing or invalid.'));
+        console.log(chalk.gray('  Please stop auto mode and restart it to set up your API key.'));
+        console.log(chalk.gray('  You will be prompted to configure Google Gemini (free), OpenRouter (free), or Anthropic API.'));
+        process.exit(1);
+      }
+
+      // Pre-flight API key validation - test the key before starting Cline CLI
+      // This catches invalid keys immediately instead of waiting for 15-second timeout
+      // Skip for Ollama (local, no API key needed)
+      const configPath = path.join(os.homedir(), '.cline_cli', 'cline_cli_settings.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const apiProvider = config.globalState?.apiProvider;
+        const isOllama = apiProvider === 'openai-native' && config.globalState?.openAiBaseUrl === 'http://localhost:11434/v1';
+
+        if (isOllama) {
+          // Ollama - verify it's installed and running
+          spinner.text = 'Checking Ollama installation...';
+          const isInstalled = clineManager.isOllamaInstalled();
+          if (!isInstalled) {
+            spinner.fail('Ollama is not installed');
+            console.log(chalk.red('\n✗ Error: Ollama is configured but not installed'));
+            console.log(chalk.gray('  Please install Ollama or choose a different provider.'));
+            process.exit(1);
+          }
+
+          spinner.succeed('Ollama is installed');
+        } else {
+          // API-based providers - validate keys
+          spinner.text = 'Validating API key before starting...';
+          let apiKey = null;
+
+          if (apiProvider === 'anthropic') {
+            apiKey = config.globalState?.anthropicApiKey || process.env.ANTHROPIC_API_KEY || clineManager.getSavedAnthropicKey();
+          } else if (apiProvider === 'openrouter') {
+            apiKey = config.globalState?.openRouterApiKey || process.env.OPENROUTER_API_KEY || clineManager.getSavedOpenRouterKey();
+          } else if (apiProvider === 'gemini' || (apiProvider === 'openai-native' && config.globalState?.openAiBaseUrl?.includes('generativelanguage.googleapis.com'))) {
+            apiKey = config.globalState?.geminiApiKey || config.globalState?.openAiApiKey || process.env.GEMINI_API_KEY || clineManager.getSavedGeminiKey();
+          }
+
+          if (apiKey) {
+            const validationResult = await clineManager.validateApiKey(
+              apiProvider === 'openai-native' ? 'gemini' : apiProvider,
+              apiKey
+            );
+
+            if (!validationResult.valid) {
+              spinner.fail('API key validation failed');
+              console.log(chalk.red(`\n✗ Error: ${validationResult.error}`));
+
+              // Check if it's a rate limit error
+              if (validationResult.rateLimited) {
+                console.log(chalk.yellow('\n⚠ Your OpenRouter free API key has exceeded its usage limit.'));
+                console.log(chalk.cyan('\n📝 Step-by-step instructions to create a new OpenRouter API key:'));
+                console.log(chalk.gray(''));
+                console.log(chalk.white('  1. Open your browser and visit:'), chalk.cyan('https://openrouter.ai/keys'));
+                console.log(chalk.white('  2. Sign in to your OpenRouter account (or create a free account if needed)'));
+                console.log(chalk.white('  3. Click the'), chalk.cyan('"Create API Key"'), chalk.white('button'));
+                console.log(chalk.white('  4. Give it a name (e.g.,'), chalk.cyan('"Vibe Coding Machine 2"'), chalk.white('or'), chalk.cyan('"Vibe Coding Machine Backup"'), chalk.white(')'));
+                console.log(chalk.white('  5. Leave'), chalk.cyan('"Reset limit every..."'), chalk.white('at'), chalk.cyan('"N/A"'));
+                console.log(chalk.white('  6. Click'), chalk.cyan('"Create Key"'), chalk.white('(or similar button)'));
+                console.log(chalk.white('  7. Copy the API key that appears (starts with'), chalk.cyan('"sk-or-"'), chalk.white(')'));
+                console.log(chalk.white('  8. Save it somewhere safe - it will only be shown once!'));
+                console.log(chalk.gray(''));
+                console.log(chalk.cyan('  9. In Vibe Coding Machine:'));
+                console.log(chalk.white('     • Stop auto mode (if running)'));
+                console.log(chalk.white('     • Start auto mode again'));
+                console.log(chalk.white('     • Select'), chalk.cyan('"OpenRouter"'), chalk.white('when prompted'));
+                console.log(chalk.white('     • Paste your new API key'));
+                console.log(chalk.gray(''));
+                console.log(chalk.cyan('  💡 Important:'));
+                console.log(chalk.gray('     • Free OpenRouter keys have usage limits (typically 20 requests/minute)'));
+                console.log(chalk.gray('     • You can create unlimited new keys for free'));
+                console.log(chalk.gray('     • When one key hits its limit, just create a new one!'));
+                console.log(chalk.gray(''));
+              } else {
+                console.log(chalk.yellow('\n⚠ Your API key is invalid or expired.'));
+              }
+
+              // Mark key as invalid immediately
+              try {
+                if (apiProvider === 'anthropic') {
+                  delete config.globalState.anthropicApiKey;
+                  delete config.globalState.apiProvider;
+                  delete config.globalState.apiModelId;
+                  const savedKeyFile = path.join(allnightDir, 'anthropic-api-key.txt');
+                  if (fs.existsSync(savedKeyFile)) {
+                    fs.unlinkSync(savedKeyFile);
+                  }
+                  const invalidMarker = path.join(allnightDir, '.anthropic-key-invalid');
+                  fs.writeFileSync(invalidMarker, new Date().toISOString());
+                } else if (apiProvider === 'openrouter') {
+                  delete config.globalState.openRouterApiKey;
+                  delete config.globalState.apiProvider;
+                  delete config.globalState.apiModelId;
+                  const savedKeyFile = path.join(allnightDir, 'openrouter-api-key.txt');
+                  if (fs.existsSync(savedKeyFile)) {
+                    fs.unlinkSync(savedKeyFile);
+                  }
+                  const invalidMarker = path.join(allnightDir, '.openrouter-key-invalid');
+                  fs.writeFileSync(invalidMarker, new Date().toISOString());
+                } else if (apiProvider === 'gemini' || apiProvider === 'openai-native') {
+                  delete config.globalState.geminiApiKey;
+                  delete config.globalState.openAiApiKey;
+                  delete config.globalState.apiProvider;
+                  delete config.globalState.apiModelId;
+                  const savedKeyFile = path.join(allnightDir, 'gemini-api-key.txt');
+                  if (fs.existsSync(savedKeyFile)) {
+                    fs.unlinkSync(savedKeyFile);
+                  }
+                  const invalidMarker = path.join(allnightDir, '.gemini-key-invalid');
+                  fs.writeFileSync(invalidMarker, new Date().toISOString());
+                }
+                fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+              } catch (error) {
+                // Non-fatal
+              }
+
+              console.log(chalk.gray('\n  Invalid key has been removed. Restart auto mode to set up a new API key.'));
+              if (!validationResult.rateLimited) {
+                console.log(chalk.gray('  The browser will automatically open to get a new key.'));
+              }
+              process.exit(1);
+            } else {
+              if (validationResult.warning) {
+                spinner.warn(`Validation incomplete: ${validationResult.warning}`);
+              } else {
+                spinner.succeed('API key validated successfully');
+              }
+            }
+          }
+        }
+      }
+
+      // Force re-sync just before running to ensure key is in config file
+      // This handles edge cases where sync might have failed
+      try {
+        const configPath = path.join(os.homedir(), '.cline_cli', 'cline_cli_settings.json');
+        if (fs.existsSync(configPath)) {
+          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          const apiProvider = config.globalState?.apiProvider;
+
+          if (apiProvider === 'anthropic' && !config.globalState?.anthropicApiKey) {
+            const savedKey = clineManager.getSavedAnthropicKey();
+            if (savedKey && savedKey.trim().length > 0) {
+              config.globalState.anthropicApiKey = savedKey;
+              fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+              console.log(chalk.green('✓ Synced API key to Cline CLI config before starting'));
+            }
+          } else if (apiProvider === 'openrouter' && !config.globalState?.openRouterApiKey) {
+            const savedKey = clineManager.getSavedOpenRouterKey();
+            if (savedKey && savedKey.trim().length > 0) {
+              config.globalState.openRouterApiKey = savedKey;
+              fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+              console.log(chalk.green('✓ Synced API key to Cline CLI config before starting'));
+            }
+          } else if (apiProvider === 'gemini' && !config.globalState?.geminiApiKey) {
+            const savedKey = clineManager.getSavedGeminiKey();
+            if (savedKey && savedKey.trim().length > 0) {
+              config.globalState.geminiApiKey = savedKey;
+              fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+              console.log(chalk.green('✓ Synced API key to Cline CLI config before starting'));
+            }
+          }
+        }
+      } catch (error) {
+        // Non-fatal - just log and continue
+        console.log(chalk.yellow('  ⚠ Could not pre-sync API key:', error.message));
+      }
+
+      spinner.text = 'Executing Cline CLI...';
+      console.log(chalk.gray('\n  Running: cline-cli task "') + chalk.cyan(textToSend.substring(0, 60) + '...') + chalk.gray('" --workspace ') + chalk.cyan(repoPath) + chalk.gray(' --full-auto'));
+
+      // Log the command to audit log
+      logIDEMessage('cline', textToSend);
+
+      // Execute Cline CLI in background (non-blocking)
+      try {
+        console.log(chalk.gray('\n─────────────────────────────────────────────────────────'));
+        console.log(chalk.bold.cyan('Cline CLI Output:'));
+        console.log(chalk.gray('─────────────────────────────────────────────────────────\n'));
+
+        // Track error output for authentication detection
+        let errorOutputBuffer = '';
+
+        // Track if we've seen any output (to detect silent failures)
+        let hasSeenOutput = false;
+        let outputCheckInterval;
+
+        const proc = clineManager.runInBackground(
+          textToSend,
+          repoPath,
+          (output) => {
+            // Mark that we've seen output
+            hasSeenOutput = true;
+            if (outputCheckInterval) clearInterval(outputCheckInterval);
+            // Output to console in real-time (tee to stdout)
+            process.stdout.write(chalk.gray(output));
+            // Also log via logger for audit trail
+            if (output.trim()) {
+              logger.info('[Cline]', output.trim());
+            }
+          },
+          (error) => {
+            // Mark that we've seen output (errors count too)
+            hasSeenOutput = true;
+            if (outputCheckInterval) clearInterval(outputCheckInterval);
+            // Collect error output for analysis
+            errorOutputBuffer += error;
+
+            // Output errors to console in real-time with full details
+            const errorText = error.toString();
+            process.stderr.write(chalk.red(errorText));
+            // Also log via logger for audit trail
+            if (errorText.trim()) {
+              logger.error('[Cline Error]', errorText.trim());
+            }
+
+            // If we see "Maximum retries reached", show more diagnostic info
+            if (errorText.toLowerCase().includes('maximum retries reached')) {
+              console.log(chalk.yellow('\n⚠ Diagnostic: Cline CLI is failing to connect to Ollama'));
+              console.log(chalk.gray('  This usually means:'));
+              console.log(chalk.gray('    1. Cline CLI cannot reach Ollama API'));
+              console.log(chalk.gray('    2. Model name format is incorrect'));
+              console.log(chalk.gray('    3. Cline CLI configuration is incorrect\n'));
+            }
+          }
+        );
+
+        spinner.succeed('Cline CLI started in background');
+        console.log(chalk.green('✓ Cline CLI is now running autonomously'));
+        console.log(chalk.gray('  Process ID:'), chalk.cyan(proc.pid));
+        console.log(chalk.gray('  Output is displayed below'));
+        console.log(chalk.gray('  Press Ctrl+C to stop\n'));
+
+        // If no output after 10 seconds, warn the user
+        outputCheckInterval = setInterval(() => {
+          if (!hasSeenOutput) {
+            console.log(chalk.yellow('\n⚠ No output from Cline CLI after 10 seconds.'));
+            console.log(chalk.gray('  This might indicate a configuration issue.'));
+
+            // Detect current provider to give context-aware suggestions
+            try {
+              const fs = require('fs');
+              const path = require('path');
+              const os = require('os');
+              const configPath = path.join(os.homedir(), '.cline_cli', 'cline_cli_settings.json');
+              if (fs.existsSync(configPath)) {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                const baseUrl = config.globalState?.openAiBaseUrl || '';
+                const apiProvider = config.globalState?.apiProvider;
+
+                if (baseUrl.includes('generativelanguage.googleapis.com')) {
+                  console.log(chalk.gray('  You\'re using Gemini. Try switching to Ollama (100% free, no limits) or OpenRouter.'));
+                } else if (baseUrl.includes('localhost:11434') || baseUrl.includes('127.0.0.1:11434')) {
+                  console.log(chalk.gray('  You\'re using Ollama. Check that ollama serve is running.'));
+                } else if (baseUrl.includes('openrouter.ai') || apiProvider === 'openrouter') {
+                  console.log(chalk.gray('  You\'re using OpenRouter. Try switching to Ollama (100% free, no limits) or Gemini.'));
+                } else if (apiProvider === 'anthropic') {
+                  console.log(chalk.gray('  You\'re using Anthropic. Try switching to Ollama (100% free, no limits) or Gemini.'));
+                } else {
+                  console.log(chalk.gray('  Try switching to Ollama (100% free, no limits) or another provider.'));
+                }
+              } else {
+                console.log(chalk.gray('  Try configuring an AI provider (Ollama, Gemini, OpenRouter, or Anthropic).'));
+              }
+            } catch (e) {
+              console.log(chalk.gray('  Try switching AI providers or checking your configuration.'));
+            }
+          }
+        }, 10000);
+
+        // Handle process exit
+        proc.on('close', async (code) => {
+          if (outputCheckInterval) clearInterval(outputCheckInterval);
+          console.log(chalk.gray('\n─────────────────────────────────────────────────────────'));
+          if (code === 0) {
+            if (!hasSeenOutput && errorOutputBuffer.trim().length === 0) {
+              console.log(chalk.yellow('⚠ Cline CLI exited with no output'));
+              console.log(chalk.yellow('  This might indicate a configuration issue.'));
+
+              // Detect current provider to give context-aware suggestions
+              try {
+                const fs = require('fs');
+                const path = require('path');
+                const os = require('os');
+                const configPath = path.join(os.homedir(), '.cline_cli', 'cline_cli_settings.json');
+                if (fs.existsSync(configPath)) {
+                  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                  const baseUrl = config.globalState?.openAiBaseUrl || '';
+                  const apiProvider = config.globalState?.apiProvider;
+
+                  if (baseUrl.includes('generativelanguage.googleapis.com')) {
+                    console.log(chalk.gray('  You\'re using Gemini. Try switching to Ollama (100% free, no limits) or OpenRouter.'));
+                  } else if (baseUrl.includes('localhost:11434') || baseUrl.includes('127.0.0.1:11434')) {
+                    console.log(chalk.gray('  You\'re using Ollama. Check that ollama serve is running.'));
+                  } else if (baseUrl.includes('openrouter.ai') || apiProvider === 'openrouter') {
+                    console.log(chalk.gray('  You\'re using OpenRouter. Try switching to Ollama (100% free, no limits) or Gemini.'));
+                  } else if (apiProvider === 'anthropic') {
+                    console.log(chalk.gray('  You\'re using Anthropic. Try switching to Ollama (100% free, no limits) or Gemini.'));
+                  } else {
+                    console.log(chalk.gray('  Try switching to Ollama (100% free, no limits) or another provider.'));
+                  }
+                } else {
+                  console.log(chalk.gray('  Try configuring an AI provider (Ollama, Gemini, OpenRouter, or Anthropic).'));
+                }
+              } catch (e) {
+                console.log(chalk.gray('  Try switching AI providers or checking your configuration.'));
+              }
+            } else {
+              console.log(chalk.green('✓ Cline CLI completed successfully'));
+            }
+            logger.info(chalk.green('Cline CLI completed successfully'));
+          } else {
+            console.log(chalk.red(`\n✗ Cline CLI exited with code ${code}`));
+
+            // Show full error output for debugging
+            if (errorOutputBuffer.trim()) {
+              console.log(chalk.yellow('\n📋 Full Error Output:'));
+              console.log(chalk.gray(errorOutputBuffer));
+            }
+
+            logger.error(chalk.red(`Cline CLI exited with code ${code}`));
+            if (errorOutputBuffer.trim()) {
+              logger.error('[Cline Full Error]', errorOutputBuffer);
+            }
+
+            // Detect authentication/API key errors
+            const lowerErrorOutput = errorOutputBuffer.toLowerCase();
+
+            // Check which provider is configured
+            const fs2 = require('fs');
+            const path2 = require('path');
+            const os2 = require('os');
+            const configPath2 = path2.join(os2.homedir(), '.cline_cli', 'cline_cli_settings.json');
+            let apiProvider = null;
+            let isOllama = false;
+            let isOpenRouter = false;
+
+            let configuredModelId = null;
+            if (fs2.existsSync(configPath2)) {
+              const config = JSON.parse(fs2.readFileSync(configPath2, 'utf8'));
+              apiProvider = config.globalState?.apiProvider;
+              configuredModelId = config.globalState?.apiModelId;
+              isOllama = apiProvider === 'openai-native' && config.globalState?.openAiBaseUrl === 'http://localhost:11434/v1';
+              isOpenRouter = apiProvider === 'openrouter';
+            }
+
+            // "Maximum retries reached" with OpenRouter is almost always a rate limit issue
+            const isRateLimited = lowerErrorOutput.includes('rate limit') ||
+              lowerErrorOutput.includes('limit exceeded') ||
+              lowerErrorOutput.includes('too many requests') ||
+              lowerErrorOutput.includes('429') ||
+              (isOpenRouter && lowerErrorOutput.includes('maximum retries reached')) ||
+              (lowerErrorOutput.includes('maximum retries reached') &&
+                (lowerErrorOutput.includes('openrouter') || lowerErrorOutput.includes('limit')));
+
+            // For Ollama, "Maximum retries reached" is NOT an auth error - it's a connectivity/service issue
+            const isAuthError = !isOllama && (
+              code === 255 ||
+              code === 1 ||
+              lowerErrorOutput.includes('maximum retries reached') ||
+              lowerErrorOutput.includes('authentication') ||
+              lowerErrorOutput.includes('api key') ||
+              lowerErrorOutput.includes('unauthorized') ||
+              lowerErrorOutput.includes('401') ||
+              lowerErrorOutput.includes('403') ||
+              lowerErrorOutput.includes('invalid api') ||
+              lowerErrorOutput.includes('expired') ||
+              isRateLimited
+            );
+
+            // Ollama-specific errors
+            const isOllamaError = isOllama && (
+              lowerErrorOutput.includes('maximum retries reached') ||
+              lowerErrorOutput.includes('connection refused') ||
+              lowerErrorOutput.includes('connect econnrefused') ||
+              lowerErrorOutput.includes('server not responding') ||
+              code === 255 ||
+              code === 1
+            );
+
+            if (isOllamaError) {
+              // Attempt automatic fix for Ollama
+              try {
+                const fixSpinner = ora('Attempting to fix Ollama automatically...').start();
+
+                // 1) Ensure service is running
+                fixSpinner.text = 'Starting Ollama service...';
+                const started = await clineManager.startOllamaService();
+                if (started) {
+                  fixSpinner.succeed('Ollama service is running');
+                } else {
+                  fixSpinner.warn('Could not confirm Ollama service is running (it may still be starting)');
+                }
+
+                // 2) Verify API endpoint is accessible (wait a bit if service just started)
+                if (started) {
+                  fixSpinner.start('Verifying Ollama API is accessible...');
+                  // Wait a moment for service to fully initialize
+                  await new Promise(resolve => setTimeout(resolve, 2000));
+                  const apiCheck = await clineManager.verifyOllamaAPI();
+                  if (apiCheck.success) {
+                    fixSpinner.succeed('Ollama API is accessible');
+                  } else {
+                    fixSpinner.warn('Ollama API may not be fully ready (will retry)');
+                  }
+
+                  // Re-verify configuration is correct for Cline CLI
+                  if (configuredModelId) {
+                    fixSpinner.start('Re-verifying Cline CLI configuration...');
+                    const configResult = await clineManager.configureWithOllama(configuredModelId);
+                    if (configResult.success) {
+                      fixSpinner.succeed('Cline CLI configuration verified');
+                    } else {
+                      fixSpinner.warn('Could not re-verify configuration (will retry)');
+                    }
+                  }
+                }
+
+                // 3) Ensure configured model is installed and accessible (if known)
+                if (configuredModelId) {
+                  fixSpinner.start(`Ensuring model ${configuredModelId} is installed...`);
+                  const pullResult = await clineManager.pullOllamaModel(configuredModelId, (p) => {
+                    const percent = typeof p === 'object' && p.percentage !== undefined ? p.percentage : p;
+                    fixSpinner.text = `Downloading ${configuredModelId}... ${percent}%`;
+                  });
+                  if (pullResult.success) {
+                    // Verify model is accessible via API
+                    fixSpinner.start(`Verifying model ${configuredModelId} is accessible...`);
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    const modelAccessible = await clineManager.verifyModelAccessible(configuredModelId);
+                    if (modelAccessible) {
+                      fixSpinner.succeed(`Model ${configuredModelId} is ready and accessible`);
+                    } else {
+                      fixSpinner.succeed(`Model ${configuredModelId} is installed (verifying accessibility...)`);
+                    }
+                  } else {
+                    fixSpinner.warn(`Could not verify/download model ${configuredModelId}. Continuing...`);
+                  }
+                }
+
+                // 3) Retry the task once (only retry once to avoid infinite loops)
+                console.log(chalk.cyan('\n↻ Retrying task now that Ollama is ready...\n'));
+                console.log(chalk.gray('─────────────────────────────────────────────────────────'));
+                console.log(chalk.bold.cyan('Cline CLI Output (Retry):'));
+                console.log(chalk.gray('─────────────────────────────────────────────────────────\n'));
+
+                // Track that we've already attempted auto-fix
+                let retryErrorBuffer = '';
+                let retryHasSeenOutput = false;
+                let retryOutputCheckInterval;
+
+                retryOutputCheckInterval = setInterval(() => {
+                  if (!retryHasSeenOutput) {
+                    console.log(chalk.yellow('\n⚠ No output from Cline CLI after 10 seconds.'));
+                    console.log(chalk.gray('  This might indicate a configuration issue.'));
+                  }
+                }, 10000);
+
+                const retryProc = clineManager.runInBackground(
+                  textToSend,
+                  repoPath,
+                  (output) => {
+                    retryHasSeenOutput = true;
+                    if (retryOutputCheckInterval) clearInterval(retryOutputCheckInterval);
+                    process.stdout.write(chalk.gray(output));
+                    if (output.trim()) {
+                      logger.info('[Cline Retry]', output.trim());
+                    }
+                  },
+                  (error) => {
+                    retryHasSeenOutput = true;
+                    if (retryOutputCheckInterval) clearInterval(retryOutputCheckInterval);
+                    retryErrorBuffer += error;
+                    process.stderr.write(chalk.red(error));
+                    if (error.trim()) {
+                      logger.error('[Cline Retry Error]', error.trim());
+                    }
+                  }
+                );
+
+                // Handle retry process exit (don't auto-fix again to avoid loops)
+                retryProc.on('close', async (retryCode) => {
+                  if (retryOutputCheckInterval) clearInterval(retryOutputCheckInterval);
+                  console.log(chalk.gray('\n─────────────────────────────────────────────────────────'));
+                  if (retryCode === 0) {
+                    if (!retryHasSeenOutput && retryErrorBuffer.trim().length === 0) {
+                      console.log(chalk.yellow('⚠ Cline CLI completed but with no output'));
+                    } else {
+                      console.log(chalk.green('✓ Cline CLI completed successfully after retry'));
+                    }
+                    logger.info('Cline CLI completed successfully after retry');
+                  } else {
+                    console.log(chalk.red(`✗ Cline CLI failed again with code ${retryCode}`));
+                    logger.error(`Cline CLI failed again with code ${retryCode}`);
+
+                    // Show error message but don't auto-fix again
+                    const lowerRetryError = retryErrorBuffer.toLowerCase();
+                    if (isOllama && (
+                      lowerRetryError.includes('maximum retries reached') ||
+                      lowerRetryError.includes('connection refused') ||
+                      lowerRetryError.includes('server not responding') ||
+                      lowerRetryError.includes('connect econnrefused')
+                    )) {
+                      console.log(chalk.yellow('\n⚠ Ollama is still having connection issues after automatic fix.'));
+                      console.log(chalk.gray('  Please manually verify:'));
+                      console.log(chalk.cyan('    1. ollama serve (in a separate terminal)'));
+                      console.log(chalk.cyan('    2. curl http://localhost:11434/api/tags'));
+                      console.log(chalk.cyan('    3. ollama list (verify models)'));
+                      if (configuredModelId) {
+                        console.log(chalk.cyan(`    4. ollama pull ${configuredModelId}`));
+                      }
+                      console.log(chalk.gray('\n  If Ollama is running but still failing, there may be a deeper issue.'));
+                      console.log(chalk.gray('  Consider switching to a different AI provider temporarily.'));
+                    } else {
+                      // Other error - show generic help
+                      console.log(chalk.yellow('\n⚠ Cline CLI failed after automatic retry.'));
+                      console.log(chalk.gray('  Please check the error messages above for details.'));
+                    }
+                  }
+                  console.log(chalk.gray('─────────────────────────────────────────────────────────\n'));
+
+                  // Clean up Auto Mode status when retry process exits
+                  await stopAutoMode('completed');
+                });
+
+                // Don't continue with original error handling - retry will handle it
+                return;
+              } catch (autoFixErr) {
+                console.log(chalk.yellow('  ⚠ Automatic fix failed:'), autoFixErr.message);
+              }
+
+              // Ollama-specific error handling
+              console.log(chalk.yellow('\n⚠ Cline CLI failed - Ollama connection error detected.'));
+              console.log(chalk.yellow('  This usually means the Ollama service is not responding or not running.'));
+              console.log(chalk.gray('\n💡 How to fix:'));
+              console.log(chalk.gray('  1. Check if Ollama service is running:'));
+              console.log(chalk.cyan('     ollama serve'));
+              console.log(chalk.gray('  2. Or launch Ollama.app from /Applications'));
+              console.log(chalk.gray('  3. Verify the service is accessible:'));
+              console.log(chalk.cyan('     curl http://localhost:11434/api/tags'));
+              console.log(chalk.gray('  4. Make sure the model you\'re using is installed:'));
+              console.log(chalk.cyan('     ollama list'));
+              if (configuredModelId) {
+                console.log(chalk.gray('  5. Configured model:'), chalk.cyan(configuredModelId));
+                console.log(chalk.gray('  6. If the model is missing, download it:'));
+                console.log(chalk.cyan(`     ollama pull ${configuredModelId}`));
+                console.log(chalk.gray('  7. Then restart auto mode and try again\n'));
+              } else {
+                console.log(chalk.gray('  5. If the model is missing, download it:'));
+                console.log(chalk.cyan('     ollama pull <model-name>'));
+                console.log(chalk.gray('  6. Then restart auto mode and try again\n'));
+              }
+              // Don't clear config for Ollama errors - it's a service issue, not a config issue
+            } else if (isAuthError) {
+              if (isRateLimited) {
+                console.log(chalk.yellow('\n⚠ Cline CLI failed - rate limit error detected.'));
+                console.log(chalk.yellow('  Your OpenRouter free API key has exceeded its usage limit.'));
+                console.log(chalk.cyan('\n📝 Step-by-step instructions to create a new OpenRouter API key:'));
+                console.log(chalk.gray(''));
+                console.log(chalk.white('  1. Open your browser and visit:'), chalk.cyan('https://openrouter.ai/keys'));
+                console.log(chalk.white('  2. Sign in to your OpenRouter account (or create a free account if needed)'));
+                console.log(chalk.white('  3. Click the'), chalk.cyan('"Create API Key"'), chalk.white('button'));
+                console.log(chalk.white('  4. Give it a name (e.g.,'), chalk.cyan('"Vibe Coding Machine 2"'), chalk.white('or'), chalk.cyan('"Vibe Coding Machine Backup"'), chalk.white(')'));
+                console.log(chalk.white('  5. Leave'), chalk.cyan('"Reset limit every..."'), chalk.white('at'), chalk.cyan('"N/A"'));
+                console.log(chalk.white('  6. Click'), chalk.cyan('"Create Key"'), chalk.white('(or similar button)'));
+                console.log(chalk.white('  7. Copy the API key that appears (starts with'), chalk.cyan('"sk-or-"'), chalk.white(')'));
+                console.log(chalk.white('  8. Save it somewhere safe - it will only be shown once!'));
+                console.log(chalk.gray(''));
+                console.log(chalk.cyan('  9. In Vibe Coding Machine:'));
+                console.log(chalk.white('     • Stop auto mode (if running)'));
+                console.log(chalk.white('     • Start auto mode again'));
+                console.log(chalk.white('     • Select'), chalk.cyan('"OpenRouter"'), chalk.white('when prompted'));
+                console.log(chalk.white('     • Paste your new API key'));
+                console.log(chalk.gray(''));
+                console.log(chalk.cyan('  💡 Important:'));
+                console.log(chalk.gray('     • Free OpenRouter keys have usage limits (typically 20 requests/minute)'));
+                console.log(chalk.gray('     • You can create unlimited new keys for free'));
+                console.log(chalk.gray('     • When one key hits its limit, just create a new one!'));
+                console.log(chalk.gray(''));
+              } else {
+                console.log(chalk.yellow('\n⚠ Cline CLI failed - authentication error detected.'));
+                console.log(chalk.yellow('  This usually means your API key is missing, invalid, or expired.'));
+              }
+
+              // Clear invalid API key from BOTH config file AND saved file to force reconfiguration
+              try {
+                const fs = require('fs');
+                const path = require('path');
+                const os = require('os');
+                const configPath = path.join(os.homedir(), '.cline_cli', 'cline_cli_settings.json');
+                const allnightDir = path.join(os.homedir(), '.vibecodingmachine');
+
+                if (fs.existsSync(configPath)) {
+                  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+                  const apiProvider = config.globalState?.apiProvider;
+
+                  if (apiProvider === 'anthropic') {
+                    // Clear the invalid key AND provider from config to force reconfiguration
+                    delete config.globalState.anthropicApiKey;
+                    delete config.globalState.apiProvider;
+                    delete config.globalState.apiModelId;
+                    fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+
+                    // Also clear saved key file and create invalid marker
+                    const savedKeyFile = path.join(allnightDir, 'anthropic-api-key.txt');
+                    if (fs.existsSync(savedKeyFile)) {
+                      fs.unlinkSync(savedKeyFile);
+                    }
+
+                    // Create marker file to prevent re-syncing invalid key
+                    const invalidMarker = path.join(allnightDir, '.anthropic-key-invalid');
+                    fs.writeFileSync(invalidMarker, new Date().toISOString());
+
+                    console.log(chalk.gray('\n  ✓ Cleared invalid API key from config and saved files'));
+                    console.log(chalk.gray('  Next time you start auto mode, you will be prompted to set up a new API key.'));
+                  } else if (apiProvider === 'openrouter') {
+                    // For rate-limited keys, don't delete the key file (user can create new one)
+                    // Just clear from config so they can reconfigure
+                    if (isRateLimited) {
+                      delete config.globalState.openRouterApiKey;
+                      delete config.globalState.apiProvider;
+                      delete config.globalState.apiModelId;
+                      fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+                      console.log(chalk.gray('\n  ✓ Cleared rate-limited API key from config'));
+                      console.log(chalk.gray('  Your saved key file was kept - you can create a new key and reconfigure.'));
+                    } else {
+                      // Invalid key - clear everything
+                      delete config.globalState.openRouterApiKey;
+                      delete config.globalState.apiProvider;
+                      delete config.globalState.apiModelId;
+                      fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+
+                      // Also clear saved key file and create invalid marker
+                      const savedKeyFile = path.join(allnightDir, 'openrouter-api-key.txt');
+                      if (fs.existsSync(savedKeyFile)) {
+                        fs.unlinkSync(savedKeyFile);
+                      }
+
+                      // Create marker file to prevent re-syncing invalid key
+                      const invalidMarker = path.join(allnightDir, '.openrouter-key-invalid');
+                      fs.writeFileSync(invalidMarker, new Date().toISOString());
+
+                      console.log(chalk.gray('\n  ✓ Cleared invalid API key from config and saved files'));
+                    }
+                    console.log(chalk.gray('  Next time you start auto mode, you will be prompted to set up a new API key.'));
+                  } else if (apiProvider === 'gemini') {
+                    // Clear the invalid key AND provider from config to force reconfiguration
+                    delete config.globalState.geminiApiKey;
+                    delete config.globalState.apiProvider;
+                    delete config.globalState.apiModelId;
+                    fs.writeFileSync(configPath, JSON.stringify(config, null, 4));
+
+                    // Also clear saved key file and create invalid marker
+                    const savedKeyFile = path.join(allnightDir, 'gemini-api-key.txt');
+                    if (fs.existsSync(savedKeyFile)) {
+                      fs.unlinkSync(savedKeyFile);
+                    }
+
+                    // Create marker file to prevent re-syncing invalid key
+                    const invalidMarker = path.join(allnightDir, '.gemini-key-invalid');
+                    fs.writeFileSync(invalidMarker, new Date().toISOString());
+
+                    console.log(chalk.gray('\n  ✓ Cleared invalid API key from config and saved files'));
+                    console.log(chalk.gray('  Next time you start auto mode, you will be prompted to set up a new API key.'));
+                  }
+                }
+              } catch (clearError) {
+                // Non-fatal
+                console.log(chalk.yellow('  ⚠ Could not clear invalid config:', clearError.message));
+              }
+
+              console.log(chalk.gray('\n  To fix this:'));
+              console.log(chalk.gray('  1. Stop auto mode (press Ctrl+C or select "Auto Mode: Stop")'));
+              console.log(chalk.gray('  2. Start auto mode again'));
+              console.log(chalk.gray('  3. You will be prompted to set up a new API key'));
+              console.log(chalk.gray('  4. Choose Google Gemini (free, no credit card), OpenRouter (free), or Anthropic'));
+              console.log(chalk.gray('  5. Enter a valid API key'));
+            }
+          }
+          console.log(chalk.gray('─────────────────────────────────────────────────────────\n'));
+
+          // Clean up Auto Mode status when Cline CLI process exits
+          await stopAutoMode('completed');
+        });
+      } catch (error) {
+        spinner.fail('Failed to start Cline CLI');
+        console.log(chalk.red('\n✗ Error:'), error.message);
+
+        // Clean up Auto Mode status if Cline CLI fails to start
+        await stopAutoMode('error');
+      }
+    } else {
+      // Use AppleScript for GUI IDEs
+
+      // Check if IDE is installed, download if needed
+      spinner.text = `Checking ${config.ide} installation...`;
+      const fs = require('fs');
+      const { spawn } = require('child_process');
+      const https = require('https');
+
+      const ideAppPaths = {
+        'cursor': '/Applications/Cursor.app',
+        'windsurf': '/Applications/Windsurf.app',
+        'antigravity': '/Applications/Antigravity.app',
+        'vscode': '/Applications/Visual Studio Code.app'
+      };
+
+      const ideDownloadUrls = {
+        'antigravity': os.arch() === 'arm64'
+          ? 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-arm/Antigravity.dmg'
+          : 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-x64/Antigravity.dmg'
+      };
+
+      const ideAppPath = ideAppPaths[config.ide];
+
+      if (ideAppPath && !fs.existsSync(ideAppPath)) {
+        spinner.warn(chalk.yellow(`${config.ide} not found at ${ideAppPath}`));
+
+        const downloadUrl = ideDownloadUrls[config.ide];
+        if (downloadUrl) {
+          console.log(chalk.cyan(`📥 Downloading ${config.ide}...`));
+          spinner.text = `Downloading ${config.ide}...`;
+
+          const downloadPath = path.join(os.tmpdir(), `${config.ide}.dmg`);
+
+          try {
+            // Download the DMG
+            await new Promise((resolve, reject) => {
+              const file = fs.createWriteStream(downloadPath);
+
+              const downloadFile = (url) => {
+                https.get(url, (response) => {
+                  // Handle redirects
+                  if (response.statusCode === 301 || response.statusCode === 302) {
+                    file.close();
+                    fs.unlinkSync(downloadPath);
+                    downloadFile(response.headers.location);
+                    return;
+                  }
+
+                  if (response.statusCode !== 200) {
+                    file.close();
+                    fs.unlinkSync(downloadPath);
+                    reject(new Error(`Download failed with status ${response.statusCode}`));
+                    return;
+                  }
+
+                  response.pipe(file);
+                  file.on('finish', () => {
+                    file.close();
+                    resolve();
+                  });
+                }).on('error', (err) => {
+                  try {
+                    file.close();
+                    fs.unlinkSync(downloadPath);
+                  } catch (e) {
+                    // Ignore cleanup errors
+                  }
+                  reject(err);
+                });
+              };
+
+              downloadFile(downloadUrl);
+            });
+
+            console.log(chalk.green(`✓ Downloaded ${config.ide}`));
+            spinner.text = `Installing ${config.ide}...`;
+
+            // Mount the DMG (remove -quiet to get mount point output)
+            const { execSync } = require('child_process');
+            const mountOutput = execSync(`hdiutil attach "${downloadPath}" -nobrowse`, { encoding: 'utf8' });
+
+            // Parse mount point from hdiutil output (last line contains mount point)
+            const lines = mountOutput.trim().split('\n');
+            const lastLine = lines[lines.length - 1];
+            const mountPoint = lastLine.match(/\/Volumes\/.+$/)?.[0]?.trim();
+
+            if (mountPoint) {
+              console.log(chalk.gray(`  Mounted at: ${mountPoint}`));
+
+              // Determine app name inside DMG
+              const appName = config.ide === 'antigravity' ? 'Antigravity' :
+                config.ide === 'cursor' ? 'Cursor' :
+                  config.ide === 'windsurf' ? 'Windsurf' :
+                    config.ide === 'vscode' ? 'Visual Studio Code' : config.ide;
+
+              // Copy app to Applications
+              execSync(`cp -R "${mountPoint}/${appName}.app" /Applications/`, { encoding: 'utf8' });
+
+              // Unmount
+              execSync(`hdiutil detach "${mountPoint}"`, { encoding: 'utf8' });
+
+              // Clean up DMG
+              fs.unlinkSync(downloadPath);
+
+              console.log(chalk.green(`✓ Installed ${config.ide} to /Applications`));
+              spinner.succeed(`${config.ide} installed successfully`);
+            } else {
+              throw new Error(`Could not parse mount point from: ${mountOutput}`);
+            }
+          } catch (downloadError) {
+            spinner.fail(`Failed to install ${config.ide}`);
+            console.log(chalk.red('Error:'), downloadError.message);
+            console.log(chalk.gray(`Please install ${config.ide} manually from its website`));
+            await stopAutoMode('error');
+            return;
+          }
+        } else {
+          spinner.fail(`${config.ide} not installed and auto-installation not available`);
+          console.log(chalk.yellow(`\nPlease install ${config.ide} manually before using it with Vibe Coding Machine`));
+          await stopAutoMode('error');
+          return;
+        }
+      } else if (ideAppPath) {
+        spinner.succeed(`${config.ide} is installed`);
+      }
+
+      // Launch the IDE if it's not already running
+      spinner.text = `Launching ${config.ide}...`;
+      const { execSync } = require('child_process');
+
+      try {
+        // Check if IDE is already running
+        const isRunning = execSync(`pgrep -x "${config.ide === 'antigravity' ? 'Antigravity' :
+          config.ide === 'cursor' ? 'Cursor' :
+            config.ide === 'windsurf' ? 'Windsurf' :
+              config.ide === 'vscode' ? 'Code' : config.ide}"`,
+          { encoding: 'utf8', stdio: 'pipe' }).trim();
+        if (isRunning) {
+          console.log(chalk.gray(`  ${config.ide} is already running (PID: ${isRunning.split('\n')[0]})`));
+        }
+      } catch (err) {
+        // Not running, launch it
+        console.log(chalk.gray(`  Launching ${config.ide}...`));
+        const appName = config.ide === 'antigravity' ? 'Antigravity' :
+          config.ide === 'cursor' ? 'Cursor' :
+            config.ide === 'windsurf' ? 'Windsurf' :
+              config.ide === 'vscode' ? 'Visual Studio Code' : config.ide;
+
+        execSync(`open -a "${appName}" "${repoPath}"`, { encoding: 'utf8' });
+
+        // Wait for the app to launch (Electron apps need more time)
+        const waitTime = (config.ide === 'antigravity' || config.ide === 'cursor' || config.ide === 'windsurf') ? 5000 : 3000;
+        console.log(chalk.gray(`  Waiting for ${config.ide} to start...`));
+        await new Promise(resolve => setTimeout(resolve, waitTime));
+
+        // Verify it's now running
+        try {
+          const processName = config.ide === 'antigravity' ? 'Antigravity' :
+            config.ide === 'cursor' ? 'Cursor' :
+              config.ide === 'windsurf' ? 'Windsurf' :
+                config.ide === 'vscode' ? 'Code' : config.ide;
+          const pid = execSync(`pgrep -x "${processName}"`, { encoding: 'utf8', stdio: 'pipe' }).trim();
+          console.log(chalk.green(`  ✓ ${config.ide} started successfully (PID: ${pid.split('\n')[0]})`));
+        } catch (checkErr) {
+          console.log(chalk.yellow(`  ⚠ ${config.ide} may still be starting up...`));
+          // Continue anyway - the AppleScript will retry
+        }
+      }
+
+      spinner.text = 'Sending initial message to IDE...';
+      const asManager = new AppleScriptManager();
+
+      try {
+        const result = await asManager.sendText(textToSend, config.ide);
+
+        if (!result.success) {
+          logIDEMessage(config.ide, `[FAILED] ${textToSend}`);
+          spinner.warn('Auto mode started but failed to send initial message to IDE');
+          console.log(chalk.yellow('\n⚠ Warning:'), result.error || 'Failed to send message');
+          console.log(chalk.gray('  Consider using'), chalk.cyan('Cline IDE'), chalk.gray('instead (set with'), chalk.cyan('allnightai'), chalk.gray('menu)'));
+        } else {
+          logIDEMessage(config.ide, textToSend);
+          spinner.succeed('Autonomous mode started and initial message sent');
+          console.log(chalk.green('\n✓ Vibe Coding Machine is now coding autonomously'));
+        }
+      } catch (sendError) {
+        logIDEMessage(config.ide, `[ERROR] ${textToSend}`);
+        spinner.warn('Auto mode started but failed to send initial message');
+        console.log(chalk.yellow('\n⚠ Warning:'), sendError.message);
+        console.log(chalk.gray('  Consider using'), chalk.cyan('Cline IDE'), chalk.gray('instead'));
+      }
+    }
+
+    // Format IDE name for display
+    const formatIDEName = (ide) => {
+      const ideNames = {
+        'aider': 'Aider CLI',
+        'cline': 'Cline IDE',
+        'continue': 'Continue CLI',
+        'cursor': 'Cursor',
+        'vscode': 'VS Code',
+        'windsurf': 'Windsurf',
+        'antigravity': 'Google Antigravity'
+      };
+      return ideNames[ide] || ide;
+    };
+    console.log(chalk.gray('  IDE:'), chalk.cyan(formatIDEName(config.ide)));
+
+    if (config.neverStop) {
+      console.log(chalk.gray('  Mode:'), chalk.cyan('Never stop'));
+    } else if (config.maxChats) {
+      console.log(chalk.gray('  Max chats:'), chalk.cyan(config.maxChats));
+    }
+  } catch (error) {
+    spinner.stop();
+    spinner.fail('Failed to start autonomous mode');
+    console.error(chalk.red('Error:'), error.message);
+    if (error.stack) {
+      console.log(chalk.gray(error.stack));
+    }
+    throw error; // Re-throw so interactive.js can handle it
+  }
+}
+
+async function stop() {
+  const spinner = ora('Stopping autonomous mode...').start();
+
+  try {
+    // Create stop file to signal running auto:start process
+    const fs = require('fs-extra');
+    const stopFilePath = path.join(os.homedir(), '.config', 'allnightai', '.stop');
+
+    await fs.ensureDir(path.dirname(stopFilePath));
+    await fs.writeFile(stopFilePath, `Stop requested at ${new Date().toISOString()}`);
+
+    spinner.text = 'Stop signal sent, waiting for process to exit...';
+
+    // Wait a moment for the process to detect the stop file
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Clean up auto mode status
+    await stopAutoMode();
+
+    spinner.succeed('Autonomous mode stopped');
+    console.log(chalk.gray('\n  The running process should exit within a few seconds.'));
+  } catch (error) {
+    spinner.fail('Failed to stop autonomous mode');
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function status() {
+  try {
+    const autoStatus = await checkAutoModeStatus();
+    const config = await getAutoConfig();
+
+    console.log(chalk.bold('\nAuto Mode Status\n'));
+
+    if (autoStatus.running) {
+      console.log(chalk.green('●'), 'Running');
+      console.log(chalk.gray('  IDE:'), chalk.cyan(config.ide || 'cursor'));
+      console.log(chalk.gray('  Chat count:'), chalk.cyan(autoStatus.chatCount || 0));
+
+      if (config.neverStop) {
+        console.log(chalk.gray('  Mode:'), chalk.cyan('Never stop'));
+      } else if (config.maxChats) {
+        console.log(chalk.gray('  Max chats:'), chalk.cyan(config.maxChats));
+        const remaining = config.maxChats - (autoStatus.chatCount || 0);
+        console.log(chalk.gray('  Remaining:'), chalk.cyan(remaining));
+      }
+    } else {
+      console.log(chalk.gray('○'), 'Not running');
+    }
+
+    console.log();
+  } catch (error) {
+    console.error(chalk.red('Error checking status:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function config(options) {
+  try {
+    const currentConfig = await getAutoConfig();
+    const newConfig = { ...currentConfig };
+
+    if (options.maxChats !== undefined) {
+      newConfig.maxChats = options.maxChats;
+    }
+
+    if (options.neverStop !== undefined) {
+      newConfig.neverStop = options.neverStop;
+    }
+
+    await setAutoConfig(newConfig);
+
+    console.log(chalk.green('✓'), 'Auto mode configuration updated');
+    console.log(chalk.gray('\nCurrent settings:'));
+
+    if (newConfig.neverStop) {
+      console.log(chalk.gray('  Mode:'), chalk.cyan('Never stop'));
+    } else if (newConfig.maxChats) {
+      console.log(chalk.gray('  Max chats:'), chalk.cyan(newConfig.maxChats));
+    }
+  } catch (error) {
+    console.error(chalk.red('Error updating configuration:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  start,
+  stop,
+  status,
+  config
+};