@lumenflow/cli 2.5.0 → 2.5.1

package/README.md

@@ -16,19 +16,22 @@ npm install @lumenflow/cli
 ## Quick Start
 
 ```bash
+# Install the CLI
+pnpm add -D @lumenflow/cli   # or: npm install -D @lumenflow/cli
+
 # Initialize LumenFlow (works with any AI)
-npx lumenflow-init
+pnpm exec lumenflow
 
 # Or specify your AI tool for enhanced integration
-npx lumenflow-init --client claude    # Claude Code
-npx lumenflow-init --client cursor    # Cursor
-npx lumenflow-init --client windsurf  # Windsurf
-npx lumenflow-init --client cline     # Cline
-npx lumenflow-init --client aider     # Aider
-npx lumenflow-init --client all       # All integrations
+pnpm exec lumenflow --client claude    # Claude Code
+pnpm exec lumenflow --client cursor    # Cursor
+pnpm exec lumenflow --client windsurf  # Windsurf
+pnpm exec lumenflow --client cline     # Cline
+pnpm exec lumenflow --client aider     # Aider
+pnpm exec lumenflow --client all       # All integrations
 ```
 
-The default `lumenflow-init` creates `AGENTS.md` and `LUMENFLOW.md` which work with **any AI coding assistant**. The `--client` flag adds vendor-specific configuration files for deeper integration.
+The default `lumenflow` command creates `AGENTS.md` and `LUMENFLOW.md` which work with **any AI coding assistant**. The `--client` flag adds vendor-specific configuration files for deeper integration.
 
 See [AI Integrations](https://lumenflow.dev/guides/ai-integrations) for details on each tool.
 

package/dist/__tests__/init-scripts.test.js

@@ -93,4 +93,115 @@ describe('init scripts generation (WU-1307)', () => {
         expect(packageJson.scripts?.['wu:claim']).toBeDefined();
         expect(packageJson.scripts?.gates).toBeDefined();
     });
+    // WU-1342: Test for all 17 essential commands
+    it('should include all 17 essential commands (WU-1342)', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const packageJson = readPackageJson();
+        // All 17 essential commands that must be present per WU-1342 acceptance criteria
+        const essentialScripts = [
+            // Core WU lifecycle
+            'wu:claim',
+            'wu:done',
+            'wu:create',
+            'wu:status',
+            'wu:block',
+            'wu:unblock',
+            // Additional critical commands (WU-1342)
+            'wu:prep',
+            'wu:recover',
+            'wu:spawn',
+            'wu:validate',
+            'wu:infer-lane',
+            // Memory commands
+            'mem:init',
+            'mem:checkpoint',
+            'mem:inbox',
+            // Lane commands
+            'lane:suggest',
+            // Gates
+            'gates',
+            'gates:docs',
+        ];
+        for (const scriptName of essentialScripts) {
+            expect(packageJson.scripts?.[scriptName], `Missing essential script: ${scriptName}`).toBeDefined();
+        }
+        // Verify count
+        const lumenflowScripts = Object.keys(packageJson.scripts ?? {}).filter((key) => key.startsWith('wu:') ||
+            key.startsWith('mem:') ||
+            key.startsWith('lane:') ||
+            key === 'gates' ||
+            key === 'gates:docs');
+        expect(lumenflowScripts.length).toBeGreaterThanOrEqual(17);
+    });
+});
+describe('init .gitignore generation (WU-1342)', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-init-gitignore-'));
+    });
+    afterEach(() => {
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should create .gitignore with required exclusions (WU-1342)', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const gitignorePath = path.join(tempDir, '.gitignore');
+        expect(fs.existsSync(gitignorePath)).toBe(true);
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        // Must include node_modules
+        expect(content).toContain('node_modules');
+        // Must include .lumenflow/state
+        expect(content).toContain('.lumenflow/state');
+        // Must include worktrees
+        expect(content).toContain('worktrees');
+    });
+    it('should preserve existing .gitignore content in merge mode (WU-1342)', async () => {
+        // Arrange
+        const gitignorePath = path.join(tempDir, '.gitignore');
+        const existingContent = '# Custom ignores\n.env\n*.log\n';
+        fs.writeFileSync(gitignorePath, existingContent);
+        // Act
+        await scaffoldProject(tempDir, { force: false, full: true, merge: true });
+        // Assert
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        // Should preserve existing content
+        expect(content).toContain('.env');
+        expect(content).toContain('*.log');
+        // Should add LumenFlow exclusions
+        expect(content).toContain('node_modules');
+        expect(content).toContain('.lumenflow/state');
+        expect(content).toContain('worktrees');
+    });
+});
+describe('init .claude directory creation (WU-1342)', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-init-claude-'));
+    });
+    afterEach(() => {
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should create .claude directory when --client claude specified (WU-1342)', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: false, client: 'claude' });
+        // Assert
+        const claudeDir = path.join(tempDir, '.claude');
+        expect(fs.existsSync(claudeDir)).toBe(true);
+        // Should have agents directory
+        const agentsDir = path.join(claudeDir, 'agents');
+        expect(fs.existsSync(agentsDir)).toBe(true);
+        // Should have settings.json
+        const settingsPath = path.join(claudeDir, 'settings.json');
+        expect(fs.existsSync(settingsPath)).toBe(true);
+        // Should have skills directory
+        const skillsDir = path.join(claudeDir, 'skills');
+        expect(fs.existsSync(skillsDir)).toBe(true);
+    });
 });

package/dist/__tests__/templates-sync.test.js

@@ -0,0 +1,219 @@
+/**
+ * @file templates-sync.test.ts
+ * Tests for templates synchronization and drift detection (WU-1353)
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { syncTemplates, syncOnboardingDocs, syncCoreDocs, convertToTemplate, checkTemplateDrift, } from '../sync-templates.js';
+// Constants for frequently used path segments (sonarjs/no-duplicate-string)
+const PACKAGES_DIR = 'packages';
+const LUMENFLOW_SCOPE = '@lumenflow';
+const CLI_DIR = 'cli';
+const TEMPLATES_DIR = 'templates';
+const CORE_DIR = 'core';
+const LUMENFLOW_DOT_DIR = '.lumenflow';
+const CONSTRAINTS_FILE = 'constraints.md';
+const CONSTRAINTS_TEMPLATE = 'constraints.md.template';
+describe('templates-sync', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'templates-sync-test-'));
+    });
+    afterEach(() => {
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('convertToTemplate', () => {
+        it('should replace dates with {{DATE}} placeholder', () => {
+            const content = 'Updated: 2026-02-02\nCreated: 2025-01-15';
+            const result = convertToTemplate(content, '/home/test/project');
+            expect(result).toBe('Updated: {{DATE}}\nCreated: {{DATE}}');
+        });
+        it('should preserve content without dates', () => {
+            const content = '# Title\n\nSome content without dates.';
+            const result = convertToTemplate(content, '/home/test/project');
+            expect(result).toBe(content);
+        });
+    });
+    describe('syncCoreDocs', () => {
+        beforeEach(() => {
+            // Set up directory structure
+            const templatesDir = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, LUMENFLOW_DOT_DIR);
+            fs.mkdirSync(templatesDir, { recursive: true });
+            // Create source constraints.md with v1.1 content
+            const lumenflowDir = path.join(tempDir, LUMENFLOW_DOT_DIR);
+            fs.mkdirSync(lumenflowDir, { recursive: true });
+            fs.writeFileSync(path.join(lumenflowDir, CONSTRAINTS_FILE), `# LumenFlow Constraints Capsule
+
+**Version:** 1.1
+**Last updated:** 2026-02-02
+
+This document contains the 7 non-negotiable constraints.
+
+### 1. Worktree Discipline and Git Safety
+
+**MANDATORY PRE-WRITE CHECK**
+
+**NEVER "QUICK FIX" ON MAIN**
+`);
+            // Create LUMENFLOW.md
+            fs.writeFileSync(path.join(tempDir, 'LUMENFLOW.md'), `# LumenFlow Workflow Guide
+
+**Last updated:** 2026-02-02
+
+## Critical Rule: Use wu:prep Then wu:done
+`);
+        });
+        it('should sync constraints.md to template', async () => {
+            const result = await syncCoreDocs(tempDir, false);
+            expect(result.errors).toHaveLength(0);
+            expect(result.synced).toContain(`${PACKAGES_DIR}/${LUMENFLOW_SCOPE}/${CLI_DIR}/${TEMPLATES_DIR}/${CORE_DIR}/${LUMENFLOW_DOT_DIR}/${CONSTRAINTS_TEMPLATE}`);
+            // Verify template content
+            const templatePath = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, LUMENFLOW_DOT_DIR, CONSTRAINTS_TEMPLATE);
+            const templateContent = fs.readFileSync(templatePath, 'utf-8');
+            // Should have {{DATE}} placeholder
+            expect(templateContent).toContain('{{DATE}}');
+            expect(templateContent).not.toContain('2026-02-02');
+            // Should have v1.1 content markers
+            expect(templateContent).toContain('Version:** 1.1');
+            expect(templateContent).toContain('7 non-negotiable constraints');
+            expect(templateContent).toContain('MANDATORY PRE-WRITE CHECK');
+            expect(templateContent).toContain('NEVER "QUICK FIX" ON MAIN');
+        });
+        it('should use dry-run mode without writing files', async () => {
+            // First, ensure no template exists
+            const templatePath = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, LUMENFLOW_DOT_DIR, CONSTRAINTS_TEMPLATE);
+            // Remove if it exists from beforeEach
+            if (fs.existsSync(templatePath)) {
+                fs.unlinkSync(templatePath);
+            }
+            const result = await syncCoreDocs(tempDir, true);
+            expect(result.errors).toHaveLength(0);
+            expect(result.synced.length).toBeGreaterThan(0);
+            expect(fs.existsSync(templatePath)).toBe(false);
+        });
+    });
+    describe('syncOnboardingDocs', () => {
+        const ONBOARDING_SUBPATH = [
+            'docs',
+            '04-operations',
+            '_frameworks',
+            'lumenflow',
+            'agent',
+            'onboarding',
+        ];
+        const FIRST_WU_MISTAKES_FILE = 'first-wu-mistakes.md';
+        beforeEach(() => {
+            // Set up onboarding source directory
+            const onboardingDir = path.join(tempDir, ...ONBOARDING_SUBPATH);
+            fs.mkdirSync(onboardingDir, { recursive: true });
+            // Create first-wu-mistakes.md with v1.1 content (11 mistakes)
+            fs.writeFileSync(path.join(onboardingDir, FIRST_WU_MISTAKES_FILE), `# First WU Mistakes
+
+**Last updated:** 2026-02-02
+
+## Mistake 1: Not Using Worktrees
+
+pnpm wu:prep --id WU-123
+
+## Mistake 11: "Quick Fixing" on Main
+
+## Quick Checklist
+
+- [ ] Check spec_refs for plans
+`);
+            // Set up target directory
+            const templatesDir = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, 'ai', 'onboarding');
+            fs.mkdirSync(templatesDir, { recursive: true });
+        });
+        it('should sync first-wu-mistakes.md to template', async () => {
+            const result = await syncOnboardingDocs(tempDir, false);
+            expect(result.errors).toHaveLength(0);
+            expect(result.synced).toContain(`${PACKAGES_DIR}/${LUMENFLOW_SCOPE}/${CLI_DIR}/${TEMPLATES_DIR}/${CORE_DIR}/ai/onboarding/${FIRST_WU_MISTAKES_FILE}.template`);
+            // Verify template content
+            const templatePath = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, 'ai', 'onboarding', `${FIRST_WU_MISTAKES_FILE}.template`);
+            const templateContent = fs.readFileSync(templatePath, 'utf-8');
+            // Should have {{DATE}} placeholder
+            expect(templateContent).toContain('{{DATE}}');
+            expect(templateContent).not.toContain('2026-02-02');
+            // Should have v1.1 content markers
+            expect(templateContent).toContain('Mistake 11:');
+            expect(templateContent).toContain('Quick Fixing" on Main');
+            expect(templateContent).toContain('wu:prep');
+            expect(templateContent).toContain('spec_refs');
+        });
+    });
+    describe('checkTemplateDrift', () => {
+        beforeEach(() => {
+            // Set up source files
+            const lumenflowDir = path.join(tempDir, LUMENFLOW_DOT_DIR);
+            fs.mkdirSync(lumenflowDir, { recursive: true });
+            fs.writeFileSync(path.join(lumenflowDir, CONSTRAINTS_FILE), `# Constraints
+**Version:** 1.1
+**Last updated:** 2026-02-02
+7 constraints`);
+            // Set up template directory
+            const templatesDir = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, LUMENFLOW_DOT_DIR);
+            fs.mkdirSync(templatesDir, { recursive: true });
+        });
+        it('should detect drift when template is outdated', async () => {
+            // Create outdated template (v1.0, 6 constraints)
+            const templatePath = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, LUMENFLOW_DOT_DIR, CONSTRAINTS_TEMPLATE);
+            fs.writeFileSync(templatePath, `# Constraints
+**Version:** 1.0
+**Last updated:** {{DATE}}
+6 constraints`);
+            const drift = await checkTemplateDrift(tempDir);
+            expect(drift.hasDrift).toBe(true);
+            expect(drift.driftingFiles.length).toBeGreaterThan(0);
+            expect(drift.driftingFiles.some((f) => f.includes(CONSTRAINTS_FILE))).toBe(true);
+        });
+        it('should report no drift when templates are in sync', async () => {
+            // First sync templates
+            await syncCoreDocs(tempDir, false);
+            // Then check for drift
+            const drift = await checkTemplateDrift(tempDir);
+            // After sync, constraints should not be drifting
+            expect(drift.driftingFiles.filter((f) => f.includes(CONSTRAINTS_FILE))).toHaveLength(0);
+        });
+        it('should return detailed drift report', async () => {
+            // Create outdated template
+            const templatePath = path.join(tempDir, PACKAGES_DIR, LUMENFLOW_SCOPE, CLI_DIR, TEMPLATES_DIR, CORE_DIR, LUMENFLOW_DOT_DIR, CONSTRAINTS_TEMPLATE);
+            fs.writeFileSync(templatePath, 'outdated content');
+            const drift = await checkTemplateDrift(tempDir);
+            expect(drift.hasDrift).toBe(true);
+            expect(drift.driftingFiles).toBeDefined();
+            expect(Array.isArray(drift.driftingFiles)).toBe(true);
+        });
+    });
+    describe('syncTemplates (full sync)', () => {
+        beforeEach(() => {
+            // Set up minimal directory structure
+            const lumenflowDir = path.join(tempDir, LUMENFLOW_DOT_DIR);
+            fs.mkdirSync(lumenflowDir, { recursive: true });
+            fs.writeFileSync(path.join(lumenflowDir, CONSTRAINTS_FILE), 'content');
+            fs.writeFileSync(path.join(tempDir, 'LUMENFLOW.md'), 'content');
+            const onboardingDir = path.join(tempDir, 'docs', '04-operations', '_frameworks', 'lumenflow', 'agent', 'onboarding');
+            fs.mkdirSync(onboardingDir, { recursive: true });
+            fs.writeFileSync(path.join(onboardingDir, 'first-wu-mistakes.md'), 'content');
+            const skillsDir = path.join(tempDir, '.claude', 'skills', 'test-skill');
+            fs.mkdirSync(skillsDir, { recursive: true });
+            fs.writeFileSync(path.join(skillsDir, 'SKILL.md'), 'skill content');
+        });
+        it('should sync all template categories', async () => {
+            const result = await syncTemplates(tempDir, false);
+            expect(result.core.errors).toHaveLength(0);
+            expect(result.onboarding.errors).toHaveLength(0);
+            expect(result.skills.errors).toHaveLength(0);
+            // Should sync at least constraints and LUMENFLOW
+            expect(result.core.synced.length).toBeGreaterThanOrEqual(2);
+            // Should sync onboarding docs
+            expect(result.onboarding.synced.length).toBeGreaterThanOrEqual(1);
+            // Should sync skills
+            expect(result.skills.synced.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+});

package/dist/init.js

@@ -1909,6 +1909,8 @@ export async function scaffoldProject(targetDir, options) {
     // Create .lumenflow/agents directory with .gitkeep
     await createDirectory(path.join(targetDir, LUMENFLOW_AGENTS_DIR), result, targetDir);
     await createFile(path.join(targetDir, LUMENFLOW_AGENTS_DIR, '.gitkeep'), '', options.force ? 'force' : 'skip', result, targetDir);
+    // WU-1342: Create .gitignore with required exclusions
+    await scaffoldGitignore(targetDir, options, result);
     // Optional: full docs scaffolding
     if (options.full) {
         await scaffoldFullDocs(targetDir, options, result, tokenDefaults);
@@ -1925,18 +1927,106 @@ export async function scaffoldProject(targetDir, options) {
     }
     return result;
 }
+/**
+ * WU-1342: .gitignore template with required exclusions
+ * Includes node_modules, .lumenflow/state, and worktrees
+ */
+const GITIGNORE_TEMPLATE = `# Dependencies
+node_modules/
+
+# LumenFlow state (local only, not shared)
+.lumenflow/state/
+
+# Worktrees (isolated parallel work directories)
+worktrees/
+
+# Build output
+dist/
+*.tsbuildinfo
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+`;
+/** Gitignore file name constant to avoid duplicate string lint error */
+const GITIGNORE_FILE_NAME = '.gitignore';
+/**
+ * WU-1342: Scaffold .gitignore file with LumenFlow exclusions
+ * Supports merge mode to add exclusions to existing .gitignore
+ */
+async function scaffoldGitignore(targetDir, options, result) {
+    const gitignorePath = path.join(targetDir, GITIGNORE_FILE_NAME);
+    const fileMode = getFileMode(options);
+    if (fileMode === 'merge' && fs.existsSync(gitignorePath)) {
+        // Merge mode: append LumenFlow exclusions if not already present
+        const existingContent = fs.readFileSync(gitignorePath, 'utf-8');
+        const linesToAdd = [];
+        // Check each required exclusion
+        const requiredExclusions = [
+            { pattern: 'node_modules', line: 'node_modules/' },
+            { pattern: '.lumenflow/state', line: '.lumenflow/state/' },
+            { pattern: 'worktrees', line: 'worktrees/' },
+        ];
+        for (const { pattern, line } of requiredExclusions) {
+            if (!existingContent.includes(pattern)) {
+                linesToAdd.push(line);
+            }
+        }
+        if (linesToAdd.length > 0) {
+            const separator = existingContent.endsWith('\n') ? '' : '\n';
+            const lumenflowBlock = `${separator}
+# LumenFlow (auto-added)
+${linesToAdd.join('\n')}
+`;
+            fs.writeFileSync(gitignorePath, existingContent + lumenflowBlock);
+            result.merged?.push(GITIGNORE_FILE_NAME);
+        }
+        else {
+            result.skipped.push(GITIGNORE_FILE_NAME);
+        }
+        return;
+    }
+    // Skip or force mode
+    await createFile(gitignorePath, GITIGNORE_TEMPLATE, fileMode, result, targetDir);
+}
 /**
  * WU-1307: LumenFlow scripts to inject into package.json
+ * WU-1342: Expanded to include all 17 essential commands
  * Uses standalone binaries (wu-claim, wu-done, gates) that work in consumer projects
  * after installing @lumenflow/cli.
  */
 const LUMENFLOW_SCRIPTS = {
+    // Core WU lifecycle
     'wu:claim': 'wu-claim',
     'wu:done': 'wu-done',
     'wu:create': 'wu-create',
     'wu:status': 'wu-status',
     'wu:block': 'wu-block',
     'wu:unblock': 'wu-unblock',
+    // WU-1342: Additional critical commands
+    'wu:prep': 'wu-prep',
+    'wu:recover': 'wu-recover',
+    'wu:spawn': 'wu-spawn',
+    'wu:validate': 'wu-validate',
+    'wu:infer-lane': 'wu-infer-lane',
+    // Memory commands
+    'mem:init': 'mem-init',
+    'mem:checkpoint': 'mem-checkpoint',
+    'mem:inbox': 'mem-inbox',
+    // Lane commands
+    'lane:suggest': 'lane-suggest',
+    // Gates
     gates: 'gates',
     'gates:docs': 'gates --docs-only',
 };

package/dist/orchestrate-init-status.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * Orchestrate Initiative Status CLI
  *
@@ -10,10 +11,14 @@
  */
 import { Command } from 'commander';
 import { existsSync, readdirSync } from 'node:fs';
-import { loadInitiativeWUs, calculateProgress, formatProgress } from '@lumenflow/initiatives';
+import { loadInitiativeWUs, calculateProgress, formatProgress, getLaneAvailability, resolveLaneConfigsFromConfig, } from '@lumenflow/initiatives';
 import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/dist/wu-constants.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
 import chalk from 'chalk';
 const LOG_PREFIX = '[orchestrate:init-status]';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function getCompletedWUs(wuIds) {
     const completed = new Set();
     if (!existsSync(LUMENFLOW_PATHS.STAMPS_DIR)) {
@@ -27,6 +32,21 @@ function getCompletedWUs(wuIds) {
     }
     return completed;
 }
+function formatLaneAvailability(availability, laneConfigs) {
+    const lanes = Object.keys(availability).sort((a, b) => a.localeCompare(b));
+    if (lanes.length === 0) {
+        return '  (no lanes found)';
+    }
+    return lanes
+        .map((lane) => {
+        const entry = availability[lane];
+        const wipLimit = laneConfigs[lane]?.wip_limit ?? 1;
+        const statusLabel = entry.available ? chalk.green('available') : chalk.red('occupied');
+        const occupiedBy = entry.occupiedBy ?? 'none';
+        return `  ${lane}: ${statusLabel} (wip_limit=${wipLimit}, lock_policy=${entry.policy}, in_progress=${entry.inProgressCount}, blocked=${entry.blockedCount}, occupied_by=${occupiedBy})`;
+    })
+        .join('\n');
+}
 const program = new Command()
     .name('orchestrate:init-status')
     .description('Show initiative progress status')
@@ -45,18 +65,26 @@ const program = new Command()
         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');
+            let status = chalk.gray('○ ready');
+            if (completed.has(wu.id)) {
+                status = chalk.green('✓ done');
+            }
+            else if (wu.doc.status === 'in_progress') {
+                status = chalk.yellow('⟳ in_progress');
+            }
+            else if (wu.doc.status === 'blocked') {
+                status = chalk.red('⛔ blocked');
+            }
             console.log(`  ${wu.id}: ${wu.doc.title} [${status}]`);
         }
+        const laneConfigs = resolveLaneConfigsFromConfig(getConfig());
+        const availability = getLaneAvailability(wus, { laneConfigs });
+        console.log('');
+        console.log(chalk.bold('Lane Availability:'));
+        console.log(formatLaneAvailability(availability, laneConfigs));
     }
     catch (err) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${err.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(err)}`));
         process.exit(EXIT_CODES.ERROR);
     }
 });

package/dist/orchestrate-initiative.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console -- CLI tool requires console output */
 /**
  * Orchestrate Initiative CLI
  *
@@ -11,8 +12,12 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlanAsync, formatExecutionPlan, formatExecutionPlanWithEmbeddedSpawns, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointModeAsync, LOG_PREFIX, } from '@lumenflow/initiatives';
+import { loadInitiativeWUs, loadMultipleInitiatives, buildExecutionPlanWithLockPolicy, resolveLaneConfigsFromConfig, formatExecutionPlan, formatExecutionPlanWithEmbeddedSpawns, calculateProgress, formatProgress, buildCheckpointWave, formatCheckpointOutput, validateCheckpointFlags, resolveCheckpointModeAsync, LOG_PREFIX, } from '@lumenflow/initiatives';
 import { EXIT_CODES } from '@lumenflow/core/dist/wu-constants.js';
+import { getConfig } from '@lumenflow/core/dist/lumenflow-config.js';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 const program = new Command()
     .name('orchestrate-initiative')
     .description('Orchestrate initiative execution with parallel agent spawning')
@@ -28,7 +33,7 @@ const program = new Command()
         validateCheckpointFlags({ checkpointPerWave, dryRun, noCheckpoint });
     }
     catch (error) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${error.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(error)}`));
         process.exit(EXIT_CODES.ERROR);
     }
     if (!initIds || initIds.length === 0) {
@@ -76,7 +81,8 @@ const program = new Command()
             return;
         }
         console.log(chalk.cyan(`${LOG_PREFIX} Building execution plan...`));
-        const plan = await buildExecutionPlanAsync(wus);
+        const laneConfigs = resolveLaneConfigsFromConfig(getConfig());
+        const plan = buildExecutionPlanWithLockPolicy(wus, { laneConfigs });
         if (plan.waves.length === 0) {
             console.log(chalk.green(`${LOG_PREFIX} All WUs are complete! Nothing to execute.`));
             return;
@@ -99,7 +105,7 @@ const program = new Command()
         console.log(chalk.cyan('Copy the spawn XML above to execute agents.'));
     }
     catch (error) {
-        console.error(chalk.red(`${LOG_PREFIX} Error: ${error.message}`));
+        console.error(chalk.red(`${LOG_PREFIX} Error: ${getErrorMessage(error)}`));
         process.exit(EXIT_CODES.ERROR);
     }
 });