@lumenflow/cli 2.20.1 → 2.21.1

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

@@ -1,247 +0,0 @@
-/**
- * @file init-greenfield.test.ts
- * Tests for greenfield onboarding with initiative-first workflow (WU-1364)
- *
- * Verifies:
- * - Init output includes initiative-first workflow guidance
- * - starting-prompt.md has 'When Starting From Product Vision' section
- * - Init auto-creates initial commit when git repo has no commits
- * - Init auto-sets git.requireRemote=false when no remote configured
- * - Default lane-inference template includes Core and Feature as parent lanes
- * - LUMENFLOW.md mentions initiatives and when to use them
- */
-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 { execFileSync } from 'node:child_process';
-import { scaffoldProject } from '../init.js';
-// Constants to avoid duplicate strings
-const ARC42_DOCS_STRUCTURE = 'arc42';
-const STARTING_PROMPT_FILE = 'starting-prompt.md';
-const LUMENFLOW_CONFIG_FILE = '.lumenflow.config.yaml';
-const LANE_INFERENCE_FILE = '.lumenflow.lane-inference.yaml';
-describe('greenfield onboarding (WU-1364)', () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-greenfield-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-    function getOnboardingDir() {
-        return path.join(tempDir, 'docs', '04-operations', '_frameworks', 'lumenflow', 'agent', 'onboarding');
-    }
-    function getArc42Options() {
-        return {
-            force: false,
-            full: true,
-            docsStructure: ARC42_DOCS_STRUCTURE,
-        };
-    }
-    /**
-     * Initialize a git repo without commits (empty repo state)
-     * Uses execFileSync for safety (no shell injection)
-     */
-    function initEmptyGitRepo() {
-        execFileSync('git', ['init'], { cwd: tempDir, stdio: 'pipe' });
-        // Configure git user for commit (required in some environments)
-        execFileSync('git', ['config', 'user.email', 'test@example.com'], {
-            cwd: tempDir,
-            stdio: 'pipe',
-        });
-        execFileSync('git', ['config', 'user.name', 'Test User'], { cwd: tempDir, stdio: 'pipe' });
-    }
-    /**
-     * Initialize a git repo with an initial commit
-     */
-    function initGitRepoWithCommit() {
-        initEmptyGitRepo();
-        fs.writeFileSync(path.join(tempDir, '.gitkeep'), '');
-        execFileSync('git', ['add', '.gitkeep'], { cwd: tempDir, stdio: 'pipe' });
-        execFileSync('git', ['commit', '-m', 'Initial commit'], { cwd: tempDir, stdio: 'pipe' });
-    }
-    describe('AC: starting-prompt.md has initiative-first workflow section', () => {
-        it('should include "When Starting From Product Vision" section in starting-prompt.md', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const startingPromptPath = path.join(getOnboardingDir(), STARTING_PROMPT_FILE);
-            expect(fs.existsSync(startingPromptPath)).toBe(true);
-            const content = fs.readFileSync(startingPromptPath, 'utf-8');
-            expect(content).toContain('When Starting From Product Vision');
-        });
-        it('should describe 4-step initiative workflow in product vision section', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const startingPromptPath = path.join(getOnboardingDir(), STARTING_PROMPT_FILE);
-            const content = fs.readFileSync(startingPromptPath, 'utf-8');
-            // Should mention initiative creation
-            expect(content).toContain('initiative:create');
-            // Should mention phased work
-            expect(content).toMatch(/phase|INIT-/i);
-            // Should mention WU organization under initiatives
-            expect(content).toMatch(/initiative.*WU|WU.*initiative/i);
-        });
-        it('should warn against creating orphan WUs without initiative structure', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const startingPromptPath = path.join(getOnboardingDir(), STARTING_PROMPT_FILE);
-            const content = fs.readFileSync(startingPromptPath, 'utf-8');
-            // Should have guidance about when NOT to create standalone WUs
-            expect(content).toMatch(/don't|avoid|instead.*initiative/i);
-        });
-    });
-    describe('AC: Init auto-creates initial commit when git repo has no commits', () => {
-        it('should create initial commit in empty git repo', async () => {
-            initEmptyGitRepo();
-            // Verify no commits exist
-            try {
-                execFileSync('git', ['rev-parse', 'HEAD'], { cwd: tempDir, stdio: 'pipe' });
-                throw new Error('Expected HEAD to not exist');
-            }
-            catch {
-                // Expected: fatal: ambiguous argument 'HEAD'
-            }
-            await scaffoldProject(tempDir, getArc42Options());
-            // Now HEAD should exist
-            const result = execFileSync('git', ['rev-parse', 'HEAD'], {
-                cwd: tempDir,
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-            expect(result.trim()).toMatch(/^[a-f0-9]{40}$/);
-        });
-        it('should not create extra commit if repo already has commits', async () => {
-            initGitRepoWithCommit();
-            // Get initial commit count
-            const beforeCount = execFileSync('git', ['rev-list', '--count', 'HEAD'], {
-                cwd: tempDir,
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            }).trim();
-            await scaffoldProject(tempDir, getArc42Options());
-            // Commit count should be the same (init doesn't auto-commit if commits exist)
-            const afterCount = execFileSync('git', ['rev-list', '--count', 'HEAD'], {
-                cwd: tempDir,
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            }).trim();
-            expect(afterCount).toBe(beforeCount);
-        });
-        it('should skip auto-commit if not in a git repo', async () => {
-            // Not a git repo - just a plain directory
-            await scaffoldProject(tempDir, getArc42Options());
-            // Should not fail, just skip the git operations
-            expect(fs.existsSync(path.join(tempDir, LUMENFLOW_CONFIG_FILE))).toBe(true);
-        });
-    });
-    describe('AC: Init auto-sets git.requireRemote=false when no remote configured', () => {
-        it('should set requireRemote=false in config when no origin remote', async () => {
-            initGitRepoWithCommit();
-            // No remote added
-            await scaffoldProject(tempDir, getArc42Options());
-            const configPath = path.join(tempDir, LUMENFLOW_CONFIG_FILE);
-            const content = fs.readFileSync(configPath, 'utf-8');
-            expect(content).toContain('requireRemote: false');
-        });
-        it('should not set requireRemote=false if origin remote exists', async () => {
-            initGitRepoWithCommit();
-            // Add a remote
-            execFileSync('git', ['remote', 'add', 'origin', 'https://github.com/test/repo.git'], {
-                cwd: tempDir,
-                stdio: 'pipe',
-            });
-            await scaffoldProject(tempDir, getArc42Options());
-            const configPath = path.join(tempDir, LUMENFLOW_CONFIG_FILE);
-            const content = fs.readFileSync(configPath, 'utf-8');
-            // Should not have requireRemote: false (remote exists)
-            expect(content).not.toContain('requireRemote: false');
-        });
-        it('should skip remote check if not in a git repo', async () => {
-            // Not a git repo
-            await scaffoldProject(tempDir, getArc42Options());
-            const configPath = path.join(tempDir, LUMENFLOW_CONFIG_FILE);
-            const content = fs.readFileSync(configPath, 'utf-8');
-            // When not in a git repo, should default to requireRemote: false for safety
-            expect(content).toContain('requireRemote: false');
-        });
-    });
-    describe('AC: Default lane-inference template includes Core and Feature parent lanes', () => {
-        it('should include Core as a parent lane', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const laneInferencePath = path.join(tempDir, LANE_INFERENCE_FILE);
-            expect(fs.existsSync(laneInferencePath)).toBe(true);
-            const content = fs.readFileSync(laneInferencePath, 'utf-8');
-            // Should have Core as a top-level parent lane (not just Framework: Core)
-            expect(content).toMatch(/^Core:/m);
-        });
-        it('should include Feature as a parent lane', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const laneInferencePath = path.join(tempDir, LANE_INFERENCE_FILE);
-            const content = fs.readFileSync(laneInferencePath, 'utf-8');
-            // Should have Feature as a top-level parent lane
-            expect(content).toMatch(/^Feature:/m);
-        });
-        it('should support intuitive lane names like "Core: Platform"', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const laneInferencePath = path.join(tempDir, LANE_INFERENCE_FILE);
-            const content = fs.readFileSync(laneInferencePath, 'utf-8');
-            // Should have sublanes under Core and Feature
-            // e.g., Core: followed by sublanes like Platform, Library, etc.
-            expect(content).toMatch(/Core:\n\s+\w+:/m);
-            expect(content).toMatch(/Feature:\n\s+\w+:/m);
-        });
-    });
-    describe('AC: LUMENFLOW.md mentions initiatives and when to use them', () => {
-        it('should mention initiatives in generated LUMENFLOW.md', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const lumenflowPath = path.join(tempDir, 'LUMENFLOW.md');
-            const content = fs.readFileSync(lumenflowPath, 'utf-8');
-            expect(content).toMatch(/initiative/i);
-        });
-        it('should explain when to use initiatives vs standalone WUs', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const lumenflowPath = path.join(tempDir, 'LUMENFLOW.md');
-            const content = fs.readFileSync(lumenflowPath, 'utf-8');
-            // Should mention when to use initiatives
-            expect(content).toMatch(/multi-phase|product vision|larger|complex/i);
-        });
-        it('should reference initiative:create command', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const lumenflowPath = path.join(tempDir, 'LUMENFLOW.md');
-            const content = fs.readFileSync(lumenflowPath, 'utf-8');
-            expect(content).toContain('initiative:create');
-        });
-    });
-    describe('AC: Init output includes initiative-first workflow guidance', () => {
-        // This test verifies the console output, which requires capturing stdout
-        // We'll mock console.log to capture the output
-        it('should print initiative-first guidance in init output', async () => {
-            const consoleLogs = [];
-            const originalLog = console.log;
-            console.log = (...args) => {
-                consoleLogs.push(args.join(' '));
-            };
-            try {
-                // Import and run main() to capture console output
-                const { main } = await import('../init.js');
-                // Change to temp directory and run init
-                const originalCwd = process.cwd();
-                process.chdir(tempDir);
-                // Mock process.argv for parseInitOptions
-                const originalArgv = process.argv;
-                process.argv = ['node', 'init', '--full'];
-                try {
-                    await main();
-                }
-                finally {
-                    process.argv = originalArgv;
-                    process.chdir(originalCwd);
-                }
-                const output = consoleLogs.join('\n');
-                // Should mention initiatives in the "Next steps" or guidance section
-                expect(output).toMatch(/initiative|product vision|INIT-/i);
-            }
-            finally {
-                console.log = originalLog;
-            }
-        });
-    });
-});

package/dist/__tests__/init-lane-inference.test.js

@@ -1,125 +0,0 @@
-/**
- * @file init-lane-inference.test.ts
- * Test: .lumenflow.lane-inference.yaml is generated in hierarchical Parent→Sublane format
- *
- * WU-1307: Fix lumenflow-init scaffolding
- *
- * The generated lane inference config must use the hierarchical format that
- * lane-inference.ts/lane-checker.ts expect:
- *
- * Parent:
- *   Sublane:
- *     code_paths:
- *       - pattern
- *     keywords:
- *       - keyword
- *
- * NOT the flat format:
- * lanes:
- *   - name: "Parent: Sublane"
- *     patterns:
- *       - pattern
- */
-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 YAML from 'yaml';
-import { scaffoldProject } from '../init.js';
-/** Lane inference file name - extracted to avoid duplicate string lint errors */
-const LANE_INFERENCE_FILE_NAME = '.lumenflow.lane-inference.yaml';
-describe('init lane inference generation (WU-1307)', () => {
-    let tempDir;
-    beforeEach(() => {
-        // Create a temporary directory for each test
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-init-lane-inference-'));
-    });
-    afterEach(() => {
-        // Clean up temporary directory
-        if (tempDir && fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-    });
-    /** Helper to read and parse lane inference config from temp directory */
-    function readLaneInference() {
-        const laneInferencePath = path.join(tempDir, LANE_INFERENCE_FILE_NAME);
-        const laneInferenceContent = fs.readFileSync(laneInferencePath, 'utf-8');
-        return YAML.parse(laneInferenceContent);
-    }
-    it('should generate .lumenflow.lane-inference.yaml in hierarchical format', async () => {
-        // Arrange
-        const laneInferencePath = path.join(tempDir, LANE_INFERENCE_FILE_NAME);
-        // Act
-        await scaffoldProject(tempDir, { force: true, full: true });
-        // Assert
-        expect(fs.existsSync(laneInferencePath)).toBe(true);
-        const laneInference = readLaneInference();
-        // Should NOT have a flat 'lanes' array
-        expect(laneInference.lanes).toBeUndefined();
-        // Should have hierarchical Parent -> Sublane structure
-        // At minimum, should have Framework, Operations, Content parents
-        expect(laneInference.Framework).toBeDefined();
-        expect(laneInference.Operations).toBeDefined();
-        expect(laneInference.Content).toBeDefined();
-    });
-    it('should include sublanes under parent lanes', async () => {
-        // Act
-        await scaffoldProject(tempDir, { force: true, full: true });
-        // Assert
-        const laneInference = readLaneInference();
-        // Framework parent should have sublanes like Core, CLI
-        expect(laneInference.Framework?.Core).toBeDefined();
-        expect(laneInference.Framework?.CLI).toBeDefined();
-        // Operations parent should have sublanes like Infrastructure, CI/CD
-        expect(laneInference.Operations?.Infrastructure).toBeDefined();
-        expect(laneInference.Operations?.['CI/CD']).toBeDefined();
-        // Content parent should have Documentation sublane
-        expect(laneInference.Content?.Documentation).toBeDefined();
-    });
-    it('should have code_paths in sublane config (not patterns)', async () => {
-        // Act
-        await scaffoldProject(tempDir, { force: true, full: true });
-        // Assert
-        const laneInference = readLaneInference();
-        // Sublanes should have code_paths (not patterns)
-        const frameworkCore = laneInference.Framework?.Core;
-        expect(frameworkCore).toBeDefined();
-        expect(frameworkCore?.code_paths).toBeDefined();
-        expect(Array.isArray(frameworkCore?.code_paths)).toBe(true);
-        expect(frameworkCore?.patterns).toBeUndefined();
-    });
-    it('should include keywords in sublane config', async () => {
-        // Act
-        await scaffoldProject(tempDir, { force: true, full: true });
-        // Assert
-        const laneInference = readLaneInference();
-        // Sublanes should have keywords array
-        const contentDocs = laneInference.Content?.Documentation;
-        expect(contentDocs).toBeDefined();
-        expect(contentDocs?.keywords).toBeDefined();
-        expect(Array.isArray(contentDocs?.keywords)).toBe(true);
-        expect(contentDocs?.keywords?.length).toBeGreaterThan(0);
-    });
-    it('should generate Experience parent lane for frontend projects', async () => {
-        // Act
-        await scaffoldProject(tempDir, { force: true, full: true });
-        // Assert
-        const laneInference = readLaneInference();
-        // Should have Experience parent for frontend work
-        expect(laneInference.Experience).toBeDefined();
-        expect(laneInference.Experience?.UI || laneInference.Experience?.Web).toBeDefined();
-    });
-    it('should add framework-specific lanes when --framework is provided', async () => {
-        // Act
-        await scaffoldProject(tempDir, {
-            force: true,
-            full: true,
-            framework: 'nextjs',
-        });
-        // Assert
-        const laneInference = readLaneInference();
-        // Should still have base lanes
-        expect(laneInference.Framework).toBeDefined();
-        expect(laneInference.Content).toBeDefined();
-    });
-});

package/dist/__tests__/init-onboarding-docs.test.js

@@ -1,132 +0,0 @@
-/**
- * @file init-onboarding-docs.test.ts
- * Tests for onboarding docs scaffold (WU-1309)
- * Verifies: starting-prompt, first-15-mins, local-only, lane-inference
- */
-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 { scaffoldProject } from '../init.js';
-describe('onboarding docs scaffold', () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-onboarding-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-    // Constants to avoid duplicate strings (sonarjs/no-duplicate-string)
-    const ARC42_DOCS_STRUCTURE = 'arc42';
-    const STARTING_PROMPT_FILE = 'starting-prompt.md';
-    const FIRST_15_MINS_FILE = 'first-15-mins.md';
-    const LOCAL_ONLY_FILE = 'local-only.md';
-    const LANE_INFERENCE_FILE = 'lane-inference.md';
-    function getOnboardingDir(docsStructure = ARC42_DOCS_STRUCTURE) {
-        if (docsStructure === 'simple') {
-            return path.join(tempDir, 'docs', '_frameworks', 'lumenflow', 'agent', 'onboarding');
-        }
-        return path.join(tempDir, 'docs', '04-operations', '_frameworks', 'lumenflow', 'agent', 'onboarding');
-    }
-    function getArc42Options() {
-        return {
-            force: false,
-            full: true,
-            docsStructure: ARC42_DOCS_STRUCTURE,
-        };
-    }
-    describe('required onboarding docs', () => {
-        it('should scaffold starting-prompt.md', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const docPath = path.join(getOnboardingDir(), STARTING_PROMPT_FILE);
-            expect(fs.existsSync(docPath)).toBe(true);
-            const content = fs.readFileSync(docPath, 'utf-8');
-            expect(content).toContain('Starting Prompt');
-            expect(content).toContain('LUMENFLOW.md');
-        });
-        it('should scaffold first-15-mins.md', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const docPath = path.join(getOnboardingDir(), FIRST_15_MINS_FILE);
-            expect(fs.existsSync(docPath)).toBe(true);
-            const content = fs.readFileSync(docPath, 'utf-8');
-            expect(content).toContain('First 15 Minutes');
-        });
-        it('should scaffold local-only.md', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const docPath = path.join(getOnboardingDir(), LOCAL_ONLY_FILE);
-            expect(fs.existsSync(docPath)).toBe(true);
-            const content = fs.readFileSync(docPath, 'utf-8');
-            expect(content).toContain('requireRemote');
-            expect(content).toContain('local');
-        });
-        it('should scaffold lane-inference.md', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const docPath = path.join(getOnboardingDir(), LANE_INFERENCE_FILE);
-            expect(fs.existsSync(docPath)).toBe(true);
-            const content = fs.readFileSync(docPath, 'utf-8');
-            expect(content).toContain('lane');
-            expect(content).toContain('.lumenflow.lane-inference.yaml');
-        });
-    });
-    describe('onboarding docs with simple structure', () => {
-        it('should scaffold onboarding docs in simple structure', async () => {
-            const options = {
-                force: false,
-                full: true,
-                docsStructure: 'simple',
-            };
-            await scaffoldProject(tempDir, options);
-            const onboardingDir = getOnboardingDir('simple');
-            expect(fs.existsSync(path.join(onboardingDir, STARTING_PROMPT_FILE))).toBe(true);
-            expect(fs.existsSync(path.join(onboardingDir, FIRST_15_MINS_FILE))).toBe(true);
-            expect(fs.existsSync(path.join(onboardingDir, LOCAL_ONLY_FILE))).toBe(true);
-            expect(fs.existsSync(path.join(onboardingDir, LANE_INFERENCE_FILE))).toBe(true);
-        });
-    });
-    describe('complete onboarding docs set', () => {
-        it('should scaffold all required onboarding docs with --full', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const onboardingDir = getOnboardingDir();
-            // Required docs from WU-1309
-            const requiredDocs = [
-                STARTING_PROMPT_FILE,
-                FIRST_15_MINS_FILE,
-                LOCAL_ONLY_FILE,
-                LANE_INFERENCE_FILE,
-                // Previously existing docs
-                'quick-ref-commands.md',
-                'first-wu-mistakes.md',
-                'troubleshooting-wu-done.md',
-                'agent-safety-card.md',
-                'wu-create-checklist.md',
-            ];
-            for (const doc of requiredDocs) {
-                const docPath = path.join(onboardingDir, doc);
-                expect(fs.existsSync(docPath), `Expected ${doc} to exist`).toBe(true);
-            }
-        });
-        it('should not scaffold onboarding docs without --full', async () => {
-            const options = {
-                force: false,
-                full: false,
-            };
-            await scaffoldProject(tempDir, options);
-            const onboardingDir = getOnboardingDir();
-            // Onboarding docs should not exist without --full (unless --client claude)
-            expect(fs.existsSync(path.join(onboardingDir, STARTING_PROMPT_FILE))).toBe(false);
-        });
-    });
-    describe('onboarding docs content quality', () => {
-        it('should have consistent date placeholder in all docs', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const onboardingDir = getOnboardingDir();
-            const docs = fs.readdirSync(onboardingDir).filter((f) => f.endsWith('.md'));
-            for (const doc of docs) {
-                const content = fs.readFileSync(path.join(onboardingDir, doc), 'utf-8');
-                // Should have a date in YYYY-MM-DD format (not {{DATE}} placeholder)
-                expect(content).toMatch(/\d{4}-\d{2}-\d{2}/);
-                expect(content).not.toContain('{{DATE}}');
-            }
-        });
-    });
-});

package/dist/__tests__/init-quick-ref.test.js

@@ -1,144 +0,0 @@
-/**
- * @file init-quick-ref.test.ts
- * Tests for quick-ref commands content (WU-1309)
- * Verifies: correct init command, complete wu:create example
- */
-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 { scaffoldProject } from '../init.js';
-// Constants to avoid duplicate strings (sonarjs/no-duplicate-string)
-const ARC42_DOCS_STRUCTURE = 'arc42';
-describe('quick-ref commands', () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-quickref-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-    function getQuickRefPath(docsStructure = ARC42_DOCS_STRUCTURE) {
-        if (docsStructure === 'simple') {
-            return path.join(tempDir, 'docs', '_frameworks', 'lumenflow', 'agent', 'onboarding', 'quick-ref-commands.md');
-        }
-        return path.join(tempDir, 'docs', '04-operations', '_frameworks', 'lumenflow', 'agent', 'onboarding', 'quick-ref-commands.md');
-    }
-    function getArc42Options() {
-        return {
-            force: false,
-            full: true,
-            docsStructure: ARC42_DOCS_STRUCTURE,
-        };
-    }
-    describe('init command documentation', () => {
-        it('should show correct lumenflow init command', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should document the init command correctly
-            expect(content).toContain('lumenflow init');
-            // Should show the various init flags
-            expect(content).toContain('--full');
-        });
-        it('should document --docs-structure flag in quick-ref', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should document the docs-structure option
-            expect(content).toContain('--docs-structure');
-            expect(content).toMatch(/simple|arc42/);
-        });
-    });
-    describe('wu:create example', () => {
-        it('should include a complete wu:create example with all required fields', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should have a complete wu:create example
-            expect(content).toContain('wu:create');
-            expect(content).toContain('--lane');
-            expect(content).toContain('--title');
-            expect(content).toContain('--description');
-            expect(content).toContain('--acceptance');
-            expect(content).toContain('--code-paths');
-            expect(content).toContain('--exposure');
-        });
-        it('should show test-paths in wu:create example', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should include test paths
-            expect(content).toMatch(/--test-paths-(unit|e2e)/);
-        });
-        it('should show spec-refs in wu:create example for feature WUs', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should include spec-refs for feature WUs
-            expect(content).toContain('--spec-refs');
-        });
-    });
-    describe('AGENTS.md quick-ref link', () => {
-        it('should have correct quick-ref link for arc42 structure', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const agentsContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            // Should point to arc42 path
-            expect(agentsContent).toContain('docs/04-operations/_frameworks/lumenflow/agent/onboarding/quick-ref-commands.md');
-        });
-        it('should have correct quick-ref link for simple structure', async () => {
-            const options = {
-                force: false,
-                full: true,
-                docsStructure: 'simple',
-            };
-            await scaffoldProject(tempDir, options);
-            const agentsContent = fs.readFileSync(path.join(tempDir, 'AGENTS.md'), 'utf-8');
-            // Should point to simple path (without 04-operations)
-            expect(agentsContent).toContain('docs/_frameworks/lumenflow/agent/onboarding/quick-ref-commands.md');
-            expect(agentsContent).not.toContain('04-operations');
-        });
-    });
-    describe('quick-ref command tables', () => {
-        it('should have project setup commands including init', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should have a project setup section
-            expect(content).toMatch(/##.*?Setup|##.*?Project/i);
-            expect(content).toContain('lumenflow init');
-        });
-        it('should have WU management commands', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should have WU commands
-            expect(content).toContain('wu:create');
-            expect(content).toContain('wu:claim');
-            expect(content).toContain('wu:done');
-            expect(content).toContain('wu:block');
-        });
-        it('should have gates commands', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should have gates commands
-            expect(content).toContain('pnpm gates');
-            expect(content).toContain('--docs-only');
-        });
-    });
-    describe('workflow sequence', () => {
-        it('should have a complete workflow sequence example', async () => {
-            await scaffoldProject(tempDir, getArc42Options());
-            const quickRefPath = getQuickRefPath();
-            const content = fs.readFileSync(quickRefPath, 'utf-8');
-            // Should have workflow sequence
-            expect(content).toMatch(/workflow|sequence/i);
-            // Should show the full flow: create -> claim -> work -> commit -> gates -> done
-            expect(content).toContain('wu:create');
-            expect(content).toContain('wu:claim');
-            expect(content).toContain('pnpm gates');
-            expect(content).toContain('wu:done');
-        });
-    });
-});