@vibecheckai/cli 3.2.6 → 3.4.0

package/bin/runners/lib/help-formatter.js

@@ -0,0 +1,413 @@
+/**
+ * Vibecheck CLI Help Formatter - World-Class Help System
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Provides consistent, beautiful, and informative help text across all commands.
+ * Features:
+ * - Consistent visual formatting
+ * - Rich examples with explanations
+ * - Tier badges and upgrade hints
+ * - Related commands section
+ * - Shell completion hints
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+"use strict";
+
+const { ansi, colors, icons, BOX, WIDTH } = require("./terminal-ui");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const HELP_WIDTH = 76;
+const INDENT = "  ";
+const SECTION_INDENT = "    ";
+
+// Tier badges
+const TIER_BADGES = {
+  free: `${ansi.green}[FREE]${ansi.reset}`,
+  starter: `${ansi.cyan}[STARTER]${ansi.reset}`,
+  pro: `${ansi.magenta}[PRO]${ansi.reset}`,
+  enterprise: `${ansi.yellow}[ENTERPRISE]${ansi.reset}`,
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELP SECTION BUILDERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Format a section header
+ */
+function formatSectionHeader(title, icon = "") {
+  const iconStr = icon ? `${icon} ` : "";
+  return `\n${INDENT}${ansi.bold}${iconStr}${title}${ansi.reset}\n`;
+}
+
+/**
+ * Format a description paragraph
+ */
+function formatDescription(text) {
+  if (!text) return "";
+  const lines = wrapText(text, HELP_WIDTH - 4);
+  return lines.map(line => `${INDENT}${ansi.dim}${line}${ansi.reset}`).join("\n") + "\n";
+}
+
+/**
+ * Format a usage line
+ */
+function formatUsage(command, args = "", options = "[options]") {
+  const parts = [`vibecheck ${command}`];
+  if (args) parts.push(args);
+  if (options) parts.push(options);
+  return `${INDENT}${ansi.cyan}${parts.join(" ")}${ansi.reset}`;
+}
+
+/**
+ * Format aliases
+ */
+function formatAliases(aliases) {
+  if (!aliases || aliases.length === 0) return "";
+  return `${INDENT}${ansi.dim}Aliases: ${aliases.join(", ")}${ansi.reset}\n`;
+}
+
+/**
+ * Format an option/flag
+ */
+function formatOption(flag, description, meta = {}) {
+  const { tier, default: defaultVal, required, short } = meta;
+  
+  let flagStr = `${colors.accent}${flag}${ansi.reset}`;
+  if (short) {
+    flagStr = `${colors.accent}${short}${ansi.reset}, ${flagStr}`;
+  }
+  
+  let line = `${SECTION_INDENT}${flagStr.padEnd(28)}`;
+  line += description;
+  
+  if (tier && tier !== "free") {
+    line += ` ${TIER_BADGES[tier]}`;
+  }
+  if (defaultVal !== undefined) {
+    line += ` ${ansi.dim}(default: ${defaultVal})${ansi.reset}`;
+  }
+  if (required) {
+    line += ` ${ansi.yellow}(required)${ansi.reset}`;
+  }
+  
+  return line;
+}
+
+/**
+ * Format a group of options
+ */
+function formatOptionGroup(title, options) {
+  const lines = [formatSectionHeader(title)];
+  for (const opt of options) {
+    lines.push(formatOption(opt.flag, opt.description, opt));
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Format an example
+ */
+function formatExample(command, description, explanation = "") {
+  let result = `${SECTION_INDENT}${ansi.dim}#${ansi.reset} ${description}\n`;
+  result += `${SECTION_INDENT}${ansi.cyan}${command}${ansi.reset}`;
+  if (explanation) {
+    result += `\n${SECTION_INDENT}${ansi.dim}${explanation}${ansi.reset}`;
+  }
+  return result;
+}
+
+/**
+ * Format examples section
+ */
+function formatExamples(examples) {
+  const lines = [formatSectionHeader("EXAMPLES", "💡")];
+  for (let i = 0; i < examples.length; i++) {
+    const ex = examples[i];
+    lines.push(formatExample(ex.command, ex.description, ex.explanation));
+    if (i < examples.length - 1) lines.push(""); // spacing between examples
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Format related commands
+ */
+function formatRelated(commands) {
+  if (!commands || commands.length === 0) return "";
+  
+  const lines = [formatSectionHeader("RELATED COMMANDS", "🔗")];
+  for (const cmd of commands) {
+    const tierBadge = cmd.tier && cmd.tier !== "free" ? ` ${TIER_BADGES[cmd.tier]}` : "";
+    lines.push(`${SECTION_INDENT}${ansi.cyan}vibecheck ${cmd.name}${ansi.reset}${tierBadge}`);
+    lines.push(`${SECTION_INDENT}${ansi.dim}${cmd.description}${ansi.reset}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Format workflow section (multi-step guide)
+ */
+function formatWorkflow(steps) {
+  if (!steps || steps.length === 0) return "";
+  
+  const lines = [formatSectionHeader("WORKFLOW", "📋")];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const num = `${i + 1}.`;
+    lines.push(`${SECTION_INDENT}${ansi.bold}${num}${ansi.reset} ${step.title}`);
+    lines.push(`${SECTION_INDENT}   ${ansi.cyan}${step.command}${ansi.reset}`);
+    if (step.note) {
+      lines.push(`${SECTION_INDENT}   ${ansi.dim}${step.note}${ansi.reset}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Format output section (what the command produces)
+ */
+function formatOutput(outputs) {
+  if (!outputs || outputs.length === 0) return "";
+  
+  const lines = [formatSectionHeader("OUTPUT", "📄")];
+  for (const out of outputs) {
+    lines.push(`${SECTION_INDENT}${ansi.cyan}${out.path}${ansi.reset}`);
+    lines.push(`${SECTION_INDENT}${ansi.dim}${out.description}${ansi.reset}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Format environment variables section
+ */
+function formatEnvVars(vars) {
+  if (!vars || vars.length === 0) return "";
+  
+  const lines = [formatSectionHeader("ENVIRONMENT VARIABLES", "🌍")];
+  for (const v of vars) {
+    lines.push(`${SECTION_INDENT}${ansi.yellow}${v.name}${ansi.reset}`);
+    lines.push(`${SECTION_INDENT}${ansi.dim}${v.description}${ansi.reset}`);
+    if (v.default) {
+      lines.push(`${SECTION_INDENT}${ansi.dim}Default: ${v.default}${ansi.reset}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Format footer with links and hints
+ */
+function formatFooter(command, options = {}) {
+  const { docsUrl, tier, upgradeHint } = options;
+  
+  const lines = ["", `${INDENT}${ansi.dim}${"─".repeat(HELP_WIDTH - 4)}${ansi.reset}`];
+  
+  // Tier info
+  if (tier && tier !== "free") {
+    lines.push(`${INDENT}${ansi.dim}This command requires ${TIER_BADGES[tier]} tier or higher.${ansi.reset}`);
+    if (upgradeHint) {
+      lines.push(`${INDENT}${ansi.dim}${upgradeHint}${ansi.reset}`);
+    }
+  }
+  
+  // Docs link
+  if (docsUrl) {
+    lines.push(`${INDENT}${ansi.dim}Documentation: ${ansi.underline}${docsUrl}${ansi.reset}`);
+  }
+  
+  // Global help hint
+  lines.push(`${INDENT}${ansi.dim}Run 'vibecheck --help' for all commands.${ansi.reset}`);
+  lines.push("");
+  
+  return lines.join("\n");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITY FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Wrap text to fit within width
+ */
+function wrapText(text, width) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let currentLine = "";
+  
+  for (const word of words) {
+    if (currentLine.length + word.length + 1 > width) {
+      if (currentLine) lines.push(currentLine);
+      currentLine = word;
+    } else {
+      currentLine = currentLine ? `${currentLine} ${word}` : word;
+    }
+  }
+  if (currentLine) lines.push(currentLine);
+  
+  return lines;
+}
+
+/**
+ * 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, "");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN HELP BUILDER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Build complete help text for a command
+ * 
+ * @param {object} config - Help configuration
+ * @param {string} config.name - Command name
+ * @param {string[]} config.aliases - Command aliases
+ * @param {string} config.description - Short description
+ * @param {string} config.longDescription - Detailed description
+ * @param {string} config.tier - Required tier (free, starter, pro)
+ * @param {string} config.usage - Usage pattern (e.g., "[path] [options]")
+ * @param {object[]} config.options - Array of option definitions
+ * @param {object[]} config.examples - Array of example definitions
+ * @param {object[]} config.related - Array of related command definitions
+ * @param {object[]} config.workflow - Array of workflow steps
+ * @param {object[]} config.outputs - Array of output file definitions
+ * @param {object[]} config.envVars - Array of environment variable definitions
+ * @param {string} config.docsUrl - Documentation URL
+ * @param {function} config.banner - Optional banner function
+ * @returns {string} Complete formatted help text
+ */
+function buildHelp(config) {
+  const parts = [];
+  
+  // Banner (optional)
+  if (config.banner) {
+    parts.push(config.banner());
+  }
+  
+  // Usage
+  parts.push(formatSectionHeader("USAGE"));
+  parts.push(formatUsage(config.name, config.usage || "[options]"));
+  parts.push("");
+  
+  // Aliases
+  if (config.aliases && config.aliases.length > 0) {
+    parts.push(formatAliases(config.aliases));
+  }
+  
+  // Description
+  if (config.longDescription || config.description) {
+    parts.push(formatSectionHeader("DESCRIPTION"));
+    parts.push(formatDescription(config.longDescription || config.description));
+  }
+  
+  // Options (grouped)
+  if (config.options && config.options.length > 0) {
+    // Group options by category
+    const groups = {};
+    for (const opt of config.options) {
+      const group = opt.group || "OPTIONS";
+      if (!groups[group]) groups[group] = [];
+      groups[group].push(opt);
+    }
+    
+    for (const [groupName, groupOpts] of Object.entries(groups)) {
+      parts.push(formatOptionGroup(groupName, groupOpts));
+    }
+  }
+  
+  // Examples
+  if (config.examples && config.examples.length > 0) {
+    parts.push(formatExamples(config.examples));
+  }
+  
+  // Workflow
+  if (config.workflow && config.workflow.length > 0) {
+    parts.push(formatWorkflow(config.workflow));
+  }
+  
+  // Output
+  if (config.outputs && config.outputs.length > 0) {
+    parts.push(formatOutput(config.outputs));
+  }
+  
+  // Environment variables
+  if (config.envVars && config.envVars.length > 0) {
+    parts.push(formatEnvVars(config.envVars));
+  }
+  
+  // Related commands
+  if (config.related && config.related.length > 0) {
+    parts.push(formatRelated(config.related));
+  }
+  
+  // Footer
+  parts.push(formatFooter(config.name, {
+    tier: config.tier,
+    docsUrl: config.docsUrl,
+    upgradeHint: config.tier !== "free" ? "Upgrade at: https://vibecheckai.dev/pricing" : null,
+  }));
+  
+  return parts.join("\n");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// QUICK HELPERS FOR COMMON PATTERNS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Global options that apply to most commands
+ */
+const GLOBAL_OPTIONS = [
+  { flag: "--help, -h", description: "Show this help", group: "GLOBAL OPTIONS" },
+  { flag: "--json", description: "Output as JSON (machine-readable)", group: "GLOBAL OPTIONS" },
+  { flag: "--quiet, -q", description: "Suppress non-essential output", group: "GLOBAL OPTIONS" },
+  { flag: "--verbose", description: "Show detailed output", group: "GLOBAL OPTIONS" },
+  { flag: "--no-banner", description: "Hide the banner", group: "GLOBAL OPTIONS" },
+  { flag: "--ci", description: "CI mode (implies --quiet --no-banner)", group: "GLOBAL OPTIONS" },
+  { flag: "--path, -p <dir>", description: "Run in specified directory", group: "GLOBAL OPTIONS" },
+  { flag: "--offline", description: "Run in offline mode (no API)", group: "GLOBAL OPTIONS" },
+];
+
+/**
+ * Add global options to a command's options array
+ */
+function withGlobalOptions(options) {
+  return [...options, ...GLOBAL_OPTIONS];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  buildHelp,
+  formatSectionHeader,
+  formatDescription,
+  formatUsage,
+  formatAliases,
+  formatOption,
+  formatOptionGroup,
+  formatExample,
+  formatExamples,
+  formatRelated,
+  formatWorkflow,
+  formatOutput,
+  formatEnvVars,
+  formatFooter,
+  wrapText,
+  stripAnsi,
+  withGlobalOptions,
+  GLOBAL_OPTIONS,
+  TIER_BADGES,
+  HELP_WIDTH,
+};

package/bin/runners/lib/logger.js

@@ -0,0 +1,38 @@
+/**
+ * Simple Logger Stub
+ * 
+ * Provides a minimal logger interface for modules that need it.
+ * Respects VIBECHECK_DEBUG and VIBECHECK_QUIET environment variables.
+ */
+
+"use strict";
+
+const isDebug = process.env.VIBECHECK_DEBUG === "true" || process.env.DEBUG;
+const isQuiet = process.env.VIBECHECK_QUIET === "true";
+
+const logger = {
+  debug: (...args) => {
+    if (isDebug && !isQuiet) {
+      console.debug("[DEBUG]", ...args);
+    }
+  },
+  info: (...args) => {
+    if (!isQuiet) {
+      console.info("[INFO]", ...args);
+    }
+  },
+  warn: (...args) => {
+    console.warn("[WARN]", ...args);
+  },
+  error: (...args) => {
+    console.error("[ERROR]", ...args);
+  },
+  // Alias for compatibility
+  log: (...args) => {
+    if (!isQuiet) {
+      console.log(...args);
+    }
+  },
+};
+
+module.exports = { logger };

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

@@ -245,39 +245,38 @@ function formatScanOutput(result, options = {}) {
     });
     
     const categoryLabels = {
-      'EnvContract': '🔐 Env Vars',
+      'EnvContract': '🔐 Env',
       'MissingRoute': '🔗 Routes',
-      'GhostAuth': '🛡️  Auth',
-      'FakeSuccess': '⚠️  Fake Success',
-      'MockData': '🎭 Mock Data',
+      'GhostAuth': '🛡️ Auth',
+      'FakeSuccess': '⚠️ Fake',
+      'MockData': '🎭 Mocks',
       'Secrets': '🔑 Secrets',
-      'ConsoleLog': '📝 Console Logs',
+      'ConsoleLog': '📝 Logs',
       'TodoFixme': '📋 TODOs',
+      'CodeQuality': '✨ Quality',
+      'Security': '⚡ Security',
+      'Performance': '⚡ Perf',
     };
     
     const summaryItems = Object.entries(categoryCounts)
       .sort((a, b) => b[1] - a[1])
       .slice(0, 6)
       .map(([cat, count]) => {
-        const label = categoryLabels[cat] || `📌 ${cat}`;
+        const label = categoryLabels[cat] || cat;
         return `${label}: ${chalk.bold}${count}${chalk.reset}`;
       });
     
     if (summaryItems.length > 0) {
-      // Split into two lines if too long
-      const categoryText = summaryItems.join('  •  ');
-      const prefix = `${chalk.dim}Findings by Category:${chalk.reset} `;
-      const maxLineLength = WIDTH - 10; // Leave some margin
+      // Simple left-aligned format with consistent spacing
+      const indent = '  ';
       
-      if (categoryText.length > maxLineLength - prefix.length) {
-        // Split into two lines
-        const midPoint = Math.floor(summaryItems.length / 2);
-        const line1 = summaryItems.slice(0, midPoint).join('  •  ');
-        const line2 = summaryItems.slice(midPoint).join('  •  ');
-        lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${prefix}${line1}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-        lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${' '.repeat(prefix.length)}${line2}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
-      } else {
-        lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${padCenter(`${prefix}${categoryText}`, WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+      // Always split into 2 rows of 3 for clean alignment
+      const row1 = summaryItems.slice(0, 3).join('   ');
+      const row2 = summaryItems.slice(3, 6).join('   ');
+      
+      lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${indent}${chalk.dim}FINDINGS:${chalk.reset} ${row1}${' '.repeat(Math.max(0, WIDTH - row1.length - 14))}${chalk.gray}${BOX.vertical}${chalk.reset}`);
+      if (row2) {
+        lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${indent}${' '.repeat(10)}${row2}${' '.repeat(Math.max(0, WIDTH - row2.length - 14))}${chalk.gray}${BOX.vertical}${chalk.reset}`);
       }
       lines.push(`${chalk.gray}${BOX.vertical}${chalk.reset}${' '.repeat(WIDTH - 2)}${chalk.gray}${BOX.vertical}${chalk.reset}`);
     }

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

@@ -322,8 +322,8 @@ function renderBlockerDetails(findings, maxShow = 8, options = {}) {
   
   if (blockers.length === 0) return '';
   
-  // Fix hints are STARTER+ only
-  const canShowFixHints = tier === 'starter' || tier === 'pro' || tier === 'compliance';
+  // Fix hints are PRO only (2-tier model)
+  const canShowFixHints = tier === 'pro' || tier === 'compliance' || tier === 'starter'; // starter=legacy compatibility
   
   const lines = [];
   lines.push(renderSection(`BLOCKERS (${blockers.length})`, '🚨'));
@@ -373,7 +373,7 @@ function renderBlockerDetails(findings, maxShow = 8, options = {}) {
       }
     } else {
       // Show locked fix hint for FREE tier
-      lines.push(`             ${ansi.dim}🔒 Fix hint available with STARTER${ansi.reset}`);
+      lines.push(`             ${ansi.dim}🔒 Fix hints available with PRO ($69/mo)${ansi.reset}`);
     }
     
     lines.push('');
@@ -388,9 +388,9 @@ function renderBlockerDetails(findings, maxShow = 8, options = {}) {
   if (!canShowFixHints && blockers.length > 0) {
     lines.push(`  ${ansi.dim}─────────────────────────────────────────${ansi.reset}`);
     lines.push(`  ${colors.accent}💡${ansi.reset} ${ansi.bold}Unlock AI fix suggestions${ansi.reset}`);
-    lines.push(`  ${ansi.dim}STARTER users get specific fix hints and${ansi.reset}`);
+    lines.push(`  ${ansi.dim}PRO users get specific fix hints and${ansi.reset}`);
     lines.push(`  ${ansi.dim}AI mission prompts for every issue.${ansi.reset}`);
-    lines.push(`  ${colors.accent}vibecheck login${ansi.reset} ${ansi.dim}to upgrade${ansi.reset}`);
+    lines.push(`  ${colors.accent}Upgrade to PRO ($69/mo)${ansi.reset} ${ansi.dim}→ vibecheckai.dev/pricing${ansi.reset}`);
     lines.push('');
   }
   
@@ -702,22 +702,15 @@ function renderUpgradePrompts(findings, verdict) {
   lines.push(`  ${colors.accent}⚡${ansi.reset} ${ansi.bold}Want to fix these automatically?${ansi.reset}`);
   lines.push('');
   
-  // STARTER tier benefits
-  lines.push(`  ${colors.accent}STARTER${ansi.reset} ${ansi.dim}($39/mo)${ansi.reset}`);
+  // PRO tier benefits (2-tier: FREE / PRO)
+  lines.push(`  ${colors.accent}PRO${ansi.reset} ${ansi.dim}($69/mo)${ansi.reset}`);
   lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck fix${ansi.reset} - AI auto-fix for ${fixableCount} issues`);
-  lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck guard${ansi.reset} - Prevent AI hallucinations before commit`);
-  lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck report${ansi.reset} - SARIF export for GitHub code scanning`);
+  lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck ship${ansi.reset} - GO/NO-GO verdicts with proof`);
+  lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck prove${ansi.reset} - Video proof your app actually works`);
+  lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck reality --agent${ansi.reset} - AI tests your app autonomously`);
   lines.push('');
   
-  // PRO tier benefits (only if there are blockers)
-  if (blockers.length > 0 || verdict === 'BLOCK') {
-    lines.push(`  ${colors.accent}PRO${ansi.reset} ${ansi.dim}($99/mo)${ansi.reset}`);
-    lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck prove${ansi.reset} - Video proof your app actually works`);
-    lines.push(`    ${colors.success}→${ansi.reset} ${ansi.bold}vibecheck reality --agent${ansi.reset} - AI tests your app autonomously`);
-    lines.push('');
-  }
-  
-  lines.push(`  ${ansi.dim}Try STARTER free for 14 days: ${colors.accent}vibecheck login${ansi.reset}`);
+  lines.push(`  ${ansi.dim}Upgrade: ${colors.accent}vibecheckai.dev/pricing${ansi.reset}`);
   lines.push('');
   
   return lines.join('\n');
@@ -751,8 +744,8 @@ function formatShipOutput(result, options = {}) {
     cached = false,
   } = result;
   
-  const isPro = tier === 'pro' || tier === 'compliance';
-  const isStarter = tier === 'starter' || isPro;
+  const isPro = tier === 'pro' || tier === 'compliance' || tier === 'starter'; // starter=legacy compat
+  const isProTier = isPro; // 2-tier model: isPro covers all paid tiers
   const canShip = verdict === 'SHIP';
   
   const lines = [];
@@ -777,7 +770,7 @@ function formatShipOutput(result, options = {}) {
   lines.push(renderBlockerDetails(findings, 8, { tier }));
   
   // Upgrade prompts for FREE tier users (if there are fixable issues)
-  if (findings.length > 0 && !isStarter) {
+  if (findings.length > 0 && !isProTier) {
     lines.push(renderUpgradePrompts(findings, verdict));
   }
   
@@ -799,16 +792,16 @@ function formatShipOutput(result, options = {}) {
   }
   
   // Badge (if requested and tier allows)
-  if (showBadge && isStarter) {
+  if (showBadge && isProTier) {
     const badgeResult = renderBadgeOutput(projectPath, verdict, score, { tier, isVerified });
     lines.push(badgeResult.output);
-  } else if (showBadge && !isStarter) {
+  } else if (showBadge && !isProTier) {
     // Show badge upsell for FREE users
     lines.push('');
     lines.push(renderSection('BADGE', '📛'));
     lines.push('');
-    lines.push(`  ${ansi.dim}🔒 Ship badges require STARTER tier${ansi.reset}`);
-    lines.push(`  ${colors.accent}vibecheck login${ansi.reset} ${ansi.dim}to upgrade${ansi.reset}`);
+    lines.push(`  ${ansi.dim}🔒 Ship badges require PRO ($69/mo)${ansi.reset}`);
+    lines.push(`  ${colors.accent}vibecheckai.dev/pricing${ansi.reset} ${ansi.dim}to upgrade${ansi.reset}`);
     lines.push('');
   }