@lumenflow/cli 2.20.1 → 2.21.1

package/dist/__tests__/hooks/enforcement.test.js

@@ -1,279 +0,0 @@
-/**
- * @file enforcement.test.ts
- * Tests for Claude Code enforcement hooks (WU-1367)
- *
- * TDD: Write failing tests first, then implement.
- */
-// Test file lint exceptions
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import * as fs from 'node:fs';
-// Mock fs before importing module under test
-vi.mock('node:fs');
-vi.mock('node:child_process');
-const TEST_PROJECT_DIR = '/test/project';
-const CONFIG_FILE_NAME = '.lumenflow.config.yaml';
-describe('WU-1367: Enforcement Hooks Config Schema', () => {
-    describe('ClientConfigSchema enforcement block', () => {
-        it('should accept enforcement block under agents.clients.claude-code', async () => {
-            // Import dynamically to allow mocking
-            const { ClientConfigSchema } = await import('@lumenflow/core/dist/lumenflow-config-schema.js');
-            const config = {
-                preamble: 'CLAUDE.md',
-                skillsDir: '.claude/skills',
-                enforcement: {
-                    hooks: true,
-                    block_outside_worktree: true,
-                    require_wu_for_edits: true,
-                    warn_on_stop_without_wu_done: true,
-                },
-            };
-            const result = ClientConfigSchema.safeParse(config);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.enforcement).toEqual({
-                    hooks: true,
-                    block_outside_worktree: true,
-                    require_wu_for_edits: true,
-                    warn_on_stop_without_wu_done: true,
-                });
-            }
-        });
-        it('should default enforcement values to false when not specified', async () => {
-            const { ClientConfigSchema } = await import('@lumenflow/core/dist/lumenflow-config-schema.js');
-            const config = {
-                preamble: 'CLAUDE.md',
-                enforcement: {},
-            };
-            const result = ClientConfigSchema.safeParse(config);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.enforcement?.hooks).toBe(false);
-                expect(result.data.enforcement?.block_outside_worktree).toBe(false);
-                expect(result.data.enforcement?.require_wu_for_edits).toBe(false);
-                expect(result.data.enforcement?.warn_on_stop_without_wu_done).toBe(false);
-            }
-        });
-        it('should allow enforcement to be undefined', async () => {
-            const { ClientConfigSchema } = await import('@lumenflow/core/dist/lumenflow-config-schema.js');
-            const config = {
-                preamble: 'CLAUDE.md',
-            };
-            const result = ClientConfigSchema.safeParse(config);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.enforcement).toBeUndefined();
-            }
-        });
-    });
-});
-describe('WU-1367: Hook Generation', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('generateEnforcementHooks', () => {
-        it('should generate PreToolUse hook for Write/Edit blocking when block_outside_worktree=true', async () => {
-            const { generateEnforcementHooks } = await import('../../hooks/enforcement-generator.js');
-            const config = {
-                block_outside_worktree: true,
-                require_wu_for_edits: false,
-                warn_on_stop_without_wu_done: false,
-            };
-            const hooks = generateEnforcementHooks(config);
-            expect(hooks.preToolUse).toBeDefined();
-            expect(hooks.preToolUse?.length).toBeGreaterThan(0);
-            expect(hooks.preToolUse?.[0].matcher).toBe('Write|Edit');
-        });
-        it('should generate PreToolUse hook for WU requirement when require_wu_for_edits=true', async () => {
-            const { generateEnforcementHooks } = await import('../../hooks/enforcement-generator.js');
-            const config = {
-                block_outside_worktree: false,
-                require_wu_for_edits: true,
-                warn_on_stop_without_wu_done: false,
-            };
-            const hooks = generateEnforcementHooks(config);
-            expect(hooks.preToolUse).toBeDefined();
-            expect(hooks.preToolUse?.some((h) => h.matcher === 'Write|Edit')).toBe(true);
-        });
-        it('should generate Stop hook when warn_on_stop_without_wu_done=true', async () => {
-            const { generateEnforcementHooks } = await import('../../hooks/enforcement-generator.js');
-            const config = {
-                block_outside_worktree: false,
-                require_wu_for_edits: false,
-                warn_on_stop_without_wu_done: true,
-            };
-            const hooks = generateEnforcementHooks(config);
-            expect(hooks.stop).toBeDefined();
-            expect(hooks.stop?.length).toBeGreaterThan(0);
-        });
-        it('should return empty hooks when all enforcement options are false', async () => {
-            const { generateEnforcementHooks } = await import('../../hooks/enforcement-generator.js');
-            const config = {
-                block_outside_worktree: false,
-                require_wu_for_edits: false,
-                warn_on_stop_without_wu_done: false,
-            };
-            const hooks = generateEnforcementHooks(config);
-            expect(hooks.preToolUse).toBeUndefined();
-            expect(hooks.stop).toBeUndefined();
-        });
-    });
-});
-describe('WU-1367: Integrate Command', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('integrateClaudeCode', () => {
-        it('should create .claude/hooks directory when enforcement.hooks=true', async () => {
-            const mockMkdirSync = vi.mocked(fs.mkdirSync);
-            vi.mocked(fs.writeFileSync);
-            vi.mocked(fs.existsSync).mockReturnValue(false);
-            const { integrateClaudeCode } = await import('../../commands/integrate.js');
-            const config = {
-                enforcement: {
-                    hooks: true,
-                    block_outside_worktree: true,
-                    require_wu_for_edits: false,
-                    warn_on_stop_without_wu_done: false,
-                },
-            };
-            await integrateClaudeCode(TEST_PROJECT_DIR, config);
-            expect(mockMkdirSync).toHaveBeenCalledWith(expect.stringContaining('.claude/hooks'), expect.any(Object));
-        });
-        it('should generate enforce-worktree.sh hook when block_outside_worktree=true', async () => {
-            const mockWriteFileSync = vi.mocked(fs.writeFileSync);
-            vi.mocked(fs.existsSync).mockReturnValue(false);
-            vi.mocked(fs.mkdirSync).mockReturnValue(undefined);
-            const { integrateClaudeCode } = await import('../../commands/integrate.js');
-            const config = {
-                enforcement: {
-                    hooks: true,
-                    block_outside_worktree: true,
-                    require_wu_for_edits: false,
-                    warn_on_stop_without_wu_done: false,
-                },
-            };
-            await integrateClaudeCode(TEST_PROJECT_DIR, config);
-            expect(mockWriteFileSync).toHaveBeenCalledWith(expect.stringContaining('enforce-worktree.sh'), expect.any(String), expect.any(Object));
-        });
-        it('should update settings.json with hook configuration', async () => {
-            const mockWriteFileSync = vi.mocked(fs.writeFileSync);
-            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({
-                permissions: { allow: ['Bash'] },
-            }));
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.mkdirSync).mockReturnValue(undefined);
-            const { integrateClaudeCode } = await import('../../commands/integrate.js');
-            const config = {
-                enforcement: {
-                    hooks: true,
-                    block_outside_worktree: true,
-                    require_wu_for_edits: false,
-                    warn_on_stop_without_wu_done: false,
-                },
-            };
-            await integrateClaudeCode(TEST_PROJECT_DIR, config);
-            // Should write updated settings.json with hooks config
-            const settingsCall = mockWriteFileSync.mock.calls.find((call) => String(call[0]).includes('settings.json'));
-            expect(settingsCall).toBeDefined();
-            const settingsContent = JSON.parse(settingsCall[1]);
-            expect(settingsContent.hooks).toBeDefined();
-            expect(settingsContent.hooks.PreToolUse).toBeDefined();
-        });
-    });
-});
-describe('WU-1367: Hook Graceful Degradation', () => {
-    it('should allow operation when LumenFlow state cannot be determined', async () => {
-        // The hook should fail-open if it cannot determine LumenFlow state
-        // This prevents blocking legitimate work due to infrastructure issues
-        const { checkWorktreeEnforcement } = await import('../../hooks/enforcement-checks.js');
-        // Simulate missing .lumenflow directory
-        vi.mocked(fs.existsSync).mockReturnValue(false);
-        const result = await checkWorktreeEnforcement({
-            file_path: '/some/path/file.ts',
-            tool_name: 'Write',
-        });
-        // Should not block - graceful degradation
-        expect(result.allowed).toBe(true);
-        expect(result.reason).toContain('graceful');
-    });
-    it('should allow operation when worktree detection fails', async () => {
-        const { checkWorktreeEnforcement } = await import('../../hooks/enforcement-checks.js');
-        // Simulate git command failure
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        const mockExecFileSync = vi.fn().mockImplementation(() => {
-            throw new Error('git command failed');
-        });
-        vi.doMock('node:child_process', () => ({
-            execFileSync: mockExecFileSync,
-        }));
-        const result = await checkWorktreeEnforcement({
-            file_path: '/some/path/file.ts',
-            tool_name: 'Write',
-        });
-        // Should not block - graceful degradation
-        expect(result.allowed).toBe(true);
-    });
-});
-describe('WU-1367: Setup Hook Sync', () => {
-    it('should sync hooks when enforcement.hooks=true in config', async () => {
-        // This tests that pnpm setup syncs hooks appropriately
-        const mockWriteFileSync = vi.mocked(fs.writeFileSync);
-        vi.mocked(fs.mkdirSync).mockReturnValue(undefined);
-        // Mock existsSync to return false for most paths (so dirs get created)
-        // but return true for the config file
-        vi.mocked(fs.existsSync).mockImplementation((p) => {
-            const pathStr = String(p);
-            return pathStr.endsWith(CONFIG_FILE_NAME);
-        });
-        // Config file is YAML, not JSON
-        vi.mocked(fs.readFileSync).mockImplementation((p) => {
-            const pathStr = String(p);
-            if (pathStr.endsWith(CONFIG_FILE_NAME)) {
-                return `
-agents:
-  clients:
-    claude-code:
-      enforcement:
-        hooks: true
-        block_outside_worktree: true
-`;
-            }
-            // Return empty JSON for settings.json
-            return '{}';
-        });
-        // Clear any previous calls
-        mockWriteFileSync.mockClear();
-        const { syncEnforcementHooks } = await import('../../hooks/enforcement-sync.js');
-        const result = await syncEnforcementHooks(TEST_PROJECT_DIR);
-        // Should have written hook files
-        expect(result).toBe(true);
-        expect(mockWriteFileSync).toHaveBeenCalled();
-    });
-    it('should skip hook sync when enforcement.hooks=false', async () => {
-        const mockWriteFileSync = vi.mocked(fs.writeFileSync);
-        vi.mocked(fs.existsSync).mockImplementation((p) => {
-            const pathStr = String(p);
-            return pathStr.endsWith(CONFIG_FILE_NAME);
-        });
-        vi.mocked(fs.readFileSync).mockImplementation((p) => {
-            const pathStr = String(p);
-            if (pathStr.endsWith(CONFIG_FILE_NAME)) {
-                return `
-agents:
-  clients:
-    claude-code:
-      enforcement:
-        hooks: false
-`;
-            }
-            return '{}';
-        });
-        // Clear any previous calls
-        mockWriteFileSync.mockClear();
-        const { syncEnforcementHooks } = await import('../../hooks/enforcement-sync.js');
-        const result = await syncEnforcementHooks(TEST_PROJECT_DIR);
-        // Should NOT have written hook files
-        expect(result).toBe(false);
-        expect(mockWriteFileSync).not.toHaveBeenCalled();
-    });
-});

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

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

@@ -1,152 +0,0 @@
-/**
- * @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 WU template with resilient defaults (simple)', async () => {
-            const options = {
-                force: false,
-                full: true,
-                docsStructure: SIMPLE_DOCS_STRUCTURE,
-            };
-            await scaffoldProject(tempDir, options);
-            const templatePath = path.join(tempDir, 'docs', 'tasks', 'templates', 'wu-template.yaml');
-            expect(fs.existsSync(templatePath)).toBe(true);
-            const content = fs.readFileSync(templatePath, 'utf-8');
-            // Feature WUs should reference plan protocol by default (plan-less friendly).
-            expect(content).toContain('lumenflow://plans/WU-XXX-plan.md');
-            // Ensure non-empty notes to avoid strict spec-linter failures out of the box.
-            expect(content).not.toContain("notes: ''");
-            expect(content).toContain('notes:');
-            // Ensure manual test stub exists to prevent empty tests failures.
-            expect(content).toContain('Manual check:');
-        });
-        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 scaffold WU template with resilient defaults (arc42)', async () => {
-            const options = {
-                force: false,
-                full: true,
-                docsStructure: ARC42_DOCS_STRUCTURE,
-            };
-            await scaffoldProject(tempDir, options);
-            const templatePath = path.join(tempDir, 'docs', DOCS_04_OPERATIONS, 'tasks', 'templates', 'wu-template.yaml');
-            expect(fs.existsSync(templatePath)).toBe(true);
-            const content = fs.readFileSync(templatePath, 'utf-8');
-            expect(content).toContain('lumenflow://plans/WU-XXX-plan.md');
-            expect(content).not.toContain("notes: ''");
-            expect(content).toContain('notes:');
-            expect(content).toContain('Manual check:');
-        });
-        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);
-        });
-    });
-});