nairon-bench 0.3.14 → 0.4.0

package/dist/index.js

@@ -15226,21 +15226,28 @@ function aggregateRecommendations(frustrations) {
   for (const f3 of frustrations) {
     const key = f3.recommendedFix.tool;
     if (!byTool[key]) {
-      byTool[key] = { count: 0, timeSaved: 0, costSaved: 0, fix: f3.recommendedFix };
+      byTool[key] = { count: 0, timeSaved: 0, costSaved: 0, fix: f3.recommendedFix, frustrations: [] };
     }
     byTool[key].count++;
     byTool[key].timeSaved += f3.estimatedTimeWastedMinutes * (f3.recommendedFix.estimatedImprovementPercent / 100);
     byTool[key].costSaved += f3.estimatedCostWasted * (f3.recommendedFix.estimatedImprovementPercent / 100);
+    byTool[key].frustrations.push(f3);
   }
   const recommendations = [];
   for (const [tool, data] of Object.entries(byTool)) {
+    const preventedFrustrations = data.frustrations.sort((a2, b2) => b2.estimatedTimeWastedMinutes - a2.estimatedTimeWastedMinutes).slice(0, 3).map((f3) => ({
+      patternType: f3.patternDescription,
+      promptSnippet: f3.exactPrompt.slice(0, 80) + (f3.exactPrompt.length > 80 ? "..." : ""),
+      timeWasted: f3.estimatedTimeWastedMinutes
+    }));
     recommendations.push({
       tool,
       description: data.fix.description,
       installCommand: data.fix.installCommand,
       wouldHavePreventedCount: data.count,
       estimatedTimeSavedMinutes: Math.round(data.timeSaved),
-      estimatedCostSaved: Math.round(data.costSaved * 100) / 100
+      estimatedCostSaved: Math.round(data.costSaved * 100) / 100,
+      preventedFrustrations
     });
   }
   recommendations.sort((a2, b2) => b2.estimatedTimeSavedMinutes - a2.estimatedTimeSavedMinutes);
@@ -15280,13 +15287,24 @@ function formatFrustrationSummary(summary) {
     }
   }
   if (summary.recommendations.length > 0) {
-    lines.push(`  ${colors2.bold(colors2.primary("Recommended Fixes:"))}`);
+    lines.push(`  ${colors2.bold(colors2.primary("Contextual Recommendations:"))}`);
+    lines.push("");
+    const totalTimeSavings = summary.recommendations.reduce((a2, r3) => a2 + r3.estimatedTimeSavedMinutes, 0);
+    const totalCostSavings = summary.recommendations.reduce((a2, r3) => a2 + r3.estimatedCostSaved, 0);
+    lines.push(`  ${colors2.dim("Total potential savings:")} ${colors2.success(`~${totalTimeSavings} min`)} | ${colors2.success(`$${totalCostSavings.toFixed(2)}`)}`);
     lines.push("");
-    for (const rec of summary.recommendations.slice(0, 3)) {
-      lines.push(`    ${colors2.success("+")} ${colors2.bold(rec.tool)}`);
-      lines.push(`      Would have prevented ${rec.wouldHavePreventedCount} issue${rec.wouldHavePreventedCount > 1 ? "s" : ""}`);
-      lines.push(`      Est. time saved: ${colors2.success(`~${rec.estimatedTimeSavedMinutes} min`)}`);
-      lines.push(`      ${colors2.dim("$")} ${colors2.primary(rec.installCommand)}`);
+    for (let i3 = 0;i3 < Math.min(3, summary.recommendations.length); i3++) {
+      const rec = summary.recommendations[i3];
+      lines.push(`    ${colors2.success(`${i3 + 1}.`)} ${colors2.bold(rec.tool)}`);
+      lines.push(`       ${rec.description}`);
+      lines.push(`       ${colors2.dim("Prevented:")} ${rec.wouldHavePreventedCount} issue${rec.wouldHavePreventedCount > 1 ? "s" : ""} ${colors2.dim("|")} ${colors2.success(`~${rec.estimatedTimeSavedMinutes} min saved`)}`);
+      if (rec.preventedFrustrations.length > 0) {
+        lines.push(`       ${colors2.dim("Would have fixed:")}`);
+        for (const pf of rec.preventedFrustrations.slice(0, 2)) {
+          lines.push(`         ${colors2.dim("•")} ${pf.patternType} ${colors2.dim(`(${pf.timeWasted} min)`)}`);
+        }
+      }
+      lines.push(`       ${colors2.dim("Install:")} ${colors2.primary(rec.installCommand)}`);
       lines.push("");
     }
   }
@@ -15346,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";
@@ -15983,6 +16357,13 @@ var scanCommand = defineCommand2({
         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 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) {
         const frustrationSummary = detectFrustrations(agents.sessions);
         if (frustrationSummary.totalFrustrations > 0) {
@@ -19005,7 +19386,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)}`);
     }
@@ -19014,7 +19395,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)}`);
     }
@@ -19082,7 +19463,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) {
@@ -21411,9 +21792,18 @@ var reportCommand = defineCommand2({
       type: "string",
       description: "Output format: terminal, md, json, or text (legacy)",
       default: "terminal"
+    },
+    leadership: {
+      type: "boolean",
+      description: "Generate leadership report with effort breakdown and hidden work visibility",
+      default: false
     }
   },
   async run({ args }) {
+    if (args.leadership) {
+      await runLeadershipReport(args);
+      return;
+    }
     if (args.hackathon || args.since) {
       await runHackathonReport(args);
       return;
@@ -21706,6 +22096,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) {
@@ -23142,6 +23567,27 @@ var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 var MAGENTA = "\x1B[35m";
 var CHANGELOG = [
+  {
+    version: "0.4.0",
+    date: "2026-02-14",
+    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",
+    title: "Contextual Recommendations",
+    highlights: [
+      "Recommendations now linked to specific frustrations they prevent",
+      "Total time and cost savings summary",
+      "See exactly which issues each tool would have fixed"
+    ]
+  },
   {
     version: "0.3.14",
     date: "2026-02-14",
@@ -23560,7 +24006,7 @@ function showFullChangelog() {
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.3.14",
+  version: "0.4.0",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -26085,7 +26531,7 @@ function formatBytes(bytes) {
 // package.json
 var package_default2 = {
   name: "nairon-bench",
-  version: "0.3.14",
+  version: "0.4.0",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {

package/package.json

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