vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/runKickoff.js

@@ -0,0 +1,878 @@
+/**
+ * vibecheck kickoff - First Run Dopamine
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 60 SECONDS TO VALUE. KNOWS WHAT TO DO NEXT.
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * Goal: User sees value and knows exactly what to do next in under 60 seconds.
+ * 
+ * Flow: link → forge → audit → (optional) ship
+ * 
+ * Magic:
+ *   • Auto-detects intent (frontend? API? full-stack?)
+ *   • Adapts checks to project type
+ *   • Produces shareable summary
+ *   • Clear next steps based on results
+ * 
+ * @version 2.0.0
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+const { EXIT } = require("./lib/exit-codes");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const VERSION = "2.0.0";
+const SIXTY_SECONDS = 60000;
+
+// Project intent types
+const INTENT = {
+  FRONTEND: "frontend",
+  API: "api",
+  FULLSTACK: "fullstack",
+  STATIC: "static",
+  LIBRARY: "library",
+  UNKNOWN: "unknown",
+};
+
+// Intent detection markers
+const INTENT_MARKERS = {
+  frontend: [
+    "next", "react", "vue", "@vue/cli", "svelte", "@sveltejs/kit",
+    "nuxt", "@remix-run/react", "gatsby", "vite", "create-react-app",
+    "angular", "@angular/core", "solid-js", "qwik",
+  ],
+  api: [
+    "express", "fastify", "@nestjs/core", "hono", "koa", "@hapi/hapi",
+    "restify", "polka", "micro", "@trpc/server", "graphql-yoga",
+  ],
+  library: [
+    "tsup", "rollup", "microbundle", "unbuild", "tsdx",
+  ],
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UNIFIED CLI OUTPUT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+let _cliOutput = null;
+
+function getCliOutput() {
+  if (!_cliOutput) _cliOutput = require("./lib/unified-cli-output");
+  return _cliOutput;
+}
+
+// Get styling from unified module (with fallback)
+function getStyles() {
+  try {
+    const cli = getCliOutput();
+    return { c: cli.ansi, sym: cli.sym };
+  } catch {
+    // Fallback if unified module not available
+    const SUPPORTS_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+    return {
+      c: SUPPORTS_COLOR ? {
+        reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+        red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m",
+        cyan: "\x1b[36m", gray: "\x1b[90m", magenta: "\x1b[35m",
+      } : Object.fromEntries(["reset", "bold", "dim", "red", "green", "yellow", "cyan", "gray", "magenta"].map(k => [k, ""])),
+      sym: {
+        check: "✓", cross: "✗", warning: "⚠", arrow: "→",
+        rocket: "🚀", brain: "🧠", search: "🔍", link: "🔗",
+        party: "🎉", target: "🎯", sparkle: "✨", lightning: "⚡",
+        boxTL: "╔", boxTR: "╗", boxBL: "╚", boxBR: "╝", boxH: "═", boxV: "║",
+      },
+    };
+  }
+}
+
+const { c, sym } = getStyles();
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BANNER (uses unified CLI output)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printWelcomeBanner(projectName, intent, projectRoot) {
+  const intentLabel = {
+    [INTENT.FRONTEND]: "Frontend App",
+    [INTENT.API]: "API Service",
+    [INTENT.FULLSTACK]: "Full-Stack App",
+    [INTENT.STATIC]: "Static Site",
+    [INTENT.LIBRARY]: "Library/Package",
+    [INTENT.UNKNOWN]: "Node Project",
+  }[intent] || "Project";
+
+  try {
+    const cli = getCliOutput();
+    console.log(cli.renderFullHeader("kickoff", {
+      version: VERSION,
+      tier: "FREE",
+      integrity: intentLabel.toUpperCase(),
+      target: projectRoot || process.cwd(),
+      sessionId: cli.generateSessionId(),
+    }));
+  } catch {
+    // Fallback to simple banner
+    console.log();
+    console.log(`  ${c.cyan}╭${"─".repeat(65)}╮${c.reset}`);
+    console.log(`  ${c.cyan}│${c.reset}                                                                 ${c.cyan}│${c.reset}`);
+    console.log(`  ${c.cyan}│${c.reset}   ${sym.rocket} ${c.bold}VIBECHECK KICKOFF${c.reset}                                          ${c.cyan}│${c.reset}`);
+    console.log(`  ${c.cyan}│${c.reset}   ${c.dim}60 seconds to value${c.reset}                                           ${c.cyan}│${c.reset}`);
+    console.log(`  ${c.cyan}│${c.reset}                                                                 ${c.cyan}│${c.reset}`);
+    console.log(`  ${c.cyan}│${c.reset}   ${c.bold}Project:${c.reset} ${projectName.substring(0, 40).padEnd(40)}       ${c.cyan}│${c.reset}`);
+    console.log(`  ${c.cyan}│${c.reset}   ${c.bold}Type:${c.reset}    ${intentLabel.padEnd(43)}       ${c.cyan}│${c.reset}`);
+    console.log(`  ${c.cyan}│${c.reset}                                                                 ${c.cyan}│${c.reset}`);
+    console.log(`  ${c.cyan}╰${"─".repeat(65)}╯${c.reset}`);
+    console.log();
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ARGS PARSING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function parseArgs(args) {
+  const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
+  
+  const opts = {
+    path: globalFlags.path || process.cwd(),
+    json: globalFlags.json || false,
+    ci: globalFlags.ci || false,
+    quiet: globalFlags.quiet || false,
+    verbose: globalFlags.verbose || false,
+    noBanner: globalFlags.noBanner || false,
+    help: globalFlags.help || false,
+    // Kickoff-specific
+    fast: false,        // Skip optional steps
+    noShip: false,      // Skip ship step
+    noOpen: false,      // Don't open browser
+    tier: "standard",   // Forge tier
+  };
+  
+  for (let i = 0; i < cleanArgs.length; i++) {
+    const arg = cleanArgs[i];
+    if (arg === "--fast" || arg === "-f") opts.fast = true;
+    else if (arg === "--no-ship") opts.noShip = true;
+    else if (arg === "--no-open") opts.noOpen = true;
+    else if (arg === "--tier" || arg === "-t") opts.tier = cleanArgs[++i] || "standard";
+    else if (arg.startsWith("--tier=")) opts.tier = arg.split("=")[1];
+    else if (arg === "--path" || arg === "-p") opts.path = cleanArgs[++i] || process.cwd();
+    else if (arg.startsWith("--path=")) opts.path = arg.split("=")[1];
+  }
+  
+  opts.path = path.resolve(opts.path);
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}${c.cyan}VIBECHECK KICKOFF${c.reset} - First Run Dopamine (v${VERSION})
+
+${c.bold}USAGE${c.reset}
+  ${c.cyan}vibecheck kickoff${c.reset} [options]
+
+${c.bold}DESCRIPTION${c.reset}
+  Get value in 60 seconds. Auto-detects your project type and runs the
+  optimal validation pipeline. Perfect for first-time setup.
+
+  ${c.dim}Flow: link → forge → audit → (optional) ship${c.reset}
+
+${c.bold}OPTIONS${c.reset}
+  ${c.cyan}--fast, -f${c.reset}            Skip optional checks for speed
+  ${c.cyan}--no-ship${c.reset}             Skip the ship verdict step
+  ${c.cyan}--no-open${c.reset}             Don't open summary in browser
+  ${c.cyan}--tier <tier>${c.reset}         Forge tier: minimal, standard, extended
+  ${c.cyan}--path, -p <dir>${c.reset}      Project path ${c.dim}(default: current directory)${c.reset}
+  ${c.cyan}--json${c.reset}                Output as JSON
+  ${c.cyan}--ci${c.reset}                  CI mode (non-interactive)
+  ${c.cyan}--quiet, -q${c.reset}           Suppress non-essential output
+  ${c.cyan}--help, -h${c.reset}            Show this help
+
+${c.bold}PROJECT TYPES${c.reset}
+  ${c.cyan}Frontend${c.reset}              React, Vue, Svelte, Next.js, etc.
+  ${c.cyan}API${c.reset}                   Express, Fastify, NestJS, Hono, etc.
+  ${c.cyan}Full-Stack${c.reset}            Both frontend and backend detected
+  ${c.cyan}Library${c.reset}               npm packages, shared modules
+
+${c.bold}EXAMPLES${c.reset}
+  ${c.dim}# First run${c.reset}
+  vibecheck kickoff
+
+  ${c.dim}# Fast mode (30s)${c.reset}
+  vibecheck kickoff --fast
+
+  ${c.dim}# Minimal rules tier${c.reset}
+  vibecheck kickoff --tier minimal
+
+${c.bold}EXIT CODES${c.reset}
+  ${c.green}0${c.reset}  Success - All clear
+  ${c.yellow}1${c.reset}  Warnings - Non-blocking issues found
+  ${c.red}2${c.reset}  Blockers - Issues need attention
+
+${c.dim}Documentation: https://docs.vibecheckai.dev/commands/kickoff${c.reset}
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INTENT DETECTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function detectIntent(projectRoot) {
+  const pkgPath = path.join(projectRoot, "package.json");
+  
+  if (!fs.existsSync(pkgPath)) {
+    // Check for static site markers
+    if (fs.existsSync(path.join(projectRoot, "index.html"))) {
+      return { intent: INTENT.STATIC, confidence: "high", evidence: ["index.html present"] };
+    }
+    return { intent: INTENT.UNKNOWN, confidence: "low", evidence: ["No package.json"] };
+  }
+  
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return { intent: INTENT.UNKNOWN, confidence: "low", evidence: ["Invalid package.json"] };
+  }
+  
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const depNames = Object.keys(deps);
+  const evidence = [];
+  
+  // Check for frontend markers
+  const hasFrontend = INTENT_MARKERS.frontend.some(marker => {
+    if (depNames.includes(marker)) {
+      evidence.push(`${marker} dependency`);
+      return true;
+    }
+    return false;
+  });
+  
+  // Check for API markers
+  const hasAPI = INTENT_MARKERS.api.some(marker => {
+    if (depNames.includes(marker)) {
+      evidence.push(`${marker} dependency`);
+      return true;
+    }
+    return false;
+  });
+  
+  // Check for library markers
+  const isLibrary = INTENT_MARKERS.library.some(marker => {
+    if (depNames.includes(marker)) {
+      evidence.push(`${marker} (library tooling)`);
+      return true;
+    }
+    return false;
+  }) || pkg.main || pkg.module || pkg.exports;
+  
+  // Determine intent
+  if (hasFrontend && hasAPI) {
+    return { intent: INTENT.FULLSTACK, confidence: "high", evidence };
+  }
+  if (hasFrontend) {
+    return { intent: INTENT.FRONTEND, confidence: "high", evidence };
+  }
+  if (hasAPI) {
+    return { intent: INTENT.API, confidence: "high", evidence };
+  }
+  if (isLibrary) {
+    evidence.push("Library structure detected");
+    return { intent: INTENT.LIBRARY, confidence: "medium", evidence };
+  }
+  
+  // Fallback checks
+  if (fs.existsSync(path.join(projectRoot, "src", "pages")) ||
+      fs.existsSync(path.join(projectRoot, "pages")) ||
+      fs.existsSync(path.join(projectRoot, "app"))) {
+    evidence.push("pages/app directory structure");
+    return { intent: INTENT.FRONTEND, confidence: "medium", evidence };
+  }
+  
+  if (fs.existsSync(path.join(projectRoot, "src", "routes")) ||
+      fs.existsSync(path.join(projectRoot, "routes"))) {
+    evidence.push("routes directory structure");
+    return { intent: INTENT.API, confidence: "medium", evidence };
+  }
+  
+  return { intent: INTENT.UNKNOWN, confidence: "low", evidence: ["Generic Node.js project"] };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STEP RUNNERS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runLinkStep(projectRoot, opts) {
+  const start = Date.now();
+  
+  try {
+    const { runLink } = require("./runLink");
+    const result = await runLink(["--path", projectRoot, "--quiet"]);
+    
+    // Load the generated receipt
+    const receiptPath = path.join(projectRoot, ".vibecheck", "project.json");
+    let receipt = null;
+    if (fs.existsSync(receiptPath)) {
+      try {
+        receipt = JSON.parse(fs.readFileSync(receiptPath, "utf-8"));
+      } catch {}
+    }
+    
+    return {
+      success: result === 0 || result === 1 || result === 12, // 12 = already linked
+      duration: Date.now() - start,
+      alreadyLinked: result === 12,
+      receipt,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: err.message,
+    };
+  }
+}
+
+async function runForgeStep(projectRoot, opts, intent) {
+  const start = Date.now();
+  
+  try {
+    const { runForge } = require("./runForge");
+    
+    // Adjust tier based on intent
+    let tier = opts.tier;
+    if (opts.fast) {
+      tier = "minimal";
+    } else if (intent === INTENT.API || intent === INTENT.FULLSTACK) {
+      tier = tier === "minimal" ? "standard" : tier;
+    }
+    
+    const args = ["--path", projectRoot, "--tier", tier];
+    if (opts.quiet || opts.ci) args.push("--quiet");
+    
+    const result = await runForge(args);
+    
+    // Count generated files
+    const generated = [];
+    const cursorRules = path.join(projectRoot, ".cursorrules");
+    if (fs.existsSync(cursorRules)) generated.push(".cursorrules");
+    
+    const cursorDir = path.join(projectRoot, ".cursor", "rules");
+    if (fs.existsSync(cursorDir)) {
+      const files = fs.readdirSync(cursorDir).filter(f => f.endsWith(".mdc"));
+      generated.push(...files.map(f => `.cursor/rules/${f}`));
+    }
+    
+    return {
+      success: result === 0,
+      duration: Date.now() - start,
+      tier,
+      generated,
+      rulesCount: generated.length,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: err.message,
+    };
+  }
+}
+
+async function runAuditStep(projectRoot, opts, intent) {
+  const start = Date.now();
+  
+  try {
+    // Try new runAudit first, fall back to runScan
+    let runAuditFn;
+    try {
+      runAuditFn = require("./runAudit").runAudit;
+    } catch {
+      runAuditFn = require("./runScan").runScan;
+    }
+    
+    const args = ["--path", projectRoot];
+    if (opts.fast) args.push("--fast");
+    if (opts.quiet || opts.ci) args.push("--quiet");
+    
+    // Focus on relevant checks for intent
+    if (intent === INTENT.FRONTEND) {
+      args.push("--skip", "auth,integrations");
+    } else if (intent === INTENT.API) {
+      args.push("--skip", "components,ui");
+    }
+    
+    const result = await runAuditFn(args);
+    
+    // Load results
+    let auditData = null;
+    const latestPath = path.join(projectRoot, ".vibecheck", "results", "latest.json");
+    const auditPath = path.join(projectRoot, ".vibecheck", "audit", "latest.json");
+    
+    if (fs.existsSync(auditPath)) {
+      try { auditData = JSON.parse(fs.readFileSync(auditPath, "utf-8")); } catch {}
+    } else if (fs.existsSync(latestPath)) {
+      try { auditData = JSON.parse(fs.readFileSync(latestPath, "utf-8")); } catch {}
+    }
+    
+    const findings = auditData?.result?.findings || auditData?.findings || [];
+    const blockers = findings.filter(f => 
+      f.severity === "BLOCK" || f.severity === "critical" || f.severity === "high"
+    );
+    const warnings = findings.filter(f => 
+      f.severity === "WARN" || f.severity === "warning" || f.severity === "medium"
+    );
+    
+    return {
+      success: true,
+      duration: Date.now() - start,
+      exitCode: result,
+      findings: findings.length,
+      blockers: blockers.length,
+      warnings: warnings.length,
+      topFindings: findings.slice(0, 5).map(f => ({
+        type: f.type || f.rule || "issue",
+        severity: f.severity,
+        message: f.message || f.description,
+        file: f.file || f.location?.file,
+      })),
+    };
+  } catch (err) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: err.message,
+    };
+  }
+}
+
+async function runShipStep(projectRoot, opts) {
+  const start = Date.now();
+  
+  try {
+    const { runShip } = require("./runShip");
+    const args = ["--path", projectRoot, "--no-banner", "--quiet"];
+    
+    const result = await runShip(args);
+    
+    // Load ship results
+    const shipPath = path.join(projectRoot, ".vibecheck", "last_ship.json");
+    let shipData = null;
+    if (fs.existsSync(shipPath)) {
+      try { shipData = JSON.parse(fs.readFileSync(shipPath, "utf-8")); } catch {}
+    }
+    
+    const verdict = shipData?.meta?.verdict || 
+      (result === 0 ? "SHIP" : result === 1 ? "WARN" : "BLOCK");
+    const score = shipData?.proofGraph?.summary?.overallScore || 
+      (100 - (shipData?.proofGraph?.summary?.riskScore || 30));
+    
+    return {
+      success: true,
+      duration: Date.now() - start,
+      exitCode: result,
+      verdict,
+      score: Math.round(score),
+    };
+  } catch (err) {
+    return {
+      success: false,
+      duration: Date.now() - start,
+      error: err.message,
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// OUTPUT RENDERING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function printStep(num, total, icon, name, description) {
+  const progress = `[${num}/${total}]`;
+  process.stdout.write(`  ${c.cyan}${progress}${c.reset} ${icon} ${name}... ${c.dim}${description}${c.reset}`);
+}
+
+function printStepResult(result, detail = "") {
+  const detailStr = detail ? ` ${c.dim}${detail}${c.reset}` : "";
+  if (result.success) {
+    console.log(` ${c.green}${sym.check}${c.reset}${detailStr}`);
+  } else if (result.skipped) {
+    console.log(` ${c.yellow}→${c.reset} ${c.dim}skipped${c.reset}`);
+  } else {
+    console.log(` ${c.red}${sym.cross}${c.reset}${detailStr}`);
+  }
+}
+
+function printSummaryBox(results, intent, totalDuration) {
+  const { link, forge, audit, ship } = results;
+  
+  // Determine overall verdict
+  let verdict, verdictIcon, verdictColor;
+  if (ship) {
+    verdict = ship.verdict;
+    verdictIcon = ship.verdict === "SHIP" ? sym.rocket : ship.verdict === "WARN" ? sym.warning : sym.cross;
+    verdictColor = ship.verdict === "SHIP" ? c.green : ship.verdict === "WARN" ? c.yellow : c.red;
+  } else if (audit) {
+    if (audit.blockers > 0) {
+      verdict = "NEEDS ATTENTION";
+      verdictIcon = sym.target;
+      verdictColor = c.yellow;
+    } else {
+      verdict = "LOOKING GOOD";
+      verdictIcon = sym.heart;
+      verdictColor = c.green;
+    }
+  } else {
+    verdict = "SETUP COMPLETE";
+    verdictIcon = sym.check;
+    verdictColor = c.green;
+  }
+  
+  console.log();
+  console.log(`  ${c.cyan}╭${"─".repeat(65)}╮${c.reset}`);
+  console.log(`  ${c.cyan}│${c.reset}                                                                 ${c.cyan}│${c.reset}`);
+  console.log(`  ${c.cyan}│${c.reset}   ${verdictIcon} ${c.bold}${verdict}${c.reset}${" ".repeat(Math.max(0, 55 - verdict.length))}${c.cyan}│${c.reset}`);
+  console.log(`  ${c.cyan}│${c.reset}                                                                 ${c.cyan}│${c.reset}`);
+  console.log(`  ${c.cyan}├${"─".repeat(65)}┤${c.reset}`);
+  
+  // Stats row
+  const stats = [];
+  if (forge?.rulesCount) stats.push(`${forge.rulesCount} rules`);
+  if (audit?.findings !== undefined) stats.push(`${audit.findings} findings`);
+  if (audit?.blockers) stats.push(`${c.red}${audit.blockers} blockers${c.reset}`);
+  if (ship?.score) stats.push(`${ship.score}/100 score`);
+  
+  const statsLine = stats.join(" ${c.dim}•${c.reset} ");
+  console.log(`  ${c.cyan}│${c.reset}                                                                 ${c.cyan}│${c.reset}`);
+  console.log(`  ${c.cyan}│${c.reset}   ${statsLine}${" ".repeat(Math.max(0, 62 - statsLine.replace(/\x1b\[[0-9;]*m/g, "").length))}${c.cyan}│${c.reset}`);
+  console.log(`  ${c.cyan}│${c.reset}   ${c.dim}Completed in ${(totalDuration / 1000).toFixed(1)}s${c.reset}                                       ${c.cyan}│${c.reset}`);
+  console.log(`  ${c.cyan}│${c.reset}                                                                 ${c.cyan}│${c.reset}`);
+  console.log(`  ${c.cyan}╰${"─".repeat(65)}╯${c.reset}`);
+}
+
+function printTopFindings(findings) {
+  if (!findings || findings.length === 0) return;
+  
+  console.log();
+  console.log(`  ${c.bold}Top Findings:${c.reset}`);
+  console.log();
+  
+  findings.slice(0, 3).forEach((f, i) => {
+    const icon = f.severity === "BLOCK" || f.severity === "critical" ? c.red + sym.cross : c.yellow + sym.warning;
+    const msg = (f.message || f.type).substring(0, 55);
+    console.log(`  ${icon}${c.reset} ${msg}`);
+    if (f.file) {
+      const file = path.basename(f.file);
+      console.log(`    ${c.dim}${file}${c.reset}`);
+    }
+  });
+}
+
+function printNextSteps(results, intent, opts) {
+  const { audit, ship, forge } = results;
+  
+  console.log();
+  console.log(`  ${c.bold}${sym.arrow} Next Steps:${c.reset}`);
+  console.log();
+  
+  // Determine what to suggest based on results
+  if (audit?.blockers > 0) {
+    console.log(`  ${c.cyan}1.${c.reset} Fix ${audit.blockers} blocker(s):`);
+    console.log(`     ${c.dim}vibecheck audit --verbose${c.reset}  ${c.dim}# See full details${c.reset}`);
+    console.log(`     ${c.dim}vibecheck fix${c.reset}              ${c.dim}# Auto-fix suggestions${c.reset}`);
+    console.log();
+    console.log(`  ${c.cyan}2.${c.reset} Then verify:`);
+    console.log(`     ${c.dim}vibecheck ship${c.reset}             ${c.dim}# Get ship verdict${c.reset}`);
+  } else if (!ship && !opts.noShip) {
+    console.log(`  ${c.cyan}1.${c.reset} Get your ship verdict:`);
+    console.log(`     ${c.dim}vibecheck ship${c.reset}             ${c.dim}# Production readiness check${c.reset}`);
+    console.log();
+    console.log(`  ${c.cyan}2.${c.reset} Before deploying:`);
+    console.log(`     ${c.dim}vibecheck launch${c.reset}           ${c.dim}# Full pre-release wizard${c.reset}`);
+  } else if (ship?.verdict === "SHIP") {
+    console.log(`  ${c.green}${sym.party} Ready to deploy!${c.reset}`);
+    console.log();
+    console.log(`  ${c.cyan}1.${c.reset} Before release:`);
+    console.log(`     ${c.dim}vibecheck launch${c.reset}           ${c.dim}# Full pre-release validation${c.reset}`);
+    console.log();
+    console.log(`  ${c.cyan}2.${c.reset} Ongoing protection:`);
+    console.log(`     ${c.dim}vibecheck shield${c.reset}           ${c.dim}# Enable agent firewall${c.reset}`);
+  } else if (ship?.verdict === "WARN") {
+    console.log(`  ${c.cyan}1.${c.reset} Review warnings:`);
+    console.log(`     ${c.dim}vibecheck audit --verbose${c.reset}  ${c.dim}# See all findings${c.reset}`);
+    console.log();
+    console.log(`  ${c.cyan}2.${c.reset} When ready:`);
+    console.log(`     ${c.dim}vibecheck launch${c.reset}           ${c.dim}# Pre-release validation${c.reset}`);
+  } else {
+    console.log(`  ${c.cyan}1.${c.reset} Fix blockers first:`);
+    console.log(`     ${c.dim}vibecheck audit --verbose${c.reset}  ${c.dim}# See details${c.reset}`);
+    console.log(`     ${c.dim}vibecheck fix${c.reset}              ${c.dim}# Get fix suggestions${c.reset}`);
+  }
+  
+  // Add forge tip if rules were generated
+  if (forge?.rulesCount > 0) {
+    console.log();
+    console.log(`  ${c.dim}${sym.brain} ${forge.rulesCount} AI rules generated in .cursorrules${c.reset}`);
+    console.log(`  ${c.dim}   Open your IDE to see them in action!${c.reset}`);
+  }
+  
+  console.log();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SHAREABLE SUMMARY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function generateShareableSummary(results, intent, projectName, duration) {
+  const { link, forge, audit, ship } = results;
+  const timestamp = new Date().toISOString();
+  const runId = `kickoff-${crypto.randomBytes(4).toString("hex")}`;
+  
+  // Determine overall status
+  let status;
+  if (ship?.verdict === "SHIP") status = "ready";
+  else if (ship?.verdict === "WARN") status = "warnings";
+  else if (audit?.blockers > 0) status = "blockers";
+  else status = "setup";
+  
+  const summary = {
+    version: VERSION,
+    runId,
+    timestamp,
+    duration: {
+      ms: duration,
+      formatted: `${(duration / 1000).toFixed(1)}s`,
+    },
+    project: {
+      name: projectName,
+      intent: intent.intent,
+      confidence: intent.confidence,
+    },
+    status,
+    steps: {
+      link: link ? { success: link.success, duration: link.duration, alreadyLinked: link.alreadyLinked } : null,
+      forge: forge ? { success: forge.success, duration: forge.duration, tier: forge.tier, rulesCount: forge.rulesCount } : null,
+      audit: audit ? { success: audit.success, duration: audit.duration, findings: audit.findings, blockers: audit.blockers, warnings: audit.warnings } : null,
+      ship: ship ? { success: ship.success, duration: ship.duration, verdict: ship.verdict, score: ship.score } : null,
+    },
+    summary: {
+      verdict: ship?.verdict || (audit?.blockers > 0 ? "NEEDS_ATTENTION" : "SETUP_COMPLETE"),
+      score: ship?.score || null,
+      findings: audit?.findings || 0,
+      blockers: audit?.blockers || 0,
+      warnings: audit?.warnings || 0,
+      rulesGenerated: forge?.rulesCount || 0,
+    },
+  };
+  
+  return summary;
+}
+
+function saveSummary(summary, projectRoot) {
+  const outputDir = path.join(projectRoot, ".vibecheck", "kickoff");
+  fs.mkdirSync(outputDir, { recursive: true });
+  
+  // JSON summary
+  const jsonPath = path.join(outputDir, "summary.json");
+  fs.writeFileSync(jsonPath, JSON.stringify(summary, null, 2));
+  
+  // Markdown summary
+  const mdPath = path.join(outputDir, "summary.md");
+  const md = generateMarkdownSummary(summary);
+  fs.writeFileSync(mdPath, md);
+  
+  return { jsonPath, mdPath };
+}
+
+function generateMarkdownSummary(summary) {
+  const { project, steps, summary: s } = summary;
+  
+  let md = `# Kickoff Summary\n\n`;
+  md += `**Project:** ${project.name}\n`;
+  md += `**Type:** ${project.intent}\n`;
+  md += `**Date:** ${new Date(summary.timestamp).toLocaleString()}\n`;
+  md += `**Duration:** ${summary.duration.formatted}\n\n`;
+  
+  md += `## Results\n\n`;
+  md += `| Metric | Value |\n`;
+  md += `|--------|-------|\n`;
+  md += `| Verdict | ${s.verdict} |\n`;
+  if (s.score) md += `| Score | ${s.score}/100 |\n`;
+  md += `| Findings | ${s.findings} |\n`;
+  md += `| Blockers | ${s.blockers} |\n`;
+  md += `| Warnings | ${s.warnings} |\n`;
+  md += `| Rules Generated | ${s.rulesGenerated} |\n`;
+  md += `\n`;
+  
+  md += `## Steps\n\n`;
+  if (steps.link) md += `- [${steps.link.success ? "✓" : "✗"}] Link: ${steps.link.alreadyLinked ? "Already linked" : "Project bound"}\n`;
+  if (steps.forge) md += `- [${steps.forge.success ? "✓" : "✗"}] Forge: ${steps.forge.rulesCount} rules (${steps.forge.tier} tier)\n`;
+  if (steps.audit) md += `- [${steps.audit.success ? "✓" : "✗"}] Audit: ${steps.audit.findings} findings\n`;
+  if (steps.ship) md += `- [${steps.ship.success ? "✓" : "✗"}] Ship: ${steps.ship.verdict} (${steps.ship.score}/100)\n`;
+  md += `\n`;
+  
+  md += `---\n`;
+  md += `*Generated by vibecheck kickoff v${summary.version}*\n`;
+  
+  return md;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function runKickoff(args, context = {}) {
+  const startTime = Date.now();
+  const opts = parseArgs(args);
+  
+  // Help
+  if (opts.help) {
+    printHelp();
+    return EXIT.SUCCESS;
+  }
+  
+  const projectRoot = opts.path;
+  const projectName = path.basename(projectRoot);
+  
+  // Validate path
+  if (!fs.existsSync(projectRoot)) {
+    if (!opts.quiet) {
+      console.error(`${c.red}${sym.cross}${c.reset} Project path does not exist: ${projectRoot}`);
+    }
+    return EXIT.USER_ERROR;
+  }
+  
+  // Detect intent
+  const intent = detectIntent(projectRoot);
+  
+  // Show banner
+  if (!opts.quiet && !opts.ci && !opts.noBanner) {
+    printWelcomeBanner(projectName, intent.intent, projectRoot);
+    
+    if (opts.verbose && intent.evidence.length > 0) {
+      console.log(`  ${c.dim}Detected: ${intent.evidence.slice(0, 2).join(", ")}${c.reset}`);
+      console.log();
+    }
+  }
+  
+  // Build step list based on options
+  const steps = [
+    { id: "link", name: "Link", icon: sym.link, desc: "binding project", runner: runLinkStep },
+    { id: "forge", name: "Forge", icon: sym.brain, desc: "generating AI rules", runner: runForgeStep },
+    { id: "audit", name: "Audit", icon: sym.search, desc: "scanning for issues", runner: runAuditStep },
+  ];
+  
+  // Add ship step unless skipped or has blockers
+  if (!opts.noShip && !opts.fast) {
+    steps.push({ id: "ship", name: "Ship", icon: sym.rocket, desc: "computing verdict", runner: runShipStep });
+  }
+  
+  const results = {};
+  let exitCode = EXIT.SUCCESS;
+  
+  // Run steps
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    
+    if (!opts.quiet && !opts.ci) {
+      printStep(i + 1, steps.length, step.icon, step.name, step.desc);
+    }
+    
+    const result = await step.runner(projectRoot, opts, intent.intent);
+    results[step.id] = result;
+    
+    // Format detail for output
+    let detail = "";
+    if (step.id === "link" && result.alreadyLinked) detail = "(already linked)";
+    if (step.id === "forge" && result.rulesCount) detail = `(${result.rulesCount} rules)`;
+    if (step.id === "audit" && result.findings !== undefined) {
+      detail = result.blockers > 0 
+        ? `(${result.blockers} blockers)` 
+        : `(${result.findings} findings)`;
+    }
+    if (step.id === "ship" && result.verdict) detail = `(${result.verdict})`;
+    
+    if (!opts.quiet && !opts.ci) {
+      printStepResult(result, detail);
+    }
+    
+    // Check for blockers after audit - skip ship if blockers found
+    if (step.id === "audit" && result.blockers > 0 && steps.find(s => s.id === "ship")) {
+      // Remove ship step
+      const shipIndex = steps.findIndex(s => s.id === "ship");
+      if (shipIndex > i) {
+        steps.splice(shipIndex, 1);
+        if (!opts.quiet && !opts.ci) {
+          console.log(`  ${c.dim}${sym.arrow} Skipping ship (blockers found)${c.reset}`);
+        }
+      }
+    }
+    
+    // Update exit code
+    if (!result.success) {
+      exitCode = Math.max(exitCode, EXIT.WARNINGS);
+    }
+  }
+  
+  const totalDuration = Date.now() - startTime;
+  
+  // Generate summary
+  const summary = generateShareableSummary(results, intent, projectName, totalDuration);
+  const saved = saveSummary(summary, projectRoot);
+  
+  // Output
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else if (opts.ci) {
+    console.log(`VERDICT=${summary.summary.verdict}`);
+    console.log(`SCORE=${summary.summary.score || 0}`);
+    console.log(`FINDINGS=${summary.summary.findings}`);
+    console.log(`BLOCKERS=${summary.summary.blockers}`);
+    console.log(`RULES=${summary.summary.rulesGenerated}`);
+    console.log(`DURATION_MS=${totalDuration}`);
+  } else if (!opts.quiet) {
+    printSummaryBox(results, intent.intent, totalDuration);
+    
+    if (results.audit?.topFindings?.length > 0 && opts.verbose) {
+      printTopFindings(results.audit.topFindings);
+    }
+    
+    printNextSteps(results, intent.intent, opts);
+    
+    console.log(`  ${c.dim}📄 Summary saved: ${path.relative(projectRoot, saved.mdPath)}${c.reset}`);
+    console.log();
+  }
+  
+  // Determine final exit code
+  if (results.audit?.blockers > 0) {
+    exitCode = EXIT.BLOCKING;
+  } else if (results.audit?.warnings > 0 || results.ship?.verdict === "WARN") {
+    exitCode = EXIT.WARNINGS;
+  }
+  
+  return exitCode;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = { runKickoff };
+
+// Direct execution
+if (require.main === module) {
+  runKickoff(process.argv.slice(2))
+    .then(code => process.exit(code))
+    .catch(err => {
+      console.error(err);
+      process.exit(10);
+    });
+}