@vibecheckai/cli 3.0.9 → 3.1.0

package/bin/runners/runProve.js

@@ -1,6 +1,10 @@
 /**
  * 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
@@ -18,6 +22,14 @@ const path = require("path");
 const { buildTruthpack, writeTruthpack, detectFastifyEntry } = require("./lib/truth");
 const { shipCore } = require("./runShip");
 const { findContractDrift, loadContracts, hasContracts, getDriftSummary } = require("./lib/drift");
+const { 
+  generateRunId, 
+  createJsonOutput, 
+  writeJsonOutput, 
+  exitCodeToVerdict,
+  verdictToExitCode,
+  saveArtifact 
+} = require("./lib/cli-output");
 
 let runReality;
 try {
@@ -33,7 +45,677 @@ try {
   runFixCore = null;
 }
 
-const { c, sym, Spinner, printHeader, printSection, printDivider, verdictBadge, formatDuration, box } = require("./lib/ui");
+// ═══════════════════════════════════════════════════════════════════════════════
+// 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() {
+  console.log(BANNER_FULL);
+  console.log(`
+  ${c.bold}Usage:${c.reset} vibecheck prove [options]
+
+  ${c.bold}One Command Reality Proof${c.reset} — Make it real or keep fixing until it is.
+
+  ${c.bold}Pipeline:${c.reset}
+    ${colors.step1}1. CTX${c.reset}      Refresh truthpack (ground truth)
+    ${colors.step2}2. REALITY${c.reset}  Runtime UI proof ${c.dim}(if --url provided)${c.reset}
+    ${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
+    ${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}--fastify-entry <path>${c.reset}   Fastify entry file for route extraction
+    ${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}--danger${c.reset}                 Allow clicking destructive elements
+    ${colors.accent}--help, -h${c.reset}               Show this help
+
+  ${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 runtime testing${c.reset}
+    vibecheck prove --url http://localhost:3000
+
+    ${c.dim}# With authentication${c.reset}
+    vibecheck prove --url http://localhost:3000 --auth user@test.com:pass
+
+    ${c.dim}# Static only (no runtime)${c.reset}
+    vibecheck prove --skip-reality
+
+    ${c.dim}# More fix attempts${c.reset}
+    vibecheck prove --url http://localhost:3000 --max-fix-rounds 5
+  `);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
 
 function ensureDir(p) {
   fs.mkdirSync(p, { recursive: true });
@@ -45,46 +727,15 @@ function stamp() {
   return `${d.getFullYear()}${z(d.getMonth() + 1)}${z(d.getDate())}_${z(d.getHours())}${z(d.getMinutes())}${z(d.getSeconds())}`;
 }
 
-function printHelp() {
-  console.log(`
-${c.cyan}${c.bold}vibecheck prove${c.reset} - One Command Reality Proof
-
-${c.bold}USAGE${c.reset}
-  vibecheck prove [options]
-
-${c.bold}OPTIONS${c.reset}
-  --url, -u <url>           Base URL for runtime testing
-  --auth <email:pass>       Login credentials for auth verification
-  --storage-state <path>    Playwright session state file
-  --fastify-entry <path>    Fastify entry file for route extraction
-  --max-fix-rounds <n>      Max auto-fix attempts (default: 3)
-  --skip-reality            Skip runtime crawling (static only)
-  --skip-fix                Don't auto-fix, just diagnose
-  --headed                  Run browser in headed mode
-  --danger                  Allow clicking destructive elements
-  --help, -h                Show this help
-
-${c.bold}WHAT IT DOES${c.reset}
-  1. ${c.cyan}ctx${c.reset}      - Refresh truthpack (ground truth)
-  2. ${c.cyan}reality${c.reset}  - Runtime UI proof (if --url provided)
-  3. ${c.cyan}ship${c.reset}     - Static + runtime verdict
-  4. ${c.cyan}fix${c.reset}      - Auto-fix if BLOCK (up to N rounds)
-  5. ${c.cyan}verify${c.reset}   - Re-run to confirm SHIP
-
-${c.bold}EXIT CODES${c.reset}
-  0 = SHIP (ready to deploy)
-  1 = WARN (warnings found)
-  2 = BLOCK (blockers found)
-
-${c.bold}EXAMPLES${c.reset}
-  vibecheck prove --url http://localhost:3000
-  vibecheck prove --url http://localhost:3000 --auth user@test.com:pass
-  vibecheck prove --skip-reality
-  vibecheck prove --url http://localhost:3000 --max-fix-rounds 5
-`);
-}
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN PROVE FUNCTION
+// ═══════════════════════════════════════════════════════════════════════════════
 
-async function runProve(argsOrOpts = {}) {
+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();
+  
   // Handle array args from CLI
   if (Array.isArray(argsOrOpts)) {
     if (argsOrOpts.includes("--help") || argsOrOpts.includes("-h")) {
@@ -108,6 +759,9 @@ async function runProve(argsOrOpts = {}) {
       skipFix: argsOrOpts.includes("--skip-fix"),
       headed: argsOrOpts.includes("--headed"),
       danger: argsOrOpts.includes("--danger"),
+      json: argsOrOpts.includes("--json"),
+      output: getArg(["--output", "-o"]),
+      ci: argsOrOpts.includes("--ci"),
     };
   }
 
@@ -126,35 +780,53 @@ async function runProve(argsOrOpts = {}) {
     danger = false,
     maxPages = 18,
     maxDepth = 2,
-    timeoutMs = 15000
+    timeoutMs = 15000,
+    json = false,
+    output = null,
+    ci = false
   } = argsOrOpts;
   
   const root = repoRoot || process.cwd();
-  const startTime = Date.now();
-
-  console.log(`
-${c.cyan}${c.bold}╔════════════════════════════════════════════════════════════╗
-║  🔬 vibecheck prove                                          ║
-║  One command to make it real                                 ║
-╚════════════════════════════════════════════════════════════╝${c.reset}
-`);
+  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
   // ═══════════════════════════════════════════════════════════════════════════
-  console.log(`${c.cyan}▶ Step 1: Refreshing context (truthpack)...${c.reset}`);
+  printStepHeader(1);
+  pipelineStatus[0] = 'running';
+  
+  startSpinner('Refreshing truthpack...', colors.step1);
   
   try {
     const fastEntry = fastifyEntry || (await detectFastifyEntry(root));
     const truthpack = await buildTruthpack({ repoRoot: root, fastifyEntry: fastEntry });
     writeTruthpack(root, truthpack);
     
+    stopSpinner('Truthpack refreshed', true);
+    
     timeline.push({
       step: 1,
       action: "ctx",
@@ -163,7 +835,10 @@ ${c.cyan}${c.bold}╔═══════════════════
       envVars: truthpack.env?.vars?.length || 0
     });
     
-    console.log(`  ${c.green}✓${c.reset} Truthpack refreshed (${truthpack.routes?.server?.length || 0} routes, ${truthpack.env?.vars?.length || 0} env vars)`);
+    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)) {
@@ -172,7 +847,7 @@ ${c.cyan}${c.bold}╔═══════════════════
       const driftSummary = getDriftSummary(driftFindings);
       
       if (driftSummary.hasDrift) {
-        console.log(`  ${driftSummary.blocks > 0 ? c.yellow + '⚠️' : c.dim + 'ℹ️'} Contract drift: ${driftSummary.blocks} blocks, ${driftSummary.warns} warnings${c.reset}`);
+        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",
@@ -182,20 +857,26 @@ ${c.cyan}${c.bold}╔═══════════════════
         });
         
         if (driftSummary.blocks > 0) {
-          console.log(`  ${c.dim}Run 'vibecheck ctx sync' to update contracts${c.reset}`);
+          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 });
-    console.log(`  ${c.yellow}⚠️ Context refresh failed: ${err.message}${c.reset}`);
+    pipelineStatus[0] = 'error';
   }
 
   // ═══════════════════════════════════════════════════════════════════════════
   // STEP 2: REALITY - Runtime UI proof (if URL provided)
   // ═══════════════════════════════════════════════════════════════════════════
   if (url && !skipReality && runReality) {
-    console.log(`\n${c.cyan}▶ Step 2: Running reality check (${url})...${c.reset}`);
+    printStepHeader(2, url);
+    pipelineStatus[1] = 'running';
+    
+    startSpinner('Running reality check...', colors.step2);
     
     try {
       await runReality({
@@ -218,6 +899,8 @@ ${c.cyan}${c.bold}╔═══════════════════
         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",
@@ -227,30 +910,39 @@ ${c.cyan}${c.bold}╔═══════════════════
           coverage: reality.coverage?.percent || null
         });
         
-        console.log(`  ${c.green}✓${c.reset} Reality check complete (${blocks} BLOCK, ${warns} WARN)`);
-        if (reality.coverage) {
-          console.log(`  ${c.dim}Coverage: ${reality.coverage.percent}% of UI paths${c.reset}`);
-        }
+        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 });
-      console.log(`  ${c.yellow}⚠️ Reality check failed: ${err.message}${c.reset}`);
+      pipelineStatus[1] = 'error';
     }
-  } else if (!url) {
-    console.log(`\n${c.dim}▶ Step 2: Skipping reality (no --url provided)${c.reset}`);
-    timeline.push({ step: 2, action: "reality", status: "skipped", reason: "no URL" });
-  } else if (skipReality) {
-    console.log(`\n${c.dim}▶ Step 2: Skipping reality (--skip-reality)${c.reset}`);
-    timeline.push({ step: 2, action: "reality", status: "skipped", reason: "--skip-reality" });
+  } 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
   // ═══════════════════════════════════════════════════════════════════════════
-  console.log(`\n${c.cyan}▶ Step 3: Running ship check...${c.reset}`);
+  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",
@@ -258,8 +950,11 @@ ${c.cyan}${c.bold}╔═══════════════════
     findingsCount: shipResult.report?.findings?.length || 0
   });
   
-  const verdictColor = shipResult.verdict === "SHIP" ? c.green : shipResult.verdict === "WARN" ? c.yellow : c.red;
-  console.log(`  ${verdictColor}${shipResult.verdict}${c.reset} (${shipResult.report?.findings?.length || 0} findings)`);
+  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 autopilot fix
@@ -268,7 +963,13 @@ ${c.cyan}${c.bold}╔═══════════════════
   
   while (shipResult.verdict === "BLOCK" && !skipFix && fixRound < maxFixRounds) {
     fixRound++;
-    console.log(`\n${c.cyan}▶ Step 4.${fixRound}: Fix round ${fixRound}/${maxFixRounds}...${c.reset}`);
+    
+    if (fixRound === 1) {
+      printStepHeader(4, `Up to ${maxFixRounds} rounds`);
+      pipelineStatus[3] = 'running';
+    }
+    
+    printFixLoopHeader(fixRound, maxFixRounds);
     
     try {
       // Import fix dependencies lazily
@@ -285,16 +986,18 @@ ${c.cyan}${c.bold}╔═══════════════════
       const missions = planMissions(findings, { maxMissions, blocksOnlyFirst: true });
       
       if (!missions.length) {
-        console.log(`  ${c.yellow}No fixable missions found.${c.reset}`);
+        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(`  Planning ${missions.length} missions...`);
+      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);
         
@@ -318,13 +1021,13 @@ ${c.cyan}${c.bold}╔═══════════════════
           allowedFiles: expanded.allowedFiles
         });
         
-        console.log(`  ${c.dim}Mission: ${mission.title}${c.reset}`);
+        printMissionStatus(mission, 'applying');
         
         try {
           const patchResponse = await generatePatchJson(prompt);
           
           if (!patchResponse || patchResponse.status !== "ok" || !patchResponse.edits?.length) {
-            console.log(`    ${c.yellow}⚠️ No patch generated${c.reset}`);
+            printMissionStatus(mission, 'skipped', 'no patch generated');
             continue;
           }
           
@@ -334,7 +1037,7 @@ ${c.cyan}${c.bold}╔═══════════════════
           });
           
           if (!validation.valid) {
-            console.log(`    ${c.yellow}⚠️ Patch validation failed: ${validation.reason}${c.reset}`);
+            printMissionStatus(mission, 'failed', `validation: ${validation.reason}`);
             continue;
           }
           
@@ -351,17 +1054,19 @@ ${c.cyan}${c.bold}╔═══════════════════
             try {
               await applyUnifiedDiff(root, edit.diff);
               appliedAny = true;
-              console.log(`    ${c.green}✓${c.reset} Applied: ${edit.path}`);
             } catch (e) {
-              console.log(`    ${c.red}✗${c.reset} Failed: ${edit.path} - ${e.message}`);
+              // Patch failed
             }
           }
           
           if (appliedAny) {
             fixedAny = true;
+            printMissionStatus(mission, 'success', `${patchResponse.edits.length} edits`);
+          } else {
+            printMissionStatus(mission, 'failed', 'patch apply failed');
           }
         } catch (e) {
-          console.log(`    ${c.yellow}⚠️ LLM error: ${e.message}${c.reset}`);
+          printMissionStatus(mission, 'failed', `LLM error: ${truncate(e.message, 30)}`);
         }
       }
       
@@ -373,29 +1078,42 @@ ${c.cyan}${c.bold}╔═══════════════════
       });
       
       if (!fixedAny) {
-        console.log(`  ${c.yellow}No fixes applied this round.${c.reset}`);
+        console.log(`    ${colors.warnAmber}${ICONS.warning}${c.reset} No fixes applied this round`);
         break;
       }
       
       // Re-run ship to check progress
-      console.log(`  Re-checking ship verdict...`);
+      startSpinner('Re-checking ship verdict...', colors.step3);
       shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
+      stopSpinner('Ship check complete', true);
       
-      const newVerdictColor = shipResult.verdict === "SHIP" ? c.green : shipResult.verdict === "WARN" ? c.yellow : c.red;
-      console.log(`  ${newVerdictColor}${shipResult.verdict}${c.reset} (${shipResult.report?.findings?.length || 0} findings)`);
+      printStepResult(3, shipResult.verdict, {
+        findings: shipResult.report?.findings?.length || 0
+      });
       
     } catch (err) {
-      console.log(`  ${c.red}Fix error: ${err.message}${c.reset}`);
+      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) {
-    console.log(`\n${c.cyan}▶ Step 5: Final verification...${c.reset}`);
+    printStepHeader(5);
+    pipelineStatus[4] = 'running';
+    
+    startSpinner('Running final verification...', colors.step5);
     
     try {
       await runReality({
@@ -413,6 +1131,8 @@ ${c.cyan}${c.bold}╔═══════════════════
       
       shipResult = await shipCore({ repoRoot: root, fastifyEntry, noWrite: false });
       
+      stopSpinner('Final verification complete', true);
+      
       timeline.push({
         step: 5,
         action: "verify",
@@ -420,11 +1140,17 @@ ${c.cyan}${c.bold}╔═══════════════════
         findingsCount: shipResult.report?.findings?.length || 0
       });
       
-      const finalColor = shipResult.verdict === "SHIP" ? c.green : shipResult.verdict === "WARN" ? c.yellow : c.red;
-      console.log(`  Final verdict: ${finalColor}${shipResult.verdict}${c.reset}`);
+      printStepResult(5, shipResult.verdict, {
+        findings: shipResult.report?.findings?.length || 0
+      });
+      
+      pipelineStatus[4] = shipResult.verdict === 'SHIP' ? 'complete' : 'error';
     } catch (err) {
-      console.log(`  ${c.yellow}⚠️ Final verification failed: ${err.message}${c.reset}`);
+      stopSpinner(`Final verification failed: ${err.message}`, false);
+      pipelineStatus[4] = 'error';
     }
+  } else {
+    pipelineStatus[4] = 'skipped';
   }
 
   finalVerdict = shipResult.verdict;
@@ -432,13 +1158,14 @@ ${c.cyan}${c.bold}╔═══════════════════
   // ═══════════════════════════════════════════════════════════════════════════
   // SUMMARY
   // ═══════════════════════════════════════════════════════════════════════════
-  const duration = Math.round((Date.now() - startTime) / 1000);
+  const duration = Date.now() - executionStart;
+  const durationStr = formatDuration(duration);
   
   const report = {
     meta: {
-      startedAt: new Date(startTime).toISOString(),
+      startedAt: new Date(executionStart).toISOString(),
       finishedAt: new Date().toISOString(),
-      durationSeconds: duration,
+      durationMs: duration,
       url: url || null,
       fixRounds: fixRound
     },
@@ -454,20 +1181,73 @@ ${c.cyan}${c.bold}╔═══════════════════
   ensureDir(path.dirname(latestPath));
   fs.writeFileSync(latestPath, JSON.stringify(report, null, 2), "utf8");
 
-  console.log(`
-${c.cyan}${c.bold}════════════════════════════════════════════════════════════${c.reset}
-${c.bold}PROVE COMPLETE${c.reset}
-
-  Duration: ${duration}s
-  Fix rounds: ${fixRound}
-  Final verdict: ${finalVerdict === "SHIP" ? c.green : finalVerdict === "WARN" ? c.yellow : c.red}${finalVerdict}${c.reset}
-  Findings: ${shipResult.report?.findings?.length || 0}
+  // Save artifacts
+  saveArtifact(runId, "prove-report", report);
+  saveArtifact(runId, "timeline", timeline);
+  
+  // 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);
+  }
   
-  Report: .vibecheck/prove/${path.basename(outDir)}/prove_report.json
-${c.cyan}════════════════════════════════════════════════════════════${c.reset}
-`);
+  // Final verdict display (unless JSON or CI mode)
+  if (!json && !ci) {
+    printFinalVerdict(finalVerdict, durationStr, fixRound, shipResult.report?.findings?.length || 0);
+    
+    // Timeline summary
+    printTimelineSummary(timeline);
+    
+    // Report links
+    printSection('REPORTS', ICONS.doc);
+    console.log();
+    console.log(`  ${colors.accent}${outDir}/prove_report.json${c.reset}`);
+    console.log(`  ${c.dim}${path.join(root, '.vibecheck', 'prove', 'last_prove.json')}${c.reset}`);
+    console.log();
+    
+    // Next steps if not proved
+    if (finalVerdict !== 'SHIP') {
+      printSection('NEXT STEPS', ICONS.lightning);
+      console.log();
+      if (skipFix) {
+        console.log(`  ${colors.accent}vibecheck prove --url ${url || '<url>'}${c.reset}  ${c.dim}Enable auto-fix${c.reset}`);
+      } else if (fixRound >= maxFixRounds) {
+        console.log(`  ${colors.accent}vibecheck prove --max-fix-rounds ${maxFixRounds + 2}${c.reset}  ${c.dim}Try more fix rounds${c.reset}`);
+      }
+      console.log(`  ${colors.accent}vibecheck ship --fix${c.reset}  ${c.dim}Manual fix mode${c.reset}`);
+      console.log();
+    }
+  } else if (ci) {
+    // CI mode - minimal output
+    console.log(`VERDICT=${finalVerdict}`);
+    console.log(`DURATION=${duration}ms`);
+    console.log(`FIX_ROUNDS=${fixRound}`);
+  }
 
-  process.exitCode = finalVerdict === "SHIP" ? 0 : finalVerdict === "WARN" ? 1 : 2;
+  return verdictToExitCode(finalVerdict);
 }
 
-module.exports = { runProve };
+module.exports = { runProve };