@lumenflow/cli 1.0.0 → 1.3.0

package/dist/__tests__/flow-report.test.js

@@ -0,0 +1,24 @@
+/**
+ * @file flow-report.test.ts
+ * @description Tests for flow-report CLI command (WU-1018)
+ *
+ * These are smoke tests to verify the CLI module can be imported.
+ * The CLI commands are wrappers around @lumenflow/metrics library functions
+ * which have their own comprehensive tests.
+ */
+import { describe, it, expect } from 'vitest';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+describe('flow-report CLI', () => {
+    it('should have the CLI source file', () => {
+        const srcPath = join(__dirname, '../flow-report.ts');
+        expect(existsSync(srcPath)).toBe(true);
+    });
+    it('should be buildable (dist file exists after build)', () => {
+        // This test verifies that tsc compiled the file successfully
+        const distPath = join(__dirname, '../../dist/flow-report.js');
+        expect(existsSync(distPath)).toBe(true);
+    });
+});

package/dist/__tests__/metrics-snapshot.test.js

@@ -0,0 +1,24 @@
+/**
+ * @file metrics-snapshot.test.ts
+ * @description Tests for metrics-snapshot CLI command (WU-1020)
+ *
+ * These are smoke tests to verify the CLI module can be imported and
+ * that the TypeScript compilation succeeds (verifying the readonly array fix).
+ */
+import { describe, it, expect } from 'vitest';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+describe('metrics-snapshot CLI', () => {
+    it('should have the CLI source file', () => {
+        const srcPath = join(__dirname, '../metrics-snapshot.ts');
+        expect(existsSync(srcPath)).toBe(true);
+    });
+    it('should be buildable (dist file exists after build)', () => {
+        // This test verifies that tsc compiled the file successfully
+        // WU-1020: The readonly array cast fix allows this file to compile
+        const distPath = join(__dirname, '../../dist/metrics-snapshot.js');
+        expect(existsSync(distPath)).toBe(true);
+    });
+});

package/dist/agent-issues-query.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+/**
+ * Agent Issues Query CLI (WU-1018)
+ *
+ * Query and display logged agent incidents/issues.
+ *
+ * Usage:
+ *   pnpm agent:issues-query summary                 # Summary of last 7 days
+ *   pnpm agent:issues-query summary --since 30     # Summary of last 30 days
+ *   pnpm agent:issues-query summary --category tooling
+ *   pnpm agent:issues-query summary --severity blocker
+ *
+ * @module agent-issues-query
+ * @see {@link @lumenflow/agent}
+ */
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[agent:issues-query]';
+/** Default days to query */
+const DEFAULT_SINCE_DAYS = 7;
+/** Issues log file path */
+const ISSUES_LOG_PATH = '.beacon/agent-issues.ndjson';
+/** Valid severity levels */
+const SEVERITY_LEVELS = ['blocker', 'major', 'minor', 'trivial'];
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+    const program = new Command()
+        .name('agent-issues-query')
+        .description('Query and display logged agent incidents')
+        .command('summary', { isDefault: true })
+        .description('Show summary of logged issues')
+        .option('--since <days>', `Days to include (default: ${DEFAULT_SINCE_DAYS})`, String(DEFAULT_SINCE_DAYS))
+        .option('--category <category>', 'Filter by category')
+        .option('--severity <severity>', `Filter by severity: ${SEVERITY_LEVELS.join(', ')}`)
+        .exitOverride();
+    try {
+        program.parse(process.argv);
+        const opts = program.opts();
+        return {
+            since: parseInt(opts.since, 10),
+            category: opts.category,
+            severity: opts.severity,
+        };
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === 'commander.helpDisplayed' || error.code === 'commander.version') {
+            process.exit(0);
+        }
+        throw err;
+    }
+}
+/**
+ * Read issues from NDJSON log file
+ */
+async function readIssues(baseDir, sinceDate, category, severity) {
+    const logPath = join(baseDir, ISSUES_LOG_PATH);
+    if (!existsSync(logPath)) {
+        return [];
+    }
+    const content = await readFile(logPath, { encoding: 'utf-8' });
+    const lines = content.split('\n').filter((line) => line.trim());
+    const issues = [];
+    for (const line of lines) {
+        try {
+            const raw = JSON.parse(line);
+            // Validate required fields
+            if (typeof raw.timestamp !== 'string' ||
+                typeof raw.category !== 'string' ||
+                typeof raw.severity !== 'string' ||
+                typeof raw.title !== 'string') {
+                continue;
+            }
+            const issue = {
+                timestamp: raw.timestamp,
+                wuId: raw.wu_id,
+                sessionId: raw.session_id,
+                category: raw.category,
+                severity: raw.severity,
+                title: raw.title,
+                description: raw.description,
+                stackTrace: raw.stack_trace,
+                metadata: raw.metadata,
+            };
+            // Filter by date
+            const issueDate = new Date(issue.timestamp);
+            if (issueDate < sinceDate) {
+                continue;
+            }
+            // Filter by category
+            if (category && issue.category.toLowerCase() !== category.toLowerCase()) {
+                continue;
+            }
+            // Filter by severity
+            if (severity && issue.severity.toLowerCase() !== severity.toLowerCase()) {
+                continue;
+            }
+            issues.push(issue);
+        }
+        catch {
+            // Skip invalid JSON lines
+        }
+    }
+    return issues;
+}
+/**
+ * Group issues by a key
+ */
+function groupBy(items, key) {
+    const groups = new Map();
+    for (const item of items) {
+        const groupKey = item[key];
+        if (!groups.has(groupKey)) {
+            groups.set(groupKey, []);
+        }
+        groups.get(groupKey).push(item);
+    }
+    return groups;
+}
+/**
+ * Get severity color function
+ */
+function getSeverityColor(severity) {
+    switch (severity) {
+        case 'blocker':
+            return chalk.red.bold;
+        case 'major':
+            return chalk.yellow;
+        case 'minor':
+            return chalk.blue;
+        case 'trivial':
+            return chalk.gray;
+        default:
+            return chalk.white;
+    }
+}
+/**
+ * Format severity badge
+ */
+function formatSeverityBadge(severity) {
+    const color = getSeverityColor(severity);
+    return color(`[${severity.toUpperCase()}]`);
+}
+/**
+ * Display summary of issues
+ */
+function displaySummary(issues, sinceDays) {
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log(`  AGENT ISSUES SUMMARY (last ${sinceDays} days)`);
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    if (issues.length === 0) {
+        console.log('  No issues found in the specified time range.');
+        console.log('');
+        return;
+    }
+    console.log(`  Total issues: ${issues.length}`);
+    console.log('');
+    // Group by severity
+    const bySeverity = groupBy(issues, 'severity');
+    console.log('  By Severity:');
+    for (const severity of SEVERITY_LEVELS) {
+        const count = bySeverity.get(severity)?.length ?? 0;
+        if (count > 0) {
+            const color = getSeverityColor(severity);
+            console.log(`    ${color(severity.toUpperCase().padEnd(10))} ${count}`);
+        }
+    }
+    console.log('');
+    // Group by category
+    const byCategory = groupBy(issues, 'category');
+    console.log('  By Category:');
+    for (const [category, categoryIssues] of byCategory.entries()) {
+        const severityCounts = SEVERITY_LEVELS.map((s) => {
+            const count = categoryIssues.filter((i) => i.severity === s).length;
+            return count > 0 ? `${s[0].toUpperCase()}:${count}` : '';
+        })
+            .filter(Boolean)
+            .join(' ');
+        console.log(`    ${String(category).padEnd(20)} ${categoryIssues.length} issues (${severityCounts})`);
+    }
+    console.log('');
+    // Top 5 most common issues
+    const issueCount = new Map();
+    for (const issue of issues) {
+        const key = `${issue.category}:${issue.title}`;
+        issueCount.set(key, (issueCount.get(key) ?? 0) + 1);
+    }
+    const topIssues = Array.from(issueCount.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+    if (topIssues.length > 0) {
+        console.log('  Top 5 Most Common:');
+        for (const [key, count] of topIssues) {
+            const [category, title] = key.split(':');
+            const truncatedTitle = title.length > 40 ? title.slice(0, 37) + '...' : title;
+            console.log(`    ${count}x  [${category}] ${truncatedTitle}`);
+        }
+        console.log('');
+    }
+    // Recent issues (last 5)
+    const recentIssues = [...issues]
+        .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+        .slice(0, 5);
+    console.log('  Recent Issues:');
+    for (const issue of recentIssues) {
+        const date = new Date(issue.timestamp).toISOString().split('T')[0];
+        const badge = formatSeverityBadge(issue.severity);
+        const wuInfo = issue.wuId ? ` (${issue.wuId})` : '';
+        const truncatedTitle = issue.title.length > 40 ? issue.title.slice(0, 37) + '...' : issue.title;
+        console.log(`    ${date} ${badge} ${truncatedTitle}${wuInfo}`);
+    }
+    console.log('');
+}
+/**
+ * Main function
+ */
+async function main() {
+    const opts = parseArgs();
+    const baseDir = process.cwd();
+    const sinceDate = new Date();
+    sinceDate.setDate(sinceDate.getDate() - opts.since);
+    sinceDate.setHours(0, 0, 0, 0);
+    console.log(`${LOG_PREFIX} Querying issues since ${sinceDate.toISOString().split('T')[0]}`);
+    if (opts.category) {
+        console.log(`${LOG_PREFIX} Category filter: ${opts.category}`);
+    }
+    if (opts.severity) {
+        if (!SEVERITY_LEVELS.includes(opts.severity)) {
+            die(`Invalid severity: ${opts.severity}\n\nValid values: ${SEVERITY_LEVELS.join(', ')}`);
+        }
+        console.log(`${LOG_PREFIX} Severity filter: ${opts.severity}`);
+    }
+    const issues = await readIssues(baseDir, sinceDate, opts.category, opts.severity);
+    displaySummary(issues, opts.since);
+}
+// Guard main() for testability (WU-1366)
+import { fileURLToPath } from 'node:url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        die(`Issues query failed: ${err.message}`);
+    });
+}

package/dist/agent-log-issue.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * Agent Log Issue CLI
+ *
+ * Logs a workflow issue or incident during agent execution.
+ *
+ * Usage:
+ *   pnpm agent:log-issue --category workflow --severity minor --title "..." --description "..."
+ */
+import { Command } from 'commander';
+import { logIncident, getCurrentSession } from '@lumenflow/agent';
+import { EXIT_CODES, INCIDENT_SEVERITY } from '@lumenflow/core/dist/wu-constants.js';
+import chalk from 'chalk';
+const program = new Command()
+    .name('agent:log-issue')
+    .description('Log a workflow issue or incident')
+    .requiredOption('--category <cat>', 'Issue category (workflow|tooling|confusion|violation|error)')
+    .requiredOption('--severity <sev>', 'Severity level (blocker|major|minor|info)')
+    .requiredOption('--title <title>', 'Short description (5-100 chars)')
+    .requiredOption('--description <desc>', 'Detailed context (10-2000 chars)')
+    .option('--resolution <res>', 'How the issue was resolved')
+    .option('--tags <tags>', 'Comma-separated tags (e.g., worktree,gates)')
+    .option('--step <step>', 'Current workflow step (e.g., wu:done, gates)')
+    .option('--files <files>', 'Comma-separated related files')
+    .action(async (opts) => {
+    try {
+        const session = await getCurrentSession();
+        if (!session) {
+            console.error(chalk.red('Error: No active session'));
+            console.error('Run: pnpm agent:session --wu WU-XXX --tier N');
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const incident = {
+            category: opts.category,
+            severity: opts.severity,
+            title: opts.title,
+            description: opts.description,
+            resolution: opts.resolution,
+            tags: opts.tags ? opts.tags.split(',').map((t) => t.trim()) : [],
+            context: {
+                current_step: opts.step,
+                related_files: opts.files ? opts.files.split(',').map((f) => f.trim()) : [],
+            },
+        };
+        await logIncident(incident);
+        console.log(chalk.green(`✓ Issue logged`));
+        console.log(`  Category: ${chalk.cyan(opts.category)}`);
+        console.log(`  Severity: ${chalk.cyan(opts.severity)}`);
+        console.log(`  File: ${chalk.gray(`.beacon/incidents/${opts.category}.ndjson`)}`);
+        if (opts.severity === INCIDENT_SEVERITY.MAJOR ||
+            opts.severity === INCIDENT_SEVERITY.BLOCKER) {
+            console.log();
+            console.log(chalk.yellow('  ⚠  Consider documenting this in your WU notes as well.'));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        if (err.issues) {
+            console.error(chalk.red('Validation errors:'));
+            err.issues.forEach((issue) => {
+                console.error(chalk.red(`  - ${issue.path.join('.')}: ${issue.message}`));
+            });
+        }
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+program.parse();

package/dist/agent-session-end.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Agent Session End CLI
+ *
+ * Ends the current agent session and returns summary.
+ *
+ * Usage:
+ *   pnpm agent:session:end
+ */
+import { Command } from 'commander';
+import { endSession, getCurrentSession } from '@lumenflow/agent';
+import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import chalk from 'chalk';
+const program = new Command()
+    .name('agent:session:end')
+    .description('End the current agent session')
+    .action(async () => {
+    try {
+        const session = await getCurrentSession();
+        if (!session) {
+            console.error(chalk.yellow('No active session to end.'));
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        const summary = await endSession();
+        console.log(chalk.green(`✓ Session ended`));
+        console.log(`  WU: ${chalk.cyan(summary.wu_id)}`);
+        console.log(`  Lane: ${chalk.cyan(summary.lane)}`);
+        console.log(`  Duration: ${chalk.cyan(summary.started)} → ${chalk.cyan(summary.completed)}`);
+        console.log(`  Incidents: ${summary.incidents_logged} (${summary.incidents_major} major)`);
+    }
+    catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+program.parse();

package/dist/agent-session.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+/**
+ * Agent Session Start CLI
+ *
+ * Starts an agent session for tracking WU execution.
+ *
+ * Usage:
+ *   pnpm agent:session --wu WU-1234 --tier 2
+ */
+import { Command } from 'commander';
+import { startSession, getCurrentSession } from '@lumenflow/agent';
+import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import chalk from 'chalk';
+const program = new Command()
+    .name('agent:session')
+    .description('Start an agent session')
+    .requiredOption('--wu <id>', 'WU ID to work on (e.g., WU-1234)')
+    .requiredOption('--tier <tier>', 'Context tier (1, 2, or 3)')
+    .option('--agent-type <type>', 'Agent type', 'claude-code')
+    .action(async (opts) => {
+    try {
+        // Check for existing session
+        const existing = await getCurrentSession();
+        if (existing) {
+            console.error(chalk.red(`Session already active for ${existing.wu_id}`));
+            console.error(`Run: pnpm agent:session:end to close it first.`);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const tier = parseInt(opts.tier, 10);
+        if (![1, 2, 3].includes(tier)) {
+            console.error(chalk.red('Invalid tier. Must be 1, 2, or 3.'));
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const sessionId = await startSession(opts.wu, tier, opts.agentType);
+        console.log(chalk.green(`✓ Session started`));
+        console.log(`  Session ID: ${chalk.cyan(sessionId.slice(0, 8))}...`);
+        console.log(`  WU: ${chalk.cyan(opts.wu)}`);
+        console.log(`  Tier: ${chalk.cyan(tier)}`);
+        console.log(`  Agent: ${chalk.cyan(opts.agentType)}`);
+    }
+    catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+program.parse();

package/dist/flow-bottlenecks.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+/**
+ * Flow Bottlenecks Analysis CLI (WU-1018)
+ *
+ * Analyzes WU dependency graph to identify bottlenecks and critical paths.
+ *
+ * Usage:
+ *   pnpm flow:bottlenecks                   # Default: top 10 bottlenecks, JSON output
+ *   pnpm flow:bottlenecks --limit 5         # Top 5 bottlenecks
+ *   pnpm flow:bottlenecks --format table    # Table output
+ *   pnpm flow:bottlenecks --format mermaid  # Mermaid diagram of critical path
+ *
+ * @module flow-bottlenecks
+ * @see {@link @lumenflow/metrics/flow/analyze-bottlenecks}
+ */
+import { Command } from 'commander';
+import { getBottleneckAnalysis, } from '@lumenflow/metrics';
+import { buildDependencyGraph, renderMermaid } from '@lumenflow/core/dist/dependency-graph.js';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[flow:bottlenecks]';
+/** Default bottleneck limit */
+const DEFAULT_LIMIT = 10;
+/** Output format options */
+const OUTPUT_FORMATS = {
+    JSON: 'json',
+    TABLE: 'table',
+    MERMAID: 'mermaid',
+};
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+    const program = new Command()
+        .name('flow-bottlenecks')
+        .description('Analyze WU dependency graph for bottlenecks and critical paths')
+        .option('--limit <number>', `Number of bottlenecks to show (default: ${DEFAULT_LIMIT})`, String(DEFAULT_LIMIT))
+        .option('--format <type>', `Output format: json, table, mermaid (default: json)`, OUTPUT_FORMATS.JSON)
+        .exitOverride();
+    try {
+        program.parse(process.argv);
+        return program.opts();
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === 'commander.helpDisplayed' || error.code === 'commander.version') {
+            process.exit(0);
+        }
+        throw err;
+    }
+}
+/**
+ * Convert core DependencyGraph to metrics DependencyGraph format
+ *
+ * The core module uses a slightly different node format, so we need to transform it.
+ */
+function convertToMetricsGraph(coreGraph) {
+    const metricsGraph = new Map();
+    for (const [id, node] of coreGraph.entries()) {
+        metricsGraph.set(id, {
+            id: node.id,
+            title: node.title,
+            blocks: node.blocks,
+            blockedBy: node.blockedBy,
+            status: node.status,
+        });
+    }
+    return metricsGraph;
+}
+/**
+ * Format analysis as table output
+ */
+function formatAsTable(analysis) {
+    const lines = [];
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('  BOTTLENECK ANALYSIS');
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+    // Critical Path section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ CRITICAL PATH                                               │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    if (analysis.criticalPath.warning) {
+        lines.push(`│ ⚠️  ${analysis.criticalPath.warning.padEnd(56)} │`);
+        if (analysis.criticalPath.cycleNodes && analysis.criticalPath.cycleNodes.length > 0) {
+            lines.push(`│ Cycle nodes: ${analysis.criticalPath.cycleNodes.join(', ').slice(0, 46)} │`);
+        }
+    }
+    else if (analysis.criticalPath.path.length === 0) {
+        lines.push('│ No critical path (all WUs are independent or completed)   │');
+    }
+    else {
+        lines.push(`│ Length: ${analysis.criticalPath.length} WUs`);
+        lines.push('│');
+        lines.push('│ Path:');
+        for (let i = 0; i < analysis.criticalPath.path.length; i++) {
+            const wuId = analysis.criticalPath.path[i];
+            const arrow = i < analysis.criticalPath.path.length - 1 ? ' → ' : '';
+            lines.push(`│   ${i + 1}. ${wuId}${arrow}`);
+        }
+    }
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    lines.push('');
+    // Bottlenecks section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ TOP BOTTLENECKS (by impact score)                          │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    if (analysis.bottlenecks.length === 0) {
+        lines.push('│ No bottlenecks found (no active dependencies)             │');
+    }
+    else {
+        lines.push('│  #  WU ID     Score  Title                                │');
+        lines.push('│ ─── ───────── ─────  ─────────────────────────────────────│');
+        for (let i = 0; i < analysis.bottlenecks.length; i++) {
+            const b = analysis.bottlenecks[i];
+            const rank = String(i + 1).padStart(2);
+            const score = String(b.score).padStart(5);
+            const title = (b.title ?? 'Unknown').slice(0, 35);
+            lines.push(`│ ${rank}. ${b.id.padEnd(9)} ${score}  ${title}`);
+        }
+    }
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    lines.push('');
+    // Explanation
+    lines.push('Impact score = number of downstream WUs blocked (recursively)');
+    lines.push('Critical path = longest dependency chain in the graph');
+    return lines.join('\n');
+}
+/**
+ * Format critical path as Mermaid diagram
+ */
+function formatAsMermaid(analysis, coreGraph) {
+    if (analysis.criticalPath.path.length === 0) {
+        return '%%{ Critical path is empty - no active dependencies }%%\ngraph TD\n  empty[No critical path]';
+    }
+    const rootId = analysis.criticalPath.path[0];
+    return renderMermaid(coreGraph, { rootId, direction: 'TD', depth: analysis.criticalPath.length });
+}
+/**
+ * Main function
+ */
+async function main() {
+    const opts = parseArgs();
+    const limit = parseInt(opts.limit, 10);
+    console.log(`${LOG_PREFIX} Building dependency graph...`);
+    // Build dependency graph from WU YAML files
+    const coreGraph = buildDependencyGraph();
+    if (coreGraph.size === 0) {
+        console.log(`${LOG_PREFIX} No WUs found in dependency graph.`);
+        console.log(`${LOG_PREFIX} Ensure WU YAML files exist in docs/04-operations/tasks/wu/ with blocked_by/blocks fields.`);
+        return;
+    }
+    console.log(`${LOG_PREFIX} Found ${coreGraph.size} WUs in graph`);
+    // Convert to metrics-compatible graph format
+    const metricsGraph = convertToMetricsGraph(coreGraph);
+    // Perform bottleneck analysis
+    console.log(`${LOG_PREFIX} Analyzing bottlenecks (top ${limit})...`);
+    const analysis = getBottleneckAnalysis(metricsGraph, limit);
+    // Count active WUs
+    const activeWUs = Array.from(coreGraph.values()).filter((n) => n.status !== 'done').length;
+    console.log(`${LOG_PREFIX} Active WUs: ${activeWUs}`);
+    console.log(`${LOG_PREFIX} Bottlenecks found: ${analysis.bottlenecks.length}`);
+    console.log(`${LOG_PREFIX} Critical path length: ${analysis.criticalPath.length}`);
+    // Output analysis
+    console.log('');
+    switch (opts.format) {
+        case OUTPUT_FORMATS.TABLE:
+            console.log(formatAsTable(analysis));
+            break;
+        case OUTPUT_FORMATS.MERMAID:
+            console.log(formatAsMermaid(analysis, coreGraph));
+            break;
+        default:
+            console.log(JSON.stringify(analysis, null, 2));
+    }
+}
+// Guard main() for testability (WU-1366)
+import { fileURLToPath } from 'node:url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        die(`Bottleneck analysis failed: ${err.message}`);
+    });
+}