@vibecheckai/cli 3.1.5 → 3.1.8

package/bin/vibecheck.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// bin/vibecheck.js - World-Class CLI
+// bin/vibecheck.js - World-Class CLI (Refactored)
 // ═══════════════════════════════════════════════════════════════════════════════
 // VibeCheck - Proves your app is real
 // Ship with confidence. Catch fake features before your users do.
@@ -7,38 +7,71 @@
 
 "use strict";
 
-const readline = require("readline");
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
 const { performance } = require("perf_hooks");
-const crypto = require("crypto");
+const STARTUP_TIME = performance.now();
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// PERFORMANCE: Track startup time
+// LAZY LOADING - Defer all requires until needed for fast startup
 // ═══════════════════════════════════════════════════════════════════════════════
-const STARTUP_TIME = performance.now();
+const lazyModules = {};
+
+function lazy(name, loader) {
+  return () => {
+    if (!lazyModules[name]) {
+      lazyModules[name] = loader();
+    }
+    return lazyModules[name];
+  };
+}
+
+const getFs = lazy("fs", () => require("fs"));
+const getPath = lazy("path", () => require("path"));
+const getOs = lazy("os", () => require("os"));
+const getCrypto = lazy("crypto", () => require("crypto"));
+const getHttps = lazy("https", () => require("https"));
+const getReadline = lazy("readline", () => require("readline"));
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// VERSION & METADATA
+// VERSION & METADATA (lazy loaded)
 // ═══════════════════════════════════════════════════════════════════════════════
+let _version = null;
 function getVersion() {
+  if (_version) return _version;
   try {
+    const fs = getFs();
+    const path = getPath();
     const pkgPath = path.join(__dirname, "..", "package.json");
     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    return pkg.version || "0.0.0";
+    _version = pkg.version || "0.0.0";
   } catch {
-    return "0.0.0";
+    _version = "0.0.0";
   }
+  return _version;
 }
 
-const VERSION = getVersion();
 const CLI_NAME = "vibecheck";
 const CONFIG_FILE = ".vibecheckrc";
-const CACHE_DIR = path.join(os.homedir(), ".vibecheck");
-const STATE_FILE = path.join(CACHE_DIR, "state.json");
 const UPDATE_CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
 
+// Cache/state paths (computed lazily)
+let _cacheDir = null;
+let _stateFile = null;
+function getCacheDir() {
+  if (!_cacheDir) {
+    const os = getOs();
+    const path = getPath();
+    _cacheDir = path.join(os.homedir(), ".vibecheck");
+  }
+  return _cacheDir;
+}
+function getStateFile() {
+  if (!_stateFile) {
+    const path = getPath();
+    _stateFile = path.join(getCacheDir(), "state.json");
+  }
+  return _stateFile;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // ANSI STYLES - Premium terminal styling with gradient support
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -47,7 +80,7 @@ const SUPPORTS_TRUECOLOR = SUPPORTS_COLOR && (
   process.env.COLORTERM === "truecolor" ||
   process.env.TERM_PROGRAM === "iTerm.app" ||
   process.env.TERM_PROGRAM === "Apple_Terminal" ||
-  process.env.WT_SESSION // Windows Terminal
+  process.env.WT_SESSION
 );
 
 const c = SUPPORTS_COLOR ? {
@@ -93,7 +126,12 @@ const c = SUPPORTS_COLOR ? {
   "bgRed", "bgGreen", "bgYellow", "bgBlue", "bgMagenta", "bgCyan", "bgWhite", "bgGray"
 ].map(k => [k, ""]));
 
-// Gradient text generator (cyan → magenta → yellow)
+// Add no-op rgb functions for non-color mode
+if (!SUPPORTS_COLOR) {
+  c.rgb = () => "";
+  c.bgRgb = () => "";
+}
+
 function gradient(text, colors = [[0, 255, 255], [255, 0, 255], [255, 255, 0]]) {
   if (!SUPPORTS_TRUECOLOR) return `${c.cyan}${text}${c.reset}`;
   const chars = [...text];
@@ -114,7 +152,7 @@ function gradient(text, colors = [[0, 255, 255], [255, 0, 255], [255, 255, 0]])
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// UNICODE SYMBOLS - Rich visual indicators
+// UNICODE SYMBOLS
 // ═══════════════════════════════════════════════════════════════════════════════
 const SUPPORTS_UNICODE = process.platform !== "win32" || process.env.WT_SESSION || process.env.TERM_PROGRAM;
 
@@ -150,24 +188,48 @@ const sym = SUPPORTS_UNICODE ? {
 };
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// SPINNER & PROGRESS
+// CI DETECTION
 // ═══════════════════════════════════════════════════════════════════════════════
 function isCI() {
-  return !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.RAILWAY_ENVIRONMENT ||
-    process.env.VERCEL || process.env.NETLIFY || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI ||
-    process.env.CIRCLECI || process.env.TRAVIS || process.env.BUILDKITE || process.env.RENDER ||
-    process.env.HEROKU || process.env.CODEBUILD_BUILD_ID || process.env.JENKINS_URL ||
-    process.env.TEAMCITY_VERSION || process.env.TF_BUILD || !process.stdin.isTTY);
+  return !!(
+    process.env.CI || 
+    process.env.CONTINUOUS_INTEGRATION || 
+    process.env.RAILWAY_ENVIRONMENT ||
+    process.env.VERCEL || 
+    process.env.NETLIFY || 
+    process.env.GITHUB_ACTIONS || 
+    process.env.GITLAB_CI ||
+    process.env.CIRCLECI || 
+    process.env.TRAVIS || 
+    process.env.BUILDKITE || 
+    process.env.RENDER ||
+    process.env.HEROKU || 
+    process.env.CODEBUILD_BUILD_ID || 
+    process.env.JENKINS_URL ||
+    process.env.TEAMCITY_VERSION || 
+    process.env.TF_BUILD || 
+    !process.stdin.isTTY
+  );
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// SPINNER CLASS
+// ═══════════════════════════════════════════════════════════════════════════════
 class Spinner {
   constructor(text = "") {
-    this.text = text; this.frame = 0; this.interval = null;
-    this.stream = process.stderr; this.isCI = isCI();
+    this.text = text;
+    this.frame = 0;
+    this.interval = null;
+    this.stream = process.stderr;
+    this.isCI = isCI();
   }
+
   start(text) {
     if (text) this.text = text;
-    if (this.isCI) { this.stream.write(`${c.dim}${sym.pending}${c.reset} ${this.text}\n`); return this; }
+    if (this.isCI) {
+      this.stream.write(`${c.dim}${sym.pending}${c.reset} ${this.text}\n`);
+      return this;
+    }
     this.interval = setInterval(() => {
       const spinner = sym.spinner[this.frame % sym.spinner.length];
       this.stream.write(`\r${c.cyan}${spinner}${c.reset} ${this.text}`);
@@ -175,35 +237,183 @@ class Spinner {
     }, 80);
     return this;
   }
-  update(text) { this.text = text; if (this.isCI) this.stream.write(`  ${c.dim}${sym.arrowRight}${c.reset} ${text}\n`); return this; }
-  succeed(text) { this.stop(); this.stream.write(`\r${c.green}${sym.success}${c.reset} ${text || this.text}\n`); return this; }
-  fail(text) { this.stop(); this.stream.write(`\r${c.red}${sym.error}${c.reset} ${text || this.text}\n`); return this; }
-  warn(text) { this.stop(); this.stream.write(`\r${c.yellow}${sym.warning}${c.reset} ${text || this.text}\n`); return this; }
-  info(text) { this.stop(); this.stream.write(`\r${c.blue}${sym.info}${c.reset} ${text || this.text}\n`); return this; }
-  stop() { if (this.interval) { clearInterval(this.interval); this.interval = null; this.stream.write("\r\x1b[K"); } return this; }
-}
 
-function stripAnsi(str) { return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, ""); }
+  update(text) {
+    this.text = text;
+    if (this.isCI) this.stream.write(`  ${c.dim}${sym.arrowRight}${c.reset} ${text}\n`);
+    return this;
+  }
 
-function ensureCacheDir() { if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true }); }
+  succeed(text) {
+    this.stop();
+    this.stream.write(`\r${c.green}${sym.success}${c.reset} ${text || this.text}\n`);
+    return this;
+  }
+
+  fail(text) {
+    this.stop();
+    this.stream.write(`\r${c.red}${sym.error}${c.reset} ${text || this.text}\n`);
+    return this;
+  }
+
+  warn(text) {
+    this.stop();
+    this.stream.write(`\r${c.yellow}${sym.warning}${c.reset} ${text || this.text}\n`);
+    return this;
+  }
+
+  info(text) {
+    this.stop();
+    this.stream.write(`\r${c.blue}${sym.info}${c.reset} ${text || this.text}\n`);
+    return this;
+  }
+
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+      this.stream.write("\r\x1b[K");
+    }
+    return this;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STATE MANAGEMENT (lazy file I/O)
+// ═══════════════════════════════════════════════════════════════════════════════
+function ensureCacheDir() {
+  const fs = getFs();
+  const cacheDir = getCacheDir();
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+}
 
 function loadState() {
-  try { if (fs.existsSync(STATE_FILE)) return JSON.parse(fs.readFileSync(STATE_FILE, "utf-8")); } catch {}
-  return { firstRun: Date.now(), lastRun: null, runCount: 0, lastUpdateCheck: null, latestVersion: null, commandHistory: [], favorites: [] };
+  try {
+    const fs = getFs();
+    const stateFile = getStateFile();
+    if (fs.existsSync(stateFile)) {
+      return JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+    }
+  } catch {}
+  return {
+    firstRun: Date.now(),
+    lastRun: null,
+    runCount: 0,
+    lastUpdateCheck: null,
+    latestVersion: null,
+    commandHistory: [],
+    favorites: [],
+  };
 }
 
-function saveState(state) { try { ensureCacheDir(); fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2)); } catch {} }
+function saveState(state) {
+  try {
+    const fs = getFs();
+    ensureCacheDir();
+    fs.writeFileSync(getStateFile(), JSON.stringify(state, null, 2));
+  } catch {}
+}
 
 function loadConfig() {
-  const config = { debug: false, verbose: false, quiet: false, color: true, analytics: true, updateCheck: true, timeout: 30000, maxRetries: 3 };
+  const fs = getFs();
+  const path = getPath();
+  
+  const config = {
+    debug: false,
+    verbose: false,
+    quiet: false,
+    color: true,
+    analytics: true,
+    updateCheck: true,
+    timeout: 30000,
+    maxRetries: 3,
+    noBanner: false,
+  };
+
   const projectConfigPath = path.join(process.cwd(), CONFIG_FILE);
-  if (fs.existsSync(projectConfigPath)) { try { Object.assign(config, JSON.parse(fs.readFileSync(projectConfigPath, "utf-8"))); } catch {} }
+  if (fs.existsSync(projectConfigPath)) {
+    try {
+      Object.assign(config, JSON.parse(fs.readFileSync(projectConfigPath, "utf-8")));
+    } catch {}
+  }
+
+  // Environment overrides
   if (process.env.VIBECHECK_DEBUG === "true") config.debug = true;
   if (process.env.VIBECHECK_VERBOSE === "true") config.verbose = true;
+  if (process.env.VIBECHECK_QUIET === "true") config.quiet = true;
+  if (process.env.VIBECHECK_NO_BANNER === "true") config.noBanner = true;
   if (process.env.NO_COLOR || process.env.VIBECHECK_NO_COLOR) config.color = false;
+
   return config;
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// UPDATE CHECKER - Actually implemented
+// ═══════════════════════════════════════════════════════════════════════════════
+async function checkForUpdates(state, config) {
+  if (!config.updateCheck) return null;
+  if (isCI()) return null;
+  
+  const now = Date.now();
+  if (state.lastUpdateCheck && (now - state.lastUpdateCheck) < UPDATE_CHECK_INTERVAL) {
+    // Use cached version if recent
+    if (state.latestVersion && state.latestVersion !== getVersion()) {
+      return state.latestVersion;
+    }
+    return null;
+  }
+
+  // Async check - don't block CLI startup
+  return new Promise((resolve) => {
+    const https = getHttps();
+    const timeout = setTimeout(() => resolve(null), 3000); // 3s timeout
+
+    const req = https.get(
+      "https://registry.npmjs.org/@vibecheckai/cli/latest",
+      { headers: { "Accept": "application/json", "User-Agent": `vibecheck-cli/${getVersion()}` } },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => { data += chunk; });
+        res.on("end", () => {
+          clearTimeout(timeout);
+          try {
+            const pkg = JSON.parse(data);
+            const latest = pkg.version;
+            state.lastUpdateCheck = now;
+            state.latestVersion = latest;
+            saveState(state);
+            
+            if (latest && latest !== getVersion()) {
+              resolve(latest);
+            } else {
+              resolve(null);
+            }
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+
+    req.on("error", () => {
+      clearTimeout(timeout);
+      resolve(null);
+    });
+
+    req.end();
+  });
+}
+
+function printUpdateNotice(latestVersion) {
+  const currentVersion = getVersion();
+  console.log();
+  console.log(`${c.yellow}${sym.sparkles}${c.reset} Update available: ${c.dim}${currentVersion}${c.reset} ${sym.arrow} ${c.green}${latestVersion}${c.reset}`);
+  console.log(`   Run ${c.cyan}npm update -g @vibecheckai/cli${c.reset} to update`);
+  console.log();
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // FUZZY MATCHING
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -213,8 +423,15 @@ function levenshtein(a, b) {
   for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
   for (let i = 1; i <= b.length; i++) {
     for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) matrix[i][j] = matrix[i - 1][j - 1];
-      else matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
     }
   }
   return matrix[b.length][a.length];
@@ -224,63 +441,89 @@ function findSimilarCommands(input, commands, maxDistance = 3) {
   const matches = [];
   for (const cmd of commands) {
     const distance = levenshtein(input.toLowerCase(), cmd.toLowerCase());
-    if (distance <= maxDistance) matches.push({ cmd, distance });
-    if (cmd.toLowerCase().startsWith(input.toLowerCase()) && input.length >= 2) matches.push({ cmd, distance: 0.5 });
+    if (distance <= maxDistance) {
+      matches.push({ cmd, distance });
+    }
+    if (cmd.toLowerCase().startsWith(input.toLowerCase()) && input.length >= 2) {
+      matches.push({ cmd, distance: 0.5 });
+    }
   }
-  return matches.sort((a, b) => a.distance - b.distance).map(m => m.cmd).slice(0, 3);
+  return [...new Set(matches.sort((a, b) => a.distance - b.distance).map(m => m.cmd))].slice(0, 3);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// ENTITLEMENTS (v2 - Single Source of Truth)
+// COMMAND REGISTRY (lazy loaded)
 // ═══════════════════════════════════════════════════════════════════════════════
-const entitlements = require("./runners/lib/entitlements-v2");
+let _registry = null;
+function getRegistry() {
+  if (!_registry) {
+    _registry = require("./registry");
+  }
+  return _registry;
+}
+
+function getRunner(cmd) {
+  const registry = getRegistry();
+  return registry.getRunner(cmd, { red: c.red, reset: c.reset, errorSymbol: sym.error });
+}
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// UPSELL COPY MODULE - Central copy generator for all upgrade messaging
+// ENTITLEMENTS & UPSELL (lazy loaded)
 // ═══════════════════════════════════════════════════════════════════════════════
-const upsell = require("./runners/lib/upsell");
+let _entitlements = null;
+let _upsell = null;
+
+function getEntitlements() {
+  if (!_entitlements) {
+    _entitlements = require("./runners/lib/entitlements-v2");
+  }
+  return _entitlements;
+}
+
+function getUpsell() {
+  if (!_upsell) {
+    _upsell = require("./runners/lib/upsell");
+  }
+  return _upsell;
+}
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// CLI OUTPUT UTILITIES
+// CLI OUTPUT UTILITIES (lazy loaded)
 // ═══════════════════════════════════════════════════════════════════════════════
-const { 
-  generateRunId, 
-  withStandardOutput, 
-  parseStandardFlags,
-  exitCodeToVerdict 
-} = require("./runners/lib/cli-output");
+let _cliOutput = null;
+function getCliOutput() {
+  if (!_cliOutput) {
+    _cliOutput = require("./runners/lib/cli-output");
+  }
+  return _cliOutput;
+}
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// COMMAND REGISTRY - Imported from bin/registry.js (single source of truth)
+// AUTH MODULE (lazy loaded)
 // ═══════════════════════════════════════════════════════════════════════════════
-const { COMMANDS, ALIAS_MAP, ALL_COMMANDS, getRunner: _getRunner } = require("./registry");
-
-// Wrap getRunner to pass styling
-function getRunner(cmd) {
-  return _getRunner(cmd, { red: c.red, reset: c.reset, errorSymbol: sym.error });
+let _authModule = null;
+function getAuthModule() {
+  if (!_authModule) {
+    _authModule = require("./runners/lib/auth");
+  }
+  return _authModule;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// AUTH & ACCESS CONTROL (uses entitlements-v2 - NO BYPASS ALLOWED)
+// ACCESS CONTROL
 // ═══════════════════════════════════════════════════════════════════════════════
-let authModule = null;
-function getAuthModule() { if (!authModule) authModule = require("./runners/lib/auth"); return authModule; }
-
-/**
- * Check command access using entitlements-v2 module.
- * NO OWNER MODE. NO ENV VAR BYPASS. NO OFFLINE ESCALATION.
- */
 async function checkCommandAccess(cmd, args, authInfo) {
-  const def = COMMANDS[cmd];
+  const registry = getRegistry();
+  const def = registry.COMMANDS[cmd];
   if (!def) return { allowed: true };
-  
-  // Use centralized entitlements enforcement
+
+  const entitlements = getEntitlements();
   const result = await entitlements.enforce(cmd, {
     apiKey: authInfo?.key,
     projectPath: process.cwd(),
-    silent: true, // We'll handle messaging ourselves
+    silent: true,
   });
-  
+
   if (result.allowed) {
     return {
       allowed: true,
@@ -290,29 +533,272 @@ async function checkCommandAccess(cmd, args, authInfo) {
       caps: result.caps,
     };
   }
-  
-  // Not allowed - return with proper exit code
+
+  const upsell = getUpsell();
   return {
     allowed: false,
     tier: result.tier,
     requiredTier: result.requiredTier,
     exitCode: result.exitCode,
-    reason: formatAccessDenied(cmd, result.requiredTier, result.tier),
+    reason: upsell.formatDenied(cmd, {
+      currentTier: result.tier,
+      requiredTier: result.requiredTier,
+    }),
   };
 }
 
-function formatAccessDenied(cmd, requiredTier, currentTier) {
-  // Use centralized upsell copy module
-  return upsell.formatDenied(cmd, {
-    currentTier,
-    requiredTier,
-  });
+// ═══════════════════════════════════════════════════════════════════════════════
+// SHELL COMPLETIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+function generateBashCompletion() {
+  const registry = getRegistry();
+  const commands = Object.keys(registry.COMMANDS);
+  const aliases = Object.keys(registry.ALIAS_MAP);
+  const allCmds = [...commands, ...aliases].join(" ");
+
+  return `# vibecheck bash completion
+# Add to ~/.bashrc or ~/.bash_profile:
+#   eval "$(vibecheck completion bash)"
+
+_vibecheck_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  
+  # Main commands
+  local commands="${allCmds}"
+  
+  # Global flags
+  local global_flags="--help --version --json --ci --quiet --verbose --debug --path --output --no-banner"
+  
+  case "\${prev}" in
+    vibecheck|vc)
+      COMPREPLY=($(compgen -W "\${commands} \${global_flags}" -- "\${cur}"))
+      return 0
+      ;;
+    --path|--output|-p|-o)
+      COMPREPLY=($(compgen -d -- "\${cur}"))
+      return 0
+      ;;
+    init)
+      COMPREPLY=($(compgen -W "--local --connect --quick --enterprise --ci --soc2 --hipaa --gdpr --team --mcp" -- "\${cur}"))
+      return 0
+      ;;
+    scan)
+      COMPREPLY=($(compgen -W "--fix --autofix --json --strict --path" -- "\${cur}"))
+      return 0
+      ;;
+    report)
+      COMPREPLY=($(compgen -W "--format --output html md json sarif csv" -- "\${cur}"))
+      return 0
+      ;;
+    completion)
+      COMPREPLY=($(compgen -W "bash zsh fish" -- "\${cur}"))
+      return 0
+      ;;
+  esac
+  
+  if [[ "\${cur}" == -* ]]; then
+    COMPREPLY=($(compgen -W "\${global_flags}" -- "\${cur}"))
+  fi
+}
+
+complete -F _vibecheck_completions vibecheck
+complete -F _vibecheck_completions vc
+`;
+}
+
+function generateZshCompletion() {
+  const registry = getRegistry();
+  const commands = Object.entries(registry.COMMANDS);
+  
+  let cmdList = commands.map(([cmd, def]) => {
+    const desc = (def.description || "").replace(/'/g, "\\'").replace(/"/g, '\\"');
+    return `    '${cmd}:${desc}'`;
+  }).join(" \\\n");
+
+  return `#compdef vibecheck vc
+# vibecheck zsh completion
+# Add to ~/.zshrc:
+#   eval "$(vibecheck completion zsh)"
+
+_vibecheck() {
+  local -a commands
+  commands=(
+${cmdList}
+  )
+
+  local -a global_opts
+  global_opts=(
+    '--help[Show help]'
+    '--version[Show version]'
+    '--json[Output as JSON]'
+    '--ci[CI mode]'
+    '--quiet[Suppress output]'
+    '--verbose[Verbose output]'
+    '--debug[Debug mode]'
+    '--path[Project path]:directory:_directories'
+    '--output[Output directory]:directory:_directories'
+    '--no-banner[Hide banner]'
+  )
+
+  _arguments -C \\
+    "1: :->command" \\
+    "*::arg:->args"
+
+  case "\$state" in
+    command)
+      _describe -t commands 'vibecheck commands' commands
+      _describe -t options 'options' global_opts
+      ;;
+    args)
+      case "\$words[1]" in
+        init)
+          _arguments \\
+            '--local[Local setup only]' \\
+            '--connect[GitHub integration]' \\
+            '--quick[Quick setup]' \\
+            '--enterprise[Enterprise mode]' \\
+            '--ci[Setup CI/CD]' \\
+            '--soc2[SOC2 compliance]' \\
+            '--hipaa[HIPAA compliance]'
+          ;;
+        scan)
+          _arguments \\
+            '--fix[Apply fixes]' \\
+            '--autofix[Auto-fix issues]' \\
+            '--json[JSON output]' \\
+            '--strict[Strict mode]'
+          ;;
+        report)
+          _arguments \\
+            '--format[Output format]:format:(html md json sarif csv)' \\
+            '--output[Output file]:file:_files'
+          ;;
+        completion)
+          _arguments '1:shell:(bash zsh fish)'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+compdef _vibecheck vibecheck
+compdef _vibecheck vc
+`;
+}
+
+function generateFishCompletion() {
+  const registry = getRegistry();
+  const commands = Object.entries(registry.COMMANDS);
+
+  let completions = `# vibecheck fish completion
+# Add to ~/.config/fish/completions/vibecheck.fish
+# Or run: vibecheck completion fish > ~/.config/fish/completions/vibecheck.fish
+
+# Disable file completion by default
+complete -c vibecheck -f
+complete -c vc -f
+
+# Global flags
+complete -c vibecheck -l help -d 'Show help'
+complete -c vibecheck -l version -d 'Show version'
+complete -c vibecheck -l json -d 'Output as JSON'
+complete -c vibecheck -l ci -d 'CI mode'
+complete -c vibecheck -l quiet -d 'Suppress output'
+complete -c vibecheck -l verbose -d 'Verbose output'
+complete -c vibecheck -l debug -d 'Debug mode'
+complete -c vibecheck -l path -d 'Project path' -r -a '(__fish_complete_directories)'
+complete -c vibecheck -l output -d 'Output directory' -r -a '(__fish_complete_directories)'
+complete -c vibecheck -l no-banner -d 'Hide banner'
+
+# Commands
+`;
+
+  for (const [cmd, def] of commands) {
+    const desc = (def.description || "").replace(/'/g, "\\'");
+    completions += `complete -c vibecheck -n '__fish_use_subcommand' -a '${cmd}' -d '${desc}'\n`;
+    completions += `complete -c vc -n '__fish_use_subcommand' -a '${cmd}' -d '${desc}'\n`;
+  }
+
+  // Add aliases
+  for (const [alias, target] of Object.entries(registry.ALIAS_MAP)) {
+    const def = registry.COMMANDS[target];
+    if (def) {
+      const desc = `Alias for ${target}`;
+      completions += `complete -c vibecheck -n '__fish_use_subcommand' -a '${alias}' -d '${desc}'\n`;
+      completions += `complete -c vc -n '__fish_use_subcommand' -a '${alias}' -d '${desc}'\n`;
+    }
+  }
+
+  completions += `
+# init subcommand options
+complete -c vibecheck -n '__fish_seen_subcommand_from init' -l local -d 'Local setup only'
+complete -c vibecheck -n '__fish_seen_subcommand_from init' -l connect -d 'GitHub integration'
+complete -c vibecheck -n '__fish_seen_subcommand_from init' -l quick -d 'Quick setup'
+complete -c vibecheck -n '__fish_seen_subcommand_from init' -l enterprise -d 'Enterprise mode'
+
+# scan subcommand options
+complete -c vibecheck -n '__fish_seen_subcommand_from scan' -l fix -d 'Apply fixes'
+complete -c vibecheck -n '__fish_seen_subcommand_from scan' -l autofix -d 'Auto-fix issues'
+complete -c vibecheck -n '__fish_seen_subcommand_from scan' -l strict -d 'Strict mode'
+
+# report subcommand options
+complete -c vibecheck -n '__fish_seen_subcommand_from report' -l format -d 'Output format' -r -a 'html md json sarif csv'
+
+# completion subcommand
+complete -c vibecheck -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish' -d 'Shell type'
+`;
+
+  return completions;
+}
+
+function runCompletion(args) {
+  const shell = args[0];
+  
+  if (!shell || shell === "--help" || shell === "-h") {
+    console.log(`
+${c.bold}Usage:${c.reset} vibecheck completion <shell>
+
+${c.bold}Shells:${c.reset}
+  bash    Generate bash completions
+  zsh     Generate zsh completions  
+  fish    Generate fish completions
+
+${c.bold}Installation:${c.reset}
+  ${c.dim}# Bash (add to ~/.bashrc)${c.reset}
+  eval "$(vibecheck completion bash)"
+  
+  ${c.dim}# Zsh (add to ~/.zshrc)${c.reset}
+  eval "$(vibecheck completion zsh)"
+  
+  ${c.dim}# Fish${c.reset}
+  vibecheck completion fish > ~/.config/fish/completions/vibecheck.fish
+`);
+    return 0;
+  }
+
+  switch (shell.toLowerCase()) {
+    case "bash":
+      console.log(generateBashCompletion());
+      return 0;
+    case "zsh":
+      console.log(generateZshCompletion());
+      return 0;
+    case "fish":
+      console.log(generateFishCompletion());
+      return 0;
+    default:
+      console.error(`${c.red}${sym.error}${c.reset} Unknown shell: ${shell}`);
+      console.error(`Supported shells: bash, zsh, fish`);
+      return 1;
+  }
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // HELP SYSTEM
 // ═══════════════════════════════════════════════════════════════════════════════
 function printBanner() {
+  const VERSION = getVersion();
   console.log(`
 ${c.dim}${sym.boxTopLeft}${sym.boxHorizontal.repeat(60)}${sym.boxTopRight}${c.reset}
 ${c.dim}${sym.boxVertical}${c.reset}  ${gradient("VIBECHECK", [[0, 255, 255], [138, 43, 226], [255, 20, 147]])} ${c.dim}v${VERSION}${c.reset}${" ".repeat(60 - 13 - VERSION.length - 4)}${c.dim}${sym.boxVertical}${c.reset}
@@ -321,9 +807,19 @@ ${c.dim}${sym.boxBottomLeft}${sym.boxHorizontal.repeat(60)}${sym.boxBottomRight}
 `);
 }
 
-function printHelp() {
-  printBanner();
-  
+function printHelp(showBanner = true) {
+  if (showBanner) printBanner();
+
+  const registry = getRegistry();
+  const { COMMANDS, ALIAS_MAP } = registry;
+
+  // Build reverse alias map for display
+  const reverseAliases = {};
+  for (const [alias, target] of Object.entries(ALIAS_MAP)) {
+    if (!reverseAliases[target]) reverseAliases[target] = [];
+    reverseAliases[target].push(alias);
+  }
+
   // Categories ordered as specified
   const categoryOrder = ["setup", "analysis", "proof", "quality", "truth", "output", "ci", "automation", "account", "extras"];
   const categories = {
@@ -338,7 +834,7 @@ function printHelp() {
     account: { name: "ACCOUNT", color: c.dim, icon: sym.key },
     extras: { name: "EXTRAS", color: c.dim, icon: sym.starEmpty },
   };
-  
+
   // Group commands
   const grouped = {};
   for (const [cmd, def] of Object.entries(COMMANDS)) {
@@ -346,33 +842,35 @@ function printHelp() {
     if (!grouped[cat]) grouped[cat] = [];
     grouped[cat].push({ cmd, ...def });
   }
-  
+
   // Print in order
   for (const catKey of categoryOrder) {
     const commands = grouped[catKey];
     if (!commands || commands.length === 0) continue;
-    
+
     const cat = categories[catKey];
     console.log(`\n${cat.color}${cat.icon} ${cat.name}${c.reset}\n`);
-    
-    for (const { cmd, description, tier, aliases, caps } of commands) {
-      // Tier badge with color
+
+    for (const { cmd, description, tier, caps } of commands) {
+      // Tier badge
       let tierBadge = "";
-      if (tier === "free") {
-        tierBadge = `${c.green}[FREE]${c.reset} `;
-      } else if (tier === "starter") {
-        tierBadge = `${c.cyan}[STARTER]${c.reset} `;
-      } else if (tier === "pro") {
-        tierBadge = `${c.magenta}[PRO]${c.reset} `;
-      }
-      
-      // Caps info (e.g., "preview mode on FREE")
+      if (tier === "free") tierBadge = `${c.green}[FREE]${c.reset} `;
+      else if (tier === "starter") tierBadge = `${c.cyan}[STARTER]${c.reset} `;
+      else if (tier === "pro") tierBadge = `${c.magenta}[PRO]${c.reset} `;
+
+      // Aliases (from reverseAliases map built earlier)
+      const aliasList = reverseAliases[cmd] || [];
+      const aliasStr = aliasList.length > 0 
+        ? `${c.dim}(${aliasList.slice(0, 3).join(", ")})${c.reset} ` 
+        : "";
+
+      // Caps info
       const capsStr = caps ? `${c.dim}(${caps})${c.reset}` : "";
-      
-      console.log(`  ${c.cyan}${cmd.padEnd(12)}${c.reset} ${tierBadge}${description} ${capsStr}`);
+
+      console.log(`  ${c.cyan}${cmd.padEnd(12)}${c.reset} ${aliasStr}${tierBadge}${description} ${capsStr}`);
     }
   }
-  
+
   console.log(`
 ${c.dim}${sym.boxHorizontal.repeat(64)}${c.reset}
 
@@ -390,6 +888,12 @@ ${c.green}QUICK START - The 5-Step Journey${c.reset}
   4. ${c.bold}Prove${c.reset}         ${c.cyan}vibecheck prove${c.reset} ${c.magenta}[PRO]${c.reset}
   5. ${c.bold}Ship${c.reset}          ${c.cyan}vibecheck ship${c.reset}
 
+${c.bold}SHELL COMPLETIONS${c.reset}
+
+  ${c.cyan}vibecheck completion bash${c.reset}   ${c.dim}# Add to ~/.bashrc${c.reset}
+  ${c.cyan}vibecheck completion zsh${c.reset}    ${c.dim}# Add to ~/.zshrc${c.reset}
+  ${c.cyan}vibecheck completion fish${c.reset}   ${c.dim}# Save to completions dir${c.reset}
+
 ${c.dim}Run 'vibecheck <command> --help' for command-specific help.${c.reset}
 ${c.dim}Pricing: https://vibecheckai.dev/pricing${c.reset}
 `);
@@ -406,58 +910,165 @@ function getArgValue(args, flags) {
   return undefined;
 }
 
+function hasFlag(args, flags) {
+  for (const flag of flags) {
+    if (args.includes(flag)) return true;
+  }
+  return false;
+}
+
 function formatError(error, config) {
   const lines = [`${c.red}${sym.error} Error:${c.reset} ${error.message}`];
-  if (config.debug && error.stack) { lines.push("", `${c.dim}Stack trace:${c.reset}`, c.dim + error.stack.split("\n").slice(1).join("\n") + c.reset); }
+  if (config.debug && error.stack) {
+    lines.push("", `${c.dim}Stack trace:${c.reset}`, c.dim + error.stack.split("\n").slice(1).join("\n") + c.reset);
+  }
   return lines.join("\n");
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// FLAG PARSING
+// ═══════════════════════════════════════════════════════════════════════════════
+function parseGlobalFlags(rawArgs) {
+  const flags = {
+    help: false,
+    version: false,
+    json: false,
+    ci: false,
+    quiet: false,
+    verbose: false,
+    debug: false,
+    strict: false,
+    noBanner: false,
+    path: process.cwd(),
+    output: null,
+  };
+
+  const cleanArgs = [];
+  let i = 0;
+
+  while (i < rawArgs.length) {
+    const arg = rawArgs[i];
+
+    switch (arg) {
+      case "--help":
+      case "-h":
+        flags.help = true;
+        break;
+      case "--version":
+      case "-v":
+        flags.version = true;
+        break;
+      case "--json":
+        flags.json = true;
+        break;
+      case "--ci":
+        flags.ci = true;
+        break;
+      case "--quiet":
+      case "-q":
+        flags.quiet = true;
+        break;
+      case "--verbose":
+        flags.verbose = true;
+        break;
+      case "--debug":
+        flags.debug = true;
+        break;
+      case "--strict":
+        flags.strict = true;
+        break;
+      case "--no-banner":
+        flags.noBanner = true;
+        break;
+      case "--path":
+      case "-p":
+        flags.path = rawArgs[++i] || process.cwd();
+        break;
+      case "--output":
+      case "-o":
+        flags.output = rawArgs[++i] || null;
+        break;
+      default:
+        if (arg.startsWith("--path=")) {
+          flags.path = arg.split("=")[1];
+        } else if (arg.startsWith("--output=")) {
+          flags.output = arg.split("=")[1];
+        } else {
+          cleanArgs.push(arg);
+        }
+    }
+    i++;
+  }
+
+  return { flags, cleanArgs };
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // MAIN ENTRY POINT
 // ═══════════════════════════════════════════════════════════════════════════════
 async function main() {
   const startTime = performance.now();
   const rawArgs = process.argv.slice(2);
+
+  // Parse global flags
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(rawArgs);
+
+  // Handle version (fast path - no config loading)
+  if (globalFlags.version) {
+    console.log(`vibecheck v${getVersion()}`);
+    process.exit(0);
+  }
+
+  // Load config and state
   const config = loadConfig();
   const state = loadState();
-  
-  // Parse standard flags
-  const { flags: globalFlags, parsed: cleanArgs } = parseStandardFlags(rawArgs);
-  
-  // Update config based on flags
+
+  // Apply flag overrides to config
   if (globalFlags.debug) config.debug = true;
   if (globalFlags.verbose) config.verbose = true;
   if (globalFlags.quiet) config.quiet = true;
-  if (globalFlags.ci) config.quiet = true; // CI mode implies quiet
-  
-  // Handle version
-  if (globalFlags.version) {
-    console.log(`vibecheck v${VERSION}`);
-    process.exit(0);
+  if (globalFlags.noBanner) config.noBanner = true;
+  if (globalFlags.ci) {
+    config.quiet = true;
+    config.noBanner = true;
   }
-  
+
   // Handle no command
-  if (!cleanArgs[0]) { printHelp(); process.exit(0); }
-  
-  // Handle command-specific help (vibecheck <cmd> --help)
-  if (globalFlags.help && cleanArgs[0] && COMMANDS[cleanArgs[0]]) {
-    // Pass --help to the command runner
-  } else if (globalFlags.help && !cleanArgs[0]) {
-    printHelp(); process.exit(0);
+  if (!cleanArgs[0]) {
+    printHelp(!config.noBanner);
+    process.exit(0);
   }
-  
+
+  // Handle global help
+  if (globalFlags.help && !cleanArgs[0]) {
+    printHelp(!config.noBanner);
+    process.exit(0);
+  }
+
+  // Handle completion command (special - doesn't need registry loaded normally)
+  if (cleanArgs[0] === "completion") {
+    process.exit(runCompletion(cleanArgs.slice(1)));
+  }
+
+  // Load registry for command resolution
+  const registry = getRegistry();
+  const { COMMANDS, ALIAS_MAP, ALL_COMMANDS } = registry;
+
   let cmd = cleanArgs[0];
-  // Only use alias if exact command doesn't exist (prefer exact matches)
-  if (!COMMANDS[cmd] && ALIAS_MAP[cmd]) { cmd = ALIAS_MAP[cmd]; }
+  // Prefer exact match, then alias
+  if (!COMMANDS[cmd] && ALIAS_MAP[cmd]) {
+    cmd = ALIAS_MAP[cmd];
+  }
   let cmdArgs = cleanArgs.slice(1);
-  
-  // Add --help back to cmdArgs if it was passed with a command
+
+  // Pass --help to runner if specified with command
   if (globalFlags.help) cmdArgs = ["--help", ...cmdArgs];
-  
+
   // Pass standard flags to runners
-  cmdArgs = [...cmdArgs];
   if (globalFlags.json) cmdArgs.push("--json");
   if (globalFlags.ci) cmdArgs.push("--ci");
+  if (globalFlags.noBanner) cmdArgs.push("--no-banner");
+  if (globalFlags.quiet) cmdArgs.push("--quiet");
   if (globalFlags.path && globalFlags.path !== process.cwd()) {
     cmdArgs.push("--path", globalFlags.path);
   }
@@ -466,114 +1077,107 @@ async function main() {
   }
   if (globalFlags.verbose) cmdArgs.push("--verbose");
   if (globalFlags.strict) cmdArgs.push("--strict");
-  
+
+  // Unknown command
   if (!COMMANDS[cmd]) {
     const suggestions = findSimilarCommands(cmd, ALL_COMMANDS);
     console.log(`\n${c.red}${sym.error}${c.reset} Unknown command: ${c.yellow}${cmd}${c.reset}`);
-    
-    // Check for specific common misses
-    if (cmd === "replay" || cmd === "record") {
-      console.log(`\n${c.dim}replay is a PRO feature for session recording.${c.reset}`);
-      console.log(`${c.dim}Free alternative:${c.reset} ${c.cyan}vibecheck reality${c.reset} ${c.dim}(one-time runtime proof)${c.reset}`);
-    } else if (suggestions.length > 0) {
+
+    if (suggestions.length > 0) {
       console.log(`\n${c.dim}Did you mean:${c.reset}`);
-      suggestions.forEach(s => { const actual = ALIAS_MAP[s] || s; const def = COMMANDS[actual]; console.log(`  ${c.cyan}vibecheck ${s}${c.reset}  ${c.dim}${def?.description || ""}${c.reset}`); });
+      suggestions.forEach((s) => {
+        const actual = ALIAS_MAP[s] || s;
+        const def = COMMANDS[actual];
+        console.log(`  ${c.cyan}vibecheck ${s}${c.reset}  ${c.dim}${def?.description || ""}${c.reset}`);
+      });
     }
     console.log(`\n${c.dim}Run 'vibecheck --help' for available commands.${c.reset}\n`);
-    process.exit(4); // INVALID_INPUT
+    process.exit(4);
   }
-  
-  // Generate runId for tracking
-  const runId = generateRunId();
+
+  // Generate runId
+  const cliOutput = getCliOutput();
+  const runId = cliOutput.generateRunId();
   const runStart = new Date().toISOString();
-  
+
   const cmdDef = COMMANDS[cmd];
   let authInfo = { key: null };
-  
+
+  // Auth check (unless skipAuth)
   if (!cmdDef.skipAuth) {
     const auth = getAuthModule();
     const { key } = auth.getApiKey();
     authInfo.key = key;
-    
-    // Use entitlements-v2 for access control (NO BYPASS)
+
     const access = await checkCommandAccess(cmd, cmdArgs, authInfo);
-    
+
     if (!access.allowed) {
       console.log(access.reason);
-      // Use proper exit code: 3 = feature not allowed
       process.exit(access.exitCode || 3);
     }
-    
-    // Show downgrade notice if applicable (single-line at start)
+
+    // Downgrade notice
     if (access.downgrade && !config.quiet) {
+      const upsell = getUpsell();
       console.log(upsell.formatDowngrade(cmd, {
         currentTier: access.tier,
         effectiveMode: access.downgrade,
         caps: access.caps,
       }));
     }
-    
-    // Show tier badge
-    if (!config.quiet) {
-      if (access.tier === "pro") console.log(`${c.magenta}${sym.arrowRight} PRO${c.reset} ${c.dim}feature${c.reset}`);
-      else if (access.tier === "complete") console.log(`${c.yellow}${sym.arrowRight} COMPLETE${c.reset} ${c.dim}feature${c.reset}`);
+
+    // Tier badge
+    if (!config.quiet && !config.noBanner) {
+      if (access.tier === "pro") {
+        console.log(`${c.magenta}${sym.arrowRight} PRO${c.reset} ${c.dim}feature${c.reset}`);
+      } else if (access.tier === "complete") {
+        console.log(`${c.yellow}${sym.arrowRight} COMPLETE${c.reset} ${c.dim}feature${c.reset}`);
+      }
     }
-    
-    // Attach access info for runners to use
+
     authInfo.access = access;
   }
-  
-  state.runCount++; state.lastRun = Date.now();
+
+  // Update state
+  state.runCount++;
+  state.lastRun = Date.now();
   state.commandHistory = [...(state.commandHistory || []).slice(-99), { cmd, timestamp: Date.now() }];
   saveState(state);
-  
+
+  // Check for updates (async, non-blocking for startup)
+  let updatePromise = null;
+  if (!config.quiet && !config.noBanner && !isCI()) {
+    updatePromise = checkForUpdates(state, config);
+  }
+
   let exitCode = 0;
+
   try {
     const runner = getRunner(cmd);
-    if (!runner) { console.error(`${c.red}${sym.error}${c.reset} Failed to load runner for: ${cmd}`); process.exit(1); }
-    
-    const context = { 
-      repoRoot: process.cwd(), 
-      config, 
-      state, 
-      authInfo, 
-      version: VERSION, 
+    if (!runner) {
+      console.error(`${c.red}${sym.error}${c.reset} Failed to load runner for: ${cmd}`);
+      process.exit(1);
+    }
+
+    const context = {
+      repoRoot: globalFlags.path,
+      config,
+      state,
+      authInfo,
+      version: getVersion(),
       isCI: isCI(),
       runId,
-      runStart
+      runStart,
     };
-    
-    // Pass context to runners that support it
-    switch (cmd) {
-      case "prove": exitCode = await runner(cmdArgs, context); break;
-      case "reality": exitCode = await runner(cmdArgs, context); break;
-      case "watch": exitCode = await runner(cmdArgs, context); break;
-      case "ship": exitCode = await runner(cmdArgs, context); break;
-      case "ctx": case "truthpack":
-        if (cmdArgs[0] === "sync") { const { runCtxSync } = require("./runners/runCtxSync"); exitCode = await runCtxSync({ ...context, fastifyEntry: getArgValue(cmdArgs, ["--fastify-entry"]) }); }
-        else if (cmdArgs[0] === "guard") { const { runCtxGuard } = require("./runners/runCtxGuard"); exitCode = await runCtxGuard.main(cmdArgs.slice(1)); }
-        else if (cmdArgs[0] === "diff") { const { main: ctxDiffMain } = require("./runners/runCtxDiff"); exitCode = await ctxDiffMain(cmdArgs.slice(1)); }
-        else if (cmdArgs[0] === "search") { const { runContext } = require("./runners/runContext"); exitCode = await runContext(["--search", ...cmdArgs.slice(1)]); }
-        else { exitCode = await runner(cmdArgs, context); }
-        break;
-      case "runtime":
-        exitCode = await runner(cmdArgs, context);
-        break;
-      case "export":
-        exitCode = await runner(cmdArgs, context);
-        break;
-      case "security":
-        exitCode = await runner(cmdArgs, context);
-        break;
-      case "install": exitCode = await runner(cmdArgs, context); break;
-      case "status": exitCode = await runner({ ...context, json: cmdArgs.includes("--json") }); break;
-      case "pr": exitCode = await runner(cmdArgs, context); break;
-      case "share": exitCode = await runner(cmdArgs, context); break;
-      default: exitCode = await runner(cmdArgs);
-    }
-  } catch (error) { console.error(formatError(error, config)); exitCode = 1; }
-  
-  // Create manifest and receipt for paid commands
+
+    // Execute command - all commands use consistent runner signature
+    exitCode = await runner(cmdArgs, context);
+  } catch (error) {
+    console.error(formatError(error, config));
+    exitCode = 1;
+  }
+
+  // Create receipt for paid commands
   if (cmdDef.tier !== "free" && runId) {
     try {
       const { createManifestAndReceipt } = require("./runners/lib/receipts");
@@ -585,24 +1189,59 @@ async function main() {
         exitCode,
         startTime: runStart,
         endTime: new Date().toISOString(),
-        projectPath: process.cwd(),
+        projectPath: globalFlags.path,
       });
     } catch (e) {
-      // Don't fail the command if receipt creation fails
       if (config.debug) console.error(`Failed to create receipt: ${e.message}`);
     }
   }
-  
-  if (config.debug) console.log(`\n${c.dim}${sym.clock} Total: ${(performance.now() - startTime).toFixed(0)}ms${c.reset}`);
+
+  // Show update notice after command (if available)
+  if (updatePromise) {
+    const latestVersion = await updatePromise;
+    if (latestVersion) {
+      printUpdateNotice(latestVersion);
+    }
+  }
+
+  // Debug timing
+  if (config.debug) {
+    console.log(`\n${c.dim}${sym.clock} Total: ${(performance.now() - startTime).toFixed(0)}ms${c.reset}`);
+  }
+
   process.exit(exitCode);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // GRACEFUL SHUTDOWN
 // ═══════════════════════════════════════════════════════════════════════════════
-process.on("SIGINT", () => { console.log(`\n${c.yellow}${sym.warning}${c.reset} Interrupted`); process.exit(130); });
-process.on("SIGTERM", () => { console.log(`\n${c.yellow}${sym.warning}${c.reset} Terminated`); process.exit(143); });
-process.on("uncaughtException", (error) => { console.error(`\n${c.red}${sym.error} Uncaught Exception:${c.reset} ${error.message}`); if (process.env.VIBECHECK_DEBUG === "true") console.error(c.dim + error.stack + c.reset); process.exit(1); });
-process.on("unhandledRejection", (reason) => { console.error(`\n${c.red}${sym.error} Unhandled Rejection:${c.reset} ${reason}`); process.exit(1); });
+process.on("SIGINT", () => {
+  console.log(`\n${c.yellow}${sym.warning}${c.reset} Interrupted`);
+  process.exit(130);
+});
+
+process.on("SIGTERM", () => {
+  console.log(`\n${c.yellow}${sym.warning}${c.reset} Terminated`);
+  process.exit(143);
+});
+
+process.on("uncaughtException", (error) => {
+  console.error(`\n${c.red}${sym.error} Uncaught Exception:${c.reset} ${error.message}`);
+  if (process.env.VIBECHECK_DEBUG === "true") {
+    console.error(c.dim + error.stack + c.reset);
+  }
+  process.exit(1);
+});
+
+process.on("unhandledRejection", (reason) => {
+  console.error(`\n${c.red}${sym.error} Unhandled Rejection:${c.reset} ${reason}`);
+  process.exit(1);
+});
 
-main().catch((error) => { console.error(`\n${c.red}${sym.error} Fatal:${c.reset} ${error.message}`); process.exit(1); });
+// ═══════════════════════════════════════════════════════════════════════════════
+// RUN
+// ═══════════════════════════════════════════════════════════════════════════════
+main().catch((error) => {
+  console.error(`\n${c.red}${sym.error} Fatal:${c.reset} ${error.message}`);
+  process.exit(1);
+});