@principles/core 1.83.0 → 1.84.0

package/dist/runtime-v2/internalization/dreamer-runner.js

@@ -1,15 +1,15 @@
 import { PDRuntimeError } from '../error-categories.js';
 import { hydratePITaskRecord } from './pitask-metadata.js';
-import { RunnerPhase } from '../runner/runner-phase.js';
 import { DreamerPromptBuilder } from './dreamer-prompt-builder.js';
 import { injectRunnerLineageIfAbsent } from './peer-runner-contracts.js';
-const DEFAULT_DREAMER_RUNNER_OPTIONS = {
+import { BasePeerRunner } from '../runner/base-peer-runner.js';
+export const DEFAULT_DREAMER_RUNNER_OPTIONS = {
     pollIntervalMs: 5_000,
     timeoutMs: 300_000,
     defaultMaxAttempts: 3,
     agentId: 'dreamer',
 };
-function resolveDreamerRunnerOptions(options) {
+export function resolveDreamerRunnerOptions(options) {
     return {
         pollIntervalMs: options.pollIntervalMs ?? DEFAULT_DREAMER_RUNNER_OPTIONS.pollIntervalMs,
         timeoutMs: options.timeoutMs ?? DEFAULT_DREAMER_RUNNER_OPTIONS.timeoutMs,
@@ -19,151 +19,23 @@ function resolveDreamerRunnerOptions(options) {
         agentId: options.agentId ?? DEFAULT_DREAMER_RUNNER_OPTIONS.agentId,
     };
 }
-// ── DreamerRunner ─────────────────────────────────────────────────────────────
-export class DreamerRunner {
-    phase = RunnerPhase.Idle;
-    resolvedOptions;
-    stateManager;
-    runtimeAdapter;
-    eventEmitter;
+// ── DreamerRunner ────────────────────────────────────────────────────────────
+export class DreamerRunner extends BasePeerRunner {
     validator;
-    artifactStore;
     constructor(deps, options) {
-        this.stateManager = deps.stateManager;
-        this.runtimeAdapter = deps.runtimeAdapter;
-        this.eventEmitter = deps.eventEmitter;
-        this.validator = deps.validator;
-        this.artifactStore = deps.artifactStore;
-        this.resolvedOptions = resolveDreamerRunnerOptions(options);
-    }
-    /** Get the current internal phase. For testing/observability only. */
-    get currentPhase() {
-        return this.phase;
-    }
-    emitDreamerEvent(eventType, taskId, payload) {
-        this.eventEmitter.emitTelemetry({
-            eventType: eventType,
-            traceId: taskId,
-            timestamp: new Date().toISOString(),
-            sessionId: this.resolvedOptions.owner,
-            agentId: this.resolvedOptions.agentId,
-            payload,
+        super(deps, options, {
+            runnerName: 'dreamer',
+            expectedTaskKind: 'dreamer',
+            defaultAgentId: 'dreamer',
+            resultRefPrefix: 'dreamer',
         });
+        this.validator = deps.validator;
     }
-    /**
-     * Execute the full Dreamer lifecycle for a task.
-     *
-     * The runner does NOT hold mutable state between run() calls.
-     * Each invocation is independent.
-     */
-    async run(taskId) {
-        this.phase = RunnerPhase.Idle;
-        // 1. Acquire lease — isolated try/catch so lease_conflict never uses synthetic TaskRecord
-        let leasedTask;
-        try {
-            leasedTask = await this.stateManager.acquireLease({
-                taskId,
-                owner: this.resolvedOptions.owner,
-                runtimeKind: this.resolvedOptions.runtimeKind,
-            });
-        }
-        catch (error) {
-            return await this.handleLeaseOrPhaseError(taskId, error);
-        }
-        this.emitDreamerEvent('dreamer_task_leased', taskId, {
-            taskKind: 'dreamer',
-            attemptCount: leasedTask.attemptCount,
-        });
-        if (leasedTask.taskKind !== 'dreamer') {
-            this.emitDreamerEvent('dreamer_wrong_task_kind', taskId, {
-                expectedKind: 'dreamer',
-                actualKind: leasedTask.taskKind,
-            });
-            await this.stateManager.markTaskFailed(taskId, 'input_invalid');
-            return {
-                status: 'failed',
-                taskId,
-                errorCategory: 'input_invalid',
-                failureReason: `Task kind must be 'dreamer', got '${leasedTask.taskKind}'`,
-                attemptCount: leasedTask.attemptCount,
-            };
-        }
-        // All subsequent errors use the real leasedTask — no synthetic TaskRecord allowed
-        try {
-            // acquireLease creates a RunRecord; resolve its runId for store operations
-            const storeRunId = await this.resolveStoreRunId(taskId);
-            // 2. Build context from predecessor task outputs (no ContextAssembler)
-            this.phase = RunnerPhase.BuildingContext;
-            const { contextHash, contextRefs, predecessorOutput } = await this.buildContext(taskId);
-            this.emitDreamerEvent('dreamer_context_built', taskId, { contextHash });
-            // 3. Invoke runtime
-            this.phase = RunnerPhase.Invoking;
-            const runHandle = await this.invokeRuntime({ taskId, contextHash, contextRefs, predecessorOutput });
-            this.emitDreamerEvent('dreamer_run_started', taskId, {
-                runtimeKind: this.resolvedOptions.runtimeKind,
-            });
-            // 4. Poll until terminal
-            this.phase = RunnerPhase.Polling;
-            const finalStatus = await this.pollUntilTerminal(runHandle);
-            // 5. Handle non-success terminal states
-            if (finalStatus.status !== 'succeeded') {
-                return await this.handleRuntimeFailure(taskId, leasedTask, finalStatus);
-            }
-            // 6. Fetch output
-            this.phase = RunnerPhase.FetchingOutput;
-            const output = await this.fetchAndParseOutput(runHandle.runId, taskId);
-            // Re-inject taskId if stripped by stripLineageFields (PRI-272 / ERR-008).
-            // Only fill when absent via Object.hasOwn — present-but-falsy values
-            // must reach validation and fail loud (Runtime Contract Rule 3).
-            injectRunnerLineageIfAbsent(output, 'taskId', taskId);
-            // 7. Validate
-            this.phase = RunnerPhase.Validating;
-            const validationResult = await this.validator.validate(output, taskId);
-            if (!validationResult.valid) {
-                return await this.handleValidationError({
-                    taskId,
-                    task: leasedTask,
-                    errors: validationResult.errors,
-                    errorCategory: validationResult.errorCategory,
-                });
-            }
-            this.emitDreamerEvent('dreamer_output_validated', taskId, {
-                candidateCount: output.candidates.length,
-            });
-            // 8. Succeed task
-            return await this.succeedTask({
-                taskId,
-                runId: storeRunId,
-                output,
-                task: leasedTask,
-                contextHash,
-            });
-        }
-        catch (error) {
-            // handleLeaseOrPhaseError is only for lease errors (before lease).
-            // Post-lease errors use retryOrFail with the real leasedTask.
-            return await this.handlePostLeaseError(taskId, leasedTask, error);
-        }
+    // ── Abstract implementations ───────────────────────────────────────────────
+    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+    get permanentErrorCategories() {
+        return new Set(['storage_unavailable', 'workspace_invalid', 'capability_missing', 'cancelled', 'input_invalid']);
     }
-    // ── Phase methods ─────────────────────────────────────────────────────────
-    /**
-     * Build context from predecessor task outputs.
-     *
-     * Dreamer doesn't use ContextAssembler — it resolves predecessor context
-     * from dependencyTaskIds via stateManager.getTask(). The predecessor's
-     * resultRef/outputArtifactRefs become the Dreamer's input context.
-     *
-     * Degradation semantics (intentional partial failure):
-     *   - If ALL dependencies fail → builds empty context (continues, not fail-closed)
-     *   - If SOME dependencies fail → builds partial context + emits dreamer_context_partial
-     *   - Only fulfilled results contribute contextRefs
-     *
-     * This is a deliberate design choice: Dreamer can produce output with partial
-     * context, whereas the host layer's task-ready validation is fail-closed.
-     * Partial context is reported via telemetry.
-     *
-     * @see hydratePITaskRecord (PRI-65) for fail-closed PI metadata access
-     */
     async buildContext(taskId) {
         const task = await this.stateManager.getTask(taskId);
         if (!task) {
@@ -207,434 +79,146 @@ export class DreamerRunner {
             }
         }
         if (rejectedDeps.length > 0) {
-            this.emitDreamerEvent('dreamer_context_partial', taskId, {
+            this.emitEvent('context_partial', taskId, {
                 rejectedCount: rejectedDeps.length,
                 rejectedDeps,
             });
         }
-        const contextHash = DreamerRunner.hashContextRefs(contextRefs);
+        const contextHash = BasePeerRunner.hashContextRefs(contextRefs);
         return { contextHash, contextRefs, predecessorOutput };
     }
-    /**
-     * Compute a deterministic hash from context references.
-     * Used for telemetry and result tracking, not for caching.
-     */
-    static hashContextRefs(refs) {
-        if (refs.length === 0)
-            return 'empty';
-        // Simple deterministic hash via DJB2-style accumulator
-        // Not cryptographic — only used for observability
-        const str = refs.join('|');
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            hash = (Math.imul(31, hash) + str.charCodeAt(i)) | 0;
-        }
-        return `ctx-${Math.abs(hash).toString(16)}`;
-    }
-    async resolveStoreRunId(taskId) {
-        const runs = await this.stateManager.getRunsByTask(taskId);
-        const latestRun = runs[runs.length - 1];
-        if (!latestRun) {
-            throw new PDRuntimeError('execution_failed', `No run records found for task ${taskId} after lease acquisition`);
-        }
-        return latestRun.runId;
-    }
-    async resolveLineageArtifactIds(taskId) {
-        const task = await this.stateManager.getTask(taskId);
-        if (!task)
-            return { ids: [], hasRejected: false };
-        const piTask = hydratePITaskRecord(task);
-        const deps = piTask?.dependencyTaskIds ?? [];
-        if (deps.length === 0)
-            return { ids: [], hasRejected: false };
-        const lineageIds = [];
-        let hasRejected = false;
-        const results = await Promise.allSettled(deps.map((depId) => this.artifactStore.listBySourceTaskId(depId)));
-        for (const result of results) {
-            if (result.status === 'fulfilled') {
-                for (const artifact of result.value) {
-                    lineageIds.push(artifact.artifactId);
-                }
-            }
-            else {
-                hasRejected = true;
-            }
-        }
-        return { ids: lineageIds, hasRejected };
-    }
-    async invokeRuntime(params) {
+    async invokeRuntime(taskId, context) {
         const builder = new DreamerPromptBuilder();
         const { message } = builder.buildPrompt({
-            taskId: params.taskId,
-            contextHash: params.contextHash,
-            contextRefs: params.contextRefs,
-            predecessorOutput: params.predecessorOutput,
+            taskId,
+            contextHash: context.contextHash,
+            contextRefs: context.contextRefs,
+            predecessorOutput: context.predecessorOutput,
         });
-        const startInput = {
+        return this.runtimeAdapter.startRun({
             agentSpec: { agentId: this.resolvedOptions.agentId, schemaVersion: 'v1' },
-            taskRef: { taskId: params.taskId },
+            taskRef: { taskId },
             inputPayload: message,
             contextItems: [],
             outputSchemaRef: 'dreamer-output-v1',
             timeoutMs: this.resolvedOptions.timeoutMs,
-        };
-        return this.runtimeAdapter.startRun(startInput);
-    }
-    async pollUntilTerminal(runHandle) {
-        const deadline = Date.now() + this.resolvedOptions.timeoutMs;
-        const terminalStatuses = ['succeeded', 'failed', 'timed_out', 'cancelled'];
-        while (Date.now() < deadline) {
-            const status = await this.runtimeAdapter.pollRun(runHandle.runId);
-            if (terminalStatuses.includes(status.status)) {
-                return status;
-            }
-            await this.sleep(this.resolvedOptions.pollIntervalMs);
-        }
-        // Timeout — cancel gracefully, preserve timeout error with cancel status
-        let cancelFailed = false;
-        try {
-            await this.runtimeAdapter.cancelRun(runHandle.runId);
-        }
-        catch (cancelErr) {
-            cancelFailed = true;
-            this.emitDreamerEvent('dreamer_cancel_run_failed', runHandle.runId, {
-                runId: runHandle.runId,
-                errorMessage: cancelErr instanceof Error ? cancelErr.message : String(cancelErr),
-            });
-        }
-        const cancelNote = cancelFailed ? ' (cancelRun also failed)' : '';
-        throw new PDRuntimeError('timeout', `Run ${runHandle.runId} timed out after ${this.resolvedOptions.timeoutMs}ms${cancelNote}`);
-    }
-    async fetchAndParseOutput(runId, taskId) {
-        const result = await this.fetchOutputWithTelemetry(runId, taskId);
-        if (!result || !result.payload) {
-            this.emitDreamerEvent('dreamer_output_extraction_failed', taskId, {
-                runId,
-                stage: 'payload_missing',
-                errorMessage: `No output available for run ${runId}`,
-            });
-            throw new PDRuntimeError('output_invalid', `No output available for run ${runId}`);
-        }
-        const payload = result.payload;
-        if (typeof payload !== 'object' || payload === null) {
-            this.emitDreamerEvent('dreamer_output_extraction_failed', taskId, {
-                runId,
-                stage: 'payload_not_object',
-                errorMessage: `Output payload is not an object for run ${runId}`,
-            });
-            throw new PDRuntimeError('output_invalid', `Output payload is not an object for run ${runId}`);
-        }
-        return result.payload;
+        });
     }
-    async fetchOutputWithTelemetry(runId, taskId) {
-        try {
-            return await this.runtimeAdapter.fetchOutput(runId);
-        }
-        catch (fetchErr) {
-            this.emitDreamerEvent('dreamer_output_extraction_failed', taskId, {
-                runId,
-                stage: 'fetchOutput',
-                errorMessage: fetchErr instanceof Error ? fetchErr.message : String(fetchErr),
-            });
-            throw fetchErr;
-        }
+    async validateOutput(output, taskId) {
+        const result = await this.validator.validate(output, taskId);
+        return {
+            valid: result.valid,
+            errors: result.errors,
+            errorCategory: result.errorCategory,
+        };
     }
-    async succeedTask(ctx) {
-        // Store output before marking succeeded so run record reflects output
+    // eslint-disable-next-line @typescript-eslint/max-params
+    async succeedTask(taskId, runId, output, task, contextHash, _context) {
+        // Store output before marking succeeded
         try {
-            await this.stateManager.updateRunOutput(ctx.runId, JSON.stringify(ctx.output));
+            await this.stateManager.updateRunOutput(runId, JSON.stringify(output));
         }
         catch (updateErr) {
-            this.emitDreamerEvent('dreamer_update_output_failed', ctx.taskId, {
-                runId: ctx.runId,
+            this.emitEvent('update_output_failed', taskId, {
+                runId,
                 errorMessage: updateErr instanceof Error ? updateErr.message : String(updateErr),
             });
             throw updateErr;
         }
-        // Emit per-candidate telemetry
-        for (const candidate of ctx.output.candidates) {
-            this.emitDreamerEvent('dreamer_candidate_generated', ctx.taskId, {
-                candidateIndex: candidate.candidateIndex,
-                confidence: candidate.confidence,
-                riskLevel: candidate.riskLevel,
-            });
-        }
         // Write PIArtifact via artifactStore (idempotent upsert)
-        // PIArtifact is the core durable output of DreamerRunner.
-        // If artifact write fails, the task must NOT be marked succeeded —
-        // downstream runners (Philosopher/Scribe) require durable artifact input.
         let lineageArtifactIds = [];
         let lineageHasRejected = false;
         try {
-            const lineageResult = await this.resolveLineageArtifactIds(ctx.taskId);
+            const lineageResult = await this.resolveLineageArtifactIds(taskId);
             lineageArtifactIds = lineageResult.ids;
             lineageHasRejected = lineageResult.hasRejected;
         }
         catch (lineageErr) {
-            this.emitDreamerEvent('dreamer_lineage_resolve_failed', ctx.taskId, {
-                runId: ctx.runId,
+            this.emitEvent('lineage_resolve_failed', taskId, {
+                runId,
                 errorMessage: lineageErr instanceof Error ? lineageErr.message : String(lineageErr),
             });
         }
         if (lineageHasRejected) {
-            this.emitDreamerEvent('dreamer_lineage_partial', ctx.taskId, {
-                runId: ctx.runId,
+            this.emitEvent('lineage_partial', taskId, {
+                runId,
                 resolvedCount: lineageArtifactIds.length,
                 warning: 'Some dependency artifact queries were rejected; lineage may be incomplete',
             });
         }
-        const artifactId = `pi-art-${ctx.taskId}-${ctx.runId}`;
+        const artifactId = `pi-art-${taskId}-${runId}`;
         const now = new Date().toISOString();
         try {
             await this.artifactStore.upsertArtifact({
                 artifactId,
                 artifactKind: 'principle',
-                sourceTaskId: ctx.taskId,
+                sourceTaskId: taskId,
                 lineageArtifactIds,
                 validationStatus: 'pending',
-                contentJson: JSON.stringify(ctx.output),
+                contentJson: JSON.stringify(output),
                 createdAt: now,
                 updatedAt: now,
             });
         }
         catch (artifactErr) {
-            this.emitDreamerEvent('dreamer_artifact_write_failed', ctx.taskId, {
-                runId: ctx.runId,
+            this.emitEvent('artifact_write_failed', taskId, {
+                runId,
                 errorMessage: artifactErr instanceof Error ? artifactErr.message : String(artifactErr),
             });
             return this.retryOrFail({
-                taskId: ctx.taskId,
-                task: ctx.task,
+                taskId,
+                task,
                 errorCategory: 'artifact_commit_failed',
                 failureReason: `PIArtifact write failed: ${artifactErr instanceof Error ? artifactErr.message : String(artifactErr)}`,
             });
         }
-        // Mark task succeeded with dreamer:// resultRef
-        const resultRef = `dreamer://${ctx.runId}`;
+        // Mark task succeeded
+        const resultRef = `${this.config.resultRefPrefix}://${runId}`;
         try {
-            await this.stateManager.markTaskSucceeded(ctx.taskId, resultRef);
+            await this.stateManager.markTaskSucceeded(taskId, resultRef);
         }
         catch (stateErr) {
-            this.emitDreamerEvent('dreamer_mark_succeeded_failed', ctx.taskId, {
-                taskId: ctx.taskId,
-                runId: ctx.runId,
+            this.emitEvent('mark_succeeded_failed', taskId, {
+                taskId,
+                runId,
                 errorMessage: stateErr instanceof Error ? stateErr.message : String(stateErr),
             });
             throw stateErr;
         }
-        this.emitDreamerEvent('dreamer_task_succeeded', ctx.taskId, {
-            attemptCount: ctx.task.attemptCount,
+        this.emitEvent('task_succeeded', taskId, {
+            attemptCount: task.attemptCount,
             resultRef,
-            candidateCount: ctx.output.candidates.length,
+            candidateCount: output.candidates.length,
         });
-        this.phase = RunnerPhase.Completed;
         return {
             status: 'succeeded',
-            taskId: ctx.taskId,
-            runId: ctx.runId,
+            taskId,
+            runId,
             artifactId,
             resultRef,
-            contextHash: ctx.contextHash,
-            output: ctx.output,
-            attemptCount: ctx.task.attemptCount,
-        };
-    }
-    async handleRuntimeFailure(taskId, task, runStatus) {
-        const errorCategory = this.mapRunStatusToErrorCategory(runStatus.status, runStatus.reason);
-        this.emitDreamerEvent('dreamer_run_failed', taskId, {
-            runStatus: runStatus.status,
-            errorCategory,
-        });
-        return this.retryOrFail({
-            taskId,
-            task,
-            errorCategory,
-            failureReason: `Runtime execution ended with status: ${runStatus.status}`,
-        });
-    }
-    async handleValidationError(ctx) {
-        const category = ctx.errorCategory ?? 'output_invalid';
-        this.emitDreamerEvent('dreamer_output_invalid', ctx.taskId, {
-            errorCount: ctx.errors.length,
-            errorCategory: category,
-        });
-        return this.retryOrFail({
-            taskId: ctx.taskId,
-            task: ctx.task,
-            errorCategory: category,
-            failureReason: `Validation failed: ${ctx.errors.join('; ')}`,
-        });
-    }
-    async handleLeaseOrPhaseError(taskId, error) {
-        const classified = this.classifyError(error);
-        // lease_conflict is concurrent-access conflict, not a state change.
-        // No mutation methods (markTaskFailed/markTaskRetryWait) are called.
-        if (classified.category === 'lease_conflict') {
-            this.emitDreamerEvent('dreamer_run_failed', taskId, {
-                errorCategory: 'lease_conflict',
-                errorMessage: classified.message,
-            });
-            return {
-                status: 'failed',
-                taskId,
-                errorCategory: 'lease_conflict',
-                failureReason: classified.message,
-                attemptCount: 1,
-            };
-        }
-        // Non-lease errors (e.g., storage_unavailable before lease) must not
-        // use synthetic TaskRecord. Build one with real defaults from options.
-        this.emitDreamerEvent('dreamer_run_failed', taskId, {
-            errorCategory: classified.category,
-            errorMessage: classified.message,
-        });
-        const task = {
-            taskId,
-            taskKind: 'dreamer',
-            status: 'leased',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            attemptCount: 1,
-            maxAttempts: this.resolvedOptions.defaultMaxAttempts,
-        };
-        return this.retryOrFail({ taskId, task, errorCategory: classified.category, failureReason: classified.message });
-    }
-    async handlePostLeaseError(taskId, task, error) {
-        const classified = this.classifyError(error);
-        this.emitDreamerEvent('dreamer_run_failed', taskId, {
-            errorCategory: classified.category,
-            errorMessage: classified.message,
-        });
-        return this.retryOrFail({ taskId, task, errorCategory: classified.category, failureReason: classified.message });
-    }
-    async retryOrFail(ctx) {
-        // Check if error is permanent (never retry)
-        if (this.isPermanentError(ctx.errorCategory)) {
-            try {
-                await this.stateManager.markTaskFailed(ctx.taskId, ctx.errorCategory);
-            }
-            catch (stateErr) {
-                this.emitDreamerEvent('dreamer_mark_failed_error', ctx.taskId, {
-                    errorCategory: 'storage_unavailable',
-                    attemptCount: ctx.task.attemptCount,
-                    errorMessage: stateErr instanceof Error ? stateErr.message : String(stateErr),
-                });
-                return {
-                    status: 'failed',
-                    taskId: ctx.taskId,
-                    errorCategory: 'storage_unavailable',
-                    failureReason: `State manager error: ${ctx.failureReason}`,
-                    attemptCount: ctx.task.attemptCount,
-                };
-            }
-            this.emitDreamerEvent('dreamer_task_failed', ctx.taskId, {
-                errorCategory: ctx.errorCategory,
-                attemptCount: ctx.task.attemptCount,
-                failureReason: ctx.failureReason,
-            });
-            this.phase = RunnerPhase.Failed;
-            return {
-                status: 'failed',
-                taskId: ctx.taskId,
-                errorCategory: ctx.errorCategory,
-                failureReason: ctx.failureReason,
-                attemptCount: ctx.task.attemptCount,
-            };
-        }
-        // Check retry policy
-        const shouldRetry = this.stateManager.getRetryPolicy().shouldRetry(ctx.task);
-        if (shouldRetry) {
-            try {
-                await this.stateManager.markTaskRetryWait(ctx.taskId, ctx.errorCategory);
-            }
-            catch (stateErr) {
-                this.emitDreamerEvent('dreamer_mark_retry_error', ctx.taskId, {
-                    errorCategory: 'storage_unavailable',
-                    attemptCount: ctx.task.attemptCount,
-                    errorMessage: stateErr instanceof Error ? stateErr.message : String(stateErr),
-                });
-                return {
-                    status: 'failed',
-                    taskId: ctx.taskId,
-                    errorCategory: 'storage_unavailable',
-                    failureReason: `State manager error: ${ctx.failureReason}`,
-                    attemptCount: ctx.task.attemptCount,
-                };
-            }
-            this.emitDreamerEvent('dreamer_task_retried', ctx.taskId, {
-                errorCategory: ctx.errorCategory,
-                attemptCount: ctx.task.attemptCount,
-            });
-            this.phase = RunnerPhase.RetryWaiting;
-            return {
-                status: 'retried',
-                taskId: ctx.taskId,
-                errorCategory: ctx.errorCategory,
-                failureReason: ctx.failureReason,
-                attemptCount: ctx.task.attemptCount,
-            };
-        }
-        // Max attempts exceeded
-        try {
-            await this.stateManager.markTaskFailed(ctx.taskId, 'max_attempts_exceeded');
-        }
-        catch (stateErr) {
-            this.emitDreamerEvent('dreamer_mark_failed_error', ctx.taskId, {
-                errorCategory: 'storage_unavailable',
-                attemptCount: ctx.task.attemptCount,
-                errorMessage: stateErr instanceof Error ? stateErr.message : String(stateErr),
-            });
-            return {
-                status: 'failed',
-                taskId: ctx.taskId,
-                errorCategory: 'storage_unavailable',
-                failureReason: `State manager error: ${ctx.failureReason}`,
-                attemptCount: ctx.task.attemptCount,
-            };
-        }
-        this.emitDreamerEvent('dreamer_task_failed', ctx.taskId, {
-            errorCategory: 'max_attempts_exceeded',
-            attemptCount: ctx.task.attemptCount,
-            failureReason: `Max attempts exceeded: ${ctx.failureReason}`,
-        });
-        this.phase = RunnerPhase.Failed;
-        return {
-            status: 'failed',
-            taskId: ctx.taskId,
-            errorCategory: 'max_attempts_exceeded',
-            failureReason: `Max attempts exceeded: ${ctx.failureReason}`,
-            attemptCount: ctx.task.attemptCount,
+            contextHash,
+            output,
+            attemptCount: task.attemptCount,
         };
     }
-    // ── Error classification ──────────────────────────────────────────────────
-    PERMANENT_ERROR_CATEGORIES = new Set(Object.freeze(['storage_unavailable', 'workspace_invalid', 'capability_missing', 'cancelled', 'input_invalid']));
-    isPermanentError(category) {
-        return this.PERMANENT_ERROR_CATEGORIES.has(category);
-    }
+    // ── Optional hooks ─────────────────────────────────────────────────────────
+    /**
+     * Re-inject taskId if stripped by stripLineageFields (PRI-272 / ERR-008).
+     * Only fill when absent via Object.hasOwn — present-but-falsy values
+     * must reach validation and fail loud (Runtime Contract Rule 3).
+     */
     // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    classifyError(error) {
-        if (error instanceof PDRuntimeError) {
-            return { category: error.category, message: error.message };
-        }
-        if (error instanceof Error) {
-            return { category: 'execution_failed', message: error.message };
-        }
-        return { category: 'execution_failed', message: String(error) };
+    postFetchTransform(taskId, untrustedOutput) {
+        injectRunnerLineageIfAbsent(untrustedOutput, 'taskId', taskId);
     }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    mapRunStatusToErrorCategory(status, _reason) {
-        switch (status) {
-            case 'failed': return 'execution_failed';
-            case 'timed_out': return 'timeout';
-            case 'cancelled': return 'cancelled';
-            default: return 'execution_failed';
+    emitSuccessTelemetry(taskId, output) {
+        for (const candidate of output.candidates) {
+            this.emitEvent('candidate_generated', taskId, {
+                candidateIndex: candidate.candidateIndex,
+                confidence: candidate.confidence,
+                riskLevel: candidate.riskLevel,
+            });
         }
     }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
 }
-// ── Exports ───────────────────────────────────────────────────────────────────
-export { resolveDreamerRunnerOptions, DEFAULT_DREAMER_RUNNER_OPTIONS };
 //# sourceMappingURL=dreamer-runner.js.map