@vibecheckai/cli 3.7.0 → 3.8.0

package/bin/runners/lib/unified-cli-output.js

@@ -1,37 +1,45 @@
 /**
- * Unified CLI Output - Enterprise-Grade Terminal Experience
+ * Unified CLI Output - World-Class Terminal Experience
  * 
  * ═══════════════════════════════════════════════════════════════════════════════
- * VIBECHECK DESIGN SYSTEM
+ * THE VIBECHECK DESIGN SYSTEM v2.0
  * ═══════════════════════════════════════════════════════════════════════════════
  * 
- * This module provides consistent, professional output formatting for all CLI
- * commands. Use these functions to ensure a unified enterprise-grade experience.
+ * Provides consistent, professional terminal UI across all CLI commands:
+ *   • ASCII art banners (main + command-specific)
+ *   • Box-drawing layouts with split columns
+ *   • Progress bars and status indicators
+ *   • Verdicts and action sections
+ * 
+ * @version 2.0.0
  */
 
 "use strict";
 
-const { getApiKey } = require("./auth");
-
 // ═══════════════════════════════════════════════════════════════════════════════
 // CONSTANTS
 // ═══════════════════════════════════════════════════════════════════════════════
 
-const WIDTH = 72;
-const SUPPORTS_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
-const SUPPORTS_UNICODE = !process.env.NO_UNICODE && process.platform !== "win32" || process.env.WT_SESSION;
+const WIDTH = 80; // Standard terminal width
+const INNER_WIDTH = WIDTH - 4; // Inside borders
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // ANSI CODES
 // ═══════════════════════════════════════════════════════════════════════════════
 
 const ESC = "\x1b";
+const SUPPORTS_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+const SUPPORTS_TRUECOLOR = process.env.COLORTERM === "truecolor" || 
+  process.env.TERM_PROGRAM === "iTerm.app" ||
+  process.env.WT_SESSION;
+
 const ansi = SUPPORTS_COLOR ? {
   reset: `${ESC}[0m`,
   bold: `${ESC}[1m`,
   dim: `${ESC}[2m`,
   italic: `${ESC}[3m`,
   underline: `${ESC}[4m`,
+  // Standard colors
   red: `${ESC}[31m`,
   green: `${ESC}[32m`,
   yellow: `${ESC}[33m`,
@@ -40,514 +48,830 @@ const ansi = SUPPORTS_COLOR ? {
   cyan: `${ESC}[36m`,
   white: `${ESC}[37m`,
   gray: `${ESC}[90m`,
-  bgGreen: `${ESC}[42m`,
+  // Bright colors
+  brightRed: `${ESC}[91m`,
+  brightGreen: `${ESC}[92m`,
+  brightYellow: `${ESC}[93m`,
+  brightCyan: `${ESC}[96m`,
+  // Backgrounds
   bgRed: `${ESC}[41m`,
+  bgGreen: `${ESC}[42m`,
   bgYellow: `${ESC}[43m`,
-  bgCyan: `${ESC}[46m`,
+  bgBlue: `${ESC}[44m`,
   bgMagenta: `${ESC}[45m`,
+  bgCyan: `${ESC}[46m`,
+  // RGB (truecolor)
+  rgb: (r, g, b) => SUPPORTS_TRUECOLOR ? `${ESC}[38;2;${r};${g};${b}m` : "",
+  bgRgb: (r, g, b) => SUPPORTS_TRUECOLOR ? `${ESC}[48;2;${r};${g};${b}m` : "",
+  // Cursor control
+  hideCursor: `${ESC}[?25l`,
+  showCursor: `${ESC}[?25h`,
+  clearLine: `${ESC}[2K`,
+  cursorUp: (n = 1) => `${ESC}[${n}A`,
 } : Object.fromEntries([
   "reset", "bold", "dim", "italic", "underline",
   "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray",
-  "bgGreen", "bgRed", "bgYellow", "bgCyan", "bgMagenta"
+  "brightRed", "brightGreen", "brightYellow", "brightCyan",
+  "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan",
+  "hideCursor", "showCursor", "clearLine"
 ].map(k => [k, ""]));
 
+// Add stub functions if colors disabled
+if (!SUPPORTS_COLOR) {
+  ansi.rgb = () => "";
+  ansi.bgRgb = () => "";
+  ansi.cursorUp = () => "";
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // SYMBOLS
 // ═══════════════════════════════════════════════════════════════════════════════
 
-const sym = SUPPORTS_UNICODE ? {
+const sym = {
+  // Status
   check: "✓",
   cross: "✗",
   warning: "⚠",
   info: "ℹ",
-  arrow: "→",
   bullet: "•",
+  arrow: "→",
+  arrowRight: "▸",
   star: "★",
+  // Progress
+  blockFull: "█",
+  blockMed: "▓",
+  blockLight: "▒",
+  blockEmpty: "░",
+  // Box drawing (double)
+  boxTL: "╔",
+  boxTR: "╗",
+  boxBL: "╚",
+  boxBR: "╝",
+  boxH: "═",
+  boxV: "║",
+  boxTeeR: "╠",
+  boxTeeL: "╣",
+  boxTeeD: "╦",
+  boxTeeU: "╩",
+  boxCross: "╬",
+  // Box drawing (single)
+  lineTL: "┌",
+  lineTR: "┐",
+  lineBL: "└",
+  lineBR: "┘",
+  lineH: "─",
+  lineV: "│",
+  lineTeeR: "├",
+  lineTeeL: "┤",
+  lineTeeD: "┬",
+  lineTeeU: "┴",
+  lineCross: "┼",
+  // Emoji
   rocket: "🚀",
+  fire: "🔥",
+  brain: "🧠",
   shield: "🛡️",
-  lock: "🔒",
-  key: "🔑",
-  gear: "⚙",
   search: "🔍",
-  chart: "📊",
-  file: "📄",
-  folder: "📁",
+  lock: "🔐",
+  unlock: "🔓",
+  link: "🔗",
   clock: "⏱",
-  lightning: "⚡",
-  sparkle: "✨",
-  fire: "🔥",
   target: "🎯",
-  trophy: "🏆",
-  box: {
-    tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║",
-    ltl: "┌", ltr: "┐", lbl: "└", lbr: "┘", lh: "─", lv: "│",
-    lt: "┬", lb: "┴", lx: "┼", ltrT: "├", ltlT: "┤",
-  },
-} : {
-  check: "+",
-  cross: "x",
-  warning: "!",
-  info: "i",
-  arrow: "->",
-  bullet: "*",
-  star: "*",
-  rocket: ">",
-  shield: "[S]",
-  lock: "[L]",
-  key: "[K]",
-  gear: "[G]",
-  search: "[?]",
-  chart: "[C]",
-  file: "[F]",
-  folder: "[D]",
-  clock: "[T]",
-  lightning: "[!]",
-  sparkle: "*",
-  fire: "(!)",
-  target: "(>)",
-  trophy: "[W]",
-  box: {
-    tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|",
-    ltl: "+", ltr: "+", lbl: "+", lbr: "+", lh: "-", lv: "|",
-    lt: "+", lb: "+", lx: "+", ltrT: "+", ltlT: "+",
-  },
+  party: "🎉",
+  skull: "💀",
+  bomb: "💣",
+  ghost: "👻",
+  money: "💰",
+  doc: "📄",
+  box: "📦",
+  sparkle: "✨",
+  lightning: "⚡",
 };
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TIER BADGES
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const TIER = {
-  free: { label: "FREE", color: ansi.green, bg: ansi.bgGreen },
-  starter: { label: "STARTER", color: ansi.cyan, bg: ansi.bgCyan },
-  pro: { label: "PRO", color: ansi.magenta, bg: ansi.bgMagenta },
-  complete: { label: "COMPLETE", color: ansi.yellow, bg: ansi.bgYellow },
+// ASCII ART BANNERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const VIBECHECK_BANNER = `
+██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗
+██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝
+██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝ 
+╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ 
+ ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗
+  ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝`.trim();
+
+const COMMAND_BANNERS = {
+  launch: `
+██╗      █████╗ ██╗   ██╗███╗   ██╗ ██████╗██╗  ██╗
+██║     ██╔══██╗██║   ██║████╗  ██║██╔════╝██║  ██║
+██║     ███████║██║   ██║██╔██╗ ██║██║     ███████║
+██║     ██╔══██║██║   ██║██║╚██╗██║██║     ██╔══██║
+███████╗██║  ██║╚██████╔╝██║ ╚████║╚██████╗██║  ██║
+╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝╚═╝  ╚═╝`.trim(),
+
+  kickoff: `
+██╗  ██╗██╗ ██████╗██╗  ██╗ ██████╗ ███████╗███████╗
+██║ ██╔╝██║██╔════╝██║ ██╔╝██╔═══██╗██╔════╝██╔════╝
+█████╔╝ ██║██║     █████╔╝ ██║   ██║█████╗  █████╗  
+██╔═██╗ ██║██║     ██╔═██╗ ██║   ██║██╔══╝  ██╔══╝  
+██║  ██╗██║╚██████╗██║  ██╗╚██████╔╝██║     ██║     
+╚═╝  ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝ ╚═════╝ ╚═╝     ╚═╝`.trim(),
+
+  scan: `
+███████╗ ██████╗ █████╗ ███╗   ██╗
+██╔════╝██╔════╝██╔══██╗████╗  ██║
+███████╗██║     ███████║██╔██╗ ██║
+╚════██║██║     ██╔══██║██║╚██╗██║
+███████║╚██████╗██║  ██║██║ ╚████║
+╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝`.trim(),
+
+  audit: `
+ █████╗ ██╗   ██╗██████╗ ██╗████████╗
+██╔══██╗██║   ██║██╔══██╗██║╚══██╔══╝
+███████║██║   ██║██║  ██║██║   ██║   
+██╔══██║██║   ██║██║  ██║██║   ██║   
+██║  ██║╚██████╔╝██████╔╝██║   ██║   
+╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═╝   ╚═╝`.trim(),
+
+  packs: `
+██████╗  █████╗  ██████╗██╗  ██╗███████╗
+██╔══██╗██╔══██╗██╔════╝██║ ██╔╝██╔════╝
+██████╔╝███████║██║     █████╔╝ ███████╗
+██╔═══╝ ██╔══██║██║     ██╔═██╗ ╚════██║
+██║     ██║  ██║╚██████╗██║  ██╗███████║
+╚═╝     ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚══════╝`.trim(),
+
+  safelist: `
+███████╗ █████╗ ███████╗███████╗██╗     ██╗███████╗████████╗
+██╔════╝██╔══██╗██╔════╝██╔════╝██║     ██║██╔════╝╚══██╔══╝
+███████╗███████║█████╗  █████╗  ██║     ██║███████╗   ██║   
+╚════██║██╔══██║██╔══╝  ██╔══╝  ██║     ██║╚════██║   ██║   
+███████║██║  ██║██║     ███████╗███████╗██║███████║   ██║   
+╚══════╝╚═╝  ╚═╝╚═╝     ╚══════╝╚══════╝╚═╝╚══════╝   ╚═╝`.trim(),
+
+  doctor: `
+██████╗  ██████╗  ██████╗████████╗ ██████╗ ██████╗ 
+██╔══██╗██╔═══██╗██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗
+██║  ██║██║   ██║██║        ██║   ██║   ██║██████╔╝
+██║  ██║██║   ██║██║        ██║   ██║   ██║██╔══██╗
+██████╔╝╚██████╔╝╚██████╗   ██║   ╚██████╔╝██║  ██║
+╚═════╝  ╚═════╝  ╚═════╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝`.trim(),
+
+  watch: `
+██╗    ██╗ █████╗ ████████╗ ██████╗██╗  ██╗
+██║    ██║██╔══██╗╚══██╔══╝██╔════╝██║  ██║
+██║ █╗ ██║███████║   ██║   ██║     ███████║
+██║███╗██║██╔══██║   ██║   ██║     ██╔══██║
+╚███╔███╔╝██║  ██║   ██║   ╚██████╗██║  ██║
+ ╚══╝╚══╝ ╚═╝  ╚═╝   ╚═╝    ╚═════╝╚═╝  ╚═╝`.trim(),
+
+  init: `
+██╗███╗   ██╗██╗████████╗
+██║████╗  ██║██║╚══██╔══╝
+██║██╔██╗ ██║██║   ██║   
+██║██║╚██╗██║██║   ██║   
+██║██║ ╚████║██║   ██║   
+╚═╝╚═╝  ╚═══╝╚═╝   ╚═╝`.trim(),
+
+  ship: `
+███████╗██╗  ██╗██╗██████╗ 
+██╔════╝██║  ██║██║██╔══██╗
+███████╗███████║██║██████╔╝
+╚════██║██╔══██║██║██╔═══╝ 
+███████║██║  ██║██║██║     
+╚══════╝╚═╝  ╚═╝╚═╝╚═╝`.trim(),
+
+  forge: `
+███████╗ ██████╗ ██████╗  ██████╗ ███████╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝
+█████╗  ██║   ██║██████╔╝██║  ███╗█████╗  
+██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝  
+██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗
+╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝`.trim(),
+
+  shield: `
+███████╗██╗  ██╗██╗███████╗██╗     ██████╗ 
+██╔════╝██║  ██║██║██╔════╝██║     ██╔══██╗
+███████╗███████║██║█████╗  ██║     ██║  ██║
+╚════██║██╔══██║██║██╔══╝  ██║     ██║  ██║
+███████║██║  ██║██║███████╗███████╗██████╔╝
+╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚═════╝`.trim(),
+
+  fix: `
+███████╗██╗██╗  ██╗
+██╔════╝██║╚██╗██╔╝
+█████╗  ██║ ╚███╔╝ 
+██╔══╝  ██║ ██╔██╗ 
+██║     ██║██╔╝ ██╗
+╚═╝     ╚═╝╚═╝  ╚═╝`.trim(),
+
+  link: `
+██╗     ██╗███╗   ██╗██╗  ██╗
+██║     ██║████╗  ██║██║ ██╔╝
+██║     ██║██╔██╗ ██║█████╔╝ 
+██║     ██║██║╚██╗██║██╔═██╗ 
+███████╗██║██║ ╚████║██║  ██╗
+╚══════╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝`.trim(),
+
+  prove: `
+██████╗ ██████╗  ██████╗ ██╗   ██╗███████╗
+██╔══██╗██╔══██╗██╔═══██╗██║   ██║██╔════╝
+██████╔╝██████╔╝██║   ██║██║   ██║█████╗  
+██╔═══╝ ██╔══██╗██║   ██║╚██╗ ██╔╝██╔══╝  
+██║     ██║  ██║╚██████╔╝ ╚████╔╝ ███████╗
+╚═╝     ╚═╝  ╚═╝ ╚═════╝   ╚═══╝  ╚══════╝`.trim(),
+
+  reality: `
+██████╗ ███████╗ █████╗ ██╗     ██╗████████╗██╗   ██╗
+██╔══██╗██╔════╝██╔══██╗██║     ██║╚══██╔══╝╚██╗ ██╔╝
+██████╔╝█████╗  ███████║██║     ██║   ██║    ╚████╔╝ 
+██╔══██╗██╔══╝  ██╔══██║██║     ██║   ██║     ╚██╔╝  
+██║  ██║███████╗██║  ██║███████╗██║   ██║      ██║   
+╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚══════╝╚═╝   ╚═╝      ╚═╝`.trim(),
 };
 
-function getTierBadge(tier) {
-  const t = TIER[tier] || TIER.free;
-  return `${t.color}[${t.label}]${ansi.reset}`;
-}
-
-function getTierFromKey() {
-  const { key } = getApiKey();
-  if (!key) return "free";
-  // Simplified tier detection - in real app would check entitlements
-  return "starter";
-}
-
 // ═══════════════════════════════════════════════════════════════════════════════
 // UTILITY FUNCTIONS
 // ═══════════════════════════════════════════════════════════════════════════════
 
+/**
+ * Strip ANSI codes for length calculation
+ */
 function stripAnsi(str) {
-  return str.replace(/\x1b\[\d+m/g, "").replace(/\x1b\[38;2;\d+;\d+;\d+m/g, "");
+  return str.replace(/\u001b\[[0-9;]*m/g, "");
 }
 
-function padCenter(str, width = WIDTH) {
-  const len = stripAnsi(str).length;
-  const padding = Math.max(0, width - len);
-  const left = Math.floor(padding / 2);
-  return " ".repeat(left) + str + " ".repeat(padding - left);
+/**
+ * Get visible length of string (excluding ANSI codes)
+ */
+function visibleLength(str) {
+  return stripAnsi(str).length;
+}
+
+/**
+ * Pad string to right with spaces
+ */
+function padRight(str, len) {
+  const visible = visibleLength(str);
+  if (visible >= len) return str;
+  return str + " ".repeat(len - visible);
 }
 
-function padRight(str, width) {
-  const len = stripAnsi(str).length;
-  return str + " ".repeat(Math.max(0, width - len));
+/**
+ * Pad string to left with spaces
+ */
+function padLeft(str, len) {
+  const visible = visibleLength(str);
+  if (visible >= len) return str;
+  return " ".repeat(len - visible) + str;
+}
+
+/**
+ * Center string within given width
+ */
+function padCenter(str, width) {
+  const visible = visibleLength(str);
+  if (visible >= width) return str;
+  const padding = width - visible;
+  const left = Math.floor(padding / 2);
+  return " ".repeat(left) + str + " ".repeat(padding - left);
 }
 
+/**
+ * Truncate string with ellipsis
+ */
 function truncate(str, maxLen) {
-  const clean = stripAnsi(str);
-  if (clean.length <= maxLen) return str;
-  return clean.slice(0, maxLen - 3) + "...";
+  const visible = visibleLength(str);
+  if (visible <= maxLen) return str;
+  return stripAnsi(str).substring(0, maxLen - 3) + "...";
 }
 
+/**
+ * Format duration
+ */
 function formatDuration(ms) {
   if (ms < 1000) return `${ms}ms`;
   if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-  return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  return `${minutes}m ${seconds}s`;
+}
+
+/**
+ * Format number with commas
+ */
+function formatNumber(num) {
+  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// HEADER / BANNER
+// PROGRESS BAR
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
- * Render a compact enterprise header for any command
- * @param {object} opts - Header options
- * @param {string} opts.command - Command name (e.g., "scan", "ship")
- * @param {string} opts.title - Title text
- * @param {string} opts.tier - Tier requirement (free, starter, pro)
- * @param {string} [opts.subtitle] - Optional subtitle
+ * Render a progress bar
+ * @param {number} percent - 0-100
+ * @param {number} width - Character width
+ * @param {object} opts - Options { color, showPercent, label }
  */
-function renderHeader(opts) {
-  const { command, title, tier = "free", subtitle } = opts;
-  const tierBadge = getTierBadge(tier);
-  const b = sym.box;
-  
-  const lines = [];
-  
-  // Top border
-  lines.push(`${ansi.gray}${b.tl}${b.h.repeat(WIDTH - 2)}${b.tr}${ansi.reset}`);
+function renderProgressBar(percent, width = 25, opts = {}) {
+  const { color = ansi.green, bgColor = ansi.gray, showPercent = false, label = "" } = opts;
+  const filled = Math.round((percent / 100) * width);
+  const empty = width - filled;
   
-  // Title line
-  const titleStr = `${ansi.bold}${title}${ansi.reset} ${tierBadge}`;
-  lines.push(`${ansi.gray}${b.v}${ansi.reset}${padCenter(titleStr, WIDTH - 2)}${ansi.gray}${b.v}${ansi.reset}`);
+  let bar = `${color}${sym.blockFull.repeat(filled)}${bgColor}${sym.blockEmpty.repeat(empty)}${ansi.reset}`;
   
-  // Subtitle if provided
-  if (subtitle) {
-    const subStr = `${ansi.dim}${subtitle}${ansi.reset}`;
-    lines.push(`${ansi.gray}${b.v}${ansi.reset}${padCenter(subStr, WIDTH - 2)}${ansi.gray}${b.v}${ansi.reset}`);
+  if (showPercent) {
+    bar += ` ${percent}%`;
   }
   
-  // Bottom border
-  lines.push(`${ansi.gray}${b.bl}${b.h.repeat(WIDTH - 2)}${b.br}${ansi.reset}`);
+  if (label) {
+    return `${label} [${bar}]`;
+  }
   
-  console.log(lines.join("\n"));
+  return `[${bar}]`;
 }
 
 /**
- * Render a minimal header (single line)
+ * Render a status indicator with label
  */
-function renderMinimalHeader(command, tier = "free") {
-  const tierBadge = getTierBadge(tier);
-  console.log(`\n  ${ansi.bold}vibecheck ${command}${ansi.reset} ${tierBadge}\n`);
+function renderStatus(label, status, width = 20) {
+  const colors = {
+    OPTIMAL: ansi.green,
+    STABLE: ansi.green,
+    GOOD: ansi.green,
+    OK: ansi.green,
+    PASS: ansi.green,
+    WARNING: ansi.yellow,
+    WARN: ansi.yellow,
+    HEAVY: ansi.yellow,
+    DEGRADED: ansi.yellow,
+    CRITICAL: ansi.red,
+    FAIL: ansi.red,
+    ERROR: ansi.red,
+    LOW: ansi.red,
+  };
+  
+  const color = colors[status.toUpperCase()] || ansi.gray;
+  return `${padRight(label, width)} ${color}[${status}]${ansi.reset}`;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// SECTION DIVIDERS
+// HEADER RENDERING
 // ═══════════════════════════════════════════════════════════════════════════════
 
-function renderDivider(style = "single") {
-  const char = style === "double" ? sym.box.h : sym.box.lh;
-  console.log(`  ${ansi.gray}${char.repeat(WIDTH - 4)}${ansi.reset}`);
-}
-
-function renderSectionHeader(title, icon = sym.bullet) {
-  console.log(`\n  ${ansi.cyan}${icon}${ansi.reset} ${ansi.bold}${title}${ansi.reset}`);
-  console.log(`  ${ansi.gray}${sym.box.lh.repeat(WIDTH - 4)}${ansi.reset}`);
+/**
+ * Render the full header with VIBECHECK banner and command banner
+ */
+function renderFullHeader(command, opts = {}) {
+  const {
+    version = "4.0.0",
+    tier = "FREE",
+    integrity = null,
+    target = process.cwd(),
+    sessionId = generateSessionId(),
+    duration = null,
+  } = opts;
+  
+  const lines = [];
+  
+  // Main VIBECHECK banner with gradient colors
+  const vibeLines = VIBECHECK_BANNER.split("\n");
+  const gradientColors = [
+    ansi.rgb(0, 255, 200),
+    ansi.rgb(0, 230, 220),
+    ansi.rgb(0, 200, 255),
+    ansi.rgb(50, 150, 255),
+    ansi.rgb(100, 100, 255),
+    ansi.rgb(150, 50, 255),
+  ];
+  
+  lines.push("");
+  vibeLines.forEach((line, i) => {
+    const color = gradientColors[i % gradientColors.length] || ansi.cyan;
+    lines.push(`  ${color}${line}${ansi.reset}`);
+  });
+  
+  // Main box
+  lines.push("");
+  lines.push(`${ansi.cyan}${sym.boxTL}${sym.boxH.repeat(WIDTH - 2)}${sym.boxTR}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  // Command banner
+  const cmdBanner = COMMAND_BANNERS[command];
+  if (cmdBanner) {
+    const cmdLines = cmdBanner.split("\n");
+    cmdLines.forEach(line => {
+      const centered = padCenter(line, WIDTH - 4);
+      lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  ${ansi.bold}${ansi.white}${centered}${ansi.reset}  ${ansi.cyan}${sym.boxV}${ansi.reset}`);
+    });
+  }
+  
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  // Info bar
+  const tierBadge = tier === "PRO" ? `${ansi.magenta}PRO${ansi.reset}` : `${ansi.gray}FREE${ansi.reset}`;
+  const integrityStr = integrity ? `  ::  SYSTEM INTEGRITY: ${getIntegrityColor(integrity)}${integrity}${ansi.reset}` : "";
+  const infoLine = `v${version} ${tierBadge}${integrityStr}`;
+  
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  ${infoLine}${" ".repeat(Math.max(0, WIDTH - 4 - visibleLength(infoLine)))}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  // Target and session line
+  const shortTarget = truncate(target, 40);
+  const durationStr = duration ? ` | Time: ${formatDuration(duration)}` : "";
+  const targetLine = `Target: ${shortTarget}${" ".repeat(6)}Session: #${sessionId}${durationStr}`;
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  ${ansi.dim}${truncate(targetLine, WIDTH - 6)}${ansi.reset}${" ".repeat(Math.max(0, WIDTH - 4 - visibleLength(targetLine)))}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  // Separator
+  lines.push(`${ansi.cyan}${sym.boxTeeR}${sym.boxH.repeat(WIDTH - 2)}${sym.boxTeeL}${ansi.reset}`);
+  
+  return lines.join("\n");
 }
 
-// ═══════════════════════════════════════════════════════════════════════════════
-// STATUS INDICATORS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-function renderSuccess(message) {
-  console.log(`  ${ansi.green}${sym.check}${ansi.reset} ${message}`);
+/**
+ * Get color for integrity level
+ */
+function getIntegrityColor(integrity) {
+  const upper = integrity.toUpperCase();
+  if (upper === "HIGH" || upper === "OPTIMAL") return ansi.green;
+  if (upper === "MEDIUM" || upper === "STABLE") return ansi.yellow;
+  return ansi.red;
 }
 
-function renderError(message) {
-  console.log(`  ${ansi.red}${sym.cross}${ansi.reset} ${message}`);
+/**
+ * Generate a short session ID
+ */
+function generateSessionId() {
+  const chars = "0123456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+  let id = "";
+  for (let i = 0; i < 6; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
 }
 
-function renderWarning(message) {
-  console.log(`  ${ansi.yellow}${sym.warning}${ansi.reset} ${message}`);
-}
+// ═══════════════════════════════════════════════════════════════════════════════
+// MINIMAL HEADER (for simpler commands)
+// ═══════════════════════════════════════════════════════════════════════════════
 
-function renderInfo(message) {
-  console.log(`  ${ansi.cyan}${sym.info}${ansi.reset} ${message}`);
+/**
+ * Render a minimal header (no full banner, just command name)
+ */
+function renderMinimalHeader(command, tier = "free") {
+  const tierBadge = tier === "pro" ? `${ansi.magenta}PRO${ansi.reset}` : `${ansi.dim}free${ansi.reset}`;
+  console.log();
+  console.log(`  ${ansi.cyan}${sym.boxTL}${sym.boxH.repeat(60)}${sym.boxTR}${ansi.reset}`);
+  console.log(`  ${ansi.cyan}${sym.boxV}${ansi.reset}  ${ansi.bold}vibecheck ${command}${ansi.reset} ${tierBadge}${" ".repeat(60 - 15 - command.length - (tier === "pro" ? 3 : 4))}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  console.log(`  ${ansi.cyan}${sym.boxBL}${sym.boxH.repeat(60)}${sym.boxBR}${ansi.reset}`);
+  console.log();
 }
 
-function renderBullet(message, indent = 2) {
-  console.log(`${" ".repeat(indent)}${ansi.gray}${sym.bullet}${ansi.reset} ${message}`);
-}
+// ═══════════════════════════════════════════════════════════════════════════════
+// SPLIT COLUMN LAYOUT
+// ═══════════════════════════════════════════════════════════════════════════════
 
-function renderStep(number, message, status = "pending") {
-  const statusIcon = status === "done" ? `${ansi.green}${sym.check}${ansi.reset}` :
-                     status === "error" ? `${ansi.red}${sym.cross}${ansi.reset}` :
-                     status === "running" ? `${ansi.cyan}${sym.gear}${ansi.reset}` :
-                     `${ansi.gray}${number}${ansi.reset}`;
-  console.log(`  ${statusIcon} ${message}`);
+/**
+ * Render a split-column section
+ */
+function renderSplitColumns(leftTitle, rightTitle, leftContent, rightContent, opts = {}) {
+  const { leftWidth = 44, rightWidth = 33 } = opts;
+  const lines = [];
+  
+  // Header row
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset} ${ansi.bold}${padRight(leftTitle, leftWidth)}${ansi.reset}${ansi.dim}│${ansi.reset} ${ansi.bold}${padRight(rightTitle, rightWidth)}${ansi.reset}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset} ${sym.lineH.repeat(leftWidth)}${ansi.dim}┼${ansi.reset}${sym.lineH.repeat(rightWidth + 1)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  // Content rows
+  const maxRows = Math.max(leftContent.length, rightContent.length);
+  for (let i = 0; i < maxRows; i++) {
+    const left = leftContent[i] || "";
+    const right = rightContent[i] || "";
+    lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset} ${padRight(left, leftWidth)}${ansi.dim}│${ansi.reset} ${padRight(right, rightWidth)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  }
+  
+  return lines.join("\n");
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// VERDICT / RESULT BOX
+// VITALS SECTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
- * Render a verdict box (SHIP/WARN/BLOCK)
- * @param {string} verdict - SHIP, WARN, or BLOCK
- * @param {object} [stats] - Optional statistics
+ * Render system vitals with progress bars
  */
-function renderVerdict(verdict, stats = {}) {
-  const b = sym.box;
-  const v = String(verdict).toUpperCase();
-  
-  let bg, icon, label;
-  switch (v) {
-    case "SHIP":
-    case "PASS":
-    case "SUCCESS":
-      bg = ansi.bgGreen;
-      icon = sym.rocket;
-      label = "SHIP";
-      break;
-    case "WARN":
-    case "WARNING":
-      bg = ansi.bgYellow;
-      icon = sym.warning;
-      label = "WARN";
-      break;
-    case "BLOCK":
-    case "FAIL":
-    case "ERROR":
-      bg = ansi.bgRed;
-      icon = sym.cross;
-      label = "BLOCK";
-      break;
-    default:
-      bg = ansi.bgCyan;
-      icon = sym.info;
-      label = v;
-  }
+function renderVitals(vitals) {
+  const lines = [];
   
-  console.log();
-  console.log(`  ${ansi.gray}${b.tl}${b.h.repeat(WIDTH - 6)}${b.tr}${ansi.reset}`);
-  
-  // Verdict line
-  const verdictStr = `${bg}${ansi.bold}${ansi.white} ${icon} ${label} ${ansi.reset}`;
-  console.log(`  ${ansi.gray}${b.v}${ansi.reset}${padCenter(verdictStr, WIDTH - 4)}${ansi.gray}${b.v}${ansi.reset}`);
-  
-  // Stats line if provided
-  if (stats.findings !== undefined || stats.duration !== undefined) {
-    const parts = [];
-    if (stats.critical !== undefined) parts.push(`${ansi.red}${stats.critical} critical${ansi.reset}`);
-    if (stats.warnings !== undefined) parts.push(`${ansi.yellow}${stats.warnings} warnings${ansi.reset}`);
-    if (stats.findings !== undefined && stats.critical === undefined) parts.push(`${stats.findings} findings`);
-    if (stats.duration !== undefined) parts.push(`${ansi.dim}${formatDuration(stats.duration)}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset} ${ansi.bold}SYSTEM VITALS${ansi.reset}${" ".repeat(WIDTH - 17)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset} ${sym.lineH.repeat(WIDTH - 4)} ${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  for (const vital of vitals) {
+    const { label, value, status, percent } = vital;
+    const statusColor = getStatusColor(status);
+    
+    let line = `  ${padRight(label, 18)} ${statusColor}[${status}]${ansi.reset}`;
+    if (percent !== undefined) {
+      const bar = renderProgressBar(percent, 25);
+      line += `\n${ansi.cyan}${sym.boxV}${ansi.reset}  ${bar} ${percent}%`;
+    } else if (value) {
+      line += `  ${ansi.dim}${value}${ansi.reset}`;
+    }
     
-    const statsStr = parts.join(` ${ansi.gray}${sym.bullet}${ansi.reset} `);
-    console.log(`  ${ansi.gray}${b.v}${ansi.reset}${padCenter(statsStr, WIDTH - 4)}${ansi.gray}${b.v}${ansi.reset}`);
+    lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${line}${" ".repeat(Math.max(0, WIDTH - 4 - visibleLength(line)))}${ansi.cyan}${sym.boxV}${ansi.reset}`);
   }
   
-  console.log(`  ${ansi.gray}${b.bl}${b.h.repeat(WIDTH - 6)}${b.br}${ansi.reset}`);
-  console.log();
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  return lines.join("\n");
+}
+
+/**
+ * Get color for status
+ */
+function getStatusColor(status) {
+  const upper = String(status).toUpperCase();
+  if (["OPTIMAL", "STABLE", "GOOD", "PASS", "HIGH", "SHIP", "LAUNCH"].includes(upper)) return ansi.green;
+  if (["WARNING", "WARN", "HEAVY", "DEGRADED", "MEDIUM"].includes(upper)) return ansi.yellow;
+  return ansi.red;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// FINDINGS TABLE
+// FINDINGS/DIAGNOSTIC SECTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
- * Render a findings table
- * @param {Array} findings - Array of finding objects
- * @param {object} opts - Options
- * @param {number} [opts.limit=5] - Max findings to show
+ * Render diagnostic log / findings
  */
-function renderFindingsTable(findings, opts = {}) {
-  const { limit = 5 } = opts;
-  const b = sym.box;
+function renderDiagnostics(findings, opts = {}) {
+  const { maxItems = 5, title = "DIAGNOSTIC LOG" } = opts;
+  const lines = [];
+  
+  lines.push(`${ansi.bold}${title}${ansi.reset}`);
+  lines.push(`${sym.lineH.repeat(30)}`);
   
-  if (!findings || findings.length === 0) {
-    console.log(`  ${ansi.green}${sym.check}${ansi.reset} ${ansi.dim}No issues found${ansi.reset}`);
-    return;
+  if (findings.length === 0) {
+    lines.push("");
+    lines.push(`${ansi.green}${sym.check} No issues found${ansi.reset}`);
+    return lines;
   }
   
-  const COL1 = 10; // Severity
-  const COL2 = 18; // Category
-  const COL3 = WIDTH - COL1 - COL2 - 12; // Message
-  
-  // Header
-  console.log(`  ${ansi.gray}${b.ltl}${b.lh.repeat(COL1)}${b.lt}${b.lh.repeat(COL2)}${b.lt}${b.lh.repeat(COL3)}${b.ltr}${ansi.reset}`);
-  console.log(`  ${ansi.gray}${b.lv}${ansi.reset}${ansi.bold}${padRight(" SEVERITY", COL1)}${ansi.reset}${ansi.gray}${b.lv}${ansi.reset}${ansi.bold}${padRight(" CATEGORY", COL2)}${ansi.reset}${ansi.gray}${b.lv}${ansi.reset}${ansi.bold}${padRight(" MESSAGE", COL3)}${ansi.reset}${ansi.gray}${b.lv}${ansi.reset}`);
-  console.log(`  ${ansi.gray}${b.ltrT}${b.lh.repeat(COL1)}${b.lx}${b.lh.repeat(COL2)}${b.lx}${b.lh.repeat(COL3)}${b.ltlT}${ansi.reset}`);
-  
-  // Rows
-  const shown = findings.slice(0, limit);
-  for (const f of shown) {
-    const sev = f.severity?.toUpperCase() || "INFO";
-    let sevStr;
-    switch (sev) {
-      case "BLOCK":
-      case "CRITICAL":
-        sevStr = `${ansi.red} ${sym.cross} BLOCK${ansi.reset}`;
-        break;
-      case "WARN":
-      case "WARNING":
-      case "HIGH":
-        sevStr = `${ansi.yellow} ${sym.warning} WARN${ansi.reset}`;
-        break;
-      default:
-        sevStr = `${ansi.gray} ${sym.info} INFO${ansi.reset}`;
-    }
+  findings.slice(0, maxItems).forEach((f, i) => {
+    const severityIcon = getSeverityIcon(f.severity);
+    const type = f.type || f.rule || "ISSUE";
     
-    const cat = truncate(f.category || f.type || "General", COL2 - 1);
-    const msg = truncate(f.message || f.title || f.id || "", COL3 - 1);
+    lines.push("");
+    lines.push(`${severityIcon} ${type}${f.count ? ` (x${f.count})` : ""}`);
+    lines.push(`${sym.lineH.repeat(30)}`);
+    lines.push(`Severity: ${getSeverityLabel(f.severity)}`);
+    if (f.impact) lines.push(`Impact:   ${f.impact}`);
     
-    console.log(`  ${ansi.gray}${b.lv}${ansi.reset}${padRight(sevStr, COL1 + 9)}${ansi.gray}${b.lv}${ansi.reset}${padRight(" " + cat, COL2)}${ansi.gray}${b.lv}${ansi.reset}${padRight(" " + msg, COL3)}${ansi.gray}${b.lv}${ansi.reset}`);
-  }
-  
-  // Footer
-  console.log(`  ${ansi.gray}${b.lbl}${b.lh.repeat(COL1)}${b.lb}${b.lh.repeat(COL2)}${b.lb}${b.lh.repeat(COL3)}${b.lbr}${ansi.reset}`);
+    if (f.instances && f.instances.length > 0) {
+      lines.push("");
+      lines.push("DETECTED INSTANCES:");
+      lines.push("");
+      f.instances.slice(0, 3).forEach((inst, j) => {
+        const file = inst.file ? truncate(inst.file, 28) : "Unknown";
+        lines.push(`${j + 1}. ${file}`);
+        if (inst.message) lines.push(`   ${ansi.dim}> ${truncate(inst.message, 25)}${ansi.reset}`);
+      });
+    } else if (f.file) {
+      lines.push("");
+      lines.push(`File: ${truncate(f.file, 25)}`);
+      if (f.message) lines.push(`${ansi.dim}> ${truncate(f.message, 25)}${ansi.reset}`);
+    }
+  });
   
-  // More indicator
-  if (findings.length > limit) {
-    console.log(`  ${ansi.dim}... and ${findings.length - limit} more findings${ansi.reset}`);
+  if (findings.length > maxItems) {
+    lines.push("");
+    lines.push(`${ansi.dim}... and ${findings.length - maxItems} more${ansi.reset}`);
   }
+  
+  return lines;
+}
+
+/**
+ * Get icon for severity
+ */
+function getSeverityIcon(severity) {
+  const upper = String(severity).toUpperCase();
+  if (["CRITICAL", "BLOCK", "HIGH"].includes(upper)) return `${ansi.red}[FAIL]${ansi.reset}`;
+  if (["WARNING", "WARN", "MEDIUM"].includes(upper)) return `${ansi.yellow}[WARN]${ansi.reset}`;
+  return `${ansi.blue}[INFO]${ansi.reset}`;
+}
+
+/**
+ * Get label for severity
+ */
+function getSeverityLabel(severity) {
+  const upper = String(severity).toUpperCase();
+  if (["CRITICAL", "BLOCK"].includes(upper)) return `${ansi.red}CRITICAL${ansi.reset}`;
+  if (upper === "HIGH") return `${ansi.red}HIGH${ansi.reset}`;
+  if (["WARNING", "WARN", "MEDIUM"].includes(upper)) return `${ansi.yellow}MEDIUM${ansi.reset}`;
+  return `${ansi.blue}LOW${ansi.reset}`;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// KEY-VALUE LIST
+// SECURITY AUDIT SECTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
- * Render a key-value list
- * @param {Array<{label: string, value: string}>} items
+ * Render security audit checklist
  */
-function renderKeyValue(items) {
-  const maxLabel = Math.max(...items.map(i => stripAnsi(i.label).length));
+function renderSecurityAudit(checks) {
+  const lines = [];
   
-  for (const item of items) {
-    const label = padRight(item.label, maxLabel);
-    console.log(`  ${ansi.dim}${label}${ansi.reset}  ${item.value}`);
+  lines.push(`${ansi.bold}SECURITY AUDIT${ansi.reset}`);
+  lines.push("");
+  
+  for (const check of checks) {
+    const icon = check.pass ? `${ansi.green}${sym.check}${ansi.reset}` : `${ansi.red}${sym.cross}${ansi.reset}`;
+    const status = check.pass ? `${ansi.green}PASS${ansi.reset}` : `${ansi.red}FAIL${ansi.reset}`;
+    const dots = ".".repeat(Math.max(0, 20 - check.name.length));
+    lines.push(` ${icon} ${check.name}${ansi.dim}${dots}${ansi.reset}${status}`);
   }
+  
+  return lines;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// PROGRESS BAR
+// ACTION REQUIRED SECTION
 // ═══════════════════════════════════════════════════════════════════════════════
 
-function renderProgressBar(percent, width = 20) {
-  const filled = Math.round((percent / 100) * width);
-  const empty = width - filled;
+/**
+ * Render action required section
+ */
+function renderActionRequired(actions, opts = {}) {
+  const { blocking = false, title = "ACTION REQUIRED" } = opts;
+  const lines = [];
+  
+  lines.push(`${ansi.cyan}${sym.boxTeeR}${sym.boxH.repeat(WIDTH - 2)}${sym.boxTeeL}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset} ${ansi.bold}${title}${ansi.reset}${" ".repeat(WIDTH - 4 - title.length)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset} ${sym.lineH.repeat(WIDTH - 4)} ${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  if (blocking) {
+    lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  ${ansi.red}[!] BLOCKING ISSUES DETECTED. DEPLOYMENT HALTED.${ansi.reset}${" ".repeat(WIDTH - 54)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  }
   
-  let color = ansi.green;
-  if (percent < 50) color = ansi.red;
-  else if (percent < 80) color = ansi.yellow;
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
   
-  return `${color}${"█".repeat(filled)}${ansi.gray}${"░".repeat(empty)}${ansi.reset}`;
+  for (const action of actions) {
+    const cmd = `${ansi.cyan}> ${action.command}${ansi.reset}`;
+    const label = action.label ? `${ansi.dim}[${action.label}]${ansi.reset}` : "";
+    const desc = action.description || "";
+    
+    const line = `  ${cmd}${" ".repeat(Math.max(2, 26 - action.command.length))}${label} ${desc}`;
+    lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${padRight(line, WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  }
+  
+  return lines.join("\n");
 }
 
-function renderScore(score, label = "Score") {
-  const bar = renderProgressBar(score);
-  console.log(`  ${ansi.dim}${label}:${ansi.reset} [${bar}] ${score}/100`);
+// ═══════════════════════════════════════════════════════════════════════════════
+// FOOTER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Render standard footer
+ */
+function renderFooter() {
+  return `${ansi.cyan}${sym.boxBL}${sym.boxH.repeat(WIDTH - 2)}${sym.boxBR}${ansi.reset}`;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// FOOTER / NEXT STEPS
+// VERDICT BOX
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
- * Render footer with next steps and optional upsell
- * @param {object} opts
- * @param {Array<{cmd: string, desc: string}>} [opts.nextSteps]
- * @param {string} [opts.docsUrl]
- * @param {boolean} [opts.showUpsell]
+ * Render a verdict box
  */
-function renderFooter(opts = {}) {
-  const { nextSteps = [], docsUrl, showUpsell = true } = opts;
-  const currentTier = getTierFromKey();
+function renderVerdict(verdict, score, stats = {}) {
+  const { blockers = 0, warnings = 0, passed = 0, duration = 0 } = stats;
+  
+  const verdictColors = {
+    SHIP: ansi.green,
+    LAUNCH: ansi.green,
+    PASS: ansi.green,
+    WARN: ansi.yellow,
+    WARNING: ansi.yellow,
+    BLOCK: ansi.red,
+    FAIL: ansi.red,
+  };
+  
+  const verdictIcons = {
+    SHIP: sym.rocket,
+    LAUNCH: sym.rocket,
+    PASS: sym.check,
+    WARN: sym.warning,
+    WARNING: sym.warning,
+    BLOCK: sym.cross,
+    FAIL: sym.cross,
+  };
+  
+  const color = verdictColors[verdict.toUpperCase()] || ansi.gray;
+  const icon = verdictIcons[verdict.toUpperCase()] || sym.bullet;
   
-  console.log();
-  renderDivider();
+  const lines = [];
   
-  // Next steps
-  if (nextSteps.length > 0) {
-    console.log(`\n  ${ansi.bold}${sym.arrow} Next steps${ansi.reset}`);
-    for (const step of nextSteps) {
-      console.log(`    ${ansi.cyan}${step.cmd}${ansi.reset} ${ansi.dim}${step.desc}${ansi.reset}`);
-    }
-  }
+  lines.push(`${ansi.cyan}${sym.boxTeeR}${sym.boxH.repeat(WIDTH - 2)}${sym.boxTeeL}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  ${icon} ${ansi.bold}VERDICT: ${color}${verdict}${ansi.reset}${" ".repeat(WIDTH - 16 - verdict.length)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
   
-  // Upsell for free tier
-  if (showUpsell && currentTier === "free") {
-    console.log();
-    console.log(`  ${ansi.dim}${sym.star}${ansi.reset} ${ansi.cyan}STARTER${ansi.reset}${ansi.dim}: dashboard sync + auto-fix + team features${ansi.reset}`);
-    console.log(`  ${ansi.dim}  Upgrade ${sym.arrow} https://vibecheckai.dev${ansi.reset}`);
-  }
+  // Score bar
+  const bar = renderProgressBar(score, 30, { color });
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  Score: ${bar} ${score}/100${" ".repeat(WIDTH - 54)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
   
-  // Docs link
-  if (docsUrl) {
-    console.log();
-    console.log(`  ${ansi.dim}Docs: ${docsUrl}${ansi.reset}`);
+  // Stats
+  const statsLine = `Blockers: ${blockers}    Warnings: ${warnings}    Passed: ${passed}`;
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  ${statsLine}${" ".repeat(WIDTH - 4 - statsLine.length)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  if (duration) {
+    const durationLine = `Duration: ${formatDuration(duration)}`;
+    lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}  ${ansi.dim}${durationLine}${ansi.reset}${" ".repeat(WIDTH - 4 - durationLine.length)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
   }
   
-  console.log();
+  lines.push(`${ansi.cyan}${sym.boxV}${ansi.reset}${" ".repeat(WIDTH - 2)}${ansi.cyan}${sym.boxV}${ansi.reset}`);
+  
+  return lines.join("\n");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SECTION HEADER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Render a section header within the box
+ */
+function renderSectionHeader(title, icon = sym.bullet) {
+  console.log(`  ${ansi.cyan}${icon}${ansi.reset} ${ansi.bold}${title}${ansi.reset}`);
+  console.log(`  ${ansi.dim}${sym.lineH.repeat(60)}${ansi.reset}`);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// SPINNER
+// SUCCESS/ERROR/WARNING MESSAGES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function renderSuccess(message) {
+  console.log(`  ${ansi.green}${sym.check}${ansi.reset} ${message}`);
+}
+
+function renderError(message) {
+  console.log(`  ${ansi.red}${sym.cross}${ansi.reset} ${message}`);
+}
+
+function renderWarning(message) {
+  console.log(`  ${ansi.yellow}${sym.warning}${ansi.reset} ${message}`);
+}
+
+function renderInfo(message) {
+  console.log(`  ${ansi.cyan}${sym.info}${ansi.reset} ${message}`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SPINNER CLASS
 // ═══════════════════════════════════════════════════════════════════════════════
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
 class Spinner {
-  constructor(text = "") {
+  constructor(text = "", color = ansi.cyan) {
     this.text = text;
+    this.color = color;
     this.timer = null;
-    this.frame = 0;
+    this.frameIndex = 0;
   }
   
   start(text) {
     if (text) this.text = text;
-    if (!process.stdout.isTTY) {
-      console.log(`  ${ansi.cyan}${sym.gear}${ansi.reset} ${this.text}...`);
-      return this;
-    }
-    
-    process.stdout.write("\x1b[?25l"); // Hide cursor
+    process.stdout.write(ansi.hideCursor);
     this.timer = setInterval(() => {
-      const f = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
-      process.stdout.write(`\r  ${ansi.cyan}${f}${ansi.reset} ${this.text}`);
-      this.frame++;
+      const frame = SPINNER_FRAMES[this.frameIndex];
+      this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+      process.stdout.write(`\r  ${this.color}${frame}${ansi.reset} ${this.text}`);
     }, 80);
     return this;
   }
   
-  stop(finalIcon, finalColor, finalText) {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    
-    if (process.stdout.isTTY) {
-      process.stdout.write("\r\x1b[2K"); // Clear line
-      process.stdout.write("\x1b[?25h"); // Show cursor
-    }
-    
+  update(text) {
+    this.text = text;
+    return this;
+  }
+  
+  stop(icon = sym.check, color = ansi.green, finalText) {
+    if (this.timer) clearInterval(this.timer);
+    process.stdout.write(`\r${ansi.clearLine}`);
     if (finalText !== null) {
-      const icon = finalIcon || sym.check;
-      const color = finalColor || ansi.green;
-      console.log(`  ${color}${icon}${ansi.reset} ${finalText || this.text}`);
+      const msg = finalText || this.text;
+      console.log(`  ${color}${icon}${ansi.reset} ${msg}`);
     }
+    process.stdout.write(ansi.showCursor);
     return this;
   }
   
   succeed(text) { return this.stop(sym.check, ansi.green, text); }
   fail(text) { return this.stop(sym.cross, ansi.red, text); }
   warn(text) { return this.stop(sym.warning, ansi.yellow, text); }
-  info(text) { return this.stop(sym.info, ansi.cyan, text); }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// COMMAND TEMPLATES
-// ═══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Standard command wrapper for consistent output
- * @param {object} opts
- * @param {string} opts.command - Command name
- * @param {string} opts.title - Title for header
- * @param {string} [opts.tier] - Required tier
- * @param {boolean} [opts.quiet] - Suppress non-essential output
- * @param {boolean} [opts.json] - JSON output mode
- * @param {Function} opts.run - The command's main logic
- */
-async function runCommand(opts) {
-  const { command, title, tier = "free", quiet = false, json = false, run } = opts;
-  
-  if (json) {
-    // JSON mode - run silently, output only JSON
-    return await run();
-  }
-  
-  if (!quiet) {
-    renderMinimalHeader(command, tier);
-  }
-  
-  const result = await run();
-  
-  return result;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -557,48 +881,51 @@ async function runCommand(opts) {
 module.exports = {
   // Constants
   WIDTH,
+  INNER_WIDTH,
+  
+  // ANSI & Symbols
   ansi,
   sym,
-  TIER,
+  
+  // Banners
+  VIBECHECK_BANNER,
+  COMMAND_BANNERS,
   
   // Utilities
   stripAnsi,
-  padCenter,
+  visibleLength,
   padRight,
+  padLeft,
+  padCenter,
   truncate,
   formatDuration,
-  getTierBadge,
-  getTierFromKey,
+  formatNumber,
+  
+  // Progress & Status
+  renderProgressBar,
+  renderStatus,
   
   // Headers
-  renderHeader,
+  renderFullHeader,
   renderMinimalHeader,
-  
-  // Dividers
-  renderDivider,
+  generateSessionId,
+  
+  // Layouts
+  renderSplitColumns,
+  renderVitals,
+  renderDiagnostics,
+  renderSecurityAudit,
+  renderActionRequired,
+  renderVerdict,
+  renderFooter,
   renderSectionHeader,
   
-  // Status
+  // Messages
   renderSuccess,
   renderError,
   renderWarning,
   renderInfo,
-  renderBullet,
-  renderStep,
-  
-  // Results
-  renderVerdict,
-  renderFindingsTable,
-  renderKeyValue,
-  renderProgressBar,
-  renderScore,
   
-  // Footer
-  renderFooter,
-  
-  // Components
+  // Spinner
   Spinner,
-  
-  // Templates
-  runCommand,
 };