@lumenflow/cli 2.5.1 → 2.7.0

package/dist/__tests__/gates-config.test.js

@@ -0,0 +1,304 @@
+/**
+ * @file gates-config.test.ts
+ * WU-1356: Tests for package manager and script name configuration.
+ *
+ * Tests configurable package_manager, gates.commands, test_runner, and build_command
+ * in .lumenflow.config.yaml for framework agnosticism.
+ */
+/* eslint-disable sonarjs/no-duplicate-string -- Test files intentionally repeat string literals for readability */
+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 * as yaml from 'yaml';
+// Import the schema and functions we're testing
+import { PackageManagerSchema, TestRunnerSchema, GatesCommandsConfigSchema, parseConfig, } from '@lumenflow/core/dist/lumenflow-config-schema.js';
+import { resolvePackageManager, resolveBuildCommand, resolveGatesCommands, resolveTestRunner, getIgnorePatterns, } from '@lumenflow/core/dist/gates-config.js';
+describe('WU-1356: Package manager and script configuration', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    describe('PackageManagerSchema', () => {
+        it('accepts pnpm as default', () => {
+            const result = PackageManagerSchema.parse(undefined);
+            expect(result).toBe('pnpm');
+        });
+        it('accepts npm', () => {
+            const result = PackageManagerSchema.parse('npm');
+            expect(result).toBe('npm');
+        });
+        it('accepts yarn', () => {
+            const result = PackageManagerSchema.parse('yarn');
+            expect(result).toBe('yarn');
+        });
+        it('accepts bun', () => {
+            const result = PackageManagerSchema.parse('bun');
+            expect(result).toBe('bun');
+        });
+        it('rejects invalid package manager', () => {
+            expect(() => PackageManagerSchema.parse('invalid')).toThrow();
+        });
+    });
+    describe('TestRunnerSchema', () => {
+        it('accepts vitest as default', () => {
+            const result = TestRunnerSchema.parse(undefined);
+            expect(result).toBe('vitest');
+        });
+        it('accepts jest', () => {
+            const result = TestRunnerSchema.parse('jest');
+            expect(result).toBe('jest');
+        });
+        it('accepts mocha', () => {
+            const result = TestRunnerSchema.parse('mocha');
+            expect(result).toBe('mocha');
+        });
+        it('rejects invalid test runner', () => {
+            expect(() => TestRunnerSchema.parse('invalid')).toThrow();
+        });
+    });
+    describe('GatesCommandsConfigSchema', () => {
+        it('has sensible defaults for test commands', () => {
+            const result = GatesCommandsConfigSchema.parse({});
+            expect(result.test_full).toBeDefined();
+            expect(result.test_docs_only).toBeDefined();
+            expect(result.test_incremental).toBeDefined();
+        });
+        it('allows custom test commands', () => {
+            const config = {
+                test_full: 'npm test',
+                test_docs_only: 'npm test -- --grep docs',
+                test_incremental: 'npm test -- --changed',
+            };
+            const result = GatesCommandsConfigSchema.parse(config);
+            expect(result.test_full).toBe('npm test');
+            expect(result.test_docs_only).toBe('npm test -- --grep docs');
+            expect(result.test_incremental).toBe('npm test -- --changed');
+        });
+    });
+    describe('LumenFlowConfigSchema - package_manager field', () => {
+        it('includes package_manager with default pnpm', () => {
+            const config = parseConfig({});
+            expect(config.package_manager).toBe('pnpm');
+        });
+        it('accepts npm as package_manager', () => {
+            const config = parseConfig({ package_manager: 'npm' });
+            expect(config.package_manager).toBe('npm');
+        });
+        it('accepts yarn as package_manager', () => {
+            const config = parseConfig({ package_manager: 'yarn' });
+            expect(config.package_manager).toBe('yarn');
+        });
+        it('accepts bun as package_manager', () => {
+            const config = parseConfig({ package_manager: 'bun' });
+            expect(config.package_manager).toBe('bun');
+        });
+    });
+    describe('LumenFlowConfigSchema - test_runner field', () => {
+        it('includes test_runner with default vitest', () => {
+            const config = parseConfig({});
+            expect(config.test_runner).toBe('vitest');
+        });
+        it('accepts jest as test_runner', () => {
+            const config = parseConfig({ test_runner: 'jest' });
+            expect(config.test_runner).toBe('jest');
+        });
+        it('accepts mocha as test_runner', () => {
+            const config = parseConfig({ test_runner: 'mocha' });
+            expect(config.test_runner).toBe('mocha');
+        });
+    });
+    describe('LumenFlowConfigSchema - gates.commands section', () => {
+        it('includes gates.commands with defaults', () => {
+            const config = parseConfig({});
+            expect(config.gates.commands).toBeDefined();
+            expect(config.gates.commands.test_full).toBeDefined();
+            expect(config.gates.commands.test_docs_only).toBeDefined();
+            expect(config.gates.commands.test_incremental).toBeDefined();
+        });
+        it('allows custom gates commands configuration', () => {
+            const config = parseConfig({
+                gates: {
+                    commands: {
+                        test_full: 'npm test',
+                        test_docs_only: 'npm test -- --docs',
+                        test_incremental: 'npm test -- --changed',
+                    },
+                },
+            });
+            expect(config.gates.commands.test_full).toBe('npm test');
+            expect(config.gates.commands.test_docs_only).toBe('npm test -- --docs');
+            expect(config.gates.commands.test_incremental).toBe('npm test -- --changed');
+        });
+    });
+    describe('LumenFlowConfigSchema - build_command field', () => {
+        it('includes build_command with default for pnpm', () => {
+            const config = parseConfig({});
+            expect(config.build_command).toBe('pnpm --filter @lumenflow/cli build');
+        });
+        it('allows custom build_command', () => {
+            const config = parseConfig({ build_command: 'npm run build' });
+            expect(config.build_command).toBe('npm run build');
+        });
+    });
+    describe('resolvePackageManager', () => {
+        it('returns pnpm when no config file exists', () => {
+            const result = resolvePackageManager(tempDir);
+            expect(result).toBe('pnpm');
+        });
+        it('returns configured package manager from config file', () => {
+            const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+            fs.writeFileSync(configPath, yaml.stringify({ package_manager: 'npm' }));
+            const result = resolvePackageManager(tempDir);
+            expect(result).toBe('npm');
+        });
+        it('returns yarn when configured', () => {
+            const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+            fs.writeFileSync(configPath, yaml.stringify({ package_manager: 'yarn' }));
+            const result = resolvePackageManager(tempDir);
+            expect(result).toBe('yarn');
+        });
+    });
+    describe('resolveBuildCommand', () => {
+        it('returns default build command when no config file exists', () => {
+            const result = resolveBuildCommand(tempDir);
+            expect(result).toBe('pnpm --filter @lumenflow/cli build');
+        });
+        it('returns configured build_command from config file', () => {
+            const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+            fs.writeFileSync(configPath, yaml.stringify({ build_command: 'npm run build' }));
+            const result = resolveBuildCommand(tempDir);
+            expect(result).toBe('npm run build');
+        });
+        it('adapts default build command for different package managers', () => {
+            const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+            fs.writeFileSync(configPath, yaml.stringify({ package_manager: 'npm' }));
+            const result = resolveBuildCommand(tempDir);
+            expect(result).toContain('npm');
+        });
+    });
+    describe('resolveGatesCommands', () => {
+        it('returns default commands when no config file exists', () => {
+            const commands = resolveGatesCommands(tempDir);
+            expect(commands.test_full).toBeDefined();
+            expect(commands.test_docs_only).toBeDefined();
+            expect(commands.test_incremental).toBeDefined();
+        });
+        it('returns configured commands from config file', () => {
+            const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+            fs.writeFileSync(configPath, yaml.stringify({
+                gates: {
+                    commands: {
+                        test_full: 'npm test',
+                        test_docs_only: 'npm test -- --docs',
+                        test_incremental: 'npm test -- --changed',
+                    },
+                },
+            }));
+            const commands = resolveGatesCommands(tempDir);
+            expect(commands.test_full).toBe('npm test');
+            expect(commands.test_docs_only).toBe('npm test -- --docs');
+            expect(commands.test_incremental).toBe('npm test -- --changed');
+        });
+    });
+    describe('resolveTestRunner', () => {
+        it('returns vitest when no config file exists', () => {
+            const result = resolveTestRunner(tempDir);
+            expect(result).toBe('vitest');
+        });
+        it('returns jest when configured', () => {
+            const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+            fs.writeFileSync(configPath, yaml.stringify({ test_runner: 'jest' }));
+            const result = resolveTestRunner(tempDir);
+            expect(result).toBe('jest');
+        });
+    });
+    describe('getIgnorePatterns', () => {
+        it('returns .turbo pattern for vitest', () => {
+            const patterns = getIgnorePatterns('vitest');
+            expect(patterns).toContain('.turbo');
+        });
+        it('returns different pattern for jest', () => {
+            const patterns = getIgnorePatterns('jest');
+            expect(patterns).not.toContain('.turbo');
+        });
+        it('returns custom pattern from config', () => {
+            const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+            fs.writeFileSync(configPath, yaml.stringify({
+                gates: {
+                    ignore_patterns: ['.nx', 'dist'],
+                },
+            }));
+            // This would be a config-aware version
+            const patterns = getIgnorePatterns('jest');
+            expect(Array.isArray(patterns)).toBe(true);
+        });
+    });
+});
+describe('WU-1356: npm+jest configuration', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-npm-jest-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('supports npm+jest configuration', () => {
+        const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+        fs.writeFileSync(configPath, yaml.stringify({
+            package_manager: 'npm',
+            test_runner: 'jest',
+            gates: {
+                commands: {
+                    test_full: 'npm test',
+                    test_docs_only: 'npm test -- --testPathPattern=docs',
+                    test_incremental: 'npm test -- --onlyChanged',
+                },
+            },
+            build_command: 'npm run build',
+        }));
+        const pkgManager = resolvePackageManager(tempDir);
+        const testRunner = resolveTestRunner(tempDir);
+        const commands = resolveGatesCommands(tempDir);
+        const buildCmd = resolveBuildCommand(tempDir);
+        expect(pkgManager).toBe('npm');
+        expect(testRunner).toBe('jest');
+        expect(commands.test_full).toBe('npm test');
+        expect(commands.test_incremental).toBe('npm test -- --onlyChanged');
+        expect(buildCmd).toBe('npm run build');
+    });
+});
+describe('WU-1356: yarn+nx configuration', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-yarn-nx-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('supports yarn+nx configuration', () => {
+        const configPath = path.join(tempDir, '.lumenflow.config.yaml');
+        fs.writeFileSync(configPath, yaml.stringify({
+            package_manager: 'yarn',
+            test_runner: 'jest',
+            gates: {
+                commands: {
+                    test_full: 'yarn nx run-many --target=test --all',
+                    test_docs_only: 'yarn nx test docs',
+                    test_incremental: 'yarn nx affected --target=test',
+                },
+            },
+            build_command: 'yarn nx build @lumenflow/cli',
+        }));
+        const pkgManager = resolvePackageManager(tempDir);
+        const commands = resolveGatesCommands(tempDir);
+        const buildCmd = resolveBuildCommand(tempDir);
+        expect(pkgManager).toBe('yarn');
+        expect(commands.test_full).toBe('yarn nx run-many --target=test --all');
+        expect(commands.test_incremental).toBe('yarn nx affected --target=test');
+        expect(buildCmd).toBe('yarn nx build @lumenflow/cli');
+    });
+});

package/dist/__tests__/wu-proto.test.js

@@ -0,0 +1,97 @@
+/**
+ * @file wu-proto.test.ts
+ * Test suite for wu:proto command (WU-1359)
+ *
+ * WU-1359: Add wu:proto convenience command for rapid prototyping
+ *
+ * Tests:
+ * - wu:proto creates WU with type: prototype
+ * - wu:proto has relaxed validation (no --acceptance required)
+ * - wu:proto immediately claims the WU
+ * - wu:proto prints cd command to worktree
+ */
+import { describe, it, expect } from 'vitest';
+// WU-1359: Import wu:proto validation and helpers
+import { validateProtoSpec } from '../wu-proto.js';
+/** Test constants to avoid duplicate string literals (sonarjs/no-duplicate-string) */
+const TEST_WU_ID = 'WU-9999';
+const TEST_LANE = 'Framework: CLI';
+const TEST_TITLE = 'Quick prototype';
+const TEST_DESCRIPTION = 'Context: testing.\nProblem: need to test.\nSolution: add tests.';
+describe('wu:proto command (WU-1359)', () => {
+    describe('validateProtoSpec relaxed validation', () => {
+        it('should pass validation without --acceptance', () => {
+            const result = validateProtoSpec({
+                id: TEST_WU_ID,
+                lane: TEST_LANE,
+                title: TEST_TITLE,
+                opts: {
+                    description: TEST_DESCRIPTION,
+                    codePaths: ['packages/@lumenflow/cli/src/wu-proto.ts'],
+                },
+            });
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should pass validation without --exposure', () => {
+            const result = validateProtoSpec({
+                id: TEST_WU_ID,
+                lane: TEST_LANE,
+                title: TEST_TITLE,
+                opts: {
+                    description: TEST_DESCRIPTION,
+                },
+            });
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should pass validation without --code-paths', () => {
+            const result = validateProtoSpec({
+                id: TEST_WU_ID,
+                lane: TEST_LANE,
+                title: TEST_TITLE,
+                opts: {
+                    description: TEST_DESCRIPTION,
+                },
+            });
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should require lane', () => {
+            const result = validateProtoSpec({
+                id: TEST_WU_ID,
+                lane: '',
+                title: TEST_TITLE,
+                opts: {},
+            });
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.toLowerCase().includes('lane'))).toBe(true);
+        });
+        it('should require title', () => {
+            const result = validateProtoSpec({
+                id: TEST_WU_ID,
+                lane: TEST_LANE,
+                title: '',
+                opts: {},
+            });
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((e) => e.toLowerCase().includes('title'))).toBe(true);
+        });
+    });
+    describe('prototype WU type', () => {
+        it('should set type to prototype', () => {
+            // The buildProtoWUContent function should return type: prototype
+            // We test this indirectly through the validateProtoSpec which checks content
+            const result = validateProtoSpec({
+                id: TEST_WU_ID,
+                lane: TEST_LANE,
+                title: TEST_TITLE,
+                opts: {
+                    description: TEST_DESCRIPTION,
+                },
+            });
+            // Prototype WUs should always be valid with minimal input
+            expect(result.valid).toBe(true);
+        });
+    });
+});

package/dist/gates.js

@@ -65,7 +65,8 @@ import { runSystemMapValidation } from '@lumenflow/core/dist/system-map-validato
 // WU-1191: Lane health gate configuration
 // WU-1262: Coverage config from methodology policy
 // WU-1280: Test policy for tests_required (warn vs block on test failures)
-import { loadLaneHealthConfig, resolveTestPolicy, } from '@lumenflow/core/dist/gates-config.js';
+// WU-1356: Configurable package manager and test commands
+import { loadLaneHealthConfig, resolveTestPolicy, resolveGatesCommands, resolveTestRunner, } from '@lumenflow/core/dist/gates-config.js';
 // WU-1191: Lane health check
 import { runLaneHealthCheck } from './lane-health.js';
 // WU-1315: Onboarding smoke test
@@ -184,8 +185,24 @@ const PRETTIER_CONFIG_FILES = new Set([
     'prettier.config.mjs',
     '.prettierignore',
 ]);
-const TEST_CONFIG_BASENAMES = new Set(['turbo.json', 'pnpm-lock.yaml', 'package.json']);
-const TEST_CONFIG_PATTERNS = [/^vitest\.config\.(ts|mts|js|mjs|cjs)$/i, /^tsconfig(\..+)?\.json$/i];
+// WU-1356: Extended to support multiple build tools and test runners
+const TEST_CONFIG_BASENAMES = new Set([
+    'turbo.json', // Turborepo
+    'nx.json', // Nx
+    'lerna.json', // Lerna
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lockb',
+    'package.json',
+]);
+// WU-1356: Extended to support vitest, jest, and mocha config patterns
+const TEST_CONFIG_PATTERNS = [
+    /^vitest\.config\.(ts|mts|js|mjs|cjs)$/i,
+    /^jest\.config\.(ts|js|mjs|cjs|json)$/i,
+    /^\.mocharc\.(js|json|yaml|yml)$/i,
+    /^tsconfig(\..+)?\.json$/i,
+];
 function normalizePath(filePath) {
     return filePath.replace(/\\/g, '/');
 }
@@ -380,9 +397,11 @@ export function loadCurrentWUCodePaths(options = {}) {
 }
 /**
  * WU-1299: Run filtered tests for docs-only mode
+ * WU-1356: Updated to use configured test command
  *
  * When --docs-only is passed and code_paths contains packages, this runs tests
- * only for those specific packages using turbo's --filter flag.
+ * only for those specific packages. The filter syntax adapts to the configured
+ * build tool (turbo, nx, or plain package manager).
  *
  * @param options - Options including packages to test and agent log context
  * @returns Result object with ok status and duration
@@ -395,10 +414,20 @@ async function runDocsOnlyFilteredTests({ packages, agentLog, }) {
         return { ok: true, duration: Date.now() - start };
     }
     logLine(`\n> Tests (docs-only filtered: ${packages.join(', ')})\n`);
-    // Build turbo filter args for each package
-    // turbo supports --filter=@scope/package or --filter=package
+    // WU-1356: Use configured test command with filter
+    const gatesCommands = resolveGatesCommands(process.cwd());
+    // If there's a configured test_docs_only command, use it
+    if (gatesCommands.test_docs_only) {
+        const result = run(gatesCommands.test_docs_only, { agentLog });
+        return { ok: result.ok, duration: Date.now() - start };
+    }
+    // Otherwise, use the full test command with filter args
+    // Build filter args for each package (works with turbo, nx, and pnpm/yarn workspaces)
     const filterArgs = packages.map((pkg) => `--filter=${pkg}`);
-    const result = run(pnpmCmd('turbo', 'run', 'test', ...filterArgs), { agentLog });
+    const baseCmd = gatesCommands.test_full;
+    // Append filter args to the base command
+    const filteredCmd = `${baseCmd} ${filterArgs.join(' ')}`;
+    const result = run(filteredCmd, { agentLog });
     return { ok: result.ok, duration: Date.now() - start };
 }
 export function parsePrettierListOutput(output) {
@@ -782,7 +811,8 @@ async function runIncrementalLint({ agentLog, } = {}) {
     }
 }
 /**
- * Run changed tests using Vitest's --changed flag from the repo root.
+ * Run changed tests using configured test runner's incremental mode.
+ * WU-1356: Updated to use configured commands from gates-config.
  * Falls back to full test suite if on main branch or if the run fails.
  *
  * @returns {{ ok: boolean, duration: number, isIncremental: boolean }}
@@ -797,13 +827,16 @@ async function runChangedTests({ agentLog, } = {}) {
         }
         writeSync(agentLog.logFd, `${line}\n`);
     };
+    // WU-1356: Get configured commands
+    const gatesCommands = resolveGatesCommands(process.cwd());
+    const testRunner = resolveTestRunner(process.cwd());
     try {
         const git = getGitForCwd();
         const currentBranch = await git.getCurrentBranch();
         const isMainBranch = currentBranch === BRANCHES.MAIN || currentBranch === BRANCHES.MASTER;
         if (isMainBranch) {
             logLine('📋 On main branch - running full test suite');
-            const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+            const result = run(gatesCommands.test_full, { agentLog });
             return { ...result, isIncremental: false };
         }
         let changedFiles = [];
@@ -841,16 +874,29 @@ async function runChangedTests({ agentLog, } = {}) {
                 logLine('⚠️  Changed file list unavailable - running full test suite');
             }
             logLine('📋 Running full test suite to avoid missing coverage');
-            const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+            const result = run(gatesCommands.test_full, { agentLog });
             return { ...result, duration: Date.now() - start, isIncremental: false };
         }
-        logLine('\n> Running tests (vitest --changed)\n');
-        const result = run(pnpmCmd('vitest', 'run', ...buildVitestChangedArgs({ baseBranch: 'origin/main' })), { agentLog });
-        return { ...result, duration: Date.now() - start, isIncremental: true };
+        // WU-1356: Use configured incremental test command
+        logLine(`\n> Running tests (${testRunner} --changed)\n`);
+        // If test_incremental is configured, use it directly
+        if (gatesCommands.test_incremental) {
+            const result = run(gatesCommands.test_incremental, { agentLog });
+            return { ...result, duration: Date.now() - start, isIncremental: true };
+        }
+        // Fallback: For vitest, use the built-in changed args helper
+        if (testRunner === 'vitest') {
+            const result = run(pnpmCmd('vitest', 'run', ...buildVitestChangedArgs({ baseBranch: 'origin/main' })), { agentLog });
+            return { ...result, duration: Date.now() - start, isIncremental: true };
+        }
+        // For other runners without configured incremental, fall back to full
+        logLine('⚠️  No incremental test command configured, running full suite');
+        const result = run(gatesCommands.test_full, { agentLog });
+        return { ...result, duration: Date.now() - start, isIncremental: false };
     }
     catch (error) {
         console.error('⚠️  Changed tests failed, falling back to full suite:', error.message);
-        const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+        const result = run(gatesCommands.test_full, { agentLog });
         return { ...result, isIncremental: false };
     }
 }
@@ -1055,6 +1101,8 @@ async function executeGates(opts) {
     const testsRequired = resolvedTestPolicy.tests_required;
     // WU-1191: Lane health gate mode (warn, error, or off)
     const laneHealthMode = loadLaneHealthConfig(process.cwd());
+    // WU-1356: Resolve configured gates commands for test execution
+    const configuredGatesCommands = resolveGatesCommands(process.cwd());
     if (useAgentMode) {
         console.log(`🧾 gates (agent mode): output -> ${agentLog.logPath} (use --verbose for streaming)\n`);
     }
@@ -1185,10 +1233,11 @@ async function executeGates(opts) {
             // WU-1920: Use changed tests by default, full suite with --full-tests
             // WU-2244: --full-coverage implies --full-tests for accurate coverage
             // WU-1280: When tests_required=false (methodology.testing: none), failures only warn
+            // WU-1356: Use configured test command instead of hard-coded turbo
             {
                 name: GATE_NAMES.TEST,
                 cmd: isFullTests || isFullCoverage
-                    ? pnpmCmd('turbo', 'run', 'test')
+                    ? configuredGatesCommands.test_full
                     : GATE_COMMANDS.INCREMENTAL_TEST,
                 warnOnly: !testsRequired,
             },

package/dist/init.js

@@ -2011,6 +2011,7 @@ const LUMENFLOW_SCRIPTS = {
     'wu:claim': 'wu-claim',
     'wu:done': 'wu-done',
     'wu:create': 'wu-create',
+    'wu:proto': 'wu-proto', // WU-1359: Prototype WU with relaxed validation
     'wu:status': 'wu-status',
     'wu:block': 'wu-block',
     'wu:unblock': 'wu-unblock',
@@ -2361,10 +2362,21 @@ export async function main() {
         console.log('\nWarnings:');
         result.warnings.forEach((w) => console.log(`  ⚠ ${w}`));
     }
+    // WU-1359: Show complete lifecycle with auto-ID (no --id flag required)
     console.log('\n[lumenflow init] Done! Next steps:');
     console.log('  1. Review AGENTS.md and LUMENFLOW.md for workflow documentation');
     console.log(`  2. Edit ${CONFIG_FILE_NAME} to match your project structure`);
-    console.log('  3. Run: pnpm wu:create --id WU-0001 --lane <lane> --title "First WU"');
+    console.log('  3. Start your first WU:');
+    console.log('');
+    console.log('     # Create (auto-generates ID):');
+    console.log('     pnpm wu:create --lane <lane> --title "First WU" \\');
+    console.log('       --description "Context: ... Problem: ... Solution: ..." \\');
+    console.log('       --acceptance "Criterion 1" --code-paths "src/..." --exposure backend-only');
+    console.log('');
+    console.log('     # Or for rapid prototyping (minimal validation):');
+    console.log('     pnpm wu:proto --lane <lane> --title "Quick experiment"');
+    console.log('');
+    console.log('  4. Full lifecycle: wu:create -> wu:claim -> wu:prep -> wu:done');
     /* eslint-enable no-console */
 }
 // WU-1297: Use import.meta.main instead of exporting main() without calling it