@lumenflow/cli 2.20.1 → 2.21.1

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

@@ -1,328 +0,0 @@
-/**
- * State Doctor CLI Tests (WU-1230)
- *
- * Tests for state:doctor --fix functionality:
- * - Micro-worktree isolation for all tracked file changes
- * - Removal of stale WU references from backlog.md and status.md
- * - Changes pushed via merge, not direct file modification
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { join } from 'node:path';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-/**
- * Mocked modules
- */
-vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
-    withMicroWorktree: vi.fn(),
-}));
-vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
-    getGitForCwd: vi.fn(() => ({
-        fetch: vi.fn(),
-        merge: vi.fn(),
-        push: vi.fn(),
-    })),
-    createGitForPath: vi.fn(() => ({
-        add: vi.fn(),
-        commit: vi.fn(),
-        push: vi.fn(),
-    })),
-}));
-/**
- * Import after mocks are set up
- */
-import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
-/**
- * Constants for test paths
- */
-const LUMENFLOW_DIR = '.lumenflow';
-const STATE_DIR = 'state';
-const STAMPS_DIR = 'stamps';
-const MEMORY_DIR = 'memory';
-const DOCS_TASKS_DIR = 'docs/04-operations/tasks';
-const BACKLOG_PATH = `${DOCS_TASKS_DIR}/backlog.md`;
-const STATUS_PATH = `${DOCS_TASKS_DIR}/status.md`;
-/**
- * Test directory path
- */
-let testDir;
-describe('state-doctor CLI (WU-1230)', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Create temp directory for each test
-        testDir = mkdtempSync(join(tmpdir(), 'state-doctor-test-'));
-    });
-    afterEach(() => {
-        // Cleanup temp directory
-        try {
-            rmSync(testDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    describe('micro-worktree isolation', () => {
-        it('should use micro-worktree when --fix modifies tracked files', async () => {
-            // Setup: Create test state with broken events
-            setupTestState(testDir, {
-                wus: [],
-                events: [{ wuId: 'WU-999', type: 'claimed', timestamp: new Date().toISOString() }],
-            });
-            // Mock withMicroWorktree to track that it was called
-            const mockWithMicroWorktree = vi.mocked(withMicroWorktree);
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                // Execute the callback to simulate micro-worktree operations
-                const result = await options.execute({
-                    worktreePath: testDir,
-                    gitWorktree: {
-                        add: vi.fn(),
-                        addWithDeletions: vi.fn(),
-                        commit: vi.fn(),
-                        push: vi.fn(),
-                    },
-                });
-                return { ...result, ref: 'main' };
-            });
-            // Import and run the fix function
-            const { createStateDoctorFixDeps } = await import('../state-doctor-fix.js');
-            const deps = createStateDoctorFixDeps(testDir);
-            // When: Attempt to remove a broken event
-            await deps.removeEvent('WU-999');
-            // Then: micro-worktree should have been used
-            expect(mockWithMicroWorktree).toHaveBeenCalled();
-            expect(mockWithMicroWorktree).toHaveBeenCalledWith(expect.objectContaining({
-                operation: 'state-doctor',
-                pushOnly: true,
-            }));
-        });
-        it('should not directly modify files on main when --fix is used', async () => {
-            // Setup: Create test state with events file
-            const eventsPath = join(testDir, LUMENFLOW_DIR, STATE_DIR, 'wu-events.jsonl');
-            setupTestState(testDir, {
-                wus: [],
-                events: [{ wuId: 'WU-999', type: 'claimed', timestamp: new Date().toISOString() }],
-            });
-            const originalContent = readFileSync(eventsPath, 'utf-8');
-            // Mock withMicroWorktree to NOT actually modify files (simulating push-only mode)
-            const mockWithMicroWorktree = vi.mocked(withMicroWorktree);
-            mockWithMicroWorktree.mockResolvedValue({
-                commitMessage: 'fix: remove broken events',
-                files: ['.lumenflow/state/wu-events.jsonl'],
-                ref: 'main',
-            });
-            // Import and run the fix function
-            const { createStateDoctorFixDeps } = await import('../state-doctor-fix.js');
-            const deps = createStateDoctorFixDeps(testDir);
-            // When: Remove broken event
-            await deps.removeEvent('WU-999');
-            // Then: Original file on main should be unchanged
-            // (changes only happen in micro-worktree and pushed)
-            const currentContent = readFileSync(eventsPath, 'utf-8');
-            expect(currentContent).toBe(originalContent);
-        });
-    });
-    describe('backlog.md and status.md cleanup', () => {
-        it('should remove stale WU references from backlog.md when removing broken events', async () => {
-            // Setup: Create backlog.md with reference to WU that will be removed
-            setupTestState(testDir, {
-                wus: [],
-                events: [{ wuId: 'WU-999', type: 'claimed', timestamp: new Date().toISOString() }],
-                backlog: `# Backlog
-
-## In Progress
-
-- WU-999: Some old WU that no longer exists
-
-## Ready
-
-- WU-100: Valid WU
-`,
-            });
-            // Track the files that would be modified in micro-worktree
-            let capturedFiles = [];
-            const mockWithMicroWorktree = vi.mocked(withMicroWorktree);
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                const result = await options.execute({
-                    worktreePath: testDir,
-                    gitWorktree: {
-                        add: vi.fn(),
-                        addWithDeletions: vi.fn(),
-                        commit: vi.fn(),
-                        push: vi.fn(),
-                    },
-                });
-                capturedFiles = result.files;
-                return { ...result, ref: 'main' };
-            });
-            // Import and run the fix function
-            const { createStateDoctorFixDeps } = await import('../state-doctor-fix.js');
-            const deps = createStateDoctorFixDeps(testDir);
-            // When: Remove broken event for WU-999
-            await deps.removeEvent('WU-999');
-            // Then: backlog.md should be in the list of modified files
-            expect(capturedFiles).toContain(BACKLOG_PATH);
-        });
-        it('should remove stale WU references from status.md when removing broken events', async () => {
-            // Setup: Create status.md with reference to WU that will be removed
-            setupTestState(testDir, {
-                wus: [],
-                events: [{ wuId: 'WU-999', type: 'claimed', timestamp: new Date().toISOString() }],
-                status: `# Status
-
-## In Progress
-
-| Lane | WU | Title |
-|------|-----|-------|
-| Framework: CLI | WU-999 | Old WU |
-`,
-            });
-            // Track the files that would be modified
-            let capturedFiles = [];
-            const mockWithMicroWorktree = vi.mocked(withMicroWorktree);
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                const result = await options.execute({
-                    worktreePath: testDir,
-                    gitWorktree: {
-                        add: vi.fn(),
-                        addWithDeletions: vi.fn(),
-                        commit: vi.fn(),
-                        push: vi.fn(),
-                    },
-                });
-                capturedFiles = result.files;
-                return { ...result, ref: 'main' };
-            });
-            // Import and run the fix function
-            const { createStateDoctorFixDeps } = await import('../state-doctor-fix.js');
-            const deps = createStateDoctorFixDeps(testDir);
-            // When: Remove broken event for WU-999
-            await deps.removeEvent('WU-999');
-            // Then: status.md should be in the list of modified files
-            expect(capturedFiles).toContain(STATUS_PATH);
-        });
-    });
-    describe('commit and push behavior', () => {
-        it('should use pushOnly mode to avoid modifying local main', async () => {
-            setupTestState(testDir, {
-                wus: [],
-                events: [{ wuId: 'WU-999', type: 'claimed', timestamp: new Date().toISOString() }],
-            });
-            const mockWithMicroWorktree = vi.mocked(withMicroWorktree);
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                // Verify pushOnly is set
-                expect(options.pushOnly).toBe(true);
-                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');
-            // The assertion is inside the mock - if we get here without error, pushOnly was true
-            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
-    const dirs = [
-        join(baseDir, LUMENFLOW_DIR, STATE_DIR),
-        join(baseDir, LUMENFLOW_DIR, STAMPS_DIR),
-        join(baseDir, LUMENFLOW_DIR, MEMORY_DIR),
-        join(baseDir, DOCS_TASKS_DIR, 'wu'),
-    ];
-    for (const dir of dirs) {
-        mkdirSync(dir, { recursive: true });
-    }
-    // Create events file
-    if (state.events && state.events.length > 0) {
-        const eventsPath = join(baseDir, LUMENFLOW_DIR, STATE_DIR, 'wu-events.jsonl');
-        const content = state.events.map((e) => JSON.stringify(e)).join('\n') + '\n';
-        writeFileSync(eventsPath, content, 'utf-8');
-    }
-    // Create signals file
-    if (state.signals && state.signals.length > 0) {
-        const signalsPath = join(baseDir, LUMENFLOW_DIR, MEMORY_DIR, 'signals.jsonl');
-        const content = state.signals.map((s) => JSON.stringify(s)).join('\n') + '\n';
-        writeFileSync(signalsPath, content, 'utf-8');
-    }
-    // Create WU YAML files
-    if (state.wus) {
-        for (const wu of state.wus) {
-            const wuPath = join(baseDir, DOCS_TASKS_DIR, 'wu', `${wu.id}.yaml`);
-            const content = `id: ${wu.id}\nstatus: ${wu.status}\ntitle: ${wu.title || wu.id}\n`;
-            writeFileSync(wuPath, content, 'utf-8');
-        }
-    }
-    // Create backlog.md
-    if (state.backlog) {
-        const backlogPath = join(baseDir, BACKLOG_PATH);
-        writeFileSync(backlogPath, state.backlog, 'utf-8');
-    }
-    // Create status.md
-    if (state.status) {
-        const statusPath = join(baseDir, STATUS_PATH);
-        writeFileSync(statusPath, state.status, 'utf-8');
-    }
-}

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

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