vibecodingmachine-cli 2025.12.1-534 → 2025.12.6-1702

package/src/commands/auto-direct.js

@@ -42,49 +42,16 @@ function stripAnsi(str) {
 }
 
 /**
- * Count visual width of emojis in a string (emojis take 2 terminal columns)
- * Uses string iterator to properly handle multi-code-point emojis
- */
-function countEmojiWidth(str) {
-  // Remove ANSI codes first
-  const cleaned = stripAnsi(str);
-
-  let emojiCount = 0;
-  // Use spread operator to properly split multi-code-point characters
-  for (const char of cleaned) {
-    const code = char.codePointAt(0);
-    // Check if it's an emoji (takes 2 columns in terminal)
-    if (
-      (code >= 0x1F300 && code <= 0x1F9FF) || // Misc Symbols and Pictographs
-      (code >= 0x2600 && code <= 0x26FF) ||   // Misc Symbols
-      (code >= 0x2700 && code <= 0x27BF) ||   // Dingbats
-      (code >= 0x1F000 && code <= 0x1F02F) || // Mahjong Tiles
-      (code >= 0x1F0A0 && code <= 0x1F0FF) || // Playing Cards
-      (code >= 0x1F100 && code <= 0x1F64F) || // Enclosed Characters
-      (code >= 0x1F680 && code <= 0x1F6FF) || // Transport and Map
-      (code >= 0x1F910 && code <= 0x1F96B) || // Supplemental Symbols
-      (code >= 0x1F980 && code <= 0x1F9E0)    // Supplemental Symbols
-    ) {
-      emojiCount++;
-    }
-  }
-  return emojiCount;
-}
-
-/**
- * Get visual width of a string accounting for ANSI codes and emojis
+ * Get visual width of a string accounting for ANSI codes, emojis, and wide characters
+ * Uses string-width library for accurate Unicode width calculation
  */
 function getVisualWidth(str) {
-  const stripped = stripAnsi(str);
-  const emojiCount = countEmojiWidth(str);
-  // Count actual characters (using spread to handle multi-code-point correctly)
-  const charCount = [...stripped].length;
-  // Each emoji takes 2 visual columns, regular chars take 1
-  return charCount + emojiCount;
+  const stringWidth = require('string-width');
+  return stringWidth(str);
 }
 
 /**
- * Pad string to visual width accounting for emojis and ANSI codes
+ * Pad string to visual width accounting for emojis, ANSI codes, and wide characters
  */
 function padToVisualWidth(str, targetWidth) {
   const visualWidth = getVisualWidth(str);
@@ -180,10 +147,17 @@ async function updateRequirementsStatus(repoPath, status) {
   }
 }
 
+// Persistent status box state
+let statusBoxInitialized = false;
+let statusBoxLines = 5; // Number of lines the status box takes
+let storedStatusTitle = '';
+let storedStatus = '';
+
 /**
  * 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
  */
 function printStatusCard(currentTitle, currentStatus) {
   const stages = ['PREPARE', 'ACT', 'CLEAN UP', 'VERIFY', 'DONE'];
@@ -222,11 +196,20 @@ function printStatusCard(currentTitle, currentStatus) {
   const titleShort = currentTitle?.substring(0, maxTitleWidth) + (currentTitle?.length > maxTitleWidth ? '...' : '');
   const titleLine = chalk.cyan(`🎯 Working on: `) + chalk.white(titleShort);
 
-  console.log(chalk.magenta('\n╭' + '─'.repeat(boxWidth) + '╮'));
-  console.log(chalk.magenta('│') + padToVisualWidth(' ' + workflowLine, boxWidth) + chalk.magenta('│'));
-  console.log(chalk.magenta('│') + ' '.repeat(boxWidth) + chalk.magenta('│'));
-  console.log(chalk.magenta('│') + padToVisualWidth(' ' + titleLine, boxWidth) + chalk.magenta('│'));
-  console.log(chalk.magenta('╰' + '─'.repeat(boxWidth) + '╯\n'));
+  // Build the status box content
+  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) + '╯');
+
+  // Store current state (using stored* names to avoid shadowing with parameters)
+  storedStatusTitle = currentTitle;
+  storedStatus = currentStatus;
+
+  // Just print the card normally - no complex cursor manipulation
+  console.log(statusBoxContent);
 }
 
 /**
@@ -308,6 +291,53 @@ async function getCurrentRequirement(repoPath) {
   }
 }
 
+/**
+ * Count total TODO requirements
+ */
+async function countTodoRequirements(repoPath) {
+  try {
+    const reqPath = await getRequirementsPath(repoPath);
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return 0;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+    let inTodoSection = false;
+    let count = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // Check if we're in the TODO section
+      if (line.includes('## ⏳ Requirements not yet completed') ||
+        line.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
+
+      // If we hit another section header, stop looking
+      if (inTodoSection && line.startsWith('##') && !line.startsWith('###')) {
+        break;
+      }
+
+      // If we're in TODO section and find a requirement header (###)
+      if (inTodoSection && line.startsWith('###')) {
+        const title = line.replace(/^###\s*/, '').trim();
+        // Only count non-empty titles
+        if (title && title.length > 0) {
+          count++;
+        }
+      }
+    }
+
+    return count;
+  } catch (err) {
+    console.error('Error counting requirements:', err.message);
+    return 0;
+  }
+}
+
 /**
  * Move requirement from TODO to TO VERIFY BY HUMAN
  */
@@ -320,37 +350,69 @@ 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)
-    const snippet = requirementText.substring(0, 80);
+    // 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].trim();
-      // Check if this is the requirement header
-      if (line.startsWith('###')) {
-        const title = line.replace(/^###\s*/, '').trim();
-        if (title && title.includes(snippet)) {
-          requirementStartIndex = i;
-          // 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;
-            }
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check if we're entering TODO section
+      if (trimmed.startsWith('##') && trimmed.includes('Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
+
+      // Check if we're leaving TODO section
+      if (inTodoSection && trimmed.startsWith('##') && !trimmed.startsWith('###') && !trimmed.includes('Requirements not yet completed')) {
+        inTodoSection = false;
+      }
+
+      // Only look for requirements in TODO section
+      if (inTodoSection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+        if (title) {
+          // Try multiple matching strategies
+          const normalizedTitle = title.trim();
+
+          // Exact match
+          if (normalizedTitle === normalizedRequirement) {
+            requirementStartIndex = i;
           }
-          if (requirementEndIndex === -1) {
-            requirementEndIndex = lines.length;
+          // Check if either contains the other (for partial matches)
+          else if (normalizedTitle.includes(normalizedRequirement) || normalizedRequirement.includes(normalizedTitle)) {
+            requirementStartIndex = i;
+          }
+          // Check snippet matches
+          else if (normalizedTitle.includes(snippet) || snippet.includes(normalizedTitle.substring(0, 80))) {
+            requirementStartIndex = i;
+          }
+
+          if (requirementStartIndex !== -1) {
+            // Find the end of this requirement (next ### or ## header)
+            for (let j = i + 1; j < lines.length; j++) {
+              const nextLine = lines[j].trim();
+              if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+                requirementEndIndex = j;
+                break;
+              }
+            }
+            if (requirementEndIndex === -1) {
+              requirementEndIndex = lines.length;
+            }
+            break;
           }
-          break;
         }
       }
     }
 
     if (requirementStartIndex === -1) {
-      console.log(chalk.yellow('⚠️  Could not find requirement in requirements file'));
+      console.log(chalk.yellow(`⚠️  Could not find requirement "${requirementText.substring(0, 60)}..." in TODO section`));
       return false;
     }
 
@@ -360,6 +422,43 @@ async function moveRequirementToVerify(repoPath, requirementText) {
     // 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 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 found a requirement in TODO section
+      if (inTodoSection && line.startsWith('###')) {
+        hasMoreTodoRequirements = true;
+        break;
+      }
+    }
+
+    // If no more TODO requirements, log message
+    if (!hasMoreTodoRequirements) {
+      console.log(chalk.green('🎉 No more requirements in TODO section'));
+    }
+
+
+
+    // Add AWS Kiro AI IDE GUI and CLI support
+    const kiroAiIdeGuiSupport = '### AWS Kiro AI IDE GUI Support\n\nThis requirement has been moved to the TO VERIFY BY HUMAN section for further review.';
+    const kiroAiIdeCliSupport = '### AWS Kiro AI IDE CLI Support\n\nThis requirement has been moved to the TO VERIFY BY HUMAN section for further review using the CLI.';
+    lines.push(kiroAiIdeGuiSupport);
+    lines.push(kiroAiIdeCliSupport);
+
     // Check if the requirement is in the Recycled section
     const recycledIndex = lines.findIndex(line => line.trim() === '## 📦 RECYCLED');
     if (recycledIndex !== -1) {
@@ -370,40 +469,155 @@ async function moveRequirementToVerify(repoPath, requirementText) {
       }
     }
 
-    // Find or create VERIFIED section
-    const headingVariants = [
-      '## 📝 VERIFIED',
-      '## VERIFIED',
-      '## ✅ VERIFIED',
-      '## ✅ VERIFIED BY HUMAN'
+    // Find or create TO VERIFY BY HUMAN section
+    // IMPORTANT: Do NOT match VERIFIED sections - only match TO VERIFY sections
+    const verifySectionVariants = [
+      '## 🔍 TO VERIFY BY HUMAN',
+      '## 🔍 TO VERIFY',
+      '## TO VERIFY',
+      '## ✅ TO VERIFY',
+      '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG'
     ];
 
-    let verifyIndex = lines.findIndex(line => headingVariants.includes(line.trim()));
+    let verifyIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check each variant more carefully
+      for (const variant of verifySectionVariants) {
+        const variantTrimmed = variant.trim();
+        // Exact match or line starts with variant
+        if (trimmed === variantTrimmed || trimmed.startsWith(variantTrimmed)) {
+          // Double-check: make sure it's NOT a VERIFIED section (without TO VERIFY)
+          if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) &&
+            (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot'))) {
+            verifyIndex = i;
+            break;
+          }
+        }
+      }
+      if (verifyIndex !== -1) break;
+    }
+
     if (verifyIndex === -1) {
+      // Create TO VERIFY section - place it BEFORE VERIFIED section if one exists, otherwise before CHANGELOG
+      const verifiedIndex = lines.findIndex(line => {
+        const trimmed = line.trim();
+        return trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED') ||
+          (trimmed.startsWith('##') && trimmed.includes('VERIFIED') && !trimmed.includes('TO VERIFY'));
+      });
+      const changelogIndex = lines.findIndex(line => line.includes('## CHANGELOG'));
       const manualFeedbackIndex = lines.findIndex(line => line.trim().startsWith('## ❓'));
-      const headingLine = '## 📝 VERIFIED';
-      const insertionIndex = manualFeedbackIndex === -1 ? lines.length : manualFeedbackIndex;
+
+      // Prefer: before VERIFIED > before CHANGELOG > before manual feedback > at end
+      let insertionIndex = lines.length;
+      if (verifiedIndex > 0) {
+        insertionIndex = verifiedIndex;
+      } else if (changelogIndex > 0) {
+        insertionIndex = changelogIndex;
+      } else if (manualFeedbackIndex > 0) {
+        insertionIndex = manualFeedbackIndex;
+      }
+
       const block = [];
       if (insertionIndex > 0 && lines[insertionIndex - 1].trim() !== '') {
         block.push('');
       }
-      block.push(headingLine, '');
+      block.push('## 🔍 TO VERIFY BY HUMAN', '');
       lines.splice(insertionIndex, 0, ...block);
-      verifyIndex = lines.findIndex(line => line.trim() === headingLine);
+      verifyIndex = lines.findIndex(line => {
+        const trimmed = line.trim();
+        return trimmed === '## 🔍 TO VERIFY BY HUMAN' || trimmed.startsWith('## 🔍 TO VERIFY BY HUMAN');
+      });
+
+      // Safety check: verifyIndex should be valid
+      if (verifyIndex === -1) {
+        console.error('Failed to create TO VERIFY BY HUMAN section');
+        return false;
+      }
+    }
+
+
+    // Safety check: verify we're not inserting into a VERIFIED section
+    const verifyLine = lines[verifyIndex] || '';
+    if (verifyLine.includes('## 📝 VERIFIED') || (verifyLine.trim().startsWith('##') && verifyLine.includes('VERIFIED') && !verifyLine.includes('TO VERIFY'))) {
+      console.error('ERROR: Attempted to insert into VERIFIED section instead of TO VERIFY');
+      return false;
     }
 
-    // Insert the requirement block at the top of the VERIFIED section
-    lines.splice(verifyIndex + 1, 0, ...requirementBlock);
-    // Add blank line after if needed
-    if (verifyIndex + 1 + requirementBlock.length < lines.length && lines[verifyIndex + 1 + requirementBlock.length].trim() !== '') {
-      lines.splice(verifyIndex + 1 + requirementBlock.length, 0, '');
+    // Remove any existing duplicate of this requirement in TO VERIFY section
+    // Find the next section header after TO VERIFY
+    let nextSectionIndex = lines.length;
+    for (let i = verifyIndex + 1; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+        nextSectionIndex = i;
+        break;
+      }
     }
 
+    // Search for duplicate requirement in TO VERIFY section
+    const requirementTitle = requirementBlock[0].trim().replace(/^###\s*/, '').trim();
+    for (let i = verifyIndex + 1; i < nextSectionIndex; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      if (trimmed.startsWith('###')) {
+        const existingTitle = trimmed.replace(/^###\s*/, '').trim();
+
+        // Check if this is a duplicate (exact match or contains/contained by)
+        if (existingTitle === requirementTitle ||
+          existingTitle.includes(requirementTitle) ||
+          requirementTitle.includes(existingTitle)) {
+
+          // Find the end of this existing requirement
+          let existingEndIndex = nextSectionIndex;
+          for (let j = i + 1; j < nextSectionIndex; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine.startsWith('###') || nextLine.startsWith('##')) {
+              existingEndIndex = j;
+              break;
+            }
+          }
+
+          // Remove the duplicate
+          lines.splice(i, existingEndIndex - i);
+
+          // Adjust nextSectionIndex if needed
+          nextSectionIndex -= (existingEndIndex - i);
+          break;
+        }
+      }
+    }
+
+    // Insert requirement block at TOP of TO VERIFY section (right after section header)
+    // Always insert immediately after the section header with proper blank line spacing
+    let insertIndex = verifyIndex + 1;
+
+    // Ensure there's a blank line after the section header
+    if (lines[insertIndex]?.trim() !== '') {
+      lines.splice(insertIndex, 0, '');
+      insertIndex++;
+    }
+
+    // Insert the requirement block with image paste ability
+    const imagePaste = '### Image Paste\n\nYou can paste an image here by using the following format: ![image](image-url)\n\nExample: ![image](https://example.com/image.png)';
+    lines.splice(insertIndex, 0, ...requirementBlock, imagePaste);
+
+    // Ensure there's a blank line after the requirement block
+    const afterIndex = insertIndex + requirementBlock.length + 1;
+    if (afterIndex < lines.length && lines[afterIndex]?.trim() !== '') {
+      lines.splice(afterIndex, 0, '');
+    }
+
+    // Write the file
     await fs.writeFile(reqPath, lines.join('\n'));
-    console.log(`Moved requirement to VERIFIED: ${requirementText}`);
+    console.log(chalk.green(`✅ Moved requirement to TO VERIFY BY HUMAN: ${requirementText.substring(0, 80)}...`));
     return true;
   } catch (err) {
-    console.error('Error moving requirement:', err.message);
+    console.error('Error moving requirement to TO VERIFY:', err.message);
+    console.error('⚠️  Requirement may have been lost. Please check the requirements file.');
     return false;
   }
 }
@@ -549,6 +763,8 @@ async function getAllAvailableProviders() {
       }
       case 'cursor':
       case 'windsurf':
+      case 'vscode':
+      case 'kiro':
       case 'antigravity': {
         providers.push(base);
         break;
@@ -581,7 +797,7 @@ async function getAllAvailableProviders() {
 /**
  * Get provider configuration with automatic failover
  */
-async function getProviderConfig() {
+async function getProviderConfig(excludeProvider = null) {
   const config = await getAutoConfig();
   const providerManager = sharedProviderManager; // Use shared instance to persist rate limit state
   const providers = await getAllAvailableProviders();
@@ -599,11 +815,15 @@ async function getProviderConfig() {
   }
 
   const availableProviders = enabledProviders.filter(p => {
+    // Exclude the specified provider and rate-limited providers
+    if (excludeProvider && p.provider === excludeProvider) {
+      return false;
+    }
     return !providerManager.isRateLimited(p.provider, p.model);
   });
 
   let selection = null;
-  if (savedAgent) {
+  if (savedAgent && savedAgent !== excludeProvider) {
     selection = availableProviders.find(p => p.provider === savedAgent);
   }
   if (!selection) {
@@ -631,9 +851,9 @@ async function getProviderConfig() {
   };
 }
 
-async function acquireProviderConfig() {
+async function acquireProviderConfig(excludeProvider = null) {
   while (true) {
-    const selection = await getProviderConfig();
+    const selection = await getProviderConfig(excludeProvider);
     if (selection.status === 'ok') {
       return selection.provider;
     }
@@ -863,9 +1083,34 @@ async function findRelevantFiles(requirement, repoPath) {
 
   try {
     const reqLower = requirement.toLowerCase();
-
-    // Map keywords to specific files
-    if (reqLower.includes('completed') && reqLower.includes('verify')) {
+    const isRemovalRequirement = /remove|delete|eliminate/i.test(requirement) &&
+      (/menu|item|option|setting|button|ui|element/i.test(requirement));
+
+    // For removal requirements, search for the specific text/identifier mentioned
+    if (isRemovalRequirement) {
+      // Extract the text/identifier to search for (text in quotes or after "Remove")
+      const match = requirement.match(/remove\s+["']?([^"']+)["']?/i) ||
+        requirement.match(/remove:\s*["']?([^"']+)["']?/i) ||
+        requirement.match(/["']([^"']+)["']/);
+
+      if (match && match[1]) {
+        const searchText = match[1].trim();
+        // Search for files containing this text
+        const searchLower = searchText.toLowerCase();
+
+        // Always check interactive.js for menu items
+        relevantFiles.push('packages/cli/src/utils/interactive.js');
+
+        // If it mentions CLI or auto, also check auto-direct.js
+        if (searchLower.includes('cli') || searchLower.includes('auto') || searchLower.includes('restart')) {
+          relevantFiles.push('packages/cli/src/commands/auto-direct.js');
+        }
+      } else {
+        // Fallback: check both files for removal requirements
+        relevantFiles.push('packages/cli/src/utils/interactive.js');
+        relevantFiles.push('packages/cli/src/commands/auto-direct.js');
+      }
+    } else if (reqLower.includes('completed') && reqLower.includes('verify')) {
       // This is about the auto mode moving requirements
       relevantFiles.push('packages/cli/src/commands/auto-direct.js');
     } else if (reqLower.includes('requirements page') || reqLower.includes('requirements:')) {
@@ -1360,10 +1605,53 @@ async function runIteration(requirement, providerConfig, repoPath) {
     });
   }
 
+  // Check if requirement involves removing menu items or UI elements
+  const isRemovalRequirement = /remove|delete|eliminate/i.test(requirement.text) &&
+    (/menu|item|option|setting|button|ui|element/i.test(requirement.text));
+
+  let removalInstructions = '';
+  if (isRemovalRequirement) {
+    removalInstructions = `
+
+⚠️ CRITICAL: THIS IS A REMOVAL REQUIREMENT ⚠️
+
+When removing menu items, UI elements, or settings, you MUST:
+
+1. **FIND ALL OCCURRENCES**: Search the CURRENT CODE CONTEXT for:
+   - The exact text/identifier mentioned in the requirement
+   - Variations (e.g., "Restart CLI", "restart CLI", "restartCLI", "setting:restart-cli")
+   - Both display code (where it's shown) AND handler code (where it's processed)
+
+2. **REMOVE ALL CODE, NOT JUST TOGGLE**:
+   - DELETE the code that displays/creates the menu item (e.g., items.push() calls)
+   - DELETE the handler code that processes the action (e.g., case 'setting:restart-cli': blocks)
+   - DELETE any configuration/state code related to the item (e.g., const restartCLI = ...)
+   - DELETE any variable declarations or references to the item
+
+3. **MULTIPLE FILES MAY BE AFFECTED**:
+   - If you find references in multiple files, you MUST provide multiple FILE/SEARCH/REPLACE blocks
+   - Each file needs its own FILE/SEARCH/REPLACE block
+   - Remove ALL occurrences across ALL files shown in the context
+
+4. **VERIFICATION**:
+   - After removal, the code should compile/run without errors
+   - The removed item should not appear anywhere in the codebase
+   - All related handlers and configuration should be removed
+
+EXAMPLE for removing "Restart CLI after each completed requirement":
+- Remove: items.push({ type: 'setting', name: \`...Restart CLI...\`, value: 'setting:restart-cli' })
+- Remove: case 'setting:restart-cli': { ... } handler block
+- Remove: const restartCLI = ... variable declaration
+- Remove: Any other references to restartCLI or 'setting:restart-cli'
+
+`;
+  }
+
   const prompt = `You are implementing a code change. Your task is to provide a SEARCH/REPLACE block that will modify the code.
 
 REQUIREMENT TO IMPLEMENT:
 ${requirement.text}
+${removalInstructions}
 ${contextSection}
 
 YOUR TASK:
@@ -1371,6 +1659,7 @@ YOUR TASK:
 2. Find the EXACT location where changes are needed
 3. COPY AT LEAST 10 LINES EXACTLY as they appear (including indentation, spacing, comments)
 4. Show what the code should look like after your changes
+${isRemovalRequirement ? '5. **REMOVE ALL CODE** related to the item - do NOT comment it out, DELETE it completely' : ''}
 
 OUTPUT FORMAT:
 
@@ -1627,16 +1916,16 @@ async function handleAutoStart(options) {
     console.log();
     console.log(chalk.gray('═'.repeat(80)));
 
+    // Calculate initial total for consistent display throughout the session
+    const initialTodoCount = await countTodoRequirements(repoPath);
+    const initialEffectiveMax = unlimited ? initialTodoCount : Math.min(maxChats, initialTodoCount);
+
     // Main loop
     let completedCount = 0;
     let failedCount = 0;
 
     for (let i = 0; i < maxChats; i++) {
-      console.log(chalk.bold.magenta(`\n${'━'.repeat(80)}`));
-      console.log(chalk.bold.magenta(`  ITERATION ${i + 1} of ${maxChats}`));
-      console.log(chalk.bold.magenta(`${'━'.repeat(80)}\n`));
-
-      // Get current requirement
+      // Get current requirement first to check if there are any TODO items
       const requirement = await getCurrentRequirement(repoPath);
       if (!requirement) {
         console.log(chalk.bold.yellow('\n🎉 All requirements completed!'));
@@ -1644,12 +1933,20 @@ async function handleAutoStart(options) {
         break;
       }
 
+      // Calculate current requirement number consistently (before processing)
+      // This represents which requirement we're working on (1-based)
+      const currentReqNumber = completedCount + failedCount + 1;
+
+      console.log(chalk.bold.magenta(`\n${'━'.repeat(80)}`));
+      console.log(chalk.bold.magenta(`  REQUIREMENT ${currentReqNumber} of ${initialEffectiveMax}`));
+      console.log(chalk.bold.magenta(`${'━'.repeat(80)}\n`));
+
       // Run iteration with full workflow
       const result = await runIteration(requirement, providerConfig, repoPath);
 
       if (result.success) {
         completedCount++;
-        console.log(chalk.bold.green(`✅ Iteration ${i + 1}/${maxChats} COMPLETE`));
+        console.log(chalk.bold.green(`✅ Requirement ${currentReqNumber}/${initialEffectiveMax} COMPLETE`));
         console.log(chalk.gray('Moving to next requirement...\n'));
 
         // Check if restart CLI is enabled and there are more iterations
@@ -1696,11 +1993,15 @@ async function handleAutoStart(options) {
         const isRateLimitError = isRateLimitMessage(result.error);
         const errorType = isRateLimitError ? 'Rate limit' : 'Error';
 
+        // Store the provider that failed before switching
+        const failedProvider = providerConfig.displayName;
+
         console.log(chalk.yellow(`⚠️  ${errorType} detected, switching to next provider in your list...\n`));
 
-        const newProviderConfig = await acquireProviderConfig();
+        const newProviderConfig = await acquireProviderConfig(providerConfig.provider);
         if (newProviderConfig) {
           providerConfig = newProviderConfig;
+          console.log(chalk.yellow(`⚠️  ${failedProvider} hit ${errorType.toLowerCase()}`));
           console.log(chalk.green(`✓ Switched to: ${providerConfig.displayName}\n`));
 
           // Retry this iteration with new provider (don't increment i)
@@ -1711,7 +2012,10 @@ async function handleAutoStart(options) {
         }
 
         failedCount++;
-        console.log(chalk.bold.red(`❌ Iteration ${i + 1}/${maxChats} FAILED`));
+        // Use the same currentReqNumber that was calculated at the start of this iteration
+        // This ensures consistency: if we showed "Requirement 2 of 3" at the start,
+        // we should show "Requirement 2 of 3 FAILED" (not recalculate it)
+        console.log(chalk.bold.red(`❌ Requirement ${currentReqNumber}/${initialEffectiveMax} FAILED`));
         console.log(chalk.red(`Error: ${result.error}\n`));
         console.log(chalk.yellow('Continuing to next requirement...\n'));
       }
@@ -1722,7 +2026,8 @@ async function handleAutoStart(options) {
     console.log(chalk.bold.magenta(`  FINAL SUMMARY`));
     console.log(chalk.bold.magenta(`${'━'.repeat(80)}\n`));
 
-    console.log(chalk.white('Total iterations:'), unlimited ? chalk.cyan('∞ (never stop)') : chalk.cyan(maxChats));
+    const totalProcessed = completedCount + failedCount;
+    console.log(chalk.white('Total requirements:'), chalk.cyan(totalProcessed));
     console.log(chalk.white('Completed:'), chalk.green(`${completedCount} ✓`));
     if (failedCount > 0) {
       console.log(chalk.white('Failed:'), chalk.red(`${failedCount} ✗`));
@@ -1732,7 +2037,6 @@ async function handleAutoStart(options) {
 
     if (completedCount > 0) {
       console.log(chalk.bold.green(`🎉 ${completedCount} requirement${completedCount > 1 ? 's' : ''} moved to TO VERIFY BY HUMAN!`));
-      console.log(chalk.gray('Check the REQUIREMENTS file to verify and approve changes.\n'));
     }
 
   } catch (error) {