@lumenflow/cli 2.4.0 → 2.5.0

package/dist/__tests__/init-config-lanes.test.js

@@ -0,0 +1,131 @@
+/**
+ * @file init-config-lanes.test.ts
+ * Test: .lumenflow.config.yaml includes default lane definitions for parent lanes
+ *
+ * WU-1307: Fix lumenflow-init scaffolding
+ *
+ * The generated config must include lane definitions that match the parent
+ * lanes used in the documentation examples (Framework, Experience, Content, Operations).
+ * These lanes should have sensible defaults for code_paths and wip_limit.
+ */
+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';
+/** Config file name - extracted to avoid duplicate string lint errors */
+const CONFIG_FILE_NAME = '.lumenflow.config.yaml';
+describe('init config default lanes (WU-1307)', () => {
+    let tempDir;
+    beforeEach(() => {
+        // Create a temporary directory for each test
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-init-config-lanes-'));
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    /** Helper to read and parse config from temp directory */
+    function readConfig() {
+        const configPath = path.join(tempDir, CONFIG_FILE_NAME);
+        const configContent = fs.readFileSync(configPath, 'utf-8');
+        return YAML.parse(configContent);
+    }
+    it('should generate .lumenflow.config.yaml with lanes.definitions', async () => {
+        // Arrange
+        const configPath = path.join(tempDir, CONFIG_FILE_NAME);
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        expect(fs.existsSync(configPath)).toBe(true);
+        const config = readConfig();
+        // Should have lanes.definitions
+        expect(config.lanes).toBeDefined();
+        expect(config.lanes.definitions).toBeDefined();
+        expect(Array.isArray(config.lanes.definitions)).toBe(true);
+    });
+    it('should include Framework parent lane with sublanes', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const config = readConfig();
+        const lanes = (config.lanes?.definitions || []);
+        const frameworkLanes = lanes.filter((l) => l.name.startsWith('Framework:'));
+        expect(frameworkLanes.length).toBeGreaterThan(0);
+        // Should have at least Framework: Core and Framework: CLI
+        const laneNames = frameworkLanes.map((l) => l.name);
+        expect(laneNames).toContain('Framework: Core');
+        expect(laneNames).toContain('Framework: CLI');
+    });
+    it('should include Experience parent lane for frontend work', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const config = readConfig();
+        const lanes = (config.lanes?.definitions || []);
+        const experienceLanes = lanes.filter((l) => l.name.startsWith('Experience:'));
+        // Should have at least one Experience lane
+        expect(experienceLanes.length).toBeGreaterThan(0);
+    });
+    it('should include Content: Documentation lane', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const config = readConfig();
+        const lanes = (config.lanes?.definitions || []);
+        const contentLane = lanes.find((l) => l.name === 'Content: Documentation');
+        expect(contentLane).toBeDefined();
+        expect(contentLane?.code_paths).toBeDefined();
+        expect(contentLane?.code_paths).toContain('docs/**');
+    });
+    it('should include Operations parent lanes', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const config = readConfig();
+        const lanes = (config.lanes?.definitions || []);
+        const operationsLanes = lanes.filter((l) => l.name.startsWith('Operations:'));
+        expect(operationsLanes.length).toBeGreaterThan(0);
+        // Should have Infrastructure and CI/CD
+        const laneNames = operationsLanes.map((l) => l.name);
+        expect(laneNames).toContain('Operations: Infrastructure');
+        expect(laneNames).toContain('Operations: CI/CD');
+    });
+    it('should have wip_limit: 1 for code lanes by default', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const config = readConfig();
+        const lanes = (config.lanes?.definitions || []);
+        const frameworkCore = lanes.find((l) => l.name === 'Framework: Core');
+        expect(frameworkCore).toBeDefined();
+        expect(frameworkCore?.wip_limit).toBe(1);
+    });
+    it('should have code_paths for each lane', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const config = readConfig();
+        const lanes = (config.lanes?.definitions || []);
+        // Every lane should have code_paths
+        for (const lane of lanes) {
+            expect(lane.code_paths).toBeDefined();
+            expect(Array.isArray(lane.code_paths)).toBe(true);
+            expect(lane.code_paths?.length).toBeGreaterThan(0);
+        }
+    });
+    it('should use "Parent: Sublane" format for lane names', async () => {
+        // Act
+        await scaffoldProject(tempDir, { force: true, full: true });
+        // Assert
+        const config = readConfig();
+        const lanes = (config.lanes?.definitions || []);
+        // All lanes should follow "Parent: Sublane" format (colon + space)
+        for (const lane of lanes) {
+            expect(lane.name).toMatch(/^[A-Z][a-z]+: [A-Z]/);
+        }
+    });
+});

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

@@ -0,0 +1,119 @@
+/**
+ * @file init-docs-structure.test.ts
+ * Tests for --docs-structure flag and auto-detection (WU-1309)
+ */
+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, detectDocsStructure, getDocsPath, } from '../init.js';
+// Constants to avoid duplicate strings (sonarjs/no-duplicate-string)
+const ARC42_DOCS_STRUCTURE = 'arc42';
+const SIMPLE_DOCS_STRUCTURE = 'simple';
+const DOCS_04_OPERATIONS = '04-operations';
+describe('docs-structure', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lumenflow-docs-structure-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    describe('detectDocsStructure', () => {
+        it('should return "arc42" when docs/04-operations exists', () => {
+            fs.mkdirSync(path.join(tempDir, 'docs', DOCS_04_OPERATIONS), { recursive: true });
+            const result = detectDocsStructure(tempDir);
+            expect(result).toBe(ARC42_DOCS_STRUCTURE);
+        });
+        it('should return "simple" when docs exists without 04-operations', () => {
+            fs.mkdirSync(path.join(tempDir, 'docs'), { recursive: true });
+            fs.writeFileSync(path.join(tempDir, 'docs', 'README.md'), '# Docs\n');
+            const result = detectDocsStructure(tempDir);
+            expect(result).toBe(SIMPLE_DOCS_STRUCTURE);
+        });
+        it('should return "simple" when no docs directory exists', () => {
+            const result = detectDocsStructure(tempDir);
+            expect(result).toBe(SIMPLE_DOCS_STRUCTURE);
+        });
+        it('should detect arc42 with any numbered directory (01-*, 02-*, etc.)', () => {
+            fs.mkdirSync(path.join(tempDir, 'docs', '01-introduction'), { recursive: true });
+            const result = detectDocsStructure(tempDir);
+            expect(result).toBe(ARC42_DOCS_STRUCTURE);
+        });
+    });
+    describe('getDocsPath', () => {
+        it('should return simple paths for simple structure', () => {
+            const paths = getDocsPath(SIMPLE_DOCS_STRUCTURE);
+            expect(paths.operations).toBe('docs');
+            expect(paths.tasks).toBe('docs/tasks');
+            expect(paths.onboarding).toBe('docs/_frameworks/lumenflow/agent/onboarding');
+        });
+        it('should return arc42 paths for arc42 structure', () => {
+            const paths = getDocsPath(ARC42_DOCS_STRUCTURE);
+            expect(paths.operations).toBe('docs/04-operations');
+            expect(paths.tasks).toBe('docs/04-operations/tasks');
+            expect(paths.onboarding).toBe('docs/04-operations/_frameworks/lumenflow/agent/onboarding');
+        });
+    });
+    describe('scaffoldProject with --docs-structure', () => {
+        it('should scaffold simple structure with --docs-structure simple', async () => {
+            const options = {
+                force: false,
+                full: true,
+                docsStructure: SIMPLE_DOCS_STRUCTURE,
+            };
+            await scaffoldProject(tempDir, options);
+            // Simple structure: docs/tasks, not docs/04-operations/tasks
+            expect(fs.existsSync(path.join(tempDir, 'docs', 'tasks'))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, 'docs', DOCS_04_OPERATIONS))).toBe(false);
+        });
+        it('should scaffold arc42 structure with --docs-structure arc42', async () => {
+            const options = {
+                force: false,
+                full: true,
+                docsStructure: ARC42_DOCS_STRUCTURE,
+            };
+            await scaffoldProject(tempDir, options);
+            // Arc42 structure: docs/04-operations/tasks
+            expect(fs.existsSync(path.join(tempDir, 'docs', DOCS_04_OPERATIONS, 'tasks'))).toBe(true);
+        });
+        it('should auto-detect arc42 when docs/04-operations exists', async () => {
+            // Create existing arc42 structure
+            fs.mkdirSync(path.join(tempDir, 'docs', DOCS_04_OPERATIONS), { recursive: true });
+            const options = {
+                force: false,
+                full: true,
+                // No docsStructure specified - should auto-detect arc42
+            };
+            await scaffoldProject(tempDir, options);
+            // Should use arc42 structure
+            expect(fs.existsSync(path.join(tempDir, 'docs', DOCS_04_OPERATIONS, 'tasks'))).toBe(true);
+        });
+        it('should auto-detect simple when only docs exists', async () => {
+            // Create existing simple structure
+            fs.mkdirSync(path.join(tempDir, 'docs'), { recursive: true });
+            fs.writeFileSync(path.join(tempDir, 'docs', 'README.md'), '# Docs\n');
+            const options = {
+                force: false,
+                full: true,
+                // No docsStructure specified - should auto-detect simple
+            };
+            await scaffoldProject(tempDir, options);
+            // Should use simple structure
+            expect(fs.existsSync(path.join(tempDir, 'docs', 'tasks'))).toBe(true);
+            expect(fs.existsSync(path.join(tempDir, 'docs', DOCS_04_OPERATIONS))).toBe(false);
+        });
+        it('should respect explicit --docs-structure over auto-detection', async () => {
+            // Create existing arc42 structure
+            fs.mkdirSync(path.join(tempDir, 'docs', DOCS_04_OPERATIONS), { recursive: true });
+            const options = {
+                force: true, // Force overwrite
+                full: true,
+                docsStructure: SIMPLE_DOCS_STRUCTURE, // Explicitly request simple
+            };
+            await scaffoldProject(tempDir, options);
+            // Should use simple structure despite arc42 existing
+            expect(fs.existsSync(path.join(tempDir, 'docs', 'tasks'))).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,125 @@
+/**
+ * @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

@@ -0,0 +1,132 @@
+/**
+ * @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

@@ -0,0 +1,145 @@
+/**
+ * @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
+            // eslint-disable-next-line sonarjs/slow-regex -- Simple alternation, no backtracking risk
+            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');
+        });
+    });
+});