nairon-bench 0.3.15 → 0.5.0

package/dist/index.js

@@ -15364,6 +15364,362 @@ function wrapText(text, width) {
   return lines;
 }
 
+// src/lib/effort-analyzer.ts
+function analyzeEffort(sessions, git) {
+  const sessionEfforts = [];
+  let totalGeneration = 0;
+  let totalReview = 0;
+  let totalCorrection = 0;
+  let totalIntegration = 0;
+  let totalCorrectionLoops = 0;
+  let totalContextChurn = 0;
+  let totalRegenerations = 0;
+  for (const session of sessions) {
+    const effort = analyzeSessionEffort(session);
+    sessionEfforts.push(effort);
+    totalGeneration += effort.generationMinutes;
+    totalReview += effort.reviewMinutes;
+    totalCorrection += effort.correctionMinutes;
+    totalIntegration += effort.integrationMinutes;
+    for (const pattern of session.patterns) {
+      if (pattern.type === "undo_loop") {
+        totalCorrectionLoops += pattern.count;
+      }
+      if (pattern.type === "context_compaction" || pattern.type === "memory_loss") {
+        totalContextChurn += pattern.count;
+      }
+      if (pattern.type === "repeated_rephrasing") {
+        totalRegenerations += pattern.count;
+      }
+    }
+  }
+  const totalMinutes = totalGeneration + totalReview + totalCorrection + totalIntegration;
+  const safeTotal = totalMinutes || 1;
+  const generationPercent = Math.round(totalGeneration / safeTotal * 100);
+  const reviewPercent = Math.round(totalReview / safeTotal * 100);
+  const correctionPercent = Math.round(totalCorrection / safeTotal * 100);
+  const integrationPercent = Math.round(totalIntegration / safeTotal * 100);
+  const safeGeneration = totalGeneration || 1;
+  const correctionRatio = totalCorrection / safeGeneration;
+  const reviewOverhead = totalReview / safeGeneration;
+  const trueEffortMultiplier = totalMinutes / safeGeneration;
+  return {
+    generationMinutes: totalGeneration,
+    reviewMinutes: totalReview,
+    correctionMinutes: totalCorrection,
+    integrationMinutes: totalIntegration,
+    totalMinutes,
+    generationPercent,
+    reviewPercent,
+    correctionPercent,
+    integrationPercent,
+    totalSessions: sessions.length,
+    correctionLoops: totalCorrectionLoops,
+    contextChurnEvents: totalContextChurn,
+    regenerationCycles: totalRegenerations,
+    correctionRatio: Math.round(correctionRatio * 100) / 100,
+    reviewOverhead: Math.round(reviewOverhead * 100) / 100,
+    trueEffortMultiplier: Math.round(trueEffortMultiplier * 100) / 100,
+    sessions: sessionEfforts
+  };
+}
+function analyzeSessionEffort(session) {
+  const totalMinutes = session.durationMinutes;
+  let generationRatio = 0.4;
+  let reviewRatio = 0.3;
+  let correctionRatio = 0.2;
+  let integrationRatio = 0.1;
+  const patterns = [];
+  let contextChurn = "low";
+  let correctionIntensity = "low";
+  for (const pattern of session.patterns) {
+    patterns.push(pattern.type);
+    if (pattern.type === "undo_loop") {
+      const undoImpact = Math.min(pattern.count * 0.05, 0.25);
+      correctionRatio += undoImpact;
+      generationRatio -= undoImpact / 2;
+      reviewRatio -= undoImpact / 2;
+      correctionIntensity = pattern.count >= 5 ? "high" : pattern.count >= 2 ? "medium" : "low";
+    }
+    if (pattern.type === "memory_loss" || pattern.type === "context_compaction") {
+      const contextImpact = Math.min(pattern.count * 0.08, 0.2);
+      correctionRatio += contextImpact / 2;
+      reviewRatio += contextImpact / 2;
+      generationRatio -= contextImpact;
+      contextChurn = pattern.count >= 3 ? "high" : pattern.count >= 1 ? "medium" : "low";
+    }
+    if (pattern.type === "repeated_rephrasing") {
+      const rephrasingImpact = Math.min(pattern.count * 0.03, 0.15);
+      generationRatio += rephrasingImpact;
+      reviewRatio -= rephrasingImpact / 2;
+      integrationRatio -= rephrasingImpact / 2;
+    }
+    if (pattern.type === "frustration_caps") {
+      correctionRatio += 0.05;
+      reviewRatio -= 0.05;
+    }
+    if (pattern.type === "smooth_flow") {
+      generationRatio += 0.1;
+      correctionRatio -= 0.1;
+    }
+  }
+  const totalRatio = generationRatio + reviewRatio + correctionRatio + integrationRatio;
+  generationRatio /= totalRatio;
+  reviewRatio /= totalRatio;
+  correctionRatio /= totalRatio;
+  integrationRatio /= totalRatio;
+  const generationMinutes = Math.round(totalMinutes * generationRatio);
+  const reviewMinutes = Math.round(totalMinutes * reviewRatio);
+  const correctionMinutes = Math.round(totalMinutes * correctionRatio);
+  const integrationMinutes = totalMinutes - generationMinutes - reviewMinutes - correctionMinutes;
+  return {
+    sessionId: session.sessionId,
+    agent: session.agent,
+    startedAt: session.startedAt,
+    generationMinutes,
+    reviewMinutes,
+    correctionMinutes,
+    integrationMinutes,
+    totalMinutes,
+    patterns,
+    contextChurn,
+    correctionIntensity
+  };
+}
+function generateLeadershipReport(effort, periodLabel = "Last 7 days") {
+  const totalHours = effort.totalMinutes / 60;
+  const generationHours = effort.generationMinutes / 60;
+  const reviewHours = effort.reviewMinutes / 60;
+  const correctionHours = effort.correctionMinutes / 60;
+  const integrationHours = effort.integrationMinutes / 60;
+  const perceivedEffort = generationHours;
+  const hiddenWork = totalHours - perceivedEffort;
+  const hiddenWorkPercent = hiddenWork / totalHours * 100;
+  const contextChurnRate = effort.contextChurnEvents / Math.max(effort.totalSessions, 1);
+  const repeatedCorrectionRate = effort.correctionLoops / Math.max(effort.totalSessions, 1);
+  let burnoutRisk = "low";
+  if (effort.correctionRatio > 0.8 || hiddenWorkPercent > 60) {
+    burnoutRisk = "high";
+  } else if (effort.correctionRatio > 0.5 || hiddenWorkPercent > 40) {
+    burnoutRisk = "medium";
+  }
+  const insights = [];
+  if (hiddenWorkPercent > 50) {
+    insights.push(`${Math.round(hiddenWorkPercent)}% of effort is invisible (review, correction, integration) - leadership may underestimate true workload`);
+  }
+  if (effort.correctionRatio > 0.5) {
+    insights.push(`High correction ratio (${Math.round(effort.correctionRatio * 100)}%) - AI output requires significant human oversight`);
+  }
+  if (contextChurnRate > 0.5) {
+    insights.push(`Frequent context loss (${Math.round(contextChurnRate * 100)}% of sessions) - engineers repeatedly re-explaining requirements`);
+  }
+  if (effort.trueEffortMultiplier > 2) {
+    insights.push(`True effort is ${effort.trueEffortMultiplier.toFixed(1)}x perceived effort - AI accelerates generation but not total delivery`);
+  }
+  if (burnoutRisk === "high") {
+    insights.push("High burnout risk: excessive correction cycles indicate AI output quality issues");
+  }
+  if (insights.length === 0) {
+    insights.push("AI workflow appears efficient - correction overhead is within healthy limits");
+  }
+  return {
+    period: periodLabel,
+    aiAssistedTasksCount: effort.totalSessions,
+    totalAIGenerationHours: Math.round(generationHours * 10) / 10,
+    totalReviewHours: Math.round(reviewHours * 10) / 10,
+    totalCorrectionHours: Math.round(correctionHours * 10) / 10,
+    totalIntegrationHours: Math.round(integrationHours * 10) / 10,
+    totalEffortHours: Math.round(totalHours * 10) / 10,
+    averageCorrectionRatio: Math.round(effort.correctionRatio * 100) / 100,
+    integrationOverheadPercent: effort.integrationPercent,
+    contextChurnRate: Math.round(contextChurnRate * 100) / 100,
+    perceivedEffortHours: Math.round(perceivedEffort * 10) / 10,
+    trueEffortHours: Math.round(totalHours * 10) / 10,
+    hiddenWorkHours: Math.round(hiddenWork * 10) / 10,
+    hiddenWorkPercent: Math.round(hiddenWorkPercent),
+    burnoutRisk,
+    contextLossFrequency: effort.contextChurnEvents,
+    repeatedCorrectionRate: Math.round(repeatedCorrectionRate * 100) / 100,
+    insights
+  };
+}
+function formatEffortBreakdown(effort) {
+  const lines = [];
+  lines.push("");
+  lines.push(colors2.dim("  " + "═".repeat(50)));
+  lines.push(`  ${icons.chart} ${colors2.bold("Effort Breakdown")} ${colors2.dim("(AI Work Visibility)")}`);
+  lines.push(colors2.dim("  " + "═".repeat(50)));
+  lines.push("");
+  const total = effort.totalMinutes || 1;
+  const genBar = "█".repeat(Math.round(effort.generationPercent / 5));
+  const revBar = "█".repeat(Math.round(effort.reviewPercent / 5));
+  const corBar = "█".repeat(Math.round(effort.correctionPercent / 5));
+  const intBar = "█".repeat(Math.round(effort.integrationPercent / 5));
+  lines.push(`  ${colors2.bold("Time Breakdown:")}`);
+  lines.push(`    ${colors2.success("Generation")}    ${formatTime(effort.generationMinutes).padEnd(10)} ${colors2.success(genBar)} ${effort.generationPercent}%`);
+  lines.push(`    ${colors2.primary("Review")}        ${formatTime(effort.reviewMinutes).padEnd(10)} ${colors2.primary(revBar)} ${effort.reviewPercent}%`);
+  lines.push(`    ${colors2.warning("Correction")}    ${formatTime(effort.correctionMinutes).padEnd(10)} ${colors2.warning(corBar)} ${effort.correctionPercent}%`);
+  lines.push(`    ${colors2.dim("Integration")}   ${formatTime(effort.integrationMinutes).padEnd(10)} ${colors2.dim(intBar)} ${effort.integrationPercent}%`);
+  lines.push("");
+  lines.push(`    ${colors2.bold("Total Active Effort:")} ${formatTime(effort.totalMinutes)}`);
+  lines.push("");
+  const hiddenWork = effort.reviewMinutes + effort.correctionMinutes + effort.integrationMinutes;
+  const hiddenPercent = Math.round(hiddenWork / total * 100);
+  if (hiddenPercent > 30) {
+    lines.push(`  ${colors2.warning("!")} ${colors2.bold("Hidden Work Alert:")}`);
+    lines.push(`    ${hiddenPercent}% of effort is invisible (review + correction + integration)`);
+    lines.push(`    ${colors2.dim("This is work leadership may not see")}`);
+    lines.push("");
+  }
+  lines.push(`  ${colors2.bold("Key Metrics:")}`);
+  lines.push(`    Correction ratio:    ${formatRatio(effort.correctionRatio)} ${getRatioIndicator(effort.correctionRatio)}`);
+  lines.push(`    Review overhead:     ${formatRatio(effort.reviewOverhead)}`);
+  lines.push(`    True effort factor:  ${effort.trueEffortMultiplier}x ${colors2.dim("(total / generation)")}`);
+  lines.push("");
+  if (effort.correctionLoops > 0 || effort.contextChurnEvents > 0) {
+    lines.push(`  ${colors2.bold("Detected Issues:")}`);
+    if (effort.correctionLoops > 0) {
+      lines.push(`    ${colors2.warning("•")} ${effort.correctionLoops} correction loop${effort.correctionLoops > 1 ? "s" : ""}`);
+    }
+    if (effort.contextChurnEvents > 0) {
+      lines.push(`    ${colors2.warning("•")} ${effort.contextChurnEvents} context churn event${effort.contextChurnEvents > 1 ? "s" : ""}`);
+    }
+    if (effort.regenerationCycles > 0) {
+      lines.push(`    ${colors2.dim("•")} ${effort.regenerationCycles} regeneration cycle${effort.regenerationCycles > 1 ? "s" : ""}`);
+    }
+    lines.push("");
+  }
+  lines.push(colors2.dim("  " + "═".repeat(50)));
+  return lines;
+}
+function formatLeadershipReport(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(colors2.dim("  " + "═".repeat(60)));
+  lines.push(`  ${icons.chart} ${colors2.bold("Leadership Report")} ${colors2.dim(`(${report.period})`)}`);
+  lines.push(colors2.dim("  " + "═".repeat(60)));
+  lines.push("");
+  lines.push(`  ${colors2.bold("Executive Summary")}`);
+  lines.push(`  ─────────────────────────────────────────────────────`);
+  lines.push(`    AI-Assisted Sessions:   ${report.aiAssistedTasksCount}`);
+  lines.push(`    Total Effort:           ${report.totalEffortHours} hours`);
+  lines.push("");
+  lines.push(`  ${colors2.bold("Effort Visibility")}`);
+  lines.push(`  ─────────────────────────────────────────────────────`);
+  lines.push(`    ${colors2.success("AI Generation:")}      ${report.totalAIGenerationHours}h ${colors2.dim("← What leadership sees")}`);
+  lines.push(`    ${colors2.primary("Review:")}             ${report.totalReviewHours}h`);
+  lines.push(`    ${colors2.warning("Correction:")}         ${report.totalCorrectionHours}h`);
+  lines.push(`    ${colors2.dim("Integration:")}        ${report.totalIntegrationHours}h`);
+  lines.push(`    ─────────────────────────────────────────────────`);
+  lines.push(`    ${colors2.bold("True Total:")}         ${report.trueEffortHours}h ${colors2.dim("← Actual effort")}`);
+  lines.push("");
+  if (report.hiddenWorkPercent > 20) {
+    lines.push(`  ${colors2.warning(icons.warning)} ${colors2.bold("Hidden Work:")}`);
+    lines.push(`    ${report.hiddenWorkHours}h (${report.hiddenWorkPercent}%) is invisible to leadership`);
+    lines.push("");
+  }
+  lines.push(`  ${colors2.bold("Risk Indicators")}`);
+  lines.push(`  ─────────────────────────────────────────────────────`);
+  const burnoutColor = report.burnoutRisk === "high" ? colors2.error : report.burnoutRisk === "medium" ? colors2.warning : colors2.success;
+  lines.push(`    Burnout Risk:          ${burnoutColor(report.burnoutRisk.toUpperCase())}`);
+  lines.push(`    Correction Ratio:      ${report.averageCorrectionRatio} ${getRatioIndicator(report.averageCorrectionRatio)}`);
+  lines.push(`    Context Churn Rate:    ${report.contextChurnRate}`);
+  lines.push("");
+  if (report.insights.length > 0) {
+    lines.push(`  ${colors2.bold("Key Insights")}`);
+    lines.push(`  ─────────────────────────────────────────────────────`);
+    for (const insight of report.insights) {
+      lines.push(`    ${colors2.primary("→")} ${insight}`);
+    }
+    lines.push("");
+  }
+  lines.push(colors2.dim("  " + "═".repeat(60)));
+  return lines;
+}
+function formatLeadershipReportMarkdown(report) {
+  let md = `# AI Work Visibility Report
+
+`;
+  md += `**Period:** ${report.period}
+
+`;
+  md += `## Executive Summary
+
+`;
+  md += `| Metric | Value |
+`;
+  md += `|--------|-------|
+`;
+  md += `| AI-Assisted Sessions | ${report.aiAssistedTasksCount} |
+`;
+  md += `| Total Effort | ${report.totalEffortHours} hours |
+`;
+  md += `| Perceived Effort (AI Generation) | ${report.perceivedEffortHours} hours |
+`;
+  md += `| Hidden Work | ${report.hiddenWorkHours} hours (${report.hiddenWorkPercent}%) |
+
+`;
+  md += `## Effort Breakdown
+
+`;
+  md += `| Phase | Hours | % of Total |
+`;
+  md += `|-------|-------|------------|
+`;
+  md += `| AI Generation | ${report.totalAIGenerationHours}h | ${Math.round(report.totalAIGenerationHours / report.totalEffortHours * 100)}% |
+`;
+  md += `| Review | ${report.totalReviewHours}h | ${Math.round(report.totalReviewHours / report.totalEffortHours * 100)}% |
+`;
+  md += `| Correction | ${report.totalCorrectionHours}h | ${Math.round(report.totalCorrectionHours / report.totalEffortHours * 100)}% |
+`;
+  md += `| Integration | ${report.totalIntegrationHours}h | ${Math.round(report.totalIntegrationHours / report.totalEffortHours * 100)}% |
+
+`;
+  md += `## Risk Assessment
+
+`;
+  md += `- **Burnout Risk:** ${report.burnoutRisk.toUpperCase()}
+`;
+  md += `- **Correction Ratio:** ${report.averageCorrectionRatio}
+`;
+  md += `- **Context Churn Rate:** ${report.contextChurnRate}
+
+`;
+  md += `## Key Insights
+
+`;
+  for (const insight of report.insights) {
+    md += `- ${insight}
+`;
+  }
+  md += `
+`;
+  md += `---
+
+`;
+  md += `*Generated by nairon-bench - AI Workflow Benchmarking*
+`;
+  return md;
+}
+function formatTime(minutes) {
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+}
+function formatRatio(ratio) {
+  return `${Math.round(ratio * 100)}%`;
+}
+function getRatioIndicator(ratio) {
+  if (ratio > 0.8)
+    return colors2.error("(high - needs attention)");
+  if (ratio > 0.5)
+    return colors2.warning("(moderate)");
+  return colors2.success("(healthy)");
+}
+
 // src/lib/optimization-installer.ts
 import { execSync as execSync2, spawnSync } from "node:child_process";
 import { existsSync as existsSync8, writeFileSync as writeFileSync3, readFileSync as readFileSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "node:fs";
@@ -15711,159 +16067,52 @@ 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/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)",
+      description: "Only output score number",
       default: false
-    },
-    watch: {
-      type: "boolean",
-      alias: "w",
-      description: "Watch mode - re-scan on file changes",
-      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);
+    }
+    const useCache = true;
+    const watchMode = false;
+    const watchInterval = 30000;
     if (watchMode) {
       console.log();
       console.log(colors2.bold(colors2.primary("  NaironAI Watch Mode")));
@@ -15996,12 +16245,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)}`);
+      const reportDir = join9(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);
@@ -16010,68 +16264,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}`);
@@ -16081,82 +16338,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,
@@ -19023,7 +19213,7 @@ function renderTimelineASCII(timeline) {
   if (timeline.milestones.length > 0) {
     lines.push("  Key Milestones:");
     for (const milestone of timeline.milestones.slice(-5)) {
-      const time = formatTime(milestone.timestamp);
+      const time = formatTime2(milestone.timestamp);
       const icon = getMilestoneIcon(milestone.type);
       lines.push(`  ${time} ${icon} ${truncate(milestone.title, 40)}`);
     }
@@ -19032,7 +19222,7 @@ function renderTimelineASCII(timeline) {
   if (timeline.strugglePoints.length > 0) {
     lines.push("  Struggle Points:");
     for (const struggle of timeline.strugglePoints.slice(-3)) {
-      const time = formatTime(struggle.timestamp);
+      const time = formatTime2(struggle.timestamp);
       const icon = getSeverityIcon(struggle.severity);
       lines.push(`  ${time} ${icon} ${truncate(struggle.description, 40)}`);
     }
@@ -19100,7 +19290,7 @@ function truncate(str, len2) {
 function cleanCommitMessage(message) {
   return message.replace(/^(feat|fix|refactor|docs|test|chore|style|perf|ci|build|revert)(\(.+?\))?:\s*/i, "").replace(/^(add|fix|update|remove|implement|refactor)\s+/i, "").trim();
 }
-function formatTime(date) {
+function formatTime2(date) {
   return date.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
 }
 function formatDate(date) {
@@ -21381,136 +21571,146 @@ 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: {
+    json: {
       type: "boolean",
-      description: "Show score trend over time",
+      description: "Output as JSON (for CI/scripts)",
       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"
     }
   },
   async run({ args }) {
-    if (args.hackathon || args.since) {
-      await runHackathonReport(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.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;
@@ -21724,6 +21924,41 @@ async function publishReport(report) {
     consola.info("Try `nb report --hackathon --format md` for local markdown instead.");
   }
 }
+async function runLeadershipReport(args) {
+  const projectDir = process.cwd();
+  const since = parseSince2(args.since || "7d");
+  const periodLabel = args.since === "30d" ? "Last 30 days" : args.since === "48h" ? "Last 48 hours" : "Last 7 days";
+  consola.start(`Generating leadership report (${periodLabel})...`);
+  const agents = await collectAgentSessions(since);
+  if (!agents || agents.sessions.length === 0) {
+    consola.warn("No AI sessions found in the specified time range.");
+    consola.info("Try running with --since 30d for a longer time range.");
+    return;
+  }
+  const effort = analyzeEffort(agents.sessions);
+  const report = generateLeadershipReport(effort, periodLabel);
+  const format2 = args.format || "terminal";
+  let output;
+  if (format2 === "md" || format2 === "markdown") {
+    output = formatLeadershipReportMarkdown(report);
+  } else {
+    output = formatLeadershipReport(report).join(`
+`);
+  }
+  if (args.output) {
+    const filepath = resolve(projectDir, args.output);
+    writeFileSync5(filepath, output);
+    consola.success(`Report saved to ${filepath}`);
+  }
+  console.log(output);
+  consola.log("");
+  consola.info(`Sessions analyzed: ${report.aiAssistedTasksCount}`);
+  consola.info(`True effort: ${report.trueEffortHours}h (${report.hiddenWorkPercent}% invisible)`);
+  consola.info(`Burnout risk: ${report.burnoutRisk.toUpperCase()}`);
+  if (format2 === "terminal" || !format2) {
+    consola.info("Run `nb report --leadership --format md` for exportable markdown");
+  }
+}
 function parseSince2(since) {
   const match = since.match(/^(\d+)(h|d|w|m)$/);
   if (match) {
@@ -22473,25 +22708,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
     }
   },
@@ -22517,16 +22744,16 @@ 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 = [];
@@ -23160,6 +23387,28 @@ var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 var MAGENTA = "\x1B[35m";
 var CHANGELOG = [
+  {
+    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",
+      "New: nb report --leadership for executive-ready reports",
+      "See hidden work (61% invisible!) that leadership may miss",
+      "Burnout risk detection and true effort multiplier"
+    ]
+  },
   {
     version: "0.3.15",
     date: "2026-02-14",
@@ -23186,7 +23435,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"
     ]
   },
   {
@@ -23588,7 +23837,7 @@ function showFullChangelog() {
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.3.15",
+  version: "0.5.0",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -26113,7 +26362,7 @@ function formatBytes(bytes) {
 // package.json
 var package_default2 = {
   name: "nairon-bench",
-  version: "0.3.15",
+  version: "0.5.0",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nairon-bench",
-  "version": "0.3.15",
+  "version": "0.5.0",
   "description": "AI workflow benchmarking CLI",
   "type": "module",
   "bin": {