create-principles-disciple 1.85.0 → 1.87.0

package/pd-cli/dist/commands/runtime-internalization-run-once.js

@@ -1,15 +1,10 @@
 import * as path from 'path';
-import { RuntimeStateManager, InternalizationOrchestrator, DreamerRunner, PhilosopherRunner, ScribeRunner, ArtificerRunner, EvaluatorRunner, RolloutReviewerRunner, TrainerRunner, StoreEventEmitter, DefaultDreamerValidator, DefaultPhilosopherValidator, DefaultScribeValidator, DefaultArtificerValidator, DefaultEvaluatorValidator, DefaultRolloutReviewerValidator, DefaultTrainerValidator, TestDoubleRuntimeAdapter, PiAiRuntimeAdapter, OpenClawCliRuntimeAdapter, resolveRuntimeConfig, isRuntimeConfigError, validateRuntimeConfig, } from '@principles/core/runtime-v2';
+import { RuntimeStateManager, InternalizationOrchestrator, DreamerRunner, PhilosopherRunner, ScribeRunner, ArtificerRunner, EvaluatorRunner, RolloutReviewerRunner, TrainerRunner, StoreEventEmitter, DefaultDreamerValidator, DefaultPhilosopherValidator, DefaultScribeValidator, DefaultArtificerValidator, DefaultEvaluatorValidator, DefaultRolloutReviewerValidator, DefaultTrainerValidator, TestDoubleRuntimeAdapter, } from '@principles/core/runtime-v2';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { readOutputLanguageFromWorkspace } from '../config-reader.js';
+import { resolveRuntimeAdapterFromConfig, ConfigResolutionError, } from '../services/runtime-adapter-resolver.js';
 const OWNER = 'pd-cli-internalization-run-once';
 const RUNTIME_KIND = 'local-worker';
-class ConfigResolutionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ConfigResolutionError';
-    }
-}
 const SUPPORTED_RUNNERS = new Set(['dreamer', 'philosopher', 'scribe', 'artificer', 'evaluator', 'rollout_reviewer', 'trainer']);
 function buildOutput(wakeResult, runnerResult, skipReason) {
     const base = { decision: wakeResult.decision };
@@ -122,244 +117,124 @@ function formatTextOutput(output) {
     }
     return lines.join('\n');
 }
-function resolveRuntimeAdapter(opts) {
-    if (opts.runtimeKind === 'test-double') {
-        if (opts.runnerKind === 'philosopher') {
-            return new TestDoubleRuntimeAdapter({
-                onPollRun: (_runId) => ({
-                    runId: _runId,
-                    status: 'succeeded',
-                    startedAt: new Date().toISOString(),
-                    endedAt: new Date().toISOString(),
-                }),
-                onFetchOutput: (_runId) => ({
-                    runId: _runId,
-                    payload: {
-                        taskId: opts.taskId,
-                        sourceDreamerArtifactId: 'pi-art-test-dreamer',
-                        thesis: 'Test thesis from test-double',
-                        principleCandidate: {
-                            title: 'Test Principle',
-                            rationale: 'Test rationale',
-                            scope: 'Test scope',
-                            confidence: 0.8,
-                        },
-                        risks: [],
-                        generatedAt: new Date().toISOString(),
-                    },
-                }),
-            });
-        }
-        if (opts.runnerKind === 'scribe') {
-            return new TestDoubleRuntimeAdapter({
-                onPollRun: (_runId) => ({
-                    runId: _runId,
-                    status: 'succeeded',
-                    startedAt: new Date().toISOString(),
-                    endedAt: new Date().toISOString(),
-                }),
-                onFetchOutput: (_runId) => ({
-                    runId: _runId,
-                    payload: {
-                        taskId: opts.taskId,
-                        sourcePhilosopherArtifactId: 'pi-art-test-philosopher',
-                        principleDraft: {
-                            title: 'Test Principle Draft',
-                            statement: 'Test principle statement',
-                            rationale: 'Test rationale',
-                            applicability: ['All operations'],
-                            antiPatterns: ['Ignoring validation'],
-                            confidence: 0.8,
-                        },
-                        sourceTrace: {
-                            philosopherArtifactId: 'pi-art-test-philosopher',
-                        },
-                        risks: [],
-                        generatedAt: new Date().toISOString(),
+/**
+ * PRI-431: Local test-double payload builder.
+ * The 7 runner-specific payloads are unique to run-once.ts; the shared resolver
+ * calls this via `testDoublePayloadBuilder` callback.
+ */
+function buildTestDoubleAdapter(runnerKind, taskId) {
+    if (runnerKind === 'philosopher') {
+        return new TestDoubleRuntimeAdapter({
+            onPollRun: (_runId) => ({
+                runId: _runId,
+                status: 'succeeded',
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+            }),
+            onFetchOutput: (_runId) => ({
+                runId: _runId,
+                payload: {
+                    taskId,
+                    sourceDreamerArtifactId: 'pi-art-test-dreamer',
+                    thesis: 'Test thesis from test-double',
+                    principleCandidate: {
+                        title: 'Test Principle',
+                        rationale: 'Test rationale',
+                        scope: 'Test scope',
+                        confidence: 0.8,
                     },
-                }),
-            });
-        }
-        if (opts.runnerKind === 'artificer') {
-            let capturedSourceScribeArtifactId = 'pi-art-test-scribe';
-            return new TestDoubleRuntimeAdapter({
-                onStartRun: (input) => {
-                    try {
-                        const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
-                        const parsed = JSON.parse(payloadStr);
-                        if (typeof parsed.sourceScribeArtifactId === 'string' && parsed.sourceScribeArtifactId.trim() !== '') {
-                            capturedSourceScribeArtifactId = parsed.sourceScribeArtifactId;
-                        }
-                    }
-                    catch { /* use default */ }
-                    return { runId: `td-artificer-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
+                    risks: [],
+                    generatedAt: new Date().toISOString(),
                 },
-                onPollRun: (_runId) => ({
-                    runId: _runId,
-                    status: 'succeeded',
-                    startedAt: new Date().toISOString(),
-                    endedAt: new Date().toISOString(),
-                }),
-                onFetchOutput: (_runId) => ({
-                    runId: _runId,
-                    payload: {
-                        taskId: opts.taskId,
-                        sourceScribeArtifactId: capturedSourceScribeArtifactId,
-                        implementationPlan: {
-                            summary: 'Test implementation summary',
-                            targetSurface: 'src/test/*.ts',
-                            changes: ['Add validation to test module'],
-                            tests: ['Unit test for validation'],
-                            rolloutNotes: ['Deploy behind feature flag'],
-                            confidence: 0.8,
-                        },
-                        sourceTrace: {
-                            scribeArtifactId: capturedSourceScribeArtifactId,
-                        },
-                        risks: [],
-                        generatedAt: new Date().toISOString(),
+            }),
+        });
+    }
+    if (runnerKind === 'scribe') {
+        return new TestDoubleRuntimeAdapter({
+            onPollRun: (_runId) => ({
+                runId: _runId,
+                status: 'succeeded',
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+            }),
+            onFetchOutput: (_runId) => ({
+                runId: _runId,
+                payload: {
+                    taskId,
+                    sourcePhilosopherArtifactId: 'pi-art-test-philosopher',
+                    principleDraft: {
+                        title: 'Test Principle Draft',
+                        statement: 'Test principle statement',
+                        rationale: 'Test rationale',
+                        applicability: ['All operations'],
+                        antiPatterns: ['Ignoring validation'],
+                        confidence: 0.8,
                     },
-                }),
-            });
-        }
-        if (opts.runnerKind === 'evaluator') {
-            let capturedSourceArtificerArtifactId = 'pi-art-test-artificer';
-            return new TestDoubleRuntimeAdapter({
-                onStartRun: (input) => {
-                    try {
-                        const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
-                        const parsed = JSON.parse(payloadStr);
-                        if (typeof parsed.sourceArtificerArtifactId === 'string' && parsed.sourceArtificerArtifactId.trim() !== '') {
-                            capturedSourceArtificerArtifactId = parsed.sourceArtificerArtifactId;
-                        }
-                    }
-                    catch { /* use default */ }
-                    return { runId: `td-evaluator-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
-                },
-                onPollRun: (_runId) => ({
-                    runId: _runId,
-                    status: 'succeeded',
-                    startedAt: new Date().toISOString(),
-                    endedAt: new Date().toISOString(),
-                }),
-                onFetchOutput: (_runId) => ({
-                    runId: _runId,
-                    payload: {
-                        taskId: opts.taskId,
-                        sourceArtificerArtifactId: capturedSourceArtificerArtifactId,
-                        evaluation: {
-                            decision: 'approved',
-                            summary: 'Test evaluation summary',
-                            score: 0.85,
-                            strengths: ['Well-structured plan'],
-                            concerns: [],
-                            requiredChanges: [],
-                        },
-                        sourceTrace: {
-                            artificerArtifactId: capturedSourceArtificerArtifactId,
-                        },
-                        risks: [],
-                        generatedAt: new Date().toISOString(),
+                    sourceTrace: {
+                        philosopherArtifactId: 'pi-art-test-philosopher',
                     },
-                }),
-            });
-        }
-        if (opts.runnerKind === 'rollout_reviewer') {
-            let capturedSourceEvaluatorArtifactId = 'pi-art-test-evaluator';
-            return new TestDoubleRuntimeAdapter({
-                onStartRun: (input) => {
-                    try {
-                        const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
-                        const parsed = JSON.parse(payloadStr);
-                        if (typeof parsed.sourceEvaluatorArtifactId === 'string' && parsed.sourceEvaluatorArtifactId.trim() !== '') {
-                            capturedSourceEvaluatorArtifactId = parsed.sourceEvaluatorArtifactId;
-                        }
-                    }
-                    catch { /* use default */ }
-                    return { runId: `td-rollout-reviewer-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
+                    risks: [],
+                    generatedAt: new Date().toISOString(),
                 },
-                onPollRun: (_runId) => ({
-                    runId: _runId,
-                    status: 'succeeded',
-                    startedAt: new Date().toISOString(),
-                    endedAt: new Date().toISOString(),
-                }),
-                onFetchOutput: (_runId) => ({
-                    runId: _runId,
-                    payload: {
-                        taskId: opts.taskId,
-                        sourceEvaluatorArtifactId: capturedSourceEvaluatorArtifactId,
-                        review: {
-                            decision: 'approve_rollout',
-                            summary: 'Test rollout review summary',
-                            confidence: 0.9,
-                            requiredChanges: [],
-                            rolloutRisks: [],
-                            safetyChecks: ['Verify feature flag is properly configured'],
-                        },
-                        sourceTrace: {
-                            evaluatorArtifactId: capturedSourceEvaluatorArtifactId,
-                        },
-                        risks: [],
-                        generatedAt: new Date().toISOString(),
-                    },
-                }),
-            });
-        }
-        if (opts.runnerKind === 'trainer') {
-            let capturedSourceRolloutReviewerArtifactId = 'pi-art-test-rollout-reviewer';
-            return new TestDoubleRuntimeAdapter({
-                onStartRun: (input) => {
-                    try {
-                        const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
-                        const parsed = JSON.parse(payloadStr);
-                        if (typeof parsed.sourceRolloutReviewerArtifactId === 'string' && parsed.sourceRolloutReviewerArtifactId.trim() !== '') {
-                            capturedSourceRolloutReviewerArtifactId = parsed.sourceRolloutReviewerArtifactId;
-                        }
+            }),
+        });
+    }
+    if (runnerKind === 'artificer') {
+        let capturedSourceScribeArtifactId = 'pi-art-test-scribe';
+        return new TestDoubleRuntimeAdapter({
+            onStartRun: (input) => {
+                try {
+                    const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
+                    const parsed = JSON.parse(payloadStr);
+                    if (typeof parsed.sourceScribeArtifactId === 'string' && parsed.sourceScribeArtifactId.trim() !== '') {
+                        capturedSourceScribeArtifactId = parsed.sourceScribeArtifactId;
                     }
-                    catch { /* use default */ }
-                    return { runId: `td-trainer-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
-                },
-                onPollRun: (_runId) => ({
-                    runId: _runId,
-                    status: 'succeeded',
-                    startedAt: new Date().toISOString(),
-                    endedAt: new Date().toISOString(),
-                }),
-                onFetchOutput: (_runId) => ({
-                    runId: _runId,
-                    payload: {
-                        taskId: opts.taskId,
-                        sourceRolloutReviewerArtifactId: capturedSourceRolloutReviewerArtifactId,
-                        ruleCandidate: {
-                            toolScope: 'src/**/*.ts',
-                            triggerCondition: 'TypeScript file edit with schema mismatch',
-                            proposedDecision: 'auto_correct',
-                            proposedCorrection: {
-                                description: 'Auto-correct by adding input validation before processing',
-                                proposedParams: {
-                                    strategy: 'prepend',
-                                    snippet: 'const validated = schema.parse(input); if (!validated.success) throw new ValidationError(validated.error);',
-                                },
-                            },
-                            rationale: 'Auto-correct validates input before processing to prevent downstream errors',
-                            confidence: 0.88,
-                        },
-                        safety: {
-                            limitations: ['Requires schema definition for all input types', 'May not handle complex nested structures'],
-                            falsePositiveRisks: ['Could over-correct on intentional dynamic patterns'],
-                            requiredReplayCases: ['Schema validation edge case', 'Nested object validation'],
-                        },
-                        sourceTrace: {
-                            rolloutReviewerArtifactId: capturedSourceRolloutReviewerArtifactId,
-                        },
-                        risks: [],
-                        generatedAt: new Date().toISOString(),
+                }
+                catch { /* use default */ }
+                return { runId: `td-artificer-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
+            },
+            onPollRun: (_runId) => ({
+                runId: _runId,
+                status: 'succeeded',
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+            }),
+            onFetchOutput: (_runId) => ({
+                runId: _runId,
+                payload: {
+                    taskId,
+                    sourceScribeArtifactId: capturedSourceScribeArtifactId,
+                    implementationPlan: {
+                        summary: 'Test implementation summary',
+                        targetSurface: 'src/test/*.ts',
+                        changes: ['Add validation to test module'],
+                        tests: ['Unit test for validation'],
+                        rolloutNotes: ['Deploy behind feature flag'],
+                        confidence: 0.8,
                     },
-                }),
-            });
-        }
+                    sourceTrace: {
+                        scribeArtifactId: capturedSourceScribeArtifactId,
+                    },
+                    risks: [],
+                    generatedAt: new Date().toISOString(),
+                },
+            }),
+        });
+    }
+    if (runnerKind === 'evaluator') {
+        let capturedSourceArtificerArtifactId = 'pi-art-test-artificer';
         return new TestDoubleRuntimeAdapter({
+            onStartRun: (input) => {
+                try {
+                    const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
+                    const parsed = JSON.parse(payloadStr);
+                    if (typeof parsed.sourceArtificerArtifactId === 'string' && parsed.sourceArtificerArtifactId.trim() !== '') {
+                        capturedSourceArtificerArtifactId = parsed.sourceArtificerArtifactId;
+                    }
+                }
+                catch { /* use default */ }
+                return { runId: `td-evaluator-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
+            },
             onPollRun: (_runId) => ({
                 runId: _runId,
                 status: 'succeeded',
@@ -369,56 +244,147 @@ function resolveRuntimeAdapter(opts) {
             onFetchOutput: (_runId) => ({
                 runId: _runId,
                 payload: {
-                    valid: true,
-                    taskId: opts.taskId,
-                    candidates: [{
-                            candidateIndex: 0,
-                            badDecision: 'Ignored input validation requirement',
-                            betterDecision: 'Validate all inputs against schema before processing',
-                            rationale: 'Input validation prevents downstream errors and data corruption',
-                            confidence: 0.85,
-                            riskLevel: 'low',
-                            strategicPerspective: 'defensive-programming',
-                        }],
-                    contextRefs: [],
+                    taskId,
+                    sourceArtificerArtifactId: capturedSourceArtificerArtifactId,
+                    evaluation: {
+                        decision: 'approved',
+                        summary: 'Test evaluation summary',
+                        score: 0.85,
+                        strengths: ['Well-structured plan'],
+                        concerns: [],
+                        requiredChanges: [],
+                    },
+                    sourceTrace: {
+                        artificerArtifactId: capturedSourceArtificerArtifactId,
+                    },
+                    risks: [],
                     generatedAt: new Date().toISOString(),
                 },
             }),
         });
     }
-    const stateDir = path.join(opts.workspaceDir, '.state');
-    const configResult = resolveRuntimeConfig(stateDir, { requestedRuntimeKind: opts.runtimeKind });
-    if (isRuntimeConfigError(configResult)) {
-        throw new ConfigResolutionError(`Config resolution failed: ${configResult.reason}. ` +
-            `${configResult.message}. nextAction: ${configResult.nextAction}`);
-    }
-    if (opts.runtimeKind === 'pi-ai' || (opts.runtimeKind === 'config' && configResult.runtimeKind === 'pi-ai')) {
-        validateRuntimeConfig(configResult);
-        // CLI --timeout-ms overrides workflows.yaml timeoutMs
-        const adapterTimeoutMs = opts.timeoutMs ?? configResult.timeoutMs;
-        return new PiAiRuntimeAdapter({
-            provider: String(configResult.provider),
-            model: String(configResult.model),
-            apiKeyEnv: String(configResult.apiKeyEnv),
-            maxRetries: configResult.maxRetries,
-            timeoutMs: adapterTimeoutMs,
-            baseUrl: configResult.baseUrl,
-            workspace: opts.workspaceDir,
+    if (runnerKind === 'rollout_reviewer') {
+        let capturedSourceEvaluatorArtifactId = 'pi-art-test-evaluator';
+        return new TestDoubleRuntimeAdapter({
+            onStartRun: (input) => {
+                try {
+                    const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
+                    const parsed = JSON.parse(payloadStr);
+                    if (typeof parsed.sourceEvaluatorArtifactId === 'string' && parsed.sourceEvaluatorArtifactId.trim() !== '') {
+                        capturedSourceEvaluatorArtifactId = parsed.sourceEvaluatorArtifactId;
+                    }
+                }
+                catch { /* use default */ }
+                return { runId: `td-rollout-reviewer-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
+            },
+            onPollRun: (_runId) => ({
+                runId: _runId,
+                status: 'succeeded',
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+            }),
+            onFetchOutput: (_runId) => ({
+                runId: _runId,
+                payload: {
+                    taskId,
+                    sourceEvaluatorArtifactId: capturedSourceEvaluatorArtifactId,
+                    review: {
+                        decision: 'approve_rollout',
+                        summary: 'Test rollout review summary',
+                        confidence: 0.9,
+                        requiredChanges: [],
+                        rolloutRisks: [],
+                        safetyChecks: ['Verify feature flag is properly configured'],
+                    },
+                    sourceTrace: {
+                        evaluatorArtifactId: capturedSourceEvaluatorArtifactId,
+                    },
+                    risks: [],
+                    generatedAt: new Date().toISOString(),
+                },
+            }),
         });
     }
-    if (opts.runtimeKind === 'openclaw-cli' || (opts.runtimeKind === 'config' && configResult.runtimeKind === 'openclaw-cli')) {
-        const { openclawMode } = configResult;
-        if (!openclawMode) {
-            throw new ConfigResolutionError(`runtimeKind 'openclaw-cli' requires openclawMode. ` +
-                `Provide --openclaw-local or --openclaw-gateway, or set openclawMode in workflows.yaml. ` +
-                `nextAction: Add openclawMode: local|gateway to your funnel policy or use CLI flags.`);
-        }
-        return new OpenClawCliRuntimeAdapter({
-            runtimeMode: openclawMode,
-            workspaceDir: opts.workspaceDir,
+    if (runnerKind === 'trainer') {
+        let capturedSourceRolloutReviewerArtifactId = 'pi-art-test-rollout-reviewer';
+        return new TestDoubleRuntimeAdapter({
+            onStartRun: (input) => {
+                try {
+                    const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
+                    const parsed = JSON.parse(payloadStr);
+                    if (typeof parsed.sourceRolloutReviewerArtifactId === 'string' && parsed.sourceRolloutReviewerArtifactId.trim() !== '') {
+                        capturedSourceRolloutReviewerArtifactId = parsed.sourceRolloutReviewerArtifactId;
+                    }
+                }
+                catch { /* use default */ }
+                return { runId: `td-trainer-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
+            },
+            onPollRun: (_runId) => ({
+                runId: _runId,
+                status: 'succeeded',
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+            }),
+            onFetchOutput: (_runId) => ({
+                runId: _runId,
+                payload: {
+                    taskId,
+                    sourceRolloutReviewerArtifactId: capturedSourceRolloutReviewerArtifactId,
+                    ruleCandidate: {
+                        toolScope: 'src/**/*.ts',
+                        triggerCondition: 'TypeScript file edit with schema mismatch',
+                        proposedDecision: 'auto_correct',
+                        proposedCorrection: {
+                            description: 'Auto-correct by adding input validation before processing',
+                            proposedParams: {
+                                strategy: 'prepend',
+                                snippet: 'const validated = schema.parse(input); if (!validated.success) throw new ValidationError(validated.error);',
+                            },
+                        },
+                        rationale: 'Auto-correct validates input before processing to prevent downstream errors',
+                        confidence: 0.88,
+                    },
+                    safety: {
+                        limitations: ['Requires schema definition for all input types', 'May not handle complex nested structures'],
+                        falsePositiveRisks: ['Could over-correct on intentional dynamic patterns'],
+                        requiredReplayCases: ['Schema validation edge case', 'Nested object validation'],
+                    },
+                    sourceTrace: {
+                        rolloutReviewerArtifactId: capturedSourceRolloutReviewerArtifactId,
+                    },
+                    risks: [],
+                    generatedAt: new Date().toISOString(),
+                },
+            }),
         });
     }
-    throw new Error(`Unsupported runtime kind: ${opts.runtimeKind}. Supported: test-double, pi-ai, openclaw-cli, config`);
+    // dreamer / default
+    return new TestDoubleRuntimeAdapter({
+        onPollRun: (_runId) => ({
+            runId: _runId,
+            status: 'succeeded',
+            startedAt: new Date().toISOString(),
+            endedAt: new Date().toISOString(),
+        }),
+        onFetchOutput: (_runId) => ({
+            runId: _runId,
+            payload: {
+                valid: true,
+                taskId,
+                candidates: [{
+                        candidateIndex: 0,
+                        badDecision: 'Ignored input validation requirement',
+                        betterDecision: 'Validate all inputs against schema before processing',
+                        rationale: 'Input validation prevents downstream errors and data corruption',
+                        confidence: 0.85,
+                        riskLevel: 'low',
+                        strategicPerspective: 'defensive-programming',
+                    }],
+                contextRefs: [],
+                generatedAt: new Date().toISOString(),
+            },
+        }),
+    });
 }
 export async function handleRuntimeInternalizationRunOnce(opts) {
     const workspaceDir = opts.workspace ? path.resolve(opts.workspace) : resolveWorkspaceDir();
@@ -436,7 +402,7 @@ export async function handleRuntimeInternalizationRunOnce(opts) {
     if (runtimeKind === 'test-double' && !opts.allowTestDouble) {
         console.error('Error: test-double runtime mutates real queue state (leases tasks, marks them succeeded with empty output).');
         console.error('Use --runtime test-double --allow-test-double to acknowledge this risk.');
-        console.error('For production use, use --runtime config (reads from workflows.yaml) or --runtime pi-ai / openclaw-cli.');
+        console.error('For production use, use --runtime config (reads from .pd/config.yaml) or --runtime pi-ai / openclaw-cli.');
         process.exitCode = 1;
         return;
     }
@@ -467,47 +433,77 @@ export async function handleRuntimeInternalizationRunOnce(opts) {
             }
             const eventEmitter = new StoreEventEmitter();
             const artifactStore = stateManager.piArtifactStore;
-            const runtimeAdapter = resolveRuntimeAdapter({ runtimeKind, taskId: wakeResult.taskId, workspaceDir, runnerKind, timeoutMs: cliTimeoutMs });
-            if (runnerKind === 'dreamer') {
-                const validator = new DefaultDreamerValidator();
-                const runner = new DreamerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
-                runnerResult = await runner.run(wakeResult.taskId);
-            }
-            else if (runnerKind === 'philosopher') {
-                const validator = new DefaultPhilosopherValidator();
-                const runner = new PhilosopherRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
-                runnerResult = await runner.run(wakeResult.taskId);
-            }
-            else if (runnerKind === 'scribe') {
-                // PRI-336: Read outputLanguage from workspace config
-                const outputLangResult = readOutputLanguageFromWorkspace(workspaceDir);
-                const outputLanguage = outputLangResult.outputLanguage;
-                const validator = new DefaultScribeValidator();
-                const runner = new ScribeRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs, outputLanguage });
-                runnerResult = await runner.run(wakeResult.taskId);
-            }
-            else if (runnerKind === 'artificer') {
-                const validator = new DefaultArtificerValidator();
-                const runner = new ArtificerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
-                runnerResult = await runner.run(wakeResult.taskId);
-            }
-            else if (runnerKind === 'evaluator') {
-                const validator = new DefaultEvaluatorValidator();
-                const runner = new EvaluatorRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
-                runnerResult = await runner.run(wakeResult.taskId);
-            }
-            else if (runnerKind === 'rollout_reviewer') {
-                const validator = new DefaultRolloutReviewerValidator();
-                const runner = new RolloutReviewerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
-                runnerResult = await runner.run(wakeResult.taskId);
-            }
-            else if (runnerKind === 'trainer') {
-                const validator = new DefaultTrainerValidator();
-                const runner = new TrainerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
-                runnerResult = await runner.run(wakeResult.taskId);
+            const runtimeAdapter = resolveRuntimeAdapterFromConfig({
+                runtimeKind,
+                workspaceDir,
+                runnerKind,
+                timeoutMs: cliTimeoutMs,
+                allowTestDouble: true,
+                testDoublePayloadBuilder: () => buildTestDoubleAdapter(runnerKind, wakeResult.taskId),
+                // PRI-419: pass the L2 readers so the resolver can build an L2AgentLoopAdapter
+                // when l2_dreamer is enabled. Only consumed for dreamer; harmless for other runners.
+                l2ArtifactReader: artifactStore,
+                l2StateDir: `${workspaceDir}/.state`,
+            });
+            try {
+                if (runnerKind === 'dreamer') {
+                    const validator = new DefaultDreamerValidator();
+                    const runner = new DreamerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
+                    runnerResult = await runner.run(wakeResult.taskId);
+                }
+                else if (runnerKind === 'philosopher') {
+                    const validator = new DefaultPhilosopherValidator();
+                    const runner = new PhilosopherRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
+                    runnerResult = await runner.run(wakeResult.taskId);
+                }
+                else if (runnerKind === 'scribe') {
+                    // PRI-336: Read outputLanguage from workspace config
+                    const outputLangResult = readOutputLanguageFromWorkspace(workspaceDir);
+                    const outputLanguage = outputLangResult.outputLanguage;
+                    const validator = new DefaultScribeValidator();
+                    const runner = new ScribeRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs, outputLanguage });
+                    runnerResult = await runner.run(wakeResult.taskId);
+                }
+                else if (runnerKind === 'artificer') {
+                    const validator = new DefaultArtificerValidator();
+                    const runner = new ArtificerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
+                    runnerResult = await runner.run(wakeResult.taskId);
+                }
+                else if (runnerKind === 'evaluator') {
+                    const validator = new DefaultEvaluatorValidator();
+                    const runner = new EvaluatorRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
+                    runnerResult = await runner.run(wakeResult.taskId);
+                }
+                else if (runnerKind === 'rollout_reviewer') {
+                    const validator = new DefaultRolloutReviewerValidator();
+                    const runner = new RolloutReviewerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
+                    runnerResult = await runner.run(wakeResult.taskId);
+                }
+                else if (runnerKind === 'trainer') {
+                    const validator = new DefaultTrainerValidator();
+                    const runner = new TrainerRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
+                    runnerResult = await runner.run(wakeResult.taskId);
+                }
+                else {
+                    skipReason = 'no_runner_implemented';
+                }
             }
-            else {
-                skipReason = 'no_runner_implemented';
+            catch (runErr) {
+                console.error(`Error: runner crashed: ${runErr instanceof Error ? runErr.message : String(runErr)}`);
+                try {
+                    const task = await stateManager.getTask(wakeResult.taskId);
+                    const failureReason = `Unhandled runner crash: ${runErr instanceof Error ? runErr.message : String(runErr)}`;
+                    if (task && stateManager.getRetryPolicy().shouldRetry(task)) {
+                        await stateManager.markTaskRetryWait(wakeResult.taskId, 'execution_failed', failureReason);
+                    }
+                    else {
+                        await stateManager.markTaskFailed(wakeResult.taskId, 'execution_failed', failureReason);
+                    }
+                }
+                catch (dbErr) {
+                    console.error(`Error: failed to update task state in DB: ${String(dbErr)}`);
+                }
+                throw runErr;
             }
         }
         const output = buildOutput(wakeResult, runnerResult, skipReason);
@@ -580,7 +576,7 @@ export async function handleRuntimeInternalizationRunOnce(opts) {
                 decision: isConfigError ? 'config_error' : 'runtime_error',
                 reason: message,
                 nextAction: isConfigError
-                    ? 'Fix the workflows.yaml funnel policy, or use --runtime pi-ai / openclaw-cli with explicit flags'
+                    ? 'Fix the .pd/config.yaml runtime profile, or use --runtime pi-ai / openclaw-cli with explicit flags'
                     : 'Check runner logs and workspace state; re-run with --runtime test-double to isolate',
             }, null, 2));
         }