@lumenflow/cli 2.7.0 → 2.8.0

package/dist/__tests__/memory-integration.test.js

@@ -0,0 +1,333 @@
+/**
+ * Memory Layer Integration Tests (WU-1363)
+ *
+ * Integration tests for memory layer operations:
+ * - AC3: mem:checkpoint, mem:signal, mem:inbox
+ *
+ * These tests validate the memory layer's ability to:
+ * - Create checkpoints for context preservation
+ * - Send and receive signals for agent coordination
+ * - Filter and query signals from inbox
+ *
+ * TDD: Tests written BEFORE implementation verification.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createCheckpoint, createSignal, loadSignals, markSignalsAsRead } from '@lumenflow/memory';
+// Test constants
+const TEST_WU_ID = 'WU-9910';
+const TEST_LANE = 'Framework: CLI';
+// Session ID must be a valid UUID
+const TEST_SESSION_ID = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890';
+/**
+ * Helper to create minimal memory directory structure
+ */
+function createMemoryProject(baseDir) {
+    const dirs = ['.lumenflow/memory', '.lumenflow/state'];
+    for (const dir of dirs) {
+        mkdirSync(join(baseDir, dir), { recursive: true });
+    }
+    // Create minimal config
+    const configContent = `
+version: 1
+memory:
+  enabled: true
+  decay:
+    enabled: false
+`;
+    writeFileSync(join(baseDir, '.lumenflow.config.yaml'), configContent);
+}
+describe('Memory Layer Integration Tests (WU-1363)', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `memory-integration-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+        createMemoryProject(tempDir);
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    });
+    describe('AC3: Integration tests for memory checkpoint, signal, inbox', () => {
+        describe('mem:checkpoint functionality', () => {
+            it('should create a checkpoint node with correct structure', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                const note = 'Checkpoint before gates';
+                // Act
+                const result = await createCheckpoint(tempDir, {
+                    note,
+                    wuId: TEST_WU_ID,
+                    sessionId: TEST_SESSION_ID,
+                });
+                // Assert
+                expect(result.success).toBe(true);
+                expect(result.checkpoint).toBeDefined();
+                expect(result.checkpoint.id).toMatch(/^mem-/);
+                expect(result.checkpoint.type).toBe('checkpoint');
+                expect(result.checkpoint.content).toContain(note);
+                expect(result.checkpoint.wu_id).toBe(TEST_WU_ID);
+                expect(result.checkpoint.session_id).toBe(TEST_SESSION_ID);
+            });
+            it('should include progress and nextSteps in metadata', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                const progress = 'Completed AC1 and AC2';
+                const nextSteps = 'Run gates and complete wu:done';
+                // Act
+                const result = await createCheckpoint(tempDir, {
+                    note: 'Progress checkpoint',
+                    wuId: TEST_WU_ID,
+                    progress,
+                    nextSteps,
+                });
+                // Assert
+                expect(result.checkpoint.metadata).toBeDefined();
+                expect(result.checkpoint.metadata?.progress).toBe(progress);
+                expect(result.checkpoint.metadata?.nextSteps).toBe(nextSteps);
+            });
+            it('should persist checkpoint to memory store', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                // Act
+                await createCheckpoint(tempDir, {
+                    note: 'Persisted checkpoint',
+                    wuId: TEST_WU_ID,
+                });
+                // Assert - Check memory file exists (memory store uses memory.jsonl)
+                const memoryFile = join(tempDir, '.lumenflow/memory/memory.jsonl');
+                expect(existsSync(memoryFile)).toBe(true);
+                const content = readFileSync(memoryFile, 'utf-8');
+                expect(content).toContain('Persisted checkpoint');
+            });
+            it('should validate note is required', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                // Act & Assert
+                await expect(createCheckpoint(tempDir, {
+                    note: '',
+                    wuId: TEST_WU_ID,
+                })).rejects.toThrow(/empty/i);
+            });
+            it('should validate WU ID format if provided', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                // Act & Assert
+                await expect(createCheckpoint(tempDir, {
+                    note: 'Test checkpoint',
+                    wuId: 'INVALID-ID',
+                })).rejects.toThrow(/WU/i);
+            });
+        });
+        describe('mem:signal functionality', () => {
+            it('should create a signal with correct structure', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                const message = 'Starting implementation';
+                // Act
+                const result = await createSignal(tempDir, {
+                    message,
+                    wuId: TEST_WU_ID,
+                    lane: TEST_LANE,
+                });
+                // Assert
+                expect(result.success).toBe(true);
+                expect(result.signal).toBeDefined();
+                expect(result.signal.id).toMatch(/^sig-/);
+                expect(result.signal.message).toBe(message);
+                expect(result.signal.wu_id).toBe(TEST_WU_ID);
+                expect(result.signal.lane).toBe(TEST_LANE);
+                expect(result.signal.read).toBe(false);
+            });
+            it('should persist signal to signals.jsonl', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                // Act
+                await createSignal(tempDir, {
+                    message: 'Persisted signal',
+                    wuId: TEST_WU_ID,
+                });
+                // Assert
+                const signalsFile = join(tempDir, '.lumenflow/memory/signals.jsonl');
+                expect(existsSync(signalsFile)).toBe(true);
+                const content = readFileSync(signalsFile, 'utf-8');
+                expect(content).toContain('Persisted signal');
+            });
+            it('should validate message is required', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                // Act & Assert
+                await expect(createSignal(tempDir, {
+                    message: '',
+                    wuId: TEST_WU_ID,
+                })).rejects.toThrow(/required/i);
+            });
+            it('should validate WU ID format if provided', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                // Act & Assert
+                await expect(createSignal(tempDir, {
+                    message: 'Test signal',
+                    wuId: 'INVALID-123',
+                })).rejects.toThrow(/WU/i);
+            });
+        });
+        describe('mem:inbox functionality', () => {
+            it('should load all signals', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                await createSignal(tempDir, { message: 'Signal 1', wuId: TEST_WU_ID });
+                await createSignal(tempDir, { message: 'Signal 2', wuId: TEST_WU_ID });
+                await createSignal(tempDir, { message: 'Signal 3', wuId: 'WU-9999' });
+                // Act
+                const signals = await loadSignals(tempDir);
+                // Assert
+                expect(signals).toHaveLength(3);
+            });
+            it('should filter signals by WU ID', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                await createSignal(tempDir, { message: 'Signal 1', wuId: TEST_WU_ID });
+                await createSignal(tempDir, { message: 'Signal 2', wuId: TEST_WU_ID });
+                await createSignal(tempDir, { message: 'Other WU', wuId: 'WU-9999' });
+                // Act
+                const signals = await loadSignals(tempDir, { wuId: TEST_WU_ID });
+                // Assert
+                expect(signals).toHaveLength(2);
+                signals.forEach((sig) => expect(sig.wu_id).toBe(TEST_WU_ID));
+            });
+            it('should filter signals by lane', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                await createSignal(tempDir, { message: 'CLI signal', lane: TEST_LANE });
+                await createSignal(tempDir, { message: 'Other lane', lane: 'Framework: Core' });
+                // Act
+                const signals = await loadSignals(tempDir, { lane: TEST_LANE });
+                // Assert
+                expect(signals).toHaveLength(1);
+                expect(signals[0].lane).toBe(TEST_LANE);
+            });
+            it('should filter unread signals only', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                const result1 = await createSignal(tempDir, { message: 'Unread signal' });
+                await createSignal(tempDir, { message: 'Another unread' });
+                // Mark first as read
+                await markSignalsAsRead(tempDir, [result1.signal.id]);
+                // Act
+                const signals = await loadSignals(tempDir, { unreadOnly: true });
+                // Assert
+                expect(signals).toHaveLength(1);
+                expect(signals[0].message).toBe('Another unread');
+            });
+            it('should filter signals since a specific time', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                const beforeTime = new Date();
+                // Wait a bit to ensure time difference
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                await createSignal(tempDir, { message: 'Recent signal' });
+                // Act
+                const signals = await loadSignals(tempDir, { since: beforeTime });
+                // Assert
+                expect(signals).toHaveLength(1);
+                expect(signals[0].message).toBe('Recent signal');
+            });
+            it('should return empty array when no signals exist', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                // Act
+                const signals = await loadSignals(tempDir);
+                // Assert
+                expect(signals).toHaveLength(0);
+            });
+        });
+        describe('mark signals as read', () => {
+            it('should mark signals as read', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                const result1 = await createSignal(tempDir, { message: 'Signal 1' });
+                const result2 = await createSignal(tempDir, { message: 'Signal 2' });
+                // Act
+                const markResult = await markSignalsAsRead(tempDir, [result1.signal.id, result2.signal.id]);
+                // Assert
+                expect(markResult.markedCount).toBe(2);
+                // Verify signals are now read
+                const allSignals = await loadSignals(tempDir);
+                expect(allSignals.every((sig) => sig.read)).toBe(true);
+            });
+            it('should not count already-read signals', async () => {
+                // Arrange
+                process.chdir(tempDir);
+                const result = await createSignal(tempDir, { message: 'Signal 1' });
+                // Mark as read first time
+                await markSignalsAsRead(tempDir, [result.signal.id]);
+                // Act - Try to mark again
+                const secondMarkResult = await markSignalsAsRead(tempDir, [result.signal.id]);
+                // Assert
+                expect(secondMarkResult.markedCount).toBe(0);
+            });
+        });
+        describe('complete memory workflow', () => {
+            it('should support full checkpoint and signal workflow', async () => {
+                // This test validates the complete memory workflow:
+                // 1. Create initial checkpoint
+                // 2. Send progress signals
+                // 3. Check inbox for signals
+                // 4. Mark signals as read
+                // 5. Create final checkpoint
+                // Arrange
+                process.chdir(tempDir);
+                // Step 1: Initial checkpoint
+                const initialCheckpoint = await createCheckpoint(tempDir, {
+                    note: 'Starting work on WU',
+                    wuId: TEST_WU_ID,
+                    sessionId: TEST_SESSION_ID,
+                });
+                expect(initialCheckpoint.success).toBe(true);
+                // Step 2: Send progress signals
+                await createSignal(tempDir, {
+                    message: 'AC1 complete',
+                    wuId: TEST_WU_ID,
+                    lane: TEST_LANE,
+                });
+                await createSignal(tempDir, {
+                    message: 'AC2 in progress',
+                    wuId: TEST_WU_ID,
+                    lane: TEST_LANE,
+                });
+                // Step 3: Check inbox
+                const inbox = await loadSignals(tempDir, { wuId: TEST_WU_ID, unreadOnly: true });
+                expect(inbox).toHaveLength(2);
+                // Step 4: Mark as read
+                const signalIds = inbox.map((sig) => sig.id);
+                await markSignalsAsRead(tempDir, signalIds);
+                const unreadAfter = await loadSignals(tempDir, { unreadOnly: true });
+                expect(unreadAfter).toHaveLength(0);
+                // Step 5: Final checkpoint
+                const finalCheckpoint = await createCheckpoint(tempDir, {
+                    note: 'Work complete, ready for wu:done',
+                    wuId: TEST_WU_ID,
+                    sessionId: TEST_SESSION_ID,
+                    progress: 'All acceptance criteria met',
+                    nextSteps: 'Run pnpm wu:done --id ' + TEST_WU_ID,
+                });
+                expect(finalCheckpoint.success).toBe(true);
+                // Verify memory store has all data (memory store uses memory.jsonl)
+                const memoryFile = join(tempDir, '.lumenflow/memory/memory.jsonl');
+                expect(existsSync(memoryFile)).toBe(true);
+            });
+        });
+    });
+});

package/dist/__tests__/release.test.js

@@ -107,7 +107,7 @@ describe('release command', () => {
             await updatePackageVersions([packagePath], '1.2.3');
             // Read back raw content and check formatting
             const content = await import('node:fs/promises').then((fs) => fs.readFile(packagePath, 'utf-8'));
-            expect(content).toMatch(/{\n  "name"/); // Preserve 2-space indent
+            expect(content).toMatch(/{\n {2}"name"/); // Preserve 2-space indent
         });
     });
     describe('buildCommitMessage', () => {

package/dist/__tests__/safe-git.test.js

@@ -1,4 +1,3 @@
-/* eslint-disable sonarjs/no-os-command-from-path -- Test file needs to execute git commands */
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { execFileSync } from 'node:child_process';
 import path from 'node:path';

package/dist/__tests__/state-doctor.test.js

@@ -229,6 +229,60 @@ describe('state-doctor CLI (WU-1230)', () => {
             expect(mockWithMicroWorktree).toHaveBeenCalled();
         });
     });
+    // WU-1362: Retry logic for push failures
+    describe('WU-1362: retry logic for push failures', () => {
+        it('should retry on push failure with exponential backoff', async () => {
+            setupTestState(testDir, {
+                wus: [],
+                events: [{ wuId: 'WU-999', type: 'claimed', timestamp: new Date().toISOString() }],
+            });
+            let callCount = 0;
+            const mockWithMicroWorktree = vi.mocked(withMicroWorktree);
+            mockWithMicroWorktree.mockImplementation(async (options) => {
+                callCount++;
+                // Simulate the micro-worktree handling retries internally
+                const result = await options.execute({
+                    worktreePath: testDir,
+                    gitWorktree: {
+                        add: vi.fn(),
+                        addWithDeletions: vi.fn(),
+                        commit: vi.fn(),
+                        push: vi.fn(),
+                    },
+                });
+                return { ...result, ref: 'main' };
+            });
+            const { createStateDoctorFixDeps } = await import('../state-doctor-fix.js');
+            const deps = createStateDoctorFixDeps(testDir);
+            // removeEvent should succeed (micro-worktree handles retry internally)
+            await deps.removeEvent('WU-999');
+            expect(callCount).toBe(1);
+        });
+        it('should use maxRetries configuration from config', async () => {
+            setupTestState(testDir, {
+                wus: [],
+                events: [{ wuId: 'WU-999', type: 'claimed', timestamp: new Date().toISOString() }],
+            });
+            const mockWithMicroWorktree = vi.mocked(withMicroWorktree);
+            mockWithMicroWorktree.mockImplementation(async (options) => {
+                // Verify retries is set (micro-worktree handles retry logic)
+                const result = await options.execute({
+                    worktreePath: testDir,
+                    gitWorktree: {
+                        add: vi.fn(),
+                        addWithDeletions: vi.fn(),
+                        commit: vi.fn(),
+                        push: vi.fn(),
+                    },
+                });
+                return { ...result, ref: 'main' };
+            });
+            const { createStateDoctorFixDeps } = await import('../state-doctor-fix.js');
+            const deps = createStateDoctorFixDeps(testDir);
+            await deps.removeEvent('WU-999');
+            expect(mockWithMicroWorktree).toHaveBeenCalled();
+        });
+    });
 });
 function setupTestState(baseDir, state) {
     // Create directories

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

@@ -0,0 +1,255 @@
+/**
+ * Tests for sync:templates command (WU-1368)
+ *
+ * Two bugs being fixed:
+ * 1. --check-drift flag syncs files instead of only checking - should be read-only
+ * 2. sync:templates writes directly to main checkout - should use micro-worktree isolation
+ *
+ * TDD: These tests are written BEFORE the implementation changes.
+ */
+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';
+// Mock modules before importing
+const mockWithMicroWorktree = vi.fn();
+vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
+    withMicroWorktree: mockWithMicroWorktree,
+}));
+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),
+}));
+describe('sync:templates --check-drift', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `sync-templates-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+        process.chdir(tempDir);
+        // Set up minimal project structure
+        const templatesDir = join(tempDir, 'packages', '@lumenflow', 'cli', 'templates', 'core');
+        mkdirSync(templatesDir, { recursive: true });
+        // Create LUMENFLOW.md source
+        writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow\n\nLast updated: 2025-01-01\n');
+        // Create matching template (no drift)
+        writeFileSync(join(templatesDir, 'LUMENFLOW.md.template'), '# LumenFlow\n\nLast updated: {{DATE}}\n');
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    describe('checkTemplateDrift', () => {
+        it('should NOT write any files when checking drift', async () => {
+            const { checkTemplateDrift } = await import('../sync-templates.js');
+            // Get initial file mtimes
+            const sourceFile = join(tempDir, 'LUMENFLOW.md');
+            const templateFile = join(tempDir, 'packages', '@lumenflow', 'cli', 'templates', 'core', 'LUMENFLOW.md.template');
+            const sourceMtimeBefore = existsSync(sourceFile) ? readFileSync(sourceFile, 'utf-8') : null;
+            const templateMtimeBefore = existsSync(templateFile)
+                ? readFileSync(templateFile, 'utf-8')
+                : null;
+            // Run check-drift
+            await checkTemplateDrift(tempDir);
+            // Verify files were NOT modified
+            const sourceMtimeAfter = existsSync(sourceFile) ? readFileSync(sourceFile, 'utf-8') : null;
+            const templateMtimeAfter = existsSync(templateFile)
+                ? readFileSync(templateFile, 'utf-8')
+                : null;
+            expect(sourceMtimeAfter).toBe(sourceMtimeBefore);
+            expect(templateMtimeAfter).toBe(templateMtimeBefore);
+        });
+        it('should return hasDrift=false when templates match source', async () => {
+            const { checkTemplateDrift } = await import('../sync-templates.js');
+            const result = await checkTemplateDrift(tempDir);
+            expect(result.hasDrift).toBe(false);
+            expect(result.driftingFiles).toHaveLength(0);
+        });
+        it('should return hasDrift=true when templates differ from source', async () => {
+            const { checkTemplateDrift } = await import('../sync-templates.js');
+            // Create source with different content
+            writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow Updated\n\nNew content here\n');
+            const result = await checkTemplateDrift(tempDir);
+            expect(result.hasDrift).toBe(true);
+            expect(result.driftingFiles.length).toBeGreaterThan(0);
+        });
+        it('should return hasDrift=true when template file is missing', async () => {
+            const { checkTemplateDrift } = await import('../sync-templates.js');
+            // Remove template file
+            const templateFile = join(tempDir, 'packages', '@lumenflow', 'cli', 'templates', 'core', 'LUMENFLOW.md.template');
+            rmSync(templateFile);
+            const result = await checkTemplateDrift(tempDir);
+            expect(result.hasDrift).toBe(true);
+            expect(result.driftingFiles).toContain('packages/@lumenflow/cli/templates/core/LUMENFLOW.md.template');
+        });
+        it('should NOT call withMicroWorktree during drift check', async () => {
+            const { checkTemplateDrift } = await import('../sync-templates.js');
+            await checkTemplateDrift(tempDir);
+            // withMicroWorktree should NOT be called for read-only drift check
+            expect(mockWithMicroWorktree).not.toHaveBeenCalled();
+        });
+    });
+    describe('exit codes', () => {
+        it('should exit 1 when drift is detected', async () => {
+            const { checkTemplateDrift } = await import('../sync-templates.js');
+            // Create drifting source
+            writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow Updated\n\nDifferent content\n');
+            const result = await checkTemplateDrift(tempDir);
+            // The result should indicate drift - CLI will use this to set exit code
+            expect(result.hasDrift).toBe(true);
+        });
+        it('should exit 0 when no drift detected', async () => {
+            const { checkTemplateDrift } = await import('../sync-templates.js');
+            const result = await checkTemplateDrift(tempDir);
+            // The result should indicate no drift - CLI will use this to set exit code
+            expect(result.hasDrift).toBe(false);
+        });
+    });
+});
+describe('sync:templates (sync mode)', () => {
+    let tempDir;
+    let originalCwd;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `sync-templates-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        originalCwd = process.cwd();
+        process.chdir(tempDir);
+        // Reset mock
+        mockWithMicroWorktree.mockReset();
+        mockWithMicroWorktree.mockImplementation(async ({ execute }) => {
+            // Simulate micro-worktree by creating temp dir and calling execute
+            const wtPath = join(tmpdir(), `micro-wt-${Date.now()}`);
+            mkdirSync(wtPath, { recursive: true });
+            const result = await execute({
+                worktreePath: wtPath,
+                gitWorktree: {
+                    add: vi.fn().mockResolvedValue(undefined),
+                    commit: vi.fn().mockResolvedValue(undefined),
+                },
+            });
+            return { ...result, ref: 'main' };
+        });
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        vi.clearAllMocks();
+    });
+    describe('micro-worktree isolation', () => {
+        it('should use withMicroWorktree for sync operations', async () => {
+            const { syncTemplatesWithWorktree } = await import('../sync-templates.js');
+            // Set up source files
+            writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow\n\nContent\n');
+            mkdirSync(join(tempDir, '.lumenflow'), { recursive: true });
+            writeFileSync(join(tempDir, '.lumenflow', 'constraints.md'), '# Constraints\n');
+            await syncTemplatesWithWorktree(tempDir);
+            // Verify withMicroWorktree was called
+            expect(mockWithMicroWorktree).toHaveBeenCalledTimes(1);
+            expect(mockWithMicroWorktree).toHaveBeenCalledWith(expect.objectContaining({
+                operation: 'sync-templates',
+                id: expect.any(String),
+                execute: expect.any(Function),
+            }));
+        });
+        it('should write files to micro-worktree path, not main checkout', async () => {
+            const { syncTemplatesWithWorktree } = await import('../sync-templates.js');
+            // Set up source files
+            writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow\n\nContent\n');
+            let capturedWorktreePath = null;
+            mockWithMicroWorktree.mockImplementation(async ({ execute }) => {
+                const wtPath = join(tmpdir(), `micro-wt-verify-${Date.now()}`);
+                mkdirSync(wtPath, { recursive: true });
+                capturedWorktreePath = wtPath;
+                // Create templates structure in worktree
+                const templatesDir = join(wtPath, 'packages', '@lumenflow', 'cli', 'templates', 'core');
+                mkdirSync(templatesDir, { recursive: true });
+                const result = await execute({
+                    worktreePath: wtPath,
+                    gitWorktree: {
+                        add: vi.fn().mockResolvedValue(undefined),
+                        commit: vi.fn().mockResolvedValue(undefined),
+                    },
+                });
+                return { ...result, ref: 'main' };
+            });
+            await syncTemplatesWithWorktree(tempDir);
+            // Verify worktree path was used (not main checkout)
+            expect(capturedWorktreePath).not.toBeNull();
+            expect(capturedWorktreePath).not.toBe(tempDir);
+            expect(capturedWorktreePath.startsWith(tmpdir())).toBe(true);
+        });
+        it('should return list of synced files for commit', async () => {
+            const { syncTemplatesWithWorktree } = await import('../sync-templates.js');
+            // Set up source files
+            writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow\n\nContent\n');
+            let capturedResult = null;
+            mockWithMicroWorktree.mockImplementation(async ({ execute }) => {
+                const wtPath = join(tmpdir(), `micro-wt-files-${Date.now()}`);
+                mkdirSync(wtPath, { recursive: true });
+                // Create templates structure
+                const templatesDir = join(wtPath, 'packages', '@lumenflow', 'cli', 'templates', 'core');
+                mkdirSync(templatesDir, { recursive: true });
+                const result = await execute({
+                    worktreePath: wtPath,
+                    gitWorktree: {
+                        add: vi.fn().mockResolvedValue(undefined),
+                        commit: vi.fn().mockResolvedValue(undefined),
+                    },
+                });
+                capturedResult = result;
+                return { ...result, ref: 'main' };
+            });
+            await syncTemplatesWithWorktree(tempDir);
+            expect(capturedResult).not.toBeNull();
+            expect(capturedResult.commitMessage).toContain('sync:templates');
+            expect(Array.isArray(capturedResult.files)).toBe(true);
+        });
+    });
+    describe('atomic commit', () => {
+        it('should create atomic commit via micro-worktree pattern', async () => {
+            const { syncTemplatesWithWorktree } = await import('../sync-templates.js');
+            // Set up source files
+            writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow\n\nContent\n');
+            await syncTemplatesWithWorktree(tempDir);
+            // Verify withMicroWorktree was called (atomic commit pattern)
+            expect(mockWithMicroWorktree).toHaveBeenCalled();
+            // Verify the execute function returns proper commit info
+            const callArgs = mockWithMicroWorktree.mock.calls[0][0];
+            expect(callArgs.operation).toBe('sync-templates');
+        });
+        it('should include timestamp in operation id for uniqueness', async () => {
+            const { syncTemplatesWithWorktree } = await import('../sync-templates.js');
+            writeFileSync(join(tempDir, 'LUMENFLOW.md'), '# LumenFlow\n');
+            await syncTemplatesWithWorktree(tempDir);
+            const callArgs = mockWithMicroWorktree.mock.calls[0][0];
+            // ID should be timestamp-based or unique identifier
+            expect(typeof callArgs.id).toBe('string');
+            expect(callArgs.id.length).toBeGreaterThan(0);
+        });
+    });
+});
+describe('sync:templates exports', () => {
+    it('should export checkTemplateDrift function', async () => {
+        const syncTemplates = await import('../sync-templates.js');
+        expect(typeof syncTemplates.checkTemplateDrift).toBe('function');
+    });
+    it('should export syncTemplatesWithWorktree function', async () => {
+        const syncTemplates = await import('../sync-templates.js');
+        expect(typeof syncTemplates.syncTemplatesWithWorktree).toBe('function');
+    });
+    it('should export main function for CLI entry', async () => {
+        const syncTemplates = await import('../sync-templates.js');
+        expect(typeof syncTemplates.main).toBe('function');
+    });
+});