@cleocode/core 2026.4.6 → 2026.4.9

package/src/__tests__/core-parity.test.js

@@ -1,645 +0,0 @@
-/**
- * CLI/MCP Core Parity Integration Tests
- *
- * Verifies that MCP engine functions delegate to src/core/ modules
- * and that both paths produce equivalent results for shared operations.
- *
- * Test categories:
- * 1. Import graph verification — engine files import from core
- * 2. Task CRUD data parity — core vs engine return identical task data
- * 3. Session operations parity — core vs engine session state
- * 4. Lifecycle operations parity — core vs engine lifecycle info
- *
- * @task T4796
- * @epic T4654
- */
-import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { closeLogger, initLogger } from '../logger.js';
-// ============================================================================
-// Section 1: Import Graph Verification
-//
-// Verifies that engine files delegate to src/core/ rather than duplicating
-// business logic inline. This is a structural test that reads source files.
-//
-// Note: Multi-line import statements like:
-//   import {
-//     foo,
-//   } from '../../core/bar.js';
-// have `from` on a separate line from `import`, so we match `from` lines.
-// ============================================================================
-describe('Import Graph Verification (T4796)', () => {
-    const ENGINE_FILES = [
-    // task-engine.ts deleted — moved to src/dispatch/engines/task-engine.ts (T5100)
-    // session-engine.ts deleted — moved to src/dispatch/engines/session-engine.ts
-    // lifecycle-engine.ts deleted — moved to src/dispatch/engines/lifecycle-engine.ts
-    // system-engine.ts deleted — moved to src/dispatch/engines/system-engine.ts (T5107)
-    // orchestrate-engine.ts deleted — moved to src/dispatch/engines/orchestrate-engine.ts (T5108)
-    // validate-engine.ts deleted — moved to src/dispatch/engines/validate-engine.ts (T5109-T5111)
-    ];
-    const ENGINE_DIR = join(process.cwd(), 'src', 'mcp', 'engine');
-    for (const file of ENGINE_FILES) {
-        describe(`${file}`, () => {
-            it('imports from @cleocode/core or ../../store/', async () => {
-                const filePath = join(ENGINE_DIR, file);
-                const content = await readFile(filePath, 'utf-8');
-                // Match `from '...'` lines (handles multi-line imports)
-                // T5718: engines now import via @cleocode/core (not relative ../../core/)
-                const fromLines = content.split('\n').filter((line) => line.match(/from\s+['"]/));
-                const coreImports = fromLines.filter((line) => line.includes("'@cleocode/core'") || line.includes('../store/'));
-                // Every engine file should have at least one core/store import
-                expect(coreImports.length).toBeGreaterThanOrEqual(1);
-            });
-            it('has meaningful core delegation', async () => {
-                const filePath = join(ENGINE_DIR, file);
-                const content = await readFile(filePath, 'utf-8');
-                // Match all `from '...'` lines
-                // T5718: engines import core via @cleocode/core package
-                const fromLines = content
-                    .split('\n')
-                    .filter((line) => line.match(/from\s+['"]/))
-                    .filter((line) => !line.includes("'node:"))
-                    .filter((line) => !line.includes("'vitest"));
-                // Count @cleocode/core + store imports
-                const coreImports = fromLines.filter((line) => line.includes("'@cleocode/core'") || line.includes('../store/'));
-                // Core imports should exist
-                if (fromLines.length > 0) {
-                    expect(coreImports.length).toBeGreaterThanOrEqual(1);
-                }
-            });
-        });
-    }
-    it('task-engine.ts imports core CRUD functions via @cleocode/core', async () => {
-        // task-engine.ts moved to src/dispatch/engines/task-engine.ts (T5100)
-        // T5718: imports rewired from relative ../../core/ to @cleocode/core
-        const dispatchEngineDir = join(process.cwd(), 'src', 'dispatch', 'engines');
-        const content = await readFile(join(dispatchEngineDir, 'task-engine.ts'), 'utf-8');
-        // Core task functions are now imported via @cleocode/core (T5718)
-        expect(content).toContain("from '@cleocode/core'");
-        // Verify the key task functions are imported
-        expect(content).toContain('addTask');
-        expect(content).toContain('showTask');
-        expect(content).toContain('listTasks');
-        expect(content).toContain('findTasks');
-        expect(content).toContain('updateTask');
-        expect(content).toContain('deleteTask');
-        expect(content).toContain('archiveTasks');
-    });
-    it('dispatch session-engine.ts imports core session/task-work functions via @cleocode/core', async () => {
-        // T5718: imports rewired from relative ../../core/ to @cleocode/core
-        const dispatchEngineDir = join(process.cwd(), 'src', 'dispatch', 'engines');
-        const content = await readFile(join(dispatchEngineDir, 'session-engine.ts'), 'utf-8');
-        expect(content).toContain("from '@cleocode/core'");
-        // Verify session and task-work functions are present
-        // (session engine builds sessions via parseScope/generateSessionId rather than startSession/endSession)
-        expect(content).toContain('parseScope');
-        expect(content).toContain('computeHandoff');
-        expect(content).toContain('startTask');
-        expect(content).toContain('stopTask');
-    });
-    it('lifecycle-engine.ts imports core lifecycle functions via @cleocode/core', async () => {
-        // lifecycle-engine.ts moved to src/dispatch/engines/lifecycle-engine.ts
-        // T5718: imports rewired from relative ../../core/ to @cleocode/core
-        const dispatchEngineDir = join(process.cwd(), 'src', 'dispatch', 'engines');
-        const content = await readFile(join(dispatchEngineDir, 'lifecycle-engine.ts'), 'utf-8');
-        expect(content).toContain("from '@cleocode/core'");
-        expect(content).toContain('getLifecycleStatus');
-        expect(content).toContain('recordStageProgress');
-    });
-    it('validate-engine.ts imports core validation functions via @cleocode/core', async () => {
-        // T5718: imports rewired from relative ../../core/ to @cleocode/core
-        const dispatchEngineDir = join(process.cwd(), 'src', 'dispatch', 'engines');
-        const content = await readFile(join(dispatchEngineDir, 'validate-engine.ts'), 'utf-8');
-        expect(content).toContain("from '@cleocode/core'");
-        expect(content).toContain('coreValidateSchema');
-        expect(content).toContain('coreValidateTask');
-    });
-    it('system-engine.ts imports core system functions via @cleocode/core', async () => {
-        // T5718: imports rewired from relative ../../core/ to @cleocode/core
-        const dispatchEngineDir = join(process.cwd(), 'src', 'dispatch', 'engines');
-        const content = await readFile(join(dispatchEngineDir, 'system-engine.ts'), 'utf-8');
-        expect(content).toContain("from '@cleocode/core'");
-        expect(content).toContain('getProjectStats');
-        expect(content).toContain('getSystemHealth');
-    });
-    it('orchestrate-engine.ts imports core orchestration functions via @cleocode/core', async () => {
-        // T5718: imports rewired from relative ../../core/ to @cleocode/core
-        const dispatchEngineDir = join(process.cwd(), 'src', 'dispatch', 'engines');
-        const content = await readFile(join(dispatchEngineDir, 'orchestrate-engine.ts'), 'utf-8');
-        expect(content).toContain("from '@cleocode/core'");
-        expect(content).toContain('analyzeEpic');
-        expect(content).toContain('prepareSpawn');
-    });
-    // research-engine.ts has been consolidated into core/memory/engine-compat.ts
-});
-// ============================================================================
-// Shared fixture helper
-// ============================================================================
-/**
- * Create a minimal .cleo project directory with required files.
- * Seeds task data into SQLite (ADR-006 canonical storage).
- * Returns { testDir, cleoDir }.
- */
-async function createTestProject(prefix, tasksJson) {
-    const testDir = await mkdtemp(join(tmpdir(), prefix));
-    const cleoDir = join(testDir, '.cleo');
-    await mkdir(cleoDir, { recursive: true });
-    await mkdir(join(cleoDir, 'backups', 'operational'), { recursive: true });
-    // Seed tasks into SQLite via the task store
-    const { getDb } = await import('../store/sqlite.js');
-    const { createTask } = await import('../store/task-store.js');
-    await getDb(testDir);
-    const tasks = tasksJson.tasks ?? [];
-    for (const task of tasks) {
-        await createTask(task, testDir);
-    }
-    return { testDir, cleoDir };
-}
-// ============================================================================
-// Section 2: Task CRUD Data Parity
-//
-// Creates a temp project dir with a valid tasks.json, then verifies that
-// calling core functions directly and engine wrapper functions produce
-// equivalent results (stripping the EngineResult wrapper).
-// ============================================================================
-describe('Task CRUD Data Parity (T4796)', () => {
-    let testDir;
-    let cleoDir;
-    const TASKS_JSON = {
-        version: '2.10.0',
-        project: {
-            name: 'Parity Test',
-            phases: {
-                core: { order: 1, name: 'Core', status: 'active' },
-            },
-        },
-        lastUpdated: '2026-01-01T00:00:00Z',
-        _meta: {
-            schemaVersion: '2.10.0',
-            specVersion: '0.1.0',
-            checksum: 'abc',
-            configVersion: '2.0.0',
-        },
-        focus: {},
-        tasks: [
-            {
-                id: 'T001',
-                title: 'Test task alpha',
-                description: 'First test task for parity testing',
-                status: 'pending',
-                priority: 'high',
-                phase: 'core',
-                type: 'task',
-                createdAt: '2026-01-01T00:00:00Z',
-                updatedAt: null,
-            },
-            {
-                id: 'T002',
-                title: 'Test task beta',
-                description: 'Second test task for parity testing',
-                status: 'done',
-                priority: 'medium',
-                phase: 'core',
-                type: 'task',
-                createdAt: '2026-01-02T00:00:00Z',
-                updatedAt: null,
-                completedAt: '2026-01-05T00:00:00Z',
-            },
-            {
-                id: 'T003',
-                title: 'Subtask of T001',
-                description: 'A child task',
-                status: 'pending',
-                priority: 'low',
-                phase: 'core',
-                type: 'subtask',
-                parentId: 'T001',
-                createdAt: '2026-01-03T00:00:00Z',
-                updatedAt: null,
-            },
-        ],
-    };
-    beforeEach(async () => {
-        const project = await createTestProject('cleo-parity-', TASKS_JSON);
-        testDir = project.testDir;
-        cleoDir = project.cleoDir;
-        process.env['CLEO_DIR'] = cleoDir;
-        initLogger(cleoDir, {
-            level: 'fatal',
-            filePath: 'logs/test.log',
-            maxFileSize: 1024 * 1024,
-            maxFiles: 1,
-        });
-    });
-    afterEach(async () => {
-        await closeLogger();
-        delete process.env['CLEO_DIR'];
-        try {
-            const { closeAllDatabases } = await import('../store/sqlite.js');
-            await closeAllDatabases();
-        }
-        catch {
-            /* ignore */
-        }
-        await Promise.race([
-            rm(testDir, { recursive: true, force: true }).catch(() => { }),
-            new Promise((resolve) => setTimeout(resolve, 8_000)),
-        ]);
-    });
-    it('taskShow returns same task data as core showTask', async () => {
-        const { showTask } = await import('../tasks/show.js');
-        const { taskShow } = await import('../../dispatch/engines/task-engine.js');
-        const { getAccessor } = await import('../store/data-accessor.js');
-        const accessor = await getAccessor(testDir);
-        // Call core directly
-        const coreResult = await showTask('T001', testDir, accessor);
-        // Call engine wrapper
-        const engineResult = await taskShow(testDir, 'T001');
-        // Both should succeed
-        expect(engineResult.success).toBe(true);
-        expect(engineResult.data).toBeDefined();
-        // Compare key fields (engine wraps core result in { task: ... })
-        expect(engineResult.data.task.id).toBe(coreResult.id);
-        expect(engineResult.data.task.title).toBe(coreResult.title);
-        expect(engineResult.data.task.status).toBe(coreResult.status);
-        expect(engineResult.data.task.priority).toBe(coreResult.priority);
-    });
-    it('taskShow and core showTask both fail for missing task', async () => {
-        const { showTask } = await import('../tasks/show.js');
-        const { taskShow } = await import('../../dispatch/engines/task-engine.js');
-        const { getAccessor } = await import('../store/data-accessor.js');
-        const accessor = await getAccessor(testDir);
-        // Core should throw
-        await expect(showTask('T999', testDir, accessor)).rejects.toThrow();
-        // Engine should return error (may be E_NOT_FOUND or E_NOT_INITIALIZED
-        // depending on where the error is caught in the engine)
-        const engineResult = await taskShow(testDir, 'T999');
-        expect(engineResult.success).toBe(false);
-        expect(engineResult.error?.code).toMatch(/^E_/);
-    });
-    it('taskList returns same tasks as core listTasks', async () => {
-        const { listTasks } = await import('../tasks/list.js');
-        const { taskList } = await import('../../dispatch/engines/task-engine.js');
-        const { getAccessor } = await import('../store/data-accessor.js');
-        const accessor = await getAccessor(testDir);
-        // Call core
-        const coreResult = await listTasks({}, testDir, accessor);
-        // Call engine
-        const engineResult = await taskList(testDir);
-        expect(engineResult.success).toBe(true);
-        expect(engineResult.data).toBeDefined();
-        expect(engineResult.page).toEqual(coreResult.page);
-        // Same number of tasks
-        expect(engineResult.data.tasks.length).toBe(coreResult.tasks.length);
-        // Same task IDs
-        const coreIds = coreResult.tasks.map((t) => t.id).sort();
-        const engineIds = engineResult.data.tasks.map((t) => t.id).sort();
-        expect(engineIds).toEqual(coreIds);
-    });
-    it('taskList with status filter matches core listTasks filter', async () => {
-        const { listTasks } = await import('../tasks/list.js');
-        const { taskList } = await import('../../dispatch/engines/task-engine.js');
-        const { getAccessor } = await import('../store/data-accessor.js');
-        const accessor = await getAccessor(testDir);
-        // Filter pending tasks
-        const coreResult = await listTasks({ status: 'pending' }, testDir, accessor);
-        const engineResult = await taskList(testDir, { status: 'pending' });
-        expect(engineResult.success).toBe(true);
-        expect(engineResult.page).toEqual(coreResult.page);
-        const coreIds = coreResult.tasks.map((t) => t.id).sort();
-        const engineIds = engineResult.data.tasks.map((t) => t.id).sort();
-        expect(engineIds).toEqual(coreIds);
-    });
-    it('taskFind returns same results as core findTasks', async () => {
-        const { findTasks } = await import('../tasks/find.js');
-        const { taskFind } = await import('../../dispatch/engines/task-engine.js');
-        const { getAccessor } = await import('../store/data-accessor.js');
-        const accessor = await getAccessor(testDir);
-        // Search for "alpha"
-        const coreResult = await findTasks({ query: 'alpha', limit: 20 }, testDir, accessor);
-        const engineResult = await taskFind(testDir, 'alpha');
-        expect(engineResult.success).toBe(true);
-        expect(engineResult.data).toBeDefined();
-        // Both should find T001
-        const coreIds = coreResult.results.map((r) => r.id);
-        const engineIds = engineResult.data.results.map((r) => r.id);
-        expect(coreIds).toContain('T001');
-        expect(engineIds).toContain('T001');
-    });
-    it('taskCreate produces a valid task via engine', async () => {
-        const { taskCreate } = await import('../../dispatch/engines/task-engine.js');
-        // Engine create
-        const engineResult = await taskCreate(testDir, {
-            title: 'Engine-created task',
-            description: 'Created via engine for parity test',
-        });
-        expect(engineResult.success).toBe(true);
-        expect(engineResult.data).toBeDefined();
-        expect(engineResult.data.task.id).toMatch(/^T\d+$/);
-        expect(engineResult.data.task.title).toBe('Engine-created task');
-        expect(engineResult.data.task.status).toBe('pending');
-    });
-});
-// ============================================================================
-// Section 3: Session Engine Delegation Verification
-//
-// Verifies that session-engine.ts functions delegate to core and produce
-// structurally valid EngineResult wrappers.
-// ============================================================================
-describe('Session Engine Delegation (T4796)', () => {
-    let testDir;
-    let cleoDir;
-    const SESSION_TASKS_JSON = {
-        version: '2.10.0',
-        project: {
-            name: 'Session Test',
-            phases: {
-                core: { order: 1, name: 'Core', status: 'active' },
-            },
-        },
-        lastUpdated: '2026-01-01T00:00:00Z',
-        _meta: {
-            schemaVersion: '2.10.0',
-            specVersion: '0.1.0',
-            checksum: 'abc',
-            configVersion: '2.0.0',
-        },
-        focus: {
-            currentTask: null,
-            currentPhase: null,
-        },
-        tasks: [
-            {
-                id: 'T010',
-                title: 'Session test epic',
-                description: 'Epic for session testing',
-                status: 'pending',
-                priority: 'high',
-                phase: 'core',
-                type: 'epic',
-                createdAt: '2026-01-01T00:00:00Z',
-                updatedAt: null,
-            },
-        ],
-    };
-    beforeEach(async () => {
-        const project = await createTestProject('cleo-sess-', SESSION_TASKS_JSON);
-        testDir = project.testDir;
-        cleoDir = project.cleoDir;
-        process.env['CLEO_DIR'] = cleoDir;
-        initLogger(cleoDir, {
-            level: 'fatal',
-            filePath: 'logs/test.log',
-            maxFileSize: 1024 * 1024,
-            maxFiles: 1,
-        });
-    });
-    afterEach(async () => {
-        await closeLogger();
-        delete process.env['CLEO_DIR'];
-        try {
-            const { closeAllDatabases } = await import('../store/sqlite.js');
-            await closeAllDatabases();
-        }
-        catch {
-            /* ignore */
-        }
-        await Promise.race([
-            rm(testDir, { recursive: true, force: true }).catch(() => { }),
-            new Promise((resolve) => setTimeout(resolve, 8_000)),
-        ]);
-    });
-    it('sessionStatus returns valid EngineResult', async () => {
-        const { sessionStatus } = await import('../../dispatch/engines/session-engine.js');
-        const result = await sessionStatus(testDir);
-        expect(result.success).toBe(true);
-        expect(result.data).toBeDefined();
-        expect(typeof result.data.hasActiveSession).toBe('boolean');
-    });
-    it('sessionList returns valid EngineResult with canonical list metadata', async () => {
-        const { sessionList } = await import('../../dispatch/engines/session-engine.js');
-        const result = await sessionList(testDir);
-        expect(result.success).toBe(true);
-        expect(result.data).toBeDefined();
-        expect(Array.isArray(result.data.sessions)).toBe(true);
-        expect(typeof result.data.total).toBe('number');
-        expect(typeof result.data.filtered).toBe('number');
-        expect(result.data._meta).toBeDefined();
-        expect(typeof result.data._meta.truncated).toBe('boolean');
-        expect(typeof result.data._meta.total).toBe('number');
-        expect(result.page).toBeDefined();
-    });
-    it('sessionStart creates session and returns EngineResult', async () => {
-        const { sessionStart } = await import('../../dispatch/engines/session-engine.js');
-        const result = await sessionStart(testDir, {
-            scope: 'epic:T010',
-            name: 'Parity Test Session',
-            autoStart: true,
-        });
-        expect(result.success).toBe(true);
-        expect(result.data).toBeDefined();
-        expect(result.data.id).toMatch(/^ses_/);
-        expect(result.data.status).toBe('active');
-        expect(result.data.scope.rootTaskId).toBe('T010');
-    });
-    it('sessionStart then sessionEnd round-trip works', async () => {
-        const { sessionStart, sessionEnd, sessionStatus } = await import('../../dispatch/engines/session-engine.js');
-        // Start session
-        const startResult = await sessionStart(testDir, {
-            scope: 'epic:T010',
-            autoStart: true,
-        });
-        expect(startResult.success).toBe(true);
-        // Verify status shows active
-        const statusResult = await sessionStatus(testDir);
-        expect(statusResult.success).toBe(true);
-        expect(statusResult.data.hasActiveSession).toBe(true);
-        // End session
-        const endResult = await sessionEnd(testDir, 'Parity test done');
-        expect(endResult.success).toBe(true);
-        expect(endResult.data.ended).toBe(true);
-    });
-    it('taskStart and taskStop delegate to core/task-work/', async () => {
-        const { taskStart, taskStop, taskCurrentGet } = await import('../../dispatch/engines/session-engine.js');
-        // Start working on a task
-        const startResult = await taskStart(testDir, 'T010');
-        expect(startResult.success).toBe(true);
-        expect(startResult.data.taskId).toBe('T010');
-        // Verify current task is set
-        const currentResult = await taskCurrentGet(testDir);
-        expect(currentResult.success).toBe(true);
-        expect(currentResult.data.currentTask).toBe('T010');
-        // Stop working
-        const stopResult = await taskStop(testDir);
-        expect(stopResult.success).toBe(true);
-        expect(stopResult.data.cleared).toBe(true);
-    });
-});
-// ============================================================================
-// Section 4: Lifecycle Engine Parity
-//
-// Verifies lifecycle-engine.ts functions produce valid EngineResult wrappers
-// and use core lifecycle constants.
-// ============================================================================
-describe('Lifecycle Engine Parity (T4796)', () => {
-    let testDir;
-    let cleoDir;
-    beforeEach(async () => {
-        testDir = await mkdtemp(join(tmpdir(), 'cleo-lifecycle-'));
-        cleoDir = join(testDir, '.cleo');
-        await mkdir(cleoDir, { recursive: true });
-        await mkdir(join(cleoDir, 'rcasd', 'T100'), { recursive: true });
-        process.env['CLEO_DIR'] = cleoDir;
-        initLogger(cleoDir, {
-            level: 'fatal',
-            filePath: 'logs/test.log',
-            maxFileSize: 1024 * 1024,
-            maxFiles: 1,
-        });
-    });
-    afterEach(async () => {
-        await closeLogger();
-        delete process.env['CLEO_DIR'];
-        try {
-            const { closeAllDatabases } = await import('../store/sqlite.js');
-            await closeAllDatabases();
-        }
-        catch {
-            /* ignore */
-        }
-        await Promise.race([
-            rm(testDir, { recursive: true, force: true }).catch(() => { }),
-            new Promise((resolve) => setTimeout(resolve, 8_000)),
-        ]);
-    });
-    it('lifecycle-engine uses PIPELINE_STAGES from core/lifecycle/', async () => {
-        const engineMod = await import('../../dispatch/engines/lifecycle-engine.js');
-        const coreMod = await import('../lifecycle/index.js');
-        // Engine function uses PIPELINE_STAGES from core for status
-        const result = await engineMod.lifecycleStatus('NONEXISTENT', testDir);
-        expect(result.success).toBe(true);
-        const data = result.data;
-        const engineStageNames = data.stages.map((s) => s.stage);
-        expect(engineStageNames).toEqual([...coreMod.PIPELINE_STAGES]);
-    });
-    it('lifecycleStatus returns valid result for uninitialized epic', async () => {
-        const { lifecycleStatus } = await import('../../dispatch/engines/lifecycle-engine.js');
-        const result = await lifecycleStatus('T100', testDir);
-        expect(result.success).toBe(true);
-        expect(result.data).toBeDefined();
-        const data = result.data;
-        expect(data.epicId).toBe('T100');
-        expect(data.initialized).toBe(false);
-        expect(data.nextStage).toBe('research');
-        expect(Array.isArray(data.stages)).toBe(true);
-    });
-    it('lifecycleProgress records stage and lifecycleStatus reflects it', async () => {
-        const { lifecycleProgress, lifecycleStatus } = await import('../../dispatch/engines/lifecycle-engine.js');
-        // Record research as completed
-        const progressResult = await lifecycleProgress('T100', 'research', 'completed', 'Research done', testDir);
-        expect(progressResult.success).toBe(true);
-        const progressData = progressResult.data;
-        expect(progressData.recorded).toBe(true);
-        expect(progressData.stage).toBe('research');
-        // Now check status reflects it
-        const statusResult = await lifecycleStatus('T100', testDir);
-        expect(statusResult.success).toBe(true);
-        const statusData = statusResult.data;
-        expect(statusData.initialized).toBe(true);
-        expect(statusData.currentStage).toBe('research');
-    });
-    it('lifecyclePrerequisites returns valid data', async () => {
-        const { lifecyclePrerequisites } = await import('../../dispatch/engines/lifecycle-engine.js');
-        const result = await lifecyclePrerequisites('specification', testDir);
-        expect(result.success).toBe(true);
-        const data = result.data;
-        expect(data.targetStage).toBe('specification');
-        expect(Array.isArray(data.prerequisites)).toBe(true);
-    });
-    it('lifecycleCheck validates prerequisites correctly', async () => {
-        const { lifecycleCheck, lifecycleProgress } = await import('../../dispatch/engines/lifecycle-engine.js');
-        // Check specification without completing research
-        const checkResult = await lifecycleCheck('T100', 'specification', testDir);
-        expect(checkResult.success).toBe(true);
-        const checkData = checkResult.data;
-        // specification requires research (at minimum), so should not be valid
-        expect(checkData.valid).toBe(false);
-        expect(checkData.missingPrerequisites.length).toBeGreaterThan(0);
-        // Complete research
-        await lifecycleProgress('T100', 'research', 'completed', 'Done', testDir);
-        // Now the gate for consensus should be valid
-        const checkAfter = await lifecycleCheck('T100', 'consensus', testDir);
-        expect(checkAfter.success).toBe(true);
-        const afterData = checkAfter.data;
-        expect(afterData.valid).toBe(true);
-    });
-    it('lifecycleSkip records skip with reason', async () => {
-        const { lifecycleSkip, lifecycleHistory } = await import('../../dispatch/engines/lifecycle-engine.js');
-        const skipResult = await lifecycleSkip('T100', 'consensus', 'Solo developer, no consensus needed', testDir);
-        expect(skipResult.success).toBe(true);
-        const skipData = skipResult.data;
-        expect(skipData.skipped).toBe(true);
-        // History should include the skip
-        const histResult = await lifecycleHistory('T100', testDir);
-        expect(histResult.success).toBe(true);
-        const histData = histResult.data;
-        const skipEntry = histData.history.find((h) => h.stage === 'consensus' && h.action === 'skipped');
-        expect(skipEntry).toBeDefined();
-    });
-});
-// ============================================================================
-// Section 5: EngineResult Wrapper Consistency
-//
-// Verifies that all engine functions return properly structured EngineResult
-// objects with consistent shape.
-// ============================================================================
-describe('EngineResult Wrapper Consistency (T4796)', () => {
-    /**
-     * Verify EngineResult shape: { success, data?, error? }
-     */
-    function assertEngineResult(result) {
-        expect(result).toBeDefined();
-        const r = result;
-        expect(typeof r.success).toBe('boolean');
-        if (r.success) {
-            expect(r.data).toBeDefined();
-            // success results should not have error
-            expect(r.error).toBeUndefined();
-        }
-        else {
-            expect(r.error).toBeDefined();
-            const err = r.error;
-            expect(typeof err.code).toBe('string');
-            expect(typeof err.message).toBe('string');
-        }
-    }
-    it('task engine error results have E_ prefixed codes', async () => {
-        const { taskShow } = await import('../../dispatch/engines/task-engine.js');
-        // This will fail because no project dir is set up
-        const result = await taskShow('/nonexistent', 'T999');
-        assertEngineResult(result);
-        if (!result.success) {
-            expect(result.error.code).toMatch(/^E_/);
-        }
-    });
-    it('session engine error results have E_ prefixed codes', async () => {
-        const { sessionStatus } = await import('../../dispatch/engines/session-engine.js');
-        const result = await sessionStatus('/nonexistent');
-        assertEngineResult(result);
-        if (!result.success) {
-            expect(result.error.code).toMatch(/^E_/);
-        }
-    });
-    it('lifecycle engine error results have E_ prefixed codes', async () => {
-        const { lifecycleStatus } = await import('../../dispatch/engines/lifecycle-engine.js');
-        // Empty epicId should fail
-        const result = await lifecycleStatus('');
-        assertEngineResult(result);
-        if (!result.success) {
-            expect(result.error.code).toMatch(/^E_/);
-        }
-    });
-});
-//# sourceMappingURL=core-parity.test.js.map