@lumenflow/cli 1.0.0 → 1.1.0

package/dist/flow-report.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * Flow Report Generator CLI (WU-1018)
+ *
+ * Generates DORA/SPACE flow reports from telemetry and WU data.
+ *
+ * Usage:
+ *   pnpm flow:report                         # Default: last 7 days, JSON output
+ *   pnpm flow:report --days 30               # Last 30 days
+ *   pnpm flow:report --format table          # Table output
+ *   pnpm flow:report --start 2026-01-01 --end 2026-01-15
+ *
+ * @module flow-report
+ * @see {@link @lumenflow/metrics/flow/generate-flow-report}
+ */
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import fg from 'fast-glob';
+import { parse as parseYaml } from 'yaml';
+import { Command } from 'commander';
+import { generateFlowReport, TELEMETRY_PATHS, } from '@lumenflow/metrics';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[flow:report]';
+/** Default report window in days */
+const DEFAULT_DAYS = 7;
+/** Output format options */
+const OUTPUT_FORMATS = {
+    JSON: 'json',
+    TABLE: 'table',
+};
+/** WU directory relative to repo root */
+const WU_DIR = 'docs/04-operations/tasks/wu';
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+    const program = new Command()
+        .name('flow-report')
+        .description('Generate DORA/SPACE flow report from telemetry and WU data')
+        .option('--start <date>', 'Start date (YYYY-MM-DD)')
+        .option('--end <date>', 'End date (YYYY-MM-DD), defaults to today')
+        .option('--days <number>', `Days to report (default: ${DEFAULT_DAYS})`, String(DEFAULT_DAYS))
+        .option('--format <type>', `Output format: json, table (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;
+    }
+}
+/**
+ * Calculate date range from options
+ */
+function calculateDateRange(opts) {
+    const end = opts.end ? new Date(opts.end) : new Date();
+    end.setHours(23, 59, 59, 999);
+    let start;
+    if (opts.start) {
+        start = new Date(opts.start);
+        start.setHours(0, 0, 0, 0);
+    }
+    else {
+        const days = parseInt(opts.days ?? String(DEFAULT_DAYS), 10);
+        start = new Date(end);
+        start.setDate(start.getDate() - days);
+        start.setHours(0, 0, 0, 0);
+    }
+    return { start, end };
+}
+/**
+ * Read NDJSON file and parse events
+ */
+async function readNDJSON(filePath) {
+    if (!existsSync(filePath)) {
+        return [];
+    }
+    const content = await readFile(filePath, { encoding: 'utf-8' });
+    const lines = content.split('\n').filter((line) => line.trim());
+    const events = [];
+    for (const line of lines) {
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch {
+            // Skip invalid JSON lines
+        }
+    }
+    return events;
+}
+/**
+ * Transform raw gate event to GateTelemetryEvent type
+ */
+function transformGateEvent(raw) {
+    if (typeof raw.timestamp !== 'string' ||
+        typeof raw.gate_name !== 'string' ||
+        typeof raw.passed !== 'boolean' ||
+        typeof raw.duration_ms !== 'number') {
+        return null;
+    }
+    return {
+        timestamp: raw.timestamp,
+        wuId: raw.wu_id ?? null,
+        lane: raw.lane ?? null,
+        gateName: raw.gate_name,
+        passed: raw.passed,
+        durationMs: raw.duration_ms,
+    };
+}
+/**
+ * Transform raw LLM event to LLMTelemetryEvent type
+ */
+function transformLLMEvent(raw) {
+    if (typeof raw.timestamp !== 'string' ||
+        typeof raw.event_type !== 'string' ||
+        typeof raw.classification_type !== 'string') {
+        return null;
+    }
+    const eventType = raw.event_type;
+    if (eventType !== 'llm.classification.start' &&
+        eventType !== 'llm.classification.complete' &&
+        eventType !== 'llm.classification.error') {
+        return null;
+    }
+    return {
+        timestamp: raw.timestamp,
+        eventType,
+        classificationType: raw.classification_type,
+        durationMs: raw.duration_ms,
+        tokensUsed: raw.tokens_used,
+        estimatedCostUsd: raw.estimated_cost_usd,
+        confidence: raw.confidence,
+        fallbackUsed: raw.fallback_used,
+        fallbackReason: raw.fallback_reason,
+        errorType: raw.error_type,
+        errorMessage: raw.error_message,
+    };
+}
+/**
+ * Load gate telemetry events from file
+ */
+async function loadGateEvents(baseDir) {
+    const gatesPath = join(baseDir, TELEMETRY_PATHS.GATES);
+    const rawEvents = await readNDJSON(gatesPath);
+    return rawEvents.map(transformGateEvent).filter((e) => e !== null);
+}
+/**
+ * Load LLM telemetry events from file
+ */
+async function loadLLMEvents(baseDir) {
+    const llmPath = join(baseDir, TELEMETRY_PATHS.LLM_CLASSIFICATION);
+    const rawEvents = await readNDJSON(llmPath);
+    return rawEvents.map(transformLLMEvent).filter((e) => e !== null);
+}
+/**
+ * Load completed WUs from YAML files
+ */
+async function loadCompletedWUs(baseDir, start, end) {
+    const wuDir = join(baseDir, WU_DIR);
+    const wuFiles = await fg('WU-*.yaml', { cwd: wuDir, absolute: true });
+    const completedWUs = [];
+    for (const file of wuFiles) {
+        try {
+            const content = await readFile(file, { encoding: 'utf-8' });
+            const wu = parseYaml(content);
+            if (wu.status !== 'done' || !wu.completed_at) {
+                continue;
+            }
+            const completedAt = new Date(wu.completed_at);
+            if (completedAt < start || completedAt > end) {
+                continue;
+            }
+            completedWUs.push({
+                id: wu.id,
+                title: wu.title,
+                lane: wu.lane,
+                status: 'done',
+                claimedAt: wu.claimed_at ? new Date(wu.claimed_at) : undefined,
+                completedAt,
+                cycleTimeHours: calculateCycleTime(wu),
+            });
+        }
+        catch {
+            // Skip invalid WU files
+        }
+    }
+    return completedWUs;
+}
+/**
+ * Calculate cycle time in hours from WU data
+ */
+function calculateCycleTime(wu) {
+    if (!wu.claimed_at || !wu.completed_at) {
+        return undefined;
+    }
+    const claimed = new Date(wu.claimed_at);
+    const completed = new Date(wu.completed_at);
+    const diffMs = completed.getTime() - claimed.getTime();
+    const diffHours = diffMs / (1000 * 60 * 60);
+    return Math.round(diffHours * 10) / 10; // Round to 1 decimal
+}
+/**
+ * Filter events by date range
+ */
+function filterByDateRange(events, start, end) {
+    return events.filter((event) => {
+        const eventDate = new Date(event.timestamp);
+        return eventDate >= start && eventDate <= end;
+    });
+}
+/**
+ * Format report as table output
+ */
+function formatAsTable(report) {
+    const lines = [];
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push(`  FLOW REPORT: ${report.range.start} to ${report.range.end}`);
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+    // Gates section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ GATES                                                       │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push(`│ Pass Rate: ${report.gates.passRate}%  |  Total: ${report.gates.total}  |  P95: ${report.gates.p95}ms │`);
+    lines.push(`│ Passed: ${report.gates.passed}  |  Failed: ${report.gates.failed}`);
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push('│ By Name:                                                    │');
+    for (const [name, stats] of Object.entries(report.gates.byName)) {
+        lines.push(`│   ${name.padEnd(20)} ${stats.passRate}% (${stats.passed}/${stats.total})`);
+    }
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    lines.push('');
+    // WUs section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ WORK UNITS                                                  │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push(`│ Completed: ${report.wus.completed}`);
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    for (const wu of report.wus.list.slice(0, 10)) {
+        lines.push(`│ ${wu.wuId.padEnd(8)} ${wu.completedDate}  ${wu.lane.padEnd(15)} ${wu.title.slice(0, 25)}`);
+    }
+    if (report.wus.list.length > 10) {
+        lines.push(`│ ... and ${report.wus.list.length - 10} more`);
+    }
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    lines.push('');
+    // LLM section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ LLM CLASSIFICATION                                          │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push(`│ Total: ${report.llm.totalClassifications}  |  Error Rate: ${report.llm.errorRate}%`);
+    lines.push(`│ Avg Latency: ${report.llm.avgLatencyMs}ms  |  P95: ${report.llm.p95LatencyMs}ms`);
+    lines.push(`│ Tokens: ${report.llm.totalTokens}  |  Cost: $${report.llm.totalCostUsd.toFixed(4)}`);
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    return lines.join('\n');
+}
+/**
+ * Main function
+ */
+async function main() {
+    const opts = parseArgs();
+    const baseDir = process.cwd();
+    console.log(`${LOG_PREFIX} Generating flow report...`);
+    const { start, end } = calculateDateRange(opts);
+    console.log(`${LOG_PREFIX} Date range: ${start.toISOString().split('T')[0]} to ${end.toISOString().split('T')[0]}`);
+    // Load telemetry and WU data
+    const [gateEvents, llmEvents, completedWUs] = await Promise.all([
+        loadGateEvents(baseDir),
+        loadLLMEvents(baseDir),
+        loadCompletedWUs(baseDir, start, end),
+    ]);
+    // Filter events by date range
+    const filteredGateEvents = filterByDateRange(gateEvents, start, end);
+    const filteredLLMEvents = filterByDateRange(llmEvents, start, end);
+    console.log(`${LOG_PREFIX} Found ${filteredGateEvents.length} gate events`);
+    console.log(`${LOG_PREFIX} Found ${filteredLLMEvents.length} LLM events`);
+    console.log(`${LOG_PREFIX} Found ${completedWUs.length} completed WUs`);
+    // Generate report
+    const input = {
+        gateEvents: filteredGateEvents,
+        llmEvents: filteredLLMEvents,
+        completedWUs,
+        dateRange: {
+            start: start.toISOString().split('T')[0],
+            end: end.toISOString().split('T')[0],
+        },
+    };
+    const report = generateFlowReport(input);
+    // Output report
+    console.log('');
+    if (opts.format === OUTPUT_FORMATS.TABLE) {
+        console.log(formatAsTable(report));
+    }
+    else {
+        console.log(JSON.stringify(report, 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(`Flow report failed: ${err.message}`);
+    });
+}

package/dist/gates.js

@@ -45,7 +45,7 @@ import path from 'node:path';
 import { emitGateEvent, getCurrentWU, getCurrentLane } from '@lumenflow/core/dist/telemetry.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { getChangedLintableFiles, convertToPackageRelativePaths, } from '@lumenflow/core/dist/incremental-lint.js';
-import { buildVitestChangedArgs, isCodeFilePath } from '@lumenflow/core/dist/incremental-test.js';
+import { isCodeFilePath } from '@lumenflow/core/dist/incremental-test.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { runCoverageGate, COVERAGE_GATE_MODES } from '@lumenflow/core/dist/coverage-gate.js';
 import { buildGatesLogPath, shouldUseGatesAgentMode, updateGatesLatestSymlink, } from '@lumenflow/core/dist/gates-agent-mode.js';
@@ -184,6 +184,15 @@ async function runIncrementalLint({ agentLog, } = {}) {
         }
         writeSync(agentLog.logFd, `${line}\n`);
     };
+    // WU-1006: Skip incremental lint if apps/web doesn't exist (repo-agnostic)
+    const webDir = path.join(process.cwd(), DIRECTORIES.APPS_WEB);
+    try {
+        await access(webDir);
+    }
+    catch {
+        logLine('\n> ESLint (incremental) skipped (apps/web not present)\n');
+        return { ok: true, duration: Date.now() - start, fileCount: 0 };
+    }
     try {
         // Check if we're on main branch
         const git = getGitForCwd();
@@ -298,15 +307,11 @@ async function runChangedTests({ agentLog, } = {}) {
             const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
             return { ...result, duration: Date.now() - start, isIncremental: false };
         }
-        logLine('\n> Vitest (changed: tools project)\n');
-        const toolsArgs = ['--project', 'tools', ...buildVitestChangedArgs()];
-        const toolsResult = run(pnpmCmd('vitest', ...toolsArgs), { agentLog });
-        if (!toolsResult.ok) {
-            return { ...toolsResult, duration: Date.now() - start, isIncremental: true };
-        }
-        logLine('\n> Vitest (changed: turbo --affected)\n');
-        const result = run(pnpmCmd('turbo', 'run', 'test:changed', '--affected'), { agentLog });
-        return { ...result, duration: Date.now() - start, isIncremental: true };
+        // WU-1006: Use turbo for tests (repo-agnostic)
+        // Previously used --project tools and test:changed which don't exist in all repos
+        logLine('\n> Running tests (turbo run test)\n');
+        const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+        return { ...result, duration: Date.now() - start, isIncremental: false };
     }
     catch (error) {
         console.error('⚠️  Changed tests failed, falling back to full suite:', error.message);
@@ -359,6 +364,15 @@ async function runSafetyCriticalTests({ agentLog, } = {}) {
         }
         writeSync(agentLog.logFd, `${line}\n`);
     };
+    // WU-1006: Skip safety-critical tests if apps/web doesn't exist (repo-agnostic)
+    const webDir = path.join(process.cwd(), DIRECTORIES.APPS_WEB);
+    try {
+        await access(webDir);
+    }
+    catch {
+        logLine('\n> Safety-critical tests skipped (apps/web not present)\n');
+        return { ok: true, duration: Date.now() - start, testCount: 0 };
+    }
     try {
         logLine('\n> Safety-critical tests (always run)\n');
         logLine(`Test files: ${SAFETY_CRITICAL_TEST_FILES.length} files\n`);

package/dist/init.js

@@ -0,0 +1,251 @@
+/**
+ * @file init.ts
+ * LumenFlow project scaffolding command (WU-1005)
+ * WU-1006: Library-First - use js-yaml.dump() for YAML generation
+ *
+ * Scaffolds new projects with:
+ * - .lumenflow.yaml configuration
+ * - CLAUDE.md development guide
+ * - AGENTS.md agent context
+ * - .beacon/stamps directory
+ * - docs/04-operations/tasks/wu directory
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+/**
+ * Default LumenFlow configuration object
+ * WU-1006: Use structured object + js-yaml instead of string template
+ */
+const DEFAULT_LUMENFLOW_CONFIG = {
+    version: '1.0',
+    lanes: [
+        { name: 'Core', paths: ['src/core/**'] },
+        { name: 'API', paths: ['src/api/**'] },
+        { name: 'UI', paths: ['src/ui/**', 'src/components/**'] },
+        { name: 'Infrastructure', paths: ['infra/**', '.github/**'] },
+        { name: 'Documentation', paths: ['docs/**', '*.md'] },
+    ],
+    gates: {
+        format: true,
+        lint: true,
+        typecheck: true,
+        test: true,
+    },
+    memory: {
+        checkpoint_interval: 30,
+    },
+};
+/**
+ * Generate YAML configuration with header comment
+ */
+function generateLumenflowYaml() {
+    const header = `# LumenFlow Configuration
+# Generated by: lumenflow init
+# Customize lanes based on your project structure
+
+`;
+    return header + yaml.dump(DEFAULT_LUMENFLOW_CONFIG, { lineWidth: -1, quotingType: "'" });
+}
+// Template for CLAUDE.md
+const CLAUDE_MD_TEMPLATE = `# Development Guide
+
+**Last updated:** ${new Date().toISOString().split('T')[0]}
+
+This project uses LumenFlow workflow for all changes.
+
+---
+
+## Quick Start
+
+\`\`\`bash
+# 1. Create a WU
+pnpm wu:create --id WU-XXXX --lane <Lane> --title "Title"
+
+# 2. Edit WU spec with acceptance criteria, then claim:
+pnpm wu:claim --id WU-XXXX --lane <Lane>
+cd worktrees/<lane>-wu-xxxx
+
+# 3. Implement in worktree
+
+# 4. Run gates
+pnpm gates
+
+# 5. Complete (from main)
+cd /path/to/main
+pnpm wu:done --id WU-XXXX
+\`\`\`
+
+---
+
+## Core Principles
+
+1. **TDD**: Failing test → implementation → passing test (≥90% coverage on new code)
+2. **Library-First**: Search existing libraries before custom code
+3. **DRY/SOLID/KISS/YAGNI**: No magic numbers, no hardcoded strings
+4. **Worktree Discipline**: After \`wu:claim\`, work ONLY in the worktree
+5. **Gates Before Done**: All gates must pass before \`wu:done\`
+6. **Do Not Bypass Hooks**: No \`--no-verify\`, fix issues properly
+
+---
+
+## Definition of Done
+
+- Acceptance criteria satisfied
+- Gates green (\`pnpm gates\`)
+- WU YAML status = \`done\`
+- \`.beacon/stamps/WU-<id>.done\` exists
+
+---
+
+## Commands Reference
+
+| Command               | Description                         |
+| --------------------- | ----------------------------------- |
+| \`pnpm wu:create\`    | Create new WU spec                  |
+| \`pnpm wu:claim\`     | Claim WU and create worktree        |
+| \`pnpm wu:done\`      | Complete WU (merge, stamp, cleanup) |
+| \`pnpm gates\`        | Run quality gates                   |
+| \`pnpm mem:checkpoint\` | Save memory checkpoint            |
+`;
+// Template for AGENTS.md
+const AGENTS_MD_TEMPLATE = `# Agent Context
+
+This project uses LumenFlow workflow. Before starting any work:
+
+## Context Loading Protocol
+
+1. Read \`CLAUDE.md\` for workflow fundamentals
+2. Read \`README.md\` for project structure
+3. Read the specific WU YAML file from \`docs/04-operations/tasks/wu/\`
+
+## Critical Rules
+
+### Worktree Discipline (IMMUTABLE LAW)
+
+After claiming a WU, you MUST work in its worktree:
+
+\`\`\`bash
+# 1. Claim creates worktree
+pnpm wu:claim --id WU-XXX --lane <lane>
+
+# 2. IMMEDIATELY cd to worktree
+cd worktrees/<lane>-wu-xxx
+
+# 3. ALL work happens here (edits, git add/commit/push, tests, gates)
+
+# 4. Return to main ONLY to complete
+cd ../../
+pnpm wu:done --id WU-XXX
+\`\`\`
+
+Main checkout becomes read-only after claim. Hooks will block WU commits from main.
+
+### Never Bypass Hooks
+
+If a git hook fails (pre-commit, commit-msg):
+
+1. Read the error message (shows which gate failed)
+2. Fix the underlying issue (format/lint/type errors)
+3. Re-run the commit
+
+**NEVER use \`--no-verify\` or \`--no-gpg-sign\` to bypass hooks.**
+
+### WIP = 1 Per Lane
+
+Only ONE work unit can be "in progress" per lane at any time.
+
+## Coding Standards
+
+- **TDD:** Tests first, ≥90% coverage on new application code
+- **Conventional commits:** \`type: summary\` (e.g., \`feat: add feature\`, \`fix: resolve bug\`)
+- **Documentation:** Concise, clear Markdown
+
+## Forbidden Git Commands (NEVER RUN on main)
+
+\`\`\`bash
+git reset --hard         # Data loss
+git stash                # Hides work
+git clean -fd            # Deletes files
+git push --force         # History rewrite
+--no-verify              # Bypasses safety checks
+\`\`\`
+
+**Where allowed:** Inside your worktree on a lane branch (safe, isolated).
+`;
+/**
+ * Scaffold a new LumenFlow project
+ */
+export async function scaffoldProject(targetDir, options) {
+    const result = {
+        created: [],
+        skipped: [],
+    };
+    // Ensure target directory exists
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    // Create .lumenflow.yaml (WU-1006: use js-yaml.dump() instead of string template)
+    await createFile(path.join(targetDir, '.lumenflow.yaml'), generateLumenflowYaml(), options.force, result);
+    // Create CLAUDE.md
+    await createFile(path.join(targetDir, 'CLAUDE.md'), CLAUDE_MD_TEMPLATE, options.force, result);
+    // Create AGENTS.md
+    await createFile(path.join(targetDir, 'AGENTS.md'), AGENTS_MD_TEMPLATE, options.force, result);
+    // Create .beacon/stamps directory
+    const beaconStampsDir = path.join(targetDir, '.beacon', 'stamps');
+    if (!fs.existsSync(beaconStampsDir)) {
+        fs.mkdirSync(beaconStampsDir, { recursive: true });
+        result.created.push('.beacon/stamps');
+    }
+    // Create docs/04-operations/tasks/wu directory with .gitkeep
+    const wuDir = path.join(targetDir, 'docs', '04-operations', 'tasks', 'wu');
+    if (!fs.existsSync(wuDir)) {
+        fs.mkdirSync(wuDir, { recursive: true });
+        result.created.push('docs/04-operations/tasks/wu');
+    }
+    // Create .gitkeep in WU directory
+    const gitkeepPath = path.join(wuDir, '.gitkeep');
+    if (!fs.existsSync(gitkeepPath)) {
+        fs.writeFileSync(gitkeepPath, '');
+    }
+    return result;
+}
+/**
+ * Create a file, respecting force option
+ */
+async function createFile(filePath, content, force, result) {
+    const relativePath = path.basename(filePath);
+    if (fs.existsSync(filePath) && !force) {
+        result.skipped.push(relativePath);
+        return;
+    }
+    // Ensure parent directory exists
+    const parentDir = path.dirname(filePath);
+    if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content);
+    result.created.push(relativePath);
+}
+/**
+ * CLI entry point
+ */
+export async function main() {
+    const args = process.argv.slice(2);
+    const force = args.includes('--force') || args.includes('-f');
+    const targetDir = process.cwd();
+    console.log('[lumenflow init] Scaffolding LumenFlow project...');
+    const result = await scaffoldProject(targetDir, { force });
+    if (result.created.length > 0) {
+        console.log('\nCreated:');
+        result.created.forEach((f) => console.log(`  ✅ ${f}`));
+    }
+    if (result.skipped.length > 0) {
+        console.log('\nSkipped (already exists, use --force to overwrite):');
+        result.skipped.forEach((f) => console.log(`  ⏭️  ${f}`));
+    }
+    console.log('\n[lumenflow init] Done! Next steps:');
+    console.log('  1. Edit .lumenflow.yaml to match your project structure');
+    console.log('  2. Review CLAUDE.md and AGENTS.md templates');
+    console.log('  3. Run: pnpm wu:create --id WU-0001 --lane <lane> --title "First WU"');
+}