@lumenflow/cli 1.0.0 → 1.1.0

package/dist/initiative-bulk-assign-wus.js

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+/**
+ * Initiative Bulk Assign WUs CLI (WU-1018)
+ *
+ * Bulk-assigns orphaned WUs to initiatives based on lane prefix rules.
+ * Uses micro-worktree isolation for race-safe commits.
+ *
+ * Usage:
+ *   pnpm initiative:bulk-assign                              # Dry-run (default)
+ *   LUMENFLOW_ADMIN=1 pnpm initiative:bulk-assign --apply    # Apply changes
+ *   pnpm initiative:bulk-assign --config custom-config.yaml  # Custom config
+ *   pnpm initiative:bulk-assign --reconcile-initiative INIT-001
+ *
+ * @module initiative-bulk-assign-wus
+ */
+import { readFile, writeFile } 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 { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[initiative:bulk-assign]';
+/** Default lane bucket configuration path */
+const DEFAULT_CONFIG_PATH = 'tools/config/initiative-lane-buckets.yaml';
+/** WU directory relative to repo root */
+const WU_DIR = 'docs/04-operations/tasks/wu';
+/** Initiative directory relative to repo root */
+const INIT_DIR = 'docs/04-operations/tasks/initiatives';
+/** Environment variable required for apply mode */
+const ADMIN_ENV_VAR = 'LUMENFLOW_ADMIN';
+/** Micro-worktree operation name */
+const OPERATION_NAME = 'initiative-bulk-assign';
+/**
+ * Load lane bucket configuration
+ */
+async function loadConfig(configPath) {
+    const fullPath = join(process.cwd(), configPath);
+    if (!existsSync(fullPath)) {
+        console.log(`${LOG_PREFIX} Config not found: ${configPath}`);
+        console.log(`${LOG_PREFIX} Using empty rules (no auto-assignment)`);
+        return { rules: [] };
+    }
+    const content = await readFile(fullPath, { encoding: 'utf-8' });
+    return parseYaml(content);
+}
+/**
+ * Scan top-level meta from WU YAML content (text-based to preserve formatting)
+ */
+function scanTopLevelMeta(text, filePath) {
+    const lines = text.split('\n');
+    let id;
+    let lane;
+    let initiative;
+    let laneLineIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip comments and empty lines
+        if (trimmed.startsWith('#') || trimmed === '' || trimmed === '---') {
+            continue;
+        }
+        // Extract id
+        if (trimmed.startsWith('id:')) {
+            id = trimmed.replace('id:', '').trim();
+        }
+        // Extract lane
+        if (trimmed.startsWith('lane:')) {
+            lane = trimmed.replace('lane:', '').trim();
+            laneLineIndex = i;
+        }
+        // Extract initiative
+        if (trimmed.startsWith('initiative:')) {
+            initiative = trimmed.replace('initiative:', '').trim();
+        }
+    }
+    if (!id || !lane || laneLineIndex === -1) {
+        return null;
+    }
+    return {
+        id,
+        lane,
+        initiative,
+        filePath,
+        laneLineIndex,
+        rawContent: text,
+    };
+}
+/**
+ * Insert initiative line after lane line (text-based)
+ */
+function insertInitiativeLine(text, laneLineIndex, initiativeId) {
+    const lines = text.split('\n');
+    const initLine = `initiative: ${initiativeId}`;
+    // Insert after lane line
+    lines.splice(laneLineIndex + 1, 0, initLine);
+    return lines.join('\n');
+}
+/**
+ * Match lane against rules to find initiative
+ */
+function pickInitiativeForLane(lane, rules) {
+    for (const rule of rules) {
+        if (lane.toLowerCase().startsWith(rule.lane_prefix.toLowerCase())) {
+            return rule.initiative;
+        }
+    }
+    return null;
+}
+/**
+ * List all WU files
+ */
+async function listWUFiles() {
+    const wuDir = join(process.cwd(), WU_DIR);
+    return fg('WU-*.yaml', { cwd: wuDir, absolute: true });
+}
+/**
+ * List all initiative files
+ */
+async function listInitiativeFiles() {
+    const initDir = join(process.cwd(), INIT_DIR);
+    if (!existsSync(initDir)) {
+        return [];
+    }
+    return fg('INIT-*.yaml', { cwd: initDir, absolute: true });
+}
+/**
+ * Load WU IDs from initiative files
+ */
+async function loadInitiativeWUs() {
+    const initFiles = await listInitiativeFiles();
+    const initWUs = new Map();
+    for (const file of initFiles) {
+        try {
+            const content = await readFile(file, { encoding: 'utf-8' });
+            const init = parseYaml(content);
+            if (init.id && Array.isArray(init.wus)) {
+                initWUs.set(init.id, init.wus);
+            }
+        }
+        catch {
+            // Skip invalid initiative files
+        }
+    }
+    return initWUs;
+}
+/**
+ * Compute all changes without writing
+ */
+async function computeChanges(config) {
+    const wuFiles = await listWUFiles();
+    const initWUs = await loadInitiativeWUs();
+    const changes = [];
+    const stats = {
+        total: wuFiles.length,
+        alreadyAssigned: 0,
+        newlyAssigned: 0,
+        synced: 0,
+        skipped: 0,
+    };
+    // Build reverse lookup: WU ID -> Initiative ID
+    const wuToInit = new Map();
+    for (const [initId, wuList] of initWUs.entries()) {
+        for (const wuId of wuList) {
+            wuToInit.set(wuId, initId);
+        }
+    }
+    for (const file of wuFiles) {
+        try {
+            const content = await readFile(file, { encoding: 'utf-8' });
+            const meta = scanTopLevelMeta(content, file);
+            if (!meta) {
+                stats.skipped++;
+                continue;
+            }
+            // Check if already assigned
+            if (meta.initiative) {
+                stats.alreadyAssigned++;
+                continue;
+            }
+            // Check if initiative assigns this WU
+            const assignedInit = wuToInit.get(meta.id);
+            if (assignedInit) {
+                // Sync from initiative
+                const newContent = insertInitiativeLine(content, meta.laneLineIndex, assignedInit);
+                changes.push({
+                    wuId: meta.id,
+                    type: 'sync',
+                    initiative: assignedInit,
+                    filePath: file,
+                    newContent,
+                });
+                stats.synced++;
+                continue;
+            }
+            // Try to auto-assign by lane prefix
+            const matchedInit = pickInitiativeForLane(meta.lane, config.rules);
+            if (matchedInit) {
+                const newContent = insertInitiativeLine(content, meta.laneLineIndex, matchedInit);
+                changes.push({
+                    wuId: meta.id,
+                    type: 'assign',
+                    initiative: matchedInit,
+                    filePath: file,
+                    newContent,
+                });
+                stats.newlyAssigned++;
+            }
+            else {
+                stats.skipped++;
+            }
+        }
+        catch {
+            stats.skipped++;
+        }
+    }
+    return { changes, stats };
+}
+/**
+ * Print summary of changes
+ */
+function printSummary(stats) {
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('  BULK ASSIGNMENT SUMMARY');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log(`  Total WUs scanned:       ${stats.total}`);
+    console.log(`  Already assigned:        ${stats.alreadyAssigned}`);
+    console.log(`  Synced from initiatives: ${stats.synced}`);
+    console.log(`  Newly assigned by lane:  ${stats.newlyAssigned}`);
+    console.log(`  Skipped (no match):      ${stats.skipped}`);
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+}
+/**
+ * Main function
+ */
+async function main() {
+    const args = createWUParser({
+        name: 'initiative-bulk-assign-wus',
+        description: 'Bulk-assign orphaned WUs to initiatives based on lane prefix rules',
+        options: [WU_OPTIONS.config, WU_OPTIONS.apply, WU_OPTIONS.syncFromInitiative],
+        required: [],
+    });
+    const configPath = args.config || DEFAULT_CONFIG_PATH;
+    const applyMode = args.apply === true;
+    console.log(`${LOG_PREFIX} Bulk assign WUs to initiatives`);
+    console.log(`${LOG_PREFIX} Config: ${configPath}`);
+    console.log(`${LOG_PREFIX} Mode: ${applyMode ? 'APPLY' : 'dry-run'}`);
+    // Check admin mode for apply
+    if (applyMode && process.env[ADMIN_ENV_VAR] !== '1') {
+        die(`Apply mode requires ${ADMIN_ENV_VAR}=1 environment variable.\n\n` +
+            `This prevents accidental use by agents.\n\n` +
+            `Usage: ${ADMIN_ENV_VAR}=1 pnpm initiative:bulk-assign --apply`);
+    }
+    // Load configuration
+    const config = await loadConfig(configPath);
+    console.log(`${LOG_PREFIX} Loaded ${config.rules.length} lane assignment rules`);
+    // Compute changes
+    console.log(`${LOG_PREFIX} Scanning WUs...`);
+    const { changes, stats } = await computeChanges(config);
+    // Print summary
+    printSummary(stats);
+    if (changes.length === 0) {
+        console.log(`${LOG_PREFIX} No changes to apply.`);
+        return;
+    }
+    // Show changes
+    console.log(`${LOG_PREFIX} Changes to apply (${changes.length}):`);
+    for (const change of changes) {
+        const icon = change.type === 'sync' ? '↻' : '→';
+        console.log(`  ${icon} ${change.wuId} ${change.type} ${change.initiative}`);
+    }
+    if (!applyMode) {
+        console.log('');
+        console.log(`${LOG_PREFIX} Dry-run complete. Use --apply to write changes.`);
+        console.log(`${LOG_PREFIX}   ${ADMIN_ENV_VAR}=1 pnpm initiative:bulk-assign --apply`);
+        return;
+    }
+    // Apply changes via micro-worktree
+    console.log('');
+    console.log(`${LOG_PREFIX} Applying changes via micro-worktree...`);
+    await withMicroWorktree({
+        operation: OPERATION_NAME,
+        id: `bulk-${Date.now()}`,
+        logPrefix: LOG_PREFIX,
+        execute: async ({ worktreePath }) => {
+            const filesChanged = [];
+            for (const change of changes) {
+                if (!change.newContent)
+                    continue;
+                // Calculate relative path from repo root
+                const relativePath = change.filePath.replace(process.cwd() + '/', '');
+                const worktreeFilePath = join(worktreePath, relativePath);
+                await writeFile(worktreeFilePath, change.newContent, { encoding: 'utf-8' });
+                filesChanged.push(relativePath);
+            }
+            const commitMessage = `chore: bulk-assign ${changes.length} WUs to initiatives\n\nAuto-assigned by initiative-bulk-assign-wus`;
+            return {
+                commitMessage,
+                files: filesChanged,
+            };
+        },
+    });
+    console.log(`${LOG_PREFIX} ✅ Successfully applied ${changes.length} changes`);
+}
+// Guard main() for testability (WU-1366)
+import { fileURLToPath } from 'node:url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        die(`Bulk assign failed: ${err.message}`);
+    });
+}

package/dist/metrics-snapshot.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+/**
+ * Metrics Snapshot Capture CLI (WU-1018)
+ *
+ * Captures DORA metrics, lane health, and flow state snapshots.
+ *
+ * Usage:
+ *   pnpm metrics:snapshot                     # All metrics, JSON output
+ *   pnpm metrics:snapshot --type dora         # DORA metrics only
+ *   pnpm metrics:snapshot --type lanes        # Lane health only
+ *   pnpm metrics:snapshot --type flow         # Flow state only
+ *   pnpm metrics:snapshot --dry-run           # Preview without writing
+ *   pnpm metrics:snapshot --output metrics.json
+ *
+ * @module metrics-snapshot
+ * @see {@link @lumenflow/metrics/flow/capture-metrics-snapshot}
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import fg from 'fast-glob';
+import { parse as parseYaml } from 'yaml';
+import { Command } from 'commander';
+import { captureMetricsSnapshot, } from '@lumenflow/metrics';
+import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[metrics:snapshot]';
+/** Default snapshot output path */
+const DEFAULT_OUTPUT = '.beacon/snapshots/metrics-latest.json';
+/** WU directory relative to repo root */
+const WU_DIR = 'docs/04-operations/tasks/wu';
+/** Skip-gates audit file path */
+const SKIP_GATES_PATH = '.beacon/skip-gates-audit.ndjson';
+/** Snapshot type options */
+const SNAPSHOT_TYPES = ['all', 'dora', 'lanes', 'flow'];
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+    const program = new Command()
+        .name('metrics-snapshot')
+        .description('Capture DORA metrics, lane health, and flow state snapshot')
+        .option('--type <type>', `Snapshot type: ${SNAPSHOT_TYPES.join(', ')} (default: all)`, 'all')
+        .option('--days <number>', 'Days to analyze for DORA metrics (default: 7)', '7')
+        .option('--output <path>', `Output file path (default: ${DEFAULT_OUTPUT})`, DEFAULT_OUTPUT)
+        .option('--dry-run', 'Preview snapshot without writing to file')
+        .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 week date range
+ */
+function calculateWeekRange(days) {
+    const weekEnd = new Date();
+    weekEnd.setHours(23, 59, 59, 999);
+    const weekStart = new Date(weekEnd);
+    weekStart.setDate(weekStart.getDate() - days);
+    weekStart.setHours(0, 0, 0, 0);
+    return { weekStart, weekEnd };
+}
+/**
+ * Load WU metrics from YAML files
+ */
+async function loadWUMetrics(baseDir) {
+    const wuDir = join(baseDir, WU_DIR);
+    const wuFiles = await fg('WU-*.yaml', { cwd: wuDir, absolute: true });
+    const wuMetrics = [];
+    for (const file of wuFiles) {
+        try {
+            const content = await readFile(file, { encoding: 'utf-8' });
+            const wu = parseYaml(content);
+            // Map WU status to valid WUMetrics status
+            const rawStatus = wu.status;
+            let status = 'ready';
+            if (rawStatus === 'in_progress')
+                status = 'in_progress';
+            else if (rawStatus === 'blocked')
+                status = 'blocked';
+            else if (rawStatus === 'waiting')
+                status = 'waiting';
+            else if (rawStatus === 'done')
+                status = 'done';
+            else if (rawStatus === 'ready')
+                status = 'ready';
+            wuMetrics.push({
+                id: wu.id,
+                title: wu.title,
+                lane: wu.lane,
+                status,
+                priority: wu.priority,
+                claimedAt: wu.claimed_at ? new Date(wu.claimed_at) : undefined,
+                completedAt: wu.completed_at ? new Date(wu.completed_at) : undefined,
+                cycleTimeHours: calculateCycleTime(wu),
+            });
+        }
+        catch {
+            // Skip invalid WU files
+        }
+    }
+    return wuMetrics;
+}
+/**
+ * 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;
+}
+/**
+ * Load git commits from repository
+ */
+async function loadGitCommits(weekStart, weekEnd) {
+    try {
+        const git = getGitForCwd();
+        // simple-git log() returns an object with 'all' array containing commits
+        // The actual simple-git result includes date but the adapter type is narrowed
+        const logResult = await git.log({ maxCount: 500 });
+        const commits = [];
+        for (const entry of [...logResult.all]) {
+            // Filter by date range
+            const commitDate = new Date(entry.date);
+            if (commitDate < weekStart || commitDate > weekEnd) {
+                continue;
+            }
+            const message = entry.message;
+            // Extract WU ID from commit message if present
+            const wuIdMatch = message.match(/\b(WU-\d+)\b/i);
+            const wuId = wuIdMatch ? wuIdMatch[1].toUpperCase() : undefined;
+            // Determine commit type from conventional commit prefix
+            const typeMatch = message.match(/^(feat|fix|docs|chore|refactor|test|style|perf|ci)[\(:]?/i);
+            const type = typeMatch ? typeMatch[1].toLowerCase() : undefined;
+            commits.push({
+                hash: entry.hash,
+                timestamp: commitDate,
+                message,
+                type,
+                wuId,
+            });
+        }
+        return commits;
+    }
+    catch (err) {
+        console.warn(`${LOG_PREFIX} ⚠️  Could not load git commits: ${err.message}`);
+        return [];
+    }
+}
+/**
+ * Load skip-gates audit entries
+ */
+async function loadSkipGatesEntries(baseDir) {
+    const auditPath = join(baseDir, SKIP_GATES_PATH);
+    if (!existsSync(auditPath)) {
+        return [];
+    }
+    try {
+        const content = await readFile(auditPath, { encoding: 'utf-8' });
+        const lines = content.split('\n').filter((line) => line.trim());
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                if (raw.timestamp && raw.wu_id && raw.reason && raw.gate) {
+                    entries.push({
+                        timestamp: new Date(raw.timestamp),
+                        wuId: raw.wu_id,
+                        reason: raw.reason,
+                        gate: raw.gate,
+                    });
+                }
+            }
+            catch {
+                // Skip invalid JSON lines
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Format snapshot for display
+ */
+function formatSnapshot(snapshot, type) {
+    const lines = [];
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push(`  METRICS SNAPSHOT (type: ${type})`);
+    lines.push(`  Generated: ${new Date().toISOString()}`);
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+    if (snapshot.dora) {
+        lines.push('┌─────────────────────────────────────────────────────────────┐');
+        lines.push('│ DORA METRICS                                                │');
+        lines.push('├─────────────────────────────────────────────────────────────┤');
+        const { deploymentFrequency, leadTimeForChanges, changeFailureRate, meanTimeToRecovery } = snapshot.dora;
+        lines.push(`│ Deployment Frequency: ${deploymentFrequency.deploysPerWeek}/week (${deploymentFrequency.status})`);
+        lines.push(`│ Lead Time: ${leadTimeForChanges.medianHours}h median (${leadTimeForChanges.status})`);
+        lines.push(`│ Change Failure Rate: ${changeFailureRate.failurePercentage}% (${changeFailureRate.status})`);
+        lines.push(`│ MTTR: ${meanTimeToRecovery.averageHours}h (${meanTimeToRecovery.status})`);
+        lines.push('└─────────────────────────────────────────────────────────────┘');
+        lines.push('');
+    }
+    if (snapshot.lanes) {
+        lines.push('┌─────────────────────────────────────────────────────────────┐');
+        lines.push('│ LANE HEALTH                                                 │');
+        lines.push('├─────────────────────────────────────────────────────────────┤');
+        lines.push(`│ Total Active: ${snapshot.lanes.totalActive}  |  Blocked: ${snapshot.lanes.totalBlocked}  |  Completed: ${snapshot.lanes.totalCompleted}`);
+        lines.push('│');
+        for (const lane of snapshot.lanes.lanes) {
+            const statusIcon = lane.status === 'healthy' ? '✓' : lane.status === 'at-risk' ? '⚠' : '✗';
+            lines.push(`│ ${statusIcon} ${lane.lane.padEnd(20)} ${lane.wusCompleted} done, ${lane.wusInProgress} active, ${lane.wusBlocked} blocked`);
+        }
+        lines.push('└─────────────────────────────────────────────────────────────┘');
+        lines.push('');
+    }
+    if (snapshot.flow) {
+        lines.push('┌─────────────────────────────────────────────────────────────┐');
+        lines.push('│ FLOW STATE                                                  │');
+        lines.push('├─────────────────────────────────────────────────────────────┤');
+        lines.push(`│ Ready: ${snapshot.flow.ready}  |  In Progress: ${snapshot.flow.inProgress}`);
+        lines.push(`│ Blocked: ${snapshot.flow.blocked}  |  Waiting: ${snapshot.flow.waiting}`);
+        lines.push(`│ Done: ${snapshot.flow.done}  |  Total Active: ${snapshot.flow.totalActive}`);
+        lines.push('└─────────────────────────────────────────────────────────────┘');
+    }
+    return lines.join('\n');
+}
+/**
+ * Main function
+ */
+async function main() {
+    const opts = parseArgs();
+    const baseDir = process.cwd();
+    const type = opts.type;
+    const days = parseInt(opts.days, 10);
+    // Validate snapshot type
+    if (!SNAPSHOT_TYPES.includes(type)) {
+        die(`Invalid snapshot type: ${type}\n\nValid types: ${SNAPSHOT_TYPES.join(', ')}`);
+    }
+    console.log(`${LOG_PREFIX} Capturing ${type} metrics snapshot...`);
+    const { weekStart, weekEnd } = calculateWeekRange(days);
+    console.log(`${LOG_PREFIX} Date range: ${weekStart.toISOString().split('T')[0]} to ${weekEnd.toISOString().split('T')[0]}`);
+    // Load data
+    console.log(`${LOG_PREFIX} Loading WU data...`);
+    const wuMetrics = await loadWUMetrics(baseDir);
+    console.log(`${LOG_PREFIX} Found ${wuMetrics.length} WUs`);
+    console.log(`${LOG_PREFIX} Loading git commits...`);
+    const commits = await loadGitCommits(weekStart, weekEnd);
+    console.log(`${LOG_PREFIX} Found ${commits.length} commits`);
+    console.log(`${LOG_PREFIX} Loading skip-gates audit entries...`);
+    const skipGatesEntries = await loadSkipGatesEntries(baseDir);
+    console.log(`${LOG_PREFIX} Found ${skipGatesEntries.length} skip-gates entries`);
+    // Capture snapshot
+    const input = {
+        commits,
+        wuMetrics,
+        skipGatesEntries,
+        weekStart,
+        weekEnd,
+        type,
+    };
+    const snapshot = captureMetricsSnapshot(input);
+    // Output
+    console.log('');
+    console.log(formatSnapshot(snapshot, type));
+    console.log('');
+    // Write to file (unless dry-run)
+    if (opts.dryRun) {
+        console.log(`${LOG_PREFIX} Dry run - not writing to file.`);
+        console.log(`${LOG_PREFIX} Would write to: ${opts.output}`);
+    }
+    else {
+        const outputPath = join(baseDir, opts.output);
+        const outputDir = dirname(outputPath);
+        // Ensure directory exists
+        if (!existsSync(outputDir)) {
+            await mkdir(outputDir, { recursive: true });
+        }
+        const outputData = {
+            capturedAt: new Date().toISOString(),
+            type,
+            dateRange: {
+                start: weekStart.toISOString(),
+                end: weekEnd.toISOString(),
+            },
+            snapshot,
+        };
+        await writeFile(outputPath, JSON.stringify(outputData, null, 2), { encoding: 'utf-8' });
+        console.log(`${LOG_PREFIX} ✅ Snapshot written to: ${outputPath}`);
+    }
+}
+// Guard main() for testability (WU-1366)
+import { fileURLToPath } from 'node:url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        die(`Metrics snapshot failed: ${err.message}`);
+    });
+}

package/dist/orchestrate-init-status.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * Orchestrate Initiative Status CLI
+ *
+ * Compact status view for initiative orchestration.
+ * Shows progress of WUs in an initiative.
+ *
+ * Usage:
+ *   pnpm orchestrate:init-status --initiative INIT-001
+ */
+import { Command } from 'commander';
+import { existsSync, readdirSync } from 'node:fs';
+import { loadInitiativeWUs, calculateProgress, formatProgress } from '@lumenflow/initiatives';
+import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import chalk from 'chalk';
+const LOG_PREFIX = '[orchestrate:init-status]';
+const STAMPS_DIR = '.beacon/stamps';
+function getCompletedWUs(wuIds) {
+    const completed = new Set();
+    if (!existsSync(STAMPS_DIR)) {
+        return completed;
+    }
+    const files = readdirSync(STAMPS_DIR);
+    for (const wuId of wuIds) {
+        if (files.includes(`${wuId}.done`)) {
+            completed.add(wuId);
+        }
+    }
+    return completed;
+}
+const program = new Command()
+    .name('orchestrate:init-status')
+    .description('Show initiative progress status')
+    .requiredOption('-i, --initiative <id>', 'Initiative ID (e.g., INIT-001)')
+    .action(async (opts) => {
+    try {
+        console.log(chalk.cyan(`${LOG_PREFIX} Loading initiative ${opts.initiative}...`));
+        const { initiative, wus } = loadInitiativeWUs(opts.initiative);
+        console.log(chalk.bold(`\nInitiative: ${initiative.id} - ${initiative.title}`));
+        console.log('');
+        const progress = calculateProgress(wus);
+        console.log(chalk.bold('Progress:'));
+        console.log(formatProgress(progress));
+        console.log('');
+        // Show WU status breakdown
+        const completed = getCompletedWUs(wus.map((w) => w.id));
+        console.log(chalk.bold('WUs:'));
+        for (const wu of wus) {
+            const status = completed.has(wu.id)
+                ? chalk.green('✓ done')
+                : wu.doc.status === 'in_progress'
+                    ? chalk.yellow('⟳ in_progress')
+                    : wu.doc.status === 'blocked'
+                        ? chalk.red('⛔ blocked')
+                        : chalk.gray('○ ready');
+            console.log(`  ${wu.id}: ${wu.doc.title} [${status}]`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${err.message}`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+});
+program.parse();