@principles/core 1.73.0

package/dist/runtime-v2/internalization/artificer-prompt-builder.js

@@ -0,0 +1,62 @@
+export const ARTIFICER_PROTOCOL_INSTRUCTION = `You are an Artificer agent in a principle internalization pipeline. Your role is to transform the Scribe's formal principle draft into an implementation-oriented plan with concrete changes, tests, and rollout notes.
+
+PROTOCOL:
+1. Review the scribeArtifact to understand the formal principle draft
+2. Transform the principle draft into an implementation plan with summary, target surface, specific changes, test requirements, and rollout notes
+3. Preserve the lineage trace from scribe, philosopher, and dreamer artifacts
+4. Identify risks associated with implementing this principle
+5. The implementation plan should be concrete enough to guide code changes, not just philosophical
+
+OUTPUT FORMAT (pure JSON, no markdown):
+{
+  "taskId": "<from input>",
+  "sourceScribeArtifactId": "<copy exactly from input.sourceScribeArtifactId>",
+  "implementationPlan": {
+    "summary": "<concise summary of the implementation approach>",
+    "targetSurface": "<specific code/module/surface area to modify>",
+    "changes": ["<specific change 1>", "<specific change 2>"],
+    "tests": ["<test requirement 1>", "<test requirement 2>"],
+    "rolloutNotes": ["<rollout consideration 1>", "<rollout consideration 2>"],
+    "confidence": 0.8
+  },
+  "sourceTrace": {
+    "scribeArtifactId": "<copy exactly from input.sourceScribeArtifactId>",
+    "philosopherArtifactId": "<from scribe artifact if available, or omit>",
+    "dreamerArtifactId": "<from scribe artifact if available, or omit>"
+  },
+  "risks": ["<risk 1>", "<risk 2>"],
+  "generatedAt": "<ISO-8601 timestamp>"
+}
+
+CONSTRAINTS:
+- Output ONLY valid JSON (no markdown, no explanatory text, no code fences)
+- implementationPlan.summary MUST be a non-empty string
+- implementationPlan.targetSurface MUST be a non-empty string
+- implementationPlan.changes MUST be an array of strings
+- implementationPlan.tests MUST be an array of strings
+- implementationPlan.rolloutNotes MUST be an array of strings
+- implementationPlan.confidence MUST be a number between 0.0 and 1.0 (NOT a string, NOT a percentage)
+- sourceScribeArtifactId MUST be copied exactly from input.sourceScribeArtifactId (non-empty string)
+- sourceTrace.scribeArtifactId MUST be copied exactly from input.sourceScribeArtifactId
+- sourceTrace.philosopherArtifactId is optional — include only if available from scribe artifact
+- sourceTrace.dreamerArtifactId is optional — include only if available from scribe artifact
+- risks MUST be an array of strings (can be empty if no risks identified)
+- generatedAt MUST be an ISO-8601 timestamp string
+`;
+export const ARTIFICER_PROMPT_CONTRACT_VERSION = 'artificer-output-v1.prompt.v1';
+export class ArtificerPromptBuilder {
+    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+    buildPrompt(input) {
+        const promptInput = {
+            taskId: input.taskId,
+            contextHash: input.contextHash,
+            sourceScribeArtifactId: input.sourceScribeArtifactId,
+            scribeArtifact: input.scribeArtifact,
+            artificerInstruction: ARTIFICER_PROTOCOL_INSTRUCTION,
+            promptContractVersion: ARTIFICER_PROMPT_CONTRACT_VERSION,
+        };
+        const message = JSON.stringify(promptInput);
+        return { message, promptInput };
+    }
+}
+//# sourceMappingURL=artificer-prompt-builder.js.map

package/dist/runtime-v2/internalization/artificer-prompt-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artificer-prompt-builder.js","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/artificer-prompt-builder.ts"],"names":[],"mappings":"AAqBA,MAAM,CAAC,MAAM,8BAA8B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C7C,CAAC;AAEF,MAAM,CAAC,MAAM,iCAAiC,GAAG,+BAA+B,CAAC;AAEjF,MAAM,OAAO,sBAAsB;IACjC,qEAAqE;IACrE,WAAW,CAAC,KAAkC;QAC5C,MAAM,WAAW,GAAyB;YACxC,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;YACpD,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,oBAAoB,EAAE,8BAA8B;YACpD,qBAAqB,EAAE,iCAAiC;SACzD,CAAC;QAEF,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAE5C,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAClC,CAAC;CACF"}

package/dist/runtime-v2/internalization/artificer-runner.d.ts

@@ -0,0 +1,77 @@
+import type { RuntimeStateManager } from '../store/runtime-state-manager.js';
+import type { PDRuntimeAdapter } from '../runtime-protocol.js';
+import type { StoreEventEmitter } from '../store/event-emitter.js';
+import type { ArtificerOutputV1, ArtificerValidator } from './artificer-output.js';
+import type { PIArtifactStore } from './pi-artifact.js';
+import { type PDErrorCategory } from '../error-categories.js';
+import { RunnerPhase } from '../runner/runner-phase.js';
+export type ArtificerRunnerResultStatus = 'succeeded' | 'failed' | 'retried';
+export interface ArtificerRunnerResult {
+    readonly status: ArtificerRunnerResultStatus;
+    readonly taskId: string;
+    readonly runId?: string;
+    readonly artifactId?: string;
+    readonly resultRef?: string;
+    readonly contextHash?: string;
+    readonly output?: ArtificerOutputV1;
+    readonly errorCategory?: PDErrorCategory;
+    readonly failureReason?: string;
+    readonly attemptCount: number;
+}
+export interface ArtificerRunnerOptions {
+    readonly pollIntervalMs?: number;
+    readonly timeoutMs?: number;
+    readonly defaultMaxAttempts?: number;
+    readonly owner: string;
+    readonly runtimeKind: string;
+    readonly agentId?: string;
+}
+export interface ResolvedArtificerRunnerOptions {
+    readonly pollIntervalMs: number;
+    readonly timeoutMs: number;
+    readonly defaultMaxAttempts: number;
+    readonly owner: string;
+    readonly runtimeKind: string;
+    readonly agentId: string;
+}
+declare const DEFAULT_ARTIFICER_RUNNER_OPTIONS: Readonly<Omit<ResolvedArtificerRunnerOptions, 'owner' | 'runtimeKind'>>;
+export declare function resolveArtificerRunnerOptions(options: ArtificerRunnerOptions): ResolvedArtificerRunnerOptions;
+export interface ArtificerRunnerDeps {
+    readonly stateManager: RuntimeStateManager;
+    readonly runtimeAdapter: PDRuntimeAdapter;
+    readonly eventEmitter: StoreEventEmitter;
+    readonly validator: ArtificerValidator;
+    readonly artifactStore: PIArtifactStore;
+}
+export declare class ArtificerRunner {
+    private phase;
+    private readonly resolvedOptions;
+    private readonly stateManager;
+    private readonly runtimeAdapter;
+    private readonly eventEmitter;
+    private readonly validator;
+    private readonly artifactStore;
+    constructor(deps: ArtificerRunnerDeps, options: ArtificerRunnerOptions);
+    get currentPhase(): RunnerPhase;
+    private emitArtificerEvent;
+    run(taskId: string): Promise<ArtificerRunnerResult>;
+    private buildContext;
+    private static hashContextRefs;
+    private resolveStoreRunId;
+    private invokeRuntime;
+    private pollUntilTerminal;
+    private fetchAndParseOutput;
+    private succeedTask;
+    private handleRuntimeFailure;
+    private handleValidationError;
+    private handleLeaseOrPhaseError;
+    private handlePostLeaseError;
+    private retryOrFail;
+    private readonly PERMANENT_ERROR_CATEGORIES;
+    private isPermanentError;
+    private classifyError;
+    private mapRunStatusToErrorCategory;
+    private sleep;
+}
+export { DEFAULT_ARTIFICER_RUNNER_OPTIONS };
+//# sourceMappingURL=artificer-runner.d.ts.map

package/dist/runtime-v2/internalization/artificer-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artificer-runner.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/internalization/artificer-runner.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,521 @@
+import { PDRuntimeError } from '../error-categories.js';
+import { hydratePITaskRecord } from './pitask-metadata.js';
+import { RunnerPhase } from '../runner/runner-phase.js';
+import { ArtificerPromptBuilder } from './artificer-prompt-builder.js';
+const DEFAULT_ARTIFICER_RUNNER_OPTIONS = {
+    pollIntervalMs: 5_000,
+    timeoutMs: 300_000,
+    defaultMaxAttempts: 3,
+    agentId: 'artificer',
+};
+export function resolveArtificerRunnerOptions(options) {
+    return {
+        pollIntervalMs: options.pollIntervalMs ?? DEFAULT_ARTIFICER_RUNNER_OPTIONS.pollIntervalMs,
+        timeoutMs: options.timeoutMs ?? DEFAULT_ARTIFICER_RUNNER_OPTIONS.timeoutMs,
+        defaultMaxAttempts: options.defaultMaxAttempts ?? DEFAULT_ARTIFICER_RUNNER_OPTIONS.defaultMaxAttempts,
+        owner: options.owner,
+        runtimeKind: options.runtimeKind,
+        agentId: options.agentId ?? DEFAULT_ARTIFICER_RUNNER_OPTIONS.agentId,
+    };
+}
+export class ArtificerRunner {
+    phase = RunnerPhase.Idle;
+    resolvedOptions;
+    stateManager;
+    runtimeAdapter;
+    eventEmitter;
+    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 = resolveArtificerRunnerOptions(options);
+    }
+    get currentPhase() {
+        return this.phase;
+    }
+    emitArtificerEvent(eventType, taskId, payload) {
+        this.eventEmitter.emitTelemetry({
+            eventType: eventType,
+            traceId: taskId,
+            timestamp: new Date().toISOString(),
+            sessionId: this.resolvedOptions.owner,
+            agentId: this.resolvedOptions.agentId,
+            payload,
+        });
+    }
+    async run(taskId) {
+        this.phase = RunnerPhase.Idle;
+        // eslint-disable-next-line @typescript-eslint/init-declarations
+        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 !== 'artificer') {
+            this.emitArtificerEvent('artificer_wrong_task_kind', taskId, {
+                expectedKind: 'artificer',
+                actualKind: leasedTask.taskKind,
+            });
+            await this.stateManager.markTaskFailed(taskId, 'input_invalid');
+            return {
+                status: 'failed',
+                taskId,
+                errorCategory: 'input_invalid',
+                failureReason: `Task kind must be 'artificer', got '${leasedTask.taskKind}'`,
+                attemptCount: leasedTask.attemptCount,
+            };
+        }
+        this.emitArtificerEvent('artificer_task_leased', taskId, {
+            taskKind: 'artificer',
+            attemptCount: leasedTask.attemptCount,
+        });
+        try {
+            const storeRunId = await this.resolveStoreRunId(taskId);
+            this.phase = RunnerPhase.BuildingContext;
+            const { contextHash, scribeArtifact, sourceScribeArtifactId } = await this.buildContext(taskId);
+            if (!scribeArtifact || !sourceScribeArtifactId) {
+                return this.retryOrFail({
+                    taskId,
+                    task: leasedTask,
+                    errorCategory: 'input_invalid',
+                    failureReason: sourceScribeArtifactId ? 'Scribe dependency artifact not found' : 'Scribe dependency artifact ID not resolved',
+                });
+            }
+            this.emitArtificerEvent('artificer_context_built', taskId, { contextHash });
+            this.phase = RunnerPhase.Invoking;
+            const runHandle = await this.invokeRuntime({ taskId, contextHash, scribeArtifact, sourceScribeArtifactId });
+            this.emitArtificerEvent('artificer_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);
+            this.phase = RunnerPhase.Validating;
+            const validationResult = await this.validator.validate(output, taskId, sourceScribeArtifactId ?? undefined);
+            if (!validationResult.valid) {
+                return await this.handleValidationError({
+                    taskId,
+                    task: leasedTask,
+                    errors: validationResult.errors,
+                    errorCategory: validationResult.errorCategory,
+                });
+            }
+            this.emitArtificerEvent('artificer_output_validated', taskId, {
+                implementationSummary: output.implementationPlan.summary,
+            });
+            return await this.succeedTask({
+                taskId,
+                runId: storeRunId,
+                output,
+                task: leasedTask,
+                contextHash,
+            });
+        }
+        catch (error) {
+            return await this.handlePostLeaseError(taskId, leasedTask, error);
+        }
+    }
+    async buildContext(taskId) {
+        const task = await this.stateManager.getTask(taskId);
+        if (!task) {
+            throw new PDRuntimeError('input_invalid', `Task ${taskId} not found`);
+        }
+        const piTask = hydratePITaskRecord(task);
+        const deps = piTask?.dependencyTaskIds ?? [];
+        if (deps.length === 0) {
+            this.emitArtificerEvent('artificer_no_dependencies', taskId, {});
+            return { contextHash: 'empty', scribeArtifact: null, sourceScribeArtifactId: null };
+        }
+        for (const depId of deps) {
+            const depTask = await this.stateManager.getTask(depId);
+            if (!depTask)
+                continue;
+            if (depTask.taskKind !== 'scribe')
+                continue;
+            if (depTask.status !== 'succeeded') {
+                this.emitArtificerEvent('artificer_dependency_not_succeeded', taskId, {
+                    depTaskId: depId,
+                    depStatus: depTask.status,
+                });
+                continue;
+            }
+            const artifacts = await this.artifactStore.listBySourceTaskId(depId);
+            if (artifacts.length > 0) {
+                const [firstArtifact] = artifacts;
+                if (!firstArtifact)
+                    continue;
+                const artifactRef = firstArtifact.artifactId;
+                this.emitArtificerEvent('artificer_scribe_dep_selected', taskId, {
+                    depTaskId: depId,
+                    artifactId: firstArtifact.artifactId,
+                });
+                return {
+                    contextHash: ArtificerRunner.hashContextRefs([artifactRef]),
+                    scribeArtifact: firstArtifact.contentJson,
+                    sourceScribeArtifactId: firstArtifact.artifactId,
+                };
+            }
+        }
+        this.emitArtificerEvent('artificer_no_scribe_artifact', taskId, {});
+        return { contextHash: 'empty', scribeArtifact: null, sourceScribeArtifactId: null };
+    }
+    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`);
+        }
+        return latestRun.runId;
+    }
+    async invokeRuntime(params) {
+        let parsedScribeArtifact = null;
+        if (params.scribeArtifact) {
+            try {
+                parsedScribeArtifact = JSON.parse(params.scribeArtifact);
+            }
+            catch {
+                parsedScribeArtifact = params.scribeArtifact;
+            }
+        }
+        const builder = new ArtificerPromptBuilder();
+        const { message } = builder.buildPrompt({
+            taskId: params.taskId,
+            contextHash: params.contextHash,
+            scribeArtifact: parsedScribeArtifact,
+            sourceScribeArtifactId: params.sourceScribeArtifactId,
+        });
+        const startInput = {
+            agentSpec: { agentId: this.resolvedOptions.agentId, schemaVersion: 'v1' },
+            taskRef: { taskId: params.taskId },
+            inputPayload: message,
+            contextItems: [],
+            outputSchemaRef: 'artificer-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);
+        }
+        let cancelFailed = false;
+        try {
+            await this.runtimeAdapter.cancelRun(runHandle.runId);
+        }
+        catch (cancelErr) {
+            cancelFailed = true;
+            this.emitArtificerEvent('artificer_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) {
+        const result = await this.runtimeAdapter.fetchOutput(runId);
+        if (!result || !result.payload) {
+            throw new PDRuntimeError('output_invalid', `No output available for run ${runId}`);
+        }
+        return result.payload;
+    }
+    async succeedTask(ctx) {
+        try {
+            await this.stateManager.updateRunOutput(ctx.runId, JSON.stringify(ctx.output));
+        }
+        catch (updateErr) {
+            this.emitArtificerEvent('artificer_update_output_failed', ctx.taskId, {
+                runId: ctx.runId,
+                errorMessage: updateErr instanceof Error ? updateErr.message : String(updateErr),
+            });
+            throw updateErr;
+        }
+        const artifactId = `pi-art-${ctx.taskId}-${ctx.runId}`;
+        const now = new Date().toISOString();
+        let lineageArtifactIds = [];
+        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);
+                    }
+                }
+            }
+        }
+        catch { /* lineage resolution failure is non-fatal */ }
+        try {
+            await this.artifactStore.upsertArtifact({
+                artifactId,
+                artifactKind: 'principle',
+                sourceTaskId: ctx.taskId,
+                lineageArtifactIds,
+                validationStatus: 'pending',
+                contentJson: JSON.stringify(ctx.output),
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        catch (artifactErr) {
+            this.emitArtificerEvent('artificer_artifact_write_failed', ctx.taskId, {
+                runId: ctx.runId,
+                errorMessage: artifactErr instanceof Error ? artifactErr.message : String(artifactErr),
+            });
+            return this.retryOrFail({
+                taskId: ctx.taskId,
+                task: ctx.task,
+                errorCategory: 'artifact_commit_failed',
+                failureReason: `PIArtifact write failed: ${artifactErr instanceof Error ? artifactErr.message : String(artifactErr)}`,
+            });
+        }
+        const resultRef = `artificer://${ctx.runId}`;
+        try {
+            await this.stateManager.markTaskSucceeded(ctx.taskId, resultRef);
+        }
+        catch (stateErr) {
+            this.emitArtificerEvent('artificer_mark_succeeded_failed', ctx.taskId, {
+                taskId: ctx.taskId,
+                runId: ctx.runId,
+                errorMessage: stateErr instanceof Error ? stateErr.message : String(stateErr),
+            });
+            throw stateErr;
+        }
+        this.emitArtificerEvent('artificer_task_succeeded', ctx.taskId, {
+            attemptCount: ctx.task.attemptCount,
+            resultRef,
+            implementationSummary: ctx.output.implementationPlan.summary,
+        });
+        this.phase = RunnerPhase.Completed;
+        return {
+            status: 'succeeded',
+            taskId: ctx.taskId,
+            runId: ctx.runId,
+            artifactId,
+            resultRef,
+            contextHash: ctx.contextHash,
+            output: ctx.output,
+            attemptCount: ctx.task.attemptCount,
+        };
+    }
+    async handleRuntimeFailure(taskId, task, runStatus) {
+        const errorCategory = this.mapRunStatusToErrorCategory(runStatus.status);
+        this.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_run_failed', taskId, {
+                errorCategory: 'lease_conflict',
+                errorMessage: classified.message,
+            });
+            return {
+                status: 'failed',
+                taskId,
+                errorCategory: 'lease_conflict',
+                failureReason: classified.message,
+                attemptCount: 1,
+            };
+        }
+        this.emitArtificerEvent('artificer_run_failed', taskId, {
+            errorCategory: classified.category,
+            errorMessage: classified.message,
+        });
+        const task = {
+            taskId,
+            taskKind: 'artificer',
+            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.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_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.emitArtificerEvent('artificer_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,
+        };
+    }
+    PERMANENT_ERROR_CATEGORIES = new Set(Object.freeze(['storage_unavailable', 'workspace_invalid', 'capability_missing', 'cancelled', 'input_invalid', 'output_invalid']));
+    isPermanentError(category) {
+        return this.PERMANENT_ERROR_CATEGORIES.has(category);
+    }
+    // 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) };
+    }
+    // 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));
+    }
+}
+export { DEFAULT_ARTIFICER_RUNNER_OPTIONS };
+//# sourceMappingURL=artificer-runner.js.map