@cleocode/core 2026.4.6 → 2026.4.9

package/src/lifecycle/__tests__/pipeline.integration.test.js

@@ -1,977 +0,0 @@
-/**
- * RCASD-IVTR+C Pipeline Integration Test
- *
- * End-to-end test exercising the full RCASD-IVTR+C lifecycle through all 9 stages.
- * This is the final validation test for epic T4798.
- *
- * Test Coverage:
- * 1. Full pipeline flow through all 9 stages
- * 2. Gate enforcement (blocking and allowing transitions)
- * 3. Evidence recording across stages
- * 4. Cross-session resume capability
- * 5. Pipeline completion verification
- *
- * @task T4806
- * @epic T4798
- * @audit T4799 - Validates unified pipeline implementation
- */
-import { mkdir, mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-// Legacy lifecycle (for cross-session resume testing)
-import { failGate, getLifecycleHistory, getLifecycleStatus, passGate, recordStageProgress, } from '../index.js';
-// Pipeline (stub implementations - validates expected behavior)
-import { advanceStage, cancelPipeline, completePipeline, getCurrentStage, getPipeline, initializePipeline, } from '../pipeline.js';
-// Stage definitions
-import { checkTransition as checkTransitionRaw, getPrerequisites as getPrerequisitesRaw, PIPELINE_STAGES, STAGE_DEFINITIONS as STAGE_DEFINITIONS_RAW, STAGE_ORDER as STAGE_ORDER_RAW, } from '../stages.js';
-// State machine (fully implemented)
-import { checkPrerequisites as checkPrerequisitesRaw, createInitialContext, executeTransition as executeTransitionRaw, getCurrentStageState, getValidNextStages, isBlocked, isTerminalState, setStageStatus as setStageStatusRaw, skipStage as skipStageRaw, validateTransition as validateTransitionRaw, } from '../state-machine.js';
-let testDir;
-let cleoDir;
-async function ensureTaskExists(taskId) {
-    const { getDb, getNativeDb } = await import('../../store/sqlite.js');
-    await getDb();
-    getNativeDb()
-        .prepare(`INSERT OR IGNORE INTO tasks (id, title, status, priority, created_at) VALUES (?, ?, 'pending', 'medium', datetime('now'))`)
-        .run(taskId, `Task ${taskId}`);
-}
-const LEGACY_TO_CANONICAL = {
-    adr: 'architecture_decision',
-    spec: 'specification',
-    decompose: 'decomposition',
-    implement: 'implementation',
-    verify: 'validation',
-    test: 'testing',
-};
-const CANONICAL_TO_LEGACY = {
-    architecture_decision: 'adr',
-    specification: 'spec',
-    decomposition: 'decompose',
-    implementation: 'implement',
-    validation: 'verify',
-    testing: 'test',
-};
-function toCanonical(stage) {
-    return (LEGACY_TO_CANONICAL[stage] ?? stage);
-}
-function toLegacy(stage) {
-    return CANONICAL_TO_LEGACY[stage] ?? stage;
-}
-function addLegacyAliases(context) {
-    const stages = context.stages;
-    for (const [legacy, canonical] of Object.entries(LEGACY_TO_CANONICAL)) {
-        stages[legacy] = stages[canonical];
-    }
-    return {
-        ...context,
-        stages: stages,
-    };
-}
-function executeTransition(transition, context) {
-    return executeTransitionRaw({
-        ...transition,
-        from: toCanonical(transition.from),
-        to: toCanonical(transition.to),
-    }, context).then((result) => ({
-        ...result,
-        context: addLegacyAliases(result.context),
-    }));
-}
-function validateTransition(transition, context) {
-    return validateTransitionRaw({
-        ...transition,
-        from: toCanonical(transition.from),
-        to: toCanonical(transition.to),
-    }, context);
-}
-function checkPrerequisites(stage, stages) {
-    return checkPrerequisitesRaw(toCanonical(stage), stages);
-}
-function setStageStatus(stage, status, context) {
-    const canonical = toCanonical(stage);
-    const next = setStageStatusRaw(canonical, status, context);
-    context.stages[canonical] = next;
-    context.stages[stage] = next;
-    return next;
-}
-function skipStage(stage, reason, context) {
-    return skipStageRaw(toCanonical(stage), reason, context);
-}
-const STAGE_ORDER = new Proxy(STAGE_ORDER_RAW, {
-    get(target, prop) {
-        return target[toCanonical(prop)];
-    },
-});
-const STAGE_DEFINITIONS = new Proxy(STAGE_DEFINITIONS_RAW, {
-    get(target, prop) {
-        return target[toCanonical(prop)];
-    },
-});
-function getPrerequisites(stage) {
-    return getPrerequisitesRaw(toCanonical(stage));
-}
-function checkTransition(from, to, force) {
-    return checkTransitionRaw(toCanonical(from), toCanonical(to), force);
-}
-describe('RCASD-IVTR+C Pipeline Integration', () => {
-    beforeEach(async () => {
-        testDir = await mkdtemp(join(tmpdir(), 'cleo-pipeline-test-'));
-        cleoDir = join(testDir, '.cleo');
-        await mkdir(cleoDir, { recursive: true });
-        await mkdir(join(cleoDir, 'rcasd'), { recursive: true });
-        await mkdir(join(cleoDir, 'backups', 'operational'), { recursive: true });
-        process.env['CLEO_DIR'] = cleoDir;
-        process.env['LIFECYCLE_ENFORCEMENT_MODE'] = 'off';
-    });
-    afterEach(async () => {
-        // Close ALL SQLite connections before cleanup — Windows locks open files
-        try {
-            const { closeAllDatabases } = await import('../../store/sqlite.js');
-            await closeAllDatabases();
-        }
-        catch {
-            /* module may not be loaded */
-        }
-        delete process.env['CLEO_DIR'];
-        delete process.env['LIFECYCLE_ENFORCEMENT_MODE'];
-        await rm(testDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    // =============================================================================
-    // FULL PIPELINE FLOW TEST
-    // =============================================================================
-    describe('full pipeline flow through all 9 stages', () => {
-        it('should complete all 9 stages with state machine transitions', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            // Stage 1: Research
-            expect(context.currentStage).toBe('research');
-            expect(context.stages['research'].status).toBe('in_progress');
-            // Mark research as completed before transitioning
-            context.stages['research'] = setStageStatus('research', 'completed', context);
-            // Complete research and transition to consensus
-            const researchTransition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            let result = await executeTransition(researchTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('consensus');
-            expect(context.stages['research'].status).toBe('completed');
-            // Stage 2: Consensus - mark as completed and transition to architecture_decision
-            context.stages['consensus'] = setStageStatus('consensus', 'completed', context);
-            const consensusTransition = {
-                from: 'consensus',
-                to: 'architecture_decision',
-                initiatedBy: 'test-agent',
-            };
-            result = await executeTransition(consensusTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('architecture_decision');
-            // Stage 3: ADR - mark as completed and transition to specification
-            context.stages['architecture_decision'] = setStageStatus('architecture_decision', 'completed', context);
-            const adrTransition = {
-                from: 'architecture_decision',
-                to: 'specification',
-                initiatedBy: 'test-agent',
-            };
-            result = await executeTransition(adrTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('specification');
-            // Stage 4: Spec - mark as completed and transition to decomposition
-            context.stages['specification'] = setStageStatus('specification', 'completed', context);
-            const specTransition = {
-                from: 'specification',
-                to: 'decomposition',
-                initiatedBy: 'test-agent',
-            };
-            result = await executeTransition(specTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('decomposition');
-            // Stage 5: Decompose - mark as completed and transition to implementation
-            context.stages['decomposition'] = setStageStatus('decomposition', 'completed', context);
-            const decomposeTransition = {
-                from: 'decomposition',
-                to: 'implementation',
-                initiatedBy: 'test-agent',
-            };
-            result = await executeTransition(decomposeTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('implementation');
-            // Stage 6: Implement - mark as completed and transition to validation
-            context.stages['implementation'] = setStageStatus('implementation', 'completed', context);
-            const implementTransition = {
-                from: 'implementation',
-                to: 'validation',
-                initiatedBy: 'test-agent',
-            };
-            result = await executeTransition(implementTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('validation');
-            // Stage 7: Verify - mark as completed and transition to testing
-            context.stages['validation'] = setStageStatus('validation', 'completed', context);
-            const verifyTransition = {
-                from: 'validation',
-                to: 'testing',
-                initiatedBy: 'test-agent',
-            };
-            result = await executeTransition(verifyTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('testing');
-            // Stage 8: Test - mark as completed and transition to release
-            context.stages['testing'] = setStageStatus('testing', 'completed', context);
-            const testTransition = {
-                from: 'testing',
-                to: 'release',
-                initiatedBy: 'test-agent',
-            };
-            result = await executeTransition(testTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            expect(context.currentStage).toBe('release');
-            // Stage 9: Release - complete it
-            const releaseState = setStageStatus('release', 'completed', context);
-            context.stages['release'] = releaseState;
-            // Verify all stages completed
-            expect(context.stages['research'].status).toBe('completed');
-            expect(context.stages['consensus'].status).toBe('completed');
-            expect(context.stages['architecture_decision'].status).toBe('completed');
-            expect(context.stages['specification'].status).toBe('completed');
-            expect(context.stages['decomposition'].status).toBe('completed');
-            expect(context.stages['implementation'].status).toBe('completed');
-            expect(context.stages['validation'].status).toBe('completed');
-            expect(context.stages['testing'].status).toBe('completed');
-            expect(context.stages['release'].status).toBe('completed');
-            // Verify terminal state
-            expect(isTerminalState(context)).toBe(true);
-            expect(context.transitionCount).toBe(8);
-        });
-        it('should track stage order correctly', () => {
-            expect(STAGE_ORDER['research']).toBe(1);
-            expect(STAGE_ORDER['consensus']).toBe(2);
-            expect(STAGE_ORDER['adr']).toBe(3);
-            expect(STAGE_ORDER['spec']).toBe(4);
-            expect(STAGE_ORDER['decompose']).toBe(5);
-            expect(STAGE_ORDER['implement']).toBe(6);
-            expect(STAGE_ORDER['verify']).toBe(7);
-            expect(STAGE_ORDER['test']).toBe(8);
-            expect(STAGE_ORDER['release']).toBe(9);
-        });
-        it('should have correct stage definitions for all 9 stages', () => {
-            expect(STAGE_DEFINITIONS['research'].order).toBe(1);
-            expect(STAGE_DEFINITIONS['consensus'].order).toBe(2);
-            expect(STAGE_DEFINITIONS['adr'].order).toBe(3);
-            expect(STAGE_DEFINITIONS['spec'].order).toBe(4);
-            expect(STAGE_DEFINITIONS['decompose'].order).toBe(5);
-            expect(STAGE_DEFINITIONS['implement'].order).toBe(6);
-            expect(STAGE_DEFINITIONS['verify'].order).toBe(7);
-            expect(STAGE_DEFINITIONS['test'].order).toBe(8);
-            expect(STAGE_DEFINITIONS['release'].order).toBe(9);
-        });
-    });
-    // =============================================================================
-    // GATE ENFORCEMENT TESTS
-    // =============================================================================
-    describe('gate enforcement blocks invalid transitions', () => {
-        it('should block transition when prerequisites are not met', async () => {
-            const pipelineId = 'T4806';
-            const context = createInitialContext(pipelineId, 'test-agent');
-            // Try to skip ahead to implementation without completing decomposition
-            const invalidTransition = {
-                from: 'research',
-                to: 'implementation',
-                initiatedBy: 'test-agent',
-            };
-            const validation = await validateTransition(invalidTransition, context);
-            expect(validation.valid).toBe(false);
-            expect(validation.errors.length).toBeGreaterThan(0);
-            expect(validation.prerequisitesMet).toBe(false);
-        });
-        it('should block backward transitions without force flag', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            // Mark research as completed before transitioning
-            context.stages['research'] = setStageStatus('research', 'completed', context);
-            // Move to consensus
-            const transition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            const result = await executeTransition(transition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            // Try to go back to research without force
-            const backwardTransition = {
-                from: 'consensus',
-                to: 'research',
-                initiatedBy: 'test-agent',
-            };
-            const validation = await validateTransition(backwardTransition, context);
-            expect(validation.valid).toBe(false);
-            expect(validation.requiresForce).toBe(true);
-        });
-        it('should require force to skip non-skippable stages', async () => {
-            const check = checkTransition('research', 'spec', false);
-            // spec requires force because it would skip consensus and adr
-            expect(check.requiresForce).toBe(true);
-        });
-        it('should detect blocked state correctly', async () => {
-            const pipelineId = 'T4806';
-            const context = createInitialContext(pipelineId, 'test-agent');
-            expect(isBlocked(context)).toBe(false);
-            // Set research as blocked
-            context.stages['research'].status = 'blocked';
-            expect(isBlocked(context)).toBe(true);
-        });
-        it('should validate prerequisite requirements per stage', () => {
-            // Research has no prerequisites
-            expect(getPrerequisites('research')).toEqual([]);
-            // Consensus requires research
-            expect(getPrerequisites('consensus')).toContain('research');
-            // Spec requires research, consensus, adr
-            const specPrereqs = getPrerequisites('spec');
-            expect(specPrereqs).toContain('research');
-            expect(specPrereqs).toContain('consensus');
-            expect(specPrereqs).toContain('architecture_decision');
-            // Implement requires research, spec, decompose
-            const implementPrereqs = getPrerequisites('implement');
-            expect(implementPrereqs).toContain('research');
-            expect(implementPrereqs).toContain('specification');
-            expect(implementPrereqs).toContain('decomposition');
-        });
-    });
-    describe('gate enforcement allows valid transitions', () => {
-        it('should allow sequential progression with prerequisites met', async () => {
-            const pipelineId = 'T4806';
-            const context = createInitialContext(pipelineId, 'test-agent');
-            // Mark research as completed
-            context.stages['research'] = setStageStatus('research', 'completed', context);
-            // Complete research
-            const transition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            const validation = await validateTransition(transition, context);
-            expect(validation.valid).toBe(true);
-            expect(validation.ruleAllowed).toBe(true);
-            expect(validation.prerequisitesMet).toBe(true);
-        });
-        it('should allow skipping optional stages', async () => {
-            const pipelineId = 'T4806';
-            const context = createInitialContext(pipelineId, 'test-agent');
-            // Mark consensus as skipped (it's skippable)
-            context.stages['consensus'] = skipStage('consensus', 'Not needed', context);
-            context.stages['consensus'].status = 'skipped';
-            // Now try to transition to adr (prerequisite is research, which is in_progress)
-            // First complete research
-            context.stages['research'].status = 'completed';
-            context.stages['research'].completedAt = new Date();
-            const transition = {
-                from: 'research',
-                to: 'architecture_decision',
-                initiatedBy: 'test-agent',
-            };
-            const validation = await validateTransition(transition, context);
-            // architecture_decision requires research and consensus - consensus is skipped which is acceptable
-            expect(validation.prerequisitesMet).toBe(true);
-        });
-        it('should allow backward transition with force flag', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            // Mark research as completed before transitioning
-            context.stages['research'] = setStageStatus('research', 'completed', context);
-            // Move forward
-            const forwardTransition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            let result = await executeTransition(forwardTransition, context);
-            expect(result.success).toBe(true);
-            context = result.context;
-            // Mark consensus as completed before going back
-            context.stages['consensus'] = setStageStatus('consensus', 'completed', context);
-            // Go back with force
-            const backwardTransition = {
-                from: 'consensus',
-                to: 'research',
-                initiatedBy: 'test-agent',
-                force: true,
-            };
-            result = await executeTransition(backwardTransition, context);
-            expect(result.success).toBe(true);
-            expect(result.context.currentStage).toBe('research');
-        });
-        it('should identify valid next stages', () => {
-            const pipelineId = 'T4806';
-            const context = createInitialContext(pipelineId, 'test-agent');
-            const validNext = getValidNextStages(context, false);
-            expect(validNext).toContain('consensus');
-        });
-    });
-    // =============================================================================
-    // EVIDENCE RECORDING TESTS
-    // =============================================================================
-    describe('evidence recording works across stages', () => {
-        it('should record stage completion timestamps', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            const beforeTime = new Date();
-            // Mark research as completed before transitioning
-            context.stages['research'] = setStageStatus('research', 'completed', context);
-            const transition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            const result = await executeTransition(transition, context);
-            context = result.context;
-            const researchCompletedAt = context.stages['research'].completedAt;
-            expect(researchCompletedAt).toBeDefined();
-            expect(researchCompletedAt.getTime()).toBeGreaterThanOrEqual(beforeTime.getTime());
-        });
-        it('should record gate results with timestamp [T4801 SQLite-native]', async () => {
-            // T4801: Now uses SQLite-native gate tracking
-            const epicId = 'T4806';
-            const gateResult = await passGate(epicId, 'research-prerequisites-met', 'test-agent', 'All prerequisites verified', testDir);
-            expect(gateResult.epicId).toBe(epicId);
-            expect(gateResult.gateName).toBe('research-prerequisites-met');
-            expect(gateResult.timestamp).toBeDefined();
-        });
-        it('should record failed gate with reason [T4801 SQLite-native]', async () => {
-            // T4801: Now uses SQLite-native gate tracking
-            const epicId = 'T4806';
-            const gateResult = await failGate(epicId, 'specification-incomplete', 'Missing acceptance criteria', testDir);
-            expect(gateResult.epicId).toBe(epicId);
-            expect(gateResult.gateName).toBe('specification-incomplete');
-            expect(gateResult.reason).toBe('Missing acceptance criteria');
-        });
-        it('should maintain stage state metadata', () => {
-            const pipelineId = 'T4806';
-            const context = createInitialContext(pipelineId, 'test-agent');
-            expect(context.stages['research'].assignedAgent).toBe('test-agent');
-            expect(context.stages['research'].status).toBe('in_progress');
-            expect(context.stages['research'].startedAt).toBeDefined();
-        });
-        it('should track transition count', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            expect(context.transitionCount).toBe(0);
-            expect(context.version).toBe(1);
-            // Mark research as completed before transitioning
-            context.stages['research'] = setStageStatus('research', 'completed', context);
-            const transition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            const result = await executeTransition(transition, context);
-            context = result.context;
-            expect(context.transitionCount).toBe(1);
-        });
-    });
-    // =============================================================================
-    // CROSS-SESSION RESUME TESTS
-    // =============================================================================
-    describe('cross-session resume preserves context', () => {
-        it('should restore pipeline state from SQLite [T4801]', async () => {
-            // T4801: Now uses SQLite-native storage
-            const epicId = 'T4806';
-            // Simulate session A: progress through some stages
-            await recordStageProgress(epicId, 'research', 'completed', 'Initial research done', testDir);
-            await recordStageProgress(epicId, 'consensus', 'completed', 'Consensus reached', testDir);
-            await recordStageProgress(epicId, 'architecture_decision', 'skipped', 'Simple change, no ADR needed', testDir);
-            await recordStageProgress(epicId, 'specification', 'completed', 'Spec written', testDir);
-            // Simulate session B: read state and continue
-            const status = await getLifecycleStatus(epicId, testDir);
-            expect(status.initialized).toBe(true);
-            expect(status.currentStage).toBe('specification');
-            // Continue in session B
-            await recordStageProgress(epicId, 'decomposition', 'completed', 'Task breakdown complete', testDir);
-            const updatedStatus = await getLifecycleStatus(epicId, testDir);
-            expect(updatedStatus.currentStage).toBe('decomposition');
-        });
-        it('should preserve gate results across sessions [T4801]', async () => {
-            // T4801: Now uses SQLite-native storage
-            const epicId = 'T4806';
-            // Session A: record gate passes
-            await passGate(epicId, 'research-complete', 'agent-a', 'Research verified', testDir);
-            await passGate(epicId, 'specification-reviewed', 'agent-a', 'Spec approved', testDir);
-            // Session B: verify gates are still recorded
-            const history = await getLifecycleHistory(epicId, testDir);
-            const gateEvents = history.history.filter((h) => h.action.startsWith('gate.'));
-            expect(gateEvents.length).toBe(2);
-        });
-        it('should maintain stage timestamps across sessions [T4801]', async () => {
-            // T4801: Now uses SQLite-native storage
-            const epicId = 'T4806';
-            const beforeTime = new Date().toISOString();
-            // Record progress
-            await recordStageProgress(epicId, 'research', 'completed', undefined, testDir);
-            // Verify timestamp is recorded
-            const status = await getLifecycleStatus(epicId, testDir);
-            const researchStage = status.stages.find((s) => s.stage === 'research');
-            expect(researchStage?.completedAt).toBeDefined();
-            expect(Date.parse(researchStage?.completedAt ?? '')).toBeGreaterThanOrEqual(Date.parse(beforeTime));
-        });
-        it('should track full history across sessions [T4801]', async () => {
-            // T4801: Now uses SQLite-native storage
-            const epicId = 'T4806';
-            // Complete several stages
-            await recordStageProgress(epicId, 'research', 'completed', undefined, testDir);
-            await recordStageProgress(epicId, 'consensus', 'skipped', 'Single agent', testDir);
-            await recordStageProgress(epicId, 'specification', 'completed', undefined, testDir);
-            const history = await getLifecycleHistory(epicId, testDir);
-            const completedActions = history.history.filter((h) => h.action === 'completed');
-            expect(completedActions.length).toBe(2); // research and specification
-            expect(history.history.some((h) => h.action === 'skipped')).toBe(true);
-        });
-    });
-    // =============================================================================
-    // PIPELINE COMPLETION TESTS
-    // =============================================================================
-    describe('pipeline completion marks all stages correctly', () => {
-        it('should mark all stages as completed when pipeline completes', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            // Progress through all stages
-            const stages = [
-                'research',
-                'consensus',
-                'architecture_decision',
-                'specification',
-                'decomposition',
-                'implementation',
-                'validation',
-                'testing',
-            ];
-            for (let i = 0; i < stages.length - 1; i++) {
-                const from = stages[i];
-                const to = stages[i + 1];
-                // Mark source stage as in-progress then completed before transitioning
-                context.stages[from] = setStageStatus(from, 'in_progress', context);
-                context.stages[from] = setStageStatus(from, 'completed', context);
-                const transition = {
-                    from,
-                    to,
-                    initiatedBy: 'test-agent',
-                };
-                const result = await executeTransition(transition, context);
-                if (!result.success) {
-                    throw new Error(`Transition from ${from} to ${to} failed: ${result.errors?.join(', ')}`);
-                }
-                context = result.context;
-            }
-            // Mark testing stage as completed and transition to release
-            const now = new Date();
-            context.stages['testing'] = setStageStatus('testing', 'in_progress', context);
-            context.stages['testing'] = setStageStatus('testing', 'completed', context);
-            const finalTransition = {
-                from: 'testing',
-                to: 'release',
-                initiatedBy: 'test-agent',
-            };
-            const finalResult = await executeTransition(finalTransition, context);
-            if (!finalResult.success) {
-                throw new Error(`Final transition from test to release failed: ${finalResult.errors?.join(', ')}`);
-            }
-            context = finalResult.context;
-            // Stage 9: Release - complete it (bypass transition validation)
-            context.stages['release'] = setStageStatus('release', 'completed', context);
-            // Verify all stages completed
-            expect(context.stages['research'].status).toBe('completed');
-            expect(context.stages['consensus'].status).toBe('completed');
-            expect(context.stages['architecture_decision'].status).toBe('completed');
-            expect(context.stages['specification'].status).toBe('completed');
-            expect(context.stages['decomposition'].status).toBe('completed');
-            expect(context.stages['implementation'].status).toBe('completed');
-            expect(context.stages['validation'].status).toBe('completed');
-            expect(context.stages['testing'].status).toBe('completed');
-            expect(context.stages['release'].status).toBe('completed');
-            // Verify terminal state
-            expect(isTerminalState(context)).toBe(true);
-            expect(context.transitionCount).toBe(8);
-        });
-        it('should calculate terminal state correctly', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            expect(isTerminalState(context)).toBe(false);
-            // Progress through all stages
-            const stages = [
-                'research',
-                'consensus',
-                'architecture_decision',
-                'specification',
-                'decomposition',
-                'implementation',
-                'validation',
-                'testing',
-                'release',
-            ];
-            for (let i = 0; i < stages.length - 1; i++) {
-                const from = stages[i];
-                const to = stages[i + 1];
-                // Mark from stage as in-progress then completed before transitioning
-                context.stages[from] = setStageStatus(from, 'in_progress', context);
-                context.stages[from] = setStageStatus(from, 'completed', context);
-                const transition = {
-                    from,
-                    to,
-                    initiatedBy: 'test-agent',
-                };
-                const result = await executeTransition(transition, context);
-                context = result.context;
-            }
-            // Complete release
-            context.stages['release'] = setStageStatus('release', 'completed', context);
-            expect(isTerminalState(context)).toBe(true);
-        });
-        it('should update transition count correctly', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            expect(context.transitionCount).toBe(0);
-            expect(context.version).toBe(1);
-            // Make 3 transitions
-            const transitions = [
-                ['research', 'consensus'],
-                ['consensus', 'architecture_decision'],
-                ['architecture_decision', 'specification'],
-            ];
-            for (const [from, to] of transitions) {
-                // Mark from stage as in-progress then completed before transitioning
-                context.stages[from] = setStageStatus(from, 'in_progress', context);
-                context.stages[from] = setStageStatus(from, 'completed', context);
-                const transition = {
-                    from,
-                    to,
-                    initiatedBy: 'test-agent',
-                };
-                const result = await executeTransition(transition, context);
-                context = result.context;
-            }
-            expect(context.transitionCount).toBe(3);
-            expect(context.version).toBe(4);
-        });
-        it('should provide correct final context state', async () => {
-            const pipelineId = 'T4806';
-            let context = createInitialContext(pipelineId, 'test-agent');
-            // Progress through all stages
-            const stages = [
-                'research',
-                'consensus',
-                'architecture_decision',
-                'specification',
-                'decomposition',
-                'implementation',
-                'validation',
-                'testing',
-                'release',
-            ];
-            for (let i = 0; i < stages.length - 1; i++) {
-                const from = stages[i];
-                const to = stages[i + 1];
-                // Mark from stage as in-progress then completed before transitioning
-                context.stages[from] = setStageStatus(from, 'in_progress', context);
-                context.stages[from] = setStageStatus(from, 'completed', context);
-                const transition = {
-                    from,
-                    to,
-                    initiatedBy: 'test-agent',
-                };
-                const result = await executeTransition(transition, context);
-                context = result.context;
-            }
-            context.stages['release'] = setStageStatus('release', 'completed', context);
-            // Verify final state
-            expect(context.pipelineId).toBe(pipelineId);
-            expect(context.currentStage).toBe('release');
-            expect(context.transitionCount).toBe(8);
-            expect(isTerminalState(context)).toBe(true);
-            // Verify stage states
-            const currentStageState = getCurrentStageState(context);
-            expect(currentStageState.stage).toBe('release');
-            expect(currentStageState.status).toBe('completed');
-        });
-    });
-    // =============================================================================
-    // PIPELINE STUB VALIDATION TESTS (T4800)
-    // =============================================================================
-    describe('pipeline stub implementations (T4800)', () => {
-        it('initializePipeline should return valid pipeline structure', async () => {
-            await ensureTaskExists('T4806');
-            const pipeline = await initializePipeline('T4806', {
-                startStage: 'research',
-                assignedAgent: 'test-agent',
-            });
-            expect(pipeline.id).toBe('T4806');
-            expect(pipeline.currentStage).toBe('research');
-            expect(pipeline.status).toBe('active');
-            expect(pipeline.isActive).toBe(true);
-            expect(pipeline.version).toBe(1);
-            expect(pipeline.transitionCount).toBe(0);
-        });
-        it('initializePipeline should accept custom start stage', async () => {
-            await ensureTaskExists('T4806');
-            const pipeline = await initializePipeline('T4806', {
-                startStage: 'specification',
-            });
-            expect(pipeline.currentStage).toBe('specification');
-        });
-        it('getPipeline should return null for non-existent pipeline (stub)', async () => {
-            const pipeline = await getPipeline('T99999');
-            expect(pipeline).toBeNull();
-        });
-        it('advanceStage should validate required parameters', async () => {
-            // Missing toStage
-            await expect(advanceStage('T4806', { initiatedBy: 'test-agent' })).rejects.toThrow('target stage');
-            // Missing initiatedBy
-            await expect(advanceStage('T4806', { toStage: 'consensus' })).rejects.toThrow('initiatedBy');
-        });
-        it('getCurrentStage should throw when pipeline not found (stub)', async () => {
-            // The stub getPipeline returns null, so getCurrentStage throws NOT_FOUND
-            await expect(getCurrentStage('T4806')).rejects.toThrow('No pipeline found');
-        });
-        it('completePipeline should validate input (stub)', async () => {
-            await expect(completePipeline('T4806', 'All stages completed')).rejects.toThrow('No pipeline found');
-        });
-        it('cancelPipeline should validate input (stub)', async () => {
-            await expect(cancelPipeline('T4806', 'Cancelled for testing')).rejects.toThrow('No pipeline found');
-        });
-    });
-    // =============================================================================
-    // STAGE DEFINITION VALIDATION TESTS
-    // =============================================================================
-    describe('stage definition validation', () => {
-        it('should have 9 pipeline stages', () => {
-            expect(PIPELINE_STAGES.length).toBe(9);
-        });
-        it('should have correct stage categories', () => {
-            expect(STAGE_DEFINITIONS['research'].category).toBe('planning');
-            expect(STAGE_DEFINITIONS['consensus'].category).toBe('decision');
-            expect(STAGE_DEFINITIONS['adr'].category).toBe('decision');
-            expect(STAGE_DEFINITIONS['spec'].category).toBe('planning');
-            expect(STAGE_DEFINITIONS['decompose'].category).toBe('planning');
-            expect(STAGE_DEFINITIONS['implement'].category).toBe('execution');
-            expect(STAGE_DEFINITIONS['verify'].category).toBe('validation');
-            expect(STAGE_DEFINITIONS['test'].category).toBe('validation');
-            expect(STAGE_DEFINITIONS['release'].category).toBe('delivery');
-        });
-        it('should have correct skippable flags', () => {
-            expect(STAGE_DEFINITIONS['research'].skippable).toBe(false);
-            expect(STAGE_DEFINITIONS['consensus'].skippable).toBe(true);
-            expect(STAGE_DEFINITIONS['adr'].skippable).toBe(true);
-            expect(STAGE_DEFINITIONS['spec'].skippable).toBe(false);
-            expect(STAGE_DEFINITIONS['decompose'].skippable).toBe(false);
-            expect(STAGE_DEFINITIONS['implement'].skippable).toBe(false);
-            expect(STAGE_DEFINITIONS['verify'].skippable).toBe(false);
-            expect(STAGE_DEFINITIONS['test'].skippable).toBe(false);
-            expect(STAGE_DEFINITIONS['release'].skippable).toBe(true);
-        });
-        it('should have expected artifacts defined for each stage', () => {
-            expect(STAGE_DEFINITIONS['research'].expectedArtifacts).toContain('research-report');
-            expect(STAGE_DEFINITIONS['spec'].expectedArtifacts).toContain('spec-document');
-            expect(STAGE_DEFINITIONS['implement'].expectedArtifacts).toContain('source-code');
-            expect(STAGE_DEFINITIONS['test'].expectedArtifacts).toContain('test-results');
-            expect(STAGE_DEFINITIONS['release'].expectedArtifacts).toContain('release-notes');
-        });
-        it('should have required gates defined for each stage', () => {
-            expect(STAGE_DEFINITIONS['research'].requiredGates).toContain('prerequisites-met');
-            expect(STAGE_DEFINITIONS['consensus'].requiredGates).toContain('research-complete');
-            expect(STAGE_DEFINITIONS['implement'].requiredGates).toContain('code-complete');
-            expect(STAGE_DEFINITIONS['test'].requiredGates).toContain('tests-pass');
-        });
-    });
-    // =============================================================================
-    // TRANSITION RULE VALIDATION TESTS
-    // =============================================================================
-    describe('transition rule validation', () => {
-        it('should allow all forward sequential transitions', () => {
-            const stages = [
-                'research',
-                'consensus',
-                'architecture_decision',
-                'specification',
-                'decomposition',
-                'implementation',
-                'validation',
-                'testing',
-                'release',
-            ];
-            for (let i = 0; i < stages.length - 1; i++) {
-                const from = stages[i];
-                const to = stages[i + 1];
-                const check = checkTransition(from, to, false);
-                expect(check.allowed).toBe(true);
-            }
-        });
-        it('should block release to any stage', () => {
-            const stages = [
-                'research',
-                'consensus',
-                'architecture_decision',
-                'specification',
-                'decomposition',
-                'implementation',
-                'validation',
-                'testing',
-            ];
-            for (const stage of stages) {
-                const check = checkTransition('release', stage, false);
-                expect(check.allowed).toBe(false);
-            }
-        });
-        it('should allow skipping with force', () => {
-            const check = checkTransition('research', 'spec', true);
-            expect(check.allowed).toBe(true);
-        });
-        it('should require force for backward transitions', () => {
-            const checkNoForce = checkTransition('implement', 'spec', false);
-            expect(checkNoForce.allowed).toBe(false);
-            expect(checkNoForce.requiresForce).toBe(true);
-            const checkWithForce = checkTransition('implement', 'spec', true);
-            expect(checkWithForce.allowed).toBe(true);
-        });
-    });
-    // =============================================================================
-    // INTEGRITY AND CONSISTENCY TESTS
-    // =============================================================================
-    describe('data integrity and consistency', () => {
-        it('should maintain immutable state during transitions', async () => {
-            const pipelineId = 'T4806';
-            const originalContext = createInitialContext(pipelineId, 'test-agent');
-            // Mark research as completed before transitioning
-            originalContext.stages['research'] = setStageStatus('research', 'completed', originalContext);
-            const transition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            const result = await executeTransition(transition, originalContext);
-            // Original context should be unchanged
-            expect(originalContext.currentStage).toBe('research');
-            expect(originalContext.stages['research'].status).toBe('completed');
-            // New context should reflect the transition
-            expect(result.context.currentStage).toBe('consensus');
-            expect(result.context.stages['research'].status).toBe('completed');
-        });
-        it('should handle concurrent transition attempts gracefully', async () => {
-            const pipelineId = 'T4806';
-            const context = createInitialContext(pipelineId, 'test-agent');
-            // Mark research as completed before transitioning
-            context.stages['research'] = setStageStatus('research', 'completed', context);
-            const transition = {
-                from: 'research',
-                to: 'consensus',
-                initiatedBy: 'test-agent',
-            };
-            // Execute same transition twice
-            const result1 = await executeTransition(transition, context);
-            const result2 = await executeTransition(transition, context);
-            // Both should succeed with fresh contexts
-            expect(result1.success).toBe(true);
-            expect(result2.success).toBe(true);
-            // But they should be independent
-            expect(result1.context).not.toBe(result2.context);
-        });
-        it('should validate all stage names are defined', () => {
-            for (const stage of PIPELINE_STAGES) {
-                expect(STAGE_DEFINITIONS[stage]).toBeDefined();
-                expect(STAGE_DEFINITIONS[stage].stage).toBe(stage);
-            }
-        });
-        it('should have consistent order between STAGE_ORDER and definitions', () => {
-            for (const stage of PIPELINE_STAGES) {
-                expect(STAGE_ORDER[stage]).toBe(STAGE_DEFINITIONS[stage].order);
-            }
-        });
-        it('should have complete prerequisite mappings', () => {
-            for (const stage of PIPELINE_STAGES) {
-                const prereqs = getPrerequisites(stage);
-                expect(Array.isArray(prereqs)).toBe(true);
-                // All prerequisites should be valid stages
-                for (const prereq of prereqs) {
-                    expect(PIPELINE_STAGES).toContain(prereq);
-                }
-            }
-        });
-    });
-});
-// =============================================================================
-// EPIC COMPLETION TEST
-// =============================================================================
-describe('T4798 Epic Completion Validation', () => {
-    beforeEach(async () => {
-        testDir = await mkdtemp(join(tmpdir(), 'cleo-epic-completion-'));
-        cleoDir = join(testDir, '.cleo');
-        await mkdir(cleoDir, { recursive: true });
-        await mkdir(join(cleoDir, 'rcasd'), { recursive: true });
-        process.env['CLEO_DIR'] = cleoDir;
-        process.env['LIFECYCLE_ENFORCEMENT_MODE'] = 'off';
-    });
-    afterEach(async () => {
-        try {
-            const { closeAllDatabases } = await import('../../store/sqlite.js');
-            await closeAllDatabases();
-        }
-        catch {
-            /* ignore */
-        }
-        delete process.env['CLEO_DIR'];
-        delete process.env['LIFECYCLE_ENFORCEMENT_MODE'];
-        await rm(testDir, { recursive: true, force: true });
-    });
-    it('validates all T4798 dependencies are functional [T4801]', async () => {
-        // T4801: All dependencies now use SQLite-native storage
-        // T4800: Pipeline State Machine
-        const pipelineId = 'T4806';
-        const context = createInitialContext(pipelineId, 'test-agent');
-        expect(context).toBeDefined();
-        expect(context.currentStage).toBe('research');
-        // T4801: SQLite Schema (verified via stage definitions)
-        expect(PIPELINE_STAGES.length).toBe(9);
-        expect(STAGE_DEFINITIONS['research'].order).toBe(1);
-        // T4804: Gate/Evidence Recording (via passGate/failGate)
-        const gateResult = await passGate('T4806', 'research-test-gate', 'agent', 'Test', testDir);
-        expect(gateResult.timestamp).toBeDefined();
-        // T4805: Cross-session resume (via recordStageProgress)
-        await recordStageProgress('T4806', 'research', 'completed', undefined, testDir);
-        const status = await getLifecycleStatus('T4806', testDir);
-        expect(status.initialized).toBe(true);
-    });
-    it('confirms pipeline integration is complete', () => {
-        // Verify all 9 stages are present
-        const expectedStages = [
-            'research',
-            'consensus',
-            'architecture_decision',
-            'specification',
-            'decomposition',
-            'implementation',
-            'validation',
-            'testing',
-            'release',
-        ];
-        expect(PIPELINE_STAGES).toEqual(expectedStages);
-        // Verify state machine is functional
-        const context = createInitialContext('T4806', 'test-agent');
-        expect(isTerminalState(context)).toBe(false);
-        // Verify gate enforcement is configured
-        expect(STAGE_DEFINITIONS['research'].requiredGates.length).toBeGreaterThan(0);
-        expect(STAGE_DEFINITIONS['implement'].requiredGates.length).toBeGreaterThan(0);
-        // Verify evidence recording is available
-        expect(typeof passGate).toBe('function');
-        expect(typeof failGate).toBe('function');
-    });
-});
-//# sourceMappingURL=pipeline.integration.test.js.map