vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-1621

package/src/commands/auto-direct.js

@@ -201,6 +201,25 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Safely log to console with EPIPE protection
+ * @param {...any} args - Arguments to pass to console.log
+ */
+function safeLog(...args) {
+  try {
+    // Check if stdout is still writable before attempting to log
+    if (process.stdout && !process.stdout.destroyed) {
+      console.log(...args);
+    }
+  } catch (logError) {
+    // Ignore EPIPE and other stdout errors - process may be terminating
+    if (logError.code !== 'EPIPE') {
+      // Re-throw non-EPIPE errors
+      throw logError;
+    }
+  }
+}
+
 /**
  * Print purple status card with progress indicators
  */
@@ -277,14 +296,20 @@ let statusBoxInitialized = false;
 let statusBoxLines = 5; // Number of lines the status box takes
 let storedStatusTitle = '';
 let storedStatus = '';
+let currentStatusMode = 'active'; // Track current mode: 'active', 'waiting', 'stopped'
 
 /**
- * Print purple status card with progress indicators
- * Makes current stage very prominent with bright white text
- * Uses full terminal width
- * Now uses persistent header that stays at top while output scrolls
+ * Print status card with color-coded states based on mode
+ * - Green: actively working on tasks
+ * - Yellow: waiting for rate limit to end
+ * - Red: stopped or error state
+ * @param {string} currentTitle - Current requirement title
+ * @param {string} currentStatus - Current workflow status
+ * @param {string} mode - Status mode: 'active', 'waiting', 'stopped'
  */
-function printStatusCard(currentTitle, currentStatus) {
+function printStatusCard(currentTitle, currentStatus, mode = 'active') {
+  currentStatusMode = mode; // Update global mode tracking
+  
   const stages = configuredStages;
   const stageMap = {};
   stages.forEach((s, i) => stageMap[s] = i);
@@ -298,8 +323,11 @@ function printStatusCard(currentTitle, currentStatus) {
       // Completed stages - grey with checkmark
       return chalk.grey(`✅ ${translatedStage}`);
     } else if (idx === currentIndex) {
-      // CURRENT stage - BRIGHT WHITE with hammer
-      return chalk.bold.white(`🔨 ${translatedStage}`);
+      // CURRENT stage - BRIGHT WHITE with hammer (or different icon for waiting/stopped)
+      let icon = '🔨';
+      if (mode === 'waiting') icon = '⏳';
+      else if (mode === 'stopped') icon = '⏹️';
+      return chalk.bold.white(`${icon} ${translatedStage}`);
     } else {
       // Future stages - grey with hourglass
       return chalk.grey(`⏳ ${translatedStage}`);
@@ -318,13 +346,23 @@ function printStatusCard(currentTitle, currentStatus) {
   const titleShort = currentTitle?.substring(0, maxTitleWidth) + (currentTitle?.length > maxTitleWidth ? '...' : '');
   const titleLine = chalk.cyan(workingOnLabel) + chalk.white(titleShort);
 
-  // Build the status box content
+  // Choose color based on mode
+  let boxColor;
+  if (mode === 'waiting') {
+    boxColor = chalk.yellow; // Yellow for waiting mode
+  } else if (mode === 'stopped') {
+    boxColor = chalk.red; // Red for stopped mode
+  } else {
+    boxColor = chalk.green; // Green for active mode (changed from magenta)
+  }
+
+  // Build the status box content with dynamic color
   const statusBoxContent =
-    chalk.magenta('╭' + '─'.repeat(boxWidth) + '╮') + '\n' +
-    chalk.magenta('│') + padToVisualWidth(' ' + workflowLine, boxWidth) + chalk.magenta('│') + '\n' +
-    chalk.magenta('│') + ' '.repeat(boxWidth) + chalk.magenta('│') + '\n' +
-    chalk.magenta('│') + padToVisualWidth(' ' + titleLine, boxWidth) + chalk.magenta('│') + '\n' +
-    chalk.magenta('╰' + '─'.repeat(boxWidth) + '╯');
+    boxColor('╭' + '─'.repeat(boxWidth) + '╮') + '\n' +
+    boxColor('│') + padToVisualWidth(' ' + workflowLine, boxWidth) + boxColor('│') + '\n' +
+    boxColor('│') + ' '.repeat(boxWidth) + boxColor('│') + '\n' +
+    boxColor('│') + padToVisualWidth(' ' + titleLine, boxWidth) + boxColor('│') + '\n' +
+    boxColor('╰' + '─'.repeat(boxWidth) + '╯');
 
   // Store current state (using stored* names to avoid shadowing with parameters)
   storedStatusTitle = currentTitle;
@@ -332,6 +370,23 @@ function printStatusCard(currentTitle, currentStatus) {
 
   // Just print the card normally - no complex cursor manipulation
   console.log(statusBoxContent);
+
+  // Notify Electron UI about mode changes
+  try {
+    if (process.versions && process.versions.electron) {
+      const { ipcRenderer } = require('electron');
+      if (ipcRenderer) {
+        ipcRenderer.send('requirements-progress', {
+          stage: currentStatus,
+          requirement: currentTitle,
+          mode: mode,
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+  } catch (e) {
+    // Ignore if not in Electron context
+  }
 }
 
 /**
@@ -479,113 +534,117 @@ async function moveRequirementToVerify(repoPath, requirementText) {
     }
 
     const content = await fs.readFile(reqPath, 'utf8');
-    const lines = content.split('\n');
-    // Find the requirement by its title (in ### header format)
-    // Only look in TODO section
-    const normalizedRequirement = requirementText.trim();
-    const snippet = normalizedRequirement.substring(0, 80);
-    let requirementStartIndex = -1;
-    let requirementEndIndex = -1;
-    let inTodoSection = false;
+// Find the requirement by its title (in ### header format)
+// Only look in TODO section
+const normalizedRequirement = requirementText.trim();
+const snippet = normalizedRequirement.substring(0, 80);
+let requirementStartIndex = -1;
+let requirementEndIndex = -1;
+let inTodoSection = false;
+
+for (let i = 0; i < lines.length; i++) {
+  const line = lines[i];
+  const trimmed = line.trim();
+
+  // Check if we're entering TODO section
+  if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
+    inTodoSection = true;
+    continue;
+  }
 
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
+  // Check if we're leaving TODO section
+  if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
+    inTodoSection = false;
+  }
 
-      // Check if we're entering TODO section
-      if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
-        inTodoSection = true;
-        continue;
-      }
+  // Only look for requirements in TODO section
+  if (inTodoSection && trimmed.startsWith('###')) {
+    const title = trimmed.replace(/^###\s*/, '').trim();
+    if (title) {
+      // Try multiple matching strategies
+      const normalizedTitle = title.trim();
 
-      // Check if we're leaving TODO section
-      if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
-        inTodoSection = false;
+      // Exact match
+      if (normalizedTitle === normalizedRequirement) {
+        requirementStartIndex = i;
+      }
+      // Check if either contains the other (for partial matches)
+      else if (normalizedTitle.includes(normalizedRequirement) || normalizedRequirement.includes(normalizedTitle)) {
+        requirementStartIndex = i;
+      }
+      // Check snippet matches
+      else if (normalizedTitle.includes(snippet) || snippet.includes(normalizedTitle.substring(0, 80))) {
+        requirementStartIndex = i;
       }
 
-      // Only look for requirements in TODO section
-      if (inTodoSection && trimmed.startsWith('###')) {
-        const title = trimmed.replace(/^###\s*/, '').trim();
-        if (title) {
-          // Try multiple matching strategies
-          const normalizedTitle = title.trim();
-
-          // Exact match
-          if (normalizedTitle === normalizedRequirement) {
-            requirementStartIndex = i;
-          }
-          // Check if either contains the other (for partial matches)
-          else if (normalizedTitle.includes(normalizedRequirement) || normalizedRequirement.includes(normalizedTitle)) {
-            requirementStartIndex = i;
-          }
-          // Check snippet matches
-          else if (normalizedTitle.includes(snippet) || snippet.includes(normalizedTitle.substring(0, 80))) {
-            requirementStartIndex = i;
-          }
-
-          if (requirementStartIndex !== -1) {
-            // Find the end of this requirement (next ### or ## header)
-            for (let j = i + 1; j < lines.length; j++) {
-              const nextLine = lines[j].trim();
-              if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
-                requirementEndIndex = j;
-                break;
-              }
-            }
-            if (requirementEndIndex === -1) {
-              requirementEndIndex = lines.length;
-            }
+      if (requirementStartIndex !== -1) {
+        // Find the end of this requirement (next ### or ## header)
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+            requirementEndIndex = j;
             break;
           }
         }
+        if (requirementEndIndex === -1) {
+          requirementEndIndex = lines.length;
+        }
+        break;
       }
     }
+  }
+}
 
-    if (requirementStartIndex === -1) {
-      console.log(chalk.yellow(`⚠️  ${t('auto.direct.requirement.not.found.todo', { requirement: requirementText.substring(0, 60) + '...' })}`));
-      return false;
-    }
+if (requirementStartIndex === -1) {
+  console.log(chalk.yellow(`⚠️  ${t('auto.direct.requirement.not.found.todo', { requirement: requirementText.substring(0, 60) + '...' })}`));
+  return false;
+}
 
-    // Extract the entire requirement block
-    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+// Extract the entire requirement block
+const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
 
-    // Remove the requirement from its current location
-    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
+// Remove the requirement from its current location
+lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
 
-    // Check if there are any more requirements in TODO section after removal
-    let hasMoreTodoRequirements = false;
-    inTodoSection = false; // Reset the existing variable
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
+// Check if there are any more requirements in TODO section after removal
+let hasMoreTodoRequirements = false;
+inTodoSection = false; // Reset the existing variable
+for (let i = 0; i < lines.length; i++) {
+  const line = lines[i].trim();
 
-      // Check if we're entering TODO section
-      if (line.startsWith('##') && line.includes('Requirements not yet completed')) {
-        inTodoSection = true;
-        continue;
-      }
+  // Check if we're entering TODO section
+  if (line.startsWith('##') && line.includes('Requirements not yet completed')) {
+    inTodoSection = true;
+    continue;
+  }
 
-      // Check if we're leaving TODO section
-      if (inTodoSection && line.startsWith('##') && !line.startsWith('###') && !line.includes('Requirements not yet completed')) {
-        break;
-      }
+  // Check if we're leaving TODO section
+  if (inTodoSection && line.startsWith('##') && !line.startsWith('###') && !line.includes('Requirements not yet completed')) {
+    break;
+  }
 
-      // Check if we found a requirement in TODO section
-      if (inTodoSection && line.startsWith('###')) {
-        const title = line.replace(/^###\s*/, '').trim();
-        if (title) {
-          hasMoreTodoRequirements = true;
-          break;
-        }
-      }
+  // Check if we found a requirement in TODO section
+  if (inTodoSection && line.startsWith('###')) {
+    const title = line.replace(/^###\s*/, '').trim();
+    if (title) {
+      hasMoreTodoRequirements = true;
+      break;
     }
+  }
+}
+
+// If no more TODO requirements, log message
+if (!hasMoreTodoRequirements) {
+  console.log(chalk.green(`🎉 ${t('auto.direct.requirement.no.more.todo')}`));
+  // Add a new requirement to the TODO section
+  const newRequirement = '### R14: TESTREQ1 with promo code FRIENDSANDFAMILYROCK';
+  lines.push(newRequirement);
+}
+
+// Run /speckit.tasks to regenerate tasks.md for spec "008-enable-disable-requirements" in checkbox format (- [ ] task)
+const childProcess = require('child_process');
+childProcess.execSync('/speckit.tasks --spec 008-enable-disable-requirements --format checkbox');
 
-    // If no more TODO requirements, log message
-    if (!hasMoreTodoRequirements) {
-      console.log(chalk.green(`🎉 ${t('auto.direct.requirement.no.more.todo')}`));
-      // Add a new requirement to the TODO section
-      const newRequirement = '### R14: TESTREQ1 with promo code FRIENDSANDFAMILYROCK';
-      lines.push(newRequirement);
-    }
 
     // Find or create TO VERIFY BY HUMAN section with conflict resolution
     // IMPORTANT: Do NOT match VERIFIED sections - only match TO VERIFY sections
@@ -884,6 +943,8 @@ async function getAllAvailableProviders() {
   const claudeCodeAvailable = await llm.isClaudeCodeAvailable();
   const clineAvailable = await llm.isClineAvailable();
   const openCodeAvailable = await llm.isOpenCodeAvailable();
+  const vscodeCopilotCLIResult = await llm.isVSCodeCopilotCLIAvailable();
+  const vscodeCopilotCLIAvailable = vscodeCopilotCLIResult.available;
   const ollamaAvailable = await llm.isOllamaAvailable();
   let ollamaModels = [];
   if (ollamaAvailable) {
@@ -988,6 +1049,45 @@ async function getAllAvailableProviders() {
         });
         break;
       }
+      case 'vscode-copilot-cli': {
+        console.log(`[AUTO-DIRECT] Checking VS Code Copilot CLI availability...`);
+        console.log(`[AUTO-DIRECT] vscodeCopilotCLIAvailable: ${vscodeCopilotCLIAvailable}`);
+        console.log(`[AUTO-DIRECT] vscodeCopilotCLIResult:`, vscodeCopilotCLIResult);
+        
+        if (!vscodeCopilotCLIAvailable) {
+          let reason = 'VS Code Copilot CLI not installed — run: brew install --cask copilot-cli';
+          
+          if (vscodeCopilotCLIResult.needsAuth) {
+            if (vscodeCopilotCLIResult.authMethod === 'manual') {
+              reason = 'VS Code Copilot CLI requires authentication — run: copilot login OR set COPILOT_GITHUB_TOKEN environment variable';
+            } else {
+              reason = `VS Code Copilot CLI authentication failed — try: copilot login OR set COPILOT_GITHUB_TOKEN environment variable`;
+            }
+          }
+          
+          console.log(`[AUTO-DIRECT] Skipping VS Code Copilot CLI: ${reason}`);
+          skipped.push({ 
+            provider: providerId, 
+            displayName: def.name, 
+            enabled, 
+            reason
+          });
+          continue;
+        }
+        
+        let authMethod = 'authenticated';
+        if (vscodeCopilotCLIResult.authMethod && vscodeCopilotCLIResult.authMethod !== 'existing') {
+          authMethod = `auto-authenticated via ${vscodeCopilotCLIResult.authMethod}`;
+        }
+        
+        console.log(`[AUTO-DIRECT] ✓ VS Code Copilot CLI available (${authMethod})`);
+        
+        providers.push({
+          ...base,
+          model: def.defaultModel
+        });
+        break;
+      }
       case 'cursor':
       case 'windsurf':
       case 'vscode':
@@ -1108,6 +1208,48 @@ async function getProviderConfig(excludeProvider = null) {
     return { status: 'no_enabled', disabledProviders, skipped };
   }
 
+  // Check if all enabled providers are rate limited (regardless of availability)
+  const allEnabledRateLimited = enabledProviders.length > 0 &&
+    enabledProviders.every(p => providerManager.isRateLimited(p.provider, p.model));
+
+  if (allEnabledRateLimited) {
+    // Calculate wait times for all enabled providers
+    const waits = enabledProviders
+      .map(p => providerManager.getTimeUntilReset(p.provider, p.model))
+      .filter(Boolean);
+    let nextResetMs = waits.length ? Math.min(...waits) : null;
+
+    // Find which provider will be available next
+    let nextProvider = null;
+    let nextResetTime = null;
+    
+    for (const provider of enabledProviders) {
+      const resetMs = providerManager.getTimeUntilReset(provider.provider, provider.model);
+      if (resetMs && (!nextResetMs || resetMs < nextResetMs)) {
+        nextResetMs = resetMs;
+        nextProvider = provider;
+        const rateLimitInfo = providerManager.getRateLimitInfo(provider.provider, provider.model);
+        nextResetTime = rateLimitInfo ? rateLimitInfo.resetTime : null;
+      }
+    }
+    
+    return {
+      status: 'all_rate_limited',
+      enabledProviders,
+      disabledProviders,
+      nextResetMs,
+      nextResetTime,
+      providers: enabledProviders.map(p => {
+        const rateLimitInfo = providerManager.getRateLimitInfo(p.provider, p.model);
+        return {
+          ...p,
+          rateLimitResetTime: rateLimitInfo ? rateLimitInfo.resetTime : null
+        };
+      })
+    };
+  }
+
+  // Filter out rate-limited providers to get available ones
   const availableProviders = enabledProviders.filter(p => {
     // Exclude specified provider and rate-limited providers
     if (excludeProvider && p.provider === excludeProvider) {
@@ -1207,24 +1349,6 @@ async function getProviderConfig(excludeProvider = null) {
     return { status: 'ok', provider: selection, disabledProviders };
   }
 
-  const waits = availableProviders
-    .map(p => providerManager.getTimeUntilReset(p.provider, p.model))
-    .filter(Boolean);
-  const nextResetMs = waits.length ? Math.min(...waits) : null;
-
-  // Only return all_rate_limited if there are available providers and ALL of them are rate limited
-  const allAvailableRateLimited = availableProviders.length > 0 &&
-    availableProviders.every(p => providerManager.isRateLimited(p.provider, p.model));
-
-  if (allAvailableRateLimited) {
-    return {
-      status: 'all_rate_limited',
-      enabledProviders,
-      disabledProviders,
-      nextResetMs
-    };
-  }
-
   // If we reach here, no providers are available (filtered out by excludeProvider or other conditions)
   return {
     status: 'no_available',
@@ -1234,6 +1358,132 @@ async function getProviderConfig(excludeProvider = null) {
   };
 }
 
+/**
+ * Enhanced rate limit waiting with immediate agent switching
+ * @param {Object} selection - Provider selection object with rate limit info
+ * @param {string} currentTitle - Current requirement title
+ * @param {string} currentStatus - Current workflow status
+ * @returns {Promise<Object>} - Next provider or wait decision
+ */
+async function handleRateLimitWithAgentSwitching(selection, currentTitle, currentStatus) {
+  console.log(chalk.yellow(`\n⚠️  ${t('auto.direct.provider.all.rate.limited')}`));
+  
+  // Notify GUI about waiting mode if available
+  try {
+    // Try to send status to GUI via IPC if running in Electron context
+    if (process.versions && process.versions.electron) {
+      const { ipcRenderer } = require('electron');
+      if (ipcRenderer) {
+        ipcRenderer.send('requirements-progress', {
+          stage: currentStatus,
+          requirement: currentTitle,
+          mode: 'waiting',
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+  } catch (e) {
+    // Ignore if not in Electron context
+  }
+  
+  // Check if we have any providers that will be available soon
+  if (selection.nextResetTime && selection.nextResetMs) {
+    const waitMinutes = Math.max(1, Math.ceil(selection.nextResetMs / 60000));
+    
+    console.log(chalk.yellow(`🔄 All enabled providers are currently rate limited.`));
+    
+    if (selection.nextProvider && selection.nextResetTime) {
+      const resetTime = new Date(selection.nextResetTime).toLocaleTimeString();
+      const resetDate = new Date(selection.nextResetTime).toLocaleDateString();
+      console.log(chalk.yellow(`   Waiting for the next available agent (${selection.nextProvider.displayName}) to reset rate limit at ${resetTime} MST on ${resetDate}`));
+    } else {
+      console.log(chalk.yellow(`   Waiting for rate limits to reset...`));
+    }
+    
+    // Update status card to waiting mode
+    printStatusCard(currentTitle, currentStatus, 'waiting');
+    
+    // Note: CLI cannot directly send IPC events to Electron app
+    // The Electron app's emitAutoModeProgress function will handle rate limit detection
+    
+    // Check for any provider becoming available within the next minute
+    const nearFutureProviders = selection.providers?.filter(p => {
+      if (!p.rateLimitResetTime) return false;
+      const resetMs = new Date(p.rateLimitResetTime).getTime() - Date.now();
+      return resetMs > 0 && resetMs <= 60000; // Within 1 minute
+    });
+    
+    if (nearFutureProviders && nearFutureProviders.length > 0) {
+      const nextProvider = nearFutureProviders[0];
+      const nextResetMs = new Date(nextProvider.rateLimitResetTime).getTime() - Date.now();
+      const nextWaitMinutes = Math.max(1, Math.ceil(nextResetMs / 60000));
+      const resetTime = new Date(nextProvider.rateLimitResetTime).toLocaleTimeString();
+      const resetDate = new Date(nextProvider.rateLimitResetTime).toLocaleDateString();
+      
+      console.log(chalk.cyan(`⏱️  ${nextProvider.displayName} will be available at ${resetTime} on ${resetDate}`));
+      console.log(chalk.gray(`   Waiting for ${nextProvider.displayName} to become available...\n`));
+      
+      // Wait for the next available provider (max 1 minute chunks)
+      const waitChunks = Math.ceil(Math.min(nextResetMs, 60000) / 10000);
+      for (let i = 0; i < waitChunks; i++) {
+        await sleep(10000);
+        // Re-check provider status in case rate limits reset early
+        const freshSelection = await getProviderConfig();
+        if (freshSelection.status === 'ok') {
+          console.log(chalk.green(`✅ ${nextProvider.displayName} is now available!\n`));
+          
+          // Notify GUI about returning to active mode
+          try {
+            if (process.versions && process.versions.electron) {
+              const { ipcRenderer } = require('electron');
+              if (ipcRenderer) {
+                ipcRenderer.send('requirements-progress', {
+                  stage: currentStatus,
+                  requirement: currentTitle,
+                  mode: 'active',
+                  timestamp: new Date().toISOString()
+                });
+              }
+            }
+          } catch (e) {
+            // Ignore if not in Electron context
+          }
+          
+          return freshSelection;
+        }
+      }
+    } else {
+      // No providers available soon, wait for the next reset
+      console.log(chalk.gray(`   DEBUG: selection = ${JSON.stringify(selection, null, 2)}\n`));
+      if (selection.nextProvider && selection.nextResetTime) {
+        const resetTime = new Date(selection.nextResetTime).toLocaleTimeString();
+        const resetDate = new Date(selection.nextResetTime).toLocaleDateString();
+        console.log(chalk.gray(`   Waiting for ${selection.nextProvider.displayName} to reset at ${resetTime} MST on ${resetDate}...\n`));
+      } else {
+        console.log(chalk.gray(`   Waiting for rate limits to reset...\n`));
+      }
+      await sleep(Math.min(selection.nextResetMs, 60000));
+    }
+  } else {
+    // No reset time info, wait default 1 minute
+    const nextAvailableProvider = selection.providers?.find(p => p.rateLimitResetTime && p.rateLimitResetTime > Date.now());
+    if (nextAvailableProvider) {
+      const resetTime = new Date(nextAvailableProvider.rateLimitResetTime).toLocaleTimeString();
+      const resetDate = new Date(nextAvailableProvider.rateLimitResetTime).toLocaleDateString();
+      console.log(chalk.gray(`   Waiting for ${nextAvailableProvider.displayName} to reset at ${resetTime} MST on ${resetDate}...\n`));
+      
+      // Note: CLI cannot directly send IPC events to Electron app
+      // The Electron app's emitAutoModeProgress function will handle rate limit detection
+    } else {
+      console.log(chalk.gray(`   Waiting for rate limits to reset...\n`));
+    }
+    printStatusCard(currentTitle, currentStatus, 'waiting');
+    await sleep(60000);
+  }
+  
+  return null; // Signal to retry provider selection
+}
+
 async function acquireProviderConfig(excludeProvider = null, excludeModel = null, forcedProvider = null) {
   // If a specific provider is forced, bypass normal selection
   if (forcedProvider) {
@@ -1305,15 +1555,12 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
     }
 
     if (selection.status === 'all_rate_limited') {
-      console.log(chalk.yellow(`\n⚠️  ${t('auto.direct.provider.all.rate.limited')}`));
-      if (selection.disabledProviders && selection.disabledProviders.length > 0) {
-        console.log(chalk.gray(`  ${t('auto.direct.provider.enable.tip')}`));
+      // Use enhanced rate limit handling with agent switching
+      const result = await handleRateLimitWithAgentSwitching(selection, storedStatusTitle || 'Unknown requirement', storedStatus || 'PREPARE');
+      if (result) {
+        return result.provider; // Found an available provider
       }
-      const waitMs = selection.nextResetMs || 60000;
-      const waitMinutes = Math.max(1, Math.ceil(waitMs / 60000));
-      console.log(chalk.gray(`  Waiting for rate limits to reset (~${waitMinutes}m)...\n`));
-      await sleep(Math.min(waitMs, 60000));
-      continue;
+      continue; // Retry provider selection
     }
 
     if (selection.status === 'no_available') {
@@ -1334,10 +1581,27 @@ async function acquireProviderConfig(excludeProvider = null, excludeModel = null
 function parseSearchReplaceBlocks(response) {
   const changes = [];
 
-  // Match FILE: path SEARCH: ``` old ``` REPLACE: ``` new ``` format
-  const blockRegex = /FILE:\s*(.+?)\nSEARCH:\s*```(?:[a-z]*)\n([\s\S]+?)```\s*REPLACE:\s*```(?:[a-z]*)\n([\s\S]+?)```/g;
+  // Match CREATE: path CONTENT: ``` content ``` format for new files
+  const createRegex = /CREATE:\s*(.+?)\nCONTENT:\s*```(?:[a-z]*)\n([\s\S]+?)```/g;
 
   let match;
+  while ((match = createRegex.exec(response)) !== null) {
+    let filePath = match[1].trim();
+    const content = match[2];
+
+    // Clean up file path - remove "---" prefix if present
+    filePath = filePath.replace(/^---\s*/, '').trim();
+
+    changes.push({
+      type: 'create',
+      file: filePath,
+      content: content
+    });
+  }
+
+  // Match FILE: path SEARCH: ``` old ``` REPLACE: ``` new ``` format for modifications
+  const blockRegex = /FILE:\s*(.+?)\nSEARCH:\s*```(?:[a-z]*)\n([\s\S]+?)```\s*REPLACE:\s*```(?:[a-z]*)\n([\s\S]+?)```/g;
+
   while ((match = blockRegex.exec(response)) !== null) {
     let filePath = match[1].trim();
     const searchText = match[2];
@@ -1347,6 +1611,7 @@ function parseSearchReplaceBlocks(response) {
     filePath = filePath.replace(/^---\s*/, '').trim();
 
     changes.push({
+      type: 'modify',
       file: filePath,
       search: searchText,
       replace: replaceText
@@ -1420,8 +1685,38 @@ function extractPattern(code) {
  */
 async function applyFileChange(change, repoPath) {
   try {
-    const fullPath = path.join(repoPath, change.file);
+    // Normalize file path to handle both absolute and relative paths
+    let fullPath;
+    if (path.isAbsolute(change.file)) {
+      // If absolute path, check if it starts with repoPath
+      if (change.file.startsWith(repoPath)) {
+        fullPath = change.file;
+      } else {
+        // Absolute path outside repo - use as-is
+        fullPath = change.file;
+      }
+    } else {
+      // Relative path - join with repoPath
+      fullPath = path.join(repoPath, change.file);
+    }
+
+    // Handle file creation
+    if (change.type === 'create') {
+      // Check if file already exists
+      if (await fs.pathExists(fullPath)) {
+        return { success: false, error: `File already exists: ${change.file}` };
+      }
 
+      // Ensure parent directory exists
+      await fs.ensureDir(path.dirname(fullPath));
+
+      // Write new file
+      await fs.writeFile(fullPath, change.content, 'utf8');
+      console.log(chalk.green(`  ✓ Created new file`));
+      return { success: true, method: 'create' };
+    }
+
+    // Handle file modification (existing behavior)
     // Check if file exists
     if (!await fs.pathExists(fullPath)) {
       return { success: false, error: `File not found: ${change.file}` };
@@ -1527,6 +1822,20 @@ async function findRelevantFiles(requirement, repoPath) {
 
   try {
     const reqLower = requirement.toLowerCase();
+
+    // Check if this is a spec task that needs to mark completion in tasks.md
+    const tasksMarkingMatch = requirement.match(/mark the task done in (.+\/tasks\.md)/);
+    if (tasksMarkingMatch) {
+      const tasksFilePath = tasksMarkingMatch[1];
+      // Convert absolute path to relative path if needed
+      let relativePath = tasksFilePath;
+      if (path.isAbsolute(tasksFilePath)) {
+        relativePath = path.relative(repoPath, tasksFilePath);
+      }
+      relevantFiles.push(relativePath);
+      return relevantFiles; // For spec tasks, only need the tasks.md file
+    }
+
     const isRemovalRequirement = /remove|delete|eliminate/i.test(requirement) &&
       (/menu|item|option|setting|button|ui|element/i.test(requirement));
 
@@ -2253,12 +2562,12 @@ async function waitForIdeCompletion(repoPath, requirementText, ideType = '', tim
 
 async function runIdeFallbackIteration(requirement, providerConfig, repoPath, providerManager, llm, startTime) {
   // Update console and requirements file with PREPARE status
-  printStatusCard(requirement.text, 'PREPARE');
+  printStatusCard(requirement.text, 'PREPARE', 'active');
   await updateRequirementsStatus(repoPath, 'PREPARE');
   console.log(chalk.gray(`${t('auto.direct.ide.skipping.context')}\n`));
 
   // Update console and requirements file with ACT status
-  printStatusCard(requirement.text, 'ACT');
+  printStatusCard(requirement.text, 'ACT', 'active');
   await updateRequirementsStatus(repoPath, 'ACT');
   const ideResult = await runIdeProviderIteration(providerConfig, repoPath);
 
@@ -2402,10 +2711,10 @@ async function runIdeFallbackIteration(requirement, providerConfig, repoPath, pr
     return { success: false, error: errorMsg };
   }
 
-  printStatusCard(requirement.text, 'VERIFY');
+  printStatusCard(requirement.text, 'VERIFY', 'active');
   console.log(chalk.green(`✅ ${t('auto.direct.provider.completed')}\n`));
 
-  printStatusCard(requirement.text, 'DONE');
+  printStatusCard(requirement.text, 'DONE', 'active');
   const duration = Date.now() - startTime;
   providerManager.recordPerformance(providerConfig.provider, providerConfig.model, duration);
 
@@ -2453,13 +2762,13 @@ async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
   // This lets the agent work through multiple tasks autonomously rather than one at a time.
   let instruction;
   if (spec.hasTasks) {
-    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Implement all remaining tasks in ${spec.path}/tasks.md. Current progress: ${doneBefore}/${totalBefore} tasks (${pctBefore}%) complete. Check off each task (change "[ ]" to "[x]") as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. Whenever you stop and wait for user response, say "STATUS:WAITING" followed by "PLEASE RESPOND". When ALL tasks are checked off, report "COMPLETION: 100%", then say "STATUS:WAITING" and "PLEASE RESPOND".`;
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Implement all remaining tasks in ${spec.path}/tasks.md. Current progress: ${doneBefore}/${totalBefore} tasks (${pctBefore}%) complete. Check off each task (change "[ ]" to "[x]") as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are checked off, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM.`;
   } else if (spec.hasPlan) {
-    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Read ${spec.path}/plan.md, generate tasks.md for this spec, then implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. Whenever you stop and wait for user response, say "STATUS:WAITING" followed by "PLEASE RESPOND". When ALL tasks are done, report "COMPLETION: 100%", then say "STATUS:WAITING" and "PLEASE RESPOND".`;
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Read ${spec.path}/plan.md, generate tasks.md for this spec, then implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are done, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM.`;
   } else {
     const planPromptNote = spec.hasPlanPrompt
       ? `Use plan prompt from ${spec.path}/plan-prompt.md to guide planning. ` : '';
-    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Read ${spec.path}/spec.md. ${planPromptNote}Run speckit workflow: (1) read spec.md, (2) generate plan.md, (3) generate tasks.md, (4) implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. Whenever you stop and wait for user response, say "STATUS:WAITING" followed by "PLEASE RESPOND". When ALL tasks are done, report "COMPLETION: 100%", then say "STATUS:WAITING" and "PLEASE RESPOND".`;
+    instruction = `Read AGENTS.md and INSTRUCTIONS.md in the repo root for workflow guidelines. Read ${spec.path}/spec.md. ${planPromptNote}Run speckit workflow: (1) read spec.md, (2) generate plan.md, (3) generate tasks.md, (4) implement all tasks. Check off each task as you complete it. Report progress as "X/Y tasks (Z%) complete" after each task. When ALL tasks are done, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM.`;
   }
 
   // Send the spec instruction to the IDE via AppleScript.
@@ -2514,7 +2823,7 @@ async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
   const TIMEOUT_MS = PROGRESS_TIMEOUT_MS;      // Use configurable progress timeout
   const PROGRESS_COOLDOWN_MS = 2 * 60 * 1000; // 2 minutes cooldown after progress
 
-  const startTime = Date.now();
+  let startTime = Date.now();
   let lastContinueSent = Date.now();
   let lastProgressTime = Date.now(); // Track when we last saw progress
   let lastProgressDetectionTime = 0; // Track when we last detected progress to implement cooldown
@@ -2540,41 +2849,70 @@ async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
     process.once('SIGINT', onSigint);
 
     interval = setInterval(async () => {
-      const elapsed = Date.now() - startTime;
+      try {
+        const elapsed = Date.now() - startTime;
 
-      if (elapsed >= TIMEOUT_MS) {
-        console.log(chalk.yellow(`⏰ Overall timeout reached - but continuing to monitor existing Windsurf instance\n`));
-        // Don't create new instance - just reset timer and continue monitoring
-        startTime = Date.now(); // Reset the overall timer
-        return;
-      }
+        if (elapsed >= TIMEOUT_MS) {
+          console.log(chalk.yellow(`⏰ Overall timeout reached - but continuing to monitor existing Windsurf instance\n`));
+          // Don't create new instance - just reset timer and continue monitoring
+          startTime = Date.now(); // Reset the overall timer
+          return;
+        }
 
-      // Detect progress AND check if IDE agent is done working
-      const { done: doneNow, total: totalNow } = countSpecCheckboxes(spec.path);
-      const currentTime = Date.now();
+        // Detect progress AND check if IDE agent is done working
+        const { done: doneNow, total: totalNow } = countSpecCheckboxes(spec.path);
+        const currentTime = Date.now();
 
-      if (doneNow > doneBefore) {
-        const pctNow = totalNow > 0 ? Math.round((doneNow / totalNow) * 100) : 0;
-        console.log(chalk.green(`✓ Progress detected: ${doneNow}/${totalNow} tasks (${pctNow}%) complete\n`));
+        // Check for completion signals from IDE agent via status file
+        const statusFilePath = spec.path.replace(/\/$/, '') + '/.vcm-status.json';
+        let agentSignaledCompletionViaFile = false;
+        try {
+          if (await fs.pathExists(statusFilePath)) {
+            const statusContent = await fs.readFile(statusFilePath, 'utf-8');
+            const statusData = JSON.parse(statusContent);
+            
+            // Check for completion signals
+            if (statusData.completion === 100 && statusData.status === 'WAITING') {
+              console.log(chalk.green(`🎯 Agent signaled completion via status file: COMPLETION: 100%, STATUS:WAITING\n`));
+              agentSignaledCompletionViaFile = true;
+              
+              // Clean up status file
+              await fs.remove(statusFilePath);
+            }
+          }
+        } catch (error) {
+          // Ignore status file errors - file might not exist or be invalid JSON
+        }
 
-        // Update progress tracking
-        lastProgressTime = currentTime;
-        lastProgressDetectionTime = currentTime;
+        if (doneNow > doneBefore) {
+          const pctNow = totalNow > 0 ? Math.round((doneNow / totalNow) * 100) : 0;
+          safeLog(chalk.green(`✓ Progress detected: ${doneNow}/${totalNow} tasks (${pctNow}%) complete\n`));
 
-        // Check if all tasks are complete - if so, wait for agent completion signal
-        if (doneNow >= totalNow && totalNow > 0) {
-          console.log(chalk.green(`🎯 All tasks checked off! Waiting for agent completion signal...\n`));
-          // Don't immediately return - wait for STATUS:WAITING signal or timeout
-          agentSignaledCompletion = true; // Flag that we're waiting for completion signal
-        }
+          // Update progress tracking
+          lastProgressTime = currentTime;
+          lastProgressDetectionTime = currentTime;
+
+          // Check if all tasks are complete - if so, wait for agent completion signal
+          if (doneNow >= totalNow && totalNow > 0) {
+            safeLog(chalk.green(`🎯 All tasks checked off! Waiting for agent completion signal...\n`));
+            // Don't immediately return - wait for STATUS:WAITING signal or timeout
+            agentSignaledCompletion = true; // Flag that we're waiting for completion signal
+          }
 
         // If progress detected but not all tasks done, continue waiting for agent to finish current work
         return; // Continue polling, don't send new task yet
       }
 
+      // Check for immediate completion via status file signal
+      if (agentSignaledCompletionViaFile) {
+        safeLog(chalk.green(`✅ Agent completed all tasks via status signal! Finishing iteration.\n`));
+        cleanup({ success: true, changes: [] });
+        return;
+      }
+
       // If agent signaled completion (all tasks done) and we've waited a reasonable time, consider it complete
       if (agentSignaledCompletion && (currentTime - lastProgressDetectionTime) >= 30 * 1000) {
-        console.log(chalk.green(`✅ Agent completed all tasks! Finishing iteration.\n`));
+        safeLog(chalk.green(`✅ Agent completed all tasks! Finishing iteration.\n`));
         cleanup({ success: true, changes: [] });
         return;
       }
@@ -2582,18 +2920,22 @@ async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
       // Implement cooldown period after progress detection to prevent rapid spawning
       if (lastProgressDetectionTime > 0 && (currentTime - lastProgressDetectionTime) < PROGRESS_COOLDOWN_MS) {
         const cooldownRemaining = Math.round((PROGRESS_COOLDOWN_MS - (currentTime - lastProgressDetectionTime)) / 1000);
-        console.log(chalk.gray(`⏱️  In cooldown period (${cooldownRemaining}s remaining) - allowing agent time to complete work\n`));
+        safeLog(chalk.gray(`⏱️  In cooldown period (${cooldownRemaining}s remaining) - allowing agent time to complete work\n`));
         return;
       }
 
       // Check for no progress timeout (configurable, default 15 minutes)
       const timeSinceLastProgress = Date.now() - lastProgressTime;
       if (timeSinceLastProgress >= PROGRESS_TIMEOUT_MS) {
-        console.log(chalk.yellow(`⚠️  No progress detected for ${Math.round(timeSinceLastProgress / 60000)} minutes on ${providerConfig.displayName}\n`));
+        safeLog(chalk.yellow(`⚠️  No progress detected for ${Math.round(timeSinceLastProgress / 60000)} minutes on ${providerConfig.displayName}\n`));
 
         // Check if we've exceeded max IDE attempts
         if (totalAttempts >= MAX_IDE_ATTEMPTS) {
-          console.log(chalk.red(`✗ Maximum IDE attempts (${MAX_IDE_ATTEMPTS}) reached. Stopping auto mode.\n`));
+          safeLog(chalk.red(`✗ Maximum IDE attempts (${MAX_IDE_ATTEMPTS}) reached. Stopping auto mode.\n`));
+          // Update status card to stopped mode
+          if (storedStatusTitle && storedStatus) {
+            printStatusCard(storedStatusTitle, storedStatus, 'stopped');
+          }
           // Stop auto mode - call async function properly
           stopAutoMode().then(() => {
             cleanup({ success: false, error: 'max_ide_attempts_exceeded', shouldRetry: false });
@@ -2622,7 +2964,7 @@ async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
         let continueMsg;
         if (agentSignaledCompletion) {
           // All tasks done, waiting for completion signal
-          continueMsg = `All tasks appear to be completed (${doneNow}/${totalNow} tasks). If you are truly finished, please report "COMPLETION: 100%" followed by "STATUS:WAITING" and "PLEASE RESPOND". If you need more time, continue working and report progress. (${mins}min elapsed) PLEASE RESPOND`;
+          continueMsg = `All tasks appear to be completed (${doneNow}/${totalNow} tasks). If you are truly finished, create a status file at ${spec.path}/.vcm-status.json with content {"completion": 100, "status": "WAITING"} to signal completion to VCM. If you need more time, continue working and report progress. (${mins}min elapsed) PLEASE RESPOND`;
         } else {
           // Normal continuation prompt
           continueMsg = `Continue implementing spec "${spec.directory}". Current progress: ${doneNow}/${totalNow} tasks (${pctNow}%) complete. Keep working until ALL tasks in tasks.md are checked off. Next task: "${taskText}". (${mins}min elapsed) PLEASE RESPOND`;
@@ -2632,9 +2974,30 @@ async function runSpecIdeIteration(spec, taskText, taskLine, providerConfig) {
           const appleScriptManager = new AppleScriptManager();
           // Use plain sendText for continuations (no need to open new thread)
           await appleScriptManager.sendText(continueMsg, ideType);
-          console.log(chalk.gray(`📤 Sent continuation prompt to ${providerConfig.displayName} (${mins}min elapsed)\n`));
+          try {
+            // Check if stdout is still writable before attempting to log
+            if (process.stdout && !process.stdout.destroyed) {
+              const message = `📤 Sent continuation prompt to ${providerConfig.displayName} (${mins}min elapsed)\n`;
+              console.log(chalk.gray(message));
+            }
+          } catch (logError) {
+            // Ignore EPIPE and other stdout errors - process may be terminating
+            if (logError.code !== 'EPIPE') {
+              // Re-throw non-EPIPE errors
+              throw logError;
+            }
+          }
         } catch (_) { /* ignore continuation errors */ }
       }
+      } catch (error) {
+        // Handle any errors in the setInterval callback, especially EPIPE
+        if (error.code === 'EPIPE') {
+          // Silently ignore EPIPE errors - process is terminating
+          return;
+        }
+        // Log other errors but don't crash
+        console.error('Error in polling interval:', error.message);
+      }
     }, POLL_INTERVAL_MS);
   });
 }
@@ -2654,7 +3017,7 @@ async function runIteration(requirement, providerConfig, repoPath) {
   // ═══════════════════════════════════════════════════════════
   // PREPARE PHASE - SEARCH AND READ ACTUAL FILES
   // ═══════════════════════════════════════════════════════════
-  printStatusCard(requirement.text, 'PREPARE');
+  printStatusCard(requirement.text, 'PREPARE', 'active');
 
   console.log(chalk.bold.white('📋 REQUIREMENT:'));
   console.log(chalk.cyan(`   ${requirement.text}\n`));
@@ -2681,19 +3044,24 @@ async function runIteration(requirement, providerConfig, repoPath) {
   // ═══════════════════════════════════════════════════════════
   // ACT PHASE - GET STRUCTURED CHANGES FROM LLM
   // ═══════════════════════════════════════════════════════════
-  printStatusCard(requirement.text, 'ACT');
+  printStatusCard(requirement.text, 'ACT', 'active');
 
   console.log(chalk.cyan(` ${getLogTimestamp()} - 🤖 Asking LLM for implementation...\n`));
   console.log(chalk.gray('─'.repeat(80)));
   console.log(chalk.yellow('💭 LLM Response (streaming):'));
   console.log(chalk.gray('─'.repeat(80)));
 
-  // Build context with actual file snippets
+  // Build context with actual file snippets (use relative paths)
   let contextSection = '';
   if (fileSnippets.length > 0) {
     contextSection = '\n\nCURRENT CODE CONTEXT:\n';
     fileSnippets.forEach(({ file, snippet, startLine }) => {
-      contextSection += `\n--- ${file} (around line ${startLine}) ---\n${snippet}\n`;
+      // Convert to relative path if absolute
+      let displayPath = file;
+      if (path.isAbsolute(file)) {
+        displayPath = path.relative(repoPath, file);
+      }
+      contextSection += `\n--- ${displayPath} (around line ${startLine}) ---\n${snippet}\n`;
     });
   }
 
@@ -2755,7 +3123,8 @@ ${isRemovalRequirement ? '5. **REMOVE ALL CODE** related to the item - do NOT co
 
 OUTPUT FORMAT:
 
-FILE: <exact path from the "---" line>
+For modifying existing files:
+FILE: <exact path from the "---" line - must be relative to repo root>
 SEARCH: \`\`\`javascript
 <COPY 10+ lines EXACTLY - preserve indentation, spacing, comments>
 \`\`\`
@@ -2763,22 +3132,31 @@ REPLACE: \`\`\`javascript
 <SAME lines but with necessary modifications>
 \`\`\`
 
+For creating new files:
+CREATE: <relative path to new file>
+CONTENT: \`\`\`javascript
+<full content of new file>
+\`\`\`
+
 CRITICAL RULES - READ CAREFULLY:
-1. SEARCH block must be COPIED CHARACTER-BY-CHARACTER from CURRENT CODE CONTEXT above
-2. Use the EXACT code as it appears NOW - do NOT use old/outdated code from memory
-3. Include ALL property values EXACTLY as shown (e.g., if context shows 'type: "info"', use 'type: "info"', NOT 'type: "setting"')
-4. Include indentation EXACTLY as shown (count the spaces!)
-5. Include AT LEAST 20-30 LINES of context:
+1. If the file does NOT exist, use CREATE: format to create it
+2. If the file DOES exist and you need to modify it, use FILE:/SEARCH:/REPLACE: format
+3. For FILE: blocks, SEARCH block must be COPIED CHARACTER-BY-CHARACTER from CURRENT CODE CONTEXT above
+4. Use the EXACT code as it appears NOW - do NOT use old/outdated code from memory
+5. Include ALL property values EXACTLY as shown (e.g., if context shows 'type: "info"', use 'type: "info"', NOT 'type: "setting"')
+6. Include indentation EXACTLY as shown (count the spaces!)
+7. For modifications, include AT LEAST 20-30 LINES of context:
    - Start 10-15 lines BEFORE the code you need to change
    - End 10-15 lines AFTER the code you need to change
    - MORE context is BETTER than less - include extra lines if unsure
-6. Do NOT paraphrase or rewrite - COPY EXACTLY from CURRENT CODE CONTEXT
-7. FILE path must match exactly what's after "---" in CURRENT CODE CONTEXT (DO NOT include the "---" itself)
-8. Output ONLY the FILE/SEARCH/REPLACE block
-9. NO explanations, NO markdown outside the blocks, NO additional text
-10. If you cannot find the exact code to modify, output: ERROR: CANNOT LOCATE CODE IN CONTEXT
-11. IMPORTANT: Include ALL intermediate code between the before/after context - do NOT skip lines
-12. DOUBLE-CHECK: Compare your SEARCH block line-by-line with CURRENT CODE CONTEXT to ensure they match
+8. Do NOT paraphrase or rewrite - COPY EXACTLY from CURRENT CODE CONTEXT
+9. FILE path must match exactly what's after "---" in CURRENT CODE CONTEXT (DO NOT include the "---" itself)
+10. All paths must be RELATIVE to repo root (e.g., "specs/005-beta-pricing/tasks.md" NOT "/Users/.../tasks.md")
+11. Output ONLY the FILE/SEARCH/REPLACE or CREATE/CONTENT blocks
+12. NO explanations, NO markdown outside the blocks, NO additional text
+13. If you cannot find the exact code to modify, output: ERROR: CANNOT LOCATE CODE IN CONTEXT
+14. IMPORTANT: Include ALL intermediate code between the before/after context - do NOT skip lines
+15. DOUBLE-CHECK: Compare your SEARCH block line-by-line with CURRENT CODE CONTEXT to ensure they match
 
 EXAMPLE (notice EXACT copying of indentation and spacing):
 
@@ -2802,7 +3180,24 @@ if (counts.todoCount === 0) {
 }
 \`\`\`
 
-Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
+CREATE EXAMPLE (for new files):
+
+CREATE: packages/web/src/utils/paypal-config.js
+CONTENT: \`\`\`javascript
+/**
+ * PayPal Configuration Utility
+ */
+
+export const getPayPalClientId = () => {
+  return import.meta.env.VITE_PAYPAL_CLIENT_ID;
+};
+
+export const getPayPalEnvironment = () => {
+  return import.meta.env.VITE_PAYPAL_ENVIRONMENT || 'sandbox';
+};
+\`\`\`
+
+Now implement the requirement. Remember: For modifications, COPY THE SEARCH BLOCK EXACTLY! For new files, use CREATE: format.`;
 
   let fullResponse = '';
   let chunkCount = 0;
@@ -2902,7 +3297,7 @@ Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
   // ═══════════════════════════════════════════════════════════
   // CLEAN UP PHASE - APPLY CHANGES TO ACTUAL FILES
   // ═══════════════════════════════════════════════════════════
-  printStatusCard(requirement.text, 'CLEAN UP');
+  printStatusCard(requirement.text, 'CLEAN UP', 'active');
 
   console.log(chalk.cyan('🧹 Parsing and applying changes...\n'));
 
@@ -2972,7 +3367,7 @@ Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
   // ═══════════════════════════════════════════════════════════
   // VERIFY PHASE - CONFIRM CHANGES WERE APPLIED
   // ═══════════════════════════════════════════════════════════
-  printStatusCard(requirement.text, 'VERIFY');
+  printStatusCard(requirement.text, 'VERIFY', 'active');
 
   console.log(chalk.cyan('✓ Verifying changes...\n'));
 
@@ -2982,7 +3377,14 @@ Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
       const fullPath = path.join(repoPath, change.file);
       if (await fs.pathExists(fullPath)) {
         const content = await fs.readFile(fullPath, 'utf8');
-        const hasChange = content.includes(change.replace.trim());
+
+        // Handle both create and modify types
+        let hasChange = false;
+        if (change.type === 'create') {
+          hasChange = change.content && content.includes(change.content.trim());
+        } else {
+          hasChange = change.replace && content.includes(change.replace.trim());
+        }
 
         if (hasChange) {
           console.log(chalk.green(`  ✓ ${change.file}`));
@@ -2999,7 +3401,7 @@ Now implement the requirement. Remember: COPY THE SEARCH BLOCK EXACTLY!`;
   // ═══════════════════════════════════════════════════════════
   // DONE PHASE
   // ═══════════════════════════════════════════════════════════
-  printStatusCard(requirement.text, 'DONE');
+  printStatusCard(requirement.text, 'DONE', 'active');
 
   const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
 
@@ -3213,6 +3615,10 @@ async function handleAutoStart(options) {
         // Update status to stopped
         updateAutoModeStatus(repoPath, { running: false });
         console.log(chalk.gray('Auto mode stopped'));
+        // Update status card to stopped mode
+        if (storedStatusTitle && storedStatus) {
+          printStatusCard(storedStatusTitle, storedStatus, 'stopped');
+        }
       }
     });