create-principles-disciple 1.85.0 → 1.87.0

package/core/dist/runtime-v2/runner/__tests__/diagnostician-runner.test.js

@@ -1,682 +0,0 @@
-/**
- * DiagnosticianRunner unit tests.
- *
- * Covers 11 scenarios:
- *   1. Happy path: full lifecycle succeeds
- *   2. Polling loop: pollRun returns 'running' then 'succeeded'
- *   3. Timeout: pollRun never reaches terminal
- *   4. Runtime failure: pollRun returns 'failed'
- *   5. Context build failure (transient)
- *   6. Context build failure (permanent)
- *   7. Validation failure
- *   8. StartRunInput construction
- *   9. Lease conflict
- *  10. Max attempts exceeded
- *  11. OpenClaw history compatibility
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { PDRuntimeError } from '../../error-categories.js';
-import { DiagnosticianRunner } from '../diagnostician-runner.js';
-import { RunnerPhase } from '../runner-phase.js';
-// ── Test fixtures ──────────────────────────────────────────────────────────────
-const TASK_ID = 'task-test-001';
-const RUN_ID = 'run-test-001';
-const OWNER = 'test-owner';
-const RUNTIME_KIND = 'test-double';
-function makeTaskRecord(overrides = {}) {
-    return {
-        taskId: TASK_ID,
-        taskKind: 'diagnostician',
-        status: 'leased',
-        createdAt: '2026-04-23T00:00:00Z',
-        updatedAt: '2026-04-23T00:00:00Z',
-        leaseOwner: OWNER,
-        leaseExpiresAt: '2026-04-23T01:00:00Z',
-        attemptCount: 1,
-        maxAttempts: 3,
-        ...overrides,
-    };
-}
-function makeRunHandle() {
-    return {
-        runId: RUN_ID,
-        runtimeKind: RUNTIME_KIND,
-        startedAt: '2026-04-23T00:00:00Z',
-    };
-}
-function makeContextPayload(overrides = {}) {
-    return {
-        contextId: 'ctx-001',
-        contextHash: 'abc123hash',
-        taskId: TASK_ID,
-        workspaceDir: '/test/workspace',
-        sourceRefs: ['trajectory-001'],
-        diagnosisTarget: {
-            reasonSummary: 'test diagnosis',
-        },
-        conversationWindow: [
-            { ts: '2026-04-23T00:00:00Z', role: 'user', text: 'hello' },
-        ],
-        ...overrides,
-    };
-}
-function makeDiagnosticianOutput(overrides = {}) {
-    return {
-        valid: true,
-        diagnosisId: 'diag-001',
-        summary: 'Test diagnosis summary',
-        rootCause: 'Test root cause',
-        violatedPrinciples: [],
-        evidence: [],
-        recommendations: [],
-        confidence: 0.9,
-        ...overrides,
-    };
-}
-function createMocks() {
-    const taskRecord = makeTaskRecord();
-    const runHandle = makeRunHandle();
-    const contextPayload = makeContextPayload();
-    const output = makeDiagnosticianOutput();
-    const mockStateManager = {
-        acquireLease: vi.fn().mockResolvedValue(taskRecord),
-        markTaskSucceeded: vi.fn().mockResolvedValue(taskRecord),
-        markTaskFailed: vi.fn().mockResolvedValue(taskRecord),
-        markTaskRetryWait: vi.fn().mockResolvedValue(taskRecord),
-        updateRunOutput: vi.fn().mockResolvedValue({}),
-        getRetryPolicy: vi.fn().mockReturnValue({
-            calculateBackoff: vi.fn().mockReturnValue(30_000),
-            shouldRetry: vi.fn().mockReturnValue(true),
-        }),
-        getRunsByTask: vi.fn().mockResolvedValue([{ runId: RUN_ID, taskId: TASK_ID }]),
-    };
-    const mockContextAssembler = {
-        assemble: vi.fn().mockResolvedValue(contextPayload),
-    };
-    const mockRuntimeAdapter = {
-        kind: vi.fn().mockReturnValue(RUNTIME_KIND),
-        getCapabilities: vi.fn(),
-        healthCheck: vi.fn(),
-        startRun: vi.fn().mockResolvedValue(runHandle),
-        pollRun: vi.fn().mockResolvedValue({
-            runId: RUN_ID,
-            status: 'succeeded',
-        }),
-        cancelRun: vi.fn().mockResolvedValue(undefined),
-        fetchOutput: vi.fn().mockResolvedValue({
-            runId: RUN_ID,
-            payload: output,
-        }),
-        fetchArtifacts: vi.fn(),
-    };
-    const mockValidator = {
-        validate: vi.fn().mockResolvedValue({
-            valid: true,
-            errors: [],
-        }),
-    };
-    const mockEventEmitter = {
-        emitTelemetry: vi.fn().mockReturnValue(true),
-        on: vi.fn(),
-        emit: vi.fn(),
-    };
-    return {
-        mockStateManager: mockStateManager,
-        mockContextAssembler: mockContextAssembler,
-        mockRuntimeAdapter: mockRuntimeAdapter,
-        mockValidator: mockValidator,
-        mockEventEmitter: mockEventEmitter,
-        taskRecord,
-        runHandle,
-        contextPayload,
-        output,
-        // Expose typed mocks for assertions
-        _stateManager: mockStateManager,
-        _contextAssembler: mockContextAssembler,
-        _runtimeAdapter: mockRuntimeAdapter,
-        _validator: mockValidator,
-        _committer: { commit: vi.fn().mockResolvedValue({ commitId: "mock-commit-id", artifactId: "mock-artifact-id", candidateCount: 0 }) },
-        _eventEmitter: mockEventEmitter,
-    };
-}
-function createRunner(mocks) {
-    return new DiagnosticianRunner({
-        stateManager: mocks.mockStateManager,
-        contextAssembler: mocks.mockContextAssembler,
-        runtimeAdapter: mocks.mockRuntimeAdapter,
-        eventEmitter: mocks.mockEventEmitter,
-        validator: mocks.mockValidator,
-        committer: mocks._committer,
-    }, {
-        owner: OWNER,
-        runtimeKind: RUNTIME_KIND,
-        pollIntervalMs: 100,
-        timeoutMs: 1000,
-    });
-}
-/** Type-safe helper to extract the first call argument from a mock. */
-function firstCallArg(mockFn) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return mockFn.mock.calls[0][0];
-}
-// ── Tests ──────────────────────────────────────────────────────────────────────
-describe('DiagnosticianRunner', () => {
-    beforeEach(() => {
-        vi.useFakeTimers({ shouldAdvanceTime: true });
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    // 1. Happy path
-    it('succeeds end-to-end when all phases complete normally', async () => {
-        const mocks = createMocks();
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        expect(result.status).toBe('succeeded');
-        expect(result.taskId).toBe(TASK_ID);
-        expect(result.output).toBeDefined();
-        expect(result.output?.diagnosisId).toBe('diag-001');
-        expect(result.contextHash).toBe('abc123hash');
-        expect(result.attemptCount).toBe(1);
-        expect(mocks._stateManager.acquireLease).toHaveBeenCalledWith({
-            taskId: TASK_ID,
-            owner: OWNER,
-            runtimeKind: RUNTIME_KIND,
-        });
-        expect(mocks._stateManager.markTaskSucceeded).toHaveBeenCalledWith(TASK_ID, 'commit://mock-commit-id');
-        expect(mocks._stateManager.updateRunOutput).toHaveBeenCalledWith(RUN_ID, JSON.stringify(mocks.output));
-    });
-    // 2. Polling loop
-    it('polls until terminal status is reached', async () => {
-        const mocks = createMocks();
-        // First poll: running, second poll: succeeded
-        mocks._runtimeAdapter.pollRun
-            .mockResolvedValueOnce({ runId: RUN_ID, status: 'running' })
-            .mockResolvedValueOnce({ runId: RUN_ID, status: 'succeeded' });
-        const runner = createRunner(mocks);
-        const resultPromise = runner.run(TASK_ID);
-        // Advance through the first sleep
-        await vi.advanceTimersByTimeAsync(200);
-        const result = await resultPromise;
-        expect(result.status).toBe('succeeded');
-        expect(mocks._runtimeAdapter.pollRun).toHaveBeenCalledTimes(2);
-    });
-    // 3. Timeout
-    it('cancels run and retries on timeout', async () => {
-        const mocks = createMocks();
-        // pollRun always returns 'running'
-        mocks._runtimeAdapter.pollRun.mockResolvedValue({ runId: RUN_ID, status: 'running' });
-        const runner = createRunner(mocks);
-        const resultPromise = runner.run(TASK_ID);
-        // Advance past timeout
-        await vi.advanceTimersByTimeAsync(1500);
-        const result = await resultPromise;
-        expect(mocks._runtimeAdapter.cancelRun).toHaveBeenCalledWith(RUN_ID);
-        // shouldRetry returns true by default, so it should be retried
-        expect(result.status).toBe('retried');
-        expect(result.errorCategory).toBe('timeout');
-    });
-    // 4. Runtime failure
-    it('handles runtime failure and retries if policy allows', async () => {
-        const mocks = createMocks();
-        mocks._runtimeAdapter.pollRun.mockResolvedValue({
-            runId: RUN_ID,
-            status: 'failed',
-            reason: 'agent error',
-        });
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        expect(result.status).toBe('retried');
-        expect(result.errorCategory).toBe('execution_failed');
-        expect(result.failureReason).toContain('failed');
-    });
-    // 5. Context build failure (transient)
-    it('retries on transient context assembly error', async () => {
-        const mocks = createMocks();
-        mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('runtime_unavailable', 'DB connection lost'));
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        expect(mocks._stateManager.markTaskRetryWait).toHaveBeenCalledWith(TASK_ID, 'runtime_unavailable');
-        expect(result.status).toBe('retried');
-        expect(result.errorCategory).toBe('runtime_unavailable');
-    });
-    // 6. Context build failure (permanent)
-    it('fails permanently on workspace_invalid error', async () => {
-        const mocks = createMocks();
-        mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('workspace_invalid', 'Workspace not found'));
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        expect(mocks._stateManager.markTaskFailed).toHaveBeenCalledWith(TASK_ID, 'workspace_invalid');
-        expect(result.status).toBe('failed');
-        expect(result.errorCategory).toBe('workspace_invalid');
-    });
-    // 7. Validation failure
-    it('retries or fails on validation failure', async () => {
-        const mocks = createMocks();
-        mocks._validator.validate.mockResolvedValue({
-            valid: false,
-            errors: ['Missing taskId', 'Invalid confidence'],
-            errorCategory: 'output_invalid',
-        });
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        // Default shouldRetry returns true
-        expect(result.status).toBe('retried');
-        expect(result.errorCategory).toBe('output_invalid');
-        expect(result.failureReason).toContain('Validation failed');
-    });
-    // 8b. StartRunInput construction with custom agentId
-    it('uses custom agentId from resolvedOptions when provided', async () => {
-        const mocks = createMocks();
-        const runner = new DiagnosticianRunner({
-            stateManager: mocks.mockStateManager,
-            contextAssembler: mocks.mockContextAssembler,
-            runtimeAdapter: mocks.mockRuntimeAdapter,
-            eventEmitter: mocks.mockEventEmitter,
-            validator: mocks.mockValidator,
-            committer: mocks._committer,
-        }, {
-            owner: OWNER,
-            runtimeKind: RUNTIME_KIND,
-            pollIntervalMs: 100,
-            timeoutMs: 1000,
-            agentId: 'custom-diagnostician',
-        });
-        await runner.run(TASK_ID);
-        const startInput = firstCallArg(mocks._runtimeAdapter.startRun);
-        expect(startInput.agentSpec.agentId).toBe('custom-diagnostician');
-    });
-    // 8c. StartRunInput uses default 'main' when agentId not provided
-    it('defaults agentSpec.agentId to main when agentId not provided', async () => {
-        const mocks = createMocks();
-        const runner = createRunner(mocks);
-        await runner.run(TASK_ID);
-        const startInput = firstCallArg(mocks._runtimeAdapter.startRun);
-        expect(startInput.agentSpec.agentId).toBe('main');
-    });
-    // 9. Lease conflict
-    it('lease_conflict returns non-mutating result without markTaskRetryWait/markTaskFailed', async () => {
-        const mocks = createMocks();
-        mocks._stateManager.acquireLease.mockRejectedValue(new PDRuntimeError('lease_conflict', 'Task already leased'));
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        // lease_conflict is handled as non-mutating — no state changes
-        expect(result.status).toBe('failed');
-        expect(result.errorCategory).toBe('lease_conflict');
-        // Mutation methods must NOT be called for lease_conflict
-        expect(mocks._stateManager.markTaskRetryWait).not.toHaveBeenCalled();
-        expect(mocks._stateManager.markTaskFailed).not.toHaveBeenCalled();
-    });
-    // 9b. Post-lease errors use real leasedTask (not synthetic)
-    it('post-lease error uses real attemptCount/maxAttempts from leasedTask', async () => {
-        const mocks = createMocks();
-        // leasedTask has attemptCount=2, maxAttempts=3 (not the default 1/3)
-        mocks._stateManager.acquireLease.mockResolvedValue(makeTaskRecord({ attemptCount: 2, maxAttempts: 3 }));
-        // Make context assembly fail to trigger post-lease error path
-        mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('runtime_unavailable', 'DB connection lost'));
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        // Should retry (not fail permanently) because runtime_unavailable is not permanent
-        // and real leasedTask (attemptCount=2, maxAttempts=3) means shouldRetry returns true
-        expect(result.status).toBe('retried');
-        // Verify markTaskRetryWait was called with the real task's attemptCount
-        expect(mocks._stateManager.markTaskRetryWait).toHaveBeenCalledWith(TASK_ID, 'runtime_unavailable');
-    });
-    // 9c. Post-lease error with maxAttempts=1 triggers fail immediately
-    it('post-lease error with attemptCount=maxAttempts fails permanently', async () => {
-        const mocks = createMocks();
-        // leasedTask at last attempt (attemptCount=3, maxAttempts=3)
-        mocks._stateManager.acquireLease.mockResolvedValue(makeTaskRecord({ attemptCount: 3, maxAttempts: 3 }));
-        // Override shouldRetry to return false when attemptCount >= maxAttempts
-        mocks._stateManager.getRetryPolicy.mockReturnValue({
-            calculateBackoff: vi.fn().mockReturnValue(30_000),
-            shouldRetry: vi.fn().mockReturnValue(false),
-        });
-        // Make context assembly fail
-        mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('runtime_unavailable', 'DB connection lost'));
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        // Should fail with max_attempts_exceeded (not runtime_unavailable)
-        // because shouldRetry=false means no more retries
-        expect(result.status).toBe('failed');
-        expect(result.errorCategory).toBe('max_attempts_exceeded');
-        expect(mocks._stateManager.markTaskFailed).toHaveBeenCalledWith(TASK_ID, 'max_attempts_exceeded');
-    });
-    // 10. Max attempts exceeded
-    it('marks task failed when max attempts exceeded', async () => {
-        const mocks = createMocks();
-        // Make shouldRetry return false
-        mocks._stateManager.getRetryPolicy.mockReturnValue({
-            calculateBackoff: vi.fn().mockReturnValue(30_000),
-            shouldRetry: vi.fn().mockReturnValue(false),
-        });
-        // Trigger a failure path (runtime failure)
-        mocks._runtimeAdapter.pollRun.mockResolvedValue({
-            runId: RUN_ID,
-            status: 'failed',
-            reason: 'agent error',
-        });
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        expect(mocks._stateManager.markTaskFailed).toHaveBeenCalledWith(TASK_ID, 'max_attempts_exceeded');
-        expect(result.status).toBe('failed');
-        expect(result.errorCategory).toBe('max_attempts_exceeded');
-    });
-    // 11. OpenClaw history compatibility
-    it('passes through openclaw-history context without inspection', async () => {
-        const mocks = createMocks();
-        // Context with mixed runtime_kind entries (openclaw-imported format)
-        const openClawContext = makeContextPayload({
-            sourceRefs: ['trajectory-001', 'openclaw-history-import-002'],
-            conversationWindow: [
-                { ts: '2026-04-23T00:00:00Z', role: 'user', text: 'hello from openclaw' },
-                { ts: '2026-04-23T00:01:00Z', role: 'assistant', text: 'response from openclaw' },
-                { ts: '2026-04-23T00:02:00Z', role: 'tool', toolName: 'Write', toolResultSummary: 'wrote file' },
-            ],
-        });
-        mocks._contextAssembler.assemble.mockResolvedValue(openClawContext);
-        const runner = createRunner(mocks);
-        const result = await runner.run(TASK_ID);
-        // Runner should NOT reject the context
-        expect(result.status).toBe('succeeded');
-        // startRun should have been called with the context serialized in inputPayload
-        const startInput = firstCallArg(mocks._runtimeAdapter.startRun);
-        const inputPayloadStr = startInput.inputPayload;
-        const inputPayload = JSON.parse(inputPayloadStr);
-        expect(inputPayload.context.conversationWindow).toHaveLength(3);
-        expect(inputPayload.context.sourceRefs).toContain('openclaw-history-import-002');
-        // contextItems should be empty (instruction embedded in inputPayload)
-        expect(startInput.contextItems).toHaveLength(0);
-    });
-    // ── Committer integration tests (m5-03 Task 5) ──────────────────────────────
-    describe('Committer integration', () => {
-        // 12. Commit before markTaskSucceeded (call order)
-        it('calls committer.commit before markTaskSucceeded', async () => {
-            const mocks = createMocks();
-            const callOrder = [];
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockImplementation(async () => {
-                callOrder.push('commit');
-                return { commitId: 'call-order-commit-id', artifactId: 'art-1', candidateCount: 1 };
-            });
-            mocks._stateManager.markTaskSucceeded.mockImplementation(async () => {
-                callOrder.push('markTaskSucceeded');
-                return mocks.taskRecord;
-            });
-            const runner = createRunner(mocks);
-            await runner.run(TASK_ID);
-            expect(callOrder).toEqual(['commit', 'markTaskSucceeded']);
-        });
-        // 13. resultRef uses commit:// scheme
-        it('resultRef uses commit:// scheme after commit', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockResolvedValue({
-                commitId: 'verify-commit-123',
-                artifactId: 'art-verify',
-                candidateCount: 3,
-            });
-            const runner = createRunner(mocks);
-            await runner.run(TASK_ID);
-            expect(mocks._stateManager.markTaskSucceeded).toHaveBeenCalledWith(TASK_ID, 'commit://verify-commit-123');
-        });
-        // 14. Commit failure triggers retry with artifact_commit_failed
-        it('commit failure triggers retry with artifact_commit_failed', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockRejectedValue(new PDRuntimeError('artifact_commit_failed', 'Commit failed', {}));
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('retried');
-            expect(result.errorCategory).toBe('artifact_commit_failed');
-            expect(mocks._stateManager.markTaskSucceeded).not.toHaveBeenCalled();
-            expect(mocks._stateManager.markTaskRetryWait).toHaveBeenCalledWith(TASK_ID, 'artifact_commit_failed');
-        });
-        // 15. Commit failure with max attempts marks task failed
-        it('commit failure with max attempts marks task failed', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockRejectedValue(new PDRuntimeError('artifact_commit_failed', 'Commit failed', {}));
-            mocks._stateManager.getRetryPolicy.mockReturnValue({
-                calculateBackoff: vi.fn().mockReturnValue(30_000),
-                shouldRetry: vi.fn().mockReturnValue(false),
-            });
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('failed');
-            expect(result.errorCategory).toBe('max_attempts_exceeded');
-            expect(mocks._stateManager.markTaskFailed).toHaveBeenCalledWith(TASK_ID, 'max_attempts_exceeded');
-        });
-        // 16. RunnerPhase transitions through Committing
-        it('RunnerPhase transitions through Committing during commit', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockResolvedValue({
-                commitId: 'phase-test-commit',
-                artifactId: 'art-phase',
-                candidateCount: 0,
-            });
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('succeeded');
-            expect(typedCommitter.commit).toHaveBeenCalledTimes(1);
-            expect(runner.currentPhase).toBe(RunnerPhase.Completed);
-        });
-    });
-    // ── M5-04: Telemetry events ───────────────────────────────────────────────
-    describe('M5-04 Telemetry events', () => {
-        // TELE-01: diagnostician_artifact_committed emitted after successful commit
-        it('emits diagnostician_artifact_committed after successful commit', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockResolvedValue({
-                commitId: 'commit-artifact-001',
-                artifactId: 'artifact-001',
-                candidateCount: 2,
-            });
-            const runner = createRunner(mocks);
-            await runner.run(TASK_ID);
-            expect(mocks._eventEmitter.emitTelemetry).toHaveBeenCalledWith(expect.objectContaining({
-                eventType: 'diagnostician_artifact_committed',
-                traceId: TASK_ID,
-                payload: expect.objectContaining({
-                    commitId: 'commit-artifact-001',
-                    artifactId: 'artifact-001',
-                    candidateCount: 2,
-                    taskId: TASK_ID,
-                    runId: RUN_ID,
-                }),
-            }));
-        });
-        // TELE-02: diagnostician_artifact_commit_failed emitted when commit throws
-        it('emits diagnostician_artifact_commit_failed when commit throws', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockRejectedValue(new PDRuntimeError('artifact_commit_failed', 'Database constraint violation', {}));
-            const runner = createRunner(mocks);
-            await runner.run(TASK_ID);
-            expect(mocks._eventEmitter.emitTelemetry).toHaveBeenCalledWith(expect.objectContaining({
-                eventType: 'diagnostician_artifact_commit_failed',
-                traceId: TASK_ID,
-                payload: expect.objectContaining({
-                    taskId: TASK_ID,
-                    runId: RUN_ID,
-                    errorCategory: 'artifact_commit_failed',
-                }),
-            }));
-        });
-        // TELE-03: principle_candidate_registered emitted per principle candidate
-        it('emits principle_candidate_registered for each principle recommendation', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockResolvedValue({
-                commitId: 'commit-candidate-001',
-                artifactId: 'artifact-001',
-                candidateCount: 2,
-            });
-            // Override output with 2 principle recommendations
-            const output = makeDiagnosticianOutput({
-                recommendations: [
-                    { kind: 'principle', description: 'Use immutable data structures' },
-                    { kind: 'principle', description: 'Prefer pure functions' },
-                    { kind: 'rule', description: 'Follow existing naming conventions' },
-                ],
-            });
-            mocks._runtimeAdapter.fetchOutput = vi.fn().mockResolvedValue({
-                runId: RUN_ID,
-                payload: output,
-            });
-            const runner = createRunner(mocks);
-            await runner.run(TASK_ID);
-            // Should have 2 calls to principle_candidate_registered
-            const candidateEvents = mocks._eventEmitter.emitTelemetry.mock.calls.filter((call) => call[0]?.eventType === 'principle_candidate_registered');
-            expect(candidateEvents).toHaveLength(2);
-            const [firstEvent, secondEvent] = candidateEvents;
-            if (!firstEvent || !secondEvent) {
-                throw new Error('Expected 2 candidate events but got fewer');
-            }
-            expect(firstEvent[0]?.payload).toMatchObject({
-                commitId: 'commit-candidate-001',
-                kind: 'principle',
-                candidateIndex: 0,
-                sourceRunId: RUN_ID,
-            });
-            expect(secondEvent[0]?.payload).toMatchObject({
-                commitId: 'commit-candidate-001',
-                kind: 'principle',
-                candidateIndex: 1,
-                sourceRunId: RUN_ID,
-            });
-        });
-        // TELE-04: all events use emitTelemetry (StoreEventEmitter)
-        it('all new telemetry events use emitTelemetry, not console.log or side effects', async () => {
-            const mocks = createMocks();
-            const typedCommitter = mocks._committer;
-            typedCommitter.commit.mockResolvedValue({
-                commitId: 'commit-tele-004',
-                artifactId: 'artifact-004',
-                candidateCount: 1,
-            });
-            // Override output with 1 principle recommendation so the event fires
-            const output = makeDiagnosticianOutput({
-                recommendations: [
-                    { kind: 'principle', description: 'Test principle' },
-                ],
-            });
-            mocks._runtimeAdapter.fetchOutput = vi.fn().mockResolvedValue({
-                runId: RUN_ID,
-                payload: output,
-            });
-            const runner = createRunner(mocks);
-            await runner.run(TASK_ID);
-            // All 3 new event types should go through emitTelemetry
-            const allEventTypes = mocks._eventEmitter.emitTelemetry.mock.calls.map((call) => call[0]?.eventType);
-            expect(allEventTypes).toContain('diagnostician_artifact_committed');
-            expect(allEventTypes).toContain('principle_candidate_registered');
-        });
-    });
-    // ── PRI-137: workspace_dirty as permanent error ──────────────────────────────────
-    describe('PRI-137: workspace_dirty permanent error handling', () => {
-        it('fails permanently on workspace_dirty error (never retries)', async () => {
-            const mocks = createMocks();
-            mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('workspace_dirty', 'Workspace contains uncommitted changes', {
-                dirtyFiles: ['file1.ts', 'file2.ts'],
-            }));
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('failed');
-            expect(result.errorCategory).toBe('workspace_dirty');
-            expect(result.failureReason).toContain('workspace_dirty');
-            expect(mocks._stateManager.markTaskFailed).toHaveBeenCalledWith(TASK_ID, 'workspace_dirty');
-            expect(mocks._stateManager.markTaskRetryWait).not.toHaveBeenCalled();
-        });
-        it('workspace_dirty fails immediately even when shouldRetry returns true', async () => {
-            const mocks = createMocks();
-            mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('workspace_dirty', 'Dirty workspace detected'));
-            mocks._stateManager.getRetryPolicy.mockReturnValue({
-                calculateBackoff: vi.fn().mockReturnValue(30_000),
-                shouldRetry: vi.fn().mockReturnValue(true),
-            });
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('failed');
-            expect(result.errorCategory).toBe('workspace_dirty');
-            expect(mocks._stateManager.markTaskRetryWait).not.toHaveBeenCalled();
-            expect(mocks._stateManager.markTaskFailed).toHaveBeenCalledWith(TASK_ID, 'workspace_dirty');
-        });
-        it('workspace_dirty is in PERMANENT_ERROR_CATEGORIES set', async () => {
-            const mocks = createMocks();
-            mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('workspace_dirty', 'Workspace dirty'));
-            mocks._stateManager.getRetryPolicy.mockReturnValue({
-                calculateBackoff: vi.fn().mockReturnValue(30_000),
-                shouldRetry: vi.fn().mockReturnValue(false),
-            });
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('failed');
-            expect(result.errorCategory).toBe('workspace_dirty');
-        });
-        it('emits task_failed telemetry with workspace_dirty category', async () => {
-            const mocks = createMocks();
-            mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('workspace_dirty', 'Uncommitted changes found'));
-            const runner = createRunner(mocks);
-            await runner.run(TASK_ID);
-            const allEventTypes = mocks._eventEmitter.emitTelemetry.mock.calls.map((call) => call[0]?.eventType);
-            expect(allEventTypes).toContain('diagnostician_task_failed');
-            const taskFailedEvents = mocks._eventEmitter.emitTelemetry.mock.calls
-                .filter((call) => call[0]?.eventType === 'diagnostician_task_failed');
-            expect(taskFailedEvents[0]?.[0]?.payload?.errorCategory).toBe('workspace_dirty');
-        });
-        it('capability_missing also fails permanently (part of permanent error set)', async () => {
-            const mocks = createMocks();
-            mocks._contextAssembler.assemble.mockRejectedValue(new PDRuntimeError('capability_missing', 'Required capability not available'));
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('failed');
-            expect(result.errorCategory).toBe('capability_missing');
-            expect(mocks._stateManager.markTaskFailed).toHaveBeenCalledWith(TASK_ID, 'capability_missing');
-            expect(mocks._stateManager.markTaskRetryWait).not.toHaveBeenCalled();
-        });
-    });
-    // ── ERR-001/005: Runner boundary schema validation ──────────────────────────
-    describe('Runner boundary schema validation (ERR-001/005)', () => {
-        it('rejects adapter payload that does not match DiagnosticianOutputV1Schema', async () => {
-            const mocks = createMocks();
-            // Adapter returns payload that bypasses its own validation (defense-in-depth test)
-            mocks._runtimeAdapter.fetchOutput = vi.fn().mockResolvedValue({
-                runId: RUN_ID,
-                payload: { wrong: 'shape', missing: 'all required fields' },
-            });
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            // Should end up in retry_wait/output_invalid, not silently accepted
-            expect(result.status).toBe('retried');
-            expect(result.errorCategory).toBe('output_invalid');
-        });
-        it('includes evidence in output_invalid error when runner boundary rejects payload', async () => {
-            const mocks = createMocks();
-            mocks._runtimeAdapter.fetchOutput = vi.fn().mockResolvedValue({
-                runId: RUN_ID,
-                payload: { invalid: true },
-            });
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('retried');
-            expect(result.errorCategory).toBe('output_invalid');
-            // The retry_wait call should have been made with output_invalid
-            expect(mocks._stateManager.markTaskRetryWait).toHaveBeenCalledWith(TASK_ID, 'output_invalid');
-        });
-        it('accepts valid DiagnosticianOutputV1 payload through runner boundary', async () => {
-            const mocks = createMocks();
-            const validOutput = makeDiagnosticianOutput();
-            mocks._runtimeAdapter.fetchOutput = vi.fn().mockResolvedValue({
-                runId: RUN_ID,
-                payload: validOutput,
-            });
-            const runner = createRunner(mocks);
-            const result = await runner.run(TASK_ID);
-            expect(result.status).toBe('succeeded');
-        });
-    });
-});
-//# sourceMappingURL=diagnostician-runner.test.js.map