vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/runInit.js

@@ -0,0 +1,1927 @@
+/**
+ * vibecheck init - Enterprise Project Setup
+ *
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * ENTERPRISE EDITION - World-Class Terminal Experience
+ * ═══════════════════════════════════════════════════════════════════════════════
+ *
+ * Configure your project for production-grade verification.
+ * Interactive wizard or quick setup for any project type.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const { EXIT } = require("./lib/exit-codes");
+
+// Use enhanced wizard if available
+let InitWizard;
+try {
+  InitWizard = require("./lib/init-wizard").InitWizard;
+} catch {
+  InitWizard = null;
+}
+
+// Enterprise init
+let EnterpriseInit;
+try {
+  EnterpriseInit = require("./lib/enterprise-init").EnterpriseInit;
+} catch {
+  EnterpriseInit = null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ADVANCED TERMINAL - ANSI CODES & UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+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',
+};
+
+// 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`;
+
+// Premium color palette (gold/amber theme for "init/setup")
+const colors = {
+  // Gradient for banner
+  gradient1: rgb(255, 215, 100),   // Gold
+  gradient2: rgb(255, 200, 80),    // Light gold
+  gradient3: rgb(255, 180, 60),    // Amber
+  gradient4: rgb(255, 160, 40),    // Deep amber
+  gradient5: rgb(255, 140, 20),    // Orange-amber
+  gradient6: rgb(255, 120, 0),     // Deep orange
+  
+  // Category colors
+  framework: rgb(100, 200, 255),   // Blue
+  database: rgb(200, 150, 255),    // Purple
+  auth: rgb(100, 255, 180),        // Green
+  payment: rgb(255, 200, 100),     // Gold
+  ci: rgb(255, 150, 100),          // Coral
+  deploy: rgb(150, 200, 255),      // Light blue
+  testing: rgb(200, 255, 150),     // Lime
+  
+  // Status colors
+  success: rgb(0, 255, 150),
+  warning: rgb(255, 200, 0),
+  error: rgb(255, 80, 80),
+  info: rgb(100, 200, 255),
+  
+  // UI colors
+  accent: rgb(255, 200, 100),
+  muted: rgb(140, 130, 100),
+  subtle: rgb(100, 90, 70),
+  highlight: rgb(255, 255, 255),
+  
+  // Enterprise
+  enterprise: rgb(200, 150, 255),
+  compliance: rgb(100, 200, 150),
+  team: rgb(150, 180, 255),
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PREMIUM BANNER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const INIT_BANNER = `
+${rgb(255, 220, 120)}  ██╗███╗   ██╗██╗████████╗${c.reset}
+${rgb(255, 200, 100)}  ██║████╗  ██║██║╚══██╔══╝${c.reset}
+${rgb(255, 180, 80)}  ██║██╔██╗ ██║██║   ██║   ${c.reset}
+${rgb(255, 160, 60)}  ██║██║╚██╗██║██║   ██║   ${c.reset}
+${rgb(255, 140, 40)}  ██║██║ ╚████║██║   ██║   ${c.reset}
+${rgb(255, 120, 20)}  ╚═╝╚═╝  ╚═══╝╚═╝   ╚═╝   ${c.reset}
+`;
+
+const BANNER_FULL = `
+${rgb(255, 220, 120)}  ██╗   ██╗██╗██████╗ ███████╗ ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗${c.reset}
+${rgb(255, 200, 100)}  ██║   ██║██║██╔══██╗██╔════╝██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝${c.reset}
+${rgb(255, 180, 80)}  ██║   ██║██║██████╔╝█████╗  ██║     ███████║█████╗  ██║     █████╔╝ ${c.reset}
+${rgb(255, 160, 60)}  ╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ ${c.reset}
+${rgb(255, 140, 40)}   ╚████╔╝ ██║██████╔╝███████╗╚██████╗██║  ██║███████╗╚██████╗██║  ██╗${c.reset}
+${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)}Enterprise Ready${c.reset}             ${c.dim}│${c.reset}
+${c.dim}  └─────────────────────────────────────────────────────────────────────┘${c.reset}
+`;
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ICONS & SYMBOLS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const ICONS = {
+  // Main
+  init: '⚡',
+  setup: '🔧',
+  config: '⚙️',
+  wizard: '🧙',
+  
+  // Status
+  check: '✓',
+  cross: '✗',
+  warning: '⚠',
+  info: 'ℹ',
+  arrow: '→',
+  bullet: '•',
+  
+  // Categories
+  framework: '🏗️',
+  database: '🗄️',
+  auth: '🔐',
+  payment: '💳',
+  ci: '🔄',
+  deploy: '🚀',
+  testing: '🧪',
+  
+  // Actions
+  create: '📝',
+  update: '✏️',
+  skip: '⏭️',
+  detect: '🔍',
+  repair: '🔧',
+  tool: '🛠️',
+  
+  // Objects
+  file: '📄',
+  folder: '📁',
+  git: '🌿',
+  lock: '🔒',
+  shield: '🛡️',
+  team: '👥',
+  clock: '⏱',
+  lightning: '⚡',
+  sparkle: '✨',
+  star: '★',
+  
+  // Enterprise
+  enterprise: '🏢',
+  compliance: '📋',
+  mcp: '🤖',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BOX DRAWING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const BOX = {
+  topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯',
+  horizontal: '─', vertical: '│',
+  teeRight: '├', teeLeft: '┤', teeDown: '┬', teeUp: '┴',
+  cross: '┼',
+  // Double line
+  dTopLeft: '╔', dTopRight: '╗', dBottomLeft: '╚', dBottomRight: '╝',
+  dHorizontal: '═', dVertical: '║',
+  // Heavy
+  hTopLeft: '┏', hTopRight: '┓', hBottomLeft: '┗', hBottomRight: '┛',
+  hHorizontal: '━', hVertical: '┃',
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SPINNER & PROGRESS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const SPINNER_DOTS = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+const SPINNER_SETUP = ['⚡', '✨', '⚡', '✨'];
+
+let spinnerIndex = 0;
+let spinnerInterval = null;
+let spinnerStartTime = null;
+
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const mins = Math.floor(ms / 60000);
+  const secs = Math.floor((ms % 60000) / 1000);
+  return `${mins}m ${secs}s`;
+}
+
+function truncate(str, len) {
+  if (!str) return '';
+  if (str.length <= len) return str;
+  return str.slice(0, len - 3) + '...';
+}
+
+function padCenter(str, width) {
+  const padding = Math.max(0, width - str.length);
+  const left = Math.floor(padding / 2);
+  const right = padding - left;
+  return ' '.repeat(left) + str + ' '.repeat(right);
+}
+
+function startSpinner(message, color = colors.accent) {
+  spinnerStartTime = Date.now();
+  process.stdout.write(c.hideCursor);
+  
+  spinnerInterval = setInterval(() => {
+    const elapsed = formatDuration(Date.now() - spinnerStartTime);
+    process.stdout.write(`\r${c.clearLine}  ${color}${SPINNER_DOTS[spinnerIndex]}${c.reset} ${message} ${c.dim}${elapsed}${c.reset}`);
+    spinnerIndex = (spinnerIndex + 1) % SPINNER_DOTS.length;
+  }, 80);
+}
+
+function stopSpinner(message, success = true) {
+  if (spinnerInterval) {
+    clearInterval(spinnerInterval);
+    spinnerInterval = null;
+  }
+  const elapsed = spinnerStartTime ? formatDuration(Date.now() - spinnerStartTime) : '';
+  const icon = success ? `${colors.success}${ICONS.check}${c.reset}` : `${colors.error}${ICONS.cross}${c.reset}`;
+  process.stdout.write(`\r${c.clearLine}  ${icon} ${message} ${c.dim}${elapsed}${c.reset}\n`);
+  process.stdout.write(c.showCursor);
+  spinnerStartTime = null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SECTION HEADERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printBanner() {
+  console.log(BANNER_FULL);
+}
+
+function printCompactBanner() {
+  console.log(INIT_BANNER);
+}
+
+function printDivider(char = '─', width = 69, color = c.dim) {
+  console.log(`${color}  ${char.repeat(width)}${c.reset}`);
+}
+
+function printSection(title, icon = '◆') {
+  console.log();
+  console.log(`  ${colors.accent}${icon}${c.reset} ${c.bold}${title}${c.reset}`);
+  printDivider();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FRAMEWORK-SPECIFIC CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function getFrameworkConfig(detection) {
+  if (!detection || !detection.frameworks) {
+    return {
+      framework: "node",
+      checks: ["routes", "env", "auth", "security"],
+      ignorePaths: [],
+      extra: {},
+    };
+  }
+
+  // Find the primary detected framework
+  const detectedFrameworks = Object.entries(detection.frameworks)
+    .filter(([key, fw]) => fw.detected)
+    .map(([key, fw]) => ({ key, ...fw }));
+
+  if (detectedFrameworks.length === 0) {
+    return {
+      framework: "node",
+      checks: ["routes", "env", "auth", "security"],
+      ignorePaths: [],
+      extra: {},
+    };
+  }
+
+  // Use the first detected framework (usually the most specific)
+  const primary = detectedFrameworks[0];
+  const frameworkKey = primary.key;
+
+  // Framework-specific configurations
+  const frameworkConfigs = {
+    nextjs: {
+      framework: "nextjs",
+      checks: ["routes", "auth", "api", "security", "ssr"],
+      ignorePaths: [".next/", "out/", ".vercel/"],
+      extra: {},
+    },
+    remix: {
+      framework: "remix",
+      checks: ["routes", "auth", "api", "security", "loaders"],
+      ignorePaths: [".remix/", "build/"],
+      extra: {},
+    },
+    nuxt: {
+      framework: "nuxt",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [".nuxt/", ".output/"],
+      extra: {},
+    },
+    sveltekit: {
+      framework: "sveltekit",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [".svelte-kit/", "build/"],
+      extra: {},
+    },
+    react: {
+      framework: "react",
+      checks: ["components", "api", "security"],
+      ignorePaths: ["build/", "dist/"],
+      extra: {},
+    },
+    vue: {
+      framework: "vue",
+      checks: ["components", "api", "security"],
+      ignorePaths: ["dist/"],
+      extra: {},
+    },
+    fastify: {
+      framework: "fastify",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [],
+      extra: {
+        fastify: {
+          plugins: detection.frameworks?.fastify?.plugins || [],
+        },
+      },
+    },
+    express: {
+      framework: "express",
+      checks: ["routes", "auth", "api", "security"],
+      ignorePaths: [],
+      extra: {},
+    },
+    nestjs: {
+      framework: "nestjs",
+      checks: ["routes", "auth", "api", "security", "modules"],
+      ignorePaths: ["dist/"],
+      extra: {},
+    },
+  };
+
+  // Get framework-specific config or use detected checks
+  const config = frameworkConfigs[frameworkKey] || {
+    framework: frameworkKey,
+    checks: primary.checks || ["routes", "env", "auth", "security"],
+    ignorePaths: [],
+    extra: {},
+  };
+
+  // Merge detected checks if available
+  if (primary.checks && primary.checks.length > 0) {
+    config.checks = [...new Set([...config.checks, ...primary.checks])];
+  }
+
+  return config;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INIT STATE TRACKING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function saveInitState(targetDir, state) {
+  try {
+    const statePath = path.join(targetDir, ".vibecheck", ".init-state.json");
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+  } catch (e) {
+    // Non-critical - state tracking is optional
+    if (process.env.VIBECHECK_DEBUG) {
+      console.error(`Failed to save init state: ${e.message}`);
+    }
+  }
+}
+
+function loadInitState(targetDir) {
+  try {
+    const statePath = path.join(targetDir, ".vibecheck", ".init-state.json");
+    if (fs.existsSync(statePath)) {
+      return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    }
+  } catch (e) {
+    // Non-critical
+  }
+  return null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// POST-INIT VALIDATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function verifyInitSetup(targetDir, opts) {
+  const issues = [];
+  const vibecheckDir = path.join(targetDir, ".vibecheck");
+  
+  // Check directory structure
+  const requiredDirs = [
+    vibecheckDir,
+    path.join(vibecheckDir, "results"),
+    path.join(vibecheckDir, "contracts"),
+  ];
+  
+  for (const dir of requiredDirs) {
+    if (!fs.existsSync(dir)) {
+      issues.push(`Missing directory: ${path.relative(targetDir, dir)}`);
+    }
+  }
+  
+  // Check config.json
+  const configPath = path.join(vibecheckDir, "config.json");
+  if (!fs.existsSync(configPath)) {
+    issues.push("Missing: .vibecheck/config.json");
+  } else {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (!config.version || !config.checks) {
+        issues.push("Invalid config.json structure");
+      }
+    } catch (e) {
+      issues.push(`Invalid config.json: ${e.message}`);
+    }
+  }
+  
+  // Check truthpack
+  const truthpackPath = path.join(vibecheckDir, "truthpack.json");
+  if (!fs.existsSync(truthpackPath)) {
+    issues.push("Missing: .vibecheck/truthpack.json (run 'vibecheck ctx build')");
+  } else {
+    try {
+      const truthpack = JSON.parse(fs.readFileSync(truthpackPath, "utf-8"));
+      if (!truthpack.version || !truthpack.generatedAt) {
+        issues.push("Invalid truthpack.json structure");
+      }
+    } catch (e) {
+      issues.push(`Invalid truthpack.json: ${e.message}`);
+    }
+  }
+  
+  // Check contracts
+  const contractsDir = path.join(vibecheckDir, "contracts");
+  const requiredContracts = ["routes.contract.json", "env.contract.json"];
+  for (const contract of requiredContracts) {
+    const contractPath = path.join(contractsDir, contract);
+    if (!fs.existsSync(contractPath)) {
+      issues.push(`Missing contract: ${contract}`);
+    }
+  }
+  
+  if (issues.length === 0 && !opts.json) {
+    console.log();
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} ${c.bold}Setup Verification:${c.reset} All checks passed`);
+  }
+  
+  return {
+    success: issues.length === 0,
+    issues,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FRAMEWORK-SPECIFIC RECOMMENDATIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printFrameworkRecommendations(detection, opts) {
+  const frameworks = Object.keys(detection.frameworks || {}).filter(k => detection.frameworks[k].detected);
+  if (frameworks.length === 0) return;
+  
+  const primaryFramework = frameworks[0];
+  const framework = detection.frameworks[primaryFramework];
+  
+  const recommendations = [];
+  
+  // Next.js specific
+  if (primaryFramework === 'nextjs') {
+    recommendations.push({
+      icon: ICONS.framework,
+      title: "Next.js Route Verification",
+      command: "vibecheck scan --routes",
+      description: "Verify all Next.js routes are properly configured",
+    });
+    if (!opts.connect) {
+      recommendations.push({
+        icon: ICONS.ci,
+        title: "Add Vercel Integration",
+        command: "vibecheck init --connect",
+        description: "Enable GitHub Actions for automatic PR checks",
+      });
+    }
+  }
+  
+  // Fastify specific
+  if (primaryFramework === 'fastify') {
+    recommendations.push({
+      icon: ICONS.framework,
+      title: "Fastify Route Extraction",
+      command: "vibecheck scan --routes",
+      description: "Extract and verify all Fastify routes",
+    });
+  }
+  
+  // Express specific
+  if (primaryFramework === 'express') {
+    recommendations.push({
+      icon: ICONS.framework,
+      title: "Express Route Analysis",
+      command: "vibecheck scan --routes",
+      description: "Analyze Express route definitions",
+    });
+  }
+  
+  // Auth providers
+  const authProviders = Object.keys(detection.auth || {}).filter(k => detection.auth[k].detected);
+  if (authProviders.length > 0) {
+    recommendations.push({
+      icon: ICONS.auth,
+      title: "Auth Coverage Check",
+      command: "vibecheck scan --auth",
+      description: "Verify authentication coverage across routes",
+    });
+  }
+  
+  // Payment providers
+  const paymentProviders = Object.keys(detection.payments || {}).filter(k => detection.payments[k].detected);
+  if (paymentProviders.length > 0) {
+    recommendations.push({
+      icon: ICONS.payment,
+      title: "Payment Flow Verification",
+      command: "vibecheck scan --billing",
+      description: "Verify payment webhook handlers and idempotency",
+    });
+  }
+  
+  if (recommendations.length > 0) {
+    console.log();
+    printSection('RECOMMENDATIONS', ICONS.sparkle);
+    console.log();
+    for (const rec of recommendations) {
+      console.log(`  ${rec.icon} ${c.bold}${rec.title}${c.reset}`);
+      console.log(`     ${c.dim}${rec.description}${c.reset}`);
+      console.log(`     ${c.cyan}${rec.command}${c.reset}`);
+      console.log();
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// REPAIR MODE - Fix partial init state
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runRepairMode(targetDir, projectName, opts) {
+  printSection('REPAIR MODE', ICONS.repair);
+  console.log();
+  console.log(`  ${colors.info}${ICONS.info}${c.reset} Scanning for partial initialization state...`);
+  console.log();
+  
+  // Load previous init state if available
+  const previousState = loadInitState(targetDir);
+  if (previousState && !opts.json) {
+    console.log(`  ${c.dim}Previous init: ${previousState.timestamp} (${previousState.mode} mode)${c.reset}`);
+    if (previousState.errors && previousState.errors.length > 0) {
+      console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${previousState.errors.length} error(s) from previous attempt`);
+    }
+    console.log();
+  }
+
+  const vibecheckDir = path.join(targetDir, ".vibecheck");
+  const issues = [];
+  const fixes = [];
+
+  // Check for missing directories
+  const requiredDirs = [
+    vibecheckDir,
+    path.join(vibecheckDir, "results"),
+    path.join(vibecheckDir, "reports"),
+    path.join(vibecheckDir, "contracts"),
+    path.join(vibecheckDir, "missions"),
+    path.join(vibecheckDir, "checkpoints"),
+    path.join(vibecheckDir, "runs"),
+  ];
+
+  for (const dir of requiredDirs) {
+    if (!fs.existsSync(dir)) {
+      issues.push(`Missing directory: ${path.relative(targetDir, dir)}`);
+      if (!opts.dryRun) {
+        fs.mkdirSync(dir, { recursive: true });
+        fixes.push(`Created: ${path.relative(targetDir, dir)}`);
+      } else {
+        fixes.push(`Would create: ${path.relative(targetDir, dir)}`);
+      }
+    }
+  }
+
+  // Check for missing config.json
+  const configPath = path.join(vibecheckDir, "config.json");
+  if (!fs.existsSync(configPath)) {
+    issues.push("Missing: .vibecheck/config.json");
+    if (!opts.dryRun) {
+      try {
+        const { detectAll } = require("./lib/enterprise-detect");
+        const detection = detectAll(targetDir);
+        const frameworkConfig = getFrameworkConfig(detection);
+        const config = {
+          version: "2.0.0",
+          project: projectName,
+          createdAt: new Date().toISOString(),
+          framework: frameworkConfig.framework || "node",
+          checks: frameworkConfig.checks || ["routes", "env", "auth", "security"],
+          output: ".vibecheck",
+          policy: {
+            allowlist: { domains: [], packages: [] },
+            ignore: {
+              paths: [
+                "node_modules",
+                "__tests__",
+                "*.test.*",
+                "*.spec.*",
+                ...(frameworkConfig.ignorePaths || []),
+              ],
+            },
+          },
+          thresholds: {
+            minScore: 70,
+            maxBlockers: 0,
+            maxWarnings: 10,
+          },
+          ...(frameworkConfig.extra || {}),
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        fixes.push("Created: .vibecheck/config.json");
+      } catch (e) {
+        issues.push(`Failed to create config.json: ${e.message}`);
+      }
+    } else {
+      fixes.push("Would create: .vibecheck/config.json");
+    }
+  }
+
+  // Check for missing truthpack
+  const truthpackPath = path.join(vibecheckDir, "truthpack.json");
+  if (!fs.existsSync(truthpackPath)) {
+    issues.push("Missing: .vibecheck/truthpack.json");
+    if (!opts.dryRun) {
+      startSpinner('Generating truthpack...', colors.accent);
+      try {
+        const { runContext } = require("./runContext");
+        await runContext(["--path", targetDir, "--quiet"]);
+        stopSpinner('Truthpack generated', true);
+        fixes.push("Generated: .vibecheck/truthpack.json");
+      } catch (e) {
+        stopSpinner('Truthpack generation failed', false);
+        issues.push(`Failed to generate truthpack: ${e.message}`);
+      }
+    } else {
+      fixes.push("Would generate: .vibecheck/truthpack.json");
+    }
+  }
+
+  // Check for missing contracts
+  const contractsDir = path.join(vibecheckDir, "contracts");
+  const routeContractPath = path.join(contractsDir, "routes.contract.json");
+  const envContractPath = path.join(contractsDir, "env.contract.json");
+
+  if (!fs.existsSync(routeContractPath)) {
+    issues.push("Missing: .vibecheck/contracts/routes.contract.json");
+    if (!opts.dryRun) {
+      const routeContract = {
+        version: "1.0.0",
+        generatedAt: new Date().toISOString(),
+        routes: [],
+        description: "Route contract - populated by scan",
+      };
+      fs.writeFileSync(routeContractPath, JSON.stringify(routeContract, null, 2));
+      fixes.push("Created: .vibecheck/contracts/routes.contract.json");
+    } else {
+      fixes.push("Would create: .vibecheck/contracts/routes.contract.json");
+    }
+  }
+
+  if (!fs.existsSync(envContractPath)) {
+    issues.push("Missing: .vibecheck/contracts/env.contract.json");
+    if (!opts.dryRun) {
+      const envContract = {
+        version: "1.0.0",
+        generatedAt: new Date().toISOString(),
+        required: [],
+        optional: [],
+        description: "Environment contract - populated by scan",
+      };
+      fs.writeFileSync(envContractPath, JSON.stringify(envContract, null, 2));
+      fixes.push("Created: .vibecheck/contracts/env.contract.json");
+    } else {
+      fixes.push("Would create: .vibecheck/contracts/env.contract.json");
+    }
+  }
+
+  // Use previous state to prioritize fixes
+  if (previousState && previousState.errors && previousState.errors.length > 0) {
+    const previousErrors = previousState.errors.map(e => e.step);
+    // Prioritize fixing errors from previous attempt
+    const prioritizedIssues = [];
+    const otherIssues = [];
+    
+    for (const issue of issues) {
+      const isPreviousError = previousErrors.some(step => issue.toLowerCase().includes(step));
+      if (isPreviousError) {
+        prioritizedIssues.push(issue);
+      } else {
+        otherIssues.push(issue);
+      }
+    }
+    
+    issues.length = 0;
+    issues.push(...prioritizedIssues, ...otherIssues);
+  }
+  
+  // Summary
+  console.log();
+  if (issues.length === 0) {
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} No issues found - initialization is complete`);
+    // Clear previous state on successful repair
+    if (!opts.dryRun) {
+      const statePath = path.join(targetDir, ".vibecheck", ".init-state.json");
+      if (fs.existsSync(statePath)) {
+        fs.unlinkSync(statePath);
+      }
+    }
+    return 0;
+  }
+
+  console.log(`  ${colors.warning}${ICONS.warning}${c.reset} Found ${issues.length} issue(s)`);
+  if (previousState && previousState.errors && previousState.errors.length > 0) {
+    console.log(`  ${c.dim}(${previousState.errors.length} from previous attempt)${c.reset}`);
+  }
+  console.log();
+  for (const issue of issues) {
+    console.log(`    ${c.dim}•${c.reset} ${issue}`);
+  }
+
+  if (fixes.length > 0) {
+    console.log();
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} Applied ${fixes.length} fix(es)`);
+    for (const fix of fixes) {
+      console.log(`    ${c.dim}•${c.reset} ${fix}`);
+    }
+  }
+
+  console.log();
+  return issues.length > 0 ? (opts.dryRun ? 0 : 1) : 0;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ENHANCED DETECTION DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printEnhancedDetection(detection, verbose = false) {
+  const frameworks = Object.keys(detection.frameworks || {}).filter(k => detection.frameworks[k].detected);
+  const databases = Object.keys(detection.databases || {}).filter(k => detection.databases[k].detected);
+  const authProviders = Object.keys(detection.auth || {}).filter(k => detection.auth[k].detected);
+  const paymentProviders = Object.keys(detection.payments || {}).filter(k => detection.payments[k].detected);
+  
+  if (frameworks.length > 0) {
+    console.log(`  ${colors.info}${ICONS.info}${c.reset} ${c.bold}Detected Stack:${c.reset}`);
+    console.log(`     ${ICONS.framework} Frameworks: ${frameworks.map(f => detection.frameworks[f].name).join(', ')}`);
+    
+    if (databases.length > 0) {
+      console.log(`     ${ICONS.database} Databases: ${databases.map(d => detection.databases[d].name).join(', ')}`);
+    }
+    if (authProviders.length > 0) {
+      console.log(`     ${ICONS.auth} Auth: ${authProviders.map(a => detection.auth[a].name).join(', ')}`);
+    }
+    if (paymentProviders.length > 0) {
+      console.log(`     ${ICONS.payment} Payments: ${paymentProviders.map(p => detection.payments[p].name).join(', ')}`);
+    }
+    
+    if (verbose) {
+      console.log();
+      console.log(`  ${c.dim}Detection Details:${c.reset}`);
+      if (detection.packageManager) {
+        console.log(`     Package Manager: ${detection.packageManager}`);
+      }
+      if (detection.nodeVersion) {
+        console.log(`     Node Version: ${detection.nodeVersion}`);
+      }
+      const checks = detection.checks || [];
+      if (checks.length > 0) {
+        console.log(`     Recommended Checks: ${checks.join(', ')}`);
+      }
+      const invariants = detection.invariants || [];
+      if (invariants.length > 0) {
+        console.log(`     Invariants: ${invariants.join(', ')}`);
+      }
+    }
+    console.log();
+  } else {
+    console.log(`  ${colors.warning}${ICONS.warning}${c.reset} No framework detected - using default Node.js configuration`);
+    console.log();
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// DETECTION DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printDetectionResults(detection) {
+  printSection('PROJECT DETECTION', ICONS.detect);
+  console.log();
+  
+  const categories = [
+    { key: 'frameworks', label: 'Frameworks', icon: ICONS.framework, color: colors.framework },
+    { key: 'databases', label: 'Databases', icon: ICONS.database, color: colors.database },
+    { key: 'auth', label: 'Authentication', icon: ICONS.auth, color: colors.auth },
+    { key: 'payments', label: 'Payments', icon: ICONS.payment, color: colors.payment },
+    { key: 'ci', label: 'CI/CD', icon: ICONS.ci, color: colors.ci },
+    { key: 'deploy', label: 'Deployment', icon: ICONS.deploy, color: colors.deploy },
+    { key: 'testing', label: 'Testing', icon: ICONS.testing, color: colors.testing },
+  ];
+  
+  for (const cat of categories) {
+    const itemsObj = detection[cat.key] || {};
+    // Handle both object and array formats
+    const items = Array.isArray(itemsObj) 
+      ? itemsObj 
+      : Object.entries(itemsObj)
+          .filter(([key, value]) => value && (value.detected || value === true))
+          .map(([key, value]) => typeof value === 'object' ? value.name || key : key);
+    
+    if (items.length === 0) continue;
+    
+    const itemList = items.slice(0, 4).join(', ');
+    const more = items.length > 4 ? ` +${items.length - 4} more` : '';
+    
+    console.log(`  ${cat.color}${cat.icon}${c.reset} ${c.bold}${cat.label.padEnd(16)}${c.reset} ${itemList}${c.dim}${more}${c.reset}`);
+  }
+  
+  // Show detected package manager
+  if (detection.packageManager) {
+    console.log();
+    console.log(`  ${c.dim}Package manager:${c.reset} ${colors.info}${detection.packageManager}${c.reset}`);
+  }
+  
+  // Show Node version if detected
+  if (detection.nodeVersion) {
+    console.log(`  ${c.dim}Node version:${c.reset} ${colors.info}${detection.nodeVersion}${c.reset}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SETUP PROGRESS DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printSetupStep(step, status, detail = null) {
+  let icon, color;
+  
+  switch (status) {
+    case 'dry-run':
+      icon = ICONS.info;
+      color = colors.warning;
+      break;
+    case 'creating':
+      icon = ICONS.create;
+      color = colors.accent;
+      break;
+    case 'updating':
+      icon = ICONS.update;
+      color = colors.info;
+      break;
+    case 'success':
+      icon = ICONS.check;
+      color = colors.success;
+      break;
+    case 'skipped':
+      icon = ICONS.skip;
+      color = colors.muted;
+      break;
+    case 'exists':
+      icon = ICONS.warning;
+      color = colors.warning;
+      break;
+    case 'error':
+      icon = ICONS.cross;
+      color = colors.error;
+      break;
+    default:
+      icon = ICONS.bullet;
+      color = colors.muted;
+  }
+  
+  let line = `  ${color}${icon}${c.reset} ${step}`;
+  if (detail) {
+    line += ` ${c.dim}${detail}${c.reset}`;
+  }
+  console.log(line);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FILES CREATED DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printFilesCreated(files) {
+  printSection('FILES CREATED', ICONS.file);
+  console.log();
+  
+  const fileIcons = {
+    'config.json': ICONS.config,
+    'invariants.yml': ICONS.shield,
+    'security-policy.json': ICONS.lock,
+    'team.json': ICONS.team,
+    'mcp.json': ICONS.mcp,
+    '.vibecheckrc': ICONS.config,
+    'vibecheck.yml': ICONS.ci,
+  };
+  
+  for (const file of files) {
+    const basename = path.basename(file);
+    const icon = fileIcons[basename] || ICONS.file;
+    const displayPath = file.startsWith('.vibecheck/') ? file : `.vibecheck/${file}`;
+    console.log(`  ${colors.success}${icon}${c.reset} ${c.dim}${displayPath}${c.reset}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SUCCESS CARD
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printSuccessCard(projectName, mode, filesCreated) {
+  const w = 68;
+  
+  console.log();
+  console.log();
+  
+  // Top border
+  console.log(`  ${colors.success}${BOX.dTopLeft}${BOX.dHorizontal.repeat(w)}${BOX.dTopRight}${c.reset}`);
+  
+  // Empty line
+  console.log(`  ${colors.success}${BOX.dVertical}${c.reset}${' '.repeat(w)}${colors.success}${BOX.dVertical}${c.reset}`);
+  
+  // Headline
+  const headline = `${ICONS.sparkle}  VIBECHECK INITIALIZED`;
+  const headlinePadded = padCenter(headline, w);
+  console.log(`  ${colors.success}${BOX.dVertical}${c.reset}${colors.success}${c.bold}${headlinePadded}${c.reset}${colors.success}${BOX.dVertical}${c.reset}`);
+  
+  // Project name
+  const projectLine = `Project: ${projectName}`;
+  const projectPadded = padCenter(projectLine, w);
+  console.log(`  ${colors.success}${BOX.dVertical}${c.reset}${c.dim}${projectPadded}${c.reset}${colors.success}${BOX.dVertical}${c.reset}`);
+  
+  // Mode
+  const modeLine = `Mode: ${mode}`;
+  const modePadded = padCenter(modeLine, w);
+  console.log(`  ${colors.success}${BOX.dVertical}${c.reset}${c.dim}${modePadded}${c.reset}${colors.success}${BOX.dVertical}${c.reset}`);
+  
+  // Empty line
+  console.log(`  ${colors.success}${BOX.dVertical}${c.reset}${' '.repeat(w)}${colors.success}${BOX.dVertical}${c.reset}`);
+  
+  // Files created count
+  const filesLine = `${filesCreated} files configured`;
+  const filesPadded = padCenter(filesLine, w);
+  console.log(`  ${colors.success}${BOX.dVertical}${c.reset}${colors.accent}${filesPadded}${c.reset}${colors.success}${BOX.dVertical}${c.reset}`);
+  
+  // Empty line
+  console.log(`  ${colors.success}${BOX.dVertical}${c.reset}${' '.repeat(w)}${colors.success}${BOX.dVertical}${c.reset}`);
+  
+  // Bottom border
+  console.log(`  ${colors.success}${BOX.dBottomLeft}${BOX.dHorizontal.repeat(w)}${BOX.dBottomRight}${c.reset}`);
+  
+  console.log();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// NEXT STEPS DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printNextSteps(options = {}) {
+  printSection('NEXT STEPS', ICONS.arrow);
+  console.log();
+  
+  const steps = [];
+  
+  if (options.mode === 'connect') {
+    steps.push(
+      { num: 1, cmd: 'vibecheck scan', desc: 'Run baseline scan' },
+      { num: 2, cmd: 'vibecheck checkpoint --save', desc: 'Save baseline for comparison' },
+      { num: 3, cmd: 'git push', desc: 'CI will run automatically' },
+    );
+  } else {
+    steps.push(
+      { num: 1, cmd: 'vibecheck scan', desc: 'Run your first scan' },
+      { num: 2, cmd: 'vibecheck ship', desc: 'Check if ready to ship' },
+    );
+    
+    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 [STARTER]' });
+    }
+  }
+  
+  for (const step of steps) {
+    console.log(`  ${colors.accent}${step.num}.${c.reset} ${c.bold}${step.cmd}${c.reset}`);
+    console.log(`     ${c.dim}${step.desc}${c.reset}`);
+  }
+  
+  console.log();
+  console.log(`  ${c.dim}Full docs:${c.reset} ${colors.info}https://docs.vibecheckai.dev${c.reset}`);
+  console.log();
+  
+  // 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}⚡ 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}`);
+  console.log(`  ${c.dim}╰────────────────────────────────────────────────────────────╯${c.reset}`);
+  console.log();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ENTERPRISE MODE HEADER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printEnterpriseHeader(options) {
+  console.log();
+  console.log(`  ${bgRgb(60, 40, 100)}${c.bold}  ${ICONS.enterprise} ENTERPRISE MODE  ${c.reset}`);
+  console.log();
+  
+  const features = [];
+  if (options.ci) features.push(`${ICONS.ci} CI/CD`);
+  if (options.compliance) features.push(`${ICONS.compliance} Compliance`);
+  if (options.team) features.push(`${ICONS.team} Team`);
+  if (options.mcp) features.push(`${ICONS.mcp} MCP`);
+  if (options.strict) features.push(`${ICONS.shield} Strict`);
+  
+  if (features.length > 0) {
+    console.log(`  ${c.dim}Features:${c.reset} ${features.join('  ')}`);
+    console.log();
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// COMPLIANCE DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printComplianceInfo(complianceType) {
+  const complianceInfo = {
+    soc2: { name: 'SOC 2 Type II', icon: '🔐', color: colors.compliance },
+    hipaa: { name: 'HIPAA', icon: '🏥', color: rgb(255, 100, 100) },
+    gdpr: { name: 'GDPR', icon: '🇪🇺', color: rgb(100, 150, 255) },
+    pci: { name: 'PCI-DSS', icon: '💳', color: rgb(255, 200, 100) },
+  };
+  
+  const info = complianceInfo[complianceType] || { name: complianceType, icon: ICONS.compliance, color: colors.compliance };
+  
+  console.log();
+  console.log(`  ${info.color}${info.icon}${c.reset} ${c.bold}${info.name} Compliance${c.reset}`);
+  console.log(`     ${c.dim}Generating baseline templates...${c.reset}`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// HELP DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printHelp(showBanner = true) {
+  if (showBanner && shouldShowBanner({})) {
+    console.log(BANNER_FULL);
+  }
+  console.log(`
+  ${c.bold}Usage:${c.reset} vibecheck init [mode] [options]
+
+  ${c.bold}MODES${c.reset}
+    ${colors.success}--local${c.reset}              ${c.green}[FREE]${c.reset}    Full local setup (default)
+                           Creates truthpack, contracts, MDC/IDE rules
+    ${colors.accent}--connect${c.reset}            ${c.cyan}[STARTER]${c.reset} + GitHub Actions, PR comments, dashboard sync
+
+  ${c.bold}Basic Options:${c.reset}
+    ${colors.accent}--path, -p <dir>${c.reset}     Project path ${c.dim}(default: current directory)${c.reset}
+    ${colors.accent}--quick, -q${c.reset}          Skip wizard, use defaults
+    ${colors.accent}--wizard, -i${c.reset}         Interactive setup wizard
+    ${colors.accent}--dry-run${c.reset}            Preview changes without applying
+    ${colors.accent}--repair${c.reset}             Fix partial init state
+    ${colors.accent}--verify${c.reset}            Verify setup after init
+    ${colors.accent}--verbose, -v${c.reset}       Show detailed output
+    ${colors.accent}--git-hooks${c.reset}          Install git pre-push hook
+    ${colors.accent}--json${c.reset}               Output results as JSON
+    ${colors.accent}--help, -h${c.reset}           Show this help
+
+  ${colors.enterprise}${c.bold}Enterprise Options:${c.reset}
+    ${colors.accent}--enterprise, -e${c.reset}     Enable enterprise mode
+    ${colors.accent}--full${c.reset}               All features: CI + team + MCP
+    ${colors.accent}--detect${c.reset}             Detection only (JSON output)
+
+  ${colors.ci}${c.bold}CI/CD Integration:${c.reset}
+    ${colors.accent}--ci [provider]${c.reset}      Setup CI/CD (auto-detects)
+    ${colors.accent}--gha${c.reset}                GitHub Actions workflow
+    ${colors.accent}--gitlab${c.reset}             GitLab CI configuration
+    ${colors.accent}--fail-on-warn${c.reset}       CI fails on WARN
+
+  ${colors.compliance}${c.bold}Compliance Templates:${c.reset}
+    ${colors.accent}--compliance [type]${c.reset}  Generate compliance templates
+    ${colors.accent}--soc2${c.reset}               SOC 2 Type II baseline
+    ${colors.accent}--hipaa${c.reset}              HIPAA compliance baseline
+    ${colors.accent}--gdpr${c.reset}               GDPR compliance baseline
+    ${colors.accent}--pci${c.reset}                PCI-DSS compliance baseline
+
+  ${colors.team}${c.bold}Team & Security:${c.reset}
+    ${colors.accent}--team${c.reset}               Generate team config (multi-env)
+    ${colors.accent}--mcp${c.reset}                Generate MCP server config
+    ${colors.accent}--strict${c.reset}             Enable strict mode
+
+  ${c.bold}Created Files (--local):${c.reset}
+    ${c.dim}.vibecheck/config.json${c.reset}           Main configuration
+    ${c.dim}.vibecheck/truthpack.json${c.reset}        Routes, env, auth, billing truth
+    ${c.dim}.vibecheck/contracts/${c.reset}            Contract definitions
+    ${c.dim}.cursor/rules/*.mdc${c.reset}              Cursor IDE rules
+    ${c.dim}.windsurf/rules.md${c.reset}               Windsurf IDE rules
+
+  ${c.bold}Additional Files (--connect):${c.reset}
+    ${c.dim}.github/workflows/vibecheck.yml${c.reset}  GitHub Actions workflow
+    ${c.dim}.github/workflows/vibecheck-pr.yml${c.reset} PR check workflow
+
+  ${c.bold}Examples:${c.reset}
+    ${c.dim}# Full local setup (default)${c.reset}
+    vibecheck init --local
+
+    ${c.dim}# Local + GitHub integration${c.reset}
+    vibecheck init --connect
+
+    ${c.dim}# Quick setup${c.reset}
+    vibecheck init --quick
+
+    ${c.dim}# Enterprise with compliance${c.reset}
+    vibecheck init --enterprise --soc2
+  `);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ARGS PARSER
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  // Parse global flags first
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
+  
+  const out = {
+    path: globalFlags.path || ".",
+    gitHooks: false,
+    help: globalFlags.help || false,
+    quick: false,
+    json: globalFlags.json || false,
+    verbose: globalFlags.verbose || false,
+    noBanner: globalFlags.noBanner || false,
+    ci: globalFlags.ci || false,
+    quiet: globalFlags.quiet || false,
+    // Mode flags (--local is default, --connect requires STARTER)
+    local: false,
+    connect: false,
+    // Enhancement flags
+    wizard: false,
+    interactive: false,
+    dryRun: false,
+    repair: false,
+    verify: false,
+    // Enterprise options
+    enterprise: false,
+    compliance: false,
+    team: false,
+    mcp: false,
+    strict: globalFlags.strict || false,
+    failOnWarn: false,
+    detect: false,
+  };
+
+  for (let i = 0; i < cleanArgs.length; i++) {
+    const a = cleanArgs[i];
+    if (a.startsWith("--path=")) out.path = a.split("=")[1];
+    if (a === "--path" || a === "-p") out.path = cleanArgs[++i];
+    if (a === "--git-hooks") out.gitHooks = true;
+    if (a === "--quick" || a === "-q") out.quick = true;
+    if (a === "--verify") out.verify = true;
+    
+    // Enhancement flags
+    if (a === "--wizard" || a === "--interactive" || a === "-i") {
+      out.wizard = true;
+      out.interactive = true;
+    }
+    if (a === "--dry-run" || a === "--dryrun") out.dryRun = true;
+    if (a === "--repair") out.repair = true;
+    
+    // Mode flags
+    if (a === "--local" || a === "-l") out.local = true;
+    if (a === "--connect" || a === "-c") out.connect = true;
+    
+    // Enterprise flags
+    if (a === "--enterprise" || a === "-e") out.enterprise = true;
+    if (a === "--ci") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        out.ci = args[++i];
+      } else {
+        out.ci = true;
+      }
+    }
+    if (a === "--gha" || a === "--github-actions") out.ci = "github";
+    if (a === "--gitlab") out.ci = "gitlab";
+    if (a === "--compliance") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        out.compliance = args[++i];
+      } else {
+        out.compliance = true;
+      }
+    }
+    if (a === "--soc2") out.compliance = "soc2";
+    if (a === "--hipaa") out.compliance = "hipaa";
+    if (a === "--gdpr") out.compliance = "gdpr";
+    if (a === "--pci") out.compliance = "pci";
+    if (a === "--team") out.team = true;
+    if (a === "--mcp") out.mcp = true;
+    if (a === "--strict") out.strict = true;
+    if (a === "--fail-on-warn") out.failOnWarn = true;
+    if (a === "--detect") out.detect = true;
+    if (a === "--full") {
+      out.enterprise = true;
+      out.ci = true;
+      out.team = true;
+      out.mcp = true;
+      out.connect = true;
+    }
+  }
+  
+  // Default to --local if neither mode specified
+  if (!out.local && !out.connect) {
+    out.local = true;
+  }
+  
+  return out;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN INIT FUNCTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// LOCAL MODE SETUP - Full local initialization
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runLocalSetup(targetDir, projectName, opts, filesCreated) {
+  printSection('LOCAL SETUP', ICONS.setup);
+  console.log();
+  
+  const totalSteps = 7; // Approximate number of major steps
+  let currentStep = 0;
+  
+  function logStep(stepName) {
+    currentStep++;
+    if (opts.verbose && !opts.json) {
+      console.log(`  ${c.dim}[${currentStep}/${totalSteps}]${c.reset} ${stepName}`);
+    }
+  }
+  
+  // Detect framework for framework-specific templates
+  let detection = null;
+  if (!opts.dryRun) {
+    try {
+      const { detectAll } = require("./lib/enterprise-detect");
+      detection = detectAll(targetDir);
+      if (!opts.json) {
+        printEnhancedDetection(detection, opts.verbose);
+      }
+    } catch (e) {
+      if (!opts.json) {
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} Detection failed: ${e.message}`);
+        if (opts.verbose) {
+          console.log(`  ${c.dim}Stack: ${e.stack}${c.reset}`);
+        }
+        console.log(`  ${c.dim}Using default configuration${c.reset}`);
+        console.log();
+      }
+    }
+  }
+  
+  const vibecheckDir = path.join(targetDir, ".vibecheck");
+  
+  // 1. Create .vibecheck/ directory structure
+  logStep('Creating directory structure');
+  const dirs = [
+    vibecheckDir,
+    path.join(vibecheckDir, "results"),
+    path.join(vibecheckDir, "reports"),
+    path.join(vibecheckDir, "contracts"),
+    path.join(vibecheckDir, "missions"),
+    path.join(vibecheckDir, "checkpoints"),
+    path.join(vibecheckDir, "runs"),
+  ];
+  
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) {
+      if (opts.dryRun) {
+        printSetupStep(path.relative(targetDir, dir), 'dry-run', 'would create');
+      } else {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+  }
+  if (!opts.dryRun) {
+    printSetupStep('.vibecheck/', 'success', 'directory structure created');
+    filesCreated.push('.vibecheck/');
+  }
+  
+  // 2. Create config.json with framework-specific settings
+  logStep('Creating configuration');
+  const configPath = path.join(vibecheckDir, "config.json");
+  if (!fs.existsSync(configPath) || opts.dryRun) {
+    const frameworkConfig = getFrameworkConfig(detection);
+    const config = {
+      version: "2.0.0",
+      project: projectName,
+      createdAt: new Date().toISOString(),
+      framework: frameworkConfig.framework || "node",
+      checks: frameworkConfig.checks || ["routes", "env", "auth", "security"],
+      output: ".vibecheck",
+      policy: {
+        allowlist: { domains: [], packages: [] },
+        ignore: { 
+          paths: [
+            "node_modules", 
+            "__tests__", 
+            "*.test.*", 
+            "*.spec.*",
+            ...(frameworkConfig.ignorePaths || [])
+          ] 
+        },
+      },
+      thresholds: {
+        minScore: 70,
+        maxBlockers: 0,
+        maxWarnings: 10,
+      },
+      ...(frameworkConfig.extra || {}),
+    };
+    
+    if (opts.dryRun) {
+      printSetupStep('config.json', 'dry-run', `would create (framework: ${config.framework})`);
+      console.log(`  ${c.dim}Config preview:${c.reset}`);
+      console.log(JSON.stringify(config, null, 2));
+    } else {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      printSetupStep('config.json', 'success', `configuration created (framework: ${config.framework})`);
+      filesCreated.push('.vibecheck/config.json');
+    }
+  } else {
+    printSetupStep('config.json', 'exists', 'already exists');
+  }
+  
+  // 3. Generate truthpack
+  logStep('Generating truthpack');
+  if (!opts.dryRun) {
+    startSpinner('Building truthpack...', colors.accent);
+    try {
+      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);
+      // 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');
+  }
+  
+  // 4. Generate contracts
+  logStep('Creating contracts');
+  const contractsDir = path.join(vibecheckDir, "contracts");
+  
+  // Routes contract
+  const routeContractPath = path.join(contractsDir, "routes.contract.json");
+  if (!fs.existsSync(routeContractPath)) {
+    const routeContract = {
+      version: "1.0.0",
+      generatedAt: new Date().toISOString(),
+      routes: [],
+      description: "Route contract - populated by scan",
+    };
+    if (opts.dryRun) {
+      printSetupStep('routes.contract.json', 'dry-run', 'would create');
+    } else {
+      fs.writeFileSync(routeContractPath, JSON.stringify(routeContract, null, 2));
+      printSetupStep('routes.contract.json', 'success', 'route contract created');
+      filesCreated.push('.vibecheck/contracts/routes.contract.json');
+    }
+  }
+  
+  // Env contract
+  const envContractPath = path.join(contractsDir, "env.contract.json");
+  if (!fs.existsSync(envContractPath)) {
+    const envContract = {
+      version: "1.0.0",
+      generatedAt: new Date().toISOString(),
+      required: [],
+      optional: [],
+      description: "Environment contract - populated by scan",
+    };
+    if (opts.dryRun) {
+      printSetupStep('env.contract.json', 'dry-run', 'would create');
+    } else {
+      fs.writeFileSync(envContractPath, JSON.stringify(envContract, null, 2));
+      printSetupStep('env.contract.json', 'success', 'env contract created');
+      filesCreated.push('.vibecheck/contracts/env.contract.json');
+    }
+  }
+  
+  // 5. Generate IDE rules (MDC for Cursor, rules for others)
+  logStep('Generating IDE rules');
+  if (!opts.dryRun) {
+    startSpinner('Generating IDE rules...', colors.accent);
+    try {
+      const { runContext } = require("./runContext");
+      await runContext(["--path", targetDir, "--quiet"]);
+      stopSpinner('IDE rules generated', true);
+      filesCreated.push('.cursor/rules/', '.windsurf/', '.github/copilot-instructions.md');
+    } catch (e) {
+      stopSpinner('IDE rules generation failed', false);
+      if (!opts.json) {
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${e.message}`);
+        console.log(`  ${c.dim}Run 'vibecheck context' manually to generate IDE rules${c.reset}`);
+      }
+      // Don't throw - IDE rules are optional
+    }
+  } else {
+    printSetupStep('IDE rules', 'dry-run', 'would generate via vibecheck context');
+  }
+  
+  // 6. Create .vibecheckrc at project root (create both for compatibility)
+  logStep('Creating root config');
+  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', '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
+  logStep('Updating .gitignore');
+  const gitignorePath = path.join(targetDir, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    let gitignore = fs.readFileSync(gitignorePath, "utf-8");
+    const additions = [];
+    if (!gitignore.includes(".vibecheck/results/")) additions.push(".vibecheck/results/");
+    if (!gitignore.includes(".vibecheck/runs/")) additions.push(".vibecheck/runs/");
+    if (!gitignore.includes(".vibecheck/checkpoints/")) additions.push(".vibecheck/checkpoints/");
+    
+    if (additions.length > 0) {
+      if (opts.dryRun) {
+        printSetupStep('.gitignore', 'dry-run', `would add: ${additions.join(', ')}`);
+      } else {
+        gitignore += `\n# vibecheck (generated outputs)\n${additions.join("\n")}\n`;
+        fs.writeFileSync(gitignorePath, gitignore);
+        printSetupStep('.gitignore', 'success', 'updated with vibecheck paths');
+      }
+    }
+  }
+  
+  // Return both filesCreated and detection for use in main function
+  return { filesCreated, detection };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONNECT MODE SETUP - GitHub integration
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runConnectSetup(targetDir, projectName, opts, filesCreated) {
+  // Check entitlement
+  const entitlements = require("./lib/entitlements-v2");
+  const access = await entitlements.enforce("init.connect", { silent: true });
+  
+  if (!access.allowed) {
+    console.log();
+    console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${c.bold}--connect requires STARTER plan${c.reset}`);
+    console.log(`  ${c.dim}Upgrade at: https://vibecheckai.dev/pricing${c.reset}`);
+    console.log();
+    console.log(`  ${c.dim}Local setup completed. Run 'vibecheck init --connect' after upgrading.${c.reset}`);
+    return filesCreated;
+  }
+  
+  printSection('GITHUB INTEGRATION', ICONS.ci);
+  console.log();
+  
+  // 1. Create GitHub workflows directory
+  const workflowsDir = path.join(targetDir, ".github", "workflows");
+  if (!fs.existsSync(workflowsDir)) {
+    fs.mkdirSync(workflowsDir, { recursive: true });
+  }
+  
+  // 2. Copy main workflow template
+  const mainWorkflowPath = path.join(workflowsDir, "vibecheck.yml");
+  if (!fs.existsSync(mainWorkflowPath)) {
+    // Read template
+    const templatePath = path.join(__dirname, "..", "..", "templates", "github-actions", "vibecheck.yml");
+    if (fs.existsSync(templatePath)) {
+      fs.copyFileSync(templatePath, mainWorkflowPath);
+      printSetupStep('vibecheck.yml', 'success', 'main workflow created');
+      filesCreated.push('.github/workflows/vibecheck.yml');
+    } else {
+      // Inline template as fallback
+      const workflow = `# Vibecheck CI/CD Workflow
+name: Vibecheck
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+jobs:
+  vibecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm ci
+      - run: npx vibecheck scan --json > .vibecheck/results/scan.json
+      - run: npx vibecheck ship --ci
+`;
+      fs.writeFileSync(mainWorkflowPath, workflow);
+      printSetupStep('vibecheck.yml', 'success', 'main workflow created');
+      filesCreated.push('.github/workflows/vibecheck.yml');
+    }
+  } else {
+    printSetupStep('vibecheck.yml', 'exists', 'already exists');
+  }
+  
+  // 3. Copy PR workflow template
+  const prWorkflowPath = path.join(workflowsDir, "vibecheck-pr.yml");
+  if (!fs.existsSync(prWorkflowPath)) {
+    const templatePath = path.join(__dirname, "..", "..", "templates", "github-actions", "vibecheck-pr.yml");
+    if (fs.existsSync(templatePath)) {
+      fs.copyFileSync(templatePath, prWorkflowPath);
+      printSetupStep('vibecheck-pr.yml', 'success', 'PR workflow created');
+      filesCreated.push('.github/workflows/vibecheck-pr.yml');
+    }
+  }
+  
+  // 4. Provide setup instructions
+  console.log();
+  console.log(`  ${colors.info}${ICONS.info}${c.reset} ${c.bold}GitHub Setup Required:${c.reset}`);
+  console.log(`     1. Add ${c.cyan}VIBECHECK_API_KEY${c.reset} to repository secrets`);
+  console.log(`     2. Push to trigger first workflow run`);
+  console.log();
+  
+  return filesCreated;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN INIT FUNCTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runInit(args) {
+  const opts = parseArgs(args);
+  
+  if (opts.help) {
+    printHelp(shouldShowBanner(opts));
+    return 0;
+  }
+
+  // --quick mode runs local setup with non-interactive defaults
+  if (opts.quick) {
+    opts.local = true;
+    opts.nonInteractive = true;
+    // Continue with normal init flow below
+  }
+
+  const targetDir = path.resolve(opts.path);
+  const projectName = path.basename(targetDir);
+  let bannerPrinted = false;
+
+  // Enterprise mode - comprehensive setup
+  const useEnterprise = opts.enterprise || opts.ci || opts.compliance || 
+                        opts.team || opts.mcp || opts.detect;
+  
+  if (EnterpriseInit && useEnterprise && !opts.local && !opts.connect) {
+    if (shouldShowBanner(opts)) {
+      printBanner();
+      bannerPrinted = true;
+      printEnterpriseHeader(opts);
+      
+      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+      console.log();
+    }
+    
+    const enterprise = new EnterpriseInit(targetDir, opts);
+    return await enterprise.run();
+  }
+
+  // Detect-only mode (quick detection report)
+  if (opts.detect) {
+    if (shouldShowBanner(opts)) {
+      printBanner();
+      bannerPrinted = true;
+      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+    }
+    
+    startSpinner('Detecting project configuration...', colors.accent);
+    
+    try {
+      const { detectAll } = require("./lib/enterprise-detect");
+      const detection = detectAll(targetDir);
+      stopSpinner('Detection complete', true);
+      if (!opts.json) {
+        printDetectionResults(detection);
+        console.log();
+        console.log(`  ${c.dim}Full JSON output:${c.reset}`);
+      }
+      console.log(JSON.stringify(detection, null, 2));
+    } catch (e) {
+      stopSpinner('Detection failed', false);
+      console.log(`  ${colors.error}Error:${c.reset} ${e.message}`);
+    }
+    return 0;
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // NEW: --local and --connect modes
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  // Interactive wizard mode
+  if (opts.wizard && InitWizard) {
+    if (shouldShowBanner(opts) && !bannerPrinted) {
+      printBanner();
+      bannerPrinted = true;
+    }
+    const wizard = new InitWizard(targetDir, opts);
+    return await wizard.run();
+  }
+  
+  // Repair mode - fix partial state
+  if (opts.repair) {
+    if (shouldShowBanner(opts) && !bannerPrinted) {
+      printBanner();
+      bannerPrinted = true;
+      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+      console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+      console.log(`  ${c.dim}Mode:${c.reset}     ${colors.accent}Repair${c.reset}`);
+      console.log();
+    }
+    return await runRepairMode(targetDir, projectName, opts);
+  }
+  
+  // Print banner only once (not already printed in enterprise/detect modes)
+  if (shouldShowBanner(opts) && !bannerPrinted) {
+    printBanner();
+    bannerPrinted = true;
+    
+    const mode = opts.connect ? 'Local + Connect' : 'Local';
+    const tierBadge = opts.connect ? `${c.cyan}[STARTER]${c.reset}` : `${c.green}[FREE]${c.reset}`;
+    
+    console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+    console.log(`  ${c.dim}Path:${c.reset}     ${targetDir}`);
+    console.log(`  ${c.dim}Mode:${c.reset}     ${colors.accent}${mode}${c.reset} ${tierBadge}`);
+    if (opts.dryRun) {
+      console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${c.bold}DRY-RUN MODE${c.reset} - No files will be created`);
+    }
+  }
+  
+  let filesCreated = [];
+  let detection = null; // Declare detection in main function scope
+  const result = {
+    success: true,
+    project: projectName,
+    path: targetDir,
+    mode: opts.connect ? 'connect' : 'local',
+    filesCreated: [],
+    errors: [],
+    dryRun: opts.dryRun,
+  };
+  
+  // Always run local setup first
+  if (opts.local || opts.connect) {
+    try {
+      // 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) {
+        console.log(`  ${colors.error}${ICONS.cross}${c.reset} Local setup error: ${e.message}`);
+        if (opts.verbose) {
+          console.log(`  ${c.dim}Stack: ${e.stack}${c.reset}`);
+        }
+        console.log(`  ${colors.info}${ICONS.info}${c.reset} Run ${c.cyan}vibecheck init --repair${c.reset} to fix partial state`);
+      }
+      // 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;
+      }
+    }
+  }
+  
+  // Run connect setup if requested
+  if (opts.connect) {
+    try {
+      filesCreated = await runConnectSetup(targetDir, projectName, opts, filesCreated);
+    } catch (e) {
+      result.errors.push({ step: 'connect', error: e.message, stack: e.stack });
+      if (!opts.json) {
+        console.log(`  ${colors.error}${ICONS.cross}${c.reset} Connect setup error: ${e.message}`);
+        if (opts.verbose) {
+          console.log(`  ${c.dim}Stack: ${e.stack}${c.reset}`);
+        }
+      }
+      if (!opts.dryRun) {
+        return EXIT.INTERNAL_ERROR;
+      }
+    }
+  }
+  
+  // Git hooks if requested
+  if (opts.gitHooks) {
+    const huskyDir = path.join(targetDir, ".husky");
+    if (!fs.existsSync(huskyDir)) {
+      fs.mkdirSync(huskyDir, { recursive: true });
+    }
+    const prePushHook = `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+echo "🚦 Running vibecheck gate..."
+npx vibecheck ship --ci
+
+if [ $? -ne 0 ]; then
+  echo "❌ Push blocked: Gate failed!"
+  exit 1
+fi
+`;
+    fs.writeFileSync(path.join(huskyDir, "pre-push"), prePushHook, { mode: 0o755 });
+    if (!opts.json) {
+      printSetupStep('.husky/pre-push', 'success', 'git hook installed');
+    }
+    filesCreated.push('.husky/pre-push');
+  }
+  
+  result.filesCreated = filesCreated;
+  
+  // JSON output
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.errors.length > 0 ? 1 : 0;
+  }
+  
+  // Success card
+  const mode = opts.connect ? 'Local + Connect' : 'Local Setup';
+  printSuccessCard(projectName, mode, filesCreated.length);
+  
+  // Generate dependency graph
+  if (!opts.dryRun) {
+    if (!opts.json) {
+      startSpinner('Generating dependency graph...', colors.accent);
+    }
+    try {
+      const { buildDependencyGraph, generateHtmlVisualization } = require("./context/dependency-graph");
+      const depGraph = buildDependencyGraph(targetDir);
+      const htmlViz = generateHtmlVisualization(depGraph, { maxNodes: 200 });
+      const graphPath = path.join(targetDir, ".vibecheck", "dependency-graph.html");
+      fs.writeFileSync(graphPath, htmlViz);
+      filesCreated.push('.vibecheck/dependency-graph.html');
+      if (!opts.json) {
+        stopSpinner('Dependency graph generated', true);
+      }
+    } catch (e) {
+      if (!opts.json) {
+        stopSpinner('Dependency graph skipped', false);
+        console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${e.message}`);
+      }
+    }
+  } else {
+    printSetupStep('dependency-graph.html', 'dry-run', 'would generate');
+  }
+  
+  // Init summary
+  printSection('INIT SUMMARY', ICONS.check);
+  console.log();
+  console.log(`  ${colors.success}${ICONS.check}${c.reset} .vibecheck/ structure created`);
+  console.log(`  ${colors.success}${ICONS.check}${c.reset} Truthpack generated`);
+  console.log(`  ${colors.success}${ICONS.check}${c.reset} Contracts initialized`);
+  console.log(`  ${colors.success}${ICONS.check}${c.reset} IDE rules generated`);
+  console.log(`  ${colors.success}${ICONS.check}${c.reset} Dependency graph generated`);
+  if (opts.connect) {
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} GitHub Actions workflows installed`);
+  }
+  console.log();
+  
+  // Show dependency graph location
+  const graphPath = path.join(targetDir, ".vibecheck", "dependency-graph.html");
+  if (fs.existsSync(graphPath)) {
+    console.log(`  ${colors.info}${ICONS.info}${c.reset} ${c.bold}Dependency Graph:${c.reset}`);
+    console.log(`     ${c.cyan}file://${graphPath.replace(/\\/g, '/')}${c.reset}`);
+    console.log();
+  }
+  
+  // Save init state for repair mode
+  if (!opts.dryRun) {
+    saveInitState(targetDir, {
+      timestamp: new Date().toISOString(),
+      mode: opts.connect ? 'connect' : 'local',
+      filesCreated,
+      errors: result.errors,
+      detection: detection ? {
+        frameworks: Object.keys(detection.frameworks || {}).filter(k => detection.frameworks[k].detected),
+        checks: detection.checks || [],
+      } : null,
+    });
+  }
+  
+  // Post-init validation
+  if (opts.verify && !opts.dryRun) {
+    const validationResult = await verifyInitSetup(targetDir, opts);
+    if (!validationResult.success && !opts.json) {
+      console.log();
+      console.log(`  ${colors.warning}${ICONS.warning}${c.reset} ${c.bold}Validation Issues Found:${c.reset}`);
+      for (const issue of validationResult.issues) {
+        console.log(`     ${c.dim}•${c.reset} ${issue}`);
+      }
+      console.log();
+    }
+  }
+  
+  // Framework-specific recommendations
+  if (detection && !opts.json && !opts.dryRun) {
+    printFrameworkRecommendations(detection, opts);
+  }
+  
+  // Next steps
+  printNextSteps({ hasCI: opts.connect, mode: opts.connect ? 'connect' : 'local' });
+
+  return 0;
+}
+
+module.exports = { runInit };