vibecodingmachine-cli 2025.12.25-1541 → 2026.1.3-2209

package/src/utils/interactive.js

@@ -5,6 +5,7 @@ const path = require('path');
 const os = require('os');
 const fs = require('fs-extra');
 const readline = require('readline');
+const { execSync } = require('child_process');
 const repo = require('../commands/repo');
 const auto = require('../commands/auto');
 const status = require('../commands/status');
@@ -22,12 +23,94 @@ const {
   detectLocale,
   setLocale
 } = require('vibecodingmachine-core');
+const { promptWithDefaultsOnce } = require('./prompt-helper');
 
 // Initialize locale detection for interactive mode
 const detectedLocale = detectLocale();
 setLocale(detectedLocale);
 const pkg = require('../../package.json');
 
+async function checkAppOrBinary(names = [], binaries = []) {
+  // names: app bundle base names (e.g., 'Cursor' -> /Applications/Cursor.app)
+  // binaries: CLI binary names to check on PATH (e.g., 'code')
+  const platform = os.platform();
+  // Check common application directories
+  if (platform === 'darwin') {
+    const appDirs = ['/Applications', path.join(os.homedir(), 'Applications')];
+    for (const appName of names) {
+      for (const dir of appDirs) {
+        try {
+          const p = path.join(dir, `${appName}.app`);
+          if (await fs.pathExists(p)) {
+            // Ensure this is a real application bundle (has Contents/MacOS executable)
+            try {
+              const macosDir = path.join(p, 'Contents', 'MacOS');
+              const exists = await fs.pathExists(macosDir);
+              if (exists) {
+                const files = await fs.readdir(macosDir);
+                if (files && files.length > 0) {
+                  // Prefer to ensure the app is usable: use spctl to assess, fallback to quarantine xattr
+                  try {
+                    // spctl returns non-zero on rejected/invalid apps
+                    execSync(`spctl --assess -v "${p}"`, { stdio: 'ignore', timeout: 5000 });
+                    // additionally validate codesign quickly (timeout to avoid hangs)
+                    try {
+                      execSync(`codesign -v --deep --strict "${p}"`, { stdio: 'ignore', timeout: 5000 });
+                      return true;
+                    } catch (csErr) {
+                      // codesign failed or timed out — treat as not usable/damaged
+                      return false;
+                    }
+                  } catch (e) {
+                    // spctl failed or timed out — check if app has quarantine attribute
+                    try {
+                      const out = execSync(`xattr -p com.apple.quarantine "${p}" 2>/dev/null || true`, { encoding: 'utf8' }).trim();
+                      if (!out) {
+                        // no quarantine attribute but spctl failed — be conservative and treat as not installed
+                        return false;
+                      }
+                      // If quarantine attribute exists, treat as not installed (damaged/not allowed)
+                      return false;
+                    } catch (e2) {
+                      return false;
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              // if we can't stat inside, be conservative and continue searching
+            }
+          }
+        } catch (e) {
+          /* ignore */
+        }
+      }
+    }
+  }
+
+  // Check PATH for known binaries
+  for (const bin of binaries) {
+    try {
+      execSync(`which ${bin}`, { stdio: 'ignore' });
+      return true;
+    } catch (e) {
+      /* not found */
+    }
+  }
+
+  // Check common Homebrew bin locations
+  const brewPaths = ['/opt/homebrew/bin', '/usr/local/bin'];
+  for (const bin of binaries) {
+    for (const brew of brewPaths) {
+      try {
+        if (await fs.pathExists(path.join(brew, bin))) return true;
+      } catch (e) { /* ignore */ }
+    }
+  }
+
+  return false;
+}
+
 /**
  * Translate workflow stage names
  */
@@ -47,6 +130,78 @@ function translateStage(stage) {
   return key ? t(key) : stage;
 }
 
+function normalizeProjectDirName(input) {
+  const s = String(input || '').trim().toLowerCase();
+  const replaced = s.replace(/\s+/g, '-');
+  const cleaned = replaced.replace(/[^a-z0-9._-]/g, '-');
+  const collapsed = cleaned.replace(/-+/g, '-').replace(/^[-._]+|[-._]+$/g, '');
+  return collapsed || 'my-project';
+}
+
+async function bootstrapProjectIfInHomeDir() {
+  let cwdResolved = path.resolve(process.cwd());
+  let homeResolved = path.resolve(os.homedir());
+
+  try {
+    cwdResolved = await fs.realpath(cwdResolved);
+  } catch (err) {
+    // Ignore
+  }
+
+  try {
+    homeResolved = await fs.realpath(homeResolved);
+  } catch (err) {
+    // Ignore
+  }
+
+  if (cwdResolved !== homeResolved) {
+    return;
+  }
+
+  const codeDir = path.join(homeResolved, 'code');
+  const codeDirExists = await fs.pathExists(codeDir);
+
+  if (!codeDirExists) {
+    const { shouldCreateCodeDir } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldCreateCodeDir',
+        message: `No code directory found at ${codeDir}. Would you like to create it?`,
+        default: true
+      }
+    ]);
+
+    if (!shouldCreateCodeDir) {
+      return;
+    }
+
+    await fs.ensureDir(codeDir);
+  }
+
+  const { projectName } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'What is the project name you want to create?',
+      validate: (value) => {
+        const trimmed = String(value || '').trim();
+        return trimmed.length > 0 || 'Please enter a project name.';
+      }
+    }
+  ]);
+
+  const dirName = normalizeProjectDirName(projectName);
+  const projectDir = path.join(codeDir, dirName);
+  await fs.ensureDir(projectDir);
+
+  process.chdir(projectDir);
+  try {
+    await writeConfig({ ...(await readConfig()), repoPath: projectDir });
+  } catch (err) {
+    // Best-effort: interactive mode will still use process.cwd()
+  }
+}
+
 /**
  * Format IDE name for display
  * @param {string} ide - Internal IDE identifier
@@ -248,6 +403,39 @@ async function countRequirements() {
   }
 }
 
+async function getSyncStatus() {
+  try {
+    const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+    const syncEngine = new SyncEngine();
+    await syncEngine.initialize();
+    const status = syncEngine.getStatus();
+    syncEngine.stop();
+
+    if (!status.isOnline && status.queuedChanges > 0) {
+      return `[Offline: ${status.queuedChanges} queued]`;
+    } else if (!status.isOnline) {
+      return '[Offline]';
+    } else if (status.isSyncing) {
+      return '[Syncing...]';
+    } else if (status.lastSyncTime) {
+      const timeSinceSync = Date.now() - status.lastSyncTime;
+      const minutesAgo = Math.floor(timeSinceSync / (1000 * 60));
+      if (minutesAgo < 1) {
+        return '[Sync: ✓ just now]';
+      } else if (minutesAgo < 60) {
+        return `[Sync: ✓ ${minutesAgo}m ago]`;
+      } else {
+        const hoursAgo = Math.floor(minutesAgo / 60);
+        return `[Sync: ✓ ${hoursAgo}h ago]`;
+      }
+    } else {
+      return '[Never synced]';
+    }
+  } catch (error) {
+    return '[Sync unavailable]';
+  }
+}
+
 async function getCurrentProgress() {
   try {
     const { getRequirementsPath } = require('vibecodingmachine-core');
@@ -333,6 +521,22 @@ async function showWelcomeScreen() {
   // Display repository and system info
   console.log();
   console.log(chalk.gray(t('system.repo').padEnd(25)), formatPath(repoPath));
+
+  // Display git branch if in a git repo
+  try {
+    const { isGitRepo, getCurrentBranch, hasUncommittedChanges } = require('vibecodingmachine-core');
+    if (isGitRepo(repoPath)) {
+      const branch = getCurrentBranch(repoPath);
+      if (branch) {
+        const isDirty = hasUncommittedChanges(repoPath);
+        const branchDisplay = isDirty ? `${chalk.cyan(branch)} ${chalk.yellow(t('system.git.status.dirty'))}` : chalk.cyan(branch);
+        console.log(chalk.gray(t('system.git.branch').padEnd(25)), branchDisplay);
+      }
+    }
+  } catch (error) {
+    // Ignore git display errors
+  }
+
   console.log(chalk.gray(t('system.computer.name').padEnd(25)), chalk.cyan(hostname));
 
   // Display auto mode progress if running
@@ -432,16 +636,16 @@ async function showRequirementsTree() {
       };
 
       // Create localized labels
-      const localizedTodoLabel = todoCount > 0 ? 
-        `⏳ ${t('requirements.section.todo')} (${todoCount} - ${Math.round((todoCount / total) * 100)}%)` : 
+      const localizedTodoLabel = todoCount > 0 ?
+        `⏳ ${t('requirements.section.todo')} (${todoCount} - ${Math.round((todoCount / total) * 100)}%)` :
         `⏳ ${t('requirements.section.todo')} (0 - 0%)`;
-      
-      const localizedToVerifyLabel = toVerifyCount > 0 ? 
-        `✅ ${t('requirements.section.to.verify')} (${toVerifyCount} - ${Math.round((toVerifyCount / total) * 100)}%)` : 
+
+      const localizedToVerifyLabel = toVerifyCount > 0 ?
+        `✅ ${t('requirements.section.to.verify')} (${toVerifyCount} - ${Math.round((toVerifyCount / total) * 100)}%)` :
         `✅ ${t('requirements.section.to.verify')} (0 - 0%)`;
-      
-      const localizedVerifiedLabel = verifiedCount > 0 ? 
-        `🎉 ${t('requirements.section.verified')} (${verifiedCount} - ${Math.round((verifiedCount / total) * 100)}%)` : 
+
+      const localizedVerifiedLabel = verifiedCount > 0 ?
+        `🎉 ${t('requirements.section.verified')} (${verifiedCount} - ${Math.round((verifiedCount / total) * 100)}%)` :
         `🎉 ${t('requirements.section.verified')} (0 - 0%)`;
 
       const verifiedReqs = tree.verifiedReqs || [];
@@ -450,6 +654,10 @@ async function showRequirementsTree() {
       const todoReqs = tree.todoReqs || [];
       const recycledReqs = tree.recycledReqs || [];
 
+      // Calculate percentages for clarification and recycled sections
+      const clarificationPercent = total > 0 ? Math.round((clarificationReqs.length / total) * 100) : 0;
+      const recycledPercent = total > 0 ? Math.round((recycledReqs.length / total) * 100) : 0;
+
       // VERIFIED section (first) - only show if has requirements
       if (verifiedReqs.length > 0 || verifiedCount > 0) {
         tree.items.push({ level: 1, type: 'section', label: localizedVerifiedLabel, key: 'verified' });
@@ -708,49 +916,99 @@ async function showRequirementsTree() {
 
     let inSection = false;
     const requirements = [];
-    let currentReq = null;
 
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
+      const trimmed = line.trim();
 
-      if (line.includes('❓ Requirements needing manual feedback')) {
+      // Check if we're entering the clarification section
+      if (trimmed.includes('❓ Requirements needing manual feedback')) {
         inSection = true;
         continue;
       }
 
-      if (inSection && line.startsWith('##') && !line.includes('❓ Requirements needing manual feedback')) {
-        if (currentReq) requirements.push(currentReq);
+      // Check if we're leaving the section (hit another ## section)
+      if (inSection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
         break;
       }
 
-      if (inSection && line.trim().startsWith('- ')) {
-        if (currentReq) requirements.push(currentReq);
-
-        const title = line.trim().substring(2);
-        currentReq = { title, questions: [], findings: null, lineIndex: i };
-      } else if (inSection && currentReq && line.trim()) {
-        // Check for AI findings section
-        if (line.trim().startsWith('**AI found in codebase:**')) {
-          continue; // Skip the header, capture next line as findings
-        } else if (!currentReq.findings && !line.trim().startsWith('**Clarifying questions:**') && !line.trim().match(/^\d+\./)) {
-          // This is the findings content (comes after "AI found in codebase:")
-          currentReq.findings = line.trim();
-        } else if (line.trim().startsWith('**Clarifying questions:**')) {
-          continue; // Skip the questions header
-        } else if (line.trim().match(/^\d+\./)) {
-          // This is a question
-          currentReq.questions.push({ question: line.trim(), response: null });
-        } else if (currentReq.questions.length > 0) {
-          // This might be a response to the last question
-          const lastQuestion = currentReq.questions[currentReq.questions.length - 1];
-          if (!lastQuestion.response) {
-            lastQuestion.response = line.trim();
+      // Read requirements in new format (### header)
+      if (inSection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+
+        // Skip empty titles
+        if (!title || title.length === 0) {
+          continue;
+        }
+
+        const details = [];
+        const questions = [];
+        let pkg = null;
+        let findings = null;
+        let currentQuestion = null;
+
+        // Read package, description, and clarifying questions
+        for (let j = i + 1; j < lines.length; j++) {
+          const nextLine = lines[j].trim();
+
+          // Stop if we hit another requirement or section
+          if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+            break;
+          }
+
+          // Check for PACKAGE line
+          if (nextLine.startsWith('PACKAGE:')) {
+            pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+          }
+          // Check for AI findings
+          else if (nextLine.startsWith('**AI found in codebase:**')) {
+            // Next line will be the findings
+            continue;
+          }
+          else if (nextLine.startsWith('**What went wrong')) {
+            // Description line
+            details.push(nextLine);
+          }
+          else if (nextLine.startsWith('**Clarifying questions:**')) {
+            // Start of questions section
+            continue;
+          }
+          else if (nextLine.match(/^\d+\./)) {
+            // Save previous question if exists
+            if (currentQuestion) {
+              questions.push(currentQuestion);
+            }
+            // This is a new question
+            currentQuestion = { question: nextLine, response: null };
           }
+          else if (currentQuestion && nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+            // This might be a response to the current question or description/findings
+            if (!findings && !currentQuestion.response && questions.length === 0 && !nextLine.match(/^\d+\./)) {
+              // This is findings content
+              findings = nextLine;
+            } else if (currentQuestion && !currentQuestion.response) {
+              // This is a response to the current question
+              currentQuestion.response = nextLine;
+            } else {
+              // Description line
+              details.push(nextLine);
+            }
+          }
+          else if (nextLine && !nextLine.startsWith('PACKAGE:') && !nextLine.startsWith('**')) {
+            // Description line
+            details.push(nextLine);
+          }
+        }
+
+        // Save last question if exists
+        if (currentQuestion) {
+          questions.push(currentQuestion);
         }
+
+        requirements.push({ title, details, pkg, questions, findings, lineIndex: i });
       }
     }
 
-    if (currentReq) requirements.push(currentReq);
     return requirements;
   };
 
@@ -2357,7 +2615,7 @@ async function showRequirementsBySection(sectionTitle) {
           }
           break;
         case 'delete':
-          const { confirmDelete } = await inquirer.prompt([{
+          const { confirmDelete } = await promptWithDefaultsOnce([{
             type: 'confirm',
             name: 'confirmDelete',
             message: 'Are you sure you want to delete this requirement?',
@@ -2773,23 +3031,39 @@ async function showProviderManagerMenu() {
       const isSelected = idx === selectedIndex;
       const isEnabled = enabled[id] !== false;
 
-      // Check for Kiro installation
+      // Check installation status for all IDEs
       let isInstalled = true;
-      if (id === 'kiro') {
+      if (def.type === 'ide') {
         try {
-          const { isKiroInstalled } = require('./kiro-installer');
-          isInstalled = isKiroInstalled();
+          if (id === 'kiro') {
+            const { isKiroInstalled } = require('./kiro-installer');
+            isInstalled = isKiroInstalled();
+          } else if (id === 'cursor') {
+            isInstalled = await checkAppOrBinary(['Cursor'], ['cursor']);
+          } else if (id === 'windsurf') {
+            isInstalled = await checkAppOrBinary(['Windsurf'], ['windsurf']);
+          } else if (id === 'vscode') {
+            isInstalled = await checkAppOrBinary(['Visual Studio Code', 'Visual Studio Code - Insiders'], ['code', 'code-insiders']);
+          } else if (id === 'antigravity') {
+            isInstalled = await checkAppOrBinary(['Antigravity'], ['antigravity']);
+          } else {
+            // For other IDEs, try binary name same as id
+            isInstalled = await checkAppOrBinary([], [id]);
+          }
         } catch (e) {
-          // Ignore error provider checks
+          // If detection fails, assume not installed
+          isInstalled = false;
         }
       }
 
-      // Determine status emoji: disabled = red alert, rate limited = green circle, enabled = green circle
+      // Determine status emoji: disabled = red alert, not installed = yellow, enabled = green
       let statusEmoji;
-      if (id === 'kiro' && !isInstalled) {
+      if (!isEnabled) {
+        statusEmoji = '🚨'; // Red for disabled
+      } else if (def.type === 'ide' && !isInstalled) {
         statusEmoji = '🟡'; // Yellow for not installed
       } else {
-        statusEmoji = !isEnabled ? '🚨' : '🟢';
+        statusEmoji = '🟢'; // Green for enabled and installed (or LLM)
       }
 
       const typeLabel = def.type === 'ide' ? chalk.cyan('IDE') : chalk.cyan('LLM');
@@ -3372,8 +3646,36 @@ async function startInteractive() {
   const { stopAutoMode } = require('./auto-mode');
   await stopAutoMode('startup');
 
+  await bootstrapProjectIfInHomeDir();
+
   await showWelcomeScreen();
 
+  // Check if .vibecodingmachine directory exists, offer to create if not
+  const allnightStatusCheck = await checkVibeCodingMachineExists();
+  if (!allnightStatusCheck.insideExists && !allnightStatusCheck.siblingExists) {
+    console.log(chalk.yellow('\n⚠️  No .vibecodingmachine directory found'));
+    console.log(chalk.gray('This directory is needed to save requirements and track progress.\n'));
+    
+    const { shouldInit } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldInit',
+        message: 'Would you like to create the .vibecodingmachine directory now?',
+        default: true
+      }
+    ]);
+    
+    if (shouldInit) {
+      // Use the initRepo function to create the directory
+      const { initRepo } = require('../commands/repo');
+      await initRepo({ location: 'inside' });
+      console.log('');
+    } else {
+      console.log(chalk.yellow('\n⚠️  Warning: Without the .vibecodingmachine directory, requirements cannot be saved.'));
+      console.log(chalk.gray('You can create it later by running: ') + chalk.cyan('vcm repo:init\n'));
+    }
+  }
+
   if (process.env.VCM_OPEN_PROVIDER_MENU === '1' || process.env.VCM_OPEN_PROVIDER_MENU === 'true') {
     await showProviderManagerMenu();
     return;
@@ -3516,7 +3818,9 @@ async function startInteractive() {
 
       // Add Requirements as a selectable setting with counts
       const hasRequirements = await requirementsExists();
-      const counts = hasRequirements ? await countRequirements() : null;
+      const { getComputerFilter } = require('./config');
+      const computerFilter = await getComputerFilter();
+      const counts = hasRequirements ? await countRequirements(computerFilter) : null;
       let requirementsText = t('interactive.requirements') + ': ';
       if (counts) {
         // Use actual counts for display (not capped by maxChats)
@@ -3538,11 +3842,19 @@ async function startInteractive() {
       if (requirementsText !== '') {
         items.push({
           type: 'setting',
-          name: requirementsText,
+          name: requirementsText + ` ${chalk.blue('Sync Status: ' + (await getSyncStatus()))}`,
           value: 'setting:requirements'
         });
       }
 
+      // Add requirement filtering by computer
+      const filterText = computerFilter ? chalk.cyan(computerFilter) : chalk.gray('All Computers');
+      items.push({
+        type: 'setting',
+        name: `  └─ Filter Requirements by Computer: ${filterText}`,
+        value: 'setting:filter-requirements'
+      });
+
       items.push({
         type: 'setting',
         name: `  └─ ${t('interactive.hostname.enabled')}: ${useHostname ? chalk.green('✓') : chalk.red('🛑')} ${useHostname ? '✓ ENABLED' : '🛑 ' + t('interactive.hostname.disabled')}`,
@@ -3559,6 +3871,83 @@ async function startInteractive() {
         value: 'setting:stages'
       });
 
+      // Add Admin Dashboard - Multi-Computer Dashboard
+      items.push({
+        type: 'setting',
+        name: `  └─ Admin Dashboard: ${chalk.cyan('Multi-Computer Dashboard')}`,
+        value: 'setting:admin-dashboard-multi-computer'
+      });
+
+      // Add Admin Dashboard - Compliance and Terms Tracking
+      items.push({
+        type: 'setting',
+        name: `  └─ Admin Dashboard: ${chalk.cyan('Compliance and Terms Tracking')}`,
+        value: 'setting:admin-dashboard-compliance'
+      });
+
+      // Add Admin Dashboard - Authentication and Security
+      items.push({
+        type: 'setting',
+        name: `  └─ Admin Dashboard: ${chalk.cyan('Authentication and Security')}`,
+        value: 'setting:admin-dashboard-auth'
+      });
+
+      // Add Admin Dashboard - Terms and Privacy Policy
+      items.push({
+        type: 'setting',
+        name: `  └─ Admin Dashboard: ${chalk.cyan('Terms and Privacy Policy')}`,
+        value: 'setting:admin-dashboard-terms'
+      });
+
+      // Add Admin Dashboard - Deployment and Infrastructure
+      items.push({
+        type: 'setting',
+        name: `  └─ Admin Dashboard: ${chalk.cyan('Deployment and Infrastructure')}`,
+        value: 'setting:admin-dashboard-deployment'
+      });
+
+      // Add Cloud Sync Infrastructure - AWS DynamoDB Setup
+      items.push({
+        type: 'setting',
+        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('AWS DynamoDB Setup')}`,
+        value: 'setting:cloud-sync-dynamodb'
+      });
+
+      // Add Cloud Sync Infrastructure - Lambda Functions
+      items.push({
+        type: 'setting',
+        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('Lambda Functions')}`,
+        value: 'setting:cloud-sync-lambda'
+      });
+
+      // Add Cloud Sync Infrastructure - API Gateway Setup
+      items.push({
+        type: 'setting',
+        name: `  └─ Cloud Sync: ${chalk.cyan('AWS DynamoDB Setup')}`,
+        value: 'setting:cloud-sync-dynamodb'
+      });
+
+      // Add Cloud Sync Infrastructure - AWS API Gateway
+      items.push({
+        type: 'setting',
+        name: `  └─ Cloud Sync: ${chalk.cyan('AWS API Gateway')}`,
+        value: 'setting:cloud-sync-api-gateway'
+      });
+
+      // Add Cloud Sync Infrastructure - AWS Cognito Authentication
+      items.push({
+        type: 'setting',
+        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('AWS Cognito Authentication')}`,
+        value: 'setting:cloud-sync-cognito'
+      });
+
+      // Add Cloud Sync Infrastructure - AWS DynamoDB Setup
+      items.push({
+        type: 'setting',
+        name: `  └─ Cloud Sync Infrastructure: ${chalk.cyan('AWS DynamoDB Setup')}`,
+        value: 'setting:cloud-sync-dynamodb'
+      });
+
       // Cloud Sync Status
       try {
         const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
@@ -3596,7 +3985,82 @@ async function startInteractive() {
         });
       }
 
+      // Computer and Usage Tracking Status
+      try {
+        const os = require('os');
+        const hostname = os.hostname();
+        const platform = os.platform();
+        const arch = os.arch();
+        const usageIcon = chalk.blue('●');
+        const trackingText = `${hostname} (${platform}/${arch})`;
+
+        items.push({
+          type: 'setting',
+          name: `${t('interactive.usage.tracking') || 'Usage Tracking'}: ${usageIcon} ${chalk.cyan(trackingText)}`,
+          value: 'setting:usage-tracking'
+        });
+      } catch (error) {
+        // Tracking info unavailable
+        items.push({
+          type: 'setting',
+          name: `Usage Tracking: ${chalk.gray('● Unavailable')}`,
+          value: 'setting:usage-tracking'
+        });
+      }
+
+      // Add requirement number tracking status
+      items.push({
+        type: 'setting',
+        name: `  └─ ${t('interactive.requirements.tracking')}: ${counts ? chalk.green('✓ ENABLED') : chalk.red('🛑 DISABLED')}`,
+        value: 'setting:requirements-tracking'
+      });
+      const { readConfig } = require('./config');
+      const config = await readConfig();
+      const lastReqNumber = config.lastRequirementNumber || 0;
+      items.push({
+        type: 'setting',
+        name: `  └─ ${t('interactive.last.requirement.number')}: ${chalk.cyan('R' + lastReqNumber)}`,
+        value: 'setting:req-number'
+      });
+
       // Add "Next TODO Requirement" as a separate menu item if there are TODO items
+      if (counts && counts.todoCount > 0) {
+        items.push({
+          type: 'setting',
+          name: `  └─ ${t('interactive.next.todo.requirement')}`,
+          value: 'setting:next-todo-requirement'
+        });
+      }
+
+      // Save last tab opened
+      const lastTabOpened = config.lastTabOpened;
+      if (lastTabOpened) {
+        items.push({
+          type: 'setting',
+          name: `  └─ ${t('interactive.last.tab.opened')}: ${lastTabOpened}`,
+          value: 'setting:last-tab-opened'
+        });
+      }
+      items.push({
+        type: 'setting',
+        name: `Start Auto: Switch to Console tab`,
+        value: 'setting:start-auto'
+      });
+      // TODO: Implement getNextTodoRequirement function
+      // if (counts && counts.todoCount > 0) {
+      //   const { getNextTodoRequirement } = require('./auto-mode');
+      //   const nextRequirement = await getNextTodoRequirement();
+      //   if (nextRequirement) {
+      //     const requirementPreview = nextRequirement.length > 80 
+      //       ? nextRequirement.substring(0, 77) + '...' 
+      //       : nextRequirement;
+      //     items.push({
+      //       type: 'info',
+      //       name: `  └─ ${t('interactive.next.requirement')}: ${chalk.cyan(requirementPreview)}`,
+      //       value: 'info:next-requirement'
+      //     });
+      //   }
+      // }
       if (counts && counts.todoCount > 0) {
         // Get the actual next requirement text (new header format)
         let nextReqText = '...';
@@ -3920,6 +4384,69 @@ async function startInteractive() {
           await showWelcomeScreen();
           break;
         }
+        case 'setting:filter-requirements': {
+          // Configure requirement filtering by computer
+          const { getComputerFilter, setComputerFilter } = require('./config');
+          const inquirer = require('inquirer');
+          const repoPath = await getRepoPath();
+
+          if (!repoPath) {
+            console.log(chalk.yellow('No repository configured. Use repo:init or repo:set first.'));
+            await showWelcomeScreen();
+            break;
+          }
+
+          // Find all REQUIREMENTS-*.md files to get available computers
+          const vibeDir = path.join(repoPath, '.vibecodingmachine');
+          const files = await fs.pathExists(vibeDir) ? await fs.readdir(vibeDir) : [];
+          const reqFiles = files.filter(f => f.startsWith('REQUIREMENTS') && f.endsWith('.md'));
+
+          const computers = [];
+          for (const file of reqFiles) {
+            const filePath = path.join(vibeDir, file);
+            const content = await fs.readFile(filePath, 'utf8');
+            const hostnameMatch = content.match(/- \*\*Hostname\*\*:\s*(.+)/);
+            if (hostnameMatch) {
+              computers.push(hostnameMatch[1].trim());
+            }
+          }
+
+          if (computers.length === 0) {
+            console.log(chalk.yellow('No computers found in requirements files.'));
+            await showWelcomeScreen();
+            break;
+          }
+
+          const currentFilter = await getComputerFilter();
+
+          console.log(chalk.cyan(`\n🖥️  ${t('interactive.filter.requirements.by.computer')}\n`));
+          console.log(chalk.gray('Select which computer\'s requirements to show, or "All Computers" to show all.\n'));
+
+          const { selectedComputer } = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'selectedComputer',
+              message: t('interactive.select.computer'),
+              choices: [
+                { name: chalk.gray('All Computers'), value: null },
+                ...computers.map(c => ({
+                  name: c === currentFilter ? chalk.cyan(`${c} (current)`) : c,
+                  value: c
+                }))
+              ],
+              default: currentFilter || null,
+              loop: false,
+              pageSize: 15
+            }
+          ]);
+
+          await setComputerFilter(selectedComputer);
+
+          const filterText = selectedComputer ? chalk.cyan(selectedComputer) : chalk.gray('All Computers');
+          console.log(chalk.green('\n✓'), `Requirements filter set to: ${filterText}\n`);
+          await showWelcomeScreen();
+          break;
+        }
         case 'setting:stages': {
           // Configure stages
           const { getStages, setStages, DEFAULT_STAGES } = require('./config');
@@ -3927,11 +4454,11 @@ async function startInteractive() {
 
           // Override inquirer's checkbox help text for current locale
           const CheckboxPrompt = require('inquirer/lib/prompts/checkbox');
-          const originalGetHelpText = CheckboxPrompt.prototype.getHelp || function() {
+          const originalGetHelpText = CheckboxPrompt.prototype.getHelp || function () {
             return '(Press <space> to select, <a> to toggle all, <i> to invert selection, and <enter> to proceed)';
           };
 
-          CheckboxPrompt.prototype.getHelp = function() {
+          CheckboxPrompt.prototype.getHelp = function () {
             const locale = detectLocale();
             if (locale === 'es') {
               return '(Presiona <espacio> para seleccionar, <a> para alternar todo, <i> para invertir selección, y <enter> para proceder)';
@@ -4013,8 +4540,23 @@ async function startInteractive() {
               const { getAutoConfig } = require('./config');
               const currentConfig = await getAutoConfig();
 
+              // Get first enabled agent from provider preferences (this is what user expects)
+              const { getProviderPreferences } = require('../utils/provider-registry');
+              const prefs = await getProviderPreferences();
+              console.log(chalk.gray('[DEBUG] Provider preferences:'), JSON.stringify(prefs, null, 2));
+              let firstEnabledAgent = null;
+              for (const agentId of prefs.order) {
+                if (prefs.enabled[agentId] !== false) {
+                  firstEnabledAgent = agentId;
+                  console.log(chalk.gray('[DEBUG] Found first enabled agent:'), firstEnabledAgent);
+                  break;
+                }
+              }
+              const agentToUse = firstEnabledAgent || currentIDE;
+              console.log(chalk.gray('[DEBUG] Agent to use:'), agentToUse, '(firstEnabled:', firstEnabledAgent, ', fallback:', currentIDE, ')');
+
               // Use saved maxChats/neverStop settings
-              const options = { ide: currentIDE };
+              const options = { ide: agentToUse };
               if (currentConfig.neverStop) {
                 options.neverStop = true;
               } else if (currentConfig.maxChats) {
@@ -4034,8 +4576,7 @@ async function startInteractive() {
                 }
 
                 // ALWAYS use auto:direct (supports both LLM and IDE agents with proper looping)
-                const currentAgent = currentConfig.agent || currentConfig.ide || 'ollama';
-                console.log(chalk.gray('[DEBUG] Using auto:direct for agent:', currentAgent));
+                console.log(chalk.gray('[DEBUG] Using auto:direct for agent:', agentToUse));
                 const { handleAutoStart: handleDirectAutoStart } = require('../commands/auto-direct');
                 await handleDirectAutoStart({ maxChats: options.maxChats });
 
@@ -4286,6 +4827,21 @@ async function startInteractive() {
             const hostname = getHostname();
             console.log('[DEBUG] Repo:', repoPath, 'Hostname:', hostname);
 
+            // Get current git branch if in a git repo
+            let currentBranch = '';
+            if (repoPath) {
+              try {
+                const { execSync } = require('child_process');
+                currentBranch = execSync('git branch --show-current', {
+                  cwd: repoPath,
+                  encoding: 'utf8'
+                }).trim();
+              } catch (err) {
+                // Not a git repo or git not available
+                currentBranch = '';
+              }
+            }
+
             // Build menu content for header
             const menuContent = `╭───────────────────────────────────────────────────────╮
 │                                                        │
@@ -4295,7 +4851,7 @@ async function startInteractive() {
 ╰───────────────────────────────────────────────────────╯
 
 ${t('system.repo').padEnd(25)} ${repoPath || 'Not set'}
-${t('system.computer.name').padEnd(25)} ${hostname}
+${currentBranch ? t('system.git.branch').padEnd(25) + ' ' + currentBranch + '\n' : ''}${t('system.computer.name').padEnd(25)} ${hostname}
 Current IDE:              ${formatIDEName(ide)}
 AI Provider:              ${getCurrentAIProvider(ide) || 'N/A'}
 Max Chats:                ${maxChats || 'Never stop'}`;
@@ -4466,7 +5022,11 @@ Max Chats:                ${maxChats || 'Never stop'}`;
   }
 }
 
-module.exports = { startInteractive };
+module.exports = {
+  startInteractive,
+  bootstrapProjectIfInHomeDir,
+  normalizeProjectDirName
+};