@principles/pd-cli 1.73.0

package/dist/commands/runtime-internalization-queue.js

@@ -0,0 +1,85 @@
+/**
+ * pd runtime internalization queue command handler.
+ *
+ * Usage:
+ *   pd runtime internalization queue --workspace <path> --json
+ *
+ * Provides a read-only snapshot of the PI task queue health.
+ * Never acquires leases or mutates any task/run/artifact/ledger state.
+ */
+import * as path from 'path';
+import { createInternalizationQueueReadModel } from '@principles/core/runtime-v2';
+import { resolveWorkspaceDir } from '../resolve-workspace.js';
+import { loadEffectiveFeatureFlags } from '../services/feature-flag-loader.js';
+function formatTextOutput(snap) {
+    const lines = [];
+    lines.push(`Internalization Queue Snapshot`);
+    lines.push(`  pending: ${snap.pendingCount}  retry_wait: ${snap.retryWaitCount}`);
+    if (snap.invalidMetadataCount > 0) {
+        lines.push(`  invalid_metadata: ${snap.invalidMetadataCount}  (${snap.sampleInvalidTaskIds.join(', ')})`);
+    }
+    lines.push(`  ready: ${snap.readyTasks.length}`);
+    const taskKinds = Object.entries(snap.countsByTaskKind);
+    if (taskKinds.length > 0) {
+        lines.push(`  by_kind: ${taskKinds.map(([k, v]) => `${k}=${v}`).join(', ')}`);
+    }
+    const channels = Object.entries(snap.countsByChannel);
+    if (channels.length > 0) {
+        lines.push(`  by_channel: ${channels.map(([k, v]) => `${k}=${v}`).join(', ')}`);
+    }
+    if (snap.blockedSummary.count > 0) {
+        lines.push(`  blocked: ${snap.blockedSummary.count}`);
+        for (const s of snap.blockedSummary.samples.slice(0, 3)) {
+            lines.push(`    ${s.taskId} (${s.taskKind}) blocked by: ${s.blockedBy.join(', ')}`);
+        }
+    }
+    if (snap.dependencyFailedSummary.count > 0) {
+        lines.push(`  dependency_failed: ${snap.dependencyFailedSummary.count}`);
+        for (const s of snap.dependencyFailedSummary.samples.slice(0, 3)) {
+            lines.push(`    ${s.taskId} (${s.taskKind}) failed deps: ${s.failedDependencies.join(', ')}`);
+        }
+    }
+    if (snap.leaseConflictSummary.count > 0) {
+        lines.push(`  lease_conflict: ${snap.leaseConflictSummary.count}`);
+        for (const s of snap.leaseConflictSummary.samples.slice(0, 3)) {
+            lines.push(`    ${s.taskId} (${s.taskKind}) owner: ${s.leaseOwner}, expires: ${s.leaseExpiresAt}`);
+        }
+    }
+    if (snap.retryWaitPendingSummary.count > 0) {
+        lines.push(`  retry_wait_pending: ${snap.retryWaitPendingSummary.count}`);
+        for (const s of snap.retryWaitPendingSummary.samples.slice(0, 3)) {
+            lines.push(`    ${s.taskId} (${s.taskKind}) retry_after: ${s.retryAfter}`);
+        }
+    }
+    if (snap.noReadyTasks) {
+        lines.push(`  no_ready_tasks: ${snap.noReadyTasks.reason} (inspected: ${snap.noReadyTasks.inspectedCount})`);
+    }
+    if (snap.suppressedTasks.length > 0) {
+        lines.push(`  suppressed (${snap.suppressedTasks.length}):`);
+        for (const s of snap.suppressedTasks.slice(0, 5)) {
+            lines.push(`    ${s.taskId} (${s.taskKind}, ${s.channel}) reason: ${s.reason}`);
+        }
+    }
+    return lines.join('\n');
+}
+export async function handleRuntimeInternalizationQueue(opts) {
+    const workspaceDir = opts.workspace ? path.resolve(opts.workspace) : resolveWorkspaceDir();
+    const featureFlags = loadEffectiveFeatureFlags(workspaceDir);
+    const enabledChannels = new Set(Object.values(featureFlags.flags)
+        .filter(f => f.enabled)
+        .map(f => f.id));
+    const { readModel, close } = await createInternalizationQueueReadModel({ workspaceDir, enabledChannels });
+    try {
+        const snapshot = await readModel.getSnapshot();
+        if (opts.json) {
+            console.log(JSON.stringify(snapshot, null, 2));
+        }
+        else {
+            console.log(formatTextOutput(snapshot));
+        }
+    }
+    finally {
+        await close();
+    }
+}
+//# sourceMappingURL=runtime-internalization-queue.js.map

package/dist/commands/runtime-internalization-queue.js.map

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

package/dist/commands/runtime-internalization-run-once.d.ts

@@ -0,0 +1,12 @@
+interface RunOnceOptions {
+    workspace?: string;
+    json?: boolean;
+    runtime?: string;
+    runner?: string;
+    allowTestDouble?: boolean;
+    enqueueNext?: boolean;
+    timeoutMs?: number;
+}
+export declare function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions): Promise<void>;
+export {};
+//# sourceMappingURL=runtime-internalization-run-once.d.ts.map

package/dist/commands/runtime-internalization-run-once.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-internalization-run-once.d.ts","sourceRoot":"","sources":["../../src/commands/runtime-internalization-run-once.ts"],"names":[],"mappings":"AA6BA,UAAU,cAAc;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA2cD,wBAAsB,mCAAmC,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAiK7F"}

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

@@ -0,0 +1,546 @@
+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 { resolveWorkspaceDir } from '../resolve-workspace.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 };
+    switch (wakeResult.decision) {
+        case 'leased':
+            base.taskId = wakeResult.taskId;
+            base.taskKind = wakeResult.taskKind;
+            base.attemptCount = wakeResult.attemptCount;
+            if (runnerResult)
+                base.runnerResult = runnerResult;
+            if (skipReason)
+                base.skipReason = skipReason;
+            break;
+        case 'would_lease':
+            base.taskId = wakeResult.taskId;
+            base.taskKind = wakeResult.taskKind;
+            if (runnerResult) {
+                base.runnerResult = runnerResult;
+                base.runId = runnerResult.runId;
+                base.artifactId = runnerResult.artifactId;
+                base.resultRef = runnerResult.resultRef;
+            }
+            if (skipReason)
+                base.skipReason = skipReason;
+            break;
+        case 'no_ready_tasks':
+            base.reason = wakeResult.reason;
+            base.inspectedCount = wakeResult.inspectedCount;
+            break;
+        case 'blocked':
+            base.taskId = wakeResult.taskId;
+            base.taskKind = wakeResult.taskKind;
+            break;
+        case 'dependency_failed':
+            base.taskId = wakeResult.taskId;
+            base.taskKind = wakeResult.taskKind;
+            break;
+        case 'lease_conflict':
+            base.taskId = wakeResult.taskId;
+            base.conflictReason = wakeResult.conflictReason;
+            break;
+        case 'invalid_task_metadata':
+            base.taskId = wakeResult.taskId;
+            base.taskKind = wakeResult.taskKind;
+            break;
+        default:
+            break;
+    }
+    return base;
+}
+function formatTextOutput(output) {
+    const lines = [];
+    lines.push(`Internalization Run-Once: ${output.decision}`);
+    if (output.runnerKind) {
+        lines.push(`  runner: ${output.runnerKind}`);
+    }
+    if (output.taskId) {
+        lines.push(`  task: ${output.taskId} (${output.taskKind ?? 'unknown'})`);
+    }
+    if (output.runnerResult) {
+        lines.push(`  runner: ${output.runnerResult.status}`);
+        if (output.runId) {
+            lines.push(`  runId: ${output.runId}`);
+        }
+        if (output.artifactId) {
+            lines.push(`  artifactId: ${output.artifactId}`);
+        }
+        if (output.resultRef) {
+            lines.push(`  resultRef: ${output.resultRef}`);
+        }
+        if (output.runnerResult.errorCategory) {
+            lines.push(`  error: ${output.runnerResult.errorCategory}`);
+        }
+        if (output.runnerResult.failureReason) {
+            lines.push(`  reason: ${output.runnerResult.failureReason}`);
+        }
+    }
+    if (output.skipReason) {
+        lines.push(`  skip: ${output.skipReason}`);
+    }
+    if (output.conflictReason) {
+        lines.push(`  conflict: ${output.conflictReason}`);
+    }
+    if (output.reason) {
+        lines.push(`  reason: ${output.reason}`);
+    }
+    if (output.successorTaskId) {
+        lines.push(`  successor: ${output.successorTaskId} (${output.successorKind ?? 'unknown'})`);
+    }
+    if (output.enqueueDecision) {
+        lines.push(`  enqueue: ${output.enqueueDecision}`);
+    }
+    if (output.effectiveTimeoutMs) {
+        lines.push(`  timeout: ${output.effectiveTimeoutMs}ms`);
+    }
+    if (output.timeoutSource) {
+        lines.push(`  timeoutSource: ${output.timeoutSource}`);
+    }
+    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(),
+                    },
+                }),
+            });
+        }
+        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() };
+                },
+                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 (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(),
+                    },
+                }),
+            });
+        }
+        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() };
+                },
+                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;
+                        }
+                    }
+                    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(),
+                    },
+                }),
+            });
+        }
+        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: 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: [],
+                    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 (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,
+        });
+    }
+    throw new Error(`Unsupported runtime kind: ${opts.runtimeKind}. Supported: test-double, pi-ai, openclaw-cli, config`);
+}
+export async function handleRuntimeInternalizationRunOnce(opts) {
+    const workspaceDir = opts.workspace ? path.resolve(opts.workspace) : resolveWorkspaceDir();
+    const runtimeKind = opts.runtime ?? 'config';
+    const runnerKind = opts.runner ?? 'dreamer';
+    // Resolve effective timeout: CLI flag > runner default (300_000)
+    const cliTimeoutMs = opts.timeoutMs;
+    if (cliTimeoutMs !== undefined && (!Number.isFinite(cliTimeoutMs) || cliTimeoutMs <= 0)) {
+        console.error(`Error: --timeout-ms must be a positive integer, got: ${opts.timeoutMs}`);
+        process.exitCode = 1;
+        return;
+    }
+    const defaultRunnerTimeoutMs = 300_000;
+    const effectiveTimeoutMs = cliTimeoutMs ?? defaultRunnerTimeoutMs;
+    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.');
+        process.exitCode = 1;
+        return;
+    }
+    if (!SUPPORTED_RUNNERS.has(runnerKind)) {
+        console.error(`Error: unsupported runner kind: ${runnerKind}. Supported: ${[...SUPPORTED_RUNNERS].join(', ')}`);
+        process.exitCode = 1;
+        return;
+    }
+    const stateManager = new RuntimeStateManager({ workspaceDir });
+    await stateManager.initialize();
+    try {
+        const orchestrator = new InternalizationOrchestrator({ stateManager }, { owner: OWNER, runtimeKind: RUNTIME_KIND, dryRun: true });
+        let wakeResult = { decision: 'no_ready_tasks', reason: 'no_candidates', inspectedCount: 0 };
+        try {
+            wakeResult = await orchestrator.wakeOnce(runnerKind);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Error: wake-once failed: ${message}`);
+            process.exitCode = 1;
+            return;
+        }
+        let runnerResult = undefined;
+        let skipReason = undefined;
+        if (wakeResult.decision === 'would_lease') {
+            if (wakeResult.taskKind !== runnerKind) {
+                throw new Error(`Invariant violation: wakeOnce returned taskKind=${wakeResult.taskKind} but runnerKind=${runnerKind}`);
+            }
+            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') {
+                const validator = new DefaultScribeValidator();
+                const runner = new ScribeRunner({ stateManager, runtimeAdapter, eventEmitter, validator, artifactStore }, { owner: OWNER, runtimeKind: RUNTIME_KIND, pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs });
+                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);
+            }
+            else {
+                skipReason = 'no_runner_implemented';
+            }
+        }
+        const output = buildOutput(wakeResult, runnerResult, skipReason);
+        output.runnerKind = runnerKind;
+        output.effectiveTimeoutMs = effectiveTimeoutMs;
+        if (runnerResult?.failureReason?.includes('timeoutSource=')) {
+            const match = /timeoutSource=(\w+)/.exec(runnerResult.failureReason);
+            if (match) {
+                const [, source] = match;
+                output.timeoutSource = source;
+            }
+        }
+        if (opts.enqueueNext && runnerResult?.status === 'succeeded' && wakeResult.decision === 'would_lease') {
+            const commitResult = await orchestrator.commitNextTaskProposal(wakeResult.taskId);
+            output.enqueueDecision = commitResult.decision;
+            if (commitResult.decision === 'successor_created' || commitResult.decision === 'successor_exists') {
+                output.successorTaskId = commitResult.successorTaskId;
+                output.successorKind = commitResult.successorKind;
+            }
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(output, null, 2));
+        }
+        else {
+            console.log(formatTextOutput(output));
+        }
+        if (wakeResult.decision === 'no_ready_tasks' || wakeResult.decision === 'lease_conflict') {
+            process.exitCode = 1;
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const isConfigError = err instanceof ConfigResolutionError;
+        if (opts.json) {
+            console.log(JSON.stringify({
+                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'
+                    : 'Check runner logs and workspace state; re-run with --runtime test-double to isolate',
+            }, null, 2));
+        }
+        else {
+            console.error(`Error: ${message}`);
+        }
+        process.exitCode = 1;
+    }
+    finally {
+        await stateManager.close();
+    }
+}
+//# sourceMappingURL=runtime-internalization-run-once.js.map