create-principles-disciple 1.85.0 → 1.87.0

package/core/dist/runtime-v2/internalization/__tests__/diag-chain-e2e.test.js

@@ -0,0 +1,803 @@
+/**
+ * Diag Chain E2E — Integration test for the split diagnostician pipeline (PRI-372).
+ *
+ * Verifies:
+ *   1. One pain signal completes A→B→C chain (schema validation + artifact consistency)
+ *   2. Flag off: monolith runs unchanged (DiagnosticianRunner used, not split runners)
+ *   3. split && !async_cli → fail loud at startup
+ *   4. split && async_cli → valid, runners instantiated
+ *
+ * ERR entries considered:
+ *   - ERR-001: Treat parsed JSON / LLM output as unknown
+ *   - ERR-004: Lineage fields must be internally consistent
+ *   - ERR-008: sourceTaskId/sourceRunIds must match
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { DiagRootCauseOutputV1Schema } from '../../diagnostician/diag-rootcause-output.js';
+import { DiagDistillerOutputV1Schema } from '../../diagnostician/diag-distiller-output.js';
+import { DiagnosticianOutputV1Schema } from '../../diagnostician-output.js';
+import { Value } from '@sinclair/typebox/value';
+import { DiagRootCauseRunner } from '../diag-rootcause-runner.js';
+import { DiagDistillerRunner } from '../diag-distiller-runner.js';
+import { DiagRouterRunner } from '../diag-router-runner.js';
+import { SplitDiagnosticianRunner } from '../split-diagnostician-runner.js';
+import { MemoryPIArtifactStore } from '../pi-artifact-store.js';
+import { createPITaskDiagnosticJson } from '../pitask-metadata.js';
+import { computeFeatureFlagsFromConfig, isFeatureEnabled } from '../../config/pd-config-feature-flags.js';
+import { computeEffectivePdConfig } from '../../config/index.js';
+import { createPainSignalBridge } from '../../pain-signal-runtime-factory.js';
+import { MOCK_ROOT_CAUSE_OUTPUTS, MOCK_DISTILLER_OUTPUTS, MOCK_ROUTER_OUTPUTS } from './__fixtures__/split-pipeline-mock-outputs.js';
+// ── Test fixtures ──────────────────────────────────────────────────────────────
+const ROOTCAUSE_TASK_ID = 'diag_rootcause-e2e';
+const DISTILLER_TASK_ID = 'diag_distiller-e2e';
+const ROUTER_TASK_ID = 'diag_router-e2e';
+const ROOTCAUSE_ARTIFACT_ID = 'pi-art-rootcause-e2e';
+const DISTILLER_ARTIFACT_ID = 'pi-art-distiller-e2e';
+const OWNER = 'test-e2e-owner';
+const RUNTIME_KIND = 'test-double';
+/** Happy-path output using cached real LLM data (R6 fixture) with test-local IDs. */
+function makeRootCauseOutput() {
+    return {
+        ...MOCK_ROOT_CAUSE_OUTPUTS.R6,
+        diagnosisId: 'diag-e2e-001',
+        taskId: ROOTCAUSE_TASK_ID,
+    };
+}
+/** Happy-path output using cached real LLM data (R6 fixture) with test-local IDs. */
+function makeDistillerOutput(overrides = {}) {
+    return {
+        ...MOCK_DISTILLER_OUTPUTS.R6,
+        taskId: DISTILLER_TASK_ID,
+        sourceRootCauseArtifactId: ROOTCAUSE_ARTIFACT_ID,
+        ...overrides,
+    };
+}
+/** Happy-path output using cached real LLM data (R6 fixture) with test-local IDs. */
+function makeRouterOutput() {
+    return {
+        ...MOCK_ROUTER_OUTPUTS.R6,
+        diagnosisId: 'diag-e2e-001',
+    };
+}
+function makeContextPayload() {
+    return {
+        sourceRefs: ['ref-1', 'ref-2'],
+        conversationWindow: [],
+        trajectorySummary: '',
+        painSignal: { painId: 'pain-e2e-001', painType: 'tool_failure', source: 'test', reason: 'test reason', score: 70 },
+    };
+}
+// ── Shared mock helpers ────────────────────────────────────────────────────────
+function makeRunHandle(runId) {
+    return { runId, runtimeKind: RUNTIME_KIND, startedAt: new Date().toISOString() };
+}
+function makeSucceededStatus(runId) {
+    return { status: 'succeeded', runId };
+}
+function makeMockStateManager(taskOverrides) {
+    return {
+        acquireLease: vi.fn().mockImplementation((params) => {
+            const task = taskOverrides[params.taskId];
+            return task ? Promise.resolve(task) : Promise.resolve(undefined);
+        }),
+        getTask: vi.fn().mockImplementation((id) => {
+            return Promise.resolve(taskOverrides[id] ?? undefined);
+        }),
+        getRunsByTask: vi.fn().mockImplementation((taskId) => {
+            // Return a run record for each task so resolveStoreRunId works
+            return Promise.resolve([{ runId: `run-${taskId}`, taskId }]);
+        }),
+        getValidRunsByTaskTolerant: vi.fn().mockImplementation((taskId) => {
+            return Promise.resolve({ runs: [{ runId: `run-${taskId}`, taskId }], degradedRuns: [] });
+        }),
+        updateRunOutput: vi.fn().mockResolvedValue(undefined),
+        markTaskSucceeded: vi.fn().mockResolvedValue(undefined),
+        markTaskFailed: vi.fn().mockResolvedValue(undefined),
+        markTaskRetryWait: vi.fn().mockResolvedValue(undefined),
+        getRetryPolicy: vi.fn().mockReturnValue({ shouldRetry: () => false }),
+        createTask: vi.fn().mockImplementation((record) => {
+            const task = {
+                ...record,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            };
+            taskOverrides[record.taskId] = task;
+            return Promise.resolve(task);
+        }),
+    };
+}
+function makeMockRuntimeAdapter() {
+    return {
+        kind: vi.fn().mockReturnValue(RUNTIME_KIND),
+        getCapabilities: vi.fn(),
+        healthCheck: vi.fn(),
+        startRun: vi.fn().mockResolvedValue(makeRunHandle('run-e2e')),
+        pollRun: vi.fn().mockResolvedValue(makeSucceededStatus('run-e2e')),
+        fetchOutput: vi.fn().mockResolvedValue({ payload: makeRootCauseOutput() }),
+        cancelRun: vi.fn().mockResolvedValue(undefined),
+        fetchArtifacts: vi.fn(),
+    };
+}
+function makeMockEventEmitter() {
+    return {
+        emitTelemetry: vi.fn(),
+        on: vi.fn(),
+        emit: vi.fn(),
+    };
+}
+function makeDefaultInternalAgents() {
+    return {
+        defaultRuntime: 'default',
+        agents: {
+            diagnostician: { enabled: true },
+            dreamer: { enabled: true },
+            philosopher: { enabled: true },
+            scribe: { enabled: true },
+            artificer: { enabled: true },
+            evaluator: { enabled: true },
+            rolloutReviewer: { enabled: true },
+            trainer: { enabled: true },
+            correctionObserver: { enabled: true },
+            empathyObserver: { enabled: true },
+        },
+    };
+}
+// ── Tests ──────────────────────────────────────────────────────────────────────
+describe('Diag chain e2e', () => {
+    // ── Schema validation tests ────────────────────────────────────────────────
+    it('Stage A output passes TypeBox schema validation', () => {
+        const output = makeRootCauseOutput();
+        expect(Value.Check(DiagRootCauseOutputV1Schema, output)).toBe(true);
+    });
+    it('Stage B output passes TypeBox schema validation and references Stage A artifact', () => {
+        const output = makeDistillerOutput();
+        expect(Value.Check(DiagDistillerOutputV1Schema, output)).toBe(true);
+        // Lineage integrity: sourceRootCauseArtifactId must reference Stage A
+        expect(output.sourceRootCauseArtifactId).toBe(ROOTCAUSE_ARTIFACT_ID);
+    });
+    it('Stage C output passes TypeBox schema validation', () => {
+        const output = makeRouterOutput();
+        expect(Value.Check(DiagnosticianOutputV1Schema, output)).toBe(true);
+    });
+    it('artifact chain is internally consistent', () => {
+        const rootCauseOutput = makeRootCauseOutput();
+        const distillerOutput = makeDistillerOutput();
+        const routerOutput = makeRouterOutput();
+        // Stage B references Stage A artifact
+        expect(distillerOutput.sourceRootCauseArtifactId).toBe(ROOTCAUSE_ARTIFACT_ID);
+        // All outputs have valid=true
+        expect(rootCauseOutput.valid).toBe(true);
+        expect(distillerOutput.valid).toBe(true);
+        expect(routerOutput.valid).toBe(true);
+        // Root cause category is consistent across stages
+        expect(rootCauseOutput.rootCauseCategory).toBe('Design');
+        expect(rootCauseOutput.rootCause).toContain('Design:');
+        expect(routerOutput.rootCause).toContain('Design:');
+    });
+    // ── Full A→B→C chain test ──────────────────────────────────────────────────
+    it('one pain signal completes A→B→C and triggers committer + onDiagnosisComplete', async () => {
+        const artifactStore = new MemoryPIArtifactStore();
+        const rootCauseTask = {
+            taskId: ROOTCAUSE_TASK_ID,
+            taskKind: 'diag_rootcause',
+            status: 'pending',
+            attemptCount: 0,
+            maxAttempts: 3,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            diagnosticJson: createPITaskDiagnosticJson({
+                dependencyTaskIds: [],
+                channel: 'prompt',
+                timeoutMs: 300_000,
+                inputArtifactRefs: [],
+                outputArtifactRefs: [],
+            }),
+        };
+        const distillerTask = {
+            taskId: DISTILLER_TASK_ID,
+            taskKind: 'diag_distiller',
+            status: 'pending',
+            attemptCount: 0,
+            maxAttempts: 3,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            diagnosticJson: createPITaskDiagnosticJson({
+                dependencyTaskIds: [ROOTCAUSE_TASK_ID],
+                channel: 'prompt',
+                timeoutMs: 300_000,
+                inputArtifactRefs: [],
+                outputArtifactRefs: [],
+            }),
+        };
+        const routerTask = {
+            taskId: ROUTER_TASK_ID,
+            taskKind: 'diag_router',
+            status: 'pending',
+            attemptCount: 0,
+            maxAttempts: 3,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            diagnosticJson: createPITaskDiagnosticJson({
+                dependencyTaskIds: [ROOTCAUSE_TASK_ID, DISTILLER_TASK_ID],
+                channel: 'prompt',
+                timeoutMs: 300_000,
+                inputArtifactRefs: [],
+                outputArtifactRefs: [],
+            }),
+        };
+        const taskMap = {
+            [ROOTCAUSE_TASK_ID]: rootCauseTask,
+            [DISTILLER_TASK_ID]: distillerTask,
+            [ROUTER_TASK_ID]: routerTask,
+        };
+        const stateManager = makeMockStateManager(taskMap);
+        const runtimeAdapter = makeMockRuntimeAdapter();
+        const eventEmitter = makeMockEventEmitter();
+        const contextAssembler = { assemble: vi.fn().mockResolvedValue(makeContextPayload()) };
+        // ── Stage A: DiagRootCauseRunner ──────────────────────────────────────────
+        const rootCauseRunId = 'run-rc-e2e';
+        runtimeAdapter.startRun.mockResolvedValue(makeRunHandle(rootCauseRunId));
+        runtimeAdapter.pollRun.mockResolvedValue(makeSucceededStatus(rootCauseRunId));
+        runtimeAdapter.fetchOutput.mockResolvedValue({ payload: makeRootCauseOutput() });
+        const rootCauseDeps = {
+            stateManager: stateManager,
+            runtimeAdapter: runtimeAdapter,
+            eventEmitter: eventEmitter,
+            artifactStore,
+            validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) },
+            contextAssembler: contextAssembler,
+        };
+        const rootCauseRunner = new DiagRootCauseRunner(rootCauseDeps, {
+            owner: OWNER,
+            runtimeKind: RUNTIME_KIND,
+            pollIntervalMs: 10,
+            timeoutMs: 1000,
+        });
+        const resultA = await rootCauseRunner.run(ROOTCAUSE_TASK_ID);
+        expect(resultA.status).toBe('succeeded');
+        expect(resultA.artifactId).toBeDefined();
+        // Verify Stage A artifact was written
+        const artifactsA = await artifactStore.listBySourceTaskId(ROOTCAUSE_TASK_ID);
+        expect(artifactsA).toHaveLength(1);
+        expect(artifactsA[0]?.artifactKind).toBe('principle');
+        // ── Stage B: DiagDistillerRunner ──────────────────────────────────────────
+        const distillerRunId = 'run-dist-e2e';
+        runtimeAdapter.startRun.mockResolvedValue(makeRunHandle(distillerRunId));
+        runtimeAdapter.pollRun.mockResolvedValue(makeSucceededStatus(distillerRunId));
+        // Use the actual artifact ID from Stage A for lineage integrity check (EP-07)
+        const stageAArtifactId = resultA.artifactId ?? ROOTCAUSE_ARTIFACT_ID;
+        runtimeAdapter.fetchOutput.mockResolvedValue({ payload: makeDistillerOutput({ sourceRootCauseArtifactId: stageAArtifactId }) });
+        const distillerDeps = {
+            stateManager: stateManager,
+            runtimeAdapter: runtimeAdapter,
+            eventEmitter: eventEmitter,
+            artifactStore,
+            validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) },
+        };
+        const distillerRunner = new DiagDistillerRunner(distillerDeps, {
+            owner: OWNER,
+            runtimeKind: RUNTIME_KIND,
+            pollIntervalMs: 10,
+            timeoutMs: 1000,
+        });
+        const resultB = await distillerRunner.run(DISTILLER_TASK_ID);
+        expect(resultB.status).toBe('succeeded');
+        expect(resultB.artifactId).toBeDefined();
+        // Verify Stage B artifact was written
+        const artifactsB = await artifactStore.listBySourceTaskId(DISTILLER_TASK_ID);
+        expect(artifactsB).toHaveLength(1);
+        // ── Stage C: DiagRouterRunner ─────────────────────────────────────────────
+        const routerRunId = 'run-router-e2e';
+        runtimeAdapter.startRun.mockResolvedValue(makeRunHandle(routerRunId));
+        runtimeAdapter.pollRun.mockResolvedValue(makeSucceededStatus(routerRunId));
+        runtimeAdapter.fetchOutput.mockResolvedValue({ payload: makeRouterOutput() });
+        const commitResult = {
+            commitId: 'commit-e2e-001',
+            artifactId: 'art-e2e-001',
+            candidateCount: 1,
+        };
+        const committer = { commit: vi.fn().mockResolvedValue(commitResult) };
+        const routerDeps = {
+            stateManager: stateManager,
+            runtimeAdapter: runtimeAdapter,
+            eventEmitter: eventEmitter,
+            artifactStore,
+            committer: committer,
+        };
+        const routerRunner = new DiagRouterRunner(routerDeps, {
+            owner: OWNER,
+            runtimeKind: RUNTIME_KIND,
+            pollIntervalMs: 10,
+            timeoutMs: 1000,
+        });
+        const resultC = await routerRunner.run(ROUTER_TASK_ID);
+        expect(resultC.status).toBe('succeeded');
+        // Verify committer was called
+        expect(committer.commit).toHaveBeenCalledWith(expect.objectContaining({
+            taskId: ROUTER_TASK_ID,
+        }));
+    });
+    // ── Flag matrix guard tests ────────────────────────────────────────────────
+    it('flag off: splitPipeline flag can be disabled via config', () => {
+        const effectiveConfig = {
+            config: {
+                version: 1,
+                features: {
+                    diagnostician_split_pipeline: { category: 'quiet', enabled: false },
+                },
+                runtimeProfiles: {},
+                internalAgents: makeDefaultInternalAgents(),
+                ui: { diagnostics: { mode: 'simple' } },
+            },
+            source: 'user_config',
+            warnings: [],
+        };
+        const featureFlags = computeFeatureFlagsFromConfig(effectiveConfig);
+        const splitPipeline = isFeatureEnabled(featureFlags, 'diagnostician_split_pipeline');
+        expect(splitPipeline).toBe(false);
+    });
+    it('split && !async_cli → fail loud at startup when explicitly overridden', async () => {
+        // When split_pipeline=true and async_cli=false, the factory guard should throw if overridden.
+        const effectiveConfig = {
+            config: {
+                version: 1,
+                features: {
+                    diagnostician_split_pipeline: { category: 'quiet', enabled: true },
+                    diagnostician_async_cli: { category: 'quiet', enabled: false },
+                },
+                runtimeProfiles: {
+                    'default': { type: 'openclaw', source: 'default' },
+                },
+                internalAgents: makeDefaultInternalAgents(),
+                ui: { diagnostics: { mode: 'simple' } },
+            },
+            source: 'user_config',
+            warnings: [],
+            featuresChangedFromDefault: ['diagnostician_split_pipeline'],
+        };
+        // Verify it actually throws in createPainSignalBridge
+        await expect(createPainSignalBridge({
+            workspaceDir: '/invalid-path-a',
+            stateDir: '/invalid-path-a',
+            effectiveConfig,
+            ledgerAdapter: { writeProbationEntry: vi.fn() },
+        })).rejects.toThrowError('diagnostician_split_pipeline requires diagnostician_async_cli=on');
+    });
+    it('split && !async_cli → does NOT throw at startup for default configuration', async () => {
+        const defaults = computeEffectivePdConfig(null);
+        // Should NOT throw the factory guard (so it will proceed to DB init and fail with a filesystem/db error, not PDRuntimeError input_invalid)
+        const result = createPainSignalBridge({
+            workspaceDir: '/invalid-path-b',
+            stateDir: '/invalid-path-b',
+            effectiveConfig: defaults,
+            ledgerAdapter: { writeProbationEntry: vi.fn() },
+        });
+        try {
+            await result;
+            expect.unreachable('should have failed with filesystem/db error');
+        }
+        catch (err) {
+            const error = err;
+            // It should NOT be the PDRuntimeError with code 'input_invalid' from the factory guard
+            expect(error.code).not.toBe('input_invalid');
+            expect(error.message).not.toContain('diagnostician_split_pipeline requires');
+        }
+    });
+    it('user config matching defaults does not trigger the factory guard', async () => {
+        // Completely list default flags matching their default values
+        const userConfig = {
+            version: 1,
+            features: {
+                prompt: { category: 'core', enabled: true },
+                code_tool_hook: { category: 'core', enabled: true },
+                defer_archive: { category: 'core', enabled: true },
+                correction_observer: { category: 'quiet', enabled: true },
+                feedback_channel: { category: 'quiet', enabled: true },
+                gfi: { category: 'quiet', enabled: false },
+                evolution_worker: { category: 'quiet', enabled: false },
+                empathy_observer: { category: 'quiet', enabled: false },
+                painEvidenceAdmission: { category: 'quiet', enabled: false },
+                diagnostician_async_cli: { category: 'quiet', enabled: false },
+                diagnostician_core_grounding: { category: 'quiet', enabled: true },
+                diagnostician_split_pipeline: { category: 'quiet', enabled: true },
+                nocturnal: { category: 'gone', enabled: false },
+                idle_trigger: { category: 'gone', enabled: false },
+                model_training: { category: 'gone', enabled: false },
+                trainer: { category: 'gone', enabled: false },
+            },
+            runtimeProfiles: {
+                'default': { type: 'openclaw', source: 'default' },
+            },
+            internalAgents: makeDefaultInternalAgents(),
+            ui: { diagnostics: { mode: 'simple' } },
+        };
+        const effectiveConfig = computeEffectivePdConfig(userConfig);
+        // Verify neither split_pipeline nor async_cli is in featuresChangedFromDefault
+        expect(effectiveConfig.featuresChangedFromDefault).not.toContain('diagnostician_split_pipeline');
+        expect(effectiveConfig.featuresChangedFromDefault).not.toContain('diagnostician_async_cli');
+        // Verify it does NOT throw the factory guard
+        const result = createPainSignalBridge({
+            workspaceDir: '/invalid-path-matching-defaults',
+            stateDir: '/invalid-path-matching-defaults',
+            effectiveConfig,
+            ledgerAdapter: { writeProbationEntry: vi.fn() },
+        });
+        try {
+            await result;
+            expect.unreachable('should have failed with filesystem/db error');
+        }
+        catch (err) {
+            const error = err;
+            expect(error.code).not.toBe('input_invalid');
+            expect(error.message).not.toContain('diagnostician_split_pipeline requires');
+        }
+    });
+    it('split && async_cli → valid, runners instantiated', () => {
+        // When both flags are on, the factory should create the 3 split runners.
+        const effectiveConfig = {
+            config: {
+                version: 1,
+                features: {
+                    diagnostician_split_pipeline: { category: 'quiet', enabled: true },
+                    diagnostician_async_cli: { category: 'quiet', enabled: true },
+                },
+                runtimeProfiles: {},
+                internalAgents: makeDefaultInternalAgents(),
+                ui: { diagnostics: { mode: 'simple' } },
+            },
+            source: 'user_config',
+            warnings: [],
+        };
+        const featureFlags = computeFeatureFlagsFromConfig(effectiveConfig);
+        const splitPipeline = isFeatureEnabled(featureFlags, 'diagnostician_split_pipeline');
+        const asyncCli = isFeatureEnabled(featureFlags, 'diagnostician_async_cli');
+        // Both flags should be enabled
+        expect(splitPipeline).toBe(true);
+        expect(asyncCli).toBe(true);
+        // The guard should NOT throw — verify by simulating the factory guard
+        if (splitPipeline && !asyncCli) {
+            expect.unreachable('Should not throw when both flags are on');
+        }
+        // If we reach here, the guard passes — runners would be instantiated
+        expect(splitPipeline && asyncCli).toBe(true);
+    });
+    // ── Cross-stage lineage integrity ──────────────────────────────────────────
+    it('Stage B sourceRootCauseArtifactId matches Stage A artifact ID', async () => {
+        const artifactStore = new MemoryPIArtifactStore();
+        // Write Stage A artifact
+        await artifactStore.upsertArtifact({
+            artifactId: ROOTCAUSE_ARTIFACT_ID,
+            artifactKind: 'principle',
+            sourceTaskId: ROOTCAUSE_TASK_ID,
+            lineageArtifactIds: [],
+            validationStatus: 'pending',
+            contentJson: JSON.stringify(makeRootCauseOutput()),
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        });
+        // Verify Stage B output references the correct artifact
+        const distillerOutput = makeDistillerOutput();
+        expect(distillerOutput.sourceRootCauseArtifactId).toBe(ROOTCAUSE_ARTIFACT_ID);
+        // Verify the artifact exists in the store
+        const artifacts = await artifactStore.listBySourceTaskId(ROOTCAUSE_TASK_ID);
+        expect(artifacts).toHaveLength(1);
+        expect(artifacts[0]?.artifactId).toBe(ROOTCAUSE_ARTIFACT_ID);
+    });
+    it('Stage C reads both Stage A and Stage B artifacts', async () => {
+        const artifactStore = new MemoryPIArtifactStore();
+        // Write Stage A artifact
+        await artifactStore.upsertArtifact({
+            artifactId: ROOTCAUSE_ARTIFACT_ID,
+            artifactKind: 'principle',
+            sourceTaskId: ROOTCAUSE_TASK_ID,
+            lineageArtifactIds: [],
+            validationStatus: 'pending',
+            contentJson: JSON.stringify(makeRootCauseOutput()),
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        });
+        // Write Stage B artifact
+        await artifactStore.upsertArtifact({
+            artifactId: DISTILLER_ARTIFACT_ID,
+            artifactKind: 'principle',
+            sourceTaskId: DISTILLER_TASK_ID,
+            lineageArtifactIds: [ROOTCAUSE_ARTIFACT_ID],
+            validationStatus: 'pending',
+            contentJson: JSON.stringify(makeDistillerOutput()),
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        });
+        // Verify both artifacts exist
+        const artifactsA = await artifactStore.listBySourceTaskId(ROOTCAUSE_TASK_ID);
+        const artifactsB = await artifactStore.listBySourceTaskId(DISTILLER_TASK_ID);
+        expect(artifactsA).toHaveLength(1);
+        expect(artifactsB).toHaveLength(1);
+        // Verify Stage B lineage includes Stage A artifact
+        expect(artifactsB[0]?.lineageArtifactIds).toContain(ROOTCAUSE_ARTIFACT_ID);
+    });
+    // ── SplitDiagnosticianRunner orchestration test ────────────────────────────
+    it('SplitDiagnosticianRunner orchestrates A→B→C and returns RunnerResult', async () => {
+        const artifactStore = new MemoryPIArtifactStore();
+        const PARENT_TASK_ID = 'diagnosis_split-e2e';
+        const STAGE_A_TASK_ID = `diag_rootcause-${PARENT_TASK_ID}`;
+        const STAGE_B_TASK_ID = `diag_distiller-${PARENT_TASK_ID}`;
+        const STAGE_C_TASK_ID = `diag_router-${PARENT_TASK_ID}`;
+        const taskMap = {};
+        const stateManager = makeMockStateManager(taskMap);
+        const runtimeAdapter = makeMockRuntimeAdapter();
+        const eventEmitter = makeMockEventEmitter();
+        const contextAssembler = { assemble: vi.fn().mockResolvedValue(makeContextPayload()) };
+        // Stage A runner setup
+        const rootCauseRunId = 'run-split-rc';
+        runtimeAdapter.startRun.mockResolvedValue(makeRunHandle(rootCauseRunId));
+        runtimeAdapter.pollRun.mockResolvedValue(makeSucceededStatus(rootCauseRunId));
+        // The store's run ID is 'run-${taskId}' per makeMockStateManager
+        const storeRunIdA = `run-${STAGE_A_TASK_ID}`;
+        const expectedStageAArtifactId = `pi-art-${STAGE_A_TASK_ID}-${storeRunIdA}`;
+        // fetchOutput returns different outputs per stage — use mockImplementation
+        // Stage A is first, Stage B second, Stage C third
+        let fetchCallCount = 0;
+        runtimeAdapter.fetchOutput.mockImplementation(async () => {
+            fetchCallCount++;
+            if (fetchCallCount === 1) {
+                return { payload: makeRootCauseOutput() };
+            }
+            if (fetchCallCount === 2) {
+                // Stage B: use the artifact ID that Stage A wrote (based on store run ID)
+                return { payload: makeDistillerOutput({ sourceRootCauseArtifactId: expectedStageAArtifactId }) };
+            }
+            return { payload: makeRouterOutput() };
+        });
+        const rootCauseDeps = {
+            stateManager: stateManager,
+            runtimeAdapter: runtimeAdapter,
+            eventEmitter: eventEmitter,
+            artifactStore,
+            validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) },
+            contextAssembler: contextAssembler,
+        };
+        const rootCauseRunner = new DiagRootCauseRunner(rootCauseDeps, {
+            owner: OWNER,
+            runtimeKind: RUNTIME_KIND,
+            pollIntervalMs: 10,
+            timeoutMs: 1000,
+        });
+        // Stage B runner
+        const distillerDeps = {
+            stateManager: stateManager,
+            runtimeAdapter: runtimeAdapter,
+            eventEmitter: eventEmitter,
+            artifactStore,
+            validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) },
+        };
+        const distillerRunner = new DiagDistillerRunner(distillerDeps, {
+            owner: OWNER,
+            runtimeKind: RUNTIME_KIND,
+            pollIntervalMs: 10,
+            timeoutMs: 1000,
+        });
+        // Stage C runner
+        const commitResult = {
+            commitId: 'commit-split-e2e',
+            artifactId: 'art-split-e2e',
+            candidateCount: 1,
+        };
+        const committer = { commit: vi.fn().mockResolvedValue(commitResult) };
+        const routerDeps = {
+            stateManager: stateManager,
+            runtimeAdapter: runtimeAdapter,
+            eventEmitter: eventEmitter,
+            artifactStore,
+            committer: committer,
+        };
+        const routerRunner = new DiagRouterRunner(routerDeps, {
+            owner: OWNER,
+            runtimeKind: RUNTIME_KIND,
+            pollIntervalMs: 10,
+            timeoutMs: 1000,
+        });
+        // Create the split runner
+        const splitRunner = new SplitDiagnosticianRunner({
+            rootCauseRunner,
+            distillerRunner,
+            routerRunner,
+            stateManager: stateManager,
+            committer: committer,
+        });
+        // Run the split pipeline
+        const result = await splitRunner.run(PARENT_TASK_ID);
+        // Verify the result
+        expect(result.status).toBe('succeeded');
+        expect(result.taskId).toBe(PARENT_TASK_ID);
+        expect(result.output).toBeDefined();
+        expect(result.output?.valid).toBe(true);
+        // Verify all 3 sub-tasks were created
+        expect(taskMap[STAGE_A_TASK_ID]).toBeDefined();
+        expect(taskMap[STAGE_A_TASK_ID]?.taskKind).toBe('diag_rootcause');
+        expect(taskMap[STAGE_B_TASK_ID]).toBeDefined();
+        expect(taskMap[STAGE_B_TASK_ID]?.taskKind).toBe('diag_distiller');
+        expect(taskMap[STAGE_C_TASK_ID]).toBeDefined();
+        expect(taskMap[STAGE_C_TASK_ID]?.taskKind).toBe('diag_router');
+        // Verify Stage B depends on Stage A
+        const stageBDiag = taskMap[STAGE_B_TASK_ID]?.diagnosticJson;
+        expect(stageBDiag).toContain(STAGE_A_TASK_ID);
+        // Verify Stage C depends on both A and B
+        const stageCDiag = taskMap[STAGE_C_TASK_ID]?.diagnosticJson;
+        expect(stageCDiag).toContain(STAGE_A_TASK_ID);
+        expect(stageCDiag).toContain(STAGE_B_TASK_ID);
+        // Verify committer was called (by Stage C)
+        expect(committer.commit).toHaveBeenCalled();
+        // Verify artifacts were written for all 3 stages
+        const artifactsA = await artifactStore.listBySourceTaskId(STAGE_A_TASK_ID);
+        const artifactsB = await artifactStore.listBySourceTaskId(STAGE_B_TASK_ID);
+        expect(artifactsA).toHaveLength(1);
+        expect(artifactsB).toHaveLength(1);
+    });
+    it('SplitDiagnosticianRunner stops and returns failure when Stage A fails', async () => {
+        const artifactStore = new MemoryPIArtifactStore();
+        const PARENT_TASK_ID = 'diagnosis_split-fail-a';
+        const taskMap = {};
+        const stateManager = makeMockStateManager(taskMap);
+        const runtimeAdapter = makeMockRuntimeAdapter();
+        const eventEmitter = makeMockEventEmitter();
+        const contextAssembler = { assemble: vi.fn().mockResolvedValue(makeContextPayload()) };
+        // Stage A fails
+        runtimeAdapter.startRun.mockResolvedValue(makeRunHandle('run-fail-rc'));
+        runtimeAdapter.pollRun.mockResolvedValue({ status: 'failed', runId: 'run-fail-rc' });
+        const rootCauseDeps = {
+            stateManager: stateManager,
+            runtimeAdapter: runtimeAdapter,
+            eventEmitter: eventEmitter,
+            artifactStore,
+            validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) },
+            contextAssembler: contextAssembler,
+        };
+        const rootCauseRunner = new DiagRootCauseRunner(rootCauseDeps, {
+            owner: OWNER,
+            runtimeKind: RUNTIME_KIND,
+            pollIntervalMs: 10,
+            timeoutMs: 1000,
+        });
+        const distillerRunner = new DiagDistillerRunner({ stateManager: stateManager, runtimeAdapter: runtimeAdapter, eventEmitter: eventEmitter, artifactStore, validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) } }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 10, timeoutMs: 1000 });
+        const committer = { commit: vi.fn() };
+        const routerRunner = new DiagRouterRunner({ stateManager: stateManager, runtimeAdapter: runtimeAdapter, eventEmitter: eventEmitter, artifactStore, committer: committer }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 10, timeoutMs: 1000 });
+        const splitRunner = new SplitDiagnosticianRunner({
+            rootCauseRunner,
+            distillerRunner,
+            routerRunner,
+            stateManager: stateManager,
+            committer: committer,
+        });
+        const result = await splitRunner.run(PARENT_TASK_ID);
+        // Should fail — Stage A failed
+        expect(result.status).toBe('failed');
+        expect(result.taskId).toBe(PARENT_TASK_ID);
+        // The failure reason comes from the runner (max_attempts_exceeded)
+        expect(result.errorCategory).toBe('max_attempts_exceeded');
+        // Stage B and C tasks should NOT have been created
+        expect(taskMap[`diag_distiller-${PARENT_TASK_ID}`]).toBeUndefined();
+        expect(taskMap[`diag_router-${PARENT_TASK_ID}`]).toBeUndefined();
+        // Committer should NOT have been called
+        expect(committer.commit).not.toHaveBeenCalled();
+    });
+    it('split pipeline end-to-end boundary integration (real SQLite + Bridge + Committer + Intake + Ledger)', async () => {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const os = await import('node:os');
+        const { RuntimeStateManager } = await import('../../store/runtime-state-manager.js');
+        const { SqliteDiagnosticianCommitter } = await import('../../store/commit/diagnostician-committer.js');
+        const { SqliteContextAssembler } = await import('../../store/context/sqlite-context-assembler.js');
+        const { SqliteHistoryQuery } = await import('../../store/history/sqlite-history-query.js');
+        const { PainSignalBridge } = await import('../../pain-signal-bridge.js');
+        const { CandidateIntakeService } = await import('../../candidate-intake-service.js');
+        const { DiagRootCauseRunner: DiagRootCauseRunnerImpl } = await import('../diag-rootcause-runner.js');
+        const { DiagDistillerRunner: DiagDistillerRunnerImpl } = await import('../diag-distiller-runner.js');
+        const { DiagRouterRunner: DiagRouterRunnerImpl } = await import('../diag-router-runner.js');
+        const { SplitDiagnosticianRunner: SplitDiagnosticianRunnerImpl } = await import('../split-diagnostician-runner.js');
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-split-e2e-boundary-'));
+        const stateManager = new RuntimeStateManager({ workspaceDir: tmpDir });
+        try {
+            await stateManager.initialize();
+            const committer = new SqliteDiagnosticianCommitter(stateManager.connection);
+            const trajectoryTurnReader = {
+                listUserTurnsForSession: vi.fn().mockReturnValue([]),
+                listAssistantTurns: vi.fn().mockReturnValue([]),
+            };
+            const contextAssembler = new SqliteContextAssembler(stateManager.taskStore, new SqliteHistoryQuery(stateManager.connection), stateManager.runStore, { trajectoryTurnReader });
+            const runtimeAdapter = makeMockRuntimeAdapter();
+            let runCount = 0;
+            runtimeAdapter.startRun.mockImplementation(async () => {
+                runCount++;
+                return { runId: `run-e2e-${runCount}`, runtimeKind: RUNTIME_KIND, startedAt: new Date().toISOString() };
+            });
+            runtimeAdapter.pollRun.mockImplementation(async (handle) => {
+                return { status: 'succeeded', runId: handle.runId };
+            });
+            let fetchCallCount = 0;
+            runtimeAdapter.fetchOutput.mockImplementation(async () => {
+                fetchCallCount++;
+                if (fetchCallCount === 1) {
+                    return { payload: makeRootCauseOutput() };
+                }
+                if (fetchCallCount === 2) {
+                    const artifactsA = await stateManager.piArtifactStore.listBySourceTaskId(`diag_rootcause-diagnosis_pain-e2e-boundary`);
+                    const stageAArtifactId = artifactsA[0]?.artifactId ?? ROOTCAUSE_ARTIFACT_ID;
+                    return { payload: makeDistillerOutput({ sourceRootCauseArtifactId: stageAArtifactId }) };
+                }
+                return { payload: makeRouterOutput() };
+            });
+            const rootCauseRunner = new DiagRootCauseRunnerImpl({
+                stateManager,
+                runtimeAdapter: runtimeAdapter,
+                eventEmitter: makeMockEventEmitter(),
+                artifactStore: stateManager.piArtifactStore,
+                validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) },
+                contextAssembler,
+            }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 10, timeoutMs: 1000 });
+            const distillerRunner = new DiagDistillerRunnerImpl({
+                stateManager,
+                runtimeAdapter: runtimeAdapter,
+                eventEmitter: makeMockEventEmitter(),
+                artifactStore: stateManager.piArtifactStore,
+                validator: { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) },
+            }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 10, timeoutMs: 1000 });
+            const routerRunner = new DiagRouterRunnerImpl({
+                stateManager,
+                runtimeAdapter: runtimeAdapter,
+                eventEmitter: makeMockEventEmitter(),
+                artifactStore: stateManager.piArtifactStore,
+                committer,
+            }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 10, timeoutMs: 1000 });
+            const splitRunner = new SplitDiagnosticianRunnerImpl({
+                rootCauseRunner,
+                distillerRunner,
+                routerRunner,
+                stateManager,
+                committer,
+            });
+            const ledgerAdapter = {
+                writeProbationEntry: vi.fn().mockImplementation((entry) => entry),
+                existsForCandidate: vi.fn().mockReturnValue(null),
+            };
+            const intakeService = new CandidateIntakeService({
+                stateManager,
+                ledgerAdapter: ledgerAdapter,
+            });
+            const bridge = new PainSignalBridge({
+                stateManager,
+                runner: splitRunner,
+                intakeService,
+                ledgerAdapter: ledgerAdapter,
+                autoIntakeEnabled: true,
+                workspaceDir: tmpDir,
+            });
+            const painSignal = {
+                painId: 'pain-e2e-boundary',
+                painType: 'tool_failure',
+                source: 'test-source',
+                reason: 'test reason',
+                evidence: [{ sourceRef: 'src-1', note: 'some evidence note' }],
+            };
+            const bridgeResult = await bridge.onPainDetected(painSignal);
+            // Verify successful e2e execution status
+            expect(bridgeResult.status).toBe('succeeded');
+            expect(bridgeResult.painId).toBe(painSignal.painId);
+            expect(bridgeResult.taskId).toBe(`diagnosis_${painSignal.painId}`);
+            // Verify all 3 sub-tasks were written to the state.db
+            const parentTaskId = `diagnosis_${painSignal.painId}`;
+            const taskA = await stateManager.getTask(`diag_rootcause-${parentTaskId}`);
+            const taskB = await stateManager.getTask(`diag_distiller-${parentTaskId}`);
+            const taskC = await stateManager.getTask(`diag_router-${parentTaskId}`);
+            expect(taskA?.status).toBe('succeeded');
+            expect(taskB?.status).toBe('succeeded');
+            expect(taskC?.status).toBe('succeeded');
+            // Verify candidate was committed and then registered to the ledger!
+            expect(ledgerAdapter.writeProbationEntry).toHaveBeenCalled();
+        }
+        finally {
+            stateManager.close();
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=diag-chain-e2e.test.js.map