vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/runProve.js

@@ -0,0 +1,1411 @@
+/**
+ * vibecheck prove - One Command Reality Proof
+ *
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * ENTERPRISE EDITION - World-Class Terminal Experience
+ * ═══════════════════════════════════════════════════════════════════════════════
+ *
+ * Orchestrates the complete "make it real" loop:
+ * 1. ctx - Refresh truthpack
+ * 2. reality --verify-auth - Runtime proof
+ * 3. ship - Static + runtime verdict
+ * 4. If BLOCK: fix --loop --apply
+ * 5. Re-run reality + ship to confirm SHIP
+ *
+ * One command = one outcome: either it's real, or it keeps fixing until it is.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { buildTruthpackSmart, writeTruthpack, detectFastifyEntry } = require("./lib/truth");
+const { shipCore } = require("./runShip");
+const { findContractDrift, loadContracts, hasContracts, getDriftSummary } = require("./lib/drift");
+const { 
+  generateRunId, 
+  createJsonOutput, 
+  writeJsonOutput, 
+  saveArtifact 
+} = require("./lib/cli-output");
+const { EXIT, verdictToExitCode, exitCodeToVerdict } = require("./lib/exit-codes");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const upsell = require("./lib/upsell");
+
+let runReality;
+try {
+  runReality = require("./runReality").runReality;
+} catch {
+  runReality = null;
+}
+
+let runFixCore;
+try {
+  runFixCore = require("./runFix").runFixCore;
+} catch {
+  runFixCore = null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 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',
+  // 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',
+};
+
+// 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 = {
+  // Gradient for banner (purple/magenta theme for "prove")
+  gradient1: rgb(180, 100, 255),   // Light purple
+  gradient2: rgb(150, 80, 255),    // Purple
+  gradient3: rgb(120, 60, 255),    // Deep purple
+  gradient4: rgb(100, 50, 220),    // Blue-purple
+  gradient5: rgb(80, 40, 200),     // Dark purple
+  gradient6: rgb(60, 30, 180),     // Deepest
+  
+  // Accent colors
+  science: rgb(180, 100, 255),     // Scientific purple
+  reality: rgb(255, 150, 100),     // Reality orange
+  truth: rgb(100, 200, 255),       // Truth blue
+  fix: rgb(100, 255, 200),         // Fix green
+  
+  // Verdict colors
+  shipGreen: rgb(0, 255, 150),
+  warnAmber: rgb(255, 200, 0),
+  blockRed: rgb(255, 80, 80),
+  
+  // UI colors
+  accent: rgb(180, 130, 255),
+  muted: rgb(120, 100, 140),
+  subtle: rgb(80, 70, 100),
+  highlight: rgb(255, 255, 255),
+  
+  // Step colors
+  step1: rgb(100, 200, 255),   // Context - blue
+  step2: rgb(255, 150, 100),   // Reality - orange
+  step3: rgb(0, 255, 150),     // Ship - green
+  step4: rgb(255, 200, 100),   // Fix - yellow
+  step5: rgb(180, 100, 255),   // Verify - purple
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PREMIUM BANNER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const PROVE_BANNER = `
+${rgb(200, 120, 255)}  ██████╗ ██████╗  ██████╗ ██╗   ██╗███████╗${c.reset}
+${rgb(180, 100, 255)}  ██╔══██╗██╔══██╗██╔═══██╗██║   ██║██╔════╝${c.reset}
+${rgb(160, 80, 255)}  ██████╔╝██████╔╝██║   ██║██║   ██║█████╗  ${c.reset}
+${rgb(140, 60, 255)}  ██╔═══╝ ██╔══██╗██║   ██║╚██╗ ██╔╝██╔══╝  ${c.reset}
+${rgb(120, 40, 255)}  ██║     ██║  ██║╚██████╔╝ ╚████╔╝ ███████╗${c.reset}
+${rgb(100, 20, 255)}  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   ╚═══╝  ╚══════╝${c.reset}
+`;
+
+const BANNER_FULL = `
+${rgb(200, 120, 255)}  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗${c.reset}
+${rgb(180, 100, 255)}  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝${c.reset}
+${rgb(160, 80, 255)}  ██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝ ${c.reset}
+${rgb(140, 60, 255)}  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ ${c.reset}
+${rgb(120, 40, 255)}   ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗${c.reset}
+${rgb(100, 20, 255)}    ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝${c.reset}
+
+${c.dim}  ┌─────────────────────────────────────────────────────────────────────┐${c.reset}
+${c.dim}  │${c.reset}  ${rgb(180, 100, 255)}🔬${c.reset} ${c.bold}PROVE${c.reset} ${c.dim}•${c.reset} ${rgb(200, 200, 200)}One Command${c.reset} ${c.dim}•${c.reset} ${rgb(150, 150, 150)}Reality Proof${c.reset} ${c.dim}•${c.reset} ${rgb(100, 100, 100)}Make It Real${c.reset}      ${c.dim}│${c.reset}
+${c.dim}  └─────────────────────────────────────────────────────────────────────┘${c.reset}
+`;
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ICONS & SYMBOLS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const ICONS = {
+  // Steps
+  context: '📋',
+  reality: '🎭',
+  ship: '🚀',
+  fix: '🔧',
+  verify: '✅',
+  prove: '🔬',
+  
+  // Status
+  check: '✓',
+  cross: '✗',
+  warning: '⚠',
+  info: 'ℹ',
+  arrow: '→',
+  bullet: '•',
+  
+  // Actions
+  running: '▶',
+  complete: '●',
+  pending: '○',
+  skip: '◌',
+  
+  // Objects
+  route: '🛤️',
+  env: '🌍',
+  auth: '🔒',
+  clock: '⏱',
+  target: '🎯',
+  lightning: '⚡',
+  loop: '🔄',
+  doc: '📄',
+  folder: '📁',
+  graph: '📊',
+  
+  // Misc
+  sparkle: '✨',
+  fire: '🔥',
+  star: '★',
+  microscope: '🔬',
+  beaker: '🧪',
+  dna: '🧬',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BOX DRAWING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const BOX = {
+  topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯',
+  horizontal: '─', vertical: '│',
+  teeRight: '├', teeLeft: '┤', teeDown: '┬', teeUp: '┴',
+  cross: '┼',
+  // Double line
+  dTopLeft: '╔', dTopRight: '╗', dBottomLeft: '╚', dBottomRight: '╝',
+  dHorizontal: '═', dVertical: '║',
+  // Heavy
+  hTopLeft: '┏', hTopRight: '┓', hBottomLeft: '┗', hBottomRight: '┛',
+  hHorizontal: '━', hVertical: '┃',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SPINNER & PROGRESS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_DOTS = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+const SPINNER_DNA = ['🧬', '🔬', '🧪', '⚗️', '🧫', '🔭'];
+
+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`;
+  const mins = Math.floor(ms / 60000);
+  const secs = Math.floor((ms % 60000) / 1000);
+  return `${mins}m ${secs}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, color = colors.science) {
+  spinnerStartTime = Date.now();
+  process.stdout.write(c.hideCursor);
+  
+  spinnerInterval = setInterval(() => {
+    const elapsed = formatDuration(Date.now() - spinnerStartTime);
+    process.stdout.write(`\r${c.clearLine}  ${color}${SPINNER_DOTS[spinnerIndex]}${c.reset} ${message} ${c.dim}${elapsed}${c.reset}`);
+    spinnerIndex = (spinnerIndex + 1) % SPINNER_DOTS.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 updateSpinner(message) {
+  if (spinnerInterval) {
+    // Just update the message, spinner keeps running
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SECTION HEADERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printBanner() {
+  console.log(BANNER_FULL);
+}
+
+function printCompactBanner() {
+  console.log(PROVE_BANNER);
+}
+
+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();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STEP DISPLAY - THE PROVE PIPELINE VISUALIZATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getStepConfig(stepNum) {
+  const configs = {
+    1: { icon: ICONS.context, name: 'CONTEXT', color: colors.step1, desc: 'Refresh truthpack' },
+    2: { icon: ICONS.reality, name: 'REALITY', color: colors.step2, desc: 'Runtime UI proof' },
+    3: { icon: ICONS.ship, name: 'SHIP', color: colors.step3, desc: 'Static verdict' },
+    4: { icon: ICONS.fix, name: 'FIX', color: colors.step4, desc: 'Auto-fix loop' },
+    5: { icon: ICONS.verify, name: 'VERIFY', color: colors.step5, desc: 'Final verification' },
+  };
+  return configs[stepNum] || { icon: ICONS.bullet, name: `STEP ${stepNum}`, color: colors.accent, desc: '' };
+}
+
+function printStepHeader(stepNum, subtitle = null) {
+  const config = getStepConfig(stepNum);
+  
+  console.log();
+  console.log(`  ${config.color}${BOX.hTopLeft}${BOX.hHorizontal.repeat(3)}${c.reset} ${config.icon} ${c.bold}Step ${stepNum}: ${config.name}${c.reset}`);
+  
+  if (subtitle) {
+    console.log(`  ${config.color}${BOX.hVertical}${c.reset}   ${c.dim}${subtitle}${c.reset}`);
+  } else {
+    console.log(`  ${config.color}${BOX.hVertical}${c.reset}   ${c.dim}${config.desc}${c.reset}`);
+  }
+  
+  console.log(`  ${config.color}${BOX.hBottomLeft}${BOX.hHorizontal.repeat(66)}${c.reset}`);
+}
+
+function printStepResult(stepNum, status, details = {}) {
+  const config = getStepConfig(stepNum);
+  
+  let statusIcon, statusColor, statusText;
+  
+  switch (status) {
+    case 'ok':
+    case 'SHIP':
+    case 'CLEAN':
+      statusIcon = ICONS.check;
+      statusColor = colors.shipGreen;
+      statusText = status === 'SHIP' ? 'SHIP' : status === 'CLEAN' ? 'CLEAN' : 'Complete';
+      break;
+    case 'WARN':
+      statusIcon = ICONS.warning;
+      statusColor = colors.warnAmber;
+      statusText = 'WARN';
+      break;
+    case 'BLOCK':
+    case 'error':
+      statusIcon = ICONS.cross;
+      statusColor = colors.blockRed;
+      statusText = status === 'BLOCK' ? 'BLOCK' : 'Failed';
+      break;
+    case 'skipped':
+      statusIcon = ICONS.skip;
+      statusColor = colors.muted;
+      statusText = 'Skipped';
+      break;
+    default:
+      statusIcon = ICONS.info;
+      statusColor = colors.accent;
+      statusText = status;
+  }
+  
+  let resultLine = `  ${statusColor}${statusIcon}${c.reset} ${c.bold}${statusText}${c.reset}`;
+  
+  // Add details
+  const detailParts = [];
+  if (details.routes !== undefined) detailParts.push(`${details.routes} routes`);
+  if (details.envVars !== undefined) detailParts.push(`${details.envVars} env vars`);
+  if (details.findings !== undefined) {
+    if (typeof details.findings === 'object') {
+      detailParts.push(`${details.findings.BLOCK || 0} blockers, ${details.findings.WARN || 0} warnings`);
+    } else {
+      detailParts.push(`${details.findings} findings`);
+    }
+  }
+  if (details.coverage !== undefined && details.coverage !== null) {
+    detailParts.push(`${details.coverage}% coverage`);
+  }
+  if (details.pagesVisited !== undefined) detailParts.push(`${details.pagesVisited} pages`);
+  if (details.reason) detailParts.push(details.reason);
+  if (details.error) detailParts.push(`error: ${truncate(details.error, 40)}`);
+  
+  if (detailParts.length > 0) {
+    resultLine += ` ${c.dim}(${detailParts.join(', ')})${c.reset}`;
+  }
+  
+  console.log(resultLine);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PIPELINE PROGRESS VISUALIZATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printPipelineOverview(steps = []) {
+  console.log();
+  console.log(`  ${c.dim}Pipeline:${c.reset}`);
+  
+  let pipeline = '  ';
+  const stepConfigs = [1, 2, 3, 4, 5].map(n => getStepConfig(n));
+  
+  for (let i = 0; i < stepConfigs.length; i++) {
+    const step = stepConfigs[i];
+    const stepStatus = steps[i];
+    
+    let color = colors.muted;
+    let icon = ICONS.pending;
+    
+    if (stepStatus === 'complete') {
+      color = colors.shipGreen;
+      icon = ICONS.complete;
+    } else if (stepStatus === 'running') {
+      color = step.color;
+      icon = ICONS.running;
+    } else if (stepStatus === 'error') {
+      color = colors.blockRed;
+      icon = ICONS.cross;
+    } else if (stepStatus === 'skipped') {
+      color = colors.muted;
+      icon = ICONS.skip;
+    }
+    
+    pipeline += `${color}${icon}${c.reset}`;
+    
+    if (i < stepConfigs.length - 1) {
+      const connectorColor = stepStatus === 'complete' ? colors.shipGreen : colors.muted;
+      pipeline += `${connectorColor}───${c.reset}`;
+    }
+  }
+  
+  console.log(pipeline);
+  
+  // Labels
+  let labels = '  ';
+  for (let i = 0; i < stepConfigs.length; i++) {
+    const step = stepConfigs[i];
+    labels += `${c.dim}${step.name.slice(0, 3)}${c.reset}`;
+    if (i < stepConfigs.length - 1) {
+      labels += '   ';
+    }
+  }
+  console.log(labels);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FIX LOOP VISUALIZATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printFixLoopHeader(round, maxRounds) {
+  const progress = Math.round((round / maxRounds) * 100);
+  
+  console.log();
+  console.log(`  ${colors.step4}${BOX.topLeft}${BOX.horizontal.repeat(3)}${c.reset} ${ICONS.loop} ${c.bold}Fix Round ${round}/${maxRounds}${c.reset}`);
+  console.log(`  ${colors.step4}${BOX.vertical}${c.reset}   ${progressBar(progress, 20, { color: colors.step4 })} ${c.dim}${progress}%${c.reset}`);
+  console.log(`  ${colors.step4}${BOX.bottomLeft}${BOX.horizontal.repeat(50)}${c.reset}`);
+}
+
+function printMissionStatus(mission, status, detail = null) {
+  let icon, color;
+  
+  switch (status) {
+    case 'planning':
+      icon = ICONS.target;
+      color = colors.accent;
+      break;
+    case 'applying':
+      icon = ICONS.lightning;
+      color = colors.step4;
+      break;
+    case 'success':
+      icon = ICONS.check;
+      color = colors.shipGreen;
+      break;
+    case 'failed':
+      icon = ICONS.cross;
+      color = colors.blockRed;
+      break;
+    case 'skipped':
+      icon = ICONS.skip;
+      color = colors.muted;
+      break;
+    default:
+      icon = ICONS.bullet;
+      color = colors.muted;
+  }
+  
+  let line = `    ${color}${icon}${c.reset} ${truncate(mission.title || mission, 50)}`;
+  if (detail) {
+    line += ` ${c.dim}${detail}${c.reset}`;
+  }
+  console.log(line);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FINAL VERDICT DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getVerdictConfig(verdict) {
+  if (verdict === 'SHIP') {
+    return {
+      icon: '🚀',
+      headline: 'PROVED REAL',
+      tagline: 'Your app is verified and ready to ship!',
+      color: colors.shipGreen,
+      bgColor: bgRgb(0, 80, 50),
+      borderColor: rgb(0, 200, 120),
+    };
+  }
+  
+  if (verdict === 'WARN') {
+    return {
+      icon: '⚠️',
+      headline: 'PARTIALLY PROVED',
+      tagline: 'Some warnings remain - review before shipping',
+      color: colors.warnAmber,
+      bgColor: bgRgb(80, 60, 0),
+      borderColor: rgb(200, 160, 0),
+    };
+  }
+  
+  return {
+    icon: '🛑',
+    headline: 'NOT PROVED',
+    tagline: 'Blockers remain - cannot verify readiness',
+    color: colors.blockRed,
+    bgColor: bgRgb(80, 20, 20),
+    borderColor: rgb(200, 60, 60),
+  };
+}
+
+function printFinalVerdict(verdict, duration, fixRounds, findings) {
+  const config = getVerdictConfig(verdict);
+  const w = 68;
+  
+  console.log();
+  console.log();
+  
+  // Top border
+  console.log(`  ${config.borderColor}${BOX.dTopLeft}${BOX.dHorizontal.repeat(w)}${BOX.dTopRight}${c.reset}`);
+  
+  // Empty line
+  console.log(`  ${config.borderColor}${BOX.dVertical}${c.reset}${' '.repeat(w)}${config.borderColor}${BOX.dVertical}${c.reset}`);
+  
+  // Icon and headline
+  const headlineText = `${config.icon}  ${config.headline}`;
+  const headlinePadded = padCenter(headlineText, w);
+  console.log(`  ${config.borderColor}${BOX.dVertical}${c.reset}${config.color}${c.bold}${headlinePadded}${c.reset}${config.borderColor}${BOX.dVertical}${c.reset}`);
+  
+  // Tagline
+  const taglinePadded = padCenter(config.tagline, w);
+  console.log(`  ${config.borderColor}${BOX.dVertical}${c.reset}${c.dim}${taglinePadded}${c.reset}${config.borderColor}${BOX.dVertical}${c.reset}`);
+  
+  // Empty line
+  console.log(`  ${config.borderColor}${BOX.dVertical}${c.reset}${' '.repeat(w)}${config.borderColor}${BOX.dVertical}${c.reset}`);
+  
+  // Stats row
+  const stats = `Duration: ${c.bold}${duration}${c.reset}  ${c.dim}•${c.reset}  Fix Rounds: ${c.bold}${fixRounds}${c.reset}  ${c.dim}•${c.reset}  Findings: ${c.bold}${findings}${c.reset}`;
+  const statsPadded = padCenter(stats.replace(/\x1b\[[0-9;]*m/g, '').length < w ? stats : stats, w);
+  // We need to calculate visible length for padding
+  const visibleStats = `Duration: ${duration}  •  Fix Rounds: ${fixRounds}  •  Findings: ${findings}`;
+  const leftPad = Math.floor((w - visibleStats.length) / 2);
+  const rightPad = w - visibleStats.length - leftPad;
+  console.log(`  ${config.borderColor}${BOX.dVertical}${c.reset}${' '.repeat(leftPad)}Duration: ${c.bold}${duration}${c.reset}  ${c.dim}•${c.reset}  Fix Rounds: ${c.bold}${fixRounds}${c.reset}  ${c.dim}•${c.reset}  Findings: ${c.bold}${findings}${c.reset}${' '.repeat(rightPad)}${config.borderColor}${BOX.dVertical}${c.reset}`);
+  
+  // Empty line
+  console.log(`  ${config.borderColor}${BOX.dVertical}${c.reset}${' '.repeat(w)}${config.borderColor}${BOX.dVertical}${c.reset}`);
+  
+  // Bottom border
+  console.log(`  ${config.borderColor}${BOX.dBottomLeft}${BOX.dHorizontal.repeat(w)}${BOX.dBottomRight}${c.reset}`);
+  
+  console.log();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TIMELINE SUMMARY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printTimelineSummary(timeline) {
+  printSection('PROOF TIMELINE', ICONS.graph);
+  console.log();
+  
+  for (const entry of timeline) {
+    const stepNum = typeof entry.step === 'number' ? entry.step : parseInt(entry.step) || 0;
+    const config = getStepConfig(stepNum);
+    
+    let statusIcon, statusColor;
+    
+    if (entry.status === 'ok' || entry.status === 'SHIP' || entry.status === 'CLEAN') {
+      statusIcon = ICONS.check;
+      statusColor = colors.shipGreen;
+    } else if (entry.status === 'WARN') {
+      statusIcon = ICONS.warning;
+      statusColor = colors.warnAmber;
+    } else if (entry.status === 'BLOCK' || entry.status === 'error') {
+      statusIcon = ICONS.cross;
+      statusColor = colors.blockRed;
+    } else if (entry.status === 'skipped') {
+      statusIcon = ICONS.skip;
+      statusColor = colors.muted;
+    } else {
+      statusIcon = ICONS.bullet;
+      statusColor = colors.accent;
+    }
+    
+    let line = `  ${statusColor}${statusIcon}${c.reset} ${c.bold}${entry.action.toUpperCase().padEnd(10)}${c.reset}`;
+    
+    // Add relevant details
+    const details = [];
+    if (entry.routes !== undefined) details.push(`${entry.routes} routes`);
+    if (entry.verdict) details.push(entry.verdict);
+    if (entry.findingsCount !== undefined) details.push(`${entry.findingsCount} findings`);
+    if (entry.coverage !== undefined && entry.coverage !== null) details.push(`${entry.coverage}% coverage`);
+    if (entry.reason) details.push(entry.reason);
+    
+    if (details.length > 0) {
+      line += ` ${c.dim}${details.join(' · ')}${c.reset}`;
+    }
+    
+    console.log(line);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELP DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printHelp(showBanner = true) {
+  if (showBanner && shouldShowBanner({})) {
+    console.log(BANNER_FULL);
+  }
+  console.log(`
+  ${c.bold}Usage:${c.reset} vibecheck prove --url <url> [options]
+
+  ${c.bold}One Command Reality Proof${c.reset} — Undeniable evidence that your app works.
+  
+  Produces a shareable proof bundle with ${c.bold}video${c.reset} + ${c.bold}network evidence${c.reset} showing
+  real user flows hitting real APIs. Drop it into CI and instantly trust the verdict.
+
+  ${c.bold}What You Get:${c.reset}
+    ${colors.shipGreen}🎬${c.reset} Video recordings of browser sessions
+    ${colors.shipGreen}📡${c.reset} Network traffic capture (HAR files)
+    ${colors.shipGreen}📊${c.reset} Playwright traces (viewable at trace.playwright.dev)
+    ${colors.shipGreen}📄${c.reset} Beautiful HTML proof report
+
+  ${c.bold}Pipeline:${c.reset}
+    ${colors.step1}1. CTX${c.reset}      Refresh truthpack (ground truth)
+    ${colors.step2}2. REALITY${c.reset}  Runtime UI proof with video + network capture
+    ${colors.step3}3. SHIP${c.reset}     Static + runtime verdict
+    ${colors.step4}4. FIX${c.reset}      Auto-fix if BLOCK ${c.dim}(up to N rounds)${c.reset}
+    ${colors.step5}5. VERIFY${c.reset}   Re-run to confirm SHIP
+
+  ${c.bold}Options:${c.reset}
+    ${colors.accent}--url, -u <url>${c.reset}           Base URL for runtime testing ${c.dim}(required)${c.reset}
+    ${colors.accent}--auth <email:pass>${c.reset}      Login credentials for auth verification
+    ${colors.accent}--storage-state <path>${c.reset}   Playwright session state file
+    ${colors.accent}--stability-runs <n>${c.reset}     Multiple runs for flakiness ${c.dim}(default: 2)${c.reset}
+    ${colors.accent}--max-fix-rounds <n>${c.reset}     Max auto-fix attempts ${c.dim}(default: 3)${c.reset}
+    ${colors.accent}--skip-reality${c.reset}           Skip runtime crawling (static only)
+    ${colors.accent}--skip-fix${c.reset}               Don't auto-fix, just diagnose
+    ${colors.accent}--headed${c.reset}                 Run browser in headed mode
+    ${colors.accent}--ci${c.reset}                     CI-friendly output (GitHub Actions)
+
+  ${c.bold}Recording Options:${c.reset} ${c.dim}(all enabled by default)${c.reset}
+    ${colors.accent}--no-video${c.reset}               Disable video recording
+    ${colors.accent}--no-trace${c.reset}               Disable Playwright traces
+    ${colors.accent}--no-har${c.reset}                 Disable HAR network capture
+
+  ${c.bold}Evidence Pack:${c.reset}
+    ${colors.accent}--bundle${c.reset}                 Generate shareable evidence pack (zip with videos, traces, screenshots)
+
+  ${c.bold}Exit Codes:${c.reset}
+    ${colors.shipGreen}0${c.reset}  SHIP  — Proved real, ready to deploy
+    ${colors.warnAmber}1${c.reset}  WARN  — Warnings found, review recommended
+    ${colors.blockRed}2${c.reset}  BLOCK — Blockers found, not proved
+
+  ${c.bold}Examples:${c.reset}
+    ${c.dim}# Full proof with video + network evidence${c.reset}
+    vibecheck prove --url http://localhost:3000
+
+    ${c.dim}# With authentication (two-pass verification)${c.reset}
+    vibecheck prove --url http://localhost:3000 --auth user@test.com:pass
+
+    ${c.dim}# CI integration (GitHub Actions)${c.reset}
+    npx vibecheck prove --url \$APP_URL --ci
+
+    ${c.dim}# Quick check (no recordings)${c.reset}
+    vibecheck prove --url http://localhost:3000 --no-video --no-trace
+
+  ${c.bold}CI Integration:${c.reset}
+    ${c.dim}# Add to .github/workflows/test.yml:${c.reset}
+    - name: Reality Proof
+      run: npx vibecheck prove --url \${{ env.APP_URL }} --ci
+    - uses: actions/upload-artifact@v4
+      with:
+        name: proof-report
+        path: .vibecheck/prove/*/proof-report.html
+  `);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function stamp() {
+  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())}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN PROVE FUNCTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runProve(argsOrOpts = {}, context = {}) {
+  // Extract runId from context or generate new one
+  const runId = context.runId || generateRunId();
+  const startTime = context.startTime || new Date().toISOString();
+  const executionStart = Date.now();
+  
+  // Handle array args from CLI
+  if (Array.isArray(argsOrOpts)) {
+    // Parse global flags first
+    const { flags: globalFlags, cleanArgs } = parseGlobalFlags(argsOrOpts);
+    
+    if (globalFlags.help) {
+      printHelp(shouldShowBanner(globalFlags));
+      return 0;
+    }
+    
+    const getArg = (flags) => {
+      for (const f of flags) {
+        const idx = cleanArgs.indexOf(f);
+        if (idx !== -1 && idx < cleanArgs.length - 1) return cleanArgs[idx + 1];
+      }
+      return undefined;
+    };
+    argsOrOpts = {
+      ...globalFlags, // Merge global flags (json, verbose, noBanner, quiet, ci, etc.)
+      url: getArg(["--url", "-u"]),
+      auth: getArg(["--auth"]),
+      storageState: getArg(["--storage-state"]),
+      fastifyEntry: getArg(["--fastify-entry"]),
+      maxFixRounds: parseInt(getArg(["--max-fix-rounds"]) || "3", 10),
+      skipReality: cleanArgs.includes("--skip-reality"),
+      skipFix: cleanArgs.includes("--skip-fix"),
+      headed: cleanArgs.includes("--headed"),
+      danger: cleanArgs.includes("--danger"),
+      // Recording options - enabled by default for "undeniable proof"
+      noVideo: cleanArgs.includes("--no-video"),
+      noTrace: cleanArgs.includes("--no-trace"),
+      noHar: cleanArgs.includes("--no-har"),
+      stabilityRuns: parseInt(getArg(["--stability-runs"]) || "2", 10),
+      flakyThreshold: parseFloat(getArg(["--flaky-threshold"]) || "0.66"),
+      maxPages: parseInt(getArg(["--max-pages"]) || "18", 10),
+      evidencePack: cleanArgs.includes("--evidence-pack") || cleanArgs.includes("--bundle"),
+      output: getArg(["--output", "-o"]),
+    };
+  }
+
+  const {
+    repoRoot,
+    url,
+    auth,
+    storageState,
+    fastifyEntry,
+    maxFixRounds = 3,
+    maxMissions = 8,
+    maxSteps = 10,
+    skipReality = false,
+    skipFix = false,
+    headed = false,
+    danger = false,
+    maxPages = 18,
+    maxDepth = 2,
+    timeoutMs = 15000,
+    // Recording enabled by default for undeniable proof
+    noVideo = false,
+    noTrace = false,
+    noHar = false,
+    stabilityRuns = 2,
+    flakyThreshold = 0.66,
+    json = false,
+    output = null,
+    ci = false,
+    evidencePack = false
+  } = argsOrOpts;
+  
+  const root = repoRoot || process.cwd();
+  const projectName = path.basename(root);
+
+  // Initialize pipeline status
+  const pipelineStatus = ['pending', 'pending', 'pending', 'pending', 'pending'];
+  const outDir = path.join(root, ".vibecheck", "prove", stamp());
+  ensureDir(outDir);
+  
+  const timeline = [];
+  let finalVerdict = "UNKNOWN";
+
+  // Print banner (unless JSON or CI mode)
+  if (!json && !ci) {
+    printBanner();
+    
+    console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+    console.log(`  ${c.dim}Path:${c.reset}     ${root}`);
+    if (url) {
+      console.log(`  ${c.dim}URL:${c.reset}      ${colors.accent}${url}${c.reset}`);
+    }
+    console.log(`  ${c.dim}Fix Rounds:${c.reset} ${maxFixRounds} max`);
+    
+    // Show pipeline overview
+    printPipelineOverview(pipelineStatus);
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 1: CTX - Refresh truthpack
+  // ═══════════════════════════════════════════════════════════════════════════
+  printStepHeader(1);
+  pipelineStatus[0] = 'running';
+  
+  startSpinner('Refreshing truthpack...', colors.step1);
+  
+  try {
+    const fastEntry = fastifyEntry || (await detectFastifyEntry(root));
+    const truthpack = await buildTruthpackSmart({ repoRoot: root, fastifyEntry: fastEntry });
+    writeTruthpack(root, truthpack);
+    
+    stopSpinner('Truthpack refreshed', true);
+    
+    timeline.push({
+      step: 1,
+      action: "ctx",
+      status: "ok",
+      routes: truthpack.routes?.server?.length || 0,
+      envVars: truthpack.env?.vars?.length || 0
+    });
+    
+    printStepResult(1, 'ok', {
+      routes: truthpack.routes?.server?.length || 0,
+      envVars: truthpack.env?.vars?.length || 0
+    });
+    
+    // Check for contract drift after truthpack refresh
+    if (hasContracts(root)) {
+      const contracts = loadContracts(root);
+      const driftFindings = findContractDrift(contracts, truthpack);
+      const driftSummary = getDriftSummary(driftFindings);
+      
+      if (driftSummary.hasDrift) {
+        console.log(`    ${driftSummary.blocks > 0 ? colors.warnAmber + ICONS.warning : colors.muted + ICONS.info}${c.reset} Contract drift: ${driftSummary.blocks} blocks, ${driftSummary.warns} warnings`);
+        timeline.push({
+          step: "1.5",
+          action: "drift_check",
+          status: driftSummary.verdict,
+          blocks: driftSummary.blocks,
+          warns: driftSummary.warns
+        });
+        
+        if (driftSummary.blocks > 0) {
+          console.log(`    ${c.dim}Run 'vibecheck ctx sync' to update contracts${c.reset}`);
+        }
+      }
+    }
+    
+    pipelineStatus[0] = 'complete';
+  } catch (err) {
+    stopSpinner(`Context refresh failed: ${err.message}`, false);
+    timeline.push({ step: 1, action: "ctx", status: "error", error: err.message });
+    pipelineStatus[0] = 'error';
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 2: REALITY - Runtime UI proof (if URL provided)
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (url && !skipReality && runReality) {
+    printStepHeader(2, url);
+    pipelineStatus[1] = 'running';
+    
+    startSpinner('Running reality check with video + network capture...', colors.step2);
+    
+    try {
+      // Enable all recording by default for undeniable proof
+      await runReality({
+        repoRoot: root,
+        url,
+        auth,
+        storageState,
+        verifyAuth: !!auth || !!storageState,
+        headed,
+        maxPages,
+        maxDepth,
+        danger,
+        timeoutMs,
+        // Recording enabled by default for "prove" - undeniable evidence
+        recordVideo: !noVideo,
+        recordTrace: !noTrace,
+        recordHar: !noHar,
+        // Multiple stability runs for flakiness reduction
+        stabilityRuns: stabilityRuns,
+        flakyThreshold: 0.66
+      });
+      
+      // Read reality report for timeline
+      const realityPath = path.join(root, ".vibecheck", "reality", "last_reality.json");
+      if (fs.existsSync(realityPath)) {
+        const reality = JSON.parse(fs.readFileSync(realityPath, "utf8"));
+        const blocks = (reality.findings || []).filter(f => f.severity === "BLOCK").length;
+        const warns = (reality.findings || []).filter(f => f.severity === "WARN").length;
+        
+        stopSpinner('Reality check complete', true);
+        
+        timeline.push({
+          step: 2,
+          action: "reality",
+          status: blocks ? "BLOCK" : warns ? "WARN" : "CLEAN",
+          findings: { BLOCK: blocks, WARN: warns },
+          pagesVisited: reality.passes?.anon?.pagesVisited?.length || 0,
+          coverage: reality.coverage?.percent || null
+        });
+        
+        printStepResult(2, blocks ? 'BLOCK' : warns ? 'WARN' : 'CLEAN', {
+          findings: { BLOCK: blocks, WARN: warns },
+          pagesVisited: reality.passes?.anon?.pagesVisited?.length || 0,
+          coverage: reality.coverage?.percent
+        });
+        
+        pipelineStatus[1] = blocks ? 'error' : 'complete';
+      }
+    } catch (err) {
+      stopSpinner(`Reality check failed: ${err.message}`, false);
+      timeline.push({ step: 2, action: "reality", status: "error", error: err.message });
+      pipelineStatus[1] = 'error';
+    }
+  } else {
+    const reason = !url ? 'no --url provided' : '--skip-reality flag';
+    console.log();
+    console.log(`  ${colors.muted}${ICONS.skip}${c.reset} ${c.dim}Step 2: REALITY skipped (${reason})${c.reset}`);
+    timeline.push({ step: 2, action: "reality", status: "skipped", reason });
+    pipelineStatus[1] = 'skipped';
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 3: SHIP - Get initial verdict
+  // ═══════════════════════════════════════════════════════════════════════════
+  printStepHeader(3);
+  pipelineStatus[2] = 'running';
+  
+  startSpinner('Running ship check...', colors.step3);
+  
+  let shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+  
+  stopSpinner('Ship check complete', true);
+  
+  timeline.push({
+    step: 3,
+    action: "ship",
+    verdict: shipResult.verdict,
+    findingsCount: shipResult.report?.findings?.length || 0
+  });
+  
+  printStepResult(3, shipResult.verdict, {
+    findings: shipResult.report?.findings?.length || 0
+  });
+  
+  pipelineStatus[2] = shipResult.verdict === 'SHIP' ? 'complete' : shipResult.verdict === 'WARN' ? 'complete' : 'error';
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 4: FIX LOOP - If BLOCK, attempt loop fix
+  // ═══════════════════════════════════════════════════════════════════════════
+  let fixRound = 0;
+  
+  while (shipResult.verdict === "BLOCK" && !skipFix && fixRound < maxFixRounds) {
+    fixRound++;
+    
+    if (fixRound === 1) {
+      printStepHeader(4, `Up to ${maxFixRounds} rounds`);
+      pipelineStatus[3] = 'running';
+    }
+    
+    printFixLoopHeader(fixRound, maxFixRounds);
+    
+    try {
+      // Import fix dependencies lazily
+      const { planMissions } = 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 } = require("./lib/validate-patch");
+      
+      const findings = shipResult.report?.findings || [];
+      const missions = planMissions(findings, { maxMissions, blocksOnlyFirst: true });
+      
+      if (!missions.length) {
+        console.log(`    ${colors.warnAmber}${ICONS.warning}${c.reset} No fixable missions found`);
+        timeline.push({ step: `4.${fixRound}`, action: "fix", status: "no_missions" });
+        break;
+      }
+      
+      console.log(`    ${c.dim}Planning ${missions.length} missions...${c.reset}`);
+      
+      let fixedAny = false;
+      
+      for (const mission of missions.slice(0, 3)) {
+        printMissionStatus(mission, 'planning');
+        
+        const targetFindings = findings.filter(f => mission.targetFindingIds.includes(f.id));
+        const template = templateForMissionType(mission.type);
+        
+        const expanded = await expandEvidence({
+          repoRoot: root,
+          truthpack: shipResult.truthpack,
+          mission,
+          targetFindings
+        });
+        
+        const prompt = buildRealityFirewall({
+          truthpackSummary: {
+            serverRoutes: shipResult.truthpack?.routes?.server?.length || 0,
+            clientRefs: shipResult.truthpack?.routes?.clientRefs?.length || 0,
+            envVars: shipResult.truthpack?.env?.vars?.length || 0
+          },
+          mission,
+          template,
+          findings: targetFindings,
+          fileSnippets: expanded.snippets,
+          allowedFiles: expanded.allowedFiles
+        });
+        
+        printMissionStatus(mission, 'applying');
+        
+        try {
+          const patchResponse = await generatePatchJson(prompt);
+          
+          if (!patchResponse || patchResponse.status !== "ok" || !patchResponse.edits?.length) {
+            printMissionStatus(mission, 'skipped', 'no patch generated');
+            continue;
+          }
+          
+          const validation = validatePatchResponse(patchResponse, {
+            allowedFiles: expanded.allowedFiles,
+            beforeTruthpack: shipResult.truthpack
+          });
+          
+          if (!validation.valid) {
+            printMissionStatus(mission, 'failed', `validation: ${validation.reason}`);
+            continue;
+          }
+          
+          // Backup before applying
+          const touchedFiles = patchResponse.edits.map(e => e.path).filter(Boolean);
+          const backupRoot = path.join(outDir, `backup_${fixRound}_${mission.id}`);
+          backupFiles(root, touchedFiles, backupRoot);
+          
+          // Apply patches
+          let appliedAny = false;
+          for (const edit of patchResponse.edits) {
+            if (!edit.diff || !edit.path) continue;
+            
+            try {
+              await applyUnifiedDiff(root, edit.diff);
+              appliedAny = true;
+            } catch (e) {
+              // Patch failed
+            }
+          }
+          
+          if (appliedAny) {
+            fixedAny = true;
+            printMissionStatus(mission, 'success', `${patchResponse.edits.length} edits`);
+          } else {
+            printMissionStatus(mission, 'failed', 'patch apply failed');
+          }
+        } catch (e) {
+          printMissionStatus(mission, 'failed', `LLM error: ${truncate(e.message, 30)}`);
+        }
+      }
+      
+      timeline.push({
+        step: `4.${fixRound}`,
+        action: "fix",
+        status: fixedAny ? "applied" : "no_changes",
+        missionsAttempted: Math.min(missions.length, 3)
+      });
+      
+      if (!fixedAny) {
+        console.log(`    ${colors.warnAmber}${ICONS.warning}${c.reset} No fixes applied this round`);
+        break;
+      }
+      
+      // Re-run ship to check progress
+      startSpinner('Re-checking ship verdict...', colors.step3);
+      shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+      stopSpinner('Ship check complete', true);
+      
+      printStepResult(3, shipResult.verdict, {
+        findings: shipResult.report?.findings?.length || 0
+      });
+      
+    } catch (err) {
+      console.log(`    ${colors.blockRed}${ICONS.cross}${c.reset} Fix error: ${err.message}`);
+      timeline.push({ step: `4.${fixRound}`, action: "fix", status: "error", error: err.message });
+      break;
+    }
+  }
+  
+  if (fixRound > 0) {
+    pipelineStatus[3] = shipResult.verdict === 'SHIP' ? 'complete' : 'error';
+  } else if (skipFix) {
+    pipelineStatus[3] = 'skipped';
+  } else if (shipResult.verdict !== 'BLOCK') {
+    pipelineStatus[3] = 'skipped';
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // STEP 5: FINAL VERIFICATION - Re-run reality + ship
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (url && !skipReality && runReality && fixRound > 0) {
+    printStepHeader(5);
+    pipelineStatus[4] = 'running';
+    
+    startSpinner('Running final verification with recording...', colors.step5);
+    
+    try {
+      await runReality({
+        repoRoot: root,
+        url,
+        auth,
+        storageState,
+        verifyAuth: !!auth || !!storageState,
+        headed,
+        maxPages,
+        maxDepth,
+        danger,
+        timeoutMs,
+        // Recording for final proof
+        recordVideo: !noVideo,
+        recordTrace: !noTrace,
+        recordHar: !noHar,
+        stabilityRuns: 1 // Single run for verification
+      });
+      
+      shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+      
+      stopSpinner('Final verification complete', true);
+      
+      timeline.push({
+        step: 5,
+        action: "verify",
+        verdict: shipResult.verdict,
+        findingsCount: shipResult.report?.findings?.length || 0
+      });
+      
+      printStepResult(5, shipResult.verdict, {
+        findings: shipResult.report?.findings?.length || 0
+      });
+      
+      pipelineStatus[4] = shipResult.verdict === 'SHIP' ? 'complete' : 'error';
+    } catch (err) {
+      stopSpinner(`Final verification failed: ${err.message}`, false);
+      pipelineStatus[4] = 'error';
+    }
+  } else {
+    pipelineStatus[4] = 'skipped';
+  }
+
+  finalVerdict = shipResult.verdict;
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // SUMMARY & HTML PROOF REPORT
+  // ═══════════════════════════════════════════════════════════════════════════
+  const duration = Date.now() - executionStart;
+  const durationStr = formatDuration(duration);
+  
+  // Load reality report for evidence
+  let realityReport = null;
+  const realityPath = path.join(root, ".vibecheck", "reality", "last_reality.json");
+  try { realityReport = JSON.parse(fs.readFileSync(realityPath, "utf8")); } catch {}
+  
+  const report = {
+    meta: {
+      startedAt: new Date(executionStart).toISOString(),
+      finishedAt: new Date().toISOString(),
+      durationMs: duration,
+      url: url || null,
+      fixRounds: fixRound,
+      stabilityRuns: stabilityRuns,
+      recordingEnabled: { video: !noVideo, trace: !noTrace, har: !noHar }
+    },
+    timeline,
+    finalVerdict,
+    finalFindings: shipResult.report?.findings?.length || 0,
+    // Include reality evidence
+    coverage: realityReport?.coverage || null,
+    artifacts: realityReport?.artifacts || null,
+    findings: realityReport?.findings || shipResult.report?.findings || []
+  };
+  
+  fs.writeFileSync(path.join(outDir, "prove_report.json"), JSON.stringify(report, null, 2), "utf8");
+  
+  // Generate HTML proof report
+  let htmlReportPath = null;
+  try {
+    const { generateHtmlProofReport } = require("./lib/html-proof-report");
+    const htmlContent = generateHtmlProofReport({
+      verdict: finalVerdict,
+      projectName: projectName,
+      url: url,
+      startedAt: new Date(executionStart).toISOString(),
+      finishedAt: new Date().toISOString(),
+      durationMs: duration,
+      findings: report.findings,
+      coverage: report.coverage,
+      passes: realityReport?.passes || {},
+      artifacts: report.artifacts,
+      meta: report.meta,
+      stabilityRuns: stabilityRuns
+    });
+    htmlReportPath = path.join(outDir, "proof-report.html");
+    fs.writeFileSync(htmlReportPath, htmlContent, "utf8");
+  } catch (e) {
+    // HTML report generation failed - non-fatal
+  }
+  
+  // Also save a stable pointer
+  const latestPath = path.join(root, ".vibecheck", "prove", "last_prove.json");
+  ensureDir(path.dirname(latestPath));
+  fs.writeFileSync(latestPath, JSON.stringify(report, null, 2), "utf8");
+
+  // Save artifacts
+  saveArtifact(runId, "prove-report", report);
+  saveArtifact(runId, "timeline", timeline);
+  
+  // Generate evidence pack if requested
+  let evidencePackPath = null;
+  if (evidencePack) {
+    try {
+      // Lazy load evidence pack module
+      const evidencePackModule = require("../../packages/cli/src/evidence/evidence-pack");
+      const { generateEvidencePack, generateHtmlViewer } = evidencePackModule.default || evidencePackModule;
+      
+      if (!json && !ci) {
+        console.log();
+        console.log(`  ${colors.accent}${ICONS.doc}${c.reset} Generating evidence pack...`);
+      }
+      
+      const result = await generateEvidencePack({
+        projectPath: root,
+        sourceReport: latestPath,
+        sourceType: 'prove',
+        includeVideos: !noVideo,
+        includeTraces: !noTrace,
+        includeHar: !noHar,
+        includeScreenshots: true
+      });
+      
+      evidencePackPath = result.packPath;
+      
+      // Generate HTML viewer
+      const htmlViewerModule = require("../../packages/cli/src/evidence/html-viewer");
+      const htmlViewer = htmlViewerModule.default || htmlViewerModule;
+      await htmlViewer.generateHtmlViewer({
+        packPath: evidencePackPath,
+        embedMedia: false,
+        title: `Evidence Pack - ${projectName}`
+      });
+      
+      if (!json && !ci) {
+        console.log(`  ${colors.success}${ICONS.check}${c.reset} Evidence pack generated: ${colors.accent}${path.relative(root, evidencePackPath)}${c.reset}`);
+      }
+    } catch (e) {
+      if (!json && !ci) {
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} Evidence pack generation failed: ${e.message}`);
+      }
+    }
+  }
+  
+  // JSON output mode
+  if (json) {
+    const output = createJsonOutput({
+      runId,
+      command: "prove",
+      startTime: executionStart,
+      exitCode: verdictToExitCode(finalVerdict),
+      verdict: finalVerdict,
+      result: {
+        meta: report.meta,
+        timeline,
+        finalVerdict,
+        fixRounds: fixRound,
+        duration: duration
+      },
+      tier: "pro",
+      version: require("../../package.json").version,
+      artifacts: [
+        {
+          type: "report",
+          path: path.join(outDir, "prove_report.json"),
+          description: "Prove report with timeline"
+        }
+      ]
+    });
+    
+    writeJsonOutput(output, output);
+  }
+  
+  // Final verdict display (unless JSON or CI mode)
+  if (!json && !ci) {
+    // Use Mission Control format
+    const { formatProveOutput } = require('./lib/prove-output');
+    const steps = timeline.map(t => ({
+      name: t.step || t.action || 'Step',
+      success: t.status === 'success' || t.status === 'complete',
+      error: t.status === 'error' ? t.error : null,
+    }));
+    
+    console.log(formatProveOutput({
+      verdict: finalVerdict,
+      finalVerdict,
+      steps,
+      runtimeTests: report.tests?.length || 0,
+      runtimePassed: report.tests?.filter(t => t.passed).length || 0,
+      duration,
+      success: finalVerdict === 'SHIP',
+    }, { version: 'v3.5.5' }));
+    
+    // Show artifacts if available
+    if (htmlReportPath) {
+      console.log(`\n  ${colors.shipGreen}${ICONS.sparkle}${c.reset} ${c.bold}HTML Proof Report:${c.reset} ${colors.accent}${path.relative(root, htmlReportPath)}${c.reset}`);
+    }
+  } else if (ci) {
+    // CI mode - structured output for easy parsing
+    console.log(`::group::vibecheck prove summary`);
+    console.log(`VERDICT=${finalVerdict}`);
+    console.log(`DURATION=${duration}ms`);
+    console.log(`FIX_ROUNDS=${fixRound}`);
+    console.log(`BLOCKERS=${report.findings.filter(f => f.severity === 'BLOCK').length}`);
+    console.log(`WARNINGS=${report.findings.filter(f => f.severity === 'WARN').length}`);
+    console.log(`COVERAGE=${report.coverage?.percent || 0}%`);
+    if (htmlReportPath) {
+      console.log(`HTML_REPORT=${path.relative(root, htmlReportPath)}`);
+    }
+    console.log(`JSON_REPORT=${path.relative(root, path.join(outDir, 'prove_report.json'))}`);
+    if (evidencePackPath) {
+      console.log(`EVIDENCE_PACK=${path.relative(root, evidencePackPath)}`);
+    }
+    console.log(`::endgroup::`);
+    
+    // GitHub Actions annotations
+    if (finalVerdict === 'BLOCK') {
+      console.log(`::error title=Reality Check Failed::${report.findings.filter(f => f.severity === 'BLOCK').length} blockers found`);
+    } else if (finalVerdict === 'WARN') {
+      console.log(`::warning title=Reality Check Passed with Warnings::${report.findings.filter(f => f.severity === 'WARN').length} warnings found`);
+    } else {
+      console.log(`::notice title=Reality Check Passed::App verified with video + network evidence`);
+    }
+  }
+
+  return verdictToExitCode(finalVerdict);
+}
+
+module.exports = { runProve };