@lumenflow/cli 2.4.0 → 2.5.1

package/dist/__tests__/plan-link.test.js

@@ -0,0 +1,239 @@
+/**
+ * Tests for plan:link command (WU-1313)
+ *
+ * The plan:link command links existing plan files to WUs (via spec_refs)
+ * or initiatives (via related_plan). This replaces the initiative:plan command.
+ *
+ * TDD: These tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseYAML, stringifyYAML } from '@lumenflow/core/dist/wu-yaml.js';
+/** Test constants - avoid sonarjs/no-duplicate-string */
+const TEST_WU_DIR = 'docs/04-operations/tasks/wu';
+const TEST_INIT_DIR = 'docs/04-operations/tasks/initiatives';
+const TEST_PLANS_DIR = 'docs/04-operations/plans';
+const TEST_WU_ID = 'WU-1313';
+const TEST_INIT_ID = 'INIT-001';
+const TEST_WU_PLAN_URI = `lumenflow://plans/${TEST_WU_ID}-plan.md`;
+const TEST_INIT_PLAN_URI = `lumenflow://plans/${TEST_INIT_ID}-plan.md`;
+const TEST_LANE = 'Framework: CLI';
+const TEST_INIT_SLUG = 'test-initiative';
+const TEST_INIT_TITLE = 'Test Initiative';
+const TEST_WU_TITLE = 'Test WU';
+const TEST_STATUS_OPEN = 'open';
+const TEST_DATE = '2026-01-25';
+// Mock modules before importing
+vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
+    getGitForCwd: vi.fn(() => ({
+        branch: vi.fn().mockResolvedValue({ current: 'main' }),
+        status: vi.fn().mockResolvedValue({ isClean: () => true }),
+    })),
+}));
+vi.mock('@lumenflow/core/dist/wu-helpers.js', () => ({
+    ensureOnMain: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
+    withMicroWorktree: vi.fn(async ({ execute }) => {
+        const tempDir = join(tmpdir(), `plan-link-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        return execute({ worktreePath: tempDir });
+    }),
+}));
+describe('plan:link command', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `plan-link-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    describe('linkPlanToWU', () => {
+        it('should add spec_refs field to WU YAML', async () => {
+            const { linkPlanToWU } = await import('../plan-link.js');
+            // Setup mock WU file
+            const wuDir = join(tempDir, ...TEST_WU_DIR.split('/'));
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            const wuDoc = {
+                id: TEST_WU_ID,
+                title: TEST_WU_TITLE,
+                lane: TEST_LANE,
+                status: 'ready',
+                type: 'feature',
+            };
+            writeFileSync(wuPath, stringifyYAML(wuDoc));
+            // Link plan
+            const changed = linkPlanToWU(tempDir, TEST_WU_ID, TEST_WU_PLAN_URI);
+            expect(changed).toBe(true);
+            // Verify the file was updated
+            const updated = parseYAML(readFileSync(wuPath, 'utf-8'));
+            expect(updated.spec_refs).toContain(TEST_WU_PLAN_URI);
+        });
+        it('should append to existing spec_refs', async () => {
+            const { linkPlanToWU } = await import('../plan-link.js');
+            // Setup mock WU file with existing spec_refs
+            const wuDir = join(tempDir, ...TEST_WU_DIR.split('/'));
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            const wuDoc = {
+                id: TEST_WU_ID,
+                title: TEST_WU_TITLE,
+                lane: TEST_LANE,
+                status: 'ready',
+                type: 'feature',
+                spec_refs: ['lumenflow://plans/existing-plan.md'],
+            };
+            writeFileSync(wuPath, stringifyYAML(wuDoc));
+            // Link additional plan
+            const changed = linkPlanToWU(tempDir, TEST_WU_ID, TEST_WU_PLAN_URI);
+            expect(changed).toBe(true);
+            // Verify both refs are present
+            const updated = parseYAML(readFileSync(wuPath, 'utf-8'));
+            expect(updated.spec_refs).toContain('lumenflow://plans/existing-plan.md');
+            expect(updated.spec_refs).toContain(TEST_WU_PLAN_URI);
+        });
+        it('should be idempotent if plan already linked', async () => {
+            const { linkPlanToWU } = await import('../plan-link.js');
+            // Setup mock WU file with plan already linked
+            const wuDir = join(tempDir, ...TEST_WU_DIR.split('/'));
+            mkdirSync(wuDir, { recursive: true });
+            const wuPath = join(wuDir, `${TEST_WU_ID}.yaml`);
+            const wuDoc = {
+                id: TEST_WU_ID,
+                title: TEST_WU_TITLE,
+                lane: TEST_LANE,
+                status: 'ready',
+                type: 'feature',
+                spec_refs: [TEST_WU_PLAN_URI],
+            };
+            writeFileSync(wuPath, stringifyYAML(wuDoc));
+            // Link same plan again
+            const changed = linkPlanToWU(tempDir, TEST_WU_ID, TEST_WU_PLAN_URI);
+            expect(changed).toBe(false);
+        });
+        it('should throw if WU not found', async () => {
+            const { linkPlanToWU } = await import('../plan-link.js');
+            expect(() => linkPlanToWU(tempDir, 'WU-9999', 'lumenflow://plans/plan.md')).toThrow();
+        });
+    });
+    describe('linkPlanToInitiative', () => {
+        it('should add related_plan field to initiative YAML', async () => {
+            const { linkPlanToInitiative } = await import('../plan-link.js');
+            // Setup mock initiative file
+            const initDir = join(tempDir, ...TEST_INIT_DIR.split('/'));
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, `${TEST_INIT_ID}.yaml`);
+            const initDoc = {
+                id: TEST_INIT_ID,
+                slug: TEST_INIT_SLUG,
+                title: TEST_INIT_TITLE,
+                status: TEST_STATUS_OPEN,
+                created: TEST_DATE,
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Link plan
+            const changed = linkPlanToInitiative(tempDir, TEST_INIT_ID, TEST_INIT_PLAN_URI);
+            expect(changed).toBe(true);
+            // Verify the file was updated
+            const updated = parseYAML(readFileSync(initPath, 'utf-8'));
+            expect(updated.related_plan).toBe(TEST_INIT_PLAN_URI);
+        });
+        it('should be idempotent if plan already linked', async () => {
+            const { linkPlanToInitiative } = await import('../plan-link.js');
+            // Setup mock initiative file with plan already linked
+            const initDir = join(tempDir, ...TEST_INIT_DIR.split('/'));
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, `${TEST_INIT_ID}.yaml`);
+            const initDoc = {
+                id: TEST_INIT_ID,
+                slug: TEST_INIT_SLUG,
+                title: TEST_INIT_TITLE,
+                status: TEST_STATUS_OPEN,
+                created: TEST_DATE,
+                related_plan: TEST_INIT_PLAN_URI,
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Link same plan again
+            const changed = linkPlanToInitiative(tempDir, TEST_INIT_ID, TEST_INIT_PLAN_URI);
+            expect(changed).toBe(false);
+        });
+        it('should warn but proceed if replacing existing plan', async () => {
+            const { linkPlanToInitiative } = await import('../plan-link.js');
+            const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            // Setup mock initiative with different plan
+            const initDir = join(tempDir, ...TEST_INIT_DIR.split('/'));
+            mkdirSync(initDir, { recursive: true });
+            const initPath = join(initDir, `${TEST_INIT_ID}.yaml`);
+            const initDoc = {
+                id: TEST_INIT_ID,
+                slug: TEST_INIT_SLUG,
+                title: TEST_INIT_TITLE,
+                status: TEST_STATUS_OPEN,
+                created: TEST_DATE,
+                related_plan: 'lumenflow://plans/old-plan.md',
+            };
+            writeFileSync(initPath, stringifyYAML(initDoc));
+            // Link new plan
+            const changed = linkPlanToInitiative(tempDir, TEST_INIT_ID, 'lumenflow://plans/new-plan.md');
+            expect(changed).toBe(true);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Replacing existing'));
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('validatePlanExists', () => {
+        it('should pass for existing plan file', async () => {
+            const { validatePlanExists } = await import('../plan-link.js');
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, '# Plan');
+            expect(() => validatePlanExists(tempDir, TEST_WU_PLAN_URI)).not.toThrow();
+        });
+        it('should throw for non-existent plan file', async () => {
+            const { validatePlanExists } = await import('../plan-link.js');
+            expect(() => validatePlanExists(tempDir, 'lumenflow://plans/nonexistent.md')).toThrow();
+        });
+    });
+    describe('resolveTargetType', () => {
+        it('should detect WU IDs', async () => {
+            const { resolveTargetType } = await import('../plan-link.js');
+            expect(resolveTargetType(TEST_WU_ID)).toBe('wu');
+            expect(resolveTargetType('WU-001')).toBe('wu');
+            expect(resolveTargetType('WU-99999')).toBe('wu');
+        });
+        it('should detect initiative IDs', async () => {
+            const { resolveTargetType } = await import('../plan-link.js');
+            expect(resolveTargetType(TEST_INIT_ID)).toBe('initiative');
+            expect(resolveTargetType('INIT-TOOLING')).toBe('initiative');
+        });
+        it('should throw for invalid IDs', async () => {
+            const { resolveTargetType } = await import('../plan-link.js');
+            expect(() => resolveTargetType('invalid')).toThrow();
+            expect(() => resolveTargetType('')).toThrow();
+        });
+    });
+});
+describe('plan:link CLI exports', () => {
+    it('should export main function for CLI entry', async () => {
+        const planLink = await import('../plan-link.js');
+        expect(typeof planLink.main).toBe('function');
+    });
+    it('should export all required functions', async () => {
+        const planLink = await import('../plan-link.js');
+        expect(typeof planLink.linkPlanToWU).toBe('function');
+        expect(typeof planLink.linkPlanToInitiative).toBe('function');
+        expect(typeof planLink.validatePlanExists).toBe('function');
+        expect(typeof planLink.resolveTargetType).toBe('function');
+        expect(typeof planLink.LOG_PREFIX).toBe('string');
+    });
+});

package/dist/__tests__/plan-promote.test.js

@@ -0,0 +1,181 @@
+/**
+ * Tests for plan:promote command (WU-1313)
+ *
+ * The plan:promote command promotes a plan from draft to approved status,
+ * or creates WUs from plan sections.
+ *
+ * TDD: These tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+/** Test constants - avoid sonarjs/no-duplicate-string */
+const TEST_PLANS_DIR = 'docs/04-operations/plans';
+const TEST_WU_ID = 'WU-1313';
+// Mock modules before importing
+vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
+    getGitForCwd: vi.fn(() => ({
+        branch: vi.fn().mockResolvedValue({ current: 'main' }),
+        status: vi.fn().mockResolvedValue({ isClean: () => true }),
+    })),
+}));
+vi.mock('@lumenflow/core/dist/wu-helpers.js', () => ({
+    ensureOnMain: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
+    withMicroWorktree: vi.fn(async ({ execute }) => {
+        const tempDir = join(tmpdir(), `plan-promote-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        return execute({ worktreePath: tempDir });
+    }),
+}));
+describe('plan:promote command', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `plan-promote-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    describe('promotePlan', () => {
+        it('should add approved status marker to plan', async () => {
+            const { promotePlan } = await import('../plan-promote.js');
+            // Setup plan file
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, `# WU-1313 Plan
+
+Created: 2026-02-01
+
+## Goal
+
+Implement plan tooling.
+`);
+            // Promote plan
+            const changed = promotePlan(planPath);
+            expect(changed).toBe(true);
+            const content = readFileSync(planPath, 'utf-8');
+            expect(content).toContain('Status: approved');
+            expect(content).toContain('Approved:');
+        });
+        it('should return false if plan already approved', async () => {
+            const { promotePlan } = await import('../plan-promote.js');
+            // Setup plan file with approved status
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, `# WU-1313 Plan
+
+Created: 2026-02-01
+Status: approved
+Approved: 2026-02-01
+
+## Goal
+
+Implement plan tooling.
+`);
+            // Try to promote again
+            const changed = promotePlan(planPath);
+            expect(changed).toBe(false);
+        });
+        it('should throw if plan file not found', async () => {
+            const { promotePlan } = await import('../plan-promote.js');
+            const planPath = join(tempDir, 'nonexistent.md');
+            expect(() => promotePlan(planPath)).toThrow();
+        });
+    });
+    describe('validatePlanComplete', () => {
+        it('should pass for complete plan', async () => {
+            const { validatePlanComplete } = await import('../plan-promote.js');
+            // Setup complete plan file
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, `# WU-1313 Plan
+
+Created: 2026-02-01
+
+## Goal
+
+Clear goal statement here.
+
+## Scope
+
+- In scope: A
+- Out of scope: B
+
+## Approach
+
+Step 1: Do X
+Step 2: Do Y
+`);
+            const result = validatePlanComplete(planPath);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should fail for plan with empty sections', async () => {
+            const { validatePlanComplete } = await import('../plan-promote.js');
+            // Setup incomplete plan file
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, `# WU-1313 Plan
+
+Created: 2026-02-01
+
+## Goal
+
+## Scope
+
+## Approach
+`);
+            const result = validatePlanComplete(planPath);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+            expect(result.errors.some((e) => e.includes('Goal'))).toBe(true);
+        });
+    });
+    describe('getPlanPath', () => {
+        it('should resolve plan path from ID', async () => {
+            const { getPlanPath } = await import('../plan-promote.js');
+            // Setup plan file
+            const plansDir = join(tempDir, ...TEST_PLANS_DIR.split('/'));
+            mkdirSync(plansDir, { recursive: true });
+            const planPath = join(plansDir, `${TEST_WU_ID}-plan.md`);
+            writeFileSync(planPath, '# Plan');
+            process.chdir(tempDir);
+            const resolved = getPlanPath('WU-1313');
+            expect(resolved).toContain(`${TEST_WU_ID}-plan.md`);
+        });
+    });
+    describe('getCommitMessage', () => {
+        it('should generate correct commit message', async () => {
+            const { getCommitMessage } = await import('../plan-promote.js');
+            expect(getCommitMessage('WU-1313')).toBe('docs: promote wu-1313 plan to approved');
+            expect(getCommitMessage('INIT-001')).toBe('docs: promote init-001 plan to approved');
+        });
+    });
+});
+describe('plan:promote CLI exports', () => {
+    it('should export main function for CLI entry', async () => {
+        const planPromote = await import('../plan-promote.js');
+        expect(typeof planPromote.main).toBe('function');
+    });
+    it('should export all required functions', async () => {
+        const planPromote = await import('../plan-promote.js');
+        expect(typeof planPromote.promotePlan).toBe('function');
+        expect(typeof planPromote.validatePlanComplete).toBe('function');
+        expect(typeof planPromote.getPlanPath).toBe('function');
+        expect(typeof planPromote.getCommitMessage).toBe('function');
+        expect(typeof planPromote.LOG_PREFIX).toBe('string');
+    });
+});

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

@@ -0,0 +1,219 @@
+/**
+ * @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);
+        });
+    });
+});