create-principles-disciple 1.0.0 → 1.74.0

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

@@ -0,0 +1,642 @@
+/**
+ * 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();
+        });
+    });
+});
+//# sourceMappingURL=diagnostician-runner.test.js.map