vibecheck-ai 2.0.2 → 5.0.0

package/bin/runners/runFix.js

@@ -0,0 +1,1355 @@
+/**
+ * vibecheck fix - Fix Missions v1
+ * 
+ * Generates surgical "mission prompts", runs them sequentially,
+ * applies patches (optional), and re-verifies by re-running ship.
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * ENTERPRISE EDITION - World-Class Terminal Experience
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * TIER ENFORCEMENT:
+ * - FREE/STARTER: --plan-only mode only
+ * - PRO: Full fix with --apply patches
+ * 
+ * Key features:
+ * - Reality Firewall prompt prevents LLM hallucinations
+ * - Patch validator ensures no drift
+ * - Backup/restore for safe rollback
+ * - Progress detector stops on stagnation
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+const { shipCore } = require('./runShip');
+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');
+const { generatePatchJson } = require('./lib/llm');
+const { applyUnifiedDiff } = require('./lib/patch');
+const { backupFiles, restoreBackup } = require('./lib/backup');
+const { validatePatchResponse, parseDiffTouchedFiles } = require('./lib/validate-patch');
+const { buildSharePack } = require('./lib/share-pack');
+const { parseGlobalFlags, shouldShowBanner } = require('./lib/global-flags');
+const { EXIT, verdictToExitCode } = require('./lib/exit-codes');
+
+// Entitlements enforcement
+const entitlements = require('./lib/entitlements-v2');
+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
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  blink: '\x1b[5m',
+  inverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  strike: '\x1b[9m',
+  // Colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  // Bright colors
+  gray: '\x1b[90m',
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+  // Background
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+  bgBrightBlack: '\x1b[100m',
+  bgBrightRed: '\x1b[101m',
+  bgBrightGreen: '\x1b[102m',
+  bgBrightYellow: '\x1b[103m',
+  // Cursor control
+  cursorUp: (n = 1) => `\x1b[${n}A`,
+  cursorDown: (n = 1) => `\x1b[${n}B`,
+  cursorRight: (n = 1) => `\x1b[${n}C`,
+  cursorLeft: (n = 1) => `\x1b[${n}D`,
+  clearLine: '\x1b[2K',
+  clearScreen: '\x1b[2J',
+  saveCursor: '\x1b[s',
+  restoreCursor: '\x1b[u',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+};
+
+// 256-color / True color support
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+const bgRgb = (r, g, b) => `\x1b[48;2;${r};${g};${b}m`;
+
+// Premium color palette
+const colors = {
+  // Gradients for banner
+  gradient1: rgb(255, 150, 50),    // Orange
+  gradient2: rgb(255, 120, 80),    // Coral
+  gradient3: rgb(255, 100, 100),   // Salmon
+  gradient4: rgb(255, 80, 120),    // Pink
+  gradient5: rgb(255, 60, 150),    // Hot pink
+  gradient6: rgb(200, 50, 200),    // Magenta
+  
+  // Status colors
+  shipGreen: rgb(0, 255, 150),
+  warnAmber: rgb(255, 200, 0),
+  blockRed: rgb(255, 80, 80),
+  
+  // UI colors
+  accent: rgb(255, 150, 50),
+  accentAlt: rgb(255, 180, 80),
+  muted: rgb(120, 120, 140),
+  subtle: rgb(80, 80, 100),
+  highlight: rgb(255, 255, 255),
+  
+  // Mission colors
+  mission: rgb(255, 150, 50),
+  prompt: rgb(100, 200, 255),
+  patch: rgb(150, 255, 150),
+  rollback: rgb(255, 150, 150),
+  
+  // Severity colors
+  critical: rgb(255, 60, 60),
+  high: rgb(255, 120, 60),
+  medium: rgb(255, 200, 60),
+  low: rgb(100, 200, 255),
+  info: rgb(150, 150, 180),
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PREMIUM BANNER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const FIX_BANNER = `
+${rgb(255, 150, 50)}  ███████╗██╗██╗  ██╗${c.reset}
+${rgb(255, 130, 70)}  ██╔════╝██║╚██╗██╔╝${c.reset}
+${rgb(255, 110, 90)}  █████╗  ██║ ╚███╔╝ ${c.reset}
+${rgb(255, 90, 110)}  ██╔══╝  ██║ ██╔██╗ ${c.reset}
+${rgb(255, 70, 130)}  ██║     ██║██╔╝ ██╗${c.reset}
+${rgb(255, 50, 150)}  ╚═╝     ╚═╝╚═╝  ╚═╝${c.reset}
+`;
+
+const BANNER_FULL = `
+${rgb(255, 150, 50)}  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗${c.reset}
+${rgb(255, 140, 60)}  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝${c.reset}
+${rgb(255, 130, 70)}  ██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝ ${c.reset}
+${rgb(255, 120, 80)}  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ ${c.reset}
+${rgb(255, 100, 100)}   ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗${c.reset}
+${rgb(255, 80, 120)}    ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝${c.reset}
+
+${c.dim}  ┌─────────────────────────────────────────────────────────────────────┐${c.reset}
+${c.dim}  │${c.reset}  ${rgb(255, 150, 50)}🔧${c.reset} ${c.bold}FIX${c.reset} ${c.dim}•${c.reset} ${rgb(200, 200, 200)}Mission Control${c.reset} ${c.dim}•${c.reset} ${rgb(150, 150, 150)}Reality Firewall${c.reset} ${c.dim}•${c.reset} ${rgb(100, 100, 100)}Auto Patch${c.reset}   ${c.dim}│${c.reset}
+${c.dim}  └─────────────────────────────────────────────────────────────────────┘${c.reset}
+`;
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TERMINAL UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const BOX = {
+  topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯',
+  horizontal: '─', vertical: '│',
+  teeRight: '├', teeLeft: '┤', teeDown: '┬', teeUp: '┴',
+  cross: '┼',
+  // Double line variants
+  dTopLeft: '╔', dTopRight: '╗', dBottomLeft: '╚', dBottomRight: '╝',
+  dHorizontal: '═', dVertical: '║',
+};
+
+const ICONS = {
+  wrench: '🔧',
+  check: '✓',
+  cross: '✗',
+  warning: '⚠',
+  error: '✗',
+  info: 'ℹ',
+  arrow: '→',
+  bullet: '•',
+  star: '★',
+  sparkle: '✨',
+  fire: '🔥',
+  lock: '🔐',
+  key: '🔑',
+  link: '🔗',
+  graph: '📊',
+  map: '🗺️',
+  doc: '📄',
+  folder: '📁',
+  clock: '⏱',
+  target: '🎯',
+  shield: '🛡️',
+  bug: '🐛',
+  lightning: '⚡',
+  package: '📦',
+  route: '🛤️',
+  env: '🌍',
+  auth: '🔒',
+  money: '💰',
+  ghost: '👻',
+  dead: '💀',
+  mission: '🎯',
+  prompt: '📝',
+  patch: '🩹',
+  rollback: '↩️',
+  ship: '🚀',
+  robot: '🤖',
+  brain: '🧠',
+  loop: '🔄',
+  stop: '🛑',
+  gear: '⚙️',
+  rocket: '🚀',
+};
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_DOTS = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+const SPINNER_GEARS = ['◐', '◓', '◑', '◒'];
+
+let spinnerIndex = 0;
+let spinnerInterval = null;
+let spinnerStartTime = null;
+
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+}
+
+function formatNumber(num) {
+  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+function truncate(str, len) {
+  if (!str) return '';
+  if (str.length <= len) return str;
+  return str.slice(0, len - 3) + '...';
+}
+
+function padCenter(str, width) {
+  const padding = Math.max(0, width - str.length);
+  const left = Math.floor(padding / 2);
+  const right = padding - left;
+  return ' '.repeat(left) + str + ' '.repeat(right);
+}
+
+function progressBar(percent, width = 30, opts = {}) {
+  const filled = Math.round((percent / 100) * width);
+  const empty = width - filled;
+  
+  let filledColor;
+  if (opts.color) {
+    filledColor = opts.color;
+  } else if (percent >= 80) {
+    filledColor = colors.shipGreen;
+  } else if (percent >= 50) {
+    filledColor = colors.warnAmber;
+  } else {
+    filledColor = colors.blockRed;
+  }
+  
+  const filledChar = opts.filled || '█';
+  const emptyChar = opts.empty || '░';
+  
+  return `${filledColor}${filledChar.repeat(filled)}${c.dim}${emptyChar.repeat(empty)}${c.reset}`;
+}
+
+function startSpinner(message, style = 'dots') {
+  const frames = style === 'gears' ? SPINNER_GEARS : 
+                 style === 'dots' ? SPINNER_DOTS : SPINNER_FRAMES;
+  spinnerStartTime = Date.now();
+  process.stdout.write(c.hideCursor);
+  
+  spinnerInterval = setInterval(() => {
+    const elapsed = formatDuration(Date.now() - spinnerStartTime);
+    process.stdout.write(`\r${c.clearLine}  ${colors.accent}${frames[spinnerIndex]}${c.reset} ${message} ${c.dim}${elapsed}${c.reset}`);
+    spinnerIndex = (spinnerIndex + 1) % frames.length;
+  }, 80);
+}
+
+function stopSpinner(message, success = true) {
+  if (spinnerInterval) {
+    clearInterval(spinnerInterval);
+    spinnerInterval = null;
+  }
+  const elapsed = spinnerStartTime ? formatDuration(Date.now() - spinnerStartTime) : '';
+  const icon = success ? `${colors.shipGreen}${ICONS.check}${c.reset}` : `${colors.blockRed}${ICONS.cross}${c.reset}`;
+  process.stdout.write(`\r${c.clearLine}  ${icon} ${message} ${c.dim}${elapsed}${c.reset}\n`);
+  process.stdout.write(c.showCursor);
+  spinnerStartTime = null;
+}
+
+function printBanner(compact = false) {
+  console.log(compact ? FIX_BANNER : BANNER_FULL);
+}
+
+function printDivider(char = '─', width = 69, color = c.dim) {
+  console.log(`${color}  ${char.repeat(width)}${c.reset}`);
+}
+
+function printSection(title, icon = '◆') {
+  console.log();
+  console.log(`  ${colors.accent}${icon}${c.reset} ${c.bold}${title}${c.reset}`);
+  printDivider();
+}
+
+function printSubSection(title) {
+  console.log();
+  console.log(`  ${c.dim}${BOX.teeRight}${BOX.horizontal}${c.reset} ${c.bold}${title}${c.reset}`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MISSION STATUS CARDS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getMissionIcon(missionType) {
+  const icons = {
+    'REMOVE_OWNER_MODE': ICONS.lock,
+    'FIX_STRIPE_WEBHOOKS': ICONS.money,
+    'ENFORCE_PAID_SURFACE': ICONS.shield,
+    'ADD_SERVER_AUTH': ICONS.auth,
+    'FIX_MISSING_ROUTE': ICONS.route,
+    'FIX_FAKE_SUCCESS': ICONS.ghost,
+    'FIX_ENV_CONTRACT': ICONS.env,
+    'FIX_DEAD_UI': ICONS.dead,
+    // New enhanced mission types
+    'FIX_EMPTY_CATCH': ICONS.bug,
+    'FIX_TEST_KEYS': ICONS.key,
+    'FIX_MOCK_DOMAINS': ICONS.link,
+    'FIX_PLACEHOLDER_DATA': ICONS.doc,
+    'FIX_HARDCODED_SECRETS': ICONS.lock,
+    'FIX_SIMULATED_BILLING': ICONS.money,
+    'FIX_SILENT_FALLBACK': ICONS.warning,
+    'SYNC_CONTRACTS': ICONS.graph,
+    'FIX_ROUTE_DRIFT': ICONS.route,
+    'FIX_AUTH_DRIFT': ICONS.shield,
+  };
+  return icons[missionType] || ICONS.mission;
+}
+
+function getMissionColor(missionType) {
+  const colorMap = {
+    'REMOVE_OWNER_MODE': colors.critical,
+    'FIX_STRIPE_WEBHOOKS': colors.high,
+    'ENFORCE_PAID_SURFACE': colors.high,
+    'ADD_SERVER_AUTH': colors.medium,
+    'FIX_MISSING_ROUTE': colors.medium,
+    'FIX_FAKE_SUCCESS': colors.medium,
+    'FIX_ENV_CONTRACT': colors.low,
+    'FIX_DEAD_UI': colors.low,
+    // New enhanced mission types
+    'FIX_EMPTY_CATCH': colors.high,
+    'FIX_TEST_KEYS': colors.critical,
+    'FIX_MOCK_DOMAINS': colors.critical,
+    'FIX_PLACEHOLDER_DATA': colors.medium,
+    'FIX_HARDCODED_SECRETS': colors.critical,
+    'FIX_SIMULATED_BILLING': colors.critical,
+    'FIX_SILENT_FALLBACK': colors.high,
+    'SYNC_CONTRACTS': colors.medium,
+    'FIX_ROUTE_DRIFT': colors.medium,
+    'FIX_AUTH_DRIFT': colors.critical,
+  };
+  return colorMap[missionType] || colors.accent;
+}
+
+function printMissionCard(mission, step, totalSteps, status = 'pending') {
+  const w = 66;
+  const icon = getMissionIcon(mission.type);
+  const missionColor = getMissionColor(mission.type);
+  
+  const statusConfig = {
+    pending: { icon: '○', color: c.dim, label: 'PENDING' },
+    running: { icon: '◐', color: colors.accent, label: 'RUNNING' },
+    success: { icon: '●', color: colors.shipGreen, label: 'SUCCESS' },
+    failed: { icon: '●', color: colors.blockRed, label: 'FAILED' },
+    skipped: { icon: '○', color: colors.warnAmber, label: 'SKIPPED' },
+    rollback: { icon: '↩', color: colors.rollback, label: 'ROLLBACK' },
+  };
+  
+  const s = statusConfig[status] || statusConfig.pending;
+  
+  console.log();
+  console.log(`  ${c.dim}${BOX.topLeft}${BOX.horizontal.repeat(w)}${BOX.topRight}${c.reset}`);
+  
+  // Header row
+  const stepLabel = `Step ${step}/${totalSteps}`;
+  const headerLeft = `${icon} ${mission.type}`;
+  const headerPadding = w - headerLeft.length - stepLabel.length - 4;
+  console.log(`  ${c.dim}${BOX.vertical}${c.reset} ${missionColor}${c.bold}${headerLeft}${c.reset}${' '.repeat(Math.max(1, headerPadding))}${c.dim}${stepLabel}${c.reset} ${c.dim}${BOX.vertical}${c.reset}`);
+  
+  // Status row
+  const statusLine = `${s.icon} ${s.label}`;
+  console.log(`  ${c.dim}${BOX.vertical}${c.reset} ${s.color}${statusLine}${c.reset}${' '.repeat(w - statusLine.length - 2)} ${c.dim}${BOX.vertical}${c.reset}`);
+  
+  // Title row
+  if (mission.title) {
+    const title = truncate(mission.title, w - 4);
+    console.log(`  ${c.dim}${BOX.vertical}${c.reset} ${title}${' '.repeat(w - title.length - 2)} ${c.dim}${BOX.vertical}${c.reset}`);
+  }
+  
+  console.log(`  ${c.dim}${BOX.bottomLeft}${BOX.horizontal.repeat(w)}${BOX.bottomRight}${c.reset}`);
+}
+
+function printMissionSummary(missions) {
+  printSection(`MISSION PLAN (${missions.length} missions)`, ICONS.target);
+  console.log();
+  
+  for (let i = 0; i < missions.length; i++) {
+    const m = missions[i];
+    const icon = getMissionIcon(m.type);
+    const color = getMissionColor(m.type);
+    const targets = m.targetFindingIds?.length || 0;
+    
+    console.log(`  ${color}${icon}${c.reset} ${c.bold}${i + 1}.${c.reset} ${m.type.padEnd(24)} ${c.dim}(${targets} finding${targets !== 1 ? 's' : ''})${c.reset}`);
+  }
+}
+
+function printLoopHeader(maxSteps, stagnationLimit) {
+  console.log();
+  console.log(`  ${bgRgb(80, 40, 20)}${c.bold} ${ICONS.loop} LOOP MODE ${c.reset}`);
+  console.log(`  ${c.dim}Max steps: ${maxSteps} • Stagnation limit: ${stagnationLimit}${c.reset}`);
+  console.log();
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function nowStamp() {
+  const d = new Date();
+  const z = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${z(d.getMonth()+1)}${z(d.getDate())}_${z(d.getHours())}${z(d.getMinutes())}${z(d.getSeconds())}`;
+}
+
+function truthpackSummary(truthpack) {
+  return {
+    routes: {
+      serverCount: truthpack?.routes?.server?.length || 0,
+      clientRefsCount: truthpack?.routes?.clientRefs?.length || 0,
+      gaps: truthpack?.routes?.gaps?.length || 0
+    },
+    env: {
+      used: truthpack?.env?.vars?.length || 0,
+      declared: truthpack?.env?.declared?.length || 0
+    },
+    auth: {
+      middlewareCount: truthpack?.auth?.nextMiddleware?.length || 0,
+      matcherCount: truthpack?.auth?.nextMatcherPatterns?.length || 0,
+      fastifySignals: truthpack?.auth?.fastify?.signalTypes || []
+    },
+    billing: truthpack?.billing?.summary || {},
+    enforcement: {
+      checked: truthpack?.enforcement?.checkedCount || 0,
+      missing: truthpack?.enforcement?.missingCount || 0
+    }
+  };
+}
+
+function score(findings) {
+  let s = 0;
+  for (const f of findings || []) s += (f.severity === "BLOCK" ? 10 : f.severity === "WARN" ? 3 : 0);
+  return s;
+}
+
+function allowedFilesForMission({ mission, targetFindings, truthpack }) {
+  const allow = new Set();
+
+  for (const f of targetFindings) {
+    for (const ev of (f.evidence || [])) {
+      if (ev.file) allow.add(ev.file);
+    }
+  }
+
+  const type = mission?.type;
+  if (type === "FIX_ENV_CONTRACT") {
+    [".env.example",".env.template",".env.sample",".env"].forEach(p => allow.add(p));
+  }
+  if (type === "ADD_SERVER_AUTH") {
+    (truthpack?.auth?.nextMiddleware || []).forEach(mw => mw.file && allow.add(mw.file));
+  }
+  if (type === "FIX_STRIPE_WEBHOOKS") {
+    (truthpack?.billing?.webhookCandidates || []).forEach(w => w.file && allow.add(w.file));
+  }
+  if (type === "ENFORCE_PAID_SURFACE") {
+    (truthpack?.enforcement?.checks || []).forEach(c => c.handler && allow.add(c.handler));
+  }
+
+  return Array.from(allow).filter(Boolean);
+}
+
+async function runFix(args) {
+  const opts = parseArgs(args);
+  const startTime = Date.now();
+  
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  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) {
+    const access = await entitlements.enforce("fix.apply_patches", {
+      projectPath: root,
+      silent: false,
+    });
+    
+    if (!access.allowed) {
+      console.log();
+      console.log(`  ${colors.warnAmber}${ICONS.warning}${c.reset} ${c.bold}Feature requires upgrade${c.reset}`);
+      console.log(`  ${c.dim}Tip: Run ${colors.accent}vibecheck fix --prompt-only${c.reset}${c.dim} to generate fix prompts (FREE)${c.reset}`);
+      console.log();
+      return entitlements.EXIT_FEATURE_NOT_ALLOWED;
+    }
+  }
+  
+  const outDir = path.join(root, ".vibecheck", "missions", nowStamp());
+  ensureDir(outDir);
+
+  // First ship check
+  startSpinner('Analyzing codebase...', 'gears');
+  const first = await shipCore({ repoRoot: root, fastifyEntry: opts.fastifyEntry, noWrite: false });
+  stopSpinner('Codebase analyzed', true);
+
+  if (first.verdict === "SHIP") {
+    // Mission Control output
+    if (!opts.json && !opts.quiet) {
+      console.log(formatFixOutput({
+        missions: [],
+        verdict: first.verdict,
+        beforeVerdict: first.verdict,
+        afterVerdict: first.verdict,
+        appliedMissions: 0,
+        totalMissions: 0,
+        duration: 0,
+        success: true,
+      }, { apply: opts.apply, promptOnly: opts.promptOnly, loop: opts.loop || opts.autopilot }));
+    }
+    return 0;
+  }
+
+  // Plan missions with enhanced options
+  startSpinner('Planning fix missions...', 'gears');
+  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(targetMissions);
+  console.log();
+  console.log(`  ${c.dim}${ICONS.folder} Mission pack: ${colors.accent}${path.relative(root, outDir)}${c.reset}`);
+  console.log();
+
+  if (!opts.loop && !opts.promptOnly && !opts.apply) {
+    printSection('NEXT STEPS', ICONS.arrow);
+    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 LLM prompts, no edits ${c.green}(FREE)${c.reset}${c.dim}${c.reset}`);
+    console.log();
+    
+    // Check if apply features are available
+    const applyAccess = await entitlements.checkCommand("fix.apply_patches", { projectPath: root });
+    if (applyAccess.allowed) {
+      console.log(`  ${colors.patch}${ICONS.patch}${c.reset} ${c.bold}vibecheck fix --apply${c.reset}`);
+      console.log(`     ${c.dim}Apply patches from LLM ${c.green}(PRO)${c.reset}${c.dim}${c.reset}`);
+      console.log();
+      console.log(`  ${colors.mission}${ICONS.robot}${c.reset} ${c.bold}vibecheck fix --autopilot --apply${c.reset}`);
+      console.log(`     ${c.dim}Loop until SHIP or stuck ${c.green}(PRO)${c.reset}${c.dim}${c.reset}`);
+      console.log();
+    } else {
+      console.log(`  ${c.dim}${ICONS.lock}${c.reset} ${c.dim}vibecheck fix --apply${c.reset} ${c.dim}(PRO tier required)${c.reset}`);
+      console.log(`     ${c.dim}Automatically apply LLM-generated patches${c.reset}`);
+      console.log();
+      console.log(`  ${c.dim}${ICONS.lock}${c.reset} ${c.dim}vibecheck fix --loop --apply${c.reset} ${c.dim}(PRO tier required)${c.reset}`);
+      console.log(`     ${c.dim}Automated fix loop until SHIP${c.reset}`);
+      console.log();
+      console.log(upsell.formatEarnedUpsell({
+        cmd: "fix",
+        withheldArtifact: "apply",
+        upgradeTier: applyAccess.requiredTier || "pro",
+        why: "Apply patches automatically",
+      }));
+    }
+    
+    return 0;
+  }
+
+  let stagnant = 0;
+  const maxSteps = opts.maxSteps || 10;
+  const stagnationLimit = opts.stagnationLimit || 2;
+
+  // Show autopilot header if in autopilot mode
+  if (opts.autopilot) {
+    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 });
+
+    if (before.verdict === "SHIP") {
+      const duration = Date.now() - startTime;
+      
+      // Generate share bundle if requested
+      if (opts.share) {
+        try {
+          startSpinner('Generating share bundle...', 'dots');
+          const shareResult = buildSharePack({ repoRoot: root, missionDirAbs: outDir });
+          stopSpinner('Share bundle generated', true);
+        } catch (e) {
+          stopSpinner('Share bundle failed', false);
+        }
+      }
+      
+      // Mission Control output
+      if (!opts.json && !opts.quiet) {
+        console.log(formatFixOutput({
+          missions: targetMissions,
+          verdict: before.verdict,
+          beforeVerdict: first.verdict,
+          afterVerdict: before.verdict,
+          appliedMissions: step - 1,
+          totalMissions: targetMissions.length,
+          duration,
+          success: true,
+        }, { apply: opts.apply, promptOnly: opts.promptOnly, loop: opts.loop || opts.autopilot }));
+      }
+      
+      return 0;
+    }
+
+    const ids = new Set(before.report.findings.map(f => f.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();
+      console.log(`  ${colors.warnAmber}${ICONS.warning}${c.reset} No remaining planned mission matches current findings.`);
+      console.log(`  ${c.dim}All planned missions completed or findings resolved.${c.reset}`);
+      console.log();
+      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`),
+      JSON.stringify(before.report, null, 2),
+      "utf8"
+    );
+
+    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');
+    
+    // Use mission template + auto-expanded evidence
+    const template = templateForMissionType(mission.type);
+    const expanded = await expandEvidence({
+      repoRoot: root,
+      truthpack: before.truthpack,
+      mission,
+      targetFindings
+    });
+    const allowedFiles = expanded.allowedFiles;
+    const snippets = expanded.snippets;
+
+    const prompt = buildRealityFirewall({
+      truthpackSummary: truthpackSummary(before.truthpack),
+      mission,
+      template,
+      findings: targetFindings,
+      fileSnippets: snippets,
+      allowedFiles
+    });
+
+    const promptPath = path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_prompt.txt`);
+    fs.writeFileSync(promptPath, prompt, "utf8");
+
+    console.log(`  ${ICONS.prompt} Prompt: ${c.dim}${path.relative(root, promptPath)}${c.reset}`);
+
+    if (opts.promptOnly) {
+      console.log(`  ${colors.shipGreen}${ICONS.check}${c.reset} Prompt generated`);
+      if (!opts.loop) return 0;
+      continue;
+    }
+
+    // Generate patch via LLM
+    startSpinner('Generating patch via LLM...', 'dots');
+    let patchJson;
+    try {
+      patchJson = await generatePatchJson(prompt);
+      stopSpinner('Patch generated', true);
+    } catch (e) {
+      stopSpinner('LLM failed', false);
+      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} ${e.message}`);
+      return EXIT.INTERNAL_ERROR;
+    }
+
+    const respPath = path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_response.json`);
+    fs.writeFileSync(respPath, JSON.stringify(patchJson, null, 2), "utf8");
+
+    // Validate patch
+    const v = validatePatchResponse({
+      repoRoot: root,
+      patchJson,
+      mission,
+      truthpack: before.truthpack,
+      allowedFiles,
+      limits: { maxEdits: 6, maxFiles: 6, maxChangedLines: 400 }
+    });
+
+    if (!v.ok) {
+      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} Patch rejected by validator`);
+      for (const e of v.errors) {
+        console.log(`    ${c.dim}${ICONS.bullet}${c.reset} ${e}`);
+      }
+      if (v.warnings.length) {
+        for (const w of v.warnings) {
+          console.log(`    ${colors.warnAmber}${ICONS.warning}${c.reset} ${w}`);
+        }
+      }
+      return EXIT.BLOCKING;
+    }
+
+    if (v.warnings.length) {
+      for (const w of v.warnings) {
+        console.log(`  ${colors.warnAmber}${ICONS.warning}${c.reset} ${w}`);
+      }
+    }
+
+    if (!opts.apply) {
+      console.log(`  ${colors.shipGreen}${ICONS.check}${c.reset} Patch generated (not applied)`);
+      console.log(`  ${c.dim}Re-run with --apply to apply diffs${c.reset}`);
+      return 0;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // 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);
+
+    // 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}`);
+        applyFailed = true;
+        break;
+      }
+      console.log(`  ${colors.patch}${ICONS.patch}${c.reset} Applied: ${c.dim}${ed.path}${c.reset}`);
+    }
+
+    // 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 });
+    
+    const verdictColor = after.verdict === 'SHIP' ? colors.shipGreen : 
+                         after.verdict === 'WARN' ? colors.warnAmber : colors.blockRed;
+    stopSpinner(`Verdict: ${after.verdict}`, after.verdict === 'SHIP');
+    console.log(`  ${verdictColor}${ICONS.bullet}${c.reset} ${after.verdict}`);
+
+    // Save after proof
+    fs.writeFileSync(
+      path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_after_ship.json`),
+      JSON.stringify(after.report, null, 2),
+      "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 = targetFindingIds.some(id => after.report.findings.some(f => f.id === id));
+    const improved = (afterScore < beforeScore) || (!targetStillThere) || postFlightResults.ok;
+
+    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) {
+      audit.info('fix_session_end', { 
+        sessionId, 
+        duration: Date.now() - startTime,
+        result: 'success_single_mission',
+      });
+      return 0;
+    }
+  }
+
+  // Max steps reached
+  const duration = Date.now() - startTime;
+  const lastShip = await shipCore({ repoRoot: root, fastifyEntry: opts.fastifyEntry, noWrite: false });
+  
+  // Generate share bundle if requested
+  if (opts.share) {
+    try {
+      startSpinner('Generating share bundle...', 'dots');
+      const shareResult = buildSharePack({ repoRoot: root, missionDirAbs: outDir });
+      stopSpinner('Share bundle generated', true);
+    } catch (e) {
+      stopSpinner('Share bundle failed', false);
+    }
+  }
+  
+  // Mission Control output
+  if (!opts.json && !opts.quiet) {
+    console.log(formatFixOutput({
+      missions: targetMissions,
+      verdict: lastShip.verdict,
+      beforeVerdict: first.verdict,
+      afterVerdict: lastShip.verdict,
+      appliedMissions: maxSteps,
+      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
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// NOTE: Legacy rule-based fix functions (showFixPlan, applyFixes, etc.) were removed.
+// The fix command now uses the mission-based system exclusively, which provides:
+// - LLM-generated patches with Reality Firewall prompt
+// - Automatic backup/restore on failure
+// - Progress detection and stagnation handling
+// - Integration with ship verification
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  // Parse global flags first
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
+  
+  const opts = {
+    ...globalFlags, // Merge global flags (json, verbose, noBanner, quiet, ci, help, etc.)
+    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
+  };
+
+  // Parse command-specific args from cleanArgs
+  for (let i = 0; i < cleanArgs.length; i++) {
+    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;
+    else if (arg === '--max-steps') opts.maxSteps = Number(cleanArgs[++i]) || 10;
+    else if (arg === '--stagnation-limit') opts.stagnationLimit = Number(cleanArgs[++i]) || 2;
+    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;
+}
+
+function printHelp(showBanner = true) {
+  if (showBanner && shouldShowBanner({})) {
+    console.log(BANNER_FULL);
+  }
+  console.log(`
+  ${c.bold}Usage:${c.reset} vibecheck fix (f) [options]
+
+  ${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 --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 --autopilot --apply${c.reset}  ${c.dim}Loop until SHIP or stuck ${c.yellow}(PRO)${c.reset}${c.dim}${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}--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
+
+  ${c.bold}Safety Features:${c.reset}
+    ${colors.shipGreen}${ICONS.shield}${c.reset} Reality Firewall prompt prevents LLM hallucinations
+    ${colors.shipGreen}${ICONS.check}${c.reset} Patch validator ensures no drift (files, routes, env)
+    ${colors.shipGreen}${ICONS.rollback}${c.reset} Backup/restore for automatic rollback on failure
+    ${colors.shipGreen}${ICONS.stop}${c.reset} Progress detector stops on stagnation
+
+  ${c.bold}Mission Types:${c.reset}
+    ${c.dim}Security & Auth:${c.reset}
+    ${colors.critical}${ICONS.lock}${c.reset} REMOVE_OWNER_MODE      ${c.dim}Delete backdoor env bypass${c.reset}
+    ${colors.critical}${ICONS.lock}${c.reset} FIX_HARDCODED_SECRETS  ${c.dim}Move secrets to env vars${c.reset}
+    ${colors.critical}${ICONS.key}${c.reset} FIX_TEST_KEYS          ${c.dim}Replace test API keys${c.reset}
+    ${colors.critical}${ICONS.shield}${c.reset} FIX_AUTH_DRIFT         ${c.dim}Restore removed auth patterns${c.reset}
+    ${colors.medium}${ICONS.auth}${c.reset} ADD_SERVER_AUTH        ${c.dim}Add auth to sensitive endpoints${c.reset}
+
+    ${c.dim}Billing & Payments:${c.reset}
+    ${colors.high}${ICONS.money}${c.reset} FIX_STRIPE_WEBHOOKS    ${c.dim}Add signature verification + idempotency${c.reset}
+    ${colors.high}${ICONS.shield}${c.reset} ENFORCE_PAID_SURFACE   ${c.dim}Add server-side entitlement checks${c.reset}
+    ${colors.critical}${ICONS.money}${c.reset} FIX_SIMULATED_BILLING  ${c.dim}Replace fake billing with real${c.reset}
+
+    ${c.dim}Reality & Data:${c.reset}
+    ${colors.critical}${ICONS.link}${c.reset} FIX_MOCK_DOMAINS       ${c.dim}Replace localhost/mock URLs${c.reset}
+    ${colors.medium}${ICONS.ghost}${c.reset} FIX_FAKE_SUCCESS       ${c.dim}Gate success UI on network result${c.reset}
+    ${colors.medium}${ICONS.doc}${c.reset} FIX_PLACEHOLDER_DATA   ${c.dim}Replace lorem ipsum with real data${c.reset}
+    ${colors.high}${ICONS.warning}${c.reset} FIX_SILENT_FALLBACK    ${c.dim}Make failures visible${c.reset}
+
+    ${c.dim}Code Quality:${c.reset}
+    ${colors.high}${ICONS.bug}${c.reset} FIX_EMPTY_CATCH        ${c.dim}Add error handling to catch blocks${c.reset}
+    ${colors.medium}${ICONS.route}${c.reset} FIX_MISSING_ROUTE      ${c.dim}Wire client refs to server routes${c.reset}
+    ${colors.low}${ICONS.env}${c.reset} FIX_ENV_CONTRACT       ${c.dim}Add missing env vars to templates${c.reset}
+    ${colors.low}${ICONS.dead}${c.reset} FIX_DEAD_UI            ${c.dim}Make UI actions functional${c.reset}
+
+  ${c.bold}LLM Configuration:${c.reset}
+    ${c.dim}Set these environment variables:${c.reset}
+    ${colors.accent}VIBECHECK_LLM_BASE_URL${c.reset}  ${c.dim}API endpoint${c.reset}
+    ${colors.accent}VIBECHECK_LLM_API_KEY${c.reset}   ${c.dim}Your API key${c.reset}
+    ${colors.accent}VIBECHECK_LLM_MODEL${c.reset}     ${c.dim}Model name (default: gpt-4.1-mini)${c.reset}
+
+  ${c.bold}Exit Codes:${c.reset}
+    ${colors.shipGreen}0${c.reset}  SHIP achieved or no fixes needed
+    ${colors.warnAmber}1${c.reset}  Fix failed or stagnation limit reached
+    ${colors.blockRed}2${c.reset}  Configuration or validation error
+
+  ${c.bold}Examples:${c.reset}
+    ${c.dim}# Plan missions (see what would be fixed)${c.reset}
+    vibecheck fix
+
+    ${c.dim}# Generate prompts for manual LLM use${c.reset}
+    vibecheck fix --prompt-only
+
+    ${c.dim}# Full loop with share bundle (PRO tier)${c.reset}
+    vibecheck fix --loop --apply --share
+  `);
+}
+
+module.exports = { runFix };