@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/runInit.js

@@ -1,8 +1,8 @@
 /**
- * vibecheck init - Project Setup
+ * vibecheck init - Enterprise Project Setup
  *
  * ═══════════════════════════════════════════════════════════════════════════════
- * Professional Terminal Experience
+ * ENTERPRISE EDITION - World-Class Terminal Experience
  * ═══════════════════════════════════════════════════════════════════════════════
  *
  * Configure your project for production-grade verification.
@@ -31,15 +31,64 @@ try {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// 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',
+  blink: '\x1b[5m',
+  inverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  strike: '\x1b[9m',
+  // Colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  // Bright colors
+  gray: '\x1b[90m',
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+  // Background
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+  // Cursor control
+  cursorUp: (n = 1) => `\x1b[${n}A`,
+  cursorDown: (n = 1) => `\x1b[${n}B`,
+  cursorRight: (n = 1) => `\x1b[${n}C`,
+  cursorLeft: (n = 1) => `\x1b[${n}D`,
+  clearLine: '\x1b[2K',
+  clearScreen: '\x1b[2J',
+  saveCursor: '\x1b[s',
+  restoreCursor: '\x1b[u',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+};
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
+// 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 init command (gold/amber theme)
+// Premium color palette (gold/amber theme for "init/setup")
 const colors = {
   // Gradient for banner
   gradient1: rgb(255, 215, 100),   // Gold
@@ -98,7 +147,7 @@ ${rgb(255, 140, 40)}   ╚████╔╝ ██║██████╔╝
 ${rgb(255, 120, 20)}    ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝${c.reset}
 
 ${c.dim}  ┌─────────────────────────────────────────────────────────────────────┐${c.reset}
-${c.dim}  │${c.reset}  ${rgb(255, 200, 100)}⚡${c.reset} ${c.bold}INIT${c.reset} ${c.dim}•${c.reset} ${rgb(200, 200, 200)}Project Setup${c.reset} ${c.dim}•${c.reset} ${rgb(150, 150, 150)}Production Ready${c.reset}              ${c.dim}│${c.reset}
+${c.dim}  │${c.reset}  ${rgb(255, 200, 100)}⚡${c.reset} ${c.bold}INIT${c.reset} ${c.dim}•${c.reset} ${rgb(200, 200, 200)}Project Setup${c.reset} ${c.dim}•${c.reset} ${rgb(150, 150, 150)}Enterprise Ready${c.reset}             ${c.dim}│${c.reset}
 ${c.dim}  └─────────────────────────────────────────────────────────────────────┘${c.reset}
 `;
 
@@ -645,8 +694,8 @@ async function runRepairMode(targetDir, projectName, opts) {
     if (!opts.dryRun) {
       startSpinner('Generating truthpack...', colors.accent);
       try {
-        const { runCtx } = require("./runCtx");
-        await runCtx(["build", "--path", targetDir, "--quiet"]);
+        const { runContext } = require("./runContext");
+        await runContext(["--path", targetDir, "--quiet"]);
         stopSpinner('Truthpack generated', true);
         fixes.push("Generated: .vibecheck/truthpack.json");
       } catch (e) {
@@ -994,7 +1043,7 @@ function printNextSteps(options = {}) {
     if (options.hasCI) {
       steps.push({ num: 3, cmd: 'git push', desc: 'CI will run automatically' });
     } else {
-      steps.push({ num: 3, cmd: 'vibecheck init --connect', desc: 'Add GitHub integration [PRO]' });
+      steps.push({ num: 3, cmd: 'vibecheck init --connect', desc: 'Add GitHub integration [STARTER]' });
     }
   }
   
@@ -1010,7 +1059,8 @@ function printNextSteps(options = {}) {
   // Upsell box
   console.log(`  ${c.dim}╭────────────────────────────────────────────────────────────╮${c.reset}`);
   console.log(`  ${c.dim}│${c.reset}                                                            ${c.dim}│${c.reset}`);
-  console.log(`  ${c.dim}│${c.reset}  ${colors.accent}🏆 PRO${c.reset}     ${c.dim}•${c.reset} AI fixes, CI, runtime proof, badges, MCP     ${c.dim}│${c.reset}`);
+  console.log(`  ${c.dim}│${c.reset}  ${colors.accent}⚡ STARTER${c.reset} ${c.dim}•${c.reset} AI-powered fixes, GitHub CI, MCP tools       ${c.dim}│${c.reset}`);
+  console.log(`  ${c.dim}│${c.reset}  ${colors.accent}🏆 PRO${c.reset}     ${c.dim}•${c.reset} Runtime proof, verified badges, AI testing   ${c.dim}│${c.reset}`);
   console.log(`  ${c.dim}│${c.reset}                                                            ${c.dim}│${c.reset}`);
   console.log(`  ${c.dim}│${c.reset}  ${colors.info}vibecheck login${c.reset} ${c.dim}to upgrade • vibecheck.dev/pricing${c.reset}       ${c.dim}│${c.reset}`);
   console.log(`  ${c.dim}│${c.reset}                                                            ${c.dim}│${c.reset}`);
@@ -1360,13 +1410,17 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
   if (!opts.dryRun) {
     startSpinner('Building truthpack...', colors.accent);
     try {
-      const { runCtx } = require("./runCtx");
-      await runCtx(["build", "--path", targetDir, "--quiet"]);
+      const { runContext } = require("./runContext");
+      await runContext(["--path", targetDir, "--quiet"]);
       stopSpinner('Truthpack generated', true);
       filesCreated.push('.vibecheck/truthpack.json');
     } catch (e) {
       stopSpinner('Truthpack generation failed', false);
-      throw new Error(`Truthpack generation failed: ${e.message}. Run 'vibecheck ctx build' manually or 'vibecheck init --repair' to retry.`);
+      // Don't throw - truthpack generation is optional for init
+      if (!opts.json) {
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${e.message}`);
+        console.log(`  ${c.dim}Run 'vibecheck context' manually to generate truthpack${c.reset}`);
+      }
     }
   } else {
     printSetupStep('truthpack.json', 'dry-run', 'would generate via vibecheck ctx build');
@@ -1434,21 +1488,36 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
     printSetupStep('IDE rules', 'dry-run', 'would generate via vibecheck context');
   }
   
-  // 6. Create .vibecheckrc at project root
+  // 6. Create .vibecheckrc at project root (create both for compatibility)
   logStep('Creating root config');
-  const rcPath = path.join(targetDir, ".vibecheckrc.json");
-  if (!fs.existsSync(rcPath)) {
-    const rc = {
-      extends: ".vibecheck/config.json",
-      tier: "free",
-    };
+  const rcPathJson = path.join(targetDir, ".vibecheckrc.json");
+  const rcPath = path.join(targetDir, ".vibecheckrc");
+  const rc = {
+    extends: ".vibecheck/config.json",
+    tier: "free",
+  };
+  
+  if (!fs.existsSync(rcPathJson) && !fs.existsSync(rcPath)) {
     if (opts.dryRun) {
+      printSetupStep('.vibecheckrc', 'dry-run', 'would create');
       printSetupStep('.vibecheckrc.json', 'dry-run', 'would create');
     } else {
+      // Create .vibecheckrc (without .json) for compatibility with tests/expectations
       fs.writeFileSync(rcPath, JSON.stringify(rc, null, 2));
-      printSetupStep('.vibecheckrc.json', 'success', 'root config created');
+      printSetupStep('.vibecheckrc', 'success', 'root config created');
+      filesCreated.push('.vibecheckrc');
+      
+      // Also create .vibecheckrc.json for backward compatibility
+      fs.writeFileSync(rcPathJson, JSON.stringify(rc, null, 2));
       filesCreated.push('.vibecheckrc.json');
     }
+  } else if (fs.existsSync(rcPathJson) && !fs.existsSync(rcPath)) {
+    // If only .vibecheckrc.json exists, create .vibecheckrc for compatibility
+    if (!opts.dryRun) {
+      fs.writeFileSync(rcPath, JSON.stringify(rc, null, 2));
+      printSetupStep('.vibecheckrc', 'success', 'root config created (compatibility)');
+      filesCreated.push('.vibecheckrc');
+    }
   }
   
   // 7. Update .gitignore
@@ -1472,7 +1541,8 @@ async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
     }
   }
   
-  return filesCreated;
+  // Return both filesCreated and detection for use in main function
+  return { filesCreated, detection };
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -1573,10 +1643,11 @@ async function runInit(args) {
     return 0;
   }
 
-  // --quick mode delegates to runInstall (zero-friction onboarding)
+  // --quick mode runs local setup with non-interactive defaults
   if (opts.quick) {
-    const { runInstall } = require("./runInstall");
-    return await runInstall(args);
+    opts.local = true;
+    opts.nonInteractive = true;
+    // Continue with normal init flow below
   }
 
   const targetDir = path.resolve(opts.path);
@@ -1674,6 +1745,7 @@ async function runInit(args) {
   }
   
   let filesCreated = [];
+  let detection = null; // Declare detection in main function scope
   const result = {
     success: true,
     project: projectName,
@@ -1687,7 +1759,15 @@ async function runInit(args) {
   // Always run local setup first
   if (opts.local || opts.connect) {
     try {
-      filesCreated = await runLocalSetup(targetDir, projectName, opts, filesCreated);
+      // runLocalSetup returns both filesCreated and detection
+      const setupResult = await runLocalSetup(targetDir, projectName, opts, filesCreated);
+      if (setupResult && typeof setupResult === 'object' && 'filesCreated' in setupResult) {
+        filesCreated = setupResult.filesCreated;
+        detection = setupResult.detection || null;
+      } else {
+        // Backward compatibility: if it returns just an array, use it
+        filesCreated = Array.isArray(setupResult) ? setupResult : filesCreated;
+      }
     } catch (e) {
       result.errors.push({ step: 'local', error: e.message, stack: e.stack });
       if (!opts.json) {
@@ -1697,8 +1777,11 @@ async function runInit(args) {
         }
         console.log(`  ${colors.info}${ICONS.info}${c.reset} Run ${c.cyan}vibecheck init --repair${c.reset} to fix partial state`);
       }
-      if (!opts.dryRun) {
-        return EXIT.INTERNAL_ERROR; // Exit on error unless dry-run
+      // Don't exit on error - continue and report errors in result
+      // Only exit if critical setup failed AND we're not in dry-run mode
+      if (!opts.dryRun && result.errors.length > 0 && filesCreated.length === 0) {
+        // Only exit if NO files were created at all (complete failure)
+        return EXIT.INTERNAL_ERROR;
       }
     }
   }

package/bin/runners/runLabs.js

@@ -0,0 +1,424 @@
+/**
+ * vibecheck labs - Experimental Features
+ *
+ * Access to experimental, internal, and beta features.
+ * These may change or be removed without notice.
+ *
+ * @module runners/runLabs
+ */
+
+"use strict";
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+};
+
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+
+const colors = {
+  accent: rgb(0, 212, 255),
+  success: rgb(16, 185, 129),
+  warning: rgb(245, 158, 11),
+  error: rgb(239, 68, 68),
+  purple: rgb(168, 85, 247),
+};
+
+const sym = {
+  check: '✓',
+  cross: '✗',
+  warning: '⚠',
+  info: 'ℹ',
+  pending: '○',
+  lightning: '⚡',
+  star: '★',
+  arrow: '→',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// LABS FEATURE REGISTRY
+// ═══════════════════════════════════════════════════════════════════════════════
+const LABS_FEATURES = {
+  // Experimental - Working but API may change
+  "ai-agent": {
+    status: "experimental",
+    description: "AI autonomous testing agent",
+    docs: "https://docs.vibecheckai.dev/labs/ai-agent",
+    runner: () => require("./runAIAgent").runAIAgent,
+  },
+  "deep-scan": {
+    status: "experimental",
+    description: "Extended static analysis with ML patterns",
+    runner: async (args, ctx) => {
+      const { runScan } = require("./runScan");
+      return runScan(["--profile", "deep", ...args], ctx);
+    },
+  },
+  "hallucination-check": {
+    status: "experimental",
+    description: "Detect AI-generated code hallucinations",
+    runner: async (args, ctx) => {
+      const { runCheckpoint } = require("./runCheckpoint");
+      return runCheckpoint(["--hallucination", ...args], ctx);
+    },
+  },
+  "truth-diff": {
+    status: "experimental",
+    description: "Diff truthpack changes across commits",
+    runner: async (args) => {
+      console.log(`\n  ${c.yellow}${sym.warning} truth-diff${c.reset} is coming soon.\n`);
+      console.log(`  ${c.dim}This feature will compare truthpack snapshots across git commits.${c.reset}\n`);
+      return 0;
+    },
+  },
+
+  // Beta - Feature complete, gathering feedback
+  "smart-fix": {
+    status: "beta",
+    description: "AI-powered intelligent fix suggestions",
+    runner: async (args, ctx) => {
+      const { runFix } = require("./runFix");
+      return runFix(["--smart", ...args], ctx);
+    },
+  },
+  "security-audit": {
+    status: "beta",
+    description: "Comprehensive security audit mode",
+    runner: async (args, ctx) => {
+      const { runScan } = require("./runScan");
+      return runScan(["--profile", "security", ...args], ctx);
+    },
+  },
+
+  // Stubs - Planned but not implemented
+  "autopilot": {
+    status: "stub",
+    description: "Continuous protection mode (auto-fix on commit)",
+    eta: "Q2 2026",
+  },
+  "certify": {
+    status: "stub",
+    description: "Generate compliance certification badges",
+    eta: "Q2 2026",
+  },
+  "audit-trail": {
+    status: "stub",
+    description: "Full audit trail for compliance (SOC2, HIPAA)",
+    eta: "Q3 2026",
+  },
+  "natural-language": {
+    status: "stub",
+    description: "Natural language command interface",
+    eta: "Q2 2026",
+  },
+  "fix-packs": {
+    status: "stub",
+    description: "Downloadable fix pack templates",
+    eta: "Q2 2026",
+  },
+  "dashboard-live": {
+    status: "stub",
+    description: "Real-time live monitoring dashboard",
+    eta: "Q3 2026",
+  },
+
+  // Aliases - Redirect to main commands
+  "ship-strict": {
+    status: "alias",
+    target: "ship --strict",
+    description: "Enhanced ship mode (use: vibecheck ship --strict)",
+  },
+  "reality-agent": {
+    status: "alias",
+    target: "reality --agent",
+    description: "Reality with AI agent (use: vibecheck reality --agent)",
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STATUS DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+const STATUS_CONFIG = {
+  experimental: {
+    icon: sym.lightning,
+    color: c.yellow,
+    label: "EXPERIMENTAL",
+    description: "Working but API may change",
+  },
+  beta: {
+    icon: sym.star,
+    color: c.cyan,
+    label: "BETA",
+    description: "Feature complete, gathering feedback",
+  },
+  stub: {
+    icon: sym.pending,
+    color: c.dim,
+    label: "PLANNED",
+    description: "Not yet implemented",
+  },
+  alias: {
+    icon: sym.arrow,
+    color: c.dim,
+    label: "ALIAS",
+    description: "Use the main command instead",
+  },
+};
+
+function formatStatus(status) {
+  const config = STATUS_CONFIG[status];
+  if (!config) return status;
+  return `${config.color}${config.icon} ${config.label}${c.reset}`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELP DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+function printHelp() {
+  console.log(`
+  ${colors.accent}${c.bold}vibecheck labs${c.reset} - Experimental & Internal Features
+
+  ${c.yellow}${sym.warning} These features are experimental and may change without notice.${c.reset}
+`);
+
+  // Group by status
+  const groups = {
+    experimental: [],
+    beta: [],
+    stub: [],
+    alias: [],
+  };
+  
+  for (const [name, feature] of Object.entries(LABS_FEATURES)) {
+    if (groups[feature.status]) {
+      groups[feature.status].push({ name, ...feature });
+    }
+  }
+  
+  // Experimental
+  if (groups.experimental.length > 0) {
+    console.log(`  ${c.yellow}${sym.lightning} EXPERIMENTAL${c.reset} ${c.dim}(working, API may change)${c.reset}\n`);
+    
+    for (const feature of groups.experimental) {
+      console.log(`    ${c.cyan}vibecheck labs ${feature.name}${c.reset}`);
+      console.log(`      ${c.dim}${feature.description}${c.reset}`);
+      if (feature.docs) {
+        console.log(`      ${c.dim}Docs: ${feature.docs}${c.reset}`);
+      }
+      console.log("");
+    }
+  }
+  
+  // Beta
+  if (groups.beta.length > 0) {
+    console.log(`  ${c.cyan}${sym.star} BETA${c.reset} ${c.dim}(feature complete, gathering feedback)${c.reset}\n`);
+    
+    for (const feature of groups.beta) {
+      console.log(`    ${c.cyan}vibecheck labs ${feature.name}${c.reset}`);
+      console.log(`      ${c.dim}${feature.description}${c.reset}`);
+      console.log("");
+    }
+  }
+  
+  // Stubs
+  if (groups.stub.length > 0) {
+    console.log(`  ${c.dim}${sym.pending} PLANNED${c.reset} ${c.dim}(not yet implemented)${c.reset}\n`);
+    
+    for (const feature of groups.stub) {
+      const eta = feature.eta ? `${c.dim}(ETA: ${feature.eta})${c.reset}` : '';
+      console.log(`    ${c.dim}${feature.name}${c.reset}  ${feature.description} ${eta}`);
+    }
+    console.log("");
+  }
+  
+  // Aliases
+  if (groups.alias.length > 0) {
+    console.log(`  ${c.dim}${sym.arrow} ALIASES${c.reset} ${c.dim}(use the main command instead)${c.reset}\n`);
+    
+    for (const feature of groups.alias) {
+      console.log(`    ${c.dim}labs ${feature.name}${c.reset} ${sym.arrow} ${c.cyan}vibecheck ${feature.target}${c.reset}`);
+    }
+    console.log("");
+  }
+  
+  // Usage
+  console.log(`  ${c.dim}${"─".repeat(60)}${c.reset}`);
+  console.log(`
+  ${c.bold}Usage${c.reset}
+
+    vibecheck labs <feature> [options]
+
+  ${c.bold}Examples${c.reset}
+
+    ${c.dim}# Run AI agent testing${c.reset}
+    vibecheck labs ai-agent --url http://localhost:3000
+
+    ${c.dim}# Deep security scan${c.reset}
+    vibecheck labs security-audit
+
+    ${c.dim}# Smart AI fixes${c.reset}
+    vibecheck labs smart-fix
+
+  ${c.dim}${"─".repeat(60)}${c.reset}
+
+  ${c.bold}Feedback${c.reset}
+
+    Want a feature prioritized? Let us know:
+    ${c.cyan}https://github.com/vibecheckai/vibecheck/discussions${c.reset}
+`);
+}
+
+function printFeatureStub(name, feature) {
+  console.log(`
+  ${c.yellow}╭${"─".repeat(58)}╮${c.reset}
+  ${c.yellow}│${c.reset}  ${c.bold}vibecheck labs ${name}${c.reset}${" ".repeat(58 - 18 - name.length)}${c.yellow}│${c.reset}
+  ${c.yellow}╰${"─".repeat(58)}╯${c.reset}
+
+  ${feature.description}
+
+  ${c.dim}This feature is not yet implemented.${c.reset}
+  ${feature.eta ? `${c.dim}Expected: ${feature.eta}${c.reset}` : ""}
+
+  ${c.dim}Want this feature? Vote for it:${c.reset}
+  ${c.cyan}https://github.com/vibecheckai/vibecheck/discussions${c.reset}
+`);
+}
+
+function printAliasWarning(name, feature) {
+  console.log(`\n  ${c.yellow}${sym.warning}${c.reset} '${name}' is now available as: ${c.cyan}vibecheck ${feature.target}${c.reset}\n`);
+  console.log(`  ${c.dim}The labs alias will be removed in a future version.${c.reset}\n`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN RUNNER
+// ═══════════════════════════════════════════════════════════════════════════════
+async function runLabs(args = [], context = {}) {
+  // Filter out global flags that are passed through from main CLI
+  const GLOBAL_FLAGS = new Set([
+    '--offline', '--local', '--json', '--ci', '--quiet', '-q',
+    '--verbose', '--debug', '--strict', '--no-banner',
+  ]);
+  
+  // Find first non-flag argument as subcommand
+  let subCmd = null;
+  const subArgs = [];
+  let skipNext = false;
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    
+    // Skip global flags (and their values for --path, --output)
+    if (GLOBAL_FLAGS.has(arg)) continue;
+    if (arg === '--path' || arg === '-p' || arg === '--output' || arg === '-o') {
+      skipNext = true;
+      continue;
+    }
+    if (arg.startsWith('--path=') || arg.startsWith('--output=')) continue;
+    
+    // First non-flag arg is the subcommand
+    if (!subCmd && !arg.startsWith('-')) {
+      subCmd = arg;
+    } else {
+      subArgs.push(arg);
+    }
+  }
+  
+  // Show help if no command
+  if (!subCmd || subCmd === "--help" || subCmd === "-h") {
+    printHelp();
+    return 0;
+  }
+  
+  // List all features
+  if (subCmd === "--list" || subCmd === "-l") {
+    console.log(`\n  ${c.bold}Labs Features${c.reset}\n`);
+    
+    for (const [name, f] of Object.entries(LABS_FEATURES)) {
+      if (f.status !== 'stub' && f.status !== 'alias') {
+        console.log(`  ${formatStatus(f.status).padEnd(30)} ${c.cyan}${name.padEnd(20)}${c.reset} ${c.dim}${f.description}${c.reset}`);
+      }
+    }
+    console.log("");
+    return 0;
+  }
+  
+  // Find feature
+  const feature = LABS_FEATURES[subCmd];
+  
+  if (!feature) {
+    console.log(`\n  ${c.red}${sym.cross}${c.reset} Unknown labs feature: ${c.yellow}${subCmd}${c.reset}\n`);
+    console.log(`  ${c.dim}Available features:${c.reset}`);
+    console.log(`    ${Object.keys(LABS_FEATURES).filter(k => 
+      LABS_FEATURES[k].status !== "stub" && 
+      LABS_FEATURES[k].status !== "alias"
+    ).join(", ")}`);
+    console.log(`\n  ${c.dim}Run 'vibecheck labs --help' for details.${c.reset}\n`);
+    return 1;
+  }
+  
+  // Handle stubs
+  if (feature.status === "stub") {
+    printFeatureStub(subCmd, feature);
+    return 0;
+  }
+  
+  // Handle aliases
+  if (feature.status === "alias") {
+    printAliasWarning(subCmd, feature);
+    
+    // Try to run the aliased command
+    const [cmd, ...aliasArgs] = feature.target.split(" ");
+    try {
+      if (cmd === "ship") {
+        const { runShip } = require("./runShip");
+        return await runShip([...aliasArgs, ...subArgs], context);
+      }
+      if (cmd === "reality") {
+        const { runReality } = require("./runReality");
+        return await runReality([...aliasArgs, ...subArgs], context);
+      }
+    } catch (e) {
+      console.log(`  ${c.dim}Please run the command directly: vibecheck ${feature.target}${c.reset}\n`);
+    }
+    return 0;
+  }
+  
+  // Run the feature
+  try {
+    const runner = feature.runner();
+    
+    // Show experimental warning
+    if (feature.status === "experimental") {
+      console.log(`\n  ${c.yellow}${sym.warning} EXPERIMENTAL:${c.reset} ${c.dim}This feature may change without notice.${c.reset}\n`);
+    } else if (feature.status === "beta") {
+      console.log(`\n  ${c.cyan}${sym.star} BETA:${c.reset} ${c.dim}Feedback welcome! github.com/vibecheckai/vibecheck${c.reset}\n`);
+    }
+    
+    return await runner(subArgs, context);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      console.log(`\n  ${c.red}${sym.cross}${c.reset} Feature '${subCmd}' is not available in this version.\n`);
+      console.log(`  ${c.dim}Try updating: npm update -g @vibecheckai/cli${c.reset}\n`);
+    } else {
+      console.error(`\n  ${c.red}${sym.cross}${c.reset} Error running labs ${subCmd}: ${e.message}`);
+      if (process.env.VIBECHECK_DEBUG) {
+        console.error(c.dim + e.stack + c.reset);
+      }
+    }
+    return 1;
+  }
+}
+
+module.exports = { runLabs, LABS_FEATURES };