@cleocode/core 2.0.0

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

@@ -0,0 +1,977 @@
+/**
+ * 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 adr
+            context.stages['consensus'] = setStageStatus('consensus', 'completed', context);
+            const consensusTransition = {
+                from: 'consensus',
+                to: 'adr',
+                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 spec
+            context.stages['adr'] = setStageStatus('adr', 'completed', context);
+            const adrTransition = {
+                from: 'adr',
+                to: 'spec',
+                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 decompose
+            context.stages['spec'] = setStageStatus('spec', 'completed', context);
+            const specTransition = {
+                from: 'spec',
+                to: 'decompose',
+                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 implement
+            context.stages['decompose'] = setStageStatus('decompose', 'completed', context);
+            const decomposeTransition = {
+                from: 'decompose',
+                to: 'implement',
+                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 verify
+            context.stages['implement'] = setStageStatus('implement', 'completed', context);
+            const implementTransition = {
+                from: 'implement',
+                to: 'verify',
+                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 test
+            context.stages['verify'] = setStageStatus('verify', 'completed', context);
+            const verifyTransition = {
+                from: 'verify',
+                to: 'test',
+                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['test'] = setStageStatus('test', 'completed', context);
+            const testTransition = {
+                from: 'test',
+                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['adr'].status).toBe('completed');
+            expect(context.stages['spec'].status).toBe('completed');
+            expect(context.stages['decompose'].status).toBe('completed');
+            expect(context.stages['implement'].status).toBe('completed');
+            expect(context.stages['verify'].status).toBe('completed');
+            expect(context.stages['test'].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 implement without completing decompose
+            const invalidTransition = {
+                from: 'research',
+                to: 'implement',
+                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: 'adr',
+                initiatedBy: 'test-agent',
+            };
+            const validation = await validateTransition(transition, context);
+            // adr 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',
+                'adr',
+                'spec',
+                'decompose',
+                'implement',
+                'verify',
+                'test',
+            ];
+            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 test stage as completed and transition to release
+            const now = new Date();
+            context.stages['test'] = setStageStatus('test', 'in_progress', context);
+            context.stages['test'] = setStageStatus('test', 'completed', context);
+            const finalTransition = {
+                from: 'test',
+                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['adr'].status).toBe('completed');
+            expect(context.stages['spec'].status).toBe('completed');
+            expect(context.stages['decompose'].status).toBe('completed');
+            expect(context.stages['implement'].status).toBe('completed');
+            expect(context.stages['verify'].status).toBe('completed');
+            expect(context.stages['test'].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',
+                'adr',
+                'spec',
+                'decompose',
+                'implement',
+                'verify',
+                'test',
+                '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', 'adr'],
+                ['adr', 'spec'],
+            ];
+            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',
+                'adr',
+                'spec',
+                'decompose',
+                'implement',
+                'verify',
+                'test',
+                '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: 'spec',
+            });
+            expect(pipeline.currentStage).toBe('spec');
+        });
+        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',
+                'adr',
+                'spec',
+                'decompose',
+                'implement',
+                'verify',
+                'test',
+                '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',
+                'adr',
+                'spec',
+                'decompose',
+                'implement',
+                'verify',
+                'test',
+            ];
+            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