@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/runAuth.js

@@ -15,6 +15,8 @@ const {
 } = require("./lib/auth");
 const { EXIT } = require("./lib/exit-codes");
 const { parseGlobalFlags, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
+const { getTier, getLimits, FREE_FEATURES, PRO_FEATURES } = require("./lib/entitlements-v2");
+const { printActionableError } = require("./lib/error-messages");
 const {
   ansi,
   sym,
@@ -30,9 +32,6 @@ const {
   TIER,
 } = require("./lib/unified-cli-output");
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
-
 async function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -154,10 +153,10 @@ async function runLogin(args) {
       if (json) {
         console.log(JSON.stringify({ success: false, error: "Invalid API key format" }));
       } else {
-        renderError("Invalid API key format");
-        console.log(`  ${ansi.dim}API keys should be at least 20 characters.${ansi.reset}`);
+        printActionableError('INVALID_API_KEY', { command: 'login' });
       }
-      return EXIT.USER_ERROR;
+      // Return AUTH_FAILED for invalid key format (matches test expectations)
+      return EXIT.AUTH_FAILED;
     }
 
     const spinner = !quiet && !json ? new Spinner("Verifying API key").start() : null;
@@ -193,25 +192,7 @@ async function runLogin(args) {
       console.log(JSON.stringify(result));
     } else if (!quiet) {
       spinner?.succeed(`Logged in as ${ansi.bold}${result.user}${ansi.reset}`);
-      console.log(`  ${ansi.dim}Plan:${ansi.reset} ${getTierBadge(result.plan)}`);
-      console.log();
-      
-      // Show available features based on plan
-      const isPro = result.plan !== 'free';
-      if (isPro) {
-        console.log(`  ${ansi.green}✓${ansi.reset} ${ansi.bold}PRO features unlocked:${ansi.reset}`);
-        console.log(`    ${ansi.cyan}vibecheck fix${ansi.reset}    ${ansi.dim}AI-powered code fixes${ansi.reset}`);
-        console.log(`    ${ansi.cyan}vibecheck ship${ansi.reset}   ${ansi.dim}Ship readiness + badges${ansi.reset}`);
-        console.log(`    ${ansi.cyan}vibecheck prove${ansi.reset}  ${ansi.dim}Runtime proof generation${ansi.reset}`);
-        console.log(`    ${ansi.cyan}vibecheck mcp${ansi.reset}    ${ansi.dim}Full MCP server access${ansi.reset}`);
-      } else {
-        console.log(`  ${ansi.gray}╭${'─'.repeat(52)}╮${ansi.reset}`);
-        console.log(`  ${ansi.gray}│${ansi.reset}  ${ansi.magenta}★${ansi.reset} Upgrade to ${ansi.bold}PRO${ansi.reset} for AI fixes, ship badges,   ${ansi.gray}│${ansi.reset}`);
-        console.log(`  ${ansi.gray}│${ansi.reset}    CI enforcement, and full MCP access              ${ansi.gray}│${ansi.reset}`);
-        console.log(`  ${ansi.gray}│${ansi.reset}    ${ansi.cyan}vibecheck upgrade${ansi.reset} or ${ansi.dim}vibecheckai.dev/pricing${ansi.reset}   ${ansi.gray}│${ansi.reset}`);
-        console.log(`  ${ansi.gray}╰${'─'.repeat(52)}╯${ansi.reset}`);
-      }
-      console.log();
+      console.log(`  ${ansi.dim}Plan:${ansi.reset} ${getTierBadge(result.plan)}\n`);
     }
 
     return EXIT.SUCCESS;
@@ -310,10 +291,16 @@ async function runWhoami(args) {
     const { key, source } = getApiKey();
 
     if (!key) {
-      const result = { authenticated: false, message: "Not logged in" };
+      const result = json ? {
+        success: false,
+        error: {
+          code: "AUTH_REQUIRED",
+          message: "Not logged in",
+        },
+      } : { authenticated: false, message: "Not logged in" };
       
       if (json) {
-        console.log(JSON.stringify(result));
+        console.log(JSON.stringify(result, null, 2));
       } else {
         renderWarning("Not logged in");
         console.log(`  ${ansi.dim}Run "vibecheck login" or set VIBECHECK_API_KEY.${ansi.reset}\n`);
@@ -329,7 +316,13 @@ async function runWhoami(args) {
     } catch (apiError) {
       spinner?.fail(`Failed to fetch: ${apiError.message}`);
       if (json) {
-        console.log(JSON.stringify({ authenticated: true, error: apiError.message }));
+        console.log(JSON.stringify({
+          success: false,
+          error: {
+            code: "NETWORK_ERROR",
+            message: apiError.message,
+          },
+        }, null, 2));
       }
       return EXIT.NETWORK_ERROR;
     }
@@ -337,7 +330,13 @@ async function runWhoami(args) {
     if (!entitlements) {
       spinner?.fail("Invalid API key or server unreachable");
       if (json) {
-        console.log(JSON.stringify({ authenticated: false, error: "Invalid API key" }));
+        console.log(JSON.stringify({
+          success: false,
+          error: {
+            code: "AUTH_FAILED",
+            message: "Invalid API key",
+          },
+        }, null, 2));
       } else {
         console.log(`  ${ansi.dim}Run "vibecheck login" to re-authenticate.${ansi.reset}\n`);
       }
@@ -346,16 +345,38 @@ async function runWhoami(args) {
 
     spinner?.stop(null, null, null); // Clear spinner without message
 
+    // Determine tier (map plan to tier)
+    const plan = entitlements.plan || entitlements.tier || "free";
+    const tier = plan === "free" ? "free" : "pro";
+    
+    // Get features available for this tier
+    const features = tier === "pro" ? PRO_FEATURES : FREE_FEATURES;
+    
+    // Get limits for this tier
+    const tierLimits = getLimits(tier);
+    
+    // Build result object
     const result = {
-      authenticated: true,
-      source: source === "env" ? "environment" : "config",
-      user: {
-        name: entitlements.user?.name,
-        id: entitlements.user?.id,
+      success: true,
+      data: {
+        user: {
+          id: entitlements.user?.id || entitlements.userId,
+          email: entitlements.user?.email || entitlements.email,
+          name: entitlements.user?.name,
+        },
+        tier: tier,
+        features: features,
+        limits: {
+          scansPerMonth: entitlements.limits?.scansPerMonth ?? tierLimits.maxScansPerMonth,
+          filesPerScan: entitlements.limits?.filesPerScan ?? tierLimits.maxFilesPerScan,
+          reportFormats: tierLimits.reportFormats,
+        },
+        usage: {
+          scansThisMonth: entitlements.usage?.scansThisMonth || 0,
+          filesScanned: entitlements.usage?.filesScanned || 0,
+        },
       },
-      plan: entitlements.plan,
-      limits: entitlements.limits,
-      scopes: entitlements.scopes,
+      timestamp: new Date().toISOString(),
     };
 
     if (json) {
@@ -364,27 +385,28 @@ async function runWhoami(args) {
       renderSectionHeader("Account", sym.key);
       
       renderKeyValue([
-        { label: "User", value: `${ansi.bold}${result.user.name}${ansi.reset} ${ansi.dim}(${result.user.id})${ansi.reset}` },
-        { label: "Plan", value: getTierBadge(result.plan) },
+        { label: "User", value: `${ansi.bold}${result.data.user.name || 'Unknown'}${ansi.reset} ${ansi.dim}(${result.data.user.id || 'N/A'})${ansi.reset}` },
+        { label: "Tier", value: getTierBadge(tier) },
         { label: "Source", value: source === "env" ? "Environment Variable" : "Local Config" },
-        { label: "Limits", value: `${result.limits?.runsPerMonth || "unlimited"} runs/month` },
+        { label: "Scans this month", value: `${result.data.usage.scansThisMonth}/${result.data.limits.scansPerMonth === -1 ? '∞' : result.data.limits.scansPerMonth}` },
       ]);
       
-      if (result.scopes && result.scopes.length > 0) {
+      const scopes = entitlements.scopes || [];
+      if (scopes.length > 0) {
         console.log();
         console.log(`  ${ansi.dim}Scopes:${ansi.reset}`);
-        result.scopes.forEach(s => console.log(`    ${ansi.gray}${sym.bullet}${ansi.reset} ${s}`));
+        scopes.forEach(s => console.log(`    ${ansi.gray}${sym.bullet}${ansi.reset} ${s}`));
       }
       
       // Tier-specific upsell
-      if (result.plan === "free") {
+      if (tier === "free") {
         renderFooter({
           nextSteps: [
             { cmd: "vibecheck scan", desc: "analyze your codebase" },
           ],
           showUpsell: true,
         });
-      } else if (result.plan === "starter") {
+      } else if (plan === "starter") {
         console.log();
         console.log(`  ${ansi.dim}${sym.star}${ansi.reset} ${ansi.magenta}PRO${ansi.reset}${ansi.dim}: proof loops + badge generation + priority support${ansi.reset}`);
         console.log(`  ${ansi.dim}  Upgrade ${sym.arrow} https://vibecheckai.dev${ansi.reset}\n`);
@@ -396,7 +418,13 @@ async function runWhoami(args) {
     return EXIT.SUCCESS;
   } catch (error) {
     if (json) {
-      console.log(JSON.stringify({ authenticated: false, error: error.message }));
+      console.log(JSON.stringify({
+        success: false,
+        error: {
+          code: error.code || "INTERNAL_ERROR",
+          message: error.message,
+        },
+      }, null, 2));
     } else {
       renderError(`Whoami failed: ${error.message}`);
     }

package/bin/runners/runCheckpoint.js

@@ -15,15 +15,37 @@ const path = require("path");
 const entitlements = require("./lib/entitlements-v2");
 const { parseGlobalFlags, shouldShowBanner, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
 const { EXIT } = require("./lib/exit-codes");
+const { ensureScanResults } = require("./lib/prerequisites");
+const { printActionableError } = require("./lib/error-messages");
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TERMINAL UI - Import from shared module
+// TERMINAL STYLING
 // ═══════════════════════════════════════════════════════════════════════════════
 
-const { c, icons, Spinner } = require("./lib/terminal-ui");
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+};
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
+const icons = {
+  check: '✓',
+  cross: '✗',
+  arrow: '→',
+  warning: '⚠',
+  info: 'ℹ',
+  star: '★',
+  rocket: '🚀',
+  target: '🎯',
+  chart: '📊',
+  brain: '🧠',
+};
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // CHECKPOINT CORE
@@ -280,7 +302,7 @@ async function runCheckpoint(args) {
     if (json) {
       console.log(JSON.stringify({ success: false, error: `Project path does not exist: ${projectPath}` }));
     } else {
-      console.error(`${c.red}${icons.cross}${c.reset} Project path does not exist: ${projectPath}`);
+      printActionableError('PROJECT_PATH_NOT_FOUND', { command: 'checkpoint', path: projectPath });
     }
     return EXIT.NOT_FOUND;
   }
@@ -333,13 +355,31 @@ async function runCheckpoint(args) {
   }
   
   if (!current) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: "No current results found" }));
-    } else if (!quiet) {
-      console.log(`\n${c.yellow}${icons.warning}${c.reset} No current results found.`);
-      console.log(`${c.dim}Run 'vibecheck scan' to generate current results.${c.reset}\n`);
+    // Auto-run scan if results are missing (unless in CI or explicitly disabled)
+    if (!opts.ci && !opts.noAutoRun && !process.env.CI) {
+      const scanPrereq = await ensureScanResults(projectPath, {
+        quiet,
+        json,
+        ci: opts.ci,
+        colors: c,
+        icons,
+        ansi: c,
+      });
+      
+      if (scanPrereq.success) {
+        // Reload after scan
+        current = loadResults(latestPath);
+      }
     }
-    return EXIT.NOT_FOUND;
+    
+      if (!current) {
+        if (json) {
+          console.log(JSON.stringify({ success: false, error: "No current results found" }));
+        } else if (!quiet) {
+          printActionableError('NO_SCAN_RESULTS', { command: 'checkpoint' });
+        }
+        return EXIT.NOT_FOUND;
+      }
   }
   
   // Extract findings arrays

package/bin/runners/runClassify.js

@@ -19,6 +19,14 @@ const { withErrorHandling, createUserError } = require("./lib/error-handler");
 const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
 const { EXIT } = require("./lib/exit-codes");
 
+// Engine V2 support (when VIBECHECK_ENGINE_V2=1)
+let createIndex = null;
+try {
+  createIndex = require("./lib/engine").createIndex;
+} catch {
+  // Engine V2 not available, use legacy file walking
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // TERMINAL UI
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -29,9 +37,6 @@ const {
   Spinner,
 } = require("./lib/terminal-ui");
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
-
 const BANNER = `
 ${ansi.rgb(0, 200, 255)}  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗${ansi.reset}
 ${ansi.rgb(30, 180, 255)}  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝${ansi.reset}
@@ -218,12 +223,34 @@ const EXCLUDED_DIRS = new Set([
 ]);
 
 /**
- * Find all source files
+ * Find all source files using RepoIndex (V2) or legacy walk
  */
 async function findSourceFiles(rootPath, maxFiles) {
-  const files = [];
   const extensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
   
+  // Use RepoIndex if V2 is enabled and available
+  if (process.env.VIBECHECK_ENGINE_V2 === "1" && createIndex) {
+    const index = await createIndex(rootPath);
+    const jsFiles = index.getJsFiles();
+    
+    const files = jsFiles
+      .slice(0, maxFiles)
+      .map(f => ({
+        path: f.abs,
+        relativePath: f.rel,
+        name: path.basename(f.abs),
+        ext: f.ext,
+        _indexContent: index.getContent(f.abs), // Cache content from index
+      }));
+    
+    // Store index reference for cleanup
+    files._index = index;
+    return files;
+  }
+  
+  // Legacy file walking
+  const files = [];
+  
   async function walk(dir, depth = 0) {
     if (depth > 20 || files.length >= maxFiles) return;
     
@@ -377,7 +404,7 @@ async function runInventoryAnalysis(projectPath, opts, spinner) {
   const startTime = Date.now();
   
   // Find source files
-  spinner.update('Discovering source files...');
+  if (spinner) spinner.update('Discovering source files...');
   const files = await findSourceFiles(projectPath, opts.maxFiles);
   
   if (files.length === 0) {
@@ -395,16 +422,17 @@ async function runInventoryAnalysis(projectPath, opts, spinner) {
     };
   }
   
-  spinner.update(`Analyzing ${files.length} files...`);
+  if (spinner) spinner.update(`Analyzing ${files.length} files...`);
   
-  // Read all file contents
+  // Read all file contents (use cached content from RepoIndex when available)
   const fileContents = new Map();
   const fileHashes = new Map();
   const normalizedHashes = new Map();
   
   for (const file of files) {
     try {
-      const content = await fs.promises.readFile(file.path, 'utf-8');
+      // Use cached content from RepoIndex if available (V2 optimization)
+      const content = file._indexContent || await fs.promises.readFile(file.path, 'utf-8');
       const lines = content.split('\n').length;
       fileContents.set(file.relativePath, { content, lines });
       
@@ -419,11 +447,16 @@ async function runInventoryAnalysis(projectPath, opts, spinner) {
     }
   }
   
+  // Cleanup RepoIndex cache if used
+  if (files._index) {
+    files._index.clearContentCache();
+  }
+  
   // ═══════════════════════════════════════════════════════════════════════════
   // DUPLICATE DETECTION
   // ═══════════════════════════════════════════════════════════════════════════
   
-  spinner.update('Detecting duplicates...');
+  if (spinner) spinner.update('Detecting duplicates...');
   
   const duplicationMap = [];
   const exactDuplicates = new Map(); // hash -> [files]
@@ -493,7 +526,7 @@ async function runInventoryAnalysis(projectPath, opts, spinner) {
   
   // Semantic duplicates (token-based similarity)
   if (opts.includeSemantic) {
-    spinner.update('Computing semantic similarity...');
+    if (spinner) spinner.update('Computing semantic similarity...');
     
     const tokenSets = new Map();
     for (const [filePath, { content }] of fileContents.entries()) {
@@ -543,7 +576,7 @@ async function runInventoryAnalysis(projectPath, opts, spinner) {
   // LEGACY CODE DETECTION
   // ═══════════════════════════════════════════════════════════════════════════
   
-  spinner.update('Detecting legacy code...');
+  if (spinner) spinner.update('Detecting legacy code...');
   
   const legacyMap = [];
   
@@ -567,7 +600,7 @@ async function runInventoryAnalysis(projectPath, opts, spinner) {
   // RISK CLASSIFICATION
   // ═══════════════════════════════════════════════════════════════════════════
   
-  spinner.update('Classifying risk levels...');
+  if (spinner) spinner.update('Classifying risk levels...');
   
   const riskClassifications = [];
   
@@ -789,8 +822,14 @@ async function runClassify(args) {
     return 0;
   }
   
-  // Print banner
-  if (shouldShowBanner(opts)) {
+  // CRITICAL: Check for JSON output FIRST - skip all banners/output if this flag is set
+  if (opts.json) {
+    process.env.NO_COLOR = '1';
+    // Skip all banner/output until we output JSON
+  }
+  
+  // Print banner (skip if JSON mode)
+  if (shouldShowBanner(opts) && !opts.json) {
     printBanner();
   }
   
@@ -801,20 +840,22 @@ async function runClassify(args) {
     throw createUserError(`Project path does not exist: ${projectPath}`, "ValidationError");
   }
   
-  if (!opts.quiet) {
+  if (!opts.quiet && !opts.json) {
     console.log(`  ${ansi.dim}Project:${ansi.reset}   ${ansi.bold}${path.basename(projectPath)}${ansi.reset}`);
     console.log(`  ${ansi.dim}Authority:${ansi.reset} ${colors.accent}inventory${ansi.reset} (FREE tier)`);
     console.log();
   }
   
-  // Run analysis
-  const spinner = new Spinner({ color: colors.primary });
-  spinner.start('Starting inventory analysis...');
+  // Run analysis (skip spinner if JSON mode)
+  const spinner = !opts.json ? new Spinner({ color: colors.primary }) : null;
+  if (spinner) spinner.start('Starting inventory analysis...');
   
   try {
     const result = await runInventoryAnalysis(projectPath, opts, spinner);
     
-    spinner.succeed(`Analysis complete (${result.summary.analysisTimeMs}ms)`);
+    if (spinner) {
+      spinner.succeed(`Analysis complete (${result.summary.analysisTimeMs}ms)`);
+    }
     
     // Construct full output
     const output = {
@@ -828,7 +869,11 @@ async function runClassify(args) {
     
     // Output based on format
     if (opts.json) {
+      // CRITICAL: Output ONLY JSON, no banners/colors
+      process.env.NO_COLOR = '1';
       console.log(JSON.stringify(output, null, 2));
+      // Exit immediately after JSON output
+      return EXIT.SUCCESS;
     } else if (opts.format === 'markdown') {
       console.log(formatMarkdownOutput(result, projectPath));
     } else {
@@ -852,7 +897,26 @@ async function runClassify(args) {
     return EXIT.SUCCESS;
     
   } catch (error) {
-    spinner.fail(`Analysis failed: ${error.message}`);
+    if (spinner && !opts.json) {
+      spinner.fail(`Analysis failed: ${error.message}`);
+    }
+    
+    // JSON error output
+    if (opts.json) {
+      process.env.NO_COLOR = '1';
+      const errorOutput = {
+        success: false,
+        error: {
+          code: error.code || 'CLASSIFY_ERROR',
+          message: error.message,
+        },
+        exitCode: error.code === 'VALIDATION_ERROR' ? EXIT.USER_ERROR : EXIT.INTERNAL_ERROR
+      };
+      console.log(JSON.stringify(errorOutput, null, 2));
+      process.exit(errorOutput.exitCode);
+      return errorOutput.exitCode;
+    }
+    
     throw error;
   }
 }

package/bin/runners/runContext.js

@@ -24,9 +24,6 @@ const {
   getTierFromKey,
 } = require("./lib/unified-cli-output");
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
-
 async function runContext(args) {
   const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
   const quiet = shouldSuppressOutput(globalFlags);

package/bin/runners/runDoctor.js

@@ -24,15 +24,44 @@ const { formatWorkflowUpsell } = require("./lib/upsell");
 const { getApiKey } = require("./lib/auth");
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TERMINAL UI - Import from shared module
+// ADVANCED TERMINAL - ANSI CODES & UTILITIES
 // ═══════════════════════════════════════════════════════════════════════════════
 
-const { c, rgb, bgRgb, icons, Spinner } = require("./lib/terminal-ui");
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  // 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',
+  // Cursor control
+  clearLine: '\x1b[2K',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+};
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
+// 256-color / True color support
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+const bgRgb = (r, g, b) => `\x1b[48;2;${r};${g};${b}m`;
 
-// Extended color palette for doctor command
+// Premium color palette
 const colors = {
   // Gradients for banner
   gradient1: rgb(100, 200, 255),   // Light blue
@@ -276,13 +305,6 @@ async function runDoctor(args, context = {}) {
   const json = isJsonMode(opts);
   const executionStart = Date.now();
   
-  // Configure unified output mode
-  output.setMode({ 
-    json: json, 
-    quiet: quiet, 
-    ci: opts.ci 
-  });
-  
   if (opts.help) {
     printHelp(shouldShowBanner(opts));
     return EXIT.SUCCESS;
@@ -581,20 +603,14 @@ function runDoctorLegacy() {
   
   // Get tier for upsell
   const { key } = getApiKey();
-  const currentTier = key ? "pro" : "free";
+  const currentTier = key ? "starter" : "free";
   
   if (hasIssues) {
     console.log("  ❌ Issues found. Fix them and run doctor again.");
     console.log();
-    
+    console.log(`  ${c.dim}Need help?${c.reset} ${colors.accent}vibecheck fix${c.reset} ${c.dim}can auto-repair many issues${c.reset}`);
     if (currentTier === "free") {
-      console.log(`  ${c.gray}╭${'─'.repeat(58)}╮${c.reset}`);
-      console.log(`  ${c.gray}│${c.reset}  ${c.magenta}★ PRO${c.reset} Auto-fix environment issues with AI            ${c.gray}│${c.reset}`);
-      console.log(`  ${c.gray}│${c.reset}       ${c.cyan}vibecheck fix${c.reset} can auto-repair many issues       ${c.gray}│${c.reset}`);
-      console.log(`  ${c.gray}│${c.reset}       ${c.dim}https://vibecheckai.dev/pricing${c.reset}                   ${c.gray}│${c.reset}`);
-      console.log(`  ${c.gray}╰${'─'.repeat(58)}╯${c.reset}`);
-    } else {
-      console.log(`  ${c.dim}Need help?${c.reset} ${colors.accent}vibecheck fix${c.reset} ${c.dim}can auto-repair many issues${c.reset}`);
+      console.log(`  ${c.dim}Requires STARTER plan • vibecheckai.dev${c.reset}`);
     }
     console.log();
     return EXIT.BLOCKING;
@@ -602,13 +618,10 @@ function runDoctorLegacy() {
     console.log("  ✅ Environment healthy!");
     console.log();
     
-    if (currentTier === "free") {
-      console.log(`  ${c.gray}╭${'─'.repeat(58)}╮${c.reset}`);
-      console.log(`  ${c.gray}│${c.reset}  ${c.green}✓${c.reset} Ready to scan! Try: ${c.cyan}vibecheck scan${c.reset}                  ${c.gray}│${c.reset}`);
-      console.log(`  ${c.gray}│${c.reset}                                                          ${c.gray}│${c.reset}`);
-      console.log(`  ${c.gray}│${c.reset}  ${c.magenta}★ PRO${c.reset} AI-powered fixes, CI gates, ship badges          ${c.gray}│${c.reset}`);
-      console.log(`  ${c.gray}│${c.reset}       ${c.dim}https://vibecheckai.dev/pricing${c.reset}                   ${c.gray}│${c.reset}`);
-      console.log(`  ${c.gray}╰${'─'.repeat(58)}╯${c.reset}`);
+    // Workflow upsell
+    const workflow = formatWorkflowUpsell("doctor", currentTier);
+    if (workflow) {
+      console.log(`  ${workflow}`);
     } else {
       console.log(`  ${c.dim}Ready to scan?${c.reset} ${colors.accent}vibecheck scan${c.reset} ${c.dim}finds AI mistakes before they ship${c.reset}`);
     }