vibecheck-ai 2.0.1 → 5.0.0

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

@@ -0,0 +1,197 @@
+/**
+ * Unified Output System - World Class
+ * * The central nervous system for Vibecheck's CLI output.
+ * Delivers consistent, high-fidelity visualization and strict exit code compliance.
+ */
+
+"use strict";
+
+const chalk = require('chalk'); 
+const os = require('os');
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIGURATION & CONSTANTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const EXIT_CODES = {
+  SHIP: 0,      // Ready to ship, no blockers
+  WARN: 1,      // Warnings found (allowed via flag)
+  BLOCK: 2,     // Blockers found (hard stop)
+  INTERNAL: 2,  // Internal error (hard stop)
+  MISCONFIG: 2, // Configuration error (hard stop)
+};
+
+const WIDTH = 76;
+
+const BOX = {
+  tl: '╔', tr: '╗', bl: '╚', br: '╝', h: '═', v: '║',
+  trT: '╠', tlT: '╣',
+  // Light (Inner)
+  ltl: '┌', ltr: '┐', lbl: '└', lbr: '┘', lh: '─', lv: '│',
+  lt: '┬', lb: '┴', lx: '┼', ltrT: '├', ltlT: '┤'
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// VISUAL RENDERING ENGINE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function padCenter(str, width) {
+  const visibleLen = str.replace(/\u001b\[\d+m/g, '').length;
+  const padding = Math.max(0, width - visibleLen);
+  const left = Math.floor(padding / 2);
+  return ' '.repeat(left) + str + ' '.repeat(padding - left);
+}
+
+function padRight(str, len) {
+  const visibleLen = str.length;
+  const truncated = visibleLen > len ? str.substring(0, len - 3) + '...' : str;
+  return truncated + ' '.repeat(Math.max(0, len - truncated.length));
+}
+
+function renderProgressBar(score, width = 20) {
+  const filled = Math.round((score / 100) * width);
+  return chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(width - filled));
+}
+
+// --- The Core Formatter ---
+
+function renderVerdict(verdictData, options = {}) {
+  const { 
+    score = 0, 
+    findings = [], 
+    duration = 0, 
+    scannedFiles = 0 
+  } = verdictData;
+
+  const lines = [];
+  const hasIssues = findings.length > 0;
+  
+  // 1. FRAME HEADER
+  lines.push(chalk.gray(BOX.tl + BOX.h.repeat(WIDTH - 2) + BOX.tr));
+  lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+
+  // 2. CLEAN HEADER (No ASCII Logo)
+  const titleColor = hasIssues ? chalk.red.bold : chalk.cyan.bold;
+  const subTitle = hasIssues ? 'INTEGRITY SCAN • ISSUES DETECTED' : 'INTEGRITY SCAN • CLEAN';
+  
+  // Add some vertical padding for elegance
+  lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+  lines.push(chalk.gray(BOX.v) + padCenter(titleColor(subTitle), WIDTH - 2) + chalk.gray(BOX.v));
+  lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+
+  // 3. TELEMETRY
+  lines.push(chalk.gray(BOX.trT + BOX.h.repeat(WIDTH - 2) + BOX.tlT));
+  const heapMB = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+  const stats = `📡 TELEMETRY  │ ⏱  ${duration}ms  │ 📂 ${scannedFiles || '?'} Files  │ 📦 ${heapMB}MB`;
+  lines.push(chalk.gray(BOX.v) + padCenter(stats, WIDTH - 2) + chalk.gray(BOX.v));
+  lines.push(chalk.gray(BOX.trT + BOX.h.repeat(WIDTH - 2) + BOX.tlT));
+
+  if (!hasIssues) {
+    // CLEAN STATE
+    lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+    lines.push(chalk.gray(BOX.v) + padCenter(chalk.green('✅  NO STATIC ISSUES FOUND'), WIDTH - 2) + chalk.gray(BOX.v));
+    lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+  } else {
+    // ISSUES STATE
+    lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+    const scoreBar = renderProgressBar(score, 20);
+    lines.push(chalk.gray(BOX.v) + padCenter(`HEALTH SCORE    [${scoreBar}] ${score} / 100`, WIDTH + 18) + chalk.gray(BOX.v));
+    lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+
+    // TABLE HEADER
+    lines.push(chalk.gray(BOX.v) + padCenter('DETECTED VULNERABILITIES', WIDTH - 2) + chalk.gray(BOX.v));
+    
+    // Hardcoded column widths for perfect alignment
+    const C1=10, C2=13, C3=41; 
+    
+    const tTop = `  ${BOX.ltl}${BOX.lh.repeat(C1)}${BOX.lt}${BOX.lh.repeat(C2)}${BOX.lt}${BOX.lh.repeat(C3)}${BOX.ltr}  `;
+    const tMid = `  ${BOX.ltrT}${BOX.lh.repeat(C1)}${BOX.lx}${BOX.lh.repeat(C2)}${BOX.lx}${BOX.lh.repeat(C3)}${BOX.ltlT}  `;
+    const tBot = `  ${BOX.lbl}${BOX.lh.repeat(C1)}${BOX.lb}${BOX.lh.repeat(C2)}${BOX.lb}${BOX.lh.repeat(C3)}${BOX.lbr}  `;
+
+    lines.push(chalk.gray(BOX.v) + chalk.gray(tTop) + chalk.gray(BOX.v));
+    const header = `  ${BOX.lv}${padRight(' SEVERITY', C1)}${BOX.lv}${padRight(' TYPE', C2)}${BOX.lv}${padRight(' FINDING', C3)}${BOX.lv}  `;
+    lines.push(chalk.gray(BOX.v) + chalk.bold(header) + chalk.gray(BOX.v));
+    lines.push(chalk.gray(BOX.v) + chalk.gray(tMid) + chalk.gray(BOX.v));
+
+    // ROWS
+    findings.slice(0, 5).forEach(f => {
+      const sev = (f.severity === 'critical' || f.severity === 'BLOCK') ? chalk.red('🛑 CRIT  ') : chalk.yellow('🟡 WARN  ');
+      const row = `  ${chalk.gray(BOX.lv)}${sev}${chalk.gray(BOX.lv)}${padRight(' '+(f.category||'General'), C2)}${chalk.gray(BOX.lv)}${padRight(' '+(f.message||f.title), C3)}${chalk.gray(BOX.lv)}  `;
+      lines.push(chalk.gray(BOX.v) + row + chalk.gray(BOX.v));
+    });
+
+    lines.push(chalk.gray(BOX.v) + chalk.gray(tBot) + chalk.gray(BOX.v));
+    lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+
+    // AUTO-FIX PROMPT
+    lines.push(chalk.gray(BOX.trT + BOX.h.repeat(WIDTH - 2) + BOX.tlT));
+    const fixTitle = chalk.white.bold('⚡ AUTO-FIX AVAILABLE');
+    lines.push(chalk.gray(BOX.v) + padCenter(fixTitle, WIDTH + 9) + chalk.gray(BOX.v));
+    lines.push(chalk.gray(BOX.v) + padCenter(chalk.gray('─'.repeat(60)), WIDTH + 9) + chalk.gray(BOX.v));
+    
+    // Fix options
+    lines.push(chalk.gray(BOX.v) + padCenter(chalk.dim('Run ') + chalk.cyan('vibecheck scan --autofix') + chalk.dim(' to apply fixes'), WIDTH + 9) + chalk.gray(BOX.v));
+    lines.push(chalk.gray(BOX.v) + padCenter(chalk.dim('Run ') + chalk.cyan('vibecheck fix') + chalk.dim(' to generate AI fix missions'), WIDTH + 9) + chalk.gray(BOX.v));
+    
+    lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+  }
+
+  // BOTTOM FRAME
+  lines.push(chalk.gray(BOX.v) + ' '.repeat(WIDTH - 2) + chalk.gray(BOX.v));
+  lines.push(chalk.gray(BOX.bl + BOX.h.repeat(WIDTH - 2) + BOX.br));
+
+  return lines.join('\n');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PUBLIC API
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function formatScanOutput(result, options = {}) {
+  const { json = false } = options;
+  
+  // Sort findings deterministically for stable output
+  if (result.findings && Array.isArray(result.findings)) {
+    const { sortFindings } = require('./finding-sorter');
+    result.findings = sortFindings(result.findings);
+  }
+  
+  if (json) return JSON.stringify(result, null, 2);
+  return renderVerdict(result, options);
+}
+
+function getExitCode(verdict) {
+  if (!verdict) return EXIT_CODES.BLOCK;
+  const v = (typeof verdict === 'string' ? verdict : verdict.verdict).toUpperCase();
+  if (v === 'SHIP' || v === 'PASS') return EXIT_CODES.SHIP;
+  if (v === 'WARN') return EXIT_CODES.WARN;
+  return EXIT_CODES.BLOCK;
+}
+
+function printError(error, context = '') {
+  const isConfig = error.message.toLowerCase().includes('config') || error.code === 'ENOENT';
+  const exitCode = isConfig ? EXIT_CODES.MISCONFIG : EXIT_CODES.INTERNAL;
+  
+  const lines = [];
+  lines.push('');
+  lines.push(chalk.bgRed.white.bold(` 🛑 SYSTEM ALERT: ${context || 'INTERNAL_ERROR'} `));
+  lines.push(chalk.red('─'.repeat(WIDTH)));
+  lines.push(`${chalk.bold('Error:')}   ${error.message}`);
+  if (error.code) lines.push(`${chalk.bold('Code:')}    ${error.code}`);
+  lines.push('');
+  
+  const fixCmd = isConfig ? 'vibecheck doctor --fix' : 'vibecheck doctor';
+  lines.push(chalk.gray('Recovery Step:'));
+  lines.push(`$ ${chalk.cyan(fixCmd)}`);
+  lines.push('');
+
+  console.error(lines.join('\n'));
+  return exitCode;
+}
+
+module.exports = {
+  formatScanOutput,
+  getExitCode,
+  printError,
+  EXIT_CODES,
+};

package/bin/runners/lib/upsell.js

@@ -0,0 +1,410 @@
+/**
+ * Upsell Copy Module - Central copy generator for tier upgrades
+ * 
+ * Simple 2-tier model: FREE and PRO ($49/mo)
+ * 
+ * Rules:
+ * - Blunt, confident, minimal tone
+ * - No cringe language ("please upgrade")
+ * - Every upsell includes a free path if one exists
+ * - No web links besides https://vibecheckai.dev/pricing
+ * 
+ * @module bin/runners/lib/upsell
+ */
+
+"use strict";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ANSI STYLING
+// ═══════════════════════════════════════════════════════════════════════════════
+const SUPPORTS_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+
+const c = SUPPORTS_COLOR ? {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+  white: "\x1b[37m",
+  gray: "\x1b[90m",
+} : {
+  reset: "", bold: "", dim: "", red: "", green: "", yellow: "",
+  cyan: "", magenta: "", white: "", gray: "",
+};
+
+const sym = {
+  lock: "🔒",
+  arrow: "→",
+  warning: "⚠",
+  check: "✓",
+  cross: "✗",
+  star: "★",
+  rocket: "🚀",
+  badge: "🏆",
+  lightning: "⚡",
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SIMPLE 2-TIER CONFIG: FREE and PRO ($49/mo)
+// ═══════════════════════════════════════════════════════════════════════════════
+const TIER_LABELS = {
+  free: "FREE",
+  pro: "PRO",
+};
+
+const TIER_COLORS = {
+  free: c.green,
+  pro: c.magenta,
+};
+
+const PRICING_URL = "https://vibecheckai.dev/pricing";
+const PRO_PRICE = "$49/mo";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// DENIAL COPY - Command-specific reasons and alternatives
+// ═══════════════════════════════════════════════════════════════════════════════
+const DENIAL_COPY = {
+  ship: {
+    feature: "release verdict",
+    why: "SHIP/WARN/BLOCK verdict with evidence",
+    freeAlt: "vibecheck scan",
+    freeAltDesc: "static analysis without verdict",
+  },
+  prove: {
+    feature: "runtime proof",
+    why: "Full runtime verification with evidence",
+    freeAlt: "vibecheck scan",
+    freeAltDesc: "static analysis",
+  },
+  fix: {
+    feature: "auto-fix",
+    why: "AI-powered fixes with --apply",
+    freeAlt: "vibecheck scan",
+    freeAltDesc: "view issues only",
+  },
+  gate: {
+    feature: "CI/CD gate",
+    why: "Block deploys on verification failures",
+    freeAlt: "vibecheck scan",
+    freeAltDesc: "check before deploy",
+  },
+  badge: {
+    feature: "ship badge",
+    why: "Verified ship badge for README",
+    freeAlt: "vibecheck report",
+    freeAltDesc: "HTML/MD report",
+  },
+  reality: {
+    feature: "full runtime verification",
+    why: "Unlimited pages + auth boundary testing",
+    freeAlt: "vibecheck scan",
+    freeAltDesc: "static analysis",
+  },
+  share: {
+    feature: "share pack",
+    why: "Shareable proof bundle for PRs/docs",
+    freeAlt: "vibecheck report",
+    freeAltDesc: "local report",
+  },
+  "ai-test": {
+    feature: "AI testing",
+    why: "AI-generated test coverage",
+    freeAlt: "vibecheck scan",
+    freeAltDesc: "static analysis",
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatDenied() - Hard denial message
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Format a denial message for a command that requires PRO.
+ * 
+ * @param {string} cmd - The command that was denied
+ * @param {object} opts - Options
+ * @returns {string} Formatted denial message
+ */
+function formatDenied(cmd, opts = {}) {
+  const copy = DENIAL_COPY[cmd] || {
+    feature: cmd,
+    why: `${cmd} command`,
+    freeAlt: null,
+    freeAltDesc: null,
+  };
+  
+  let msg = `
+${c.red}${c.bold}${sym.lock} PRO FEATURE${c.reset}
+
+  ${c.bold}Command:${c.reset}  ${c.yellow}${cmd}${c.reset}
+  ${c.bold}Feature:${c.reset}  ${copy.feature}
+  ${c.bold}Why:${c.reset}      ${copy.why}
+`;
+
+  // Free alternative
+  if (copy.freeAlt) {
+    msg += `
+  ${c.green}${sym.arrow} Free:${c.reset} ${c.cyan}${copy.freeAlt}${c.reset} ${c.dim}(${copy.freeAltDesc})${c.reset}`;
+  }
+
+  // Upgrade CTA
+  msg += `
+  ${c.bold}${sym.arrow} Upgrade:${c.reset} PRO ${PRO_PRICE} ${sym.arrow} ${PRICING_URL}
+`;
+
+  return msg;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatCapHit() - Limit reached notice
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Format a cap-hit notice when user reaches a limit.
+ * 
+ * @param {string} cmd - The command being run
+ * @param {object} opts - Options
+ * @returns {string} Formatted cap-hit message
+ */
+function formatCapHit(cmd, opts = {}) {
+  const { limitType = "limit", limitValue } = opts;
+  
+  return `${c.yellow}${sym.warning}${c.reset} FREE ${limitType} cap (${limitValue}). Upgrade to ${c.magenta}PRO${c.reset} (${PRO_PRICE}) ${sym.arrow} ${PRICING_URL}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatEarnedUpsell() - End-of-run upsell
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Format an earned upsell shown at end of run.
+ * 
+ * @param {object} opts - Options
+ * @returns {string} Formatted earned upsell message
+ */
+function formatEarnedUpsell(opts = {}) {
+  const { 
+    cmd, 
+    verdict, 
+    topIssues = [], 
+    withheldArtifact, 
+    why,
+    currentTier = "free",
+    suggestedCmd,
+  } = opts;
+  
+  let msg = "";
+  
+  // Badge withheld case
+  if (withheldArtifact === "badge") {
+    msg += `
+${c.dim}─────────────────────────────────────────────────────────────${c.reset}
+${c.yellow}${sym.badge} Badge withheld${c.reset} ${c.dim}(verdict: ${verdict})${c.reset}
+`;
+    
+    if (topIssues.length > 0) {
+      msg += `\n${c.bold}Top blockers:${c.reset}\n`;
+      topIssues.slice(0, 3).forEach((issue, i) => {
+        const sev = issue.severity === "BLOCK" ? c.red : c.yellow;
+        msg += `  ${c.dim}${i + 1}.${c.reset} ${sev}${issue.severity}${c.reset} ${issue.message || issue.id || issue.type}\n`;
+      });
+    }
+    
+    if (suggestedCmd) {
+      msg += `\n${c.green}${sym.arrow} Fix:${c.reset} ${c.cyan}${suggestedCmd}${c.reset}`;
+    }
+    
+    msg += `\n${c.dim}Badge unlocks when verdict = SHIP${c.reset}\n`;
+    return msg;
+  }
+  
+  // Fix withheld case
+  if (cmd === "fix" && withheldArtifact === "apply") {
+    msg += `
+${c.dim}─────────────────────────────────────────────────────────────${c.reset}
+${c.yellow}${sym.lightning} Fix plan generated${c.reset}
+
+  Patches ready but ${c.yellow}--apply${c.reset} requires ${c.magenta}PRO${c.reset}.
+  
+  ${c.green}${sym.arrow} Review:${c.reset} .vibecheck/missions/
+  ${c.bold}${sym.arrow} Apply:${c.reset}  Upgrade to PRO ${sym.arrow} ${PRICING_URL}
+`;
+    return msg;
+  }
+  
+  // Reality cap hit case
+  if (cmd === "reality" && why === "cap_hit") {
+    msg += `
+${c.dim}─────────────────────────────────────────────────────────────${c.reset}
+${c.yellow}${sym.warning} Preview complete${c.reset}
+
+  Crawled ${topIssues.length || 5} pages (FREE limit).
+  ${c.magenta}PRO${c.reset} unlocks unlimited pages + auth boundary testing.
+  
+  ${c.bold}${sym.arrow} Upgrade:${c.reset} ${PRICING_URL}
+`;
+    return msg;
+  }
+  
+  // Generic earned upsell
+  if (why) {
+    msg += `
+${c.dim}─────────────────────────────────────────────────────────────${c.reset}
+${c.cyan}${sym.star} ${why}${c.reset}
+
+  ${c.magenta}PRO${c.reset} (${PRO_PRICE}) unlocks this feature.
+  ${c.bold}${sym.arrow} Upgrade:${c.reset} ${PRICING_URL}
+`;
+  }
+  
+  return msg;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatBadgeWithheld() - Specific badge denial
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Format badge withheld message with top issues.
+ */
+function formatBadgeWithheld(verdict, findings = [], currentTier = "free") {
+  const blockers = findings.filter(f => f.severity === "BLOCK").slice(0, 3);
+  const topIssues = blockers.length > 0 ? blockers : findings.slice(0, 3);
+  
+  let msg = `
+${c.yellow}${sym.badge} Badge withheld${c.reset}
+
+  ${c.bold}Verdict:${c.reset} ${verdict === "BLOCK" ? c.red : c.yellow}${verdict}${c.reset}
+  ${c.dim}Badge requires SHIP verdict${c.reset}
+`;
+
+  if (topIssues.length > 0) {
+    msg += `\n  ${c.bold}Fix these first:${c.reset}\n`;
+    topIssues.forEach((issue, i) => {
+      const sev = issue.severity === "BLOCK" ? c.red : c.yellow;
+      const label = issue.id || issue.type || issue.ruleId || "issue";
+      const desc = issue.message || issue.description || "";
+      msg += `    ${c.dim}${i + 1}.${c.reset} ${sev}[${issue.severity}]${c.reset} ${label}${desc ? `: ${c.dim}${desc.slice(0, 50)}${c.reset}` : ""}\n`;
+    });
+  }
+
+  // Suggest fix command
+  if (currentTier === "pro") {
+    msg += `\n  ${c.green}${sym.arrow} Run:${c.reset} ${c.cyan}vibecheck fix${c.reset}\n`;
+  } else {
+    msg += `\n  ${c.dim}Upgrade to PRO for auto-fix ${sym.arrow} ${PRICING_URL}${c.reset}\n`;
+  }
+
+  return msg;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatNextSteps() - Smart suggestions
+// ═══════════════════════════════════════════════════════════════════════════════
+/**
+ * Format next step suggestions based on current command and result.
+ */
+function formatNextSteps(cmd, verdict, currentTier = "free") {
+  const steps = [];
+  const isPro = currentTier === "pro";
+  
+  switch (cmd) {
+    case "scan":
+      if (isPro) {
+        steps.push({ cmd: "vibecheck ship", desc: "get verdict" });
+        steps.push({ cmd: "vibecheck fix", desc: "auto-fix issues" });
+      } else {
+        steps.push({ cmd: "vibecheck report", desc: "export report" });
+      }
+      break;
+      
+    case "ship":
+      if (verdict === "SHIP" && isPro) {
+        steps.push({ cmd: "vibecheck badge", desc: "generate badge" });
+      } else if (isPro) {
+        steps.push({ cmd: "vibecheck fix", desc: "auto-fix issues" });
+      }
+      steps.push({ cmd: "vibecheck report", desc: "export report" });
+      break;
+      
+    case "fix":
+      if (isPro) {
+        steps.push({ cmd: "vibecheck ship", desc: "verify fixes" });
+      }
+      break;
+  }
+  
+  if (steps.length === 0) return "";
+  
+  let msg = `\n${c.dim}Next:${c.reset} `;
+  msg += steps.map(s => `${c.cyan}${s.cmd}${c.reset} ${c.dim}(${s.desc})${c.reset}`).join(" or ");
+  
+  return msg;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatDowngrade() - Caps/downgrade notice (for free tier)
+// ═══════════════════════════════════════════════════════════════════════════════
+function formatDowngrade(cmd, opts = {}) {
+  const { currentTier = "free" } = opts;
+  
+  if (currentTier === "pro") return "";
+  
+  return `${c.yellow}${sym.warning}${c.reset} Running in ${c.yellow}FREE${c.reset} mode ${c.dim}(limited features)${c.reset}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatSoftUpsell() - Non-intrusive end-of-run upsell
+// ═══════════════════════════════════════════════════════════════════════════════
+function formatSoftUpsell(cmd, opts = {}) {
+  const { currentTier = "free" } = opts;
+  
+  if (currentTier === "pro") return "";
+  
+  return `${c.dim}${sym.star} ${c.magenta}PRO${c.reset}${c.dim} (${PRO_PRICE}): Fix, Prove & Enforce ${sym.arrow} ${PRICING_URL}${c.reset}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatWorkflowUpsell() - Workflow suggestion with upsell
+// ═══════════════════════════════════════════════════════════════════════════════
+function formatWorkflowUpsell(completedCmd, currentTier = "free") {
+  if (currentTier === "pro") {
+    // PRO users get next command suggestion without upsell
+    const NEXT_CMDS = {
+      scan: "vibecheck ship",
+      ship: "vibecheck badge",
+      fix: "vibecheck ship",
+      reality: "vibecheck prove",
+    };
+    const next = NEXT_CMDS[completedCmd];
+    return next ? `${c.dim}Next:${c.reset} ${c.cyan}${next}${c.reset}` : "";
+  }
+  
+  // FREE users get upsell
+  return `${c.dim}Next:${c.reset} ${c.cyan}vibecheck report${c.reset} ${c.dim}or${c.reset} ${c.magenta}PRO${c.reset}${c.dim}: ship, fix, prove, gate, badge${c.reset}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+module.exports = {
+  // Core formatters
+  formatDenied,
+  formatDowngrade,
+  formatCapHit,
+  formatEarnedUpsell,
+  formatBadgeWithheld,
+  formatNextSteps,
+  formatSoftUpsell,
+  formatWorkflowUpsell,
+  
+  // Copy data (for testing/docs)
+  DENIAL_COPY,
+  TIER_LABELS,
+  TIER_COLORS,
+  PRICING_URL,
+  PRO_PRICE,
+  
+  // Styling (for consistent use)
+  c,
+  sym,
+};