vibecodingmachine-cli 2025.12.6-1702 → 2025.12.22-2230

package/bin/vibecodingmachine.js

@@ -35,7 +35,13 @@ const { cleanupBrokenAssets } = require('../src/utils/asset-cleanup');
 const { program } = require('commander');
 const chalk = require('chalk');
 const inquirer = require('inquirer');
-const { execSync } = require('child_process');
+const { execSync, spawn } = require('child_process');
+const ora = require('ora');
+const https = require('https');
+const os = require('os');
+const { pipeline } = require('stream');
+const { promisify } = require('util');
+const streamPipeline = promisify(pipeline);
 // const path = require('path'); // Moved to top for .env.auth loading
 const packageJson = require('../package.json');
 
@@ -117,6 +123,11 @@ program
   .option('--no-never-stop', 'Disable never stop mode')
   .action(autoCommands.config);
 
+program
+  .command('auto:agents')
+  .description('List available agents and their quota status')
+  .action(autoCommands.listAgents);
+
 // Requirements management commands
 program
   .command('req:list')
@@ -298,18 +309,33 @@ program
 // Error handling
 process.on('uncaughtException', (error) => {
   console.error(chalk.red('Error:'), error.message);
+  if (process.env.DEBUG) {
+    console.error(chalk.gray('Stack:'), error.stack);
+  }
   process.exit(1);
 });
 
 process.on('unhandledRejection', (error) => {
   console.error(chalk.red('Error:'), error.message);
+  if (process.env.DEBUG) {
+    console.error(chalk.gray('Stack:'), error.stack);
+  }
   process.exit(1);
 });
 
 // Check for updates and display notification
 async function checkForUpdates() {
   try {
+    if (process.env.VCM_SKIP_UPDATE_CHECK === '1' || process.env.VCM_SKIP_UPDATE_CHECK === 'true') {
+      return;
+    }
     const { checkForCLIUpdates } = require('vibecodingmachine-core');
+    // If running inside the repository (local development), skip update checks entirely
+    const isDevWorkspace = fs.existsSync(path.join(rootDir, '.git'));
+    if (isDevWorkspace) {
+      console.log(chalk.yellow('\nDetected local development workspace; skipping update check.'));
+      return;
+    }
     console.log(chalk.gray(`\n🔍 Checking for updates... (current: v${packageJson.version})`));
     const updateInfo = await checkForCLIUpdates(packageJson.version);
     console.log(chalk.gray(`   Update check result: ${JSON.stringify(updateInfo)}\n`));
@@ -335,14 +361,136 @@ async function checkForUpdates() {
       if (answer.shouldUpdate) {
         console.log(chalk.cyan('\n🔄 Updating VibeCodingMachine CLI...\n'));
         try {
-          // Run npm install with inherited stdio to show progress
-          execSync('npm install -g vibecodingmachine-cli@latest', {
-            stdio: 'inherit',
-            encoding: 'utf8'
+          // If we're running from the repository (local dev), avoid performing a global install
+          const isDevWorkspace = fs.existsSync(path.join(rootDir, '.git'));
+          if (isDevWorkspace) {
+            console.log(chalk.yellow('\nDetected local development workspace; skipping automatic global install.'));
+            console.log(chalk.gray('   To update the globally installed CLI run:') + ' ' + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
+            // Do not attempt global install during development to avoid confusing local dev flow
+            return;
+          }
+          const spinner = ora('Fetching package metadata...').start();
+
+          // Get latest package metadata from npm registry
+          const registryUrl = 'https://registry.npmjs.org/vibecodingmachine-cli/latest';
+          const meta = await new Promise((resolve, reject) => {
+            https.get(registryUrl, (res) => {
+              let data = '';
+              res.on('data', (chunk) => data += chunk);
+              res.on('end', () => {
+                try {
+                  resolve(JSON.parse(data));
+                } catch (err) {
+                  reject(err);
+                }
+              });
+            }).on('error', reject);
           });
-          console.log(chalk.green('\n✅ Successfully updated to v' + updateInfo.latestVersion + '!'));
-          console.log(chalk.gray('   Please restart your command to use the new version.\n'));
-          process.exit(0);
+
+          const tarball = meta && meta.dist && meta.dist.tarball;
+          if (!tarball) {
+            spinner.fail('Could not determine tarball URL for update');
+            console.log(chalk.yellow('   You can manually update with: ') + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
+            return;
+          }
+
+          spinner.text = 'Resolving tarball...';
+
+          // HEAD to get content-length
+          const totalBytes = await new Promise((resolve) => {
+            const req = https.request(tarball, { method: 'HEAD' }, (res) => {
+              const len = parseInt(res.headers['content-length'] || '0', 10);
+              resolve(Number.isFinite(len) ? len : 0);
+            });
+            req.on('error', () => resolve(0));
+            req.end();
+          });
+
+          const tmpFile = path.join(os.tmpdir(), `vcm-update-${Date.now()}.tgz`);
+
+          // Download tarball with progress
+          spinner.text = 'Downloading update...';
+          // Stop the spinner so we can write a single-line progress indicator without conflicts
+          try { spinner.stop(); } catch (e) {}
+          // Print initial progress line (clear line first)
+          process.stdout.write('\r\x1b[2KDownloading: 0% — 0.0 MB');
+          const progressStart = Date.now();
+          function formatEta(sec) {
+            if (!isFinite(sec) || sec === null) return '--:--';
+            const s = Math.max(0, Math.round(sec));
+            const m = Math.floor(s / 60);
+            const ss = s % 60;
+            return `${m}:${ss.toString().padStart(2, '0')}`;
+          }
+          await new Promise((resolve, reject) => {
+            https.get(tarball, (res) => {
+              const fileStream = fs.createWriteStream(tmpFile);
+              let downloaded = 0;
+
+              // Print an updating single-line progress indicator (percent + MB)
+              let lastPercent = -1;
+              let lastMbReported = -1;
+              res.on('data', (chunk) => {
+                downloaded += chunk.length;
+                const percent = totalBytes ? Math.round((downloaded / totalBytes) * 100) : null;
+                const mbDownloaded = +(downloaded / (1024 * 1024));
+                const mbTotal = totalBytes ? (totalBytes / (1024 * 1024)) : null;
+
+                // ETA and speed
+                const elapsedSec = Math.max(0.001, (Date.now() - progressStart) / 1000);
+                const speed = downloaded / elapsedSec; // bytes/sec
+                const remaining = totalBytes ? Math.max(0, totalBytes - downloaded) : null;
+                const etaSec = remaining && speed > 0 ? remaining / speed : null;
+
+                // Build simple ASCII progress bar
+                const width = 30;
+                const fill = percent !== null ? Math.round((percent / 100) * width) : Math.min(width, Math.max(0, Math.round((mbDownloaded / (mbTotal || 1)) * width)));
+                const bar = '█'.repeat(fill) + '-'.repeat(Math.max(0, width - fill));
+
+                const pctText = percent !== null ? `${percent}%` : '--%';
+                const mbText = mbTotal ? `${mbDownloaded.toFixed(1)} MB / ${mbTotal.toFixed(1)} MB` : `${mbDownloaded.toFixed(1)} MB`;
+                const etaText = etaSec ? formatEta(etaSec) : '--:--';
+
+                // Update only when percent changes or every 0.5 MB to reduce noise
+                const mbReport = Math.floor(mbDownloaded * 2) / 2;
+                if ((percent !== null && percent !== lastPercent) || (percent === null && mbReport !== lastMbReported) || Math.random() < 0.001) {
+                  lastPercent = percent;
+                  lastMbReported = mbReport;
+                  process.stdout.write(`\r\x1b[2K[${bar}] ${pctText} ${mbText} ETA: ${etaText}`);
+                }
+              });
+
+              res.on('end', () => fileStream.end());
+              res.on('error', (err) => reject(err));
+
+              fileStream.on('finish', () => resolve());
+              fileStream.on('error', (err) => reject(err));
+
+              res.pipe(fileStream);
+            }).on('error', reject);
+          });
+
+          // Ensure progress line ends and move to next line
+          process.stdout.write('\n');
+          spinner.start();
+          spinner.succeed('Downloaded update');
+
+          // Install the downloaded tarball
+          spinner.start('Installing update...');
+          try {
+            execSync(`npm install -g "${tmpFile}"`, { stdio: 'inherit', encoding: 'utf8' });
+            spinner.succeed('Installed update');
+            console.log(chalk.green('\n✅ Successfully updated to v' + updateInfo.latestVersion + '!'));
+            console.log(chalk.gray('   Please restart your command to use the new version.\n'));
+            // Cleanup
+            try { fs.unlinkSync(tmpFile); } catch (e) {}
+            process.exit(0);
+          } catch (err) {
+            spinner.fail('Installation failed');
+            console.log(chalk.red('\n❌ Update failed:'), err.message);
+            console.log(chalk.yellow('   You can manually update with: ') + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
+            try { fs.unlinkSync(tmpFile); } catch (e) {}
+          }
         } catch (error) {
           console.log(chalk.red('\n❌ Update failed:'), error.message);
           console.log(chalk.yellow('   You can manually update with: ') + chalk.bold.white('npm install -g vibecodingmachine-cli@latest\n'));
@@ -384,6 +532,18 @@ if (!process.argv.slice(2).length) {
       }
     }
 
+    // Check compliance after authentication
+    const { checkCompliance } = require('../src/utils/compliance-check');
+    const isCompliant = await checkCompliance();
+    
+    if (!isCompliant) {
+      console.log(chalk.red('\n✗ Compliance check failed. Exiting.\n'));
+      process.exit(1);
+    }
+
+    // Track CLI usage - interactive mode
+    await auth.trackCLIActivity('interactive_mode_started');
+
     const { startInteractive } = require('../src/utils/interactive');
     await startInteractive();
   })();
@@ -391,6 +551,47 @@ if (!process.argv.slice(2).length) {
   // Check for updates before parsing commands
   (async () => {
     await checkForUpdates();
+    
+    // Check authentication for all commands (except auth commands)
+    const command = process.argv[2] || 'unknown';
+    const authCommands = ['auth:login', 'auth:logout', 'auth:status'];
+    const skipAuthCheck = authCommands.includes(command);
+    
+    const auth = require('../src/utils/auth');
+    
+    if (!skipAuthCheck) {
+      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 compliance after authentication (skip for auth commands)
+    if (!skipAuthCheck) {
+      const { checkCompliance } = require('../src/utils/compliance-check');
+      const isCompliant = await checkCompliance();
+      
+      if (!isCompliant) {
+        console.log(chalk.red('\n✗ Compliance check failed. Exiting.\n'));
+        process.exit(1);
+      }
+      
+      // Track CLI usage - command execution
+      const args = process.argv.slice(3);
+      await auth.trackCLIActivity('command_executed', {
+        command,
+        args: args.filter(arg => !arg.includes('password') && !arg.includes('token'))
+      });
+    }
+    
     // Parse arguments only if commands were provided
     program.parse(process.argv);
   })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-cli",
-  "version": "2025.12.06-1702",
+  "version": "2025.12.22-2230",
   "description": "Command-line interface for Vibe Coding Machine - Autonomous development",
   "main": "src/index.js",
   "bin": {
@@ -25,7 +25,7 @@
   "author": "Vibe Coding Machine Team",
   "license": "MIT",
   "dependencies": {
-    "vibecodingmachine-core": "^2025.12.06-1702",
+    "vibecodingmachine-core": "^2025.12.22-2230",
     "@aws-sdk/client-dynamodb": "^3.600.0",
     "@aws-sdk/lib-dynamodb": "^3.600.0",
     "boxen": "^5.1.2",

package/reproduce_issue.js

@@ -0,0 +1,160 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const { getRepoPath } = require('./src/utils/config');
+const requirements = require('./src/commands/requirements');
+
+// Mock specific functions we need from interactive.js's logic
+// helping function to move requirement to recycled (deletion logic)
+async function moveRequirementToRecycled(reqPath, requirementTitle, fromSection) {
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('###')) {
+            const title = line.replace(/^###\s*/, '').trim();
+            // Logic from interactive.js
+            if (title && title.includes(requirementTitle)) {
+                requirementStartIndex = i;
+                for (let j = i + 1; j < lines.length; j++) {
+                    const nextLine = lines[j].trim();
+                    if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+                        requirementEndIndex = j;
+                        break;
+                    }
+                }
+                if (requirementEndIndex === -1) {
+                    requirementEndIndex = lines.length;
+                }
+                break;
+            }
+        }
+    }
+
+    if (requirementStartIndex === -1) {
+        console.log('⚠️  Could not find requirement to recycle');
+        return false;
+    }
+
+    console.log(`Found requirement at lines ${requirementStartIndex}-${requirementEndIndex}`);
+
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+
+    if (requirementStartIndex < lines.length) {
+        const nextLine = lines[requirementStartIndex]?.trim();
+        const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
+        if (nextLine && packageNames.includes(nextLine.toLowerCase()) &&
+            !nextLine.startsWith('###') && !nextLine.startsWith('PACKAGE:')) {
+            lines.splice(requirementStartIndex, 1);
+        }
+        while (requirementStartIndex < lines.length && lines[requirementStartIndex]?.trim() === '') {
+            lines.splice(requirementStartIndex, 1);
+        }
+    }
+
+    let recycledIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes('♻️ Recycled') || lines[i].includes('🗑️ Recycled')) {
+            recycledIndex = i;
+            break;
+        }
+    }
+
+    if (recycledIndex === -1) {
+        let lastSectionIndex = -1;
+        for (let i = lines.length - 1; i >= 0; i--) {
+            if (lines[i].startsWith('##') && !lines[i].startsWith('###')) {
+                lastSectionIndex = i;
+                break;
+            }
+        }
+        const insertIndex = lastSectionIndex > 0 ? lastSectionIndex : lines.length;
+        lines.splice(insertIndex, 0, '', '## ♻️ Recycled', '');
+        recycledIndex = insertIndex + 1;
+    }
+
+    let insertIndex = recycledIndex + 1;
+    while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+        insertIndex++;
+    }
+    lines.splice(insertIndex, 0, ...requirementBlock);
+
+    if (insertIndex + requirementBlock.length < lines.length && lines[insertIndex + requirementBlock.length].trim() !== '') {
+        lines.splice(insertIndex + requirementBlock.length, 0, '');
+    }
+
+    await fs.writeFile(reqPath, lines.join('\n'));
+    return true;
+}
+
+async function run() {
+    try {
+        const repoPath = '/Users/jesse/code/mediawink/vibecodingmachine'; // Hardcoded valid repo path
+        console.log('Repo path:', repoPath);
+
+        const reqPath = await getRequirementsPath(repoPath);
+        console.log('<<< PATH >>>', reqPath);
+
+        if (await fs.pathExists(reqPath)) {
+            const content = await fs.readFile(reqPath, 'utf8');
+            console.log('Current content length:', content.length);
+            console.log('Current content PRE-TEST:\n', content);
+        } else {
+            console.log('Requirements file does not exist');
+        }
+
+        console.log('\n--- Adding TESTREQ1 ---');
+        await requirements.add('TESTREQ1', 'all', 'Description 1');
+
+        console.log('\n--- Adding TESTREQ2 ---');
+        await requirements.add('TESTREQ2', 'all', 'Description 2');
+
+        let content = await fs.readFile(reqPath, 'utf8');
+        console.log('Content after adding:\n', content);
+
+        // Verify order
+        // We expect TESTREQ2 to be above TESTREQ1 if it inserts at the top of the section
+        const lines = content.split('\n');
+        let idx1 = -1, idx2 = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes('### TESTREQ1')) idx1 = i;
+            if (lines[i].includes('### TESTREQ2')) idx2 = i;
+        }
+        console.log(`TESTREQ1 line: ${idx1}, TESTREQ2 line: ${idx2}`);
+        if (idx2 < idx1 && idx2 > -1) {
+            console.log('SUCCESS: TESTREQ2 is above TESTREQ1 (Correct LIFO/Stack behavior for "Top of list")');
+        } else {
+            console.log('FAIL: Order is not correct for "Top of list" insertion');
+        }
+
+        console.log('\n--- Deleting TESTREQ1 ---');
+        const success = await moveRequirementToRecycled(reqPath, 'TESTREQ1', 'todo');
+        console.log('Delete success:', success);
+
+        content = await fs.readFile(reqPath, 'utf8');
+        console.log('Content after delete:\n', content);
+
+        if (content.includes('### TESTREQ1')) {
+            // It should be in recycled section
+            const recycledIndex = content.indexOf('## ♻️ Recycled');
+            const reqIndex = content.indexOf('### TESTREQ1');
+            if (reqIndex > recycledIndex) {
+                console.log('SUCCESS: TESTREQ1 moved to Recycled');
+            } else {
+                console.log('FAIL: TESTREQ1 is still in TODO or wrong place');
+            }
+        } else {
+            console.log('FAIL: TESTREQ1 disappeared completely (should be recycled)');
+        }
+
+    } catch (error) {
+        console.error('Error:', error);
+    }
+}
+
+run();

package/src/commands/auth.js

@@ -58,7 +58,6 @@ async function status() {
         }
 
         const profile = await auth.getUserProfile();
-        const token = await auth.getToken();
 
         // Get usage stats
         const canRun = await auth.canRunAutoMode();

package/src/commands/auto-direct.js

@@ -5,21 +5,29 @@
  */
 
 const chalk = require('chalk');
-const { DirectLLMManager } = require('vibecodingmachine-core');
-const { getRepoPath, getAutoConfig, setAutoConfig } = require('../utils/config');
+const { DirectLLMManager, AppleScriptManager } = require('vibecodingmachine-core');
+const { getRepoPath, getAutoConfig, setAutoConfig, getStages, DEFAULT_STAGES } = require('../utils/config');
 const { getRequirementsPath, readRequirements } = require('vibecodingmachine-core');
 const fs = require('fs-extra');
 const path = require('path');
 const { spawn } = require('child_process');
 const chokidar = require('chokidar');
+const stringWidth = require('string-width');
+const { getProviderPreferences, getProviderDefinition } = require('../utils/provider-registry');
+const { createKeyboardHandler } = require('../utils/keyboard-handler');
+const logger = require('../utils/logger');
+const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
+const { checkAntigravityRateLimit, handleAntigravityRateLimit } = require('../utils/antigravity-js-handler');
+
 // Status management will use in-process tracking instead of external file
 const CLI_ENTRY_POINT = path.join(__dirname, '../../bin/vibecodingmachine.js');
-const { getProviderPreferences, getProviderDefinition } = require('../utils/provider-registry');
 
 // CRITICAL: Shared ProviderManager instance to track rate limits across all function calls
-const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
 const sharedProviderManager = new ProviderManager();
 
+// Configured stages (will be loaded in handleAutoStart)
+let configuredStages = DEFAULT_STAGES;
+
 /**
  * Get timestamp for logging
  */
@@ -46,7 +54,6 @@ function stripAnsi(str) {
  * Uses string-width library for accurate Unicode width calculation
  */
 function getVisualWidth(str) {
-  const stringWidth = require('string-width');
   return stringWidth(str);
 }
 
@@ -111,7 +118,8 @@ async function updateRequirementsStatus(repoPath, status) {
         break;
       }
 
-      if (inStatusSection && line.trim().match(/^(PREPARE|CREATE|ACT|CLEAN UP|VERIFY|DONE)$/)) {
+      // Check against configured stages
+      if (inStatusSection && configuredStages.includes(line.trim())) {
         statusLineIndex = i;
         break;
       }
@@ -160,14 +168,9 @@ let storedStatus = '';
  * Now uses persistent header that stays at top while output scrolls
  */
 function printStatusCard(currentTitle, currentStatus) {
-  const stages = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
-  const stageMap = {
-    'PREPARE': 0,
-    'ACT': 1,
-    'CLEAN UP': 2,
-    'VERIFY': 3,
-    'DONE': 4
-  };
+  const stages = configuredStages;
+  const stageMap = {};
+  stages.forEach((s, i) => stageMap[s] = i);
 
   const currentIndex = stageMap[currentStatus] || 0;
 
@@ -249,7 +252,7 @@ async function getCurrentRequirement(repoPath) {
         // Skip empty titles
         if (title && title.length > 0) {
           // Read package and description (optional)
-          let package = null;
+          let pkg = null;
           let description = '';
           let j = i + 1;
 
@@ -262,7 +265,7 @@ async function getCurrentRequirement(repoPath) {
             }
             // Check for PACKAGE line
             if (nextLine.startsWith('PACKAGE:')) {
-              package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+              pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
             } else if (nextLine && !nextLine.startsWith('PACKAGE:')) {
               // Description line (not empty, not package)
               if (description) {
@@ -277,7 +280,7 @@ async function getCurrentRequirement(repoPath) {
           return {
             text: title,
             fullLine: lines[i],
-            package: package,
+            package: pkg,
             description: description
           };
         }
@@ -1334,11 +1337,14 @@ async function runIdeProviderIteration(providerConfig, repoPath) {
         resolve({ success: true, output: combinedOutput });
       } else {
         const message = `${providerConfig.displayName} exited with code ${code}`;
+        const antigravityRateLimit = checkAntigravityRateLimit(combinedOutput);
+
         resolve({
           success: false,
           error: combinedOutput ? `${message}\n${combinedOutput}` : message,
           output: combinedOutput,
-          rateLimited: isRateLimitMessage(combinedOutput)
+          rateLimited: isRateLimitMessage(combinedOutput) || antigravityRateLimit.isRateLimited,
+          antigravityRateLimited: antigravityRateLimit.isRateLimited
         });
       }
     });
@@ -1435,26 +1441,15 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
         // Check 3: Quota limit detection for Antigravity (after 2 minutes of waiting)
         const elapsed = Date.now() - startTime;
         if (ideType === 'antigravity' && !quotaHandled && elapsed >= 120000) {
-          console.log(chalk.yellow('\n⚠️  No progress detected after 2 minutes - checking for quota limit...\n'));
-          try {
-            const { AppleScriptManager } = require('vibecodingmachine-core');
-            const manager = new AppleScriptManager();
-            const result = await manager.handleAntigravityQuotaLimit();
-
-            if (result.success) {
-              console.log(chalk.green(`✓ Switched to model: ${result.model || 'alternative'}`));
-              console.log(chalk.cyan('   Resuming work with new model...\n'));
-              quotaHandled = true;
-              // Reset start time to give new model time to work
-              startTime = Date.now();
-            } else {
-              console.log(chalk.yellow(`⚠️  Could not switch models: ${result.error}\n`));
-              quotaHandled = true; // Don't try again
-            }
-          } catch (error) {
-            console.error(chalk.red(`Error handling quota limit: ${error.message}\n`));
-            quotaHandled = true; // Don't try again
-          }
+          console.log(chalk.yellow('\n⚠️  Antigravity quota limit detected after 2 minutes\n'));
+          console.log(chalk.cyan('   Switching to next available IDE agent...\n'));
+          watcher.close();
+          resolve({
+            success: false,
+            reason: 'antigravity-quota',
+            antigravityRateLimited: true  // This triggers switching to next provider
+          });
+          return;
         }
 
         // Check 4: Timeout
@@ -1511,6 +1506,10 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
   const ideResult = await runIdeProviderIteration(providerConfig, repoPath);
 
   if (!ideResult.success) {
+    if (ideResult.antigravityRateLimited) {
+      await handleAntigravityRateLimit();
+      return { success: false, error: 'Antigravity rate limit detected, retrying with next provider.', shouldRetry: true };
+    }
     // CRITICAL: Mark provider as unavailable for ANY error so acquireProviderConfig() will skip it
     providerManager.markRateLimited(providerConfig.provider, providerConfig.model, ideResult.output || ideResult.error || 'IDE provider failed');
     return { success: false, error: ideResult.error || 'IDE provider failed' };
@@ -1522,6 +1521,12 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
   const completionResult = await waitForIdeCompletion(repoPath, requirement.text, providerConfig.ide || providerConfig.provider);
 
   if (!completionResult.success) {
+    if (completionResult.antigravityRateLimited) {
+      console.log(chalk.yellow('⚠️  Antigravity quota exhausted, switching to next IDE\n'));
+      providerManager.markRateLimited(providerConfig.provider, providerConfig.model, 'Quota limit reached');
+      return { success: false, error: 'Antigravity quota limit', shouldRetry: true };
+    }
+
     const errorMsg = completionResult.reason === 'timeout'
       ? 'IDE agent timed out'
       : 'IDE agent failed to complete';
@@ -1891,6 +1896,9 @@ async function handleAutoStart(options) {
     console.log();
 
     // Get repo path
+    // Load configured stages
+    configuredStages = await getStages();
+
     const repoPath = await getRepoPath();
     if (!repoPath) {
       console.log(chalk.red('✗ No repository configured'));
@@ -1900,8 +1908,15 @@ async function handleAutoStart(options) {
 
     console.log(chalk.white('Repository:'), chalk.cyan(repoPath));
 
-    // Get provider configuration  
-    let providerConfig = await acquireProviderConfig();
+    // Get effective agent using centralized selector
+    const { getEffectiveAgent } = require('../utils/agent-selector');
+    const PROVIDER_DEFINITIONS = require('./auto').PROVIDER_DEFINITIONS;
+    const PROVIDER_DEFINITION_MAP = new Map(PROVIDER_DEFINITIONS.map(def => [def.id, def]));
+
+    const { effectiveAgent } = await getEffectiveAgent(options, PROVIDER_DEFINITIONS, PROVIDER_DEFINITION_MAP);
+
+    // Get provider configuration for the selected agent
+    let providerConfig = await acquireProviderConfig(effectiveAgent);
     if (!providerConfig) {
       return;
     }