@principles/pd-cli 1.115.0 → 1.117.0

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

@@ -1,17 +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, L2AgentLoopAdapter, loadLedger, isRuntimeConfigError, validateRuntimeConfig, } from '@principles/core/runtime-v2';
-import { loadEffectiveFeatureFlags } from '../services/feature-flag-loader.js';
+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 { resolveRuntimeFromPdConfig } from '../services/resolve-runtime-from-pd-config.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 };
@@ -125,266 +118,123 @@ function formatTextOutput(output) {
     return lines.join('\n');
 }
 /**
- * PRI-419: build a read-only principle reader from the workspace ledger.
- * Returns active internalized principles (id + statement). Degrades to empty on missing ledger.
+ * 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 makeDreamerPrincipleReader(stateDir) {
-    return {
-        listActivePrinciples: async () => {
-            try {
-                const ledger = loadLedger(stateDir);
-                const principles = ledger.tree.principles ?? {};
-                const active = Object.values(principles).filter(p => p.status === 'active' && typeof p.id === 'string' && typeof p.text === 'string');
-                return active.map(p => ({ id: p.id, statement: p.text }));
-            }
-            catch (error) {
-                // Graceful degradation WITH an observable reason (Runtime Contract R9): the L2
-                // dreamer proceeds with only core axioms; the degradation is logged for debugging.
-                const reason = error instanceof Error ? error.message : String(error);
-                console.warn(`[l2_dreamer] listActivePrinciples degraded — no internalized principles loaded: ${reason}`);
-                return [];
-            }
-        },
-    };
-}
-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(),
+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',
@@ -394,78 +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(),
                 },
             }),
         });
     }
-    // PRI-393: resolve runtime from .pd/config.yaml (not .state/workflows.yaml)
-    const resolved = resolveRuntimeFromPdConfig(opts.workspaceDir);
-    const configResult = resolved.result;
-    if (isRuntimeConfigError(configResult)) {
-        throw new ConfigResolutionError(`Config resolution from .pd/config.yaml 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 config timeoutMs
-        const adapterTimeoutMs = opts.timeoutMs ?? configResult.timeoutMs;
-        // PRI-419: when l2_dreamer flag is on AND this is the dreamer runner, route through the
-        // L2 multi-turn agent loop adapter. Other runners (philosopher/scribe/...) stay on L1.
-        if (opts.runnerKind === 'dreamer' && opts.l2ArtifactReader && opts.l2StateDir) {
-            const effectiveFlags = loadEffectiveFeatureFlags(opts.workspaceDir);
-            const l2Flag = Object.hasOwn(effectiveFlags.flags, 'l2_dreamer')
-                ? effectiveFlags.flags.l2_dreamer.enabled
-                : false;
-            if (l2Flag) {
-                return new L2AgentLoopAdapter({
-                    provider: String(configResult.provider),
-                    model: String(configResult.model),
-                    apiKeyEnv: String(configResult.apiKeyEnv),
-                    baseUrl: configResult.baseUrl,
-                    workspace: opts.workspaceDir,
-                    totalBudgetMs: adapterTimeoutMs,
-                }, {
-                    artifactReader: opts.l2ArtifactReader,
-                    principleReader: makeDreamerPrincipleReader(opts.l2StateDir),
-                });
-            }
-        }
-        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 .pd/config.yaml. ` +
-                `nextAction: Add openclawMode: local|gateway to your .pd/config.yaml runtime profile 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();
@@ -514,13 +433,14 @@ export async function handleRuntimeInternalizationRunOnce(opts) {
             }
             const eventEmitter = new StoreEventEmitter();
             const artifactStore = stateManager.piArtifactStore;
-            const runtimeAdapter = resolveRuntimeAdapter({
+            const runtimeAdapter = resolveRuntimeAdapterFromConfig({
                 runtimeKind,
-                taskId: wakeResult.taskId,
                 workspaceDir,
                 runnerKind,
                 timeoutMs: cliTimeoutMs,
-                // PRI-419: pass the L2 readers so resolveRuntimeAdapter can build an L2AgentLoopAdapter
+                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`,