@lumenflow/cli 2.20.1 → 2.21.1

package/dist/__tests__/lumenflow-upgrade.test.js

@@ -1,260 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for lumenflow-upgrade CLI command
- *
- * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
- * WU-1127: Add micro-worktree isolation pattern
- *
- * lumenflow-upgrade updates all @lumenflow/* packages to latest versions.
- * Key requirements:
- * - Uses micro-worktree pattern (atomic changes to main without requiring user worktree)
- * - Checks all 7 @lumenflow/* packages
- * - Supports --dry-run and --latest flags
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { execSync } from 'node:child_process';
-// Mock modules with inline factories (no external references)
-vi.mock('@lumenflow/core/dist/micro-worktree.js', () => ({
-    withMicroWorktree: vi.fn(),
-}));
-vi.mock('@lumenflow/core/dist/git-adapter.js', () => ({
-    getGitForCwd: vi.fn(),
-}));
-vi.mock('node:child_process', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        execSync: vi.fn(),
-    };
-});
-// Import mocked modules to access mock functions
-import { withMicroWorktree } from '@lumenflow/core/dist/micro-worktree.js';
-import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
-// Import functions under test after mocks are set up
-import { parseUpgradeArgs, LUMENFLOW_PACKAGES, buildUpgradeCommands, executeUpgradeInMicroWorktree, validateMainCheckout, } from '../lumenflow-upgrade.js';
-// Cast mocks for TypeScript
-const mockWithMicroWorktree = withMicroWorktree;
-const mockGetGitForCwd = getGitForCwd;
-const mockExecSync = execSync;
-describe('lumenflow-upgrade', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Default mock behavior for git adapter
-        mockGetGitForCwd.mockReturnValue({
-            raw: vi.fn().mockResolvedValue('main'),
-            getStatus: vi.fn().mockResolvedValue(''),
-        });
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe('LUMENFLOW_PACKAGES constant', () => {
-        it('should include all 7 @lumenflow/* packages', () => {
-            expect(LUMENFLOW_PACKAGES).toContain('@lumenflow/agent');
-            expect(LUMENFLOW_PACKAGES).toContain('@lumenflow/cli');
-            expect(LUMENFLOW_PACKAGES).toContain('@lumenflow/core');
-            expect(LUMENFLOW_PACKAGES).toContain('@lumenflow/initiatives');
-            expect(LUMENFLOW_PACKAGES).toContain('@lumenflow/memory');
-            expect(LUMENFLOW_PACKAGES).toContain('@lumenflow/metrics');
-            expect(LUMENFLOW_PACKAGES).toContain('@lumenflow/shims');
-            expect(LUMENFLOW_PACKAGES).toHaveLength(7);
-        });
-        it('should have packages in alphabetical order', () => {
-            const sorted = [...LUMENFLOW_PACKAGES].sort();
-            expect(LUMENFLOW_PACKAGES).toEqual(sorted);
-        });
-    });
-    describe('parseUpgradeArgs', () => {
-        it('should parse --version flag', () => {
-            const args = parseUpgradeArgs(['node', 'lumenflow-upgrade.js', '--version', '1.5.0']);
-            expect(args.version).toBe('1.5.0');
-        });
-        it('should parse --latest flag', () => {
-            const args = parseUpgradeArgs(['node', 'lumenflow-upgrade.js', '--latest']);
-            expect(args.latest).toBe(true);
-        });
-        it('should parse --dry-run flag', () => {
-            const args = parseUpgradeArgs(['node', 'lumenflow-upgrade.js', '--dry-run']);
-            expect(args.dryRun).toBe(true);
-        });
-        it('should parse --help flag', () => {
-            const args = parseUpgradeArgs(['node', 'lumenflow-upgrade.js', '--help']);
-            expect(args.help).toBe(true);
-        });
-        it('should default latest to false', () => {
-            const args = parseUpgradeArgs(['node', 'lumenflow-upgrade.js']);
-            expect(args.latest).toBeFalsy();
-        });
-        it('should default dryRun to false', () => {
-            const args = parseUpgradeArgs(['node', 'lumenflow-upgrade.js']);
-            expect(args.dryRun).toBeFalsy();
-        });
-    });
-    describe('buildUpgradeCommands', () => {
-        it('should build commands for specific version', () => {
-            const args = { version: '1.5.0' };
-            const commands = buildUpgradeCommands(args);
-            // Should have pnpm add command for all packages
-            expect(commands.addCommand).toContain('pnpm add');
-            expect(commands.addCommand).toContain('@lumenflow/agent@1.5.0');
-            expect(commands.addCommand).toContain('@lumenflow/cli@1.5.0');
-            expect(commands.addCommand).toContain('@lumenflow/core@1.5.0');
-            expect(commands.addCommand).toContain('@lumenflow/initiatives@1.5.0');
-            expect(commands.addCommand).toContain('@lumenflow/memory@1.5.0');
-            expect(commands.addCommand).toContain('@lumenflow/metrics@1.5.0');
-            expect(commands.addCommand).toContain('@lumenflow/shims@1.5.0');
-        });
-        it('should build commands for latest version', () => {
-            const args = { latest: true };
-            const commands = buildUpgradeCommands(args);
-            // Should have pnpm add command for all packages with @latest
-            expect(commands.addCommand).toContain('pnpm add');
-            expect(commands.addCommand).toContain('@lumenflow/agent@latest');
-            expect(commands.addCommand).toContain('@lumenflow/cli@latest');
-        });
-        it('should include dev dependencies flag', () => {
-            const args = { version: '1.5.0' };
-            const commands = buildUpgradeCommands(args);
-            // LumenFlow packages are dev dependencies
-            expect(commands.addCommand).toContain('--save-dev');
-        });
-        it('should include all 7 packages in the command', () => {
-            const args = { version: '1.5.0' };
-            const commands = buildUpgradeCommands(args);
-            // Count how many packages are in the command
-            const packageCount = LUMENFLOW_PACKAGES.filter((pkg) => commands.addCommand.includes(pkg)).length;
-            expect(packageCount).toBe(7);
-        });
-    });
-    // WU-1127: Tests for micro-worktree isolation pattern
-    describe('validateMainCheckout', () => {
-        let originalCwd;
-        beforeEach(() => {
-            originalCwd = process.cwd;
-        });
-        afterEach(() => {
-            process.cwd = originalCwd;
-        });
-        it('should return valid when on main branch and not in worktree', async () => {
-            // Mock process.cwd to be on main checkout (not worktree)
-            process.cwd = vi.fn().mockReturnValue('/path/to/repo');
-            mockGetGitForCwd.mockReturnValue({
-                raw: vi.fn().mockResolvedValue('main'),
-                getStatus: vi.fn().mockResolvedValue(''),
-            });
-            const result = await validateMainCheckout();
-            expect(result.valid).toBe(true);
-        });
-        it('should return invalid when not on main branch', async () => {
-            // Mock process.cwd to be on main checkout (not worktree)
-            process.cwd = vi.fn().mockReturnValue('/path/to/repo');
-            mockGetGitForCwd.mockReturnValue({
-                raw: vi.fn().mockResolvedValue('lane/framework-cli/wu-123'),
-                getStatus: vi.fn().mockResolvedValue(''),
-            });
-            const result = await validateMainCheckout();
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain('must be run from main checkout');
-        });
-        it('should return invalid when in a worktree directory', async () => {
-            // Mock process.cwd() to be in a worktree
-            process.cwd = vi
-                .fn()
-                .mockReturnValue('/path/to/repo/worktrees/some-wu');
-            mockGetGitForCwd.mockReturnValue({
-                raw: vi.fn().mockResolvedValue('main'),
-                getStatus: vi.fn().mockResolvedValue(''),
-            });
-            const result = await validateMainCheckout();
-            expect(result.valid).toBe(false);
-            expect(result.error).toContain('worktree');
-        });
-    });
-    describe('executeUpgradeInMicroWorktree', () => {
-        it('should call withMicroWorktree with correct operation name', async () => {
-            mockWithMicroWorktree.mockResolvedValue({});
-            mockExecSync.mockReturnValue('');
-            const args = { version: '2.1.0' };
-            await executeUpgradeInMicroWorktree(args);
-            expect(mockWithMicroWorktree).toHaveBeenCalledTimes(1);
-            expect(mockWithMicroWorktree).toHaveBeenCalledWith(expect.objectContaining({
-                operation: 'lumenflow-upgrade',
-            }));
-        });
-        it('should use a unique ID for micro-worktree based on timestamp', async () => {
-            mockWithMicroWorktree.mockResolvedValue({});
-            mockExecSync.mockReturnValue('');
-            const args = { latest: true };
-            await executeUpgradeInMicroWorktree(args);
-            // ID should be a timestamp-like string
-            expect(mockWithMicroWorktree).toHaveBeenCalledWith(expect.objectContaining({
-                id: expect.stringMatching(/^upgrade-\d+$/),
-            }));
-        });
-        it('should execute pnpm add in the micro-worktree', async () => {
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                // Simulate calling the execute function with a worktree path
-                return options.execute({ worktreePath: '/tmp/test-worktree' });
-            });
-            const args = { version: '2.1.0' };
-            await executeUpgradeInMicroWorktree(args);
-            // Verify pnpm add was executed with correct cwd
-            expect(mockExecSync).toHaveBeenCalledWith(expect.stringContaining('pnpm add'), expect.objectContaining({
-                cwd: '/tmp/test-worktree',
-            }));
-        });
-        it('should include all 7 packages in the pnpm add command', async () => {
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                return options.execute({ worktreePath: '/tmp/test-worktree' });
-            });
-            const args = { version: '2.1.0' };
-            await executeUpgradeInMicroWorktree(args);
-            // Get the command that was executed
-            const execCall = mockExecSync.mock.calls[0][0];
-            expect(typeof execCall).toBe('string');
-            // Verify all 7 packages are included
-            for (const pkg of LUMENFLOW_PACKAGES) {
-                expect(execCall).toContain(`${pkg}@2.1.0`);
-            }
-        });
-        it('should return appropriate commit message and files', async () => {
-            let executeResult;
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                executeResult = await options.execute({ worktreePath: '/tmp/test-worktree' });
-                return executeResult;
-            });
-            const args = { version: '2.1.0' };
-            await executeUpgradeInMicroWorktree(args);
-            expect(executeResult).toBeDefined();
-            expect(executeResult.commitMessage).toContain('upgrade @lumenflow packages');
-            expect(executeResult.files).toContain('package.json');
-            expect(executeResult.files).toContain('pnpm-lock.yaml');
-        });
-        it('should use --latest version specifier when latest flag is set', async () => {
-            mockWithMicroWorktree.mockImplementation(async (options) => {
-                return options.execute({ worktreePath: '/tmp/test-worktree' });
-            });
-            const args = { latest: true };
-            await executeUpgradeInMicroWorktree(args);
-            const execCall = mockExecSync.mock.calls[0][0];
-            expect(execCall).toContain('@lumenflow/core@latest');
-        });
-    });
-    describe('dry-run mode', () => {
-        it('should not call withMicroWorktree when dryRun is true', async () => {
-            const args = { version: '2.1.0', dryRun: true };
-            // In dry-run mode, executeUpgradeInMicroWorktree should not be called
-            // This is handled by the main() function checking dryRun before calling execute
-            // We just verify the function exists and can be called
-            expect(typeof executeUpgradeInMicroWorktree).toBe('function');
-        });
-    });
-    describe('legacy worktree validation removal', () => {
-        it('should not require user to be in a worktree', () => {
-            // The old implementation required users to be inside a worktree
-            // The new implementation uses micro-worktree and runs from main checkout
-            // This test verifies the old validateWorktreeContext is no longer used
-            expect(typeof validateMainCheckout).toBe('function');
-        });
-    });
-});

package/dist/__tests__/mem-cleanup-execution.test.js

@@ -1,19 +0,0 @@
-import { exec } from 'node:child_process';
-import path from 'node:path';
-import { promisify } from 'node:util';
-import { describe, it, expect } from 'vitest';
-const execAsync = promisify(exec);
-const CLI_DIST_PATH = path.resolve(__dirname, '../../dist/mem-cleanup.js');
-describe('mem:cleanup CLI execution', () => {
-    it('should run --help without crashing', async () => {
-        try {
-            // We run the actual built JS file to catch ESM/CJS compatibility issues
-            const { stdout } = await execAsync(`node ${CLI_DIST_PATH} --help`);
-            expect(stdout).toContain('Usage: mem-cleanup');
-        }
-        catch (error) {
-            // If it fails, we want to see why (expecting ReferenceError: require is not defined)
-            throw new Error(`Command failed: ${error.message}\nStderr: ${error.stderr}`);
-        }
-    });
-});

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

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