@vibecheckai/cli 3.6.1 → 3.8.0

package/bin/runners/runFix.js

@@ -23,7 +23,7 @@ const path = require('path');
 const fs = require('fs');
 const { execSync } = require('child_process');
 const { shipCore } = require('./runShip');
-const { planMissions } = require('./lib/missions/plan');
+const { planMissions, getMissionStats } = require('./lib/missions/plan');
 const { templateForMissionType } = require('./lib/missions/templates');
 const { expandEvidence } = require('./lib/missions/evidence');
 const { buildRealityFirewall } = require('./lib/firewall-prompt');
@@ -42,6 +42,45 @@ const upsell = require('./lib/upsell');
 // Mission Control output formatter
 const { formatFixOutput } = require('./lib/fix-output');
 
+// Fix Missions V2 - New components
+const { updateMissionStatus, MISSION_STATUS, isSafeToAutoApply } = require('./lib/missions/schema');
+const { 
+  createCheckpoint, 
+  rollbackToCheckpoint, 
+  rollbackMission,
+  markCheckpointApplied,
+  markCheckpointFailed,
+  listCheckpoints,
+  getMissionHistory,
+  cleanupOldCheckpoints,
+} = require('./lib/missions/checkpoint');
+const { 
+  runPreFlightGates, 
+  runPostFlightGates,
+  shouldAutoApply,
+  DEFAULT_THRESHOLDS,
+} = require('./lib/missions/safety-gates');
+const {
+  formatAllBriefings,
+  formatMissionSummary,
+  formatMissionResult,
+  formatFinalSummary,
+  formatMissionBriefing,
+  colors: briefingColors,
+  ICONS: briefingIcons,
+} = require('./lib/missions/briefing');
+const {
+  initAuditTrail,
+  getAuditTrail,
+  circuitBreakerAllows,
+  circuitBreakerSuccess,
+  circuitBreakerFailure,
+  circuitBreakerReset,
+  circuitBreakerStatus,
+  safeExecute,
+  ExecutionError,
+} = require('./lib/missions/hardening');
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -511,11 +550,103 @@ async function runFix(args) {
   const root = path.resolve(opts.path || process.cwd());
   const projectName = path.basename(root);
   
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // FIX MISSIONS V2 - Initialize hardening components
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  // Initialize audit trail
+  const auditDir = path.join(root, '.vibecheck', 'logs');
+  initAuditTrail(auditDir);
+  const audit = getAuditTrail();
+  
+  // Generate session ID for tracking
+  const sessionId = `fix_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  process.env.VIBECHECK_SESSION_ID = sessionId;
+  
+  audit.info('fix_session_start', { 
+    sessionId, 
+    projectName, 
+    root,
+    args: args.filter(a => !a.includes('key') && !a.includes('token')), // Filter sensitive args
+  });
+  
+  // Check circuit breaker
+  if (!circuitBreakerAllows()) {
+    const status = circuitBreakerStatus();
+    console.log(`  ${colors.blockRed}${ICONS.stop}${c.reset} Circuit breaker is open - too many recent failures`);
+    console.log(`  ${c.dim}Failures: ${status.failures}, Last failure: ${new Date(status.lastFailure).toISOString()}${c.reset}`);
+    console.log(`  ${c.dim}Wait ${Math.ceil((status.resetTimeout - (Date.now() - status.lastFailure)) / 1000)}s or use --force to override${c.reset}`);
+    
+    if (!opts.force) {
+      audit.warn('circuit_breaker_blocked', { status });
+      return EXIT.BLOCKING;
+    }
+    
+    audit.warn('circuit_breaker_override', { status });
+    circuitBreakerReset();
+  }
+  
   // Print banner
   printBanner();
   console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
   console.log(`  ${c.dim}Path:${c.reset}     ${root}`);
+  console.log(`  ${c.dim}Session:${c.reset}  ${c.dim}${sessionId}${c.reset}`);
   console.log();
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // FIX MISSIONS V2 - Handle special modes first
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  // Handle --list-checkpoints
+  if (opts.listCheckpoints) {
+    const checkpoints = listCheckpoints(root);
+    if (checkpoints.length === 0) {
+      console.log(`  ${c.dim}No checkpoints found${c.reset}`);
+    } else {
+      console.log(`  ${colors.accent}${ICONS.mission}${c.reset} ${c.bold}CHECKPOINTS${c.reset} ${c.dim}(${checkpoints.length})${c.reset}`);
+      console.log();
+      for (const cp of checkpoints.slice(0, 10)) {
+        const age = Math.round((Date.now() - new Date(cp.createdAt).getTime()) / 1000 / 60);
+        console.log(`  ${ICONS.check} ${cp.id}`);
+        console.log(`    ${c.dim}Mission: ${cp.missionType} • ${cp.files} files • ${age}m ago${c.reset}`);
+      }
+      if (checkpoints.length > 10) {
+        console.log(`  ${c.dim}... and ${checkpoints.length - 10} more${c.reset}`);
+      }
+    }
+    console.log();
+    return 0;
+  }
+
+  // Handle --cleanup-checkpoints
+  if (opts.cleanupCheckpoints) {
+    startSpinner('Cleaning up old checkpoints...', 'dots');
+    const result = cleanupOldCheckpoints(root);
+    stopSpinner(`Cleaned up ${result.count} checkpoints`, true);
+    return 0;
+  }
+
+  // Handle --rollback
+  if (opts.rollback) {
+    const missionId = opts.rollback;
+    console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Rolling back mission: ${c.bold}${missionId}${c.reset}`);
+    
+    const result = rollbackMission(root, missionId);
+    
+    if (result.ok) {
+      console.log(`  ${colors.shipGreen}${ICONS.check}${c.reset} Rollback successful`);
+      if (result.restored.length > 0) {
+        console.log(`    ${c.dim}Restored: ${result.restored.length} files${c.reset}`);
+      }
+      if (result.deleted.length > 0) {
+        console.log(`    ${c.dim}Deleted: ${result.deleted.length} files${c.reset}`);
+      }
+      return 0;
+    } else {
+      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} Rollback failed: ${result.error}`);
+      return EXIT.INTERNAL_ERROR;
+    }
+  }
   
   // TIER ENFORCEMENT: Check if --apply is allowed
   if (opts.apply || opts.autopilot) {
@@ -558,14 +689,65 @@ async function runFix(args) {
     return 0;
   }
 
-  // Plan missions
+  // Plan missions with enhanced options
   startSpinner('Planning fix missions...', 'gears');
-  const missions = planMissions(first.report.findings, { maxMissions: opts.maxMissions || 8 });
-  fs.writeFileSync(path.join(outDir, "missions.json"), JSON.stringify({ missions, fromVerdict: first.verdict }, null, 2));
-  stopSpinner(`Planned ${missions.length} missions`, true);
+  const missions = planMissions(first.report.findings, { 
+    maxMissions: opts.maxMissions || 8,
+    truthpack: first.truthpack,
+    maxBlastRadius: opts.maxBlast,
+    minConfidence: opts.minConfidence,
+  });
+  
+  // Filter to specific mission if requested
+  let targetMissions = missions;
+  if (opts.mission) {
+    targetMissions = missions.filter(m => m.id === opts.mission || m.id.includes(opts.mission));
+    if (targetMissions.length === 0) {
+      stopSpinner('Mission not found', false);
+      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} No mission found with ID: ${opts.mission}`);
+      console.log(`  ${c.dim}Available missions:${c.reset}`);
+      for (const m of missions.slice(0, 5)) {
+        console.log(`    ${c.dim}${m.id} - ${m.type}${c.reset}`);
+      }
+      return EXIT.BLOCKING;
+    }
+  }
+  
+  fs.writeFileSync(path.join(outDir, "missions.json"), JSON.stringify({ missions: targetMissions, fromVerdict: first.verdict }, null, 2));
+  stopSpinner(`Planned ${targetMissions.length} missions`, true);
+
+  // Get mission stats
+  const stats = getMissionStats(targetMissions);
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // FIX MISSIONS V2 - Plan-only mode with full briefings
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  if (opts.planOnly) {
+    // Show full mission briefings
+    const gateOptions = {
+      minConfidence: opts.minConfidence,
+      maxBlastRadius: opts.maxBlast,
+      force: opts.force,
+      allowDirty: opts.allowDirty,
+    };
+    
+    console.log(formatAllBriefings(root, targetMissions, gateOptions));
+    
+    // Save briefings to file
+    fs.writeFileSync(
+      path.join(outDir, "briefings.txt"),
+      formatAllBriefings(root, targetMissions, gateOptions).replace(/\x1b\[[0-9;]*m/g, ''),
+      "utf8"
+    );
+    console.log(`  ${c.dim}${ICONS.folder} Briefings saved: ${colors.accent}${path.relative(root, path.join(outDir, "briefings.txt"))}${c.reset}`);
+    console.log();
+    
+    return 0;
+  }
 
   // Show mission summary
-  printMissionSummary(missions);
+  printMissionSummary(targetMissions);
   console.log();
   console.log(`  ${c.dim}${ICONS.folder} Mission pack: ${colors.accent}${path.relative(root, outDir)}${c.reset}`);
   console.log();
@@ -575,8 +757,11 @@ async function runFix(args) {
     console.log();
     console.log(`  ${c.bold}Choose a mode:${c.reset}`);
     console.log();
+    console.log(`  ${colors.accent}${ICONS.prompt}${c.reset} ${c.bold}vibecheck fix --plan-only${c.reset}`);
+    console.log(`     ${c.dim}Full mission briefings with safety gates ${c.green}(FREE)${c.reset}${c.dim}${c.reset}`);
+    console.log();
     console.log(`  ${colors.accent}${ICONS.prompt}${c.reset} ${c.bold}vibecheck fix --prompt-only${c.reset}`);
-    console.log(`     ${c.dim}Generate perfect prompts, no edits ${c.green}(FREE)${c.reset}${c.dim}${c.reset}`);
+    console.log(`     ${c.dim}Generate LLM prompts, no edits ${c.green}(FREE)${c.reset}${c.dim}${c.reset}`);
     console.log();
     
     // Check if apply features are available
@@ -615,6 +800,15 @@ async function runFix(args) {
     printLoopHeader(maxSteps, stagnationLimit);
   }
 
+  // Track execution summary for V2
+  const executionSummary = {
+    total: targetMissions.length,
+    completed: 0,
+    failed: 0,
+    rolledBack: 0,
+    skipped: 0,
+  };
+
   for (let step = 1; step <= maxSteps; step++) {
     const before = await shipCore({ repoRoot: root, fastifyEntry: opts.fastifyEntry, noWrite: false });
 
@@ -635,12 +829,12 @@ async function runFix(args) {
       // Mission Control output
       if (!opts.json && !opts.quiet) {
         console.log(formatFixOutput({
-          missions,
+          missions: targetMissions,
           verdict: before.verdict,
           beforeVerdict: first.verdict,
           afterVerdict: before.verdict,
           appliedMissions: step - 1,
-          totalMissions: missions.length,
+          totalMissions: targetMissions.length,
           duration,
           success: true,
         }, { apply: opts.apply, promptOnly: opts.promptOnly, loop: opts.loop || opts.autopilot }));
@@ -650,7 +844,7 @@ async function runFix(args) {
     }
 
     const ids = new Set(before.report.findings.map(f => f.id));
-    const mission = missions.find(m => m.targetFindingIds.some(id => ids.has(id)));
+    const mission = targetMissions.find(m => m.objective?.targetFindingIds?.some(id => ids.has(id)) || m.targetFindingIds?.some(id => ids.has(id)));
     if (!mission) {
       printSection('COMPLETE', ICONS.check);
       console.log();
@@ -660,6 +854,28 @@ async function runFix(args) {
       return 0;
     }
 
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // FIX MISSIONS V2 - Pre-flight safety gates
+    // ═══════════════════════════════════════════════════════════════════════════════
+    
+    const gateOptions = {
+      minConfidence: opts.minConfidence,
+      maxBlastRadius: opts.maxBlast,
+      force: opts.force,
+      allowDirty: opts.allowDirty,
+    };
+    
+    const preFlightResults = runPreFlightGates(root, mission, gateOptions);
+    
+    if (!preFlightResults.ok && !opts.force) {
+      console.log(`  ${colors.warnAmber}${ICONS.warning}${c.reset} Mission ${mission.id} skipped: pre-flight gates failed`);
+      for (const result of preFlightResults.results.filter(r => !r.pass)) {
+        console.log(`    ${c.dim}${ICONS.cross} ${result.gate}: ${result.reason}${c.reset}`);
+      }
+      executionSummary.skipped++;
+      continue;
+    }
+
     // Save before proof
     fs.writeFileSync(
       path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_before_ship.json`),
@@ -667,7 +883,8 @@ async function runFix(args) {
       "utf8"
     );
 
-    const targetFindings = before.report.findings.filter(f => mission.targetFindingIds.includes(f.id));
+    const targetFindingIds = mission.objective?.targetFindingIds || mission.targetFindingIds || [];
+    const targetFindings = before.report.findings.filter(f => targetFindingIds.includes(f.id));
     
     // Show mission card
     printMissionCard(mission, step, maxSteps, 'running');
@@ -753,28 +970,60 @@ async function runFix(args) {
       return 0;
     }
 
-    // Apply patch
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // FIX MISSIONS V2 - Apply patch with checkpoint-based rollback
+    // ═══════════════════════════════════════════════════════════════════════════════
+
+    // Determine files to touch
     const touchedFiles = new Set();
     for (const ed of patchJson.edits) {
       for (const f of parseDiffTouchedFiles(ed.diff)) touchedFiles.add(f);
     }
     const touchedList = Array.from(touchedFiles);
 
-    const backupRoot = path.join(outDir, `backup_step_${String(step).padStart(2,"0")}`);
-    backupFiles(root, touchedList, backupRoot);
+    // Create checkpoint before applying (V2)
+    let checkpoint;
+    try {
+      checkpoint = createCheckpoint(root, mission, touchedList);
+      mission.safety = mission.safety || {};
+      mission.safety.checkpointId = checkpoint.id;
+      console.log(`  ${briefingColors.info}${briefingIcons.checkpoint}${c.reset} Checkpoint: ${c.dim}${checkpoint.id}${c.reset}`);
+    } catch (e) {
+      // Fall back to simple backup
+      const backupRoot = path.join(outDir, `backup_step_${String(step).padStart(2,"0")}`);
+      backupFiles(root, touchedList, backupRoot);
+      checkpoint = { id: null, backupRoot };
+    }
 
+    // Apply patches
+    let applyFailed = false;
     for (const ed of patchJson.edits) {
       const res = applyUnifiedDiff(root, ed.diff);
       if (!res.ok) {
         console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} Patch apply failed: ${res.error}`);
-        restoreBackup(root, backupRoot);
-        console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Restored from backup`);
-        return EXIT.INTERNAL_ERROR;
+        applyFailed = true;
+        break;
       }
       console.log(`  ${colors.patch}${ICONS.patch}${c.reset} Applied: ${c.dim}${ed.path}${c.reset}`);
     }
 
-    // Verify
+    // Handle apply failure - rollback
+    if (applyFailed) {
+      if (checkpoint.id) {
+        const rollbackResult = rollbackToCheckpoint(root, checkpoint.id);
+        markCheckpointFailed(root, checkpoint.id, 'Patch apply failed');
+        console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Rolled back via checkpoint`);
+      } else if (checkpoint.backupRoot) {
+        restoreBackup(root, checkpoint.backupRoot);
+        console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Restored from backup`);
+      }
+      executionSummary.failed++;
+      circuitBreakerFailure();
+      audit.error('mission_apply_failed', { missionId: mission.id, step });
+      return EXIT.INTERNAL_ERROR;
+    }
+
+    // Verify fix
     startSpinner('Verifying fix...', 'dots');
     const after = await shipCore({ repoRoot: root, fastifyEntry: opts.fastifyEntry, noWrite: false });
     
@@ -790,29 +1039,101 @@ async function runFix(args) {
       "utf8"
     );
 
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // FIX MISSIONS V2 - Post-flight safety gates
+    // ═══════════════════════════════════════════════════════════════════════════════
+    
+    const postFlightResults = runPostFlightGates(root, mission, before, after, {
+      runTests: !opts.skipTests,
+      testCommand: opts.testCommand,
+    });
+    
     const beforeScore = score(before.report.findings);
     const afterScore = score(after.report.findings);
-    const targetStillThere = mission.targetFindingIds.some(id => after.report.findings.some(f => f.id === id));
-    const improved = (afterScore < beforeScore) || (!targetStillThere);
+    const targetStillThere = targetFindingIds.some(id => after.report.findings.some(f => f.id === id));
+    const improved = (afterScore < beforeScore) || (!targetStillThere) || postFlightResults.ok;
 
-    if (!improved) {
-      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} No measurable progress`);
-      restoreBackup(root, backupRoot);
-      console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Restored from backup`);
+    if (!improved || postFlightResults.shouldRollback) {
+      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} ${postFlightResults.shouldRollback ? 'Post-flight gates failed' : 'No measurable progress'}`);
+      
+      // Show failed gates
+      for (const result of postFlightResults.results.filter(r => !r.pass)) {
+        console.log(`    ${c.dim}${ICONS.cross} ${result.gate}: ${result.reason}${c.reset}`);
+      }
+      
+      // Rollback
+      if (checkpoint.id) {
+        const rollbackResult = rollbackToCheckpoint(root, checkpoint.id);
+        console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Rolled back via checkpoint`);
+      } else if (checkpoint.backupRoot) {
+        restoreBackup(root, checkpoint.backupRoot);
+        console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Restored from backup`);
+      }
+      
+      executionSummary.rolledBack++;
+      circuitBreakerFailure();
+      audit.warn('mission_rolled_back', { 
+        missionId: mission.id, 
+        step,
+        reason: postFlightResults.shouldRollback ? 'post_flight_failed' : 'no_progress',
+        failedGates: postFlightResults.results.filter(r => !r.pass).map(r => r.gate),
+      });
+      
       stagnant += 1;
+      
       if (!opts.autopilot || stagnant >= stagnationLimit) {
         printSection('STAGNATION', ICONS.stop);
         console.log();
         console.log(`  ${colors.blockRed}${ICONS.stop}${c.reset} Stopping: stagnation limit reached (${stagnant}/${stagnationLimit})`);
         console.log();
+        
+        // Show final summary
+        executionSummary.verdict = after.verdict;
+        executionSummary.duration = Date.now() - startTime;
+        console.log(formatFinalSummary(executionSummary));
+        
+        audit.error('fix_session_stagnation', { 
+          sessionId, 
+          stagnant,
+          stagnationLimit,
+          duration: Date.now() - startTime,
+        });
+        
         return EXIT.BLOCKING;
       }
       continue;
     }
 
+    // Success - mark checkpoint as applied
+    if (checkpoint.id) {
+      markCheckpointApplied(root, checkpoint.id);
+    }
+    
     console.log(`  ${colors.shipGreen}${ICONS.check}${c.reset} Progress confirmed`);
+    console.log(formatMissionResult(mission, { 
+      success: true, 
+      findings: { before: beforeScore, after: afterScore } 
+    }));
+    
+    executionSummary.completed++;
+    circuitBreakerSuccess();
+    audit.info('mission_completed', { 
+      missionId: mission.id, 
+      step,
+      beforeScore,
+      afterScore,
+      improvement: beforeScore - afterScore,
+    });
+    
     stagnant = 0;
-    if (!opts.autopilot) return 0;
+    if (!opts.autopilot) {
+      audit.info('fix_session_end', { 
+        sessionId, 
+        duration: Date.now() - startTime,
+        result: 'success_single_mission',
+      });
+      return 0;
+    }
   }
 
   // Max steps reached
@@ -833,17 +1154,32 @@ async function runFix(args) {
   // Mission Control output
   if (!opts.json && !opts.quiet) {
     console.log(formatFixOutput({
-      missions,
+      missions: targetMissions,
       verdict: lastShip.verdict,
       beforeVerdict: first.verdict,
       afterVerdict: lastShip.verdict,
       appliedMissions: maxSteps,
-      totalMissions: missions.length,
+      totalMissions: targetMissions.length,
       duration,
       success: false,
     }, { apply: opts.apply, promptOnly: opts.promptOnly, loop: opts.loop || opts.autopilot }));
+    
+    // V2 Final summary
+    executionSummary.verdict = lastShip.verdict;
+    executionSummary.duration = duration;
+    console.log(formatFinalSummary(executionSummary));
   }
   
+  // Flush audit trail
+  audit.info('fix_session_end', { 
+    sessionId, 
+    duration,
+    result: 'max_steps_reached',
+    executionSummary,
+    verdict: lastShip.verdict,
+  });
+  audit.flush();
+  
   return EXIT.WARNINGS; // Max steps reached, incomplete
 }
 
@@ -865,12 +1201,23 @@ function parseArgs(args) {
     path: globalFlags.path || process.cwd(),
     apply: false,
     promptOnly: false,
+    planOnly: false,
     loop: false,
     share: false,
     maxMissions: 8,
     maxSteps: 10,
     stagnationLimit: 2,
     fastifyEntry: null,
+    // Fix Missions V2 - New options
+    rollback: null,       // Mission ID to rollback
+    mission: null,        // Specific mission ID to run
+    force: false,         // Override safety gates
+    minConfidence: DEFAULT_THRESHOLDS.minConfidence,
+    maxBlast: DEFAULT_THRESHOLDS.maxBlastRadius,
+    allowDirty: false,    // Allow uncommitted changes
+    skipTests: true,      // Skip post-flight tests
+    listCheckpoints: false,
+    cleanupCheckpoints: false,
     // Note: help comes from globalFlags, don't override it here
   };
 
@@ -879,6 +1226,7 @@ function parseArgs(args) {
     const arg = cleanArgs[i];
     if (arg === '--apply') opts.apply = true;
     else if (arg === '--prompt-only') opts.promptOnly = true;
+    else if (arg === '--plan-only') opts.planOnly = true;
     else if (arg === '--autopilot') opts.autopilot = true;
     else if (arg === '--share') opts.share = true;
     else if (arg === '--max-missions') opts.maxMissions = Number(cleanArgs[++i]) || 8;
@@ -887,6 +1235,16 @@ function parseArgs(args) {
     else if (arg === '--fastify-entry') opts.fastifyEntry = cleanArgs[++i];
     else if (arg === '--path' || arg === '-p') opts.path = cleanArgs[++i];
     else if (arg === '--help' || arg === '-h') opts.help = true;
+    // Fix Missions V2 - New flags
+    else if (arg === '--rollback') opts.rollback = cleanArgs[++i];
+    else if (arg === '--mission') opts.mission = cleanArgs[++i];
+    else if (arg === '--force') opts.force = true;
+    else if (arg === '--min-confidence') opts.minConfidence = Number(cleanArgs[++i]) || DEFAULT_THRESHOLDS.minConfidence;
+    else if (arg === '--max-blast') opts.maxBlast = Number(cleanArgs[++i]) || DEFAULT_THRESHOLDS.maxBlastRadius;
+    else if (arg === '--allow-dirty') opts.allowDirty = true;
+    else if (arg === '--run-tests') opts.skipTests = false;
+    else if (arg === '--list-checkpoints') opts.listCheckpoints = true;
+    else if (arg === '--cleanup-checkpoints') opts.cleanupCheckpoints = true;
   }
 
   return opts;
@@ -899,22 +1257,43 @@ function printHelp(showBanner = true) {
   console.log(`
   ${c.bold}Usage:${c.reset} vibecheck fix (f) [options]
 
-  ${c.bold}Mission Control${c.reset} — Generate surgical fix prompts, apply patches, verify with ship.
+  ${c.bold}Mission Control V2${c.reset} — "Missions, not chaos" - Surgical fixes with safety gates.
 
   ${c.bold}Modes:${c.reset}
     ${colors.accent}vibecheck fix${c.reset}                      ${c.dim}Plan missions (no changes) ${c.green}(FREE)${c.reset}${c.dim}${c.reset}
-    ${colors.accent}vibecheck fix --prompt-only${c.reset}        ${c.dim}Generate perfect prompts ${c.green}(FREE)${c.reset}${c.dim}${c.reset}
+    ${colors.accent}vibecheck fix --plan-only${c.reset}          ${c.dim}Full mission briefings ${c.green}(FREE)${c.reset}${c.dim}${c.reset}
+    ${colors.accent}vibecheck fix --prompt-only${c.reset}        ${c.dim}Generate LLM prompts ${c.green}(FREE)${c.reset}${c.dim}${c.reset}
     ${colors.accent}vibecheck fix --apply${c.reset}              ${c.dim}Apply patches from LLM ${c.yellow}(PRO)${c.reset}${c.dim}${c.reset}
-    ${colors.accent}vibecheck fix --loop --apply${c.reset}  ${c.dim}Loop until SHIP or stuck ${c.yellow}(PRO)${c.reset}${c.dim}${c.reset}
+    ${colors.accent}vibecheck fix --autopilot --apply${c.reset}  ${c.dim}Loop until SHIP or stuck ${c.yellow}(PRO)${c.reset}${c.dim}${c.reset}
 
-  ${c.bold}Options:${c.reset}
+  ${c.bold}Core Options:${c.reset}
+    ${colors.accent}--plan-only${c.reset}           Show full mission briefings with safety gates
     ${colors.accent}--prompt-only${c.reset}         Generate mission prompts only ${c.dim}(no edits)${c.reset}
     ${colors.accent}--apply${c.reset}               Apply patches returned by the model ${c.dim}(PRO tier)${c.reset}
-    ${colors.accent}--loop${c.reset}              Loop: fix → verify → fix until SHIP ${c.dim}(PRO tier)${c.reset}
+    ${colors.accent}--autopilot${c.reset}           Loop: fix → verify → fix until SHIP ${c.dim}(PRO tier)${c.reset}
     ${colors.accent}--share${c.reset}               Generate share bundle after fix ${c.dim}(PRO tier)${c.reset}
+
+  ${c.bold}Mission Selection:${c.reset}
+    ${colors.accent}--mission <id>${c.reset}        Run specific mission only (e.g., M_abc123)
     ${colors.accent}--max-missions <n>${c.reset}    Max missions to plan ${c.dim}(default: 8)${c.reset}
+
+  ${c.bold}Safety Gates (V2):${c.reset}
+    ${colors.accent}--force${c.reset}               Override safety gates for critical missions
+    ${colors.accent}--min-confidence <n>${c.reset}  Min confidence threshold ${c.dim}(default: 0.6)${c.reset}
+    ${colors.accent}--max-blast <n>${c.reset}       Max files per mission ${c.dim}(default: 10)${c.reset}
+    ${colors.accent}--allow-dirty${c.reset}         Allow uncommitted git changes
+    ${colors.accent}--run-tests${c.reset}           Run tests in post-flight gates
+
+  ${c.bold}Rollback & Checkpoints (V2):${c.reset}
+    ${colors.accent}--rollback <id>${c.reset}       Rollback a mission by ID
+    ${colors.accent}--list-checkpoints${c.reset}    List all checkpoints
+    ${colors.accent}--cleanup-checkpoints${c.reset} Clean up old checkpoints
+
+  ${c.bold}Autopilot Options:${c.reset}
     ${colors.accent}--max-steps <n>${c.reset}       Max autopilot steps ${c.dim}(default: 10)${c.reset}
     ${colors.accent}--stagnation-limit${c.reset}    Stop after N non-improving steps ${c.dim}(default: 2)${c.reset}
+
+  ${c.bold}Other Options:${c.reset}
     ${colors.accent}--fastify-entry${c.reset}       Fastify entry file ${c.dim}(e.g. src/server.ts)${c.reset}
     ${colors.accent}--path, -p${c.reset}            Project path ${c.dim}(default: current directory)${c.reset}
     ${colors.accent}--help, -h${c.reset}            Show this help