@vibecheckai/cli 3.1.2 → 3.1.4

package/bin/runners/runScan.js

@@ -19,321 +19,64 @@ const { enforceLimit, trackUsage } = require("./lib/entitlements");
 const { emitScanStart, emitScanComplete } = require("./lib/audit-bridge");
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// ADVANCED TERMINAL - ANSI CODES & UTILITIES
+// ENHANCED TERMINAL UI & OUTPUT MODULES
 // ═══════════════════════════════════════════════════════════════════════════════
 
-const c = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  italic: '\x1b[3m',
-  underline: '\x1b[4m',
-  blink: '\x1b[5m',
-  inverse: '\x1b[7m',
-  hidden: '\x1b[8m',
-  strike: '\x1b[9m',
-  // Colors
-  black: '\x1b[30m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
-  // Bright colors
-  gray: '\x1b[90m',
-  brightRed: '\x1b[91m',
-  brightGreen: '\x1b[92m',
-  brightYellow: '\x1b[93m',
-  brightBlue: '\x1b[94m',
-  brightMagenta: '\x1b[95m',
-  brightCyan: '\x1b[96m',
-  brightWhite: '\x1b[97m',
-  // Background
-  bgBlack: '\x1b[40m',
-  bgRed: '\x1b[41m',
-  bgGreen: '\x1b[42m',
-  bgYellow: '\x1b[43m',
-  bgBlue: '\x1b[44m',
-  bgMagenta: '\x1b[45m',
-  bgCyan: '\x1b[46m',
-  bgWhite: '\x1b[47m',
-  bgBrightBlack: '\x1b[100m',
-  bgBrightRed: '\x1b[101m',
-  bgBrightGreen: '\x1b[102m',
-  bgBrightYellow: '\x1b[103m',
-  // Cursor
-  cursorUp: (n = 1) => `\x1b[${n}A`,
-  cursorDown: (n = 1) => `\x1b[${n}B`,
-  cursorRight: (n = 1) => `\x1b[${n}C`,
-  cursorLeft: (n = 1) => `\x1b[${n}D`,
-  clearLine: '\x1b[2K',
-  clearScreen: '\x1b[2J',
-  saveCursor: '\x1b[s',
-  restoreCursor: '\x1b[u',
-  hideCursor: '\x1b[?25l',
-  showCursor: '\x1b[?25h',
-};
-
-// 256-color 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`;
-
-// Gradient colors for the banner
-const gradientCyan = rgb(0, 255, 255);
-const gradientBlue = rgb(100, 149, 237);
-const gradientPurple = rgb(138, 43, 226);
-const gradientPink = rgb(255, 105, 180);
-const gradientOrange = rgb(255, 165, 0);
+const {
+  ansi,
+  colors,
+  Spinner,
+  PhaseProgress,
+  renderBanner,
+  renderSection,
+  formatDuration,
+} = require("./lib/terminal-ui");
+
+const {
+  formatScanOutput,
+  formatSARIF,
+  getExitCode,
+  printError,
+  EXIT_CODES,
+  calculateScore,
+} = require("./lib/scan-output");
 
 const BANNER = `
-${rgb(0, 200, 255)}  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗${c.reset}
-${rgb(30, 180, 255)}  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝${c.reset}
-${rgb(60, 160, 255)}  ██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝ ${c.reset}
-${rgb(90, 140, 255)}  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ ${c.reset}
-${rgb(120, 120, 255)}   ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗${c.reset}
-${rgb(150, 100, 255)}    ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝${c.reset}
-
-${c.dim}  ┌─────────────────────────────────────────────────────────────────────┐${c.reset}
-${c.dim}  │${c.reset}  ${rgb(255, 255, 255)}${c.bold}Route Integrity${c.reset} ${c.dim}•${c.reset} ${rgb(200, 200, 200)}Security${c.reset} ${c.dim}•${c.reset} ${rgb(150, 150, 150)}Quality${c.reset} ${c.dim}•${c.reset} ${rgb(100, 100, 100)}Ship with Confidence${c.reset}  ${c.dim}│${c.reset}
-${c.dim}  └─────────────────────────────────────────────────────────────────────┘${c.reset}
+${ansi.rgb(0, 200, 255)}  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗${ansi.reset}
+${ansi.rgb(30, 180, 255)}  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝${ansi.reset}
+${ansi.rgb(60, 160, 255)}  ██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝ ${ansi.reset}
+${ansi.rgb(90, 140, 255)}  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ ${ansi.reset}
+${ansi.rgb(120, 120, 255)}   ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗${ansi.reset}
+${ansi.rgb(150, 100, 255)}    ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝${ansi.reset}
+
+${ansi.dim}  ┌─────────────────────────────────────────────────────────────────────┐${ansi.reset}
+${ansi.dim}  │${ansi.reset}  ${ansi.rgb(255, 255, 255)}${ansi.bold}Route Integrity${ansi.reset} ${ansi.dim}•${ansi.reset} ${ansi.rgb(200, 200, 200)}Security${ansi.reset} ${ansi.dim}•${ansi.reset} ${ansi.rgb(150, 150, 150)}Quality${ansi.reset} ${ansi.dim}•${ansi.reset} ${ansi.rgb(100, 100, 100)}Ship with Confidence${ansi.reset}  ${ansi.dim}│${ansi.reset}
+${ansi.dim}  └─────────────────────────────────────────────────────────────────────┘${ansi.reset}
 `;
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// TERMINAL UTILITIES
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const BOX_CHARS = {
-  topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯',
-  horizontal: '─', vertical: '│',
-  teeRight: '├', teeLeft: '┤', teeDown: '┬', teeUp: '┴',
-  cross: '┼',
-};
-
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-let spinnerIndex = 0;
-let spinnerInterval = null;
-
-function formatNumber(num) {
-  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
-}
-
-function truncate(str, len) {
-  if (str.length <= len) return str;
-  return str.slice(0, len - 3) + '...';
-}
-
-function progressBar(percent, width = 30) {
-  const filled = Math.round((percent / 100) * width);
-  const empty = width - filled;
-  const filledColor = percent >= 80 ? rgb(0, 255, 100) : percent >= 50 ? rgb(255, 200, 0) : rgb(255, 80, 80);
-  return `${filledColor}${'█'.repeat(filled)}${c.dim}${'░'.repeat(empty)}${c.reset}`;
-}
-
-function startSpinner(message) {
-  process.stdout.write(c.hideCursor);
-  spinnerInterval = setInterval(() => {
-    process.stdout.write(`\r  ${c.cyan}${SPINNER_FRAMES[spinnerIndex]}${c.reset} ${message}    `);
-    spinnerIndex = (spinnerIndex + 1) % SPINNER_FRAMES.length;
-  }, 80);
-}
-
-function stopSpinner(message, success = true) {
-  if (spinnerInterval) {
-    clearInterval(spinnerInterval);
-    spinnerInterval = null;
-  }
-  const icon = success ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`;
-  process.stdout.write(`\r${c.clearLine}  ${icon} ${message}\n`);
-  process.stdout.write(c.showCursor);
-}
-
 function printBanner() {
   console.log(BANNER);
 }
 
-function printDivider(char = '─', color = c.dim) {
-  console.log(`${color}  ${char.repeat(69)}${c.reset}`);
-}
-
-function printSection(title, icon = '◆') {
-  console.log();
-  console.log(`  ${rgb(100, 200, 255)}${icon}${c.reset} ${c.bold}${title}${c.reset}`);
-  printDivider();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// SCORE DISPLAY
-// ═══════════════════════════════════════════════════════════════════════════════
-
-function getScoreColor(score) {
-  if (score >= 90) return rgb(0, 255, 100);
-  if (score >= 80) return rgb(100, 255, 100);
-  if (score >= 70) return rgb(200, 255, 0);
-  if (score >= 60) return rgb(255, 200, 0);
-  if (score >= 50) return rgb(255, 150, 0);
-  return rgb(255, 80, 80);
-}
-
-function getGradeColor(grade) {
-  const colors = {
-    'A': rgb(0, 255, 100),
-    'B': rgb(100, 255, 100),
-    'C': rgb(255, 200, 0),
-    'D': rgb(255, 150, 0),
-    'F': rgb(255, 80, 80),
-  };
-  return colors[grade] || c.white;
-}
-
-function printScoreCard(score, grade, canShip) {
-  const scoreColor = getScoreColor(score);
-  const gradeColor = getGradeColor(grade);
-  
-  console.log();
-  console.log(`  ${c.dim}╭────────────────────────────────────────────────────────────────╮${c.reset}`);
-  console.log(`  ${c.dim}│${c.reset}                                                                ${c.dim}│${c.reset}`);
-  
-  const scoreStr = `${score}`;
-  const scorePadding = ' '.repeat(Math.max(0, 3 - scoreStr.length));
-  console.log(`  ${c.dim}│${c.reset}     ${c.dim}INTEGRITY SCORE${c.reset}    ${scoreColor}${c.bold}${scorePadding}${scoreStr}${c.reset}${c.dim}/100${c.reset}     ${c.dim}GRADE${c.reset}  ${gradeColor}${c.bold}${grade}${c.reset}            ${c.dim}│${c.reset}`);
-  console.log(`  ${c.dim}│${c.reset}                                                                ${c.dim}│${c.reset}`);
-  console.log(`  ${c.dim}│${c.reset}     ${progressBar(score, 40)}              ${c.dim}│${c.reset}`);
-  console.log(`  ${c.dim}│${c.reset}                                                                ${c.dim}│${c.reset}`);
-  
-  if (canShip) {
-    console.log(`  ${c.dim}│${c.reset}              ${bgRgb(0, 150, 80)}${c.bold}  ✓ CLEAR TO SHIP  ${c.reset}                       ${c.dim}│${c.reset}`);
-  } else {
-    console.log(`  ${c.dim}│${c.reset}              ${bgRgb(200, 50, 50)}${c.bold}  ✗ NOT SHIP READY  ${c.reset}                      ${c.dim}│${c.reset}`);
-  }
-  
-  console.log(`  ${c.dim}│${c.reset}                                                                ${c.dim}│${c.reset}`);
-  console.log(`  ${c.dim}╰────────────────────────────────────────────────────────────────╯${c.reset}`);
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// COVERAGE MAP VISUALIZATION
-// ═══════════════════════════════════════════════════════════════════════════════
-
+// Legacy compatibility functions - now use enhanced modules
 function printCoverageMap(coverageMap) {
-  printSection('NAVIGATION COVERAGE', '🗺️');
-  
-  const pct = coverageMap.coveragePercent;
-  const color = pct >= 80 ? rgb(0, 255, 100) : pct >= 60 ? rgb(255, 200, 0) : rgb(255, 80, 80);
-  
-  console.log();
-  console.log(`  ${color}${c.bold}${pct}%${c.reset} ${c.dim}of shipped routes reachable from${c.reset} ${c.cyan}/${c.reset}`);
-  console.log(`  ${progressBar(pct, 50)}`);
-  console.log();
-  console.log(`  ${c.dim}Routes:${c.reset} ${coverageMap.reachableFromRoot}${c.dim}/${c.reset}${coverageMap.totalShippedRoutes} ${c.dim}reachable${c.reset}`);
-  
-  if (coverageMap.isolatedClusters && coverageMap.isolatedClusters.length > 0) {
-    console.log();
-    console.log(`  ${c.yellow}⚠${c.reset} ${c.dim}Isolated clusters:${c.reset}`);
-    for (const cluster of coverageMap.isolatedClusters.slice(0, 3)) {
-      const auth = cluster.requiresAuth ? ` ${c.dim}(auth)${c.reset}` : '';
-      console.log(`    ${c.dim}├─${c.reset} ${c.bold}${cluster.name}${c.reset}${auth} ${c.dim}(${cluster.nodeIds.length} routes)${c.reset}`);
-    }
-  }
-  
-  if (coverageMap.unreachableRoutes && coverageMap.unreachableRoutes.length > 0) {
-    console.log();
-    console.log(`  ${c.red}✗${c.reset} ${c.dim}Unreachable routes:${c.reset}`);
-    for (const route of coverageMap.unreachableRoutes.slice(0, 5)) {
-      console.log(`    ${c.dim}├─${c.reset} ${c.red}${route}${c.reset}`);
-    }
-    if (coverageMap.unreachableRoutes.length > 5) {
-      console.log(`    ${c.dim}└─ ... and ${coverageMap.unreachableRoutes.length - 5} more${c.reset}`);
-    }
-  }
+  const { renderCoverageMap } = require("./lib/scan-output");
+  console.log(renderCoverageMap(coverageMap));
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// BREAKDOWN DISPLAY
-// ═══════════════════════════════════════════════════════════════════════════════
-
 function printBreakdown(breakdown) {
-  printSection('BREAKDOWN', '📊');
-  console.log();
-  
-  const items = [
-    { key: 'deadLinks', label: 'Dead Links', icon: '🔗', color: rgb(255, 100, 100) },
-    { key: 'orphanRoutes', label: 'Orphan Routes', icon: '👻', color: rgb(200, 150, 255) },
-    { key: 'runtimeFailures', label: 'Runtime 404s', icon: '💥', color: rgb(255, 80, 80) },
-    { key: 'unresolvedDynamic', label: 'Unresolved Dynamic', icon: '❓', color: rgb(255, 200, 100) },
-    { key: 'placeholders', label: 'Placeholders', icon: '📝', color: rgb(255, 180, 100) },
-  ];
-  
-  for (const item of items) {
-    const data = breakdown[item.key] || { count: 0, penalty: 0 };
-    const status = data.count === 0 ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`;
-    const countColor = data.count === 0 ? c.green : item.color;
-    const countStr = String(data.count).padStart(3);
-    const penaltyStr = data.penalty > 0 ? `${c.dim}-${data.penalty} pts${c.reset}` : `${c.dim}    ---${c.reset}`;
-    
-    console.log(`  ${status} ${item.icon} ${item.label.padEnd(22)} ${countColor}${c.bold}${countStr}${c.reset}  ${penaltyStr}`);
-  }
+  const { renderBreakdown } = require("./lib/scan-output");
+  console.log(renderBreakdown(breakdown));
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// BLOCKERS DISPLAY
-// ═══════════════════════════════════════════════════════════════════════════════
-
 function printBlockers(blockers) {
-  if (!blockers || blockers.length === 0) {
-    printSection('SHIP BLOCKERS', '🚀');
-    console.log();
-    console.log(`  ${c.green}${c.bold}✓ No blockers! You're clear to ship.${c.reset}`);
-    return;
-  }
-  
-  printSection(`SHIP BLOCKERS (${blockers.length})`, '🚨');
-  console.log();
-  
-  for (const blocker of blockers.slice(0, 8)) {
-    const sevColor = blocker.severity === 'critical' ? bgRgb(180, 40, 40) : bgRgb(180, 120, 0);
-    const sevLabel = blocker.severity === 'critical' ? 'CRITICAL' : '  HIGH  ';
-    
-    console.log(`  ${sevColor}${c.bold} ${sevLabel} ${c.reset} ${c.bold}${truncate(blocker.title, 45)}${c.reset}`);
-    console.log(`  ${c.dim}           ${truncate(blocker.description, 55)}${c.reset}`);
-    if (blocker.file) {
-      const fileDisplay = path.basename(blocker.file) + (blocker.line ? `:${blocker.line}` : '');
-      console.log(`  ${c.dim}           ${c.reset}${c.cyan}${fileDisplay}${c.reset}`);
-    }
-    if (blocker.fixSuggestion) {
-      console.log(`  ${c.dim}           ${c.green}→ ${blocker.fixSuggestion}${c.reset}`);
-    }
-    console.log();
-  }
-  
-  if (blockers.length > 8) {
-    console.log(`  ${c.dim}... and ${blockers.length - 8} more blockers (see full report)${c.reset}`);
-  }
+  const { renderBlockers } = require("./lib/scan-output");
+  console.log(renderBlockers(blockers));
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// LAYERS DISPLAY
-// ═══════════════════════════════════════════════════════════════════════════════
-
 function printLayers(layers) {
-  printSection('ANALYSIS LAYERS', '⚡');
-  console.log();
-  
-  const layerInfo = {
-    ast: { name: 'AST Analysis', icon: '🔍', desc: 'Static code analysis' },
-    truth: { name: 'Build Truth', icon: '📦', desc: 'Manifest verification' },
-    reality: { name: 'Reality Proof', icon: '🎭', desc: 'Playwright crawl' },
-  };
-  
-  for (const layer of layers) {
-    const info = layerInfo[layer.layer] || { name: layer.layer, icon: '○', desc: '' };
-    const status = layer.executed ? `${c.green}✓${c.reset}` : `${c.dim}○${c.reset}`;
-    const duration = layer.executed ? `${c.dim}${layer.duration}ms${c.reset}` : `${c.dim}skipped${c.reset}`;
-    const findings = layer.executed ? `${c.cyan}${layer.findings}${c.reset} ${c.dim}findings${c.reset}` : '';
-    
-    console.log(`  ${status} ${info.icon} ${c.bold}${info.name.padEnd(15)}${c.reset} ${duration.padEnd(20)} ${findings}`);
-  }
+  const { renderLayers } = require("./lib/scan-output");
+  console.log(renderLayers(layers));
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -351,6 +94,8 @@ function parseArgs(args) {
     sarif: false,
     verbose: false,
     help: false,
+    autofix: false,
+    save: true, // Always save results by default
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -364,6 +109,8 @@ function parseArgs(args) {
     else if (arg === '--sarif') opts.sarif = true;
     else if (arg === '--verbose' || arg === '-v') opts.verbose = true;
     else if (arg === '--help' || arg === '-h') opts.help = true;
+    else if (arg === '--autofix' || arg === '--fix' || arg === '-f') opts.autofix = true;
+    else if (arg === '--no-save') opts.save = false;
     else if (arg === '--path' || arg === '-p') opts.path = args[++i];
     else if (arg.startsWith('--path=')) opts.path = arg.split('=')[1];
     else if (!arg.startsWith('-')) opts.path = path.resolve(arg);
@@ -375,33 +122,315 @@ function parseArgs(args) {
 function printHelp() {
   console.log(BANNER);
   console.log(`
-  ${c.bold}Usage:${c.reset} vibecheck scan [path] [options]
-
-  ${c.bold}Scan Modes:${c.reset}
-    ${c.cyan}(default)${c.reset}       Layer 1: AST static analysis ${c.dim}(fast)${c.reset}
-    ${c.cyan}--truth, -t${c.reset}     Layer 1+2: Include build manifest verification ${c.dim}(CI/ship)${c.reset}
-    ${c.cyan}--reality, -r${c.reset}   Layer 1+2+3: Include Playwright runtime proof ${c.dim}(full)${c.reset}
-    ${c.cyan}--reality-sniff${c.reset} Include Reality Sniff AI artifact detection ${c.dim}(recommended)${c.reset}
-
-  ${c.bold}Options:${c.reset}
-    ${c.cyan}--url, -u${c.reset}       Base URL for reality testing (e.g., http://localhost:3000)
-    ${c.cyan}--verbose, -v${c.reset}   Show detailed progress
-    ${c.cyan}--json${c.reset}          Output results as JSON
-    ${c.cyan}--sarif${c.reset}         Output in SARIF format (GitHub code scanning)
-    ${c.cyan}--help, -h${c.reset}      Show this help
-
-  ${c.bold}Examples:${c.reset}
-    ${c.dim}# Quick scan (AST only)${c.reset}
+  ${ansi.bold}Usage:${ansi.reset} vibecheck scan [path] [options]
+
+  ${ansi.bold}Scan Modes:${ansi.reset}
+    ${colors.accent}(default)${ansi.reset}       Layer 1: AST static analysis ${ansi.dim}(fast)${ansi.reset}
+    ${colors.accent}--truth, -t${ansi.reset}     Layer 1+2: Include build manifest verification ${ansi.dim}(CI/ship)${ansi.reset}
+    ${colors.accent}--reality, -r${ansi.reset}   Layer 1+2+3: Include Playwright runtime proof ${ansi.dim}(full)${ansi.reset}
+    ${colors.accent}--reality-sniff${ansi.reset} Include Reality Sniff AI artifact detection ${ansi.dim}(recommended)${ansi.reset}
+
+  ${ansi.bold}Fix Mode:${ansi.reset}
+    ${colors.accent}--autofix, -f${ansi.reset}   Apply safe fixes + generate AI missions ${ansi.rgb(0, 200, 255)}[STARTER]${ansi.reset}
+
+  ${ansi.bold}Options:${ansi.reset}
+    ${colors.accent}--url, -u${ansi.reset}       Base URL for reality testing (e.g., http://localhost:3000)
+    ${colors.accent}--verbose, -v${ansi.reset}   Show detailed progress
+    ${colors.accent}--json${ansi.reset}          Output results as JSON
+    ${colors.accent}--sarif${ansi.reset}         Output in SARIF format (GitHub code scanning)
+    ${colors.accent}--no-save${ansi.reset}       Don't save results to .vibecheck/results/
+    ${colors.accent}--help, -h${ansi.reset}      Show this help
+
+  ${ansi.bold}Examples:${ansi.reset}
+    ${ansi.dim}# Quick scan (AST only)${ansi.reset}
     vibecheck scan
 
-    ${c.dim}# CI/CD scan with manifest verification${c.reset}
+    ${ansi.dim}# Scan + autofix with missions${ansi.reset}
+    vibecheck scan --autofix
+
+    ${ansi.dim}# CI/CD scan with manifest verification${ansi.reset}
     vibecheck scan --truth
 
-    ${c.dim}# Full proof with Playwright${c.reset}
+    ${ansi.dim}# Full proof with Playwright${ansi.reset}
     vibecheck scan --reality --url http://localhost:3000
+
+  ${ansi.bold}Output:${ansi.reset}
+    Results saved to: .vibecheck/results/latest.json
+    Missions saved to: .vibecheck/missions/ ${ansi.dim}(with --autofix)${ansi.reset}
   `);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// AUTOFIX & MISSION GENERATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Normalize severity values to standard format
+ */
+function normalizeSeverity(severity) {
+  if (!severity) return 'medium';
+  const sev = String(severity).toLowerCase();
+  if (sev === 'block' || sev === 'critical') return 'critical';
+  if (sev === 'high') return 'high';
+  if (sev === 'warn' || sev === 'warning' || sev === 'medium') return 'medium';
+  if (sev === 'info' || sev === 'low') return 'low';
+  return 'medium'; // Default fallback
+}
+
+async function generateMissions(findings, projectPath, opts) {
+  const missionsDir = path.join(projectPath, '.vibecheck', 'missions');
+  
+  // Ensure missions directory exists
+  if (!fs.existsSync(missionsDir)) {
+    fs.mkdirSync(missionsDir, { recursive: true });
+  }
+  
+  const missions = [];
+  const missionIndex = [];
+  
+  for (let i = 0; i < findings.length; i++) {
+    const finding = findings[i];
+    const missionId = `mission-${String(i + 1).padStart(3, '0')}`;
+    const normalizedSeverity = normalizeSeverity(finding.severity);
+    
+    // Generate AI-ready mission prompt
+    const mission = {
+      id: missionId,
+      createdAt: new Date().toISOString(),
+      finding: {
+        id: finding.id || `finding-${i + 1}`,
+        severity: normalizedSeverity,
+        originalSeverity: finding.severity, // Keep original for reference
+        category: finding.category,
+        title: finding.title || finding.message,
+        file: finding.file,
+        line: finding.line,
+      },
+      prompt: generateMissionPrompt(finding),
+      constraints: generateConstraints(finding),
+      verification: generateVerificationSteps(finding),
+      status: 'pending',
+    };
+    
+    missions.push(mission);
+    missionIndex.push({
+      id: missionId,
+      severity: normalizedSeverity,
+      title: finding.title || finding.message,
+      file: finding.file,
+      status: 'pending',
+    });
+    
+    // Save individual mission JSON
+    const missionPath = path.join(missionsDir, `${missionId}.json`);
+    fs.writeFileSync(missionPath, JSON.stringify(mission, null, 2));
+  }
+  
+  // Generate MISSIONS.md index
+  const missionsMarkdown = generateMissionsMarkdown(missionIndex, projectPath);
+  fs.writeFileSync(path.join(missionsDir, 'MISSIONS.md'), missionsMarkdown);
+  
+  // Save missions summary
+  const summary = {
+    generatedAt: new Date().toISOString(),
+    totalMissions: missions.length,
+    bySeverity: {
+      critical: missionIndex.filter(m => m.severity === 'critical').length,
+      high: missionIndex.filter(m => m.severity === 'high').length,
+      medium: missionIndex.filter(m => m.severity === 'medium').length,
+      low: missionIndex.filter(m => m.severity === 'low').length,
+    },
+    missions: missionIndex,
+  };
+  fs.writeFileSync(path.join(missionsDir, 'summary.json'), JSON.stringify(summary, null, 2));
+  
+  return { missions, summary };
+}
+
+function generateMissionPrompt(finding) {
+  const file = finding.file || 'unknown file';
+  const line = finding.line ? ` at line ${finding.line}` : '';
+  const title = finding.title || finding.message || 'Unknown issue';
+  const category = finding.category || 'general';
+  
+  let prompt = `## Mission: Fix ${title}
+
+**File:** \`${file}\`${line}
+**Category:** ${category}
+**Severity:** ${finding.severity || 'medium'}
+
+### Problem
+${finding.message || title}
+
+### Context
+`;
+
+  // Add category-specific context
+  if (category === 'ROUTE' || category === 'routes') {
+    prompt += `This is a route integrity issue. The route may be:
+- Referenced but not defined
+- Defined but not reachable
+- Missing proper error handling
+`;
+  } else if (category === 'ENV' || category === 'env') {
+    prompt += `This is an environment variable issue. The variable may be:
+- Used but not defined in .env
+- Missing from .env.example
+- Not documented
+`;
+  } else if (category === 'AUTH' || category === 'auth' || category === 'security') {
+    prompt += `This is a security/authentication issue. Check for:
+- Proper authentication middleware
+- Authorization checks
+- Secure defaults
+`;
+  } else if (category === 'MOCK' || category === 'mock') {
+    prompt += `This is a mock/placeholder issue. The code may contain:
+- TODO comments that need implementation
+- Placeholder data that should be real
+- Fake success responses
+`;
+  }
+
+  prompt += `
+### Requirements
+1. Fix the issue while maintaining existing functionality
+2. Follow the project's coding style and patterns
+3. Add appropriate error handling
+4. Update tests if they exist
+
+### Verification
+After making changes:
+1. Run \`vibecheck scan\` to verify the issue is resolved
+2. Run any existing tests for the affected file
+3. Manually verify the functionality if applicable
+`;
+
+  if (finding.fix || finding.fixSuggestion) {
+    prompt += `
+### Suggested Fix
+${finding.fix || finding.fixSuggestion}
+`;
+  }
+
+  return prompt;
+}
+
+function generateConstraints(finding) {
+  const constraints = [
+    'Do not break existing functionality',
+    'Follow existing code patterns in the project',
+    'Add error handling where appropriate',
+  ];
+  
+  if (finding.category === 'security' || finding.category === 'AUTH') {
+    constraints.push('Ensure no security regressions');
+    constraints.push('Follow OWASP security guidelines');
+  }
+  
+  if (finding.category === 'ROUTE' || finding.category === 'routes') {
+    constraints.push('Maintain API backwards compatibility');
+    constraints.push('Update route documentation if changed');
+  }
+  
+  return constraints;
+}
+
+function generateVerificationSteps(finding) {
+  const steps = [
+    'Run `vibecheck scan` and confirm this issue no longer appears',
+    'Run `vibecheck checkpoint` to ensure no regressions',
+  ];
+  
+  if (finding.file) {
+    steps.push(`Review changes in \`${finding.file}\``);
+  }
+  
+  if (finding.category === 'ROUTE' || finding.category === 'routes') {
+    steps.push('Test the affected route(s) manually or with automated tests');
+  }
+  
+  if (finding.category === 'ENV' || finding.category === 'env') {
+    steps.push('Verify environment variable is properly documented');
+    steps.push('Check .env.example is updated');
+  }
+  
+  return steps;
+}
+
+function generateMissionsMarkdown(missionIndex, projectPath) {
+  const projectName = path.basename(projectPath);
+  const now = new Date().toISOString();
+  
+  let md = `# Vibecheck Missions
+
+> Generated: ${now}
+> Project: ${projectName}
+
+## Summary
+
+| Severity | Count |
+|----------|-------|
+| Critical | ${missionIndex.filter(m => m.severity === 'critical').length} |
+| High | ${missionIndex.filter(m => m.severity === 'high').length} |
+| Medium | ${missionIndex.filter(m => m.severity === 'medium').length} |
+| Low | ${missionIndex.filter(m => m.severity === 'low').length} |
+| **Total** | **${missionIndex.length}** |
+
+## Missions
+
+`;
+
+  // Group by severity
+  const bySeverity = {
+    critical: missionIndex.filter(m => m.severity === 'critical'),
+    high: missionIndex.filter(m => m.severity === 'high'),
+    medium: missionIndex.filter(m => m.severity === 'medium'),
+    low: missionIndex.filter(m => m.severity === 'low'),
+  };
+
+  for (const [severity, missions] of Object.entries(bySeverity)) {
+    if (missions.length === 0) continue;
+    
+    const emoji = severity === 'critical' ? '🔴' : severity === 'high' ? '🟠' : severity === 'medium' ? '🟡' : '🔵';
+    md += `### ${emoji} ${severity.charAt(0).toUpperCase() + severity.slice(1)} (${missions.length})\n\n`;
+    
+    for (const mission of missions) {
+      const checkbox = mission.status === 'completed' ? '[x]' : '[ ]';
+      md += `- ${checkbox} **${mission.id}**: ${mission.title}\n`;
+      if (mission.file) {
+        md += `  - File: \`${mission.file}\`\n`;
+      }
+    }
+    md += '\n';
+  }
+
+  md += `---
+
+## How to Use
+
+1. **Review missions**: Read each mission file in \`.vibecheck/missions/\`
+2. **Copy prompts**: Use the prompt in each mission file with your AI assistant
+3. **Verify fixes**: Run \`vibecheck scan\` after each fix
+4. **Track progress**: Update mission status in this file
+
+## Commands
+
+\`\`\`bash
+# Re-scan after fixes
+vibecheck scan
+
+# Check progress
+vibecheck checkpoint
+
+# Final verification
+vibecheck ship
+\`\`\`
+`;
+
+  return md;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // MAIN SCAN FUNCTION - ROUTE INTEGRITY SYSTEM
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -426,8 +455,8 @@ async function runScan(args) {
     }
     // Network error - fall back to free tier only (SECURITY: never grant paid features offline)
     if (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT' || err.code === 'ENOTFOUND' || err.name === 'NetworkError') {
-      console.warn(`  ${c.yellow}⚠${c.reset} API unavailable, running in ${c.green}FREE${c.reset} tier mode`);
-      console.warn(`  ${c.dim}Paid features require API connection. Continuing with free features only.${c.reset}\n`);
+      console.warn(`  ${colors.warning}⚠${ansi.reset} API unavailable, running in ${colors.success}FREE${ansi.reset} tier mode`);
+      console.warn(`  ${ansi.dim}Paid features require API connection. Continuing with free features only.${ansi.reset}\n`);
       // Continue with free tier features only - scan command is free tier
     } else {
       throw err; // Re-throw unexpected errors
@@ -464,19 +493,22 @@ async function runScan(args) {
   if (layers.reality) layerNames.push('Reality');
   if (layers.realitySniff) layerNames.push('Reality Sniff');
 
-  console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
-  console.log(`  ${c.dim}Path:${c.reset}     ${projectPath}`);
-  console.log(`  ${c.dim}Layers:${c.reset}   ${c.cyan}${layerNames.join(' → ')}${c.reset}`);
+  console.log(`  ${ansi.dim}Project:${ansi.reset}  ${ansi.bold}${projectName}${ansi.reset}`);
+  console.log(`  ${ansi.dim}Path:${ansi.reset}     ${projectPath}`);
+  console.log(`  ${ansi.dim}Layers:${ansi.reset}   ${colors.accent}${layerNames.join(' → ')}${ansi.reset}`);
   console.log();
 
   // Reality layer requires URL
   if (opts.reality && !opts.baseUrl) {
-    console.log(`  ${c.yellow}⚠${c.reset} ${c.bold}Reality layer requires --url${c.reset}`);
-    console.log(`  ${c.dim}Example: vibecheck scan --reality --url http://localhost:3000${c.reset}`);
+    console.log(`  ${colors.warning}⚠${ansi.reset} ${ansi.bold}Reality layer requires --url${ansi.reset}`);
+    console.log(`  ${ansi.dim}Example: vibecheck scan --reality --url http://localhost:3000${ansi.reset}`);
     console.log();
     return 1;
   }
 
+  // Initialize spinner outside try block for error handling
+  let spinner = null;
+  
   try {
     // Import systems - try TypeScript compiled first, fallback to JS runtime
     let scanRouteIntegrity;
@@ -539,7 +571,7 @@ async function runScan(args) {
     }
     
     // Try to import new unified output system (may not be compiled yet)
-    let buildVerdictOutput, normalizeFinding, formatStandardOutput, formatScanOutput, getExitCode, CacheManager;
+    let buildVerdictOutput, normalizeFinding, formatStandardOutput, formatScanOutputFromUnified, getExitCodeFromUnified, CacheManager;
     let useUnifiedOutput = false;
     
     try {
@@ -549,8 +581,8 @@ async function runScan(args) {
       formatStandardOutput = outputContract.formatStandardOutput;
       
       const unifiedOutput = require('./lib/unified-output');
-      formatScanOutput = unifiedOutput.formatScanOutput;
-      getExitCode = unifiedOutput.getExitCode;
+      formatScanOutputFromUnified = unifiedOutput.formatScanOutput;
+      getExitCodeFromUnified = unifiedOutput.getExitCode;
       
       const cacheModule = require('../../dist/lib/cli/cache-manager');
       CacheManager = cacheModule.CacheManager;
@@ -558,7 +590,7 @@ async function runScan(args) {
     } catch (error) {
       // Fallback to old system if new one not available
       if (opts.verbose) {
-        console.warn('Unified output system not available, using legacy format');
+        console.warn('Unified output system not available, using enhanced format');
       }
       useUnifiedOutput = false;
     }
@@ -594,17 +626,18 @@ async function runScan(args) {
             return getExitCode(verdict);
           }
 
-          console.log(formatScanOutput({ verdict, findings: cachedResult.findings }, { verbose: opts.verbose, json: opts.json }));
+          console.log(formatScanOutput({ verdict, findings: cachedResult.findings, cached }, { verbose: opts.verbose }));
           return getExitCode(verdict);
         }
       }
     }
 
-    // Start scanning with spinner
+    // Start scanning with enhanced spinner
     const timings = { discovery: 0, analysis: 0, verification: 0, detection: 0, total: 0 };
     timings.discovery = Date.now();
 
-    startSpinner('Analyzing codebase...');
+    spinner = new Spinner({ color: colors.primary });
+    spinner.start('Analyzing codebase...');
 
     const result = await scanRouteIntegrity({
       projectPath,
@@ -612,8 +645,8 @@ async function runScan(args) {
       baseUrl: opts.baseUrl,
       verbose: opts.verbose,
       onProgress: opts.verbose ? (phase, progress) => {
-        stopSpinner(`${phase}: ${Math.round(progress)}%`, true);
-        if (progress < 100) startSpinner(`Running ${phase}...`);
+        spinner.succeed(`${phase}: ${Math.round(progress)}%`);
+        if (progress < 100) spinner.start(`Running ${phase}...`);
       } : undefined,
     });
 
@@ -689,24 +722,24 @@ async function runScan(args) {
       }
       
       timings.detection = Date.now() - detectionStart;
-      stopSpinner(`Detection complete (${detectionFindings.length} findings)`, true);
+      spinner.succeed(`Detection complete (${detectionFindings.length} findings)`);
     } catch (detectionError) {
       // Detection engines not compiled yet - continue without them
       if (opts.verbose) {
-        console.log(`  ${c.dim}Detection engines not available: ${detectionError.message}${c.reset}`);
+        console.log(`  ${ansi.dim}Detection engines not available: ${detectionError.message}${ansi.reset}`);
       }
-      stopSpinner('Detection skipped (not compiled)', true);
+      spinner.warn('Detection skipped (not compiled)');
     }
     
     timings.verification = Date.now() - timings.analysis - timings.discovery;
     timings.total = Date.now() - startTime;
 
-    stopSpinner('Analysis complete', true);
+    spinner.succeed('Analysis complete');
 
     const { report, outputPaths } = result;
 
-    // Use new unified output if available, otherwise fallback to old format
-    if (useUnifiedOutput && buildVerdictOutput && normalizeFinding) {
+    // Use new unified output if available, otherwise fallback to enhanced format
+    if (useUnifiedOutput && buildVerdictOutput && normalizeFinding && formatScanOutputFromUnified) {
       // Normalize findings with stable IDs
       const existingIDs = new Set();
       const normalizedFindings = [];
@@ -765,22 +798,34 @@ async function runScan(args) {
     // JSON output mode
     if (opts.json) {
       console.log(JSON.stringify(standardOutput, null, 2));
-      return getExitCode(verdict);
+      return getExitCodeFromUnified ? getExitCodeFromUnified(verdict) : getExitCode(verdict);
     }
 
     // SARIF output mode
     if (opts.sarif) {
-      const sarifContent = fs.readFileSync(outputPaths.sarif, 'utf8');
-      console.log(sarifContent);
-      return report.score.overall >= 70 ? 0 : 1;
+      const sarif = formatSARIF(normalizedFindings, { 
+        projectPath, 
+        version: require('../../package.json').version || '1.0.0' 
+      });
+      console.log(JSON.stringify(sarif, null, 2));
+      return getExitCodeFromUnified ? getExitCodeFromUnified(verdict) : getExitCode(verdict);
     }
 
     // ═══════════════════════════════════════════════════════════════════════════
-    // UNIFIED OUTPUT
+    // ENHANCED OUTPUT
     // ═══════════════════════════════════════════════════════════════════════════
 
-    // Use unified output formatter
-    console.log(formatScanOutput({ verdict, findings: normalizedFindings }, { verbose: opts.verbose, json: false }));
+    // Use enhanced output formatter (from scan-output.js)
+    const resultForOutput = {
+      verdict,
+      findings: normalizedFindings,
+      layers: report.layers || [],
+      coverage: report.coverageMap,
+      breakdown: report.score?.breakdown,
+      timings,
+      cached,
+    };
+    console.log(formatScanOutput(resultForOutput, { verbose: opts.verbose }));
 
     // Additional details if verbose
     if (opts.verbose) {
@@ -797,6 +842,66 @@ async function runScan(args) {
       }
     }
 
+    // ═══════════════════════════════════════════════════════════════════════════
+    // SAVE RESULTS
+    // ═══════════════════════════════════════════════════════════════════════════
+    
+    if (opts.save) {
+      const resultsDir = path.join(projectPath, '.vibecheck', 'results');
+      if (!fs.existsSync(resultsDir)) {
+        fs.mkdirSync(resultsDir, { recursive: true });
+      }
+      
+      // Save latest.json
+      const latestPath = path.join(resultsDir, 'latest.json');
+      fs.writeFileSync(latestPath, JSON.stringify(standardOutput, null, 2));
+      
+      // Save timestamped copy
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const historyDir = path.join(resultsDir, 'history');
+      if (!fs.existsSync(historyDir)) {
+        fs.mkdirSync(historyDir, { recursive: true });
+      }
+      fs.writeFileSync(path.join(historyDir, `scan-${timestamp}.json`), JSON.stringify(standardOutput, null, 2));
+      
+      if (!opts.json) {
+        console.log(`\n  ${ansi.dim}Results saved to: ${latestPath}${ansi.reset}`);
+      }
+    }
+    
+    // ═══════════════════════════════════════════════════════════════════════════
+    // AUTOFIX MODE - Generate missions
+    // ═══════════════════════════════════════════════════════════════════════════
+    
+    if (opts.autofix && normalizedFindings.length > 0) {
+      // Check entitlement
+      const entitlementsV2 = require("./lib/entitlements-v2");
+      const access = await entitlementsV2.enforce("scan.autofix", { 
+        projectPath,
+        silent: false,
+      });
+      
+      if (!access.allowed) {
+        console.log(`\n  ${colors.warning}${icons.warning}${ansi.reset} ${ansi.bold}--autofix requires STARTER plan${ansi.reset}`);
+        console.log(`  ${ansi.dim}Upgrade at: https://vibecheckai.dev/pricing${ansi.reset}`);
+        console.log(`  ${ansi.dim}Scan results saved. Run 'vibecheck fix' for manual mission generation.${ansi.reset}\n`);
+      } else {
+        console.log(`\n  ${colors.accent}${icons.lightning}${ansi.reset} ${ansi.bold}Generating AI missions...${ansi.reset}\n`);
+        
+        const { missions, summary } = await generateMissions(normalizedFindings, projectPath, opts);
+        
+        console.log(`  ${colors.success}✓${ansi.reset} Generated ${missions.length} missions`);
+        console.log(`    ${ansi.dim}Critical: ${summary.bySeverity.critical}${ansi.reset}`);
+        console.log(`    ${ansi.dim}High: ${summary.bySeverity.high}${ansi.reset}`);
+        console.log(`    ${ansi.dim}Medium: ${summary.bySeverity.medium}${ansi.reset}`);
+        console.log(`    ${ansi.dim}Low: ${summary.bySeverity.low}${ansi.reset}`);
+        console.log();
+        console.log(`  ${ansi.dim}Missions saved to: .vibecheck/missions/${ansi.reset}`);
+        console.log(`  ${ansi.dim}Open MISSIONS.md for prompts to use with your AI assistant.${ansi.reset}`);
+        console.log();
+      }
+    }
+
     // Emit audit event for scan complete
     emitScanComplete(projectPath, verdict.verdict === 'PASS' ? 'success' : 'failure', {
       score: report.score?.overall || (verdict.verdict === 'PASS' ? 100 : 50),
@@ -805,7 +910,7 @@ async function runScan(args) {
       durationMs: timings.total,
     });
 
-    return getExitCode(verdict);
+    return getExitCodeFromUnified ? getExitCodeFromUnified(verdict) : getExitCode(verdict);
     } else {
       // Legacy fallback output when unified output system isn't available
       const findings = [...(report.shipBlockers || []), ...detectionFindings];
@@ -814,40 +919,32 @@ async function runScan(args) {
       
       const verdict = criticalCount > 0 ? 'BLOCK' : warningCount > 0 ? 'WARN' : 'SHIP';
       
-      // Print simple output
-      console.log();
-      console.log(`  ${c.bold}═══════════════════════════════════════════════════════════════════${c.reset}`);
-      
-      if (verdict === 'SHIP') {
-        console.log(`  ${c.bgGreen}${c.white}${c.bold}  ✓ SHIP  ${c.reset} ${c.green}Ready to ship!${c.reset}`);
-      } else if (verdict === 'WARN') {
-        console.log(`  ${c.bgYellow}${c.black}${c.bold}  ⚠ WARN  ${c.reset} ${c.yellow}Review recommended before shipping${c.reset}`);
-      } else {
-        console.log(`  ${c.bgRed}${c.white}${c.bold}  ✗ BLOCK ${c.reset} ${c.red}Issues must be fixed before shipping${c.reset}`);
-      }
+      // Use enhanced output formatter for legacy fallback
+      const severityCounts = {
+        critical: criticalCount,
+        high: 0,
+        medium: warningCount,
+        low: findings.length - criticalCount - warningCount,
+      };
+      const score = calculateScore(severityCounts);
       
-      console.log(`  ${c.bold}═══════════════════════════════════════════════════════════════════${c.reset}`);
-      console.log();
+      const result = {
+        verdict: { verdict, score },
+        findings: findings.map(f => ({
+          severity: f.severity === 'critical' || f.severity === 'BLOCK' ? 'critical' :
+                   f.severity === 'warning' || f.severity === 'WARN' ? 'medium' : 'low',
+          category: f.category || 'ROUTE',
+          title: f.title || f.message,
+          message: f.message || f.title,
+          file: f.file,
+          line: f.line,
+          fix: f.fixSuggestion,
+        })),
+        layers: [],
+        timings,
+      };
       
-      if (findings.length > 0) {
-        console.log(`  ${c.bold}Findings (${findings.length})${c.reset}`);
-        console.log();
-        
-        for (const finding of findings.slice(0, 10)) {
-          const severityIcon = finding.severity === 'critical' || finding.severity === 'BLOCK' 
-            ? `${c.red}✗${c.reset}` 
-            : `${c.yellow}⚠${c.reset}`;
-          console.log(`  ${severityIcon} ${finding.title || finding.message}`);
-          if (finding.file) {
-            console.log(`    ${c.dim}${finding.file}${finding.line ? `:${finding.line}` : ''}${c.reset}`);
-          }
-        }
-        
-        if (findings.length > 10) {
-          console.log(`  ${c.dim}... and ${findings.length - 10} more findings${c.reset}`);
-        }
-        console.log();
-      }
+      console.log(formatScanOutput(result, { verbose: opts.verbose }));
       
       // Emit audit event
       emitScanComplete(projectPath, verdict === 'SHIP' ? 'success' : 'failure', {
@@ -860,10 +957,11 @@ async function runScan(args) {
     }
 
   } catch (error) {
-    stopSpinner(`Scan failed: ${error.message}`, false);
+    if (spinner) {
+      spinner.fail(`Scan failed: ${error.message}`);
+    }
     
-    // Use unified error handling
-    const { printError, EXIT_CODES } = require('./lib/unified-output');
+    // Use enhanced error handling
     const exitCode = printError(error, 'Scan');
     
     // Emit audit event for scan error