@lumenflow/cli 2.20.1 → 2.21.1

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

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

package/dist/__tests__/trace-gen.test.js

@@ -1,115 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for trace-gen CLI command
- *
- * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
- *
- * Trace generator creates traceability reports linking WUs to code changes,
- * useful for audit trails and compliance documentation.
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Import functions under test
-import { parseTraceArgs, TraceFormat, buildTraceEntry, } from '../trace-gen.js';
-describe('trace-gen', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('parseTraceArgs', () => {
-        it('should parse --wu flag', () => {
-            const args = parseTraceArgs(['node', 'trace-gen.js', '--wu', 'WU-1112']);
-            expect(args.wuId).toBe('WU-1112');
-        });
-        it('should parse --format json', () => {
-            const args = parseTraceArgs(['node', 'trace-gen.js', '--format', 'json']);
-            expect(args.format).toBe('json');
-        });
-        it('should parse --format markdown', () => {
-            const args = parseTraceArgs(['node', 'trace-gen.js', '--format', 'markdown']);
-            expect(args.format).toBe('markdown');
-        });
-        it('should parse --output flag', () => {
-            const args = parseTraceArgs(['node', 'trace-gen.js', '--output', 'trace.json']);
-            expect(args.output).toBe('trace.json');
-        });
-        it('should parse --since flag', () => {
-            const args = parseTraceArgs(['node', 'trace-gen.js', '--since', '2024-01-01']);
-            expect(args.since).toBe('2024-01-01');
-        });
-        it('should parse --help flag', () => {
-            const args = parseTraceArgs(['node', 'trace-gen.js', '--help']);
-            expect(args.help).toBe(true);
-        });
-        it('should default format to json', () => {
-            const args = parseTraceArgs(['node', 'trace-gen.js']);
-            expect(args.format).toBeUndefined();
-        });
-    });
-    describe('TraceFormat enum', () => {
-        it('should have JSON format', () => {
-            expect(TraceFormat.JSON).toBe('json');
-        });
-        it('should have markdown format', () => {
-            expect(TraceFormat.MARKDOWN).toBe('markdown');
-        });
-        it('should have CSV format', () => {
-            expect(TraceFormat.CSV).toBe('csv');
-        });
-    });
-    describe('buildTraceEntry', () => {
-        it('should build trace entry from WU and commit data', () => {
-            const entry = buildTraceEntry({
-                wuId: 'WU-1112',
-                title: 'Migrate tools',
-                status: 'done',
-                commits: [{ sha: 'abc1234', message: 'feat: add deps-add', date: '2024-01-15T10:00:00Z' }],
-                files: ['src/deps-add.ts'],
-            });
-            expect(entry.wuId).toBe('WU-1112');
-            expect(entry.title).toBe('Migrate tools');
-            expect(entry.status).toBe('done');
-            expect(entry.commitCount).toBe(1);
-            expect(entry.fileCount).toBe(1);
-        });
-        it('should calculate commit count correctly', () => {
-            const entry = buildTraceEntry({
-                wuId: 'WU-1112',
-                title: 'Test',
-                status: 'done',
-                commits: [
-                    { sha: 'abc1234', message: 'feat: first', date: '2024-01-15T10:00:00Z' },
-                    { sha: 'def5678', message: 'feat: second', date: '2024-01-16T10:00:00Z' },
-                    { sha: 'ghi9012', message: 'fix: third', date: '2024-01-17T10:00:00Z' },
-                ],
-                files: ['a.ts', 'b.ts'],
-            });
-            expect(entry.commitCount).toBe(3);
-            expect(entry.fileCount).toBe(2);
-        });
-        it('should include first and last commit dates', () => {
-            const entry = buildTraceEntry({
-                wuId: 'WU-1112',
-                title: 'Test',
-                status: 'done',
-                commits: [
-                    { sha: 'abc1234', message: 'feat: first', date: '2024-01-15T10:00:00Z' },
-                    { sha: 'def5678', message: 'feat: last', date: '2024-01-20T10:00:00Z' },
-                ],
-                files: [],
-            });
-            expect(entry.firstCommit).toBe('2024-01-15T10:00:00Z');
-            expect(entry.lastCommit).toBe('2024-01-20T10:00:00Z');
-        });
-        it('should handle empty commits array', () => {
-            const entry = buildTraceEntry({
-                wuId: 'WU-1112',
-                title: 'Test',
-                status: 'done',
-                commits: [],
-                files: [],
-            });
-            expect(entry.commitCount).toBe(0);
-            expect(entry.firstCommit).toBeUndefined();
-            expect(entry.lastCommit).toBeUndefined();
-        });
-    });
-});

package/dist/__tests__/wu-create-required-fields.test.js

@@ -1,143 +0,0 @@
-/**
- * @file wu-create-required-fields.test.ts
- * Test suite for wu:create required field aggregation (WU-1366)
- *
- * WU-1366: Missing required fields in wu:create should be reported together
- *          in a single error block.
- *
- * Tests:
- * - Multiple missing required fields are collected and reported together
- * - Error block formatting includes all missing fields
- * - Single missing field still reports correctly
- */
-import { describe, it, expect } from 'vitest';
-import { validateCreateSpec } from '../wu-create.js';
-/** Default lane for test cases */
-const TEST_LANE = 'Framework: CLI';
-/** Default test WU ID */
-const TEST_WU_ID = 'WU-9999';
-/** Minimum valid description with required sections */
-const VALID_DESCRIPTION = 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum.';
-/** Default acceptance criteria for tests */
-const TEST_ACCEPTANCE = ['Acceptance criterion'];
-describe('wu:create required field aggregation (WU-1366)', () => {
-    describe('validateCreateSpec error aggregation', () => {
-        it('should aggregate multiple missing required fields into a single error block', () => {
-            // Missing: description, acceptance, exposure, code-paths, test-paths
-            const result = validateCreateSpec({
-                id: TEST_WU_ID,
-                lane: TEST_LANE,
-                title: 'Test WU',
-                priority: 'P2',
-                type: 'feature',
-                opts: {
-                    // All required fields missing
-                    strict: false, // Skip path existence checks
-                },
-            });
-            expect(result.valid).toBe(false);
-            // Should have multiple errors collected
-            expect(result.errors.length).toBeGreaterThan(1);
-            // Verify specific missing fields are included
-            expect(result.errors.some((e) => e.includes('--description'))).toBe(true);
-            expect(result.errors.some((e) => e.includes('--acceptance'))).toBe(true);
-            expect(result.errors.some((e) => e.includes('--exposure'))).toBe(true);
-        });
-        it('should report code-paths and test-paths as missing for non-documentation WUs', () => {
-            const result = validateCreateSpec({
-                id: TEST_WU_ID,
-                lane: TEST_LANE,
-                title: 'Test WU',
-                priority: 'P2',
-                type: 'feature',
-                opts: {
-                    description: VALID_DESCRIPTION,
-                    acceptance: TEST_ACCEPTANCE,
-                    exposure: 'backend-only',
-                    // Missing: codePaths, testPaths, specRefs
-                    strict: false,
-                },
-            });
-            expect(result.valid).toBe(false);
-            expect(result.errors.some((e) => e.includes('--code-paths'))).toBe(true);
-            expect(result.errors.some((e) => e.includes('test path'))).toBe(true);
-        });
-        it('should report spec-refs as missing for feature WUs', () => {
-            const result = validateCreateSpec({
-                id: TEST_WU_ID,
-                lane: TEST_LANE,
-                title: 'Test WU',
-                priority: 'P2',
-                type: 'feature',
-                opts: {
-                    description: VALID_DESCRIPTION,
-                    acceptance: TEST_ACCEPTANCE,
-                    exposure: 'backend-only',
-                    codePaths: ['packages/@lumenflow/cli/src/wu-create.ts'],
-                    testPathsUnit: ['packages/@lumenflow/cli/src/__tests__/wu-create.test.ts'],
-                    // Missing: specRefs (required for feature type)
-                    strict: false,
-                },
-            });
-            expect(result.valid).toBe(false);
-            expect(result.errors.some((e) => e.includes('--spec-refs'))).toBe(true);
-        });
-        it('should treat empty spec-refs array as missing for feature WUs', () => {
-            const result = validateCreateSpec({
-                id: TEST_WU_ID,
-                lane: TEST_LANE,
-                title: 'Test WU',
-                priority: 'P2',
-                type: 'feature',
-                opts: {
-                    description: VALID_DESCRIPTION,
-                    acceptance: TEST_ACCEPTANCE,
-                    exposure: 'backend-only',
-                    codePaths: ['packages/@lumenflow/cli/src/wu-create.ts'],
-                    testPathsUnit: [
-                        'packages/@lumenflow/cli/src/__tests__/wu-create-required-fields.test.ts',
-                    ],
-                    specRefs: [],
-                    strict: false,
-                },
-            });
-            expect(result.valid).toBe(false);
-            expect(result.errors.some((e) => e.includes('--spec-refs'))).toBe(true);
-        });
-        it('should return all errors at once, not fail on first error', () => {
-            const result = validateCreateSpec({
-                id: TEST_WU_ID,
-                lane: TEST_LANE,
-                title: 'Test WU',
-                priority: 'P2',
-                type: 'feature',
-                opts: {
-                    // All required fields missing to ensure multiple errors
-                    strict: false,
-                },
-            });
-            expect(result.valid).toBe(false);
-            // Verify multiple errors are present (at least 3: description, acceptance, exposure)
-            expect(result.errors.length).toBeGreaterThanOrEqual(3);
-        });
-        it('should validate documentation WUs without requiring code-paths', () => {
-            const result = validateCreateSpec({
-                id: TEST_WU_ID,
-                lane: 'Content: Documentation',
-                title: 'Test Docs WU',
-                priority: 'P2',
-                type: 'documentation',
-                opts: {
-                    description: VALID_DESCRIPTION,
-                    acceptance: TEST_ACCEPTANCE,
-                    exposure: 'documentation',
-                    testPathsManual: ['Verify docs render correctly'],
-                    strict: false,
-                },
-            });
-            // Documentation WUs should not require code-paths
-            const hasCodePathsError = result.errors.some((e) => e.includes('--code-paths'));
-            expect(hasCodePathsError).toBe(false);
-        });
-    });
-});

package/dist/__tests__/wu-create-strict.test.js

@@ -1,118 +0,0 @@
-/**
- * @file wu-create-strict.test.ts
- * Test suite for wu:create strict validation behavior (WU-1329)
- *
- * WU-1329: Make wu:create run strict validation by default
- *
- * Tests:
- * - Strict validation runs by default (validates code_paths/test_paths exist)
- * - --no-strict flag bypasses strict validation
- * - --no-strict usage is logged
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-// Import test utilities (WU-1329)
-import { validateCreateSpec } from '../wu-create.js';
-// WU-1329: Constants for test file paths
-const NON_EXISTENT_CODE_PATH = 'non-existent/file.ts';
-const NON_EXISTENT_TEST_PATH = 'non-existent/test.test.ts';
-describe('wu:create strict validation (WU-1329)', () => {
-    describe('validateCreateSpec strict mode', () => {
-        const baseOpts = {
-            id: 'WU-9999',
-            lane: 'Framework: CLI',
-            title: 'Test WU',
-            priority: 'P2',
-            type: 'feature',
-            opts: {
-                description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum length requirement.',
-                acceptance: ['Acceptance criterion 1'],
-                codePaths: ['packages/@lumenflow/cli/src/wu-create.ts'],
-                testPathsUnit: ['packages/@lumenflow/cli/src/__tests__/wu-create-strict.test.ts'],
-                exposure: 'backend-only',
-                specRefs: ['lumenflow://plans/WU-9999-plan.md'],
-            },
-        };
-        it('should pass validation with valid spec in non-strict mode', () => {
-            const result = validateCreateSpec({
-                ...baseOpts,
-                opts: {
-                    ...baseOpts.opts,
-                    strict: false,
-                },
-            });
-            expect(result.valid).toBe(true);
-            expect(result.errors).toHaveLength(0);
-        });
-        // WU-1329: This test verifies that strict validation is the default
-        it('should validate code_paths existence by default (strict=true)', () => {
-            const result = validateCreateSpec({
-                ...baseOpts,
-                opts: {
-                    ...baseOpts.opts,
-                    codePaths: [NON_EXISTENT_CODE_PATH],
-                    // strict is not explicitly set - should default to true
-                },
-            });
-            // In strict mode, non-existent paths should be caught
-            expect(result.valid).toBe(false);
-            expect(result.errors.some((e) => e.includes('code_paths') || e.includes('not found'))).toBe(true);
-        });
-        // WU-1329: This test verifies --no-strict bypasses path validation
-        it('should skip code_paths existence check when strict=false', () => {
-            const result = validateCreateSpec({
-                ...baseOpts,
-                opts: {
-                    ...baseOpts.opts,
-                    codePaths: [NON_EXISTENT_CODE_PATH],
-                    strict: false,
-                },
-            });
-            // In non-strict mode, non-existent paths should not fail validation
-            // (other schema validation may still fail)
-            expect(result.errors.every((e) => !e.includes('not found') && !e.includes('does not exist'))).toBe(true);
-        });
-        // WU-1329: This test verifies test_paths validation in strict mode
-        it('should validate test_paths existence by default (strict=true)', () => {
-            const result = validateCreateSpec({
-                ...baseOpts,
-                opts: {
-                    ...baseOpts.opts,
-                    testPathsUnit: [NON_EXISTENT_TEST_PATH],
-                },
-            });
-            // In strict mode, non-existent test paths should be caught
-            expect(result.valid).toBe(false);
-            expect(result.errors.some((e) => e.includes('test') || e.includes('not found'))).toBe(true);
-        });
-    });
-    describe('--no-strict logging', () => {
-        let consoleSpy;
-        beforeEach(() => {
-            consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        });
-        afterEach(() => {
-            consoleSpy.mockRestore();
-        });
-        // WU-1329: This test verifies --no-strict usage is logged
-        it('should log warning when --no-strict is used', () => {
-            validateCreateSpec({
-                id: 'WU-9999',
-                lane: 'Framework: CLI',
-                title: 'Test WU',
-                priority: 'P2',
-                type: 'feature',
-                opts: {
-                    description: 'Context: test context.\nProblem: test problem.\nSolution: test solution that exceeds minimum.',
-                    acceptance: ['Acceptance criterion'],
-                    codePaths: [NON_EXISTENT_CODE_PATH],
-                    testPathsUnit: [NON_EXISTENT_TEST_PATH],
-                    exposure: 'backend-only',
-                    specRefs: ['lumenflow://plans/WU-9999-plan.md'],
-                    strict: false,
-                },
-            });
-            // Should log that strict validation was bypassed
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('strict validation bypassed'));
-        });
-    });
-});