nairon-bench 0.4.0 → 0.5.1

package/dist/index.js

@@ -4447,8 +4447,8 @@ function defineCommand2(def) {
 
 // src/commands/scan.ts
 init_dist();
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync10 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -16067,159 +16067,261 @@ function filterAlreadyInstalled(optimizations, status) {
     return true;
   });
 }
-var QUICK_INSTALL_PRESETS = {
-  essential: [
-    {
-      id: "context7",
-      name: "Context7 MCP",
-      type: "mcp",
-      description: "Up-to-date library documentation",
-      installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http",
-      selected: true
-    },
-    {
-      id: "supermemory",
-      name: "Supermemory MCP",
-      type: "mcp",
-      description: "Persistent memory across sessions",
-      installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest",
-      selected: true
-    },
-    {
-      id: "beads",
-      name: "Beads Task Manager",
-      type: "mcp",
-      description: "Persistent task tracking",
-      installCommand: "bun add -g beads && bd init",
-      selected: true
-    }
-  ],
-  productivity: [
-    {
-      id: "claude-md",
-      name: "CLAUDE.md",
-      type: "config",
-      description: "Project context file",
-      configPath: "CLAUDE.md",
-      configContent: `# Project Instructions
-
-## Build & Test Commands
-\`\`\`bash
-bun test           # Run tests
-bun run build      # Build project
-bun run lint       # Run linter
-\`\`\`
-
-## Architecture
-Describe your project structure here.
 
-## Conventions
-- Use TypeScript
-- Write tests for new features
-- Use conventional commits
-`,
-      selected: true
-    },
-    {
-      id: "vitest",
-      name: "Vitest",
-      type: "library",
-      description: "Fast unit testing framework",
-      installCommand: "bun add -D vitest",
-      selected: true
+// src/lib/first-run.ts
+init_dist();
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join9 } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var FIRST_RUN_FLAG = join9(homedir8(), ".nairon-bench", "first-run-complete");
+var PROJECT_SCAN_MARKER = ".nairon/first-scan-complete";
+function isFirstScanInProject(projectDir) {
+  return !existsSync9(join9(projectDir, PROJECT_SCAN_MARKER));
+}
+function markProjectScanned(projectDir) {
+  const naironDir = join9(projectDir, ".nairon");
+  if (!existsSync9(naironDir)) {
+    mkdirSync4(naironDir, { recursive: true });
+  }
+  writeFileSync4(join9(projectDir, PROJECT_SCAN_MARKER), new Date().toISOString());
+}
+function detectAgent() {
+  const home = homedir8();
+  const claudeConfig = join9(home, ".claude");
+  const hasClaudeCode = existsSync9(claudeConfig);
+  const opencodeConfig = join9(home, ".config", "opencode");
+  const opencodeData = join9(home, ".local", "share", "opencode");
+  const hasOpenCode = existsSync9(opencodeConfig) || existsSync9(opencodeData);
+  const cursorConfig = join9(home, ".cursor");
+  const hasCursor = existsSync9(cursorConfig);
+  if (hasClaudeCode)
+    return "claude-code";
+  if (hasOpenCode)
+    return "opencode";
+  if (hasCursor)
+    return "cursor";
+  return "unknown";
+}
+function analyzeReadme(projectDir) {
+  const readmePath = join9(projectDir, "README.md");
+  if (!existsSync9(readmePath)) {
+    const alternatives = ["readme.md", "Readme.md", "README.MD", "README"];
+    for (const alt of alternatives) {
+      const altPath = join9(projectDir, alt);
+      if (existsSync9(altPath)) {
+        return parseReadme(readFileSync9(altPath, "utf-8"), projectDir);
+      }
     }
-  ]
-};
+    return null;
+  }
+  const content = readFileSync9(readmePath, "utf-8");
+  return parseReadme(content, projectDir);
+}
+function parseReadme(content, projectDir) {
+  let name = "Unknown Project";
+  const pkgPath = join9(projectDir, "package.json");
+  if (existsSync9(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+      if (pkg.name && !pkg.name.startsWith("@") && pkg.name !== "root") {
+        name = pkg.name;
+      }
+    } catch {}
+  }
+  if (name === "Unknown Project") {
+    const headingMatch = content.match(/^#\s+([^<\n]+)$/m);
+    if (headingMatch && headingMatch[1]) {
+      const heading = headingMatch[1].trim();
+      if (!heading.toLowerCase().includes("install") && !heading.toLowerCase().includes("getting started") && heading.length < 50) {
+        name = heading;
+      }
+    }
+  }
+  let description = "";
+  const descMatch = content.match(/^#[^#].*\n\n(.+?)(\n\n|$)/s);
+  if (descMatch && descMatch[1]) {
+    description = descMatch[1].replace(/\n/g, " ").trim().slice(0, 200);
+  }
+  const techStack = [];
+  const techPatterns = {
+    react: /\breact\b/i,
+    "next.js": /\bnext\.?js\b/i,
+    vue: /\bvue\b/i,
+    svelte: /\bsvelte\b/i,
+    typescript: /\btypescript\b/i,
+    python: /\bpython\b/i,
+    rust: /\brust\b/i,
+    go: /\bgolang?\b/i,
+    node: /\bnode\.?js\b/i,
+    bun: /\bbun\b/i,
+    deno: /\bdeno\b/i,
+    tailwind: /\btailwind\b/i,
+    prisma: /\bprisma\b/i,
+    postgres: /\bpostgres\b/i,
+    mongodb: /\bmongo\b/i,
+    redis: /\bredis\b/i,
+    docker: /\bdocker\b/i,
+    kubernetes: /\bkubernetes\b|\bk8s\b/i,
+    aws: /\baws\b/i,
+    vercel: /\bvercel\b/i,
+    cloudflare: /\bcloudflare\b/i,
+    openai: /\bopenai\b/i,
+    anthropic: /\banthropic\b|\bclaude\b/i,
+    langchain: /\blangchain\b/i,
+    convex: /\bconvex\b/i,
+    supabase: /\bsupabase\b/i,
+    firebase: /\bfirebase\b/i,
+    stripe: /\bstripe\b/i,
+    playwright: /\bplaywright\b/i,
+    vitest: /\bvitest\b/i,
+    jest: /\bjest\b/i,
+    remotion: /\bremotion\b/i
+  };
+  for (const [tech, pattern] of Object.entries(techPatterns)) {
+    if (pattern.test(content)) {
+      techStack.push(tech);
+    }
+  }
+  const keywords = [];
+  const keywordPatterns = {
+    api: /\bapi\b|\brest\b|\bgraphql\b/i,
+    cli: /\bcli\b|\bcommand.?line\b/i,
+    web: /\bweb\b|\bwebsite\b|\bfrontend\b/i,
+    mobile: /\bmobile\b|\bios\b|\bandroid\b|\breact.?native\b/i,
+    ai: /\bai\b|\bmachine.?learning\b|\bllm\b|\bgpt\b/i,
+    video: /\bvideo\b|\bstreaming\b|\bmedia\b/i,
+    ecommerce: /\becommerce\b|\bshop\b|\bstore\b|\bpayment\b/i,
+    auth: /\bauth\b|\blogin\b|\bsession\b/i,
+    testing: /\btest\b|\btesting\b|\btdd\b/i,
+    devtools: /\bdevtool\b|\bdeveloper.?tool\b/i
+  };
+  for (const [keyword, pattern] of Object.entries(keywordPatterns)) {
+    if (pattern.test(content)) {
+      keywords.push(keyword);
+    }
+  }
+  return { name, description, techStack, keywords };
+}
+function suggestSkills(context) {
+  const suggestions = [];
+  suggestions.push({
+    name: "Find Skills",
+    installCommand: "npx skills add vercel-labs/skills@find-skills --yes",
+    reason: "Discover more skills for your workflow"
+  });
+  if (!context) {
+    suggestions.push({
+      name: "Writing Plans",
+      installCommand: "npx skills add obra/superpowers@writing-plans --yes",
+      reason: "Better planning before implementation"
+    });
+    return suggestions;
+  }
+  if (context.techStack.includes("react") || context.techStack.includes("next.js")) {
+    suggestions.push({
+      name: "React Best Practices",
+      installCommand: "npx skills add vercel-labs/agent-skills@vercel-react-best-practices --yes",
+      reason: `Detected React/Next.js in ${context.name}`
+    });
+  }
+  if (context.techStack.includes("remotion")) {
+    suggestions.push({
+      name: "Remotion",
+      installCommand: "npx skills add remotion-dev/skills@remotion-best-practices --yes",
+      reason: "Detected Remotion video framework"
+    });
+  }
+  if (context.keywords.includes("testing") || context.keywords.includes("tdd")) {
+    suggestions.push({
+      name: "Test-Driven Development",
+      installCommand: "npx skills add obra/superpowers@test-driven-development --yes",
+      reason: "Testing focus detected"
+    });
+  }
+  if (context.keywords.includes("web")) {
+    suggestions.push({
+      name: "Web Design Guidelines",
+      installCommand: "npx skills add vercel-labs/agent-skills@web-design-guidelines --yes",
+      reason: "Web project detected"
+    });
+  }
+  if (!suggestions.some((s2) => s2.name.includes("Plan"))) {
+    suggestions.push({
+      name: "Writing Plans",
+      installCommand: "npx skills add obra/superpowers@writing-plans --yes",
+      reason: "Helps structure work before coding"
+    });
+  }
+  return suggestions.slice(0, 5);
+}
+function installSkill2(installCommand) {
+  try {
+    const result = spawnSync2("npx", installCommand.replace("npx ", "").split(" "), {
+      stdio: "pipe",
+      timeout: 60000,
+      shell: true
+    });
+    if (result.status === 0) {
+      return { success: true, message: "Installed successfully" };
+    } else {
+      const stderr = result.stderr?.toString() || "";
+      return { success: false, message: stderr.slice(0, 100) || "Installation failed" };
+    }
+  } catch (error2) {
+    return { success: false, message: error2 instanceof Error ? error2.message : "Unknown error" };
+  }
+}
 
 // src/commands/scan.ts
 var scanCommand = defineCommand2({
   meta: {
     name: "scan",
-    description: "Analyze local data sources (git, AI sessions, tests) and compute your NaironAI score"
+    description: "Scan your AI workflow and get optimization recommendations (interactive)"
   },
   args: {
-    since: {
-      type: "string",
-      description: 'Time range: 6h, 24h, 7d, 30d, or "7 days"',
-      default: "7d"
-    },
-    project: {
-      type: "string",
-      description: "Project directory to scan (defaults to cwd)"
-    },
-    install: {
-      type: "boolean",
-      alias: "i",
-      description: "Install recommended optimizations (interactive)",
-      default: false
-    },
-    "install-all": {
-      type: "boolean",
-      description: "Install all recommended optimizations (non-interactive)",
-      default: false
-    },
-    "install-essentials": {
-      type: "boolean",
-      description: "Install essential tools: Context7, Supermemory, Beads",
-      default: false
-    },
-    offline: {
-      type: "boolean",
-      description: "Skip uploading results to Convex",
-      default: false
-    },
-    "no-report": {
-      type: "boolean",
-      description: "Skip generating markdown report",
-      default: false
-    },
-    "report-dir": {
-      type: "string",
-      description: "Directory for reports (defaults to .nairon/reports)",
-      default: ".nairon/reports"
-    },
-    brief: {
-      type: "boolean",
-      description: "Show brief output (skip detailed analysis)",
-      default: false
-    },
     json: {
       type: "boolean",
-      description: "Output results as JSON (for CI/scripts)",
+      description: "Output as JSON (for CI/scripts)",
       default: false
     },
     quiet: {
       type: "boolean",
       alias: "q",
-      description: "Quiet mode - only output the score number",
-      default: false
-    },
-    "no-cache": {
-      type: "boolean",
-      description: "Disable session caching (slower but ensures fresh data)",
-      default: false
-    },
-    watch: {
-      type: "boolean",
-      alias: "w",
-      description: "Watch mode - re-scan on file changes",
+      description: "Only output score number",
       default: false
-    },
-    "watch-interval": {
-      type: "string",
-      description: "Watch interval in seconds (default: 30)",
-      default: "30"
     }
   },
   async run({ args }) {
-    const projectDir = args.project ?? process.cwd();
-    const since = parseSince(args.since);
+    const projectDir = process.cwd();
     const jsonOutput = args.json;
     const quietMode = args.quiet;
-    const useCache = !args["no-cache"];
-    const watchMode = args.watch;
-    const watchInterval = parseInt(args["watch-interval"] || "30", 10) * 1000;
     const silent = jsonOutput || quietMode;
+    let since;
+    if (silent) {
+      since = parseSince("7d");
+    } else {
+      console.log();
+      console.log("  \uD83D\uDD0D " + "\x1B[1mNaironAI Workflow Scanner\x1B[0m");
+      console.log("  " + "\x1B[2m" + "─".repeat(35) + "\x1B[0m");
+      console.log();
+      const period = await consola.prompt("Time period to analyze?", {
+        type: "select",
+        options: [
+          { value: "7d", label: "Last 7 days (recommended)" },
+          { value: "24h", label: "Last 24 hours" },
+          { value: "30d", label: "Last 30 days" }
+        ]
+      });
+      since = parseSince(period);
+      if (isFirstScanInProject(projectDir)) {
+        await showFirstScanWelcome(projectDir);
+        markProjectScanned(projectDir);
+      }
+    }
+    const useCache = true;
+    const watchMode = false;
+    const watchInterval = 30000;
     if (watchMode) {
       console.log();
       console.log(colors2.bold(colors2.primary("  NaironAI Watch Mode")));
@@ -16352,19 +16454,17 @@ var scanCommand = defineCommand2({
       console.log(`     Projected monthly: ${colors2.primary(`$${scanCost.projectedMonthlyCostUsd.toFixed(2)}`)}`);
       console.log(colors2.dim("  " + "═".repeat(45)));
       console.log();
-      if (!args["no-report"]) {
-        const reportDir = join9(projectDir, args["report-dir"]);
-        const reportPath = generateReport(reportDir, score, git, agents, tests, args.since, sdlcAnalysis, scanCost, analysis);
-        console.log(`  ${icons.success} Report saved: ${colors2.dim(reportPath)}`);
-      }
-      if (agents && agents.sessions.length > 0 && !args.brief) {
+      const reportDir = join10(projectDir, ".nairon/reports");
+      const reportPath = generateReport(reportDir, score, git, agents, tests, "7d", sdlcAnalysis, scanCost, analysis);
+      console.log(`  ${icons.success} Report saved: ${colors2.dim(reportPath)}`);
+      if (agents && agents.sessions.length > 0) {
         const effortBreakdown = analyzeEffort(agents.sessions, git);
         const effortLines = formatEffortBreakdown(effortBreakdown);
         for (const line of effortLines) {
           console.log(line);
         }
       }
-      if (agents && agents.sessions.length > 0 && !args.brief) {
+      if (agents && agents.sessions.length > 0) {
         const frustrationSummary = detectFrustrations(agents.sessions);
         if (frustrationSummary.totalFrustrations > 0) {
           const frustrationLines = formatFrustrationSummary(frustrationSummary);
@@ -16373,68 +16473,71 @@ var scanCommand = defineCommand2({
           }
         }
       }
-      if (!args.brief) {
-        const installedStatus = checkInstalledStatus(projectDir);
-        const projectContext = loadProjectContext(projectDir);
-        if (projectContext) {
-          console.log(`  ${colors2.dim("Using project context from onboarding for personalized recommendations")}`);
-        }
-        const sdlc = analyzeSDLC(agents, git, tests, projectDir, analysis, projectContext);
-        for (const phase of [sdlc.requirements, sdlc.planning, sdlc.implementation, sdlc.review]) {
-          phase.recommendations = phase.recommendations.filter((rec) => {
-            const id = rec.title.toLowerCase().replace(/\s+/g, "-");
-            if (id.includes("context7") && installedStatus.context7)
-              return false;
-            if (id.includes("supermemory") && installedStatus.supermemory)
-              return false;
-            if (id.includes("nia") && installedStatus.nia)
-              return false;
-            if (id.includes("beads") && installedStatus.beads)
-              return false;
-            return true;
-          });
-          for (const tool of phase.tools) {
-            if (tool.name.toLowerCase().includes("context7") && installedStatus.context7) {
-              tool.installed = true;
-            }
-            if (tool.name.toLowerCase().includes("supermemory") && installedStatus.supermemory) {
-              tool.installed = true;
-            }
-            if (tool.name.toLowerCase().includes("nia") && installedStatus.nia) {
-              tool.installed = true;
-            }
+      const installedStatus = checkInstalledStatus(projectDir);
+      const projectContext = loadProjectContext(projectDir);
+      if (projectContext) {
+        console.log(`  ${colors2.dim("Using project context from onboarding for personalized recommendations")}`);
+      }
+      const sdlc = analyzeSDLC(agents, git, tests, projectDir, analysis, projectContext);
+      for (const phase of [sdlc.requirements, sdlc.planning, sdlc.implementation, sdlc.review]) {
+        phase.recommendations = phase.recommendations.filter((rec) => {
+          const id = rec.title.toLowerCase().replace(/\s+/g, "-");
+          if (id.includes("context7") && installedStatus.context7)
+            return false;
+          if (id.includes("supermemory") && installedStatus.supermemory)
+            return false;
+          if (id.includes("nia") && installedStatus.nia)
+            return false;
+          if (id.includes("beads") && installedStatus.beads)
+            return false;
+          return true;
+        });
+        for (const tool of phase.tools) {
+          if (tool.name.toLowerCase().includes("context7") && installedStatus.context7) {
+            tool.installed = true;
+          }
+          if (tool.name.toLowerCase().includes("supermemory") && installedStatus.supermemory) {
+            tool.installed = true;
+          }
+          if (tool.name.toLowerCase().includes("nia") && installedStatus.nia) {
+            tool.installed = true;
           }
         }
-        const totalRecs = [sdlc.requirements, sdlc.planning, sdlc.implementation, sdlc.review].reduce((a2, p) => a2 + p.recommendations.length, 0);
-        if (totalRecs > 0) {
-          sdlc.overall.summary = sdlc.overall.summary.replace(/\d+ optimizations available\./, `${totalRecs} optimizations available.`);
-        } else if (sdlc.overall.summary.includes("optimizations available")) {
-          sdlc.overall.summary = sdlc.overall.summary.replace(/\d+ optimizations available\./, "All recommended tools installed.");
-        }
-        const sdlcLines = formatSDLCForTerminal(sdlc);
-        for (const line of sdlcLines) {
-          console.log(line);
-        }
-        let allRecs = [];
-        for (const phase of [sdlc.requirements, sdlc.planning, sdlc.implementation, sdlc.review]) {
-          for (const rec of phase.recommendations) {
-            if (rec.installCommand) {
-              allRecs.push(phaseRecToInstallable(rec));
-            }
+      }
+      const totalRecs = [sdlc.requirements, sdlc.planning, sdlc.implementation, sdlc.review].reduce((a2, p) => a2 + p.recommendations.length, 0);
+      if (totalRecs > 0) {
+        sdlc.overall.summary = sdlc.overall.summary.replace(/\d+ optimizations available\./, `${totalRecs} optimizations available.`);
+      } else if (sdlc.overall.summary.includes("optimizations available")) {
+        sdlc.overall.summary = sdlc.overall.summary.replace(/\d+ optimizations available\./, "All recommended tools installed.");
+      }
+      const sdlcLines = formatSDLCForTerminal(sdlc);
+      for (const line of sdlcLines) {
+        console.log(line);
+      }
+      let allRecs = [];
+      for (const phase of [sdlc.requirements, sdlc.planning, sdlc.implementation, sdlc.review]) {
+        for (const rec of phase.recommendations) {
+          if (rec.installCommand) {
+            allRecs.push(phaseRecToInstallable(rec));
           }
         }
-        allRecs = filterAlreadyInstalled(allRecs, installedStatus);
-        if (args["install-essentials"]) {
-          console.log();
-          console.log(`  ${colors2.bold(colors2.primary("Installing Essential Tools"))}`);
-          console.log(colors2.dim("  " + "─".repeat(40)));
-          console.log();
-          const essentials = filterAlreadyInstalled(QUICK_INSTALL_PRESETS.essential, installedStatus);
-          if (essentials.length === 0) {
-            console.log(`  ${colors2.success("✓")} All essential tools already installed!`);
+      }
+      allRecs = filterAlreadyInstalled(allRecs, installedStatus);
+      if (allRecs.length > 0) {
+        console.log();
+        const optionLabels = allRecs.map((rec) => `${rec.name} - ${rec.description}`);
+        const selected = await consola.prompt(`${allRecs.length} optimizations available. Select to install (space to select, enter to confirm):`, {
+          type: "multiselect",
+          options: optionLabels,
+          required: false
+        });
+        if (selected && typeof selected !== "symbol" && Array.isArray(selected) && selected.length > 0) {
+          const toInstall = allRecs.filter((rec) => selected.some((s2) => s2.startsWith(rec.name))).map((r3) => ({ ...r3, selected: true }));
+          if (toInstall.length > 0) {
             console.log();
-          } else {
-            const results = await installOptimizations(essentials.map((e2) => ({ ...e2, selected: true })), projectDir, {});
+            console.log(`  ${colors2.bold("Installing...")}${colors2.dim("")}`);
+            console.log();
+            const results = await installOptimizations(toInstall, projectDir, {});
             for (const result of results) {
               if (result.success) {
                 console.log(`  ${colors2.success("✓")} ${result.name}: ${result.message}`);
@@ -16444,82 +16547,15 @@ var scanCommand = defineCommand2({
             }
             console.log();
           }
-        } else if (args["install-all"] && allRecs.length > 0) {
-          console.log();
-          console.log(`  ${colors2.bold(colors2.primary("Installing All Optimizations"))}`);
-          console.log(colors2.dim("  " + "─".repeat(40)));
-          console.log();
-          const results = await installOptimizations(allRecs.map((r3) => ({ ...r3, selected: true })), projectDir, {});
-          for (const result of results) {
-            if (result.success) {
-              console.log(`  ${colors2.success("✓")} ${result.name}: ${result.message}`);
-            } else {
-              console.log(`  ${colors2.error("✗")} ${result.name}: ${result.error || result.message}`);
-            }
-          }
-          console.log();
-        } else if (allRecs.length > 0 && !args["install-essentials"] && !args["install-all"]) {
+        } else {
+          console.log(`  ${colors2.dim("Skipped.")}`);
           console.log();
-          const optionLabels = allRecs.map((rec) => `${rec.name} - ${rec.description}`);
-          const selected = await consola.prompt(`${allRecs.length} optimizations available. Select to install (space to select, enter to confirm):`, {
-            type: "multiselect",
-            options: optionLabels,
-            required: false
-          });
-          if (selected && typeof selected !== "symbol" && Array.isArray(selected) && selected.length > 0) {
-            const toInstall = allRecs.filter((rec) => selected.some((s2) => s2.startsWith(rec.name))).map((r3) => ({ ...r3, selected: true }));
-            if (toInstall.length > 0) {
-              console.log();
-              console.log(`  ${colors2.bold("Installing...")}${colors2.dim("")}`);
-              console.log();
-              const results = await installOptimizations(toInstall, projectDir, {});
-              for (const result of results) {
-                if (result.success) {
-                  console.log(`  ${colors2.success("✓")} ${result.name}: ${result.message}`);
-                } else {
-                  console.log(`  ${colors2.error("✗")} ${result.name}: ${result.error || result.message}`);
-                }
-              }
-              console.log();
-            }
-          } else {
-            console.log(`  ${colors2.dim("Skipped. Run")} ${colors2.primary("nb scan --install-essentials")} ${colors2.dim("anytime to quick-install.")}`);
-            console.log();
-          }
         }
       }
     }
-    if (args.offline) {
-      if (!silent) {
-        console.log(`  ${icons.info} Offline mode - skipping cloud sync`);
-        console.log();
-      }
-      if (jsonOutput) {
-        const output = {
-          score: score.overall,
-          tier: score.tier,
-          baseScore: score.baseScore,
-          tokenEfficiency: score.tokenEfficiency,
-          phases: score.phases,
-          cost: scanCost,
-          git: git ? { commitCount: git.commitCount, authors: git.authors.length } : null,
-          agents: agents ? { sessions: agents.totalSessions, tokens: agents.totalTokens } : null,
-          tests: tests ? { total: tests.totalTests, passRate: tests.passRate } : null,
-          scannedAt: score.scannedAt
-        };
-        console.log(JSON.stringify(output, null, 2));
-      } else if (quietMode) {
-        console.log(score.overall);
-      }
-      return;
-    }
     const client = getClient();
     const clerkId = getClerkId();
     if (!client || !clerkId) {
-      if (!silent) {
-        console.log(`  ${icons.info} Run ${colors2.primary("nb init")} to enable cloud sync`);
-        console.log();
-      }
       if (jsonOutput) {
         const output = {
           score: score.overall,
@@ -16634,12 +16670,12 @@ var scanCommand = defineCommand2({
   }
 });
 function loadProjectContext(projectDir) {
-  const contextPath = join9(projectDir, ".nairon", "context.json");
-  if (!existsSync9(contextPath)) {
+  const contextPath = join10(projectDir, ".nairon", "context.json");
+  if (!existsSync10(contextPath)) {
     return null;
   }
   try {
-    const raw = readFileSync9(contextPath, "utf-8");
+    const raw = readFileSync10(contextPath, "utf-8");
     const data = JSON.parse(raw);
     const context = {
       painPoints: data.painPoints || [],
@@ -16692,12 +16728,12 @@ function parseSince(since) {
   return new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
 }
 function generateReport(reportDir, score, git, agents, tests, since, sdlcAnalysis, scanCost, analysis) {
-  if (!existsSync9(reportDir)) {
-    mkdirSync4(reportDir, { recursive: true });
+  if (!existsSync10(reportDir)) {
+    mkdirSync5(reportDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = `scan-${timestamp}.md`;
-  const filepath = join9(reportDir, filename);
+  const filepath = join10(reportDir, filename);
   const lines = [];
   lines.push(`# NaironAI Scan Report`);
   lines.push("");
@@ -16813,7 +16849,7 @@ function generateReport(reportDir, score, git, agents, tests, since, sdlcAnalysi
   lines.push("---");
   lines.push("");
   lines.push("*Generated by [nairon-bench](https://github.com/ObaidUr-Rahmaan/nairon-bench)*");
-  writeFileSync4(filepath, lines.join(`
+  writeFileSync5(filepath, lines.join(`
 `));
   return filepath;
 }
@@ -16832,15 +16868,73 @@ function formatTokensPlain(tokens) {
     return `${Math.round(tokens / 1000)}K`;
   return tokens.toString();
 }
+async function showFirstScanWelcome(projectDir) {
+  console.log();
+  console.log(colors2.dim("  " + "═".repeat(50)));
+  console.log(`  ${colors2.primary("✨")} ${colors2.bold("First scan in this project!")}`);
+  console.log(colors2.dim("  " + "═".repeat(50)));
+  console.log();
+  const agent = detectAgent();
+  const agentNames = {
+    "claude-code": "Claude Code",
+    opencode: "OpenCode",
+    cursor: "Cursor",
+    unknown: "Unknown"
+  };
+  console.log(`  ${icons.info} Detected agent: ${colors2.bold(agentNames[agent])}`);
+  const context = analyzeReadme(projectDir);
+  if (context) {
+    console.log(`  ${icons.info} Project: ${colors2.bold(context.name)}`);
+    if (context.techStack.length > 0) {
+      console.log(`  ${colors2.dim("  Tech: " + context.techStack.slice(0, 4).join(", "))}`);
+    }
+  }
+  console.log();
+  const suggestions = suggestSkills(context);
+  if (suggestions.length > 0) {
+    console.log(`  ${colors2.bold("Recommended skills for this project:")}`);
+    console.log();
+    for (let i3 = 0;i3 < Math.min(3, suggestions.length); i3++) {
+      const s2 = suggestions[i3];
+      console.log(`  ${colors2.primary((i3 + 1).toString())}. ${colors2.bold(s2.name)}`);
+      console.log(`     ${colors2.dim(s2.reason)}`);
+    }
+    console.log();
+    const installChoice = await consola.prompt("Install recommended skills?", {
+      type: "select",
+      options: [
+        { value: "find-skills", label: "Just find-skills (discover more skills later)" },
+        { value: "all", label: "All recommended skills" },
+        { value: "skip", label: "Skip - continue to scan" }
+      ]
+    });
+    if (installChoice === "find-skills" || installChoice === "all") {
+      console.log();
+      const toInstall = installChoice === "all" ? suggestions.slice(0, 3) : suggestions.slice(0, 1);
+      for (const skill of toInstall) {
+        process.stdout.write(`  Installing ${skill.name}...`);
+        const result = installSkill2(skill.installCommand);
+        if (result.success) {
+          console.log(` ${colors2.success("✓")}`);
+        } else {
+          console.log(` ${colors2.warning("⚠")} ${colors2.dim(`(${result.message.slice(0, 50)})`)}`);
+        }
+      }
+      console.log();
+    }
+  }
+  console.log(colors2.dim("  " + "═".repeat(50)));
+  console.log();
+}
 
 // src/commands/report.ts
 init_dist();
 init_client();
 
 // src/collectors/report-data.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join10, basename as basename3 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync2 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join11, basename as basename3 } from "node:path";
 async function collectReportData(projectDir, since, until = new Date, harness) {
   const projectName = basename3(projectDir);
   const [commits, allSessions, mcpConfigs] = await Promise.all([
@@ -16923,12 +17017,12 @@ function detectAIAssistedCommit(message) {
 }
 async function collectAllSessions(since, until, projectDir) {
   const sessions = [];
-  const claudeDir = join10(homedir8(), ".claude");
-  if (existsSync10(claudeDir)) {
+  const claudeDir = join11(homedir9(), ".claude");
+  if (existsSync11(claudeDir)) {
     sessions.push(...collectClaudeCodeSessions(claudeDir, since, until, projectDir));
   }
-  const openCodeDir = join10(homedir8(), ".local", "share", "opencode");
-  if (existsSync10(openCodeDir)) {
+  const openCodeDir = join11(homedir9(), ".local", "share", "opencode");
+  if (existsSync11(openCodeDir)) {
     sessions.push(...collectOpenCodeSessions2(openCodeDir, since, until));
   }
   sessions.sort((a2, b2) => a2.startTime.getTime() - b2.startTime.getTime());
@@ -16936,15 +17030,15 @@ async function collectAllSessions(since, until, projectDir) {
 }
 function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
   const sessions = [];
-  const transcriptsDir = join10(claudeDir, "transcripts");
-  if (!existsSync10(transcriptsDir))
+  const transcriptsDir = join11(claudeDir, "transcripts");
+  if (!existsSync11(transcriptsDir))
     return sessions;
   const projectHash = projectDir ? hashPath(projectDir) : null;
-  const projectsDir = join10(claudeDir, "projects");
+  const projectsDir = join11(claudeDir, "projects");
   try {
     const transcriptFiles = readdirSync5(transcriptsDir).filter((f3) => f3.endsWith(".jsonl"));
     for (const file of transcriptFiles) {
-      const filePath = join10(transcriptsDir, file);
+      const filePath = join11(transcriptsDir, file);
       const stat = statSync2(filePath);
       if (stat.mtime < since || stat.mtime > until)
         continue;
@@ -16955,12 +17049,12 @@ function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
         }
       } catch {}
     }
-    if (projectHash && existsSync10(projectsDir)) {
-      const projectSessionDir = join10(projectsDir, projectHash);
-      if (existsSync10(projectSessionDir)) {
+    if (projectHash && existsSync11(projectsDir)) {
+      const projectSessionDir = join11(projectsDir, projectHash);
+      if (existsSync11(projectSessionDir)) {
         const projectFiles = readdirSync5(projectSessionDir).filter((f3) => f3.endsWith(".jsonl"));
         for (const file of projectFiles) {
-          const filePath = join10(projectSessionDir, file);
+          const filePath = join11(projectSessionDir, file);
           const stat = statSync2(filePath);
           if (stat.mtime < since || stat.mtime > until)
             continue;
@@ -16979,7 +17073,7 @@ function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
   return sessions;
 }
 function parseClaudeTranscript(filePath, fileName) {
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync11(filePath, "utf-8");
   const lines = content.trim().split(`
 `).filter((l2) => l2.trim());
   if (lines.length === 0)
@@ -17069,25 +17163,25 @@ function parseClaudeTranscript(filePath, fileName) {
 }
 function collectOpenCodeSessions2(openCodeDir, since, until) {
   const sessions = [];
-  const sessionDir = join10(openCodeDir, "storage", "session");
-  const messageDir = join10(openCodeDir, "storage", "message");
-  const partDir = join10(openCodeDir, "storage", "part");
-  if (!existsSync10(sessionDir))
+  const sessionDir = join11(openCodeDir, "storage", "session");
+  const messageDir = join11(openCodeDir, "storage", "message");
+  const partDir = join11(openCodeDir, "storage", "part");
+  if (!existsSync11(sessionDir))
     return sessions;
   try {
-    const projectDirs = readdirSync5(sessionDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join10(sessionDir, d2.name));
+    const projectDirs = readdirSync5(sessionDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join11(sessionDir, d2.name));
     for (const projectDir of projectDirs) {
       const sessionFiles = readdirSync5(projectDir).filter((f3) => f3.endsWith(".json"));
       for (const sessionFile of sessionFiles) {
         try {
-          const sessionPath = join10(projectDir, sessionFile);
-          const sessionData = JSON.parse(readFileSync10(sessionPath, "utf-8"));
+          const sessionPath = join11(projectDir, sessionFile);
+          const sessionData = JSON.parse(readFileSync11(sessionPath, "utf-8"));
           const createdAt = new Date(sessionData.time?.created || 0);
           const updatedAt = new Date(sessionData.time?.updated || sessionData.time?.created || 0);
           if (updatedAt < since || createdAt > until)
             continue;
           const sessionId = sessionData.id;
-          const sessionMsgDir = join10(messageDir, sessionId);
+          const sessionMsgDir = join11(messageDir, sessionId);
           const prompts = [];
           const responses = [];
           const toolsUsed = new Set;
@@ -17098,12 +17192,12 @@ function collectOpenCodeSessions2(openCodeDir, since, until) {
           let model = "unknown";
           let startTime = createdAt;
           let endTime = updatedAt;
-          if (existsSync10(sessionMsgDir)) {
+          if (existsSync11(sessionMsgDir)) {
             const msgFiles = readdirSync5(sessionMsgDir).filter((f3) => f3.endsWith(".json")).sort();
             for (const msgFile of msgFiles) {
               try {
-                const msgPath = join10(sessionMsgDir, msgFile);
-                const msgData = JSON.parse(readFileSync10(msgPath, "utf-8"));
+                const msgPath = join11(sessionMsgDir, msgFile);
+                const msgData = JSON.parse(readFileSync11(msgPath, "utf-8"));
                 const msgId = msgData.id;
                 if (msgData.model?.modelID) {
                   model = msgData.model.modelID;
@@ -17113,14 +17207,14 @@ function collectOpenCodeSessions2(openCodeDir, since, until) {
                   startTime = msgTime;
                 if (msgTime > endTime)
                   endTime = msgTime;
-                const msgPartDir = join10(partDir, msgId);
+                const msgPartDir = join11(partDir, msgId);
                 let messageText = "";
-                if (existsSync10(msgPartDir)) {
+                if (existsSync11(msgPartDir)) {
                   const partFiles = readdirSync5(msgPartDir).filter((f3) => f3.endsWith(".json")).sort();
                   for (const partFile of partFiles) {
                     try {
-                      const partPath = join10(msgPartDir, partFile);
-                      const partData = JSON.parse(readFileSync10(partPath, "utf-8"));
+                      const partPath = join11(msgPartDir, partFile);
+                      const partData = JSON.parse(readFileSync11(partPath, "utf-8"));
                       if (partData.type === "text" && partData.text && !partData.synthetic) {
                         messageText += partData.text + `
 `;
@@ -17294,10 +17388,10 @@ function analyzeResponse(text, sessionId, index, promptId, timestamp) {
 }
 function collectMCPConfigs() {
   const configs = [];
-  const claudeConfig = join10(homedir8(), ".claude.json");
-  if (existsSync10(claudeConfig)) {
+  const claudeConfig = join11(homedir9(), ".claude.json");
+  if (existsSync11(claudeConfig)) {
     try {
-      const data = JSON.parse(readFileSync10(claudeConfig, "utf-8"));
+      const data = JSON.parse(readFileSync11(claudeConfig, "utf-8"));
       const mcpServers = data.mcpServers || {};
       for (const [name, config] of Object.entries(mcpServers)) {
         configs.push({
@@ -17310,13 +17404,13 @@ function collectMCPConfigs() {
     } catch {}
   }
   const openCodeConfigs = [
-    join10(homedir8(), ".opencode.json"),
-    join10(homedir8(), ".config", "opencode", "opencode.json")
+    join11(homedir9(), ".opencode.json"),
+    join11(homedir9(), ".config", "opencode", "opencode.json")
   ];
   for (const configPath of openCodeConfigs) {
-    if (existsSync10(configPath)) {
+    if (existsSync11(configPath)) {
       try {
-        const data = JSON.parse(readFileSync10(configPath, "utf-8"));
+        const data = JSON.parse(readFileSync11(configPath, "utf-8"));
         const mcpServers = data.mcp || {};
         for (const [name, config] of Object.entries(mcpServers)) {
           if (!configs.find((c3) => c3.name === name)) {
@@ -17331,10 +17425,10 @@ function collectMCPConfigs() {
       } catch {}
     }
   }
-  const cursorConfig = join10(homedir8(), ".cursor", "mcp.json");
-  if (existsSync10(cursorConfig)) {
+  const cursorConfig = join11(homedir9(), ".cursor", "mcp.json");
+  if (existsSync11(cursorConfig)) {
     try {
-      const data = JSON.parse(readFileSync10(cursorConfig, "utf-8"));
+      const data = JSON.parse(readFileSync11(cursorConfig, "utf-8"));
       const mcpServers = data.mcpServers || {};
       for (const [name, config] of Object.entries(mcpServers)) {
         if (!configs.find((c3) => c3.name === name)) {
@@ -19535,9 +19629,9 @@ function getSeverityEmoji(severity) {
 }
 
 // src/lib/tool-analyzer.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync6 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join12 } from "node:path";
 function analyzeToolUtilization(data) {
   const mcpServers = analyzeMCPServers(data);
   const mcpSummary = buildMCPSummary(mcpServers);
@@ -19687,24 +19781,24 @@ function categorizeTools(tools) {
 }
 function analyzeSkills() {
   const skills = [];
-  const home = homedir9();
+  const home = homedir10();
   const skillsDirs = [
-    join11(home, ".claude", "skills"),
-    join11(home, ".agents", "skills"),
-    join11(home, ".config", "claude", "skills")
+    join12(home, ".claude", "skills"),
+    join12(home, ".agents", "skills"),
+    join12(home, ".config", "claude", "skills")
   ];
   const projectSkillsDirs = [
-    join11(process.cwd(), ".claude", "skills"),
-    join11(process.cwd(), ".agents", "skills")
+    join12(process.cwd(), ".claude", "skills"),
+    join12(process.cwd(), ".agents", "skills")
   ];
   const openCodeSkillDirs = [
-    join11(home, ".config", "opencode", "skills"),
-    join11(home, ".local", "share", "opencode", "skills")
+    join12(home, ".config", "opencode", "skills"),
+    join12(home, ".local", "share", "opencode", "skills")
   ];
   const allSkillDirs = [...skillsDirs, ...projectSkillsDirs, ...openCodeSkillDirs];
   const seenSkills = new Set;
   for (const skillsDir of allSkillDirs) {
-    if (existsSync11(skillsDir)) {
+    if (existsSync12(skillsDir)) {
       try {
         const entries = readdirSync6(skillsDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -19715,7 +19809,7 @@ function analyzeSkills() {
           if (entry.isDirectory() || entry.isSymbolicLink() || entry.name.endsWith(".md")) {
             skills.push({
               name: skillName,
-              path: join11(skillsDir, entry.name),
+              path: join12(skillsDir, entry.name),
               used: false,
               usageCount: 0
             });
@@ -20012,22 +20106,22 @@ function renderToolUtilizationMarkdown(analysis) {
 }
 
 // src/lib/coverage-parser.ts
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
+import { join as join13 } from "node:path";
 function parseCoverageReport(projectDir) {
   const coveragePaths = [
-    { path: join12(projectDir, "coverage", "lcov.info"), parser: parseLcov },
-    { path: join12(projectDir, "coverage", "coverage-summary.json"), parser: parseIstanbulSummary },
-    { path: join12(projectDir, "coverage", "coverage-final.json"), parser: parseIstanbulFinal },
-    { path: join12(projectDir, "coverage", "cobertura-coverage.xml"), parser: parseCobertura },
-    { path: join12(projectDir, "coverage", "clover.xml"), parser: parseClover },
-    { path: join12(projectDir, "lcov.info"), parser: parseLcov },
-    { path: join12(projectDir, ".nyc_output", "coverage-summary.json"), parser: parseIstanbulSummary }
+    { path: join13(projectDir, "coverage", "lcov.info"), parser: parseLcov },
+    { path: join13(projectDir, "coverage", "coverage-summary.json"), parser: parseIstanbulSummary },
+    { path: join13(projectDir, "coverage", "coverage-final.json"), parser: parseIstanbulFinal },
+    { path: join13(projectDir, "coverage", "cobertura-coverage.xml"), parser: parseCobertura },
+    { path: join13(projectDir, "coverage", "clover.xml"), parser: parseClover },
+    { path: join13(projectDir, "lcov.info"), parser: parseLcov },
+    { path: join13(projectDir, ".nyc_output", "coverage-summary.json"), parser: parseIstanbulSummary }
   ];
   for (const { path, parser: parser4 } of coveragePaths) {
-    if (existsSync12(path)) {
+    if (existsSync13(path)) {
       try {
-        const content = readFileSync12(path, "utf-8");
+        const content = readFileSync13(path, "utf-8");
         return parser4(content, path);
       } catch {}
     }
@@ -21739,150 +21833,151 @@ function formatReportAsJSON(report) {
 }
 
 // src/commands/report.ts
-import { writeFileSync as writeFileSync5 } from "node:fs";
+import { writeFileSync as writeFileSync6 } from "node:fs";
 import { resolve } from "node:path";
 var reportCommand = defineCommand2({
   meta: {
     name: "report",
-    description: "Generate AI-nativeness reports for hackathon submissions or regular benchmarks"
+    description: "Generate AI-nativeness reports (interactive)"
   },
   args: {
-    hackathon: {
-      type: "boolean",
-      description: "Generate hackathon submission report (last 48 hours)",
-      default: false
-    },
-    harness: {
-      type: "string",
-      description: "AI harness to analyze: claude-code, opencode, cursor, or all"
-    },
-    since: {
-      type: "string",
-      description: "Time range: 48h, 7d, 30d, or ISO date"
-    },
-    output: {
-      type: "string",
-      description: "Save report to file (e.g., report.md)"
-    },
-    publish: {
-      type: "boolean",
-      description: "Publish report and get a shareable public link",
-      default: false
-    },
-    phase: {
-      type: "string",
-      description: "Drill into a specific phase (requirements, planning, implementation, testing, review)"
-    },
-    weekly: {
-      type: "boolean",
-      description: "Show latest scheduled weekly improvement report",
-      default: false
-    },
-    history: {
-      type: "boolean",
-      description: "Show score trend over time",
-      default: false
-    },
-    limit: {
-      type: "string",
-      description: "Number of historical scans to show",
-      default: "10"
-    },
-    format: {
-      type: "string",
-      description: "Output format: terminal, md, json, or text (legacy)",
-      default: "terminal"
-    },
-    leadership: {
+    json: {
       type: "boolean",
-      description: "Generate leadership report with effort breakdown and hidden work visibility",
+      description: "Output as JSON (for CI/scripts)",
       default: false
     }
   },
   async run({ args }) {
-    if (args.leadership) {
-      await runLeadershipReport(args);
+    if (args.json) {
+      const projectDir = process.cwd();
+      const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+      const report = await generateHackathonReport(projectDir, since, new Date, "all");
+      console.log(formatReportAsJSON(report));
       return;
     }
-    if (args.hackathon || args.since) {
-      await runHackathonReport(args);
-      return;
-    }
-    if (!args.weekly && !args.history && !args.phase) {
-      const choice = await consola.prompt("What would you like to report on?", {
-        type: "select",
-        options: [
-          { value: "hackathon", label: "Hackathon (last 48 hours)" },
-          { value: "week", label: "Last week" },
-          { value: "month", label: "Last month" },
-          { value: "cloud", label: "Cloud benchmark (requires nb init)" }
-        ]
-      });
-      if (choice === "hackathon" || choice === "week" || choice === "month") {
-        const sinceMap = {
-          hackathon: "48h",
-          week: "7d",
-          month: "30d"
-        };
-        args.since = sinceMap[choice];
-        const harness = await consola.prompt("Which AI harness did you use?", {
-          type: "select",
-          options: [
-            { value: "claude-code", label: "Claude Code" },
-            { value: "opencode", label: "OpenCode" },
-            { value: "cursor", label: "Cursor" },
-            { value: "all", label: "All (combine sessions from all harnesses)" }
-          ]
-        });
-        args.harness = harness;
-        const format2 = await consola.prompt("Output format?", {
-          type: "select",
-          options: [
-            { value: "terminal", label: "Terminal (view now)" },
-            { value: "md", label: "Markdown (for submission)" },
-            { value: "publish", label: "Public link (shareable URL)" },
-            { value: "json", label: "JSON (programmatic)" }
-          ]
-        });
-        if (format2 === "publish") {
-          args.publish = true;
-          args.format = "terminal";
-        } else {
-          args.format = format2;
-        }
-        if (format2 === "md") {
-          const filename = await consola.prompt("Save to file?", {
-            type: "text",
-            default: "ai-nativeness-report.md",
-            placeholder: "report.md"
-          });
-          if (filename && typeof filename === "string") {
-            args.output = filename;
-          }
-        }
-        await runHackathonReport(args);
-        return;
-      }
-      args.format = "text";
-    }
-    const client = getClient();
-    const clerkId = getClerkId();
-    if (!client || !clerkId) {
-      consola.error("Not connected to Convex. Run `nb init` to set up your profile.");
-      consola.info("Use `nb report --hackathon` for local AI-nativeness report.");
+    console.log();
+    console.log("  \uD83D\uDCCA " + "\x1B[1mNaironAI Report Generator\x1B[0m");
+    console.log("  " + "\x1B[2m" + "─".repeat(35) + "\x1B[0m");
+    console.log();
+    const reportType = await consola.prompt("What kind of report?", {
+      type: "select",
+      options: [
+        { value: "ai-nativeness", label: "AI-Nativeness Report (recommended)" },
+        { value: "leadership", label: "Leadership Report (effort visibility)" },
+        { value: "cloud", label: "Cloud Benchmark (requires nb init)" }
+      ]
+    });
+    if (reportType === "leadership") {
+      await runLeadershipReportInteractive();
       return;
     }
-    if (args.weekly) {
-      await showWeeklyReport(client, clerkId, args.format);
+    if (reportType === "cloud") {
+      await runCloudReport();
       return;
     }
-    if (args.history) {
-      await showHistory(client, clerkId, parseInt(args.limit, 10), args.format);
-      return;
+    const period = await consola.prompt("Time period?", {
+      type: "select",
+      options: [
+        { value: "48h", label: "Last 48 hours (hackathon)" },
+        { value: "7d", label: "Last 7 days" },
+        { value: "30d", label: "Last 30 days" }
+      ]
+    });
+    const harness = await consola.prompt("Which AI tool?", {
+      type: "select",
+      options: [
+        { value: "all", label: "All tools (recommended)" },
+        { value: "claude-code", label: "Claude Code" },
+        { value: "opencode", label: "OpenCode" },
+        { value: "cursor", label: "Cursor" }
+      ]
+    });
+    const format2 = await consola.prompt("Output format?", {
+      type: "select",
+      options: [
+        { value: "publish", label: "Public link (shareable URL)" },
+        { value: "terminal", label: "Terminal (view now)" },
+        { value: "md", label: "Markdown file" },
+        { value: "json", label: "JSON" }
+      ]
+    });
+    const reportArgs = {
+      since: period,
+      harness,
+      format: format2 === "publish" ? "terminal" : format2,
+      publish: format2 === "publish"
+    };
+    if (format2 === "md") {
+      const filename = await consola.prompt("Save to file?", {
+        type: "text",
+        default: "ai-nativeness-report.md",
+        placeholder: "report.md"
+      });
+      if (filename && typeof filename === "string") {
+        reportArgs.output = filename;
+      }
     }
-    await showLatestScan(client, clerkId, args.phase, args.format);
+    await runHackathonReport(reportArgs);
   }
 });
+async function runLeadershipReportInteractive() {
+  const period = await consola.prompt("Time period?", {
+    type: "select",
+    options: [
+      { value: "7d", label: "Last 7 days" },
+      { value: "30d", label: "Last 30 days" },
+      { value: "48h", label: "Last 48 hours" }
+    ]
+  });
+  const format2 = await consola.prompt("Output format?", {
+    type: "select",
+    options: [
+      { value: "terminal", label: "Terminal (view now)" },
+      { value: "md", label: "Markdown file" }
+    ]
+  });
+  let output;
+  if (format2 === "md") {
+    const filename = await consola.prompt("Save to file?", {
+      type: "text",
+      default: "leadership-report.md"
+    });
+    if (filename && typeof filename === "string") {
+      output = filename;
+    }
+  }
+  await runLeadershipReport({
+    since: period,
+    format: format2,
+    output
+  });
+}
+async function runCloudReport() {
+  const client = getClient();
+  const clerkId = getClerkId();
+  if (!client || !clerkId) {
+    consola.error("Not connected to Convex. Run `nb init` to set up your profile.");
+    consola.info("Try the AI-Nativeness Report instead - it works locally.");
+    return;
+  }
+  const cloudOption = await consola.prompt("What would you like to see?", {
+    type: "select",
+    options: [
+      { value: "latest", label: "Latest scan results" },
+      { value: "history", label: "Score history (trend)" },
+      { value: "weekly", label: "Weekly improvement report" }
+    ]
+  });
+  if (cloudOption === "weekly") {
+    await showWeeklyReport(client, clerkId, "text");
+    return;
+  }
+  if (cloudOption === "history") {
+    await showHistory(client, clerkId, 10, "text");
+    return;
+  }
+  await showLatestScan(client, clerkId, undefined, "text");
+}
 async function runHackathonReport(args) {
   const projectDir = process.cwd();
   let harness = args.harness;
@@ -21950,7 +22045,7 @@ async function runHackathonReport(args) {
     }
     if (args.output) {
       const filepath = resolve(projectDir, args.output);
-      writeFileSync5(filepath, output);
+      writeFileSync6(filepath, output);
       consola.success(`Report saved to ${filepath}`);
     }
     console.log(output);
@@ -22119,7 +22214,7 @@ async function runLeadershipReport(args) {
   }
   if (args.output) {
     const filepath = resolve(projectDir, args.output);
-    writeFileSync5(filepath, output);
+    writeFileSync6(filepath, output);
     consola.success(`Report saved to ${filepath}`);
   }
   console.log(output);
@@ -22281,9 +22376,9 @@ function renderBar4(value, width) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { join as join14 } from "node:path";
 init_client();
 
 // src/lib/recommendations-db.ts
@@ -22409,6 +22504,18 @@ var PLUGINS = [
   }
 ];
 var SKILLS = [
+  {
+    id: "find-skills",
+    name: "Find Skills",
+    type: "skill",
+    description: "Discover and install skills from the open agent skills ecosystem - essential for any AI workflow",
+    installCommand: "npx skills add vercel-labs/skills@find-skills --yes",
+    phases: ["requirements", "planning", "implementation", "review"],
+    impact: "high",
+    detectionKey: "find-skills",
+    website: "https://skills.sh/vercel-labs/skills/find-skills",
+    badge: "Essential"
+  },
   {
     id: "tdd-skill",
     name: "Test-Driven Development",
@@ -22880,25 +22987,17 @@ function printVerificationResults(summary, verbose = false) {
 var doctorCommand = defineCommand2({
   meta: {
     name: "doctor",
-    description: "Check tool detection, data sources, and connectivity health"
+    description: "Check system health and diagnose issues"
   },
   args: {
     "verify-recommendations": {
       type: "boolean",
-      description: "Verify all recommendations in the database are valid",
-      alias: "verify",
+      description: "",
       default: false
     },
     thorough: {
       type: "boolean",
-      description: "Run thorough verification with network checks",
-      alias: "t",
-      default: false
-    },
-    verbose: {
-      type: "boolean",
-      description: "Show all results including valid recommendations",
-      alias: "v",
+      description: "",
       default: false
     }
   },
@@ -22924,32 +23023,32 @@ var doctorCommand = defineCommand2({
       } else {
         spinner2.succeed("All recommendations verified");
       }
-      printVerificationResults(summary, args.verbose);
+      printVerificationResults(summary, true);
       if (summary.invalid > 0) {
         process.exit(1);
       }
       return;
     }
     console.log();
-    console.log(colors2.bold(colors2.primary("  NaironAI Doctor")));
-    console.log(colors2.dim(`  Checking system health...
-`));
+    console.log("  \uD83E\uDE7A " + "\x1B[1mNaironAI Doctor\x1B[0m");
+    console.log("  " + "\x1B[2m" + "─".repeat(35) + "\x1B[0m");
+    console.log();
     const spinner = createSpinner("Running diagnostics...");
     spinner.start();
     const results = [];
     results.push({ label: "OS", status: "info", value: `${process.platform} ${process.arch}` });
     results.push({ label: "Bun", status: "info", value: typeof Bun !== "undefined" ? Bun.version : "N/A" });
     results.push({ label: "Node", status: "info", value: process.version });
-    results.push({ label: "Home", status: "info", value: homedir10() });
-    const gitDir = join13(process.cwd(), ".git");
-    if (existsSync13(gitDir)) {
+    results.push({ label: "Home", status: "info", value: homedir11() });
+    const gitDir = join14(process.cwd(), ".git");
+    if (existsSync14(gitDir)) {
       results.push({ label: "Git", status: "success", value: "Repository detected" });
     } else {
       results.push({ label: "Git", status: "warn", value: "No repository in current directory" });
     }
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir10());
-      if (existsSync13(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir11());
+      if (existsSync14(resolvedPath)) {
         results.push({ label: agent, status: "success", value: `found at ${resolvedPath}` });
       }
     }
@@ -23003,10 +23102,10 @@ var doctorCommand = defineCommand2({
 });
 
 // src/commands/setup.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, copyFileSync } from "node:fs";
-import { join as join14, dirname as dirname2 } from "node:path";
-import { homedir as homedir11, platform as platform2 } from "node:os";
-import { execSync as execSync3 } from "node:child_process";
+import { existsSync as existsSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, copyFileSync } from "node:fs";
+import { join as join15, dirname as dirname2 } from "node:path";
+import { homedir as homedir12, platform as platform2 } from "node:os";
+import { execSync as execSync4 } from "node:child_process";
 import { createInterface } from "node:readline";
 var CONVEX_SITE_URL = "https://steady-bass-841.convex.site";
 async function fetchSetupData() {
@@ -23024,7 +23123,7 @@ var FALLBACK_HARNESSES = [
     id: "claude-code",
     name: "Claude Code",
     configPaths: [
-      join14(homedir11(), ".claude.json")
+      join15(homedir12(), ".claude.json")
     ],
     mcpConfigKey: "mcpServers",
     detected: false
@@ -23033,8 +23132,8 @@ var FALLBACK_HARNESSES = [
     id: "opencode",
     name: "OpenCode",
     configPaths: [
-      join14(homedir11(), ".opencode.json"),
-      join14(homedir11(), ".config", "opencode", "opencode.json")
+      join15(homedir12(), ".opencode.json"),
+      join15(homedir12(), ".config", "opencode", "opencode.json")
     ],
     mcpConfigKey: "mcp",
     detected: false
@@ -23043,8 +23142,8 @@ var FALLBACK_HARNESSES = [
     id: "cursor",
     name: "Cursor",
     configPaths: [
-      join14(homedir11(), ".cursor", "mcp.json"),
-      join14(homedir11(), "Library", "Application Support", "Cursor", "User", "globalStorage", "mcp.json")
+      join15(homedir12(), ".cursor", "mcp.json"),
+      join15(homedir12(), "Library", "Application Support", "Cursor", "User", "globalStorage", "mcp.json")
     ],
     mcpConfigKey: "mcpServers",
     detected: false
@@ -23061,7 +23160,7 @@ function getConfigPathsForPlatform(harness) {
   } else {
     paths = pathMap.linux;
   }
-  return paths.map((p) => p.replace(/^~/, homedir11()).replace(/%USERPROFILE%/gi, homedir11()).replace(/%APPDATA%/gi, join14(homedir11(), "AppData", "Roaming")));
+  return paths.map((p) => p.replace(/^~/, homedir12()).replace(/%USERPROFILE%/gi, homedir12()).replace(/%APPDATA%/gi, join15(homedir12(), "AppData", "Roaming")));
 }
 function convertAPIHarnessToConfig(harness) {
   return {
@@ -23076,7 +23175,7 @@ function detectHarnesses(harnesses) {
   const detected = [];
   for (const harness of harnesses) {
     for (const configPath of harness.configPaths) {
-      if (existsSync14(configPath)) {
+      if (existsSync15(configPath)) {
         detected.push({
           ...harness,
           detected: true,
@@ -23089,19 +23188,19 @@ function detectHarnesses(harnesses) {
   return detected;
 }
 function backupConfig(configPath) {
-  const backupDir = join14(homedir11(), ".nairon", "backups");
-  if (!existsSync14(backupDir)) {
-    mkdirSync5(backupDir, { recursive: true });
+  const backupDir = join15(homedir12(), ".nairon", "backups");
+  if (!existsSync15(backupDir)) {
+    mkdirSync6(backupDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = configPath.replace(/[/\\]/g, "_").replace(/^_/, "");
-  const backupPath = join14(backupDir, `${timestamp}_${filename}`);
+  const backupPath = join15(backupDir, `${timestamp}_${filename}`);
   copyFileSync(configPath, backupPath);
   return backupPath;
 }
 function readJsonConfig(configPath) {
   try {
-    const content = readFileSync13(configPath, "utf-8");
+    const content = readFileSync14(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -23109,10 +23208,10 @@ function readJsonConfig(configPath) {
 }
 function writeJsonConfig(configPath, config) {
   const dir = dirname2(configPath);
-  if (!existsSync14(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync15(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
-  writeFileSync6(configPath, JSON.stringify(config, null, 2));
+  writeFileSync7(configPath, JSON.stringify(config, null, 2));
 }
 async function prompt2(question) {
   const rl = createInterface({
@@ -23153,7 +23252,7 @@ function getInstalledMCPs(harnesses) {
   const installed = new Set;
   for (const harness of harnesses) {
     for (const configPath of harness.configPaths) {
-      if (!existsSync14(configPath))
+      if (!existsSync15(configPath))
         continue;
       const config = readJsonConfig(configPath);
       const mcpServers = config[harness.mcpConfigKey];
@@ -23177,7 +23276,7 @@ async function installMCPServer(serverName, instruction, harness) {
   if (!harness.configPath || !instruction.mcpServerConfig)
     return false;
   try {
-    if (existsSync14(harness.configPath)) {
+    if (existsSync15(harness.configPath)) {
       backupConfig(harness.configPath);
     }
     const config = readJsonConfig(harness.configPath);
@@ -23205,16 +23304,16 @@ async function installMCPServer(serverName, instruction, harness) {
 async function installBeads(projectDir) {
   try {
     try {
-      execSync3("bd --version", { stdio: "ignore" });
+      execSync4("bd --version", { stdio: "ignore" });
     } catch {
       const spinner = createSpinner("Installing Beads globally...");
       spinner.start();
       try {
-        execSync3("bun add -g beads", { stdio: "ignore" });
+        execSync4("bun add -g beads", { stdio: "ignore" });
         spinner.succeed("Beads installed globally");
       } catch {
         try {
-          execSync3("npm install -g beads", { stdio: "ignore" });
+          execSync4("npm install -g beads", { stdio: "ignore" });
           spinner.succeed("Beads installed globally (via npm)");
         } catch {
           spinner.fail("Failed to install Beads globally");
@@ -23222,13 +23321,13 @@ async function installBeads(projectDir) {
         }
       }
     }
-    const beadsDir = join14(projectDir, ".beads");
-    if (!existsSync14(beadsDir)) {
+    const beadsDir = join15(projectDir, ".beads");
+    if (!existsSync15(beadsDir)) {
       const projectName = projectDir.split(/[/\\]/).pop() ?? "project";
       const initSpinner = createSpinner(`Initializing Beads in ${projectName}...`);
       initSpinner.start();
       try {
-        execSync3(`bd init ${projectName}`, { cwd: projectDir, stdio: "ignore" });
+        execSync4(`bd init ${projectName}`, { cwd: projectDir, stdio: "ignore" });
         initSpinner.succeed(`Beads initialized in ${projectName}`);
       } catch {
         initSpinner.fail("Failed to initialize Beads in project");
@@ -23242,9 +23341,9 @@ async function installBeads(projectDir) {
   }
 }
 async function createClaudeRules(projectDir) {
-  const claudeMdPath = join14(projectDir, "CLAUDE.md");
-  const agentsMdPath = join14(projectDir, "AGENTS.md");
-  if (existsSync14(claudeMdPath) || existsSync14(agentsMdPath)) {
+  const claudeMdPath = join15(projectDir, "CLAUDE.md");
+  const agentsMdPath = join15(projectDir, "AGENTS.md");
+  if (existsSync15(claudeMdPath) || existsSync15(agentsMdPath)) {
     console.log(`  ${icons.info} CLAUDE.md or AGENTS.md already exists`);
     return true;
   }
@@ -23278,7 +23377,7 @@ bun run build
 Use conventional commits: feat:, fix:, docs:, refactor:, test:, chore:
 `;
   try {
-    writeFileSync6(claudeMdPath, content);
+    writeFileSync7(claudeMdPath, content);
     return true;
   } catch {
     return false;
@@ -23558,7 +23657,7 @@ var setupCommand = defineCommand2({
 });
 
 // src/commands/upgrade.ts
-import { execSync as execSync4 } from "node:child_process";
+import { execSync as execSync5 } from "node:child_process";
 var CYAN = "\x1B[36m";
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
@@ -23568,8 +23667,30 @@ var RESET = "\x1B[0m";
 var MAGENTA = "\x1B[35m";
 var CHANGELOG = [
   {
-    version: "0.4.0",
+    version: "0.5.1",
+    date: "2026-02-14",
+    title: "Smart Project Onboarding",
+    highlights: [
+      "First scan detects your project and suggests relevant skills",
+      "Auto-installs find-skills to discover more tools later",
+      "Analyzes README to recommend skills for your tech stack",
+      "Detects your AI agent (Claude Code, OpenCode, Cursor)"
+    ]
+  },
+  {
+    version: "0.5.0",
     date: "2026-02-14",
+    title: "Interactive-First CLI",
+    highlights: [
+      "No more flags to remember - commands guide you through options",
+      "Just run nb scan or nb report and follow the prompts",
+      "Public link is now the first option for report sharing",
+      "CI/scripts still supported via --json flag"
+    ]
+  },
+  {
+    version: "0.4.0",
+    date: "2026-02-13",
     title: "AI Work Visibility",
     highlights: [
       "New: Effort breakdown shows generation/review/correction/integration time",
@@ -23604,7 +23725,7 @@ var CHANGELOG = [
     title: "Reliable Recommendations",
     highlights: [
       "Fixed skills.sh format - skills now install correctly",
-      "New: nb doctor --verify-recommendations to validate install commands"
+      "Improved recommendation validation before release"
     ]
   },
   {
@@ -23872,7 +23993,7 @@ var upgradeCommand = defineCommand2({
     console.log(`${DIM}  Checking for updates...${RESET}`);
     let latestVersion;
     try {
-      latestVersion = execSync4("npm view nairon-bench version", { encoding: "utf-8" }).trim();
+      latestVersion = execSync5("npm view nairon-bench version", { encoding: "utf-8" }).trim();
     } catch {
       console.log(`  ${YELLOW}⚠${RESET} Could not check npm registry`);
       console.log(`  ${DIM}Run 'bun add -g nairon-bench@latest' manually${RESET}`);
@@ -23899,7 +24020,7 @@ var upgradeCommand = defineCommand2({
     console.log(`  ${CYAN}↓${RESET} Upgrading to ${GREEN}v${latestVersion}${RESET}...`);
     console.log();
     try {
-      execSync4("npm install -g nairon-bench@latest", {
+      execSync5("npm install -g nairon-bench@latest", {
         stdio: "inherit",
         env: { ...process.env, npm_config_fund: "false" }
       });
@@ -23917,7 +24038,7 @@ var upgradeCommand = defineCommand2({
 });
 function getCurrentVersion() {
   try {
-    const output = execSync4("nb --version 2>/dev/null || nairon-bench --version 2>/dev/null", {
+    const output = execSync5("nb --version 2>/dev/null || nairon-bench --version 2>/dev/null", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -24006,7 +24127,7 @@ function showFullChangelog() {
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.4.0",
+  version: "0.5.1",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -24014,7 +24135,8 @@ var package_default = {
     nb: "./dist/index.js"
   },
   files: [
-    "dist"
+    "dist",
+    "postinstall.js"
   ],
   repository: {
     type: "git",
@@ -24042,7 +24164,8 @@ var package_default = {
     "test:e2e": "vitest run tests/e2e/",
     "test:watch": "vitest",
     clean: "rm -rf dist",
-    prepublishOnly: "bun run build"
+    prepublishOnly: "bun run build",
+    postinstall: "node postinstall.js || true"
   },
   dependencies: {
     "cli-boxes": "^4.0.1",
@@ -24065,9 +24188,9 @@ var versionCommand = defineCommand2({
 
 // src/commands/init.ts
 init_dist();
-import { existsSync as existsSync15 } from "node:fs";
-import { homedir as homedir12, platform as platform3, arch } from "node:os";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { homedir as homedir13, platform as platform3, arch } from "node:os";
+import { join as join16 } from "node:path";
 init_client();
 
 // src/lib/github-auth.ts
@@ -24237,8 +24360,8 @@ var initCommand = defineCommand2({
     consola.start("Step 2/6: Detecting AI agents...");
     const detectedAgents = [];
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir12());
-      if (existsSync15(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir13());
+      if (existsSync16(resolvedPath)) {
         detectedAgents.push(agent);
         consola.success(`  Found: ${agent}`);
       }
@@ -24341,7 +24464,7 @@ var initCommand = defineCommand2({
       { name: "playwright", configs: ["playwright.config.ts", "playwright.config.js"] }
     ];
     for (const fw of testFrameworks) {
-      if (fw.configs.some((c3) => existsSync15(join15(process.cwd(), c3)))) {
+      if (fw.configs.some((c3) => existsSync16(join16(process.cwd(), c3)))) {
         toolStack.testing.push(fw.name);
       }
     }
@@ -24410,13 +24533,13 @@ var initCommand = defineCommand2({
 });
 function detectPackageManager() {
   const cwd = process.cwd();
-  if (existsSync15(join15(cwd, "bun.lock")) || existsSync15(join15(cwd, "bun.lockb")))
+  if (existsSync16(join16(cwd, "bun.lock")) || existsSync16(join16(cwd, "bun.lockb")))
     return "bun";
-  if (existsSync15(join15(cwd, "pnpm-lock.yaml")))
+  if (existsSync16(join16(cwd, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync15(join15(cwd, "yarn.lock")))
+  if (existsSync16(join16(cwd, "yarn.lock")))
     return "yarn";
-  if (existsSync15(join15(cwd, "package-lock.json")))
+  if (existsSync16(join16(cwd, "package-lock.json")))
     return "npm";
   return;
 }
@@ -24431,15 +24554,15 @@ var CLAUDE_CODE_SKILLS = [
 ];
 function detectEasyWins(detectedAgents) {
   const wins = [];
-  const home = homedir12();
+  const home = homedir13();
   const hasClaudeCode = detectedAgents.some((a2) => a2.toLowerCase().includes("claude") || a2.toLowerCase().includes("opencode"));
-  const claudeConfigDir = join15(home, ".claude");
-  const hasClaudeConfig = existsSync15(claudeConfigDir);
+  const claudeConfigDir = join16(home, ".claude");
+  const hasClaudeConfig = existsSync16(claudeConfigDir);
   if (hasClaudeCode || hasClaudeConfig) {
-    const skillsDir = join15(home, ".claude", "skills");
+    const skillsDir = join16(home, ".claude", "skills");
     for (const skill of CLAUDE_CODE_SKILLS) {
-      const skillPath = join15(skillsDir, skill.id);
-      const isInstalled = existsSync15(skillPath);
+      const skillPath = join16(skillsDir, skill.id);
+      const isInstalled = existsSync16(skillPath);
       if (!isInstalled) {
         wins.push({
           icon: skill.icon,
@@ -24455,12 +24578,12 @@ function detectEasyWins(detectedAgents) {
 // src/commands/onboard.ts
 init_dist();
 init_client();
-import { existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync7, readdirSync as readdirSync9 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync16, writeFileSync as writeFileSync8, readdirSync as readdirSync9 } from "node:fs";
+import { join as join18 } from "node:path";
 
 // src/lib/project-context-detector.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14, readdirSync as readdirSync8 } from "node:fs";
-import { join as join16, basename as basename4 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync15, readdirSync as readdirSync8 } from "node:fs";
+import { join as join17, basename as basename4 } from "node:path";
 function detectProjectContext(projectDir) {
   const projectName = basename4(projectDir);
   const projectId = generateProjectId(projectDir);
@@ -24496,11 +24619,11 @@ function detectTechStack(projectDir) {
   };
 }
 function readPackageJson(projectDir) {
-  const pkgPath = join16(projectDir, "package.json");
-  if (!existsSync16(pkgPath))
+  const pkgPath = join17(projectDir, "package.json");
+  if (!existsSync17(pkgPath))
     return {};
   try {
-    return JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    return JSON.parse(readFileSync15(pkgPath, "utf-8"));
   } catch {
     return {};
   }
@@ -24521,34 +24644,34 @@ function detectFramework(deps) {
   return null;
 }
 function detectMetaFramework(deps, projectDir) {
-  if (deps.next || existsSync16(join16(projectDir, "next.config.js")) || existsSync16(join16(projectDir, "next.config.mjs")))
+  if (deps.next || existsSync17(join17(projectDir, "next.config.js")) || existsSync17(join17(projectDir, "next.config.mjs")))
     return "next";
-  if (deps.nuxt || existsSync16(join16(projectDir, "nuxt.config.ts")))
+  if (deps.nuxt || existsSync17(join17(projectDir, "nuxt.config.ts")))
     return "nuxt";
   if (deps["@sveltejs/kit"])
     return "sveltekit";
-  if (deps.astro || existsSync16(join16(projectDir, "astro.config.mjs")))
+  if (deps.astro || existsSync17(join17(projectDir, "astro.config.mjs")))
     return "astro";
   if (deps["@remix-run/react"])
     return "remix";
   if (deps.gatsby)
     return "gatsby";
-  if (deps.vite || existsSync16(join16(projectDir, "vite.config.ts")))
+  if (deps.vite || existsSync17(join17(projectDir, "vite.config.ts")))
     return "vite";
   return null;
 }
 function detectRuntime(projectDir) {
-  if (existsSync16(join16(projectDir, "bun.lockb")) || existsSync16(join16(projectDir, "bun.lock")))
+  if (existsSync17(join17(projectDir, "bun.lockb")) || existsSync17(join17(projectDir, "bun.lock")))
     return "bun";
-  if (existsSync16(join16(projectDir, "deno.json")) || existsSync16(join16(projectDir, "deno.lock")))
+  if (existsSync17(join17(projectDir, "deno.json")) || existsSync17(join17(projectDir, "deno.lock")))
     return "deno";
   return "node";
 }
 function detectLanguage(projectDir) {
-  if (existsSync16(join16(projectDir, "tsconfig.json")))
+  if (existsSync17(join17(projectDir, "tsconfig.json")))
     return "typescript";
-  const srcDir = join16(projectDir, "src");
-  if (existsSync16(srcDir)) {
+  const srcDir = join17(projectDir, "src");
+  if (existsSync17(srcDir)) {
     try {
       const files = readdirSync8(srcDir);
       if (files.some((f3) => f3.endsWith(".ts") || f3.endsWith(".tsx")))
@@ -24559,7 +24682,7 @@ function detectLanguage(projectDir) {
 }
 function detectStyling(deps, projectDir) {
   const tools = [];
-  if (deps.tailwindcss || existsSync16(join16(projectDir, "tailwind.config.js")) || existsSync16(join16(projectDir, "tailwind.config.ts")))
+  if (deps.tailwindcss || existsSync17(join17(projectDir, "tailwind.config.js")) || existsSync17(join17(projectDir, "tailwind.config.ts")))
     tools.push("tailwind");
   if (deps["styled-components"])
     tools.push("styled-components");
@@ -24604,13 +24727,13 @@ function detectORM(deps) {
 }
 function detectTesting(deps, projectDir) {
   const tools = [];
-  if (deps.vitest || existsSync16(join16(projectDir, "vitest.config.ts")))
+  if (deps.vitest || existsSync17(join17(projectDir, "vitest.config.ts")))
     tools.push("vitest");
-  if (deps.jest || existsSync16(join16(projectDir, "jest.config.js")))
+  if (deps.jest || existsSync17(join17(projectDir, "jest.config.js")))
     tools.push("jest");
-  if (deps["@playwright/test"] || existsSync16(join16(projectDir, "playwright.config.ts")))
+  if (deps["@playwright/test"] || existsSync17(join17(projectDir, "playwright.config.ts")))
     tools.push("playwright");
-  if (deps.cypress || existsSync16(join16(projectDir, "cypress.config.ts")))
+  if (deps.cypress || existsSync17(join17(projectDir, "cypress.config.ts")))
     tools.push("cypress");
   if (deps["@testing-library/react"] || deps["@testing-library/vue"])
     tools.push("testing-library");
@@ -24642,7 +24765,7 @@ function detectBuildTools(deps, projectDir) {
     tools.push("esbuild");
   if (deps.webpack)
     tools.push("webpack");
-  if (deps.turbo || existsSync16(join16(projectDir, "turbo.json")))
+  if (deps.turbo || existsSync17(join17(projectDir, "turbo.json")))
     tools.push("turborepo");
   if (deps.tsup)
     tools.push("tsup");
@@ -24652,17 +24775,17 @@ function detectBuildTools(deps, projectDir) {
 }
 function detectDeployment(projectDir) {
   const tools = [];
-  if (existsSync16(join16(projectDir, "vercel.json")) || existsSync16(join16(projectDir, ".vercel")))
+  if (existsSync17(join17(projectDir, "vercel.json")) || existsSync17(join17(projectDir, ".vercel")))
     tools.push("vercel");
-  if (existsSync16(join16(projectDir, "netlify.toml")))
+  if (existsSync17(join17(projectDir, "netlify.toml")))
     tools.push("netlify");
-  if (existsSync16(join16(projectDir, "fly.toml")))
+  if (existsSync17(join17(projectDir, "fly.toml")))
     tools.push("fly");
-  if (existsSync16(join16(projectDir, "railway.json")))
+  if (existsSync17(join17(projectDir, "railway.json")))
     tools.push("railway");
-  if (existsSync16(join16(projectDir, "Dockerfile")))
+  if (existsSync17(join17(projectDir, "Dockerfile")))
     tools.push("docker");
-  if (existsSync16(join16(projectDir, ".github", "workflows")))
+  if (existsSync17(join17(projectDir, ".github", "workflows")))
     tools.push("github-actions");
   return tools;
 }
@@ -24685,20 +24808,20 @@ function detectAIML(deps) {
   return tools;
 }
 function inferProjectType(projectDir, techStack) {
-  if (existsSync16(join16(projectDir, "packages")) || existsSync16(join16(projectDir, "apps"))) {
+  if (existsSync17(join17(projectDir, "packages")) || existsSync17(join17(projectDir, "apps"))) {
     return "monorepo";
   }
   const pkg = readPackageJson(projectDir);
-  if (pkg.bin || existsSync16(join16(projectDir, "src", "cli.ts")) || existsSync16(join16(projectDir, "src", "index.ts"))) {
+  if (pkg.bin || existsSync17(join17(projectDir, "src", "cli.ts")) || existsSync17(join17(projectDir, "src", "index.ts"))) {
     const hasBin = !!pkg.bin;
-    const hasCommands = existsSync16(join16(projectDir, "src", "commands"));
+    const hasCommands = existsSync17(join17(projectDir, "src", "commands"));
     if (hasBin || hasCommands)
       return "cli";
   }
   if (!techStack.framework && !techStack.metaFramework && pkg.main) {
     return "library";
   }
-  if (existsSync16(join16(projectDir, "app.json")) || existsSync16(join16(projectDir, "expo"))) {
+  if (existsSync17(join17(projectDir, "app.json")) || existsSync17(join17(projectDir, "expo"))) {
     return "mobile";
   }
   if (techStack.database.length > 0 && !techStack.framework) {
@@ -24715,10 +24838,10 @@ function extractDescription(projectDir) {
     return pkg.description;
   const readmePaths = ["README.md", "readme.md", "Readme.md"];
   for (const readme of readmePaths) {
-    const path = join16(projectDir, readme);
-    if (existsSync16(path)) {
+    const path = join17(projectDir, readme);
+    if (existsSync17(path)) {
       try {
-        const content = readFileSync14(path, "utf-8");
+        const content = readFileSync15(path, "utf-8");
         const lines = content.split(`
 `);
         let foundTitle = false;
@@ -26136,9 +26259,9 @@ var onboardCommand = defineCommand2({
   },
   async run({ args }) {
     const projectPath = process.cwd();
-    const contextPath = join17(projectPath, ".nairon", "context.json");
-    if (existsSync17(contextPath) && !args.force) {
-      const existing = JSON.parse(readFileSync15(contextPath, "utf-8"));
+    const contextPath = join18(projectPath, ".nairon", "context.json");
+    if (existsSync18(contextPath) && !args.force) {
+      const existing = JSON.parse(readFileSync16(contextPath, "utf-8"));
       consola.info("Project already onboarded. Use --force to re-run.");
       consola.info(`Business: ${existing.businessContext?.domain || existing.businessContext?.slice?.(0, 50) || "Not set"}...`);
       consola.info(`Stack: ${formatTechStackSummary(existing)}`);
@@ -26286,11 +26409,11 @@ var onboardCommand = defineCommand2({
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString()
     };
-    const naironDir = join17(projectPath, ".nairon");
-    if (!existsSync17(naironDir)) {
-      mkdirSync6(naironDir, { recursive: true });
+    const naironDir = join18(projectPath, ".nairon");
+    if (!existsSync18(naironDir)) {
+      mkdirSync7(naironDir, { recursive: true });
     }
-    writeFileSync7(contextPath, JSON.stringify(fullContext, null, 2));
+    writeFileSync8(contextPath, JSON.stringify(fullContext, null, 2));
     consola.success(`Saved to ${contextPath}`);
     if (isSupermemoryConfigured()) {
       consola.start("Storing in Supermemory...");
@@ -26378,51 +26501,51 @@ function formatTechStackSummary(context) {
 function detectInstalledTools(projectPath) {
   const tools = [];
   const home = process.env.HOME || "";
-  const userClaudeJson = join17(home, ".claude.json");
-  if (existsSync17(userClaudeJson)) {
+  const userClaudeJson = join18(home, ".claude.json");
+  if (existsSync18(userClaudeJson)) {
     try {
-      const config = JSON.parse(readFileSync15(userClaudeJson, "utf-8"));
+      const config = JSON.parse(readFileSync16(userClaudeJson, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const claudeDesktopConfig = join17(home, ".claude", "claude_desktop_config.json");
-  if (existsSync17(claudeDesktopConfig)) {
+  const claudeDesktopConfig = join18(home, ".claude", "claude_desktop_config.json");
+  if (existsSync18(claudeDesktopConfig)) {
     try {
-      const config = JSON.parse(readFileSync15(claudeDesktopConfig, "utf-8"));
+      const config = JSON.parse(readFileSync16(claudeDesktopConfig, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const projectMcpJson = join17(projectPath, ".mcp.json");
-  if (existsSync17(projectMcpJson)) {
+  const projectMcpJson = join18(projectPath, ".mcp.json");
+  if (existsSync18(projectMcpJson)) {
     try {
-      const config = JSON.parse(readFileSync15(projectMcpJson, "utf-8"));
+      const config = JSON.parse(readFileSync16(projectMcpJson, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const projectClaudeConfig = join17(projectPath, ".claude", "settings.json");
-  if (existsSync17(projectClaudeConfig)) {
+  const projectClaudeConfig = join18(projectPath, ".claude", "settings.json");
+  if (existsSync18(projectClaudeConfig)) {
     try {
-      const config = JSON.parse(readFileSync15(projectClaudeConfig, "utf-8"));
+      const config = JSON.parse(readFileSync16(projectClaudeConfig, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const skillsDir = join17(home, ".config", "opencode", "skills");
-  if (existsSync17(skillsDir)) {
+  const skillsDir = join18(home, ".config", "opencode", "skills");
+  if (existsSync18(skillsDir)) {
     try {
       const skills = readdirSync9(skillsDir);
       tools.push(...skills.filter((s2) => !s2.startsWith(".")));
     } catch {}
   }
-  const agentsSkillsDir = join17(home, ".agents", "skills");
-  if (existsSync17(agentsSkillsDir)) {
+  const agentsSkillsDir = join18(home, ".agents", "skills");
+  if (existsSync18(agentsSkillsDir)) {
     try {
       const skills = readdirSync9(agentsSkillsDir);
       tools.push(...skills.filter((s2) => !s2.startsWith(".")));
@@ -26432,11 +26555,11 @@ function detectInstalledTools(projectPath) {
 }
 function detectPrimaryAgent() {
   const home = process.env.HOME || "";
-  if (existsSync17(join17(home, ".claude")))
+  if (existsSync18(join18(home, ".claude")))
     return "claude-code";
-  if (existsSync17(join17(home, ".cursor")))
+  if (existsSync18(join18(home, ".cursor")))
     return "cursor";
-  if (existsSync17(join17(home, ".config", "opencode")))
+  if (existsSync18(join18(home, ".config", "opencode")))
     return "opencode";
   return;
 }
@@ -26531,7 +26654,7 @@ function formatBytes(bytes) {
 // package.json
 var package_default2 = {
   name: "nairon-bench",
-  version: "0.4.0",
+  version: "0.5.1",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -26539,7 +26662,8 @@ var package_default2 = {
     nb: "./dist/index.js"
   },
   files: [
-    "dist"
+    "dist",
+    "postinstall.js"
   ],
   repository: {
     type: "git",
@@ -26567,7 +26691,8 @@ var package_default2 = {
     "test:e2e": "vitest run tests/e2e/",
     "test:watch": "vitest",
     clean: "rm -rf dist",
-    prepublishOnly: "bun run build"
+    prepublishOnly: "bun run build",
+    postinstall: "node postinstall.js || true"
   },
   dependencies: {
     "cli-boxes": "^4.0.1",
@@ -26632,7 +26757,7 @@ var hasVersion = args.includes("--version");
 if (!hasSubcommand && !hasHelp && !hasVersion && args.length === 0) {
   showBanner();
 } else {
-  const main = defineCommand({
+  const cmd = defineCommand({
     meta: {
       name: "nairon-bench",
       version: VERSION2,
@@ -26650,5 +26775,5 @@ if (!hasSubcommand && !hasHelp && !hasVersion && args.length === 0) {
       cache: cacheCommand
     }
   });
-  runMain(main);
+  runMain(cmd);
 }