@principles/core 1.84.0 → 1.86.0

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

@@ -1,15 +1,15 @@
-import { PDRuntimeError } from '../error-categories.js';
+import { PDRuntimeError, isPDErrorCategory } from '../error-categories.js';
 import { hydratePITaskRecord } from './pitask-metadata.js';
-import { RunnerPhase } from '../runner/runner-phase.js';
 import { PhilosopherPromptBuilder } from './philosopher-prompt-builder.js';
 import { injectRunnerLineageIfAbsent } from './peer-runner-contracts.js';
-const DEFAULT_PHILOSOPHER_RUNNER_OPTIONS = {
+import { BasePeerRunner } from '../runner/base-peer-runner.js';
+export const DEFAULT_PHILOSOPHER_RUNNER_OPTIONS = {
     pollIntervalMs: 5_000,
     timeoutMs: 300_000,
     defaultMaxAttempts: 3,
     agentId: 'philosopher',
 };
-function resolvePhilosopherRunnerOptions(options) {
+export function resolvePhilosopherRunnerOptions(options) {
     return {
         pollIntervalMs: options.pollIntervalMs ?? DEFAULT_PHILOSOPHER_RUNNER_OPTIONS.pollIntervalMs,
         timeoutMs: options.timeoutMs ?? DEFAULT_PHILOSOPHER_RUNNER_OPTIONS.timeoutMs,
@@ -19,120 +19,23 @@ function resolvePhilosopherRunnerOptions(options) {
         agentId: options.agentId ?? DEFAULT_PHILOSOPHER_RUNNER_OPTIONS.agentId,
     };
 }
-// ── PhilosopherRunner ──────────────────────────────────────────────────────────
-export class PhilosopherRunner {
-    phase = RunnerPhase.Idle;
-    resolvedOptions;
-    stateManager;
-    runtimeAdapter;
-    eventEmitter;
+// ── PhilosopherRunner ────────────────────────────────────────────────────────
+export class PhilosopherRunner 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 = resolvePhilosopherRunnerOptions(options);
-    }
-    get currentPhase() {
-        return this.phase;
-    }
-    emitPhilosopherEvent(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: 'philosopher',
+            expectedTaskKind: 'philosopher',
+            defaultAgentId: 'philosopher',
+            resultRefPrefix: 'philosopher',
         });
+        this.validator = deps.validator;
     }
-    async run(taskId) {
-        this.phase = RunnerPhase.Idle;
-        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);
-        }
-        if (leasedTask.taskKind !== 'philosopher') {
-            this.emitPhilosopherEvent('philosopher_wrong_task_kind', taskId, {
-                expectedKind: 'philosopher',
-                actualKind: leasedTask.taskKind,
-            });
-            await this.stateManager.markTaskFailed(taskId, 'input_invalid');
-            return {
-                status: 'failed',
-                taskId,
-                errorCategory: 'input_invalid',
-                failureReason: `Task kind must be 'philosopher', got '${leasedTask.taskKind}'`,
-                attemptCount: leasedTask.attemptCount,
-            };
-        }
-        this.emitPhilosopherEvent('philosopher_task_leased', taskId, {
-            taskKind: 'philosopher',
-            attemptCount: leasedTask.attemptCount,
-        });
-        try {
-            const storeRunId = await this.resolveStoreRunId(taskId);
-            this.phase = RunnerPhase.BuildingContext;
-            const { contextHash, dreamerArtifact, sourceDreamerArtifactId } = await this.buildContext(taskId);
-            if (!dreamerArtifact) {
-                return this.retryOrFail({
-                    taskId,
-                    task: leasedTask,
-                    errorCategory: 'input_invalid',
-                    failureReason: 'Dreamer dependency artifact not found',
-                });
-            }
-            this.emitPhilosopherEvent('philosopher_context_built', taskId, { contextHash });
-            this.phase = RunnerPhase.Invoking;
-            const runHandle = await this.invokeRuntime({ taskId, contextHash, dreamerArtifact, sourceDreamerArtifactId });
-            this.emitPhilosopherEvent('philosopher_run_started', taskId, {
-                runtimeKind: this.resolvedOptions.runtimeKind,
-            });
-            this.phase = RunnerPhase.Polling;
-            const finalStatus = await this.pollUntilTerminal(runHandle);
-            if (finalStatus.status !== 'succeeded') {
-                return await this.handleRuntimeFailure(taskId, leasedTask, finalStatus);
-            }
-            this.phase = RunnerPhase.FetchingOutput;
-            const output = await this.fetchAndParseOutput(runHandle.runId);
-            // Re-inject taskId if stripped by stripLineageFields (PRI-272 / ERR-008).
-            injectRunnerLineageIfAbsent(output, 'taskId', taskId);
-            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.emitPhilosopherEvent('philosopher_output_validated', taskId, {
-                principleTitle: output.principleCandidate.title,
-            });
-            return await this.succeedTask({
-                taskId,
-                runId: storeRunId,
-                output,
-                task: leasedTask,
-                contextHash,
-            });
-        }
-        catch (error) {
-            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 ─────────────────────────────────────────────────────────
     async buildContext(taskId) {
         const task = await this.stateManager.getTask(taskId);
         if (!task) {
@@ -141,15 +44,14 @@ export class PhilosopherRunner {
         const piTask = hydratePITaskRecord(task);
         const deps = piTask?.dependencyTaskIds ?? [];
         if (deps.length === 0) {
-            this.emitPhilosopherEvent('philosopher_no_dependencies', taskId, {});
-            return { contextHash: 'empty', dreamerArtifact: null, sourceDreamerArtifactId: null };
+            throw new PDRuntimeError('input_invalid', 'Dreamer dependency artifact not found');
         }
         for (const depId of deps) {
             const depTask = await this.stateManager.getTask(depId);
             if (!depTask)
                 continue;
             if (depTask.status !== 'succeeded') {
-                this.emitPhilosopherEvent('philosopher_dependency_not_succeeded', taskId, {
+                this.emitEvent('dependency_not_succeeded', taskId, {
                     depTaskId: depId,
                     depStatus: depTask.status,
                 });
@@ -163,359 +65,173 @@ export class PhilosopherRunner {
                     continue;
                 const artifactRef = depPiTask?.outputArtifactRefs?.[0]?.ref ?? `pi-artifact://${depId}`;
                 return {
-                    contextHash: PhilosopherRunner.hashContextRefs([artifactRef]),
+                    contextHash: BasePeerRunner.hashContextRefs([artifactRef]),
                     dreamerArtifact: firstArtifact.contentJson,
                     sourceDreamerArtifactId: firstArtifact.artifactId,
                 };
             }
         }
-        this.emitPhilosopherEvent('philosopher_no_dreamer_artifact', taskId, {});
-        return { contextHash: 'empty', dreamerArtifact: null, sourceDreamerArtifactId: null };
+        throw new PDRuntimeError('input_invalid', 'Dreamer dependency artifact not found');
     }
-    static hashContextRefs(refs) {
-        if (refs.length === 0)
-            return 'empty';
-        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`);
+    async invokeRuntime(taskId, context) {
+        let parsedDreamerArtifact;
+        try {
+            parsedDreamerArtifact = JSON.parse(context.dreamerArtifact);
         }
-        return latestRun.runId;
-    }
-    async invokeRuntime(params) {
-        let parsedDreamerArtifact = null;
-        if (params.dreamerArtifact) {
-            try {
-                parsedDreamerArtifact = JSON.parse(params.dreamerArtifact);
-            }
-            catch {
-                parsedDreamerArtifact = params.dreamerArtifact;
-            }
+        catch {
+            parsedDreamerArtifact = context.dreamerArtifact;
         }
         const builder = new PhilosopherPromptBuilder();
         const { message } = builder.buildPrompt({
-            taskId: params.taskId,
-            contextHash: params.contextHash,
+            taskId,
+            contextHash: context.contextHash,
             dreamerArtifact: parsedDreamerArtifact,
-            sourceDreamerArtifactId: params.sourceDreamerArtifactId ?? '',
+            sourceDreamerArtifactId: context.sourceDreamerArtifactId,
         });
-        const startInput = {
+        return this.runtimeAdapter.startRun({
             agentSpec: { agentId: this.resolvedOptions.agentId, schemaVersion: 'v1' },
-            taskRef: { taskId: params.taskId },
+            taskRef: { taskId },
             inputPayload: message,
             contextItems: [],
             outputSchemaRef: 'philosopher-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);
+    async validateOutput(output, taskId) {
+        const result = await this.validator.validate(output, taskId);
+        // Trust-boundary: validator is an injected dependency returning `string | undefined`
+        // for errorCategory. We must not `as`-cast; validate at runtime (ERR-001, ERR-005).
+        const rawCategory = result.errorCategory;
+        let errorCategory;
+        if (rawCategory == null) {
+            errorCategory = undefined;
         }
-        let cancelFailed = false;
-        try {
-            await this.runtimeAdapter.cancelRun(runHandle.runId);
+        else if (isPDErrorCategory(rawCategory)) {
+            errorCategory = rawCategory;
         }
-        catch (cancelErr) {
-            cancelFailed = true;
-            this.emitPhilosopherEvent('philosopher_cancel_run_failed', runHandle.runId, {
-                runId: runHandle.runId,
-                errorMessage: cancelErr instanceof Error ? cancelErr.message : String(cancelErr),
-            });
+        else {
+            // Invalid errorCategory from validator — fail loud, do not pass through
+            return {
+                valid: false,
+                errors: [...result.errors, `invalid errorCategory: ${rawCategory}`],
+                errorCategory: 'output_invalid',
+            };
         }
-        const cancelNote = cancelFailed ? ' (cancelRun also failed)' : '';
-        throw new PDRuntimeError('timeout', `Run ${runHandle.runId} timed out after ${this.resolvedOptions.timeoutMs}ms${cancelNote}`);
+        return {
+            valid: result.valid,
+            errors: result.errors,
+            errorCategory,
+        };
     }
-    async fetchAndParseOutput(runId) {
-        const result = await this.runtimeAdapter.fetchOutput(runId);
-        if (!result || !result.payload) {
-            throw new PDRuntimeError('output_invalid', `No output available for run ${runId}`);
+    // eslint-disable-next-line @typescript-eslint/max-params
+    async succeedTask(taskId, runId, output, task, contextHash, context) {
+        // Lineage consistency: sourceDreamerArtifactId must match buildContext result (ERR-004).
+        if (output.sourceDreamerArtifactId !== context.sourceDreamerArtifactId) {
+            throw new PDRuntimeError('output_invalid', `sourceDreamerArtifactId mismatch: expected ${context.sourceDreamerArtifactId}, got ${output.sourceDreamerArtifactId}`);
         }
-        return result.payload;
-    }
-    async succeedTask(ctx) {
+        // 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.emitPhilosopherEvent('philosopher_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;
         }
-        const artifactId = `pi-art-${ctx.taskId}-${ctx.runId}`;
-        const now = new Date().toISOString();
+        // Resolve lineage artifact IDs
         let lineageArtifactIds = [];
+        let lineageHasRejected = false;
         try {
-            const piTask = hydratePITaskRecord(ctx.task);
-            const deps = piTask?.dependencyTaskIds ?? [];
-            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) {
-                        lineageArtifactIds.push(artifact.artifactId);
-                    }
-                }
-            }
+            const lineageResult = await this.resolveLineageArtifactIds(taskId);
+            lineageArtifactIds = lineageResult.ids;
+            lineageHasRejected = lineageResult.hasRejected;
+        }
+        catch (lineageErr) {
+            this.emitEvent('lineage_resolve_failed', taskId, {
+                runId,
+                errorMessage: lineageErr instanceof Error ? lineageErr.message : String(lineageErr),
+            });
+        }
+        if (lineageHasRejected) {
+            this.emitEvent('lineage_partial', taskId, {
+                runId,
+                resolvedCount: lineageArtifactIds.length,
+                warning: 'Some dependency artifact queries were rejected; lineage may be incomplete',
+            });
         }
-        catch { /* lineage resolution failure is non-fatal */ }
+        // Write PIArtifact via artifactStore (idempotent upsert)
+        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.emitPhilosopherEvent('philosopher_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)}`,
             });
         }
-        const resultRef = `philosopher://${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.emitPhilosopherEvent('philosopher_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.emitPhilosopherEvent('philosopher_task_succeeded', ctx.taskId, {
-            attemptCount: ctx.task.attemptCount,
+        this.emitEvent('task_succeeded', taskId, {
+            attemptCount: task.attemptCount,
             resultRef,
-            principleTitle: ctx.output.principleCandidate.title,
+            principleTitle: output.principleCandidate.title,
         });
-        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,
+            contextHash,
+            output,
+            attemptCount: task.attemptCount,
         };
     }
-    async handleRuntimeFailure(taskId, task, runStatus) {
-        const errorCategory = this.mapRunStatusToErrorCategory(runStatus.status);
-        this.emitPhilosopherEvent('philosopher_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.emitPhilosopherEvent('philosopher_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);
-        if (classified.category === 'lease_conflict') {
-            this.emitPhilosopherEvent('philosopher_run_failed', taskId, {
-                errorCategory: 'lease_conflict',
-                errorMessage: classified.message,
-            });
-            return {
-                status: 'failed',
-                taskId,
-                errorCategory: 'lease_conflict',
-                failureReason: classified.message,
-                attemptCount: 1,
-            };
-        }
-        this.emitPhilosopherEvent('philosopher_run_failed', taskId, {
-            errorCategory: classified.category,
-            errorMessage: classified.message,
-        });
-        const task = {
-            taskId,
-            taskKind: 'philosopher',
-            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.emitPhilosopherEvent('philosopher_run_failed', taskId, {
-            errorCategory: classified.category,
-            errorMessage: classified.message,
-        });
-        return this.retryOrFail({ taskId, task, errorCategory: classified.category, failureReason: classified.message });
-    }
-    async retryOrFail(ctx) {
-        if (this.isPermanentError(ctx.errorCategory)) {
-            try {
-                await this.stateManager.markTaskFailed(ctx.taskId, ctx.errorCategory);
-            }
-            catch (stateErr) {
-                this.emitPhilosopherEvent('philosopher_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.emitPhilosopherEvent('philosopher_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,
-            };
-        }
-        const shouldRetry = this.stateManager.getRetryPolicy().shouldRetry(ctx.task);
-        if (shouldRetry) {
-            try {
-                await this.stateManager.markTaskRetryWait(ctx.taskId, ctx.errorCategory);
-            }
-            catch (stateErr) {
-                this.emitPhilosopherEvent('philosopher_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.emitPhilosopherEvent('philosopher_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,
-            };
-        }
-        try {
-            await this.stateManager.markTaskFailed(ctx.taskId, 'max_attempts_exceeded');
-        }
-        catch (stateErr) {
-            this.emitPhilosopherEvent('philosopher_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.emitPhilosopherEvent('philosopher_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,
-        };
-    }
-    // ── 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) {
-        switch (status) {
-            case 'failed': return 'execution_failed';
-            case 'timed_out': return 'timeout';
-            case 'cancelled': return 'cancelled';
-            default: return 'execution_failed';
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
+    emitSuccessTelemetry(taskId, output) {
+        this.emitEvent('principle_candidate_generated', taskId, {
+            principleTitle: output.principleCandidate.title,
+            confidence: output.principleCandidate.confidence,
+        });
     }
 }
-export { resolvePhilosopherRunnerOptions, DEFAULT_PHILOSOPHER_RUNNER_OPTIONS };
 //# sourceMappingURL=philosopher-runner.js.map