@principles/core 1.296.2 → 1.297.1

package/dist/runtime-v2/adapter/openclaw-cli-runtime-adapter.js

@@ -1,837 +0,0 @@
-/**
- * OpenClawCliRuntimeAdapter — PDRuntimeAdapter implementation for openclaw-cli.
- *
- * One-shot run: startRun() spawns 'openclaw agent', blocks until CLI exits,
- * stores CliOutput in memory. pollRun()/fetchOutput() operate on stored state.
- *
- * Error mapping (D-04):
- *   ENOENT (binary not found) → runtime_unavailable
- *   timedOut → timeout
- *   non-zero exit code → execution_failed
- *   JSON parse failure → output_invalid
- *   DiagnosticianOutputV1Schema validation failure → output_invalid
- */
-import { Value } from '@sinclair/typebox/value';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { runCliProcess } from '../utils/cli-process-runner.js';
-import { PDRuntimeError } from '../error-categories.js';
-import { DiagnosticianOutputV1Schema } from '../diagnostician-output.js';
-import { resolveOutputSchema } from './output-schema-registry.js';
-import { storeEmitter } from '../store/event-emitter.js';
-import { safeStringifyPreview, truncatePreview } from './output-repair-contract.js';
-import { redactTelemetryString } from '../feedback/redact-sensitive.js';
-import { redactSensitiveFields } from '../feedback/redact-sensitive.js';
-import { repairMalformedJson } from './json-extractor.js';
-/**
- * Persist an inter-process message payload so the runtime CLI can read it via
- * --message-file. When no workspaceDir is configured, the payload is written
- * inside a fresh mkdtemp root owned solely by this call; on any write failure
- * that root is removed here so failed writes cannot leak temp dirs
- * (PRI-827 / js/insecure-temporary-file). Workspace-owned directories are
- * never removed: they are shared, not exclusive to this call.
- */
-async function writeMessageFile(message, workspaceDir) {
-    // Keep the payload in the PD workspace so cleanup and workspace ownership remain explicit.
-    const baseDir = workspaceDir
-        ? join(workspaceDir, '.pd', 'tmp')
-        : await mkdtemp(join(tmpdir(), 'pd-msg-'));
-    const cleanupDir = workspaceDir ? undefined : baseDir;
-    try {
-        await mkdir(baseDir, { recursive: true });
-        const filePath = join(baseDir, `msg-${Date.now()}-${Math.random().toString(36).slice(2, 7)}.json`);
-        await writeFile(filePath, message, 'utf8');
-        return { filePath, cleanupDir };
-    }
-    catch (error) {
-        if (cleanupDir !== undefined) {
-            try {
-                await rm(cleanupDir, { recursive: true, force: true });
-            }
-            catch {
-                // Best effort: preserve the original error even if cleanup also fails.
-            }
-        }
-        throw error;
-    }
-}
-/**
- * Remove a message file created by writeMessageFile, including its unique temp
- * root when one was created. Best effort on both success and failure paths.
- */
-async function cleanupMessageFile(ref) {
-    if (!ref)
-        return;
-    try {
-        if (ref.cleanupDir !== undefined) {
-            await rm(ref.cleanupDir, { recursive: true, force: true });
-        }
-        else {
-            await rm(ref.filePath, { force: true });
-        }
-    }
-    catch {
-        // File may already be gone; ignore cleanup errors
-    }
-}
-/**
- * Parse CliOutput stdout into the runtime's native result structure.
- *
- * OCRA-03 (revised): OpenClaw `--json` produces a CliOutput object (from openclaw's own
- * output.ts), NOT DiagnosticianOutputV1 directly. The LLM's diagnosis JSON lives inside
- * CliOutput.text as a string that may be:
- *
- *  1. Bare DiagnosticianOutputV1 JSON — { "valid": true, ... }
- *  2. Local envelope — { payloads: [{ text: "<json>" }], meta: ... }
- *  3. Gateway envelope — { result: { payloads: [{ text: "<json>" }] }, ... }
- *
- * This function normalises all three into a raw JSON value (string or object) that
- * DiagnosticianOutputV1Schema can validate.
- *
- * @returns The parsed JSON value, or null if stdout could not be parsed at all.
- */
-function extractPayloadFromCliOutput(stdout, stderr) {
-    for (const source of [stdout, stderr ?? '']) {
-        if (!source)
-            continue;
-        // Attempt 1: direct parse — covers case 1 (bare JSON)
-        try {
-            return JSON.parse(source);
-        }
-        catch { /* fall through */ }
-        // Attempt 2: balanced-bracket extraction — handles text that surrounds JSON.
-        // When multiple JSON objects are present (e.g. probe message + agent response in
-        // stderr), return the LAST complete object — the agent's response comes after the
-        // probe message that was injected into the session.
-        const objects = [];
-        let depth = 0;
-        let start = -1;
-        for (let i = 0; i < source.length; i++) {
-            const ch = source[i];
-            if (!ch)
-                continue;
-            if (ch === '{') {
-                if (start === -1)
-                    start = i;
-                depth++;
-            }
-            else if (ch === '}') {
-                depth--;
-                if (depth === 0 && start !== -1) {
-                    try {
-                        objects.push(JSON.parse(source.slice(start, i + 1)));
-                    }
-                    catch { /* keep scanning */ }
-                    start = -1;
-                }
-            }
-        }
-        if (objects.length > 0)
-            return objects[objects.length - 1];
-    }
-    return null;
-}
-/**
- * Search for a single JSON object literal inside `text` using a balanced-bracket
- * scan. Returns the parsed object, or null if no valid object is found.
- */
-function extractJsonObject(text) {
-    let depth = 0;
-    let start = -1;
-    for (let i = 0; i < text.length; i++) {
-        const ch = text[i];
-        if (ch === '{') {
-            if (start === -1)
-                start = i;
-            depth++;
-        }
-        else if (ch === '}') {
-            depth--;
-            if (depth === 0 && start !== -1) {
-                try {
-                    return JSON.parse(text.slice(start, i + 1));
-                }
-                catch { /* keep scanning */ }
-                start = -1;
-            }
-        }
-    }
-    return null;
-}
-/**
- * Navigate the three possible envelope shapes to find the payload text that
- * contains the DiagnosticianOutputV1 JSON string.
- *
- * Returns the parsed JSON object (not a string) if extraction succeeds,
- * or null if the envelope structure doesn't match any known shape.
- */
-function extractDiagnosisFromEnvelope(parsed) {
-    if (typeof parsed !== 'object' || parsed === null) {
-        return null;
-    }
-    // Case 2: local envelope — { payloads: [{ text: "<json>" }] }
-    const asLocal = parsed;
-    if (Array.isArray(asLocal.payloads) && asLocal.payloads.length > 0) {
-        const [first] = asLocal.payloads;
-        if (first && typeof first.text === 'string') {
-            const inner = first.text.trim();
-            try {
-                return JSON.parse(inner);
-            }
-            catch { /* fall through — try prose extraction */ }
-            const extracted = extractJsonObject(inner);
-            if (extracted !== null)
-                return extracted;
-        }
-    }
-    // Case 3: gateway envelope — { result: { payloads: [{ text: "<json>" }] } }
-    const asGateway = parsed;
-    if (asGateway.result &&
-        typeof asGateway.result === 'object' &&
-        Array.isArray(asGateway.result.payloads) &&
-        asGateway.result.payloads.length > 0) {
-        const [first] = asGateway.result.payloads;
-        if (first && typeof first.text === 'string') {
-            const inner = first.text.trim();
-            try {
-                return JSON.parse(inner);
-            }
-            catch { /* fall through */ }
-            const extracted = extractJsonObject(inner);
-            if (extracted !== null)
-                return extracted;
-        }
-    }
-    // No matching envelope shape
-    return null;
-}
-/**
- * Extract the inner result object from an OpenClaw agent response envelope.
- *
- * OpenClaw `--json --local` wraps the agent's response text inside an envelope:
- *   Case A — local envelope:  { payloads: [{ text: "<json or prose>" }] }
- *   Case B — gateway envelope: { result: { payloads: [{ text: "<json or prose>" }] } }
- *   Case C — bare object:     { ok: true }   (no envelope, direct response)
- *
- * The inner text may be bare JSON (`{"ok":true}`) or wrapped in a small amount
- * of prose that surrounds the JSON. We balance-bracket extract to find the JSON
- * object within the text, then return the parsed result.
- *
- * Returns the parsed inner object on success, or null if extraction fails.
- */
-function extractProbeResult(parsed) {
-    // Case A: local envelope — { payloads: [{ text: "..." }] }
-    const asLocal = parsed;
-    if (Array.isArray(asLocal.payloads) && asLocal.payloads.length > 0) {
-        const [first] = asLocal.payloads;
-        if (first && typeof first.text === 'string') {
-            const inner = first.text.trim();
-            try {
-                return JSON.parse(inner);
-            }
-            catch { /* fall through — try prose extraction */ }
-            const extracted = extractJsonObject(inner);
-            if (extracted !== null)
-                return extracted;
-        }
-    }
-    // Case B: gateway envelope — { result: { payloads: [{ text: "..." }] } }
-    const asGateway = parsed;
-    if (asGateway.result &&
-        typeof asGateway.result === 'object' &&
-        Array.isArray(asGateway.result.payloads) &&
-        asGateway.result.payloads.length > 0) {
-        const [first] = asGateway.result.payloads;
-        if (first && typeof first.text === 'string') {
-            const inner = first.text.trim();
-            try {
-                return JSON.parse(inner);
-            }
-            catch { /* fall through */ }
-            const extracted = extractJsonObject(inner);
-            if (extracted !== null)
-                return extracted;
-        }
-    }
-    // Case C: bare object — already the result
-    if (typeof parsed === 'object' && parsed !== null) {
-        return parsed;
-    }
-    return null;
-}
-export class OpenClawCliRuntimeAdapter {
-    runStateMap = new Map();
-    runtimeMode;
-    workspaceDir;
-    agentId;
-    eventEmitter;
-    cliProcessRunner;
-    constructor(options) {
-        this.runtimeMode = options.runtimeMode;
-        this.workspaceDir = options.workspaceDir;
-        this.agentId = options.agentId ?? 'main';
-        this.eventEmitter = options.eventEmitter ?? storeEmitter;
-        this.cliProcessRunner = options.cliProcessRunner ?? runCliProcess;
-    }
-    // OCRA-01: kind() returns RuntimeKind literal 'openclaw-cli'
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    kind() {
-        return 'openclaw-cli';
-    }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    async getCapabilities() {
-        return {
-            supportsStructuredJsonOutput: true,
-            supportsToolUse: false,
-            supportsWorkingDirectory: false,
-            supportsModelSelection: false,
-            supportsLongRunningSessions: false,
-            supportsCancellation: true,
-            supportsArtifactWriteBack: false,
-            supportsConcurrentRuns: false,
-            supportsStreaming: false,
-        };
-    }
-    /**
-     * Probe runtime health by running a minimal openclaw command.
-     *
-     * Verifies:
-     *  1. openclaw binary is executable (run `openclaw --version`)
-     *  2. The configured agent is available (run `openclaw agents list --json`)
-     *  3. The agent can actually respond (one-shot minimal probe with --agent)
-     *
-     * Returns healthy=false with appropriate error category when checks fail.
-     * Per DPB-09: No silent fallback — failures are reported accurately.
-     * Per P1 hard gate: Binary-only check is insufficient; must verify real invocation.
-     */
-    async healthCheck() {
-        const warnings = [];
-        let healthy = true;
-        let degraded = false;
-        // Probe 1: verify openclaw binary is executable
-        try {
-            const versionResult = await this.cliProcessRunner({
-                command: 'openclaw',
-                args: ['--version'],
-                cwd: this.workspaceDir,
-                timeoutMs: 10_000,
-            });
-            if (versionResult.spawnError === 'ENOENT') {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: ['openclaw binary not found'],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (versionResult.spawnError === 'EACCES' || versionResult.spawnError === 'EMFILE') {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: [`openclaw binary not executable: ${versionResult.spawnError}`],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (versionResult.timedOut) {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: ['openclaw --version timed out'],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (versionResult.exitCode !== null && versionResult.exitCode !== 0) {
-                degraded = true;
-                warnings.push(`openclaw --version exited with code ${versionResult.exitCode}`);
-            }
-        }
-        catch (err) {
-            return {
-                healthy: false,
-                degraded: false,
-                warnings: [err instanceof Error ? err.message : String(err)],
-                lastCheckedAt: new Date().toISOString(),
-            };
-        }
-        // Probe 2: verify the configured agent is available via agents list
-        // P1 fix: Must verify agent exists, not just the binary
-        // Using `openclaw agents list --json` to check if agentId is registered
-        try {
-            const listArgs = ['agents', 'list', '--json'];
-            if (this.runtimeMode === 'local') {
-                listArgs.push('--local');
-            }
-            const listResult = await this.cliProcessRunner({
-                command: 'openclaw',
-                args: listArgs,
-                cwd: this.workspaceDir,
-                timeoutMs: 15_000,
-            });
-            if (listResult.spawnError === 'ENOENT') {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: ['openclaw binary not found'],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (listResult.spawnError === 'EACCES' || listResult.spawnError === 'EMFILE') {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: [`openclaw binary not executable: ${listResult.spawnError}`],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (listResult.timedOut) {
-                degraded = true;
-                warnings.push(`openclaw agents list timed out`);
-            }
-            else if (listResult.exitCode !== null && listResult.exitCode !== 0) {
-                // agents list failed — degraded state
-                degraded = true;
-                warnings.push(`openclaw agents list exited with code ${listResult.exitCode}`);
-            }
-            else {
-                // Parse agent list and check if target agent exists
-                // The output may contain config warnings/ANSI codes before the JSON array
-                try {
-                    const jsonStart = listResult.stdout.indexOf('[');
-                    if (jsonStart === -1)
-                        throw new Error('No JSON array found');
-                    const jsonStr = listResult.stdout.slice(jsonStart);
-                    const parsed = JSON.parse(jsonStr);
-                    // agents list returns an array of agent objects (each with an `id` field)
-                    const agentIds = parsed.map((a) => typeof a === 'string' ? a : a.id);
-                    if (!agentIds.includes(this.agentId)) {
-                        healthy = false;
-                        warnings.push(`agent '${this.agentId}' not found in agents list`);
-                    }
-                }
-                catch {
-                    // JSON parse failed — cannot verify agent, treat as degraded
-                    degraded = true;
-                    warnings.push(`failed to parse agents list output`);
-                }
-            }
-        }
-        catch (err) {
-            // Any error in the agent probe is a hard failure
-            return {
-                healthy: false,
-                degraded: false,
-                warnings: [err instanceof Error ? err.message : String(err)],
-                lastCheckedAt: new Date().toISOString(),
-            };
-        }
-        // Probe 3: One-shot minimal agent invocation (P1 hard gate)
-        // Verifies the agent can actually respond, not just that it exists in the list.
-        // This catches plugin loading failures, permission issues, etc.
-        let probeMessageRef = undefined;
-        try {
-            // Unique session ID for probe to avoid lock conflicts with concurrent runs
-            const probeSessionId = `pd-runtime-probe-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            probeMessageRef = await writeMessageFile(JSON.stringify({ probe: 'pd-runtime-v2', instruction: 'reply with {"ok":true} only' }), this.workspaceDir);
-            const probeArgs = [
-                'agent',
-                '--agent', this.agentId,
-                '--message-file', probeMessageRef.filePath,
-                '--session-id', probeSessionId,
-                '--timeout', '240',
-                '--json',
-            ];
-            if (this.runtimeMode === 'local') {
-                probeArgs.push('--local');
-            }
-            const probeResult = await this.cliProcessRunner({
-                command: 'openclaw',
-                args: probeArgs,
-                cwd: this.workspaceDir,
-                timeoutMs: 240_000, // 240s — agent init + bootstrap + skill loading can take >60s on cold start
-            });
-            if (probeResult.spawnError === 'ENOENT') {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: ['openclaw binary not found'],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (probeResult.spawnError === 'EACCES' || probeResult.spawnError === 'EMFILE') {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: [`openclaw binary not executable: ${probeResult.spawnError}`],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (probeResult.timedOut) {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: ['openclaw agent probe timed out'],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            if (probeResult.exitCode !== null && probeResult.exitCode !== 0) {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: [
-                        `openclaw agent '${this.agentId}' probe failed with exit code ${probeResult.exitCode}`,
-                        ...(probeResult.stderr ? [`stderr: ${probeResult.stderr.substring(0, 2000)}`] : []),
-                    ],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            // exit code 0 — verify the output is parseable JSON
-            const rawParsed = extractPayloadFromCliOutput(probeResult.stdout, probeResult.stderr);
-            if (rawParsed === null) {
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: ['openclaw agent probe produced unparseable output'],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-            // Extract the inner result from the OpenClaw envelope and verify {ok: true}
-            const result = extractProbeResult(rawParsed);
-            if (typeof result !== 'object' ||
-                result === null ||
-                !Object.hasOwn(result, 'ok') ||
-                result.ok !== true) {
-                const excerpt = rawParsed && typeof rawParsed === 'object'
-                    ? JSON.stringify(rawParsed).substring(0, 2000)
-                    : String(rawParsed).substring(0, 2000);
-                return {
-                    healthy: false,
-                    degraded: false,
-                    warnings: [
-                        `openclaw agent '${this.agentId}' probe returned unexpected result: ${excerpt}`,
-                    ],
-                    lastCheckedAt: new Date().toISOString(),
-                };
-            }
-        }
-        catch (err) {
-            return {
-                healthy: false,
-                degraded: false,
-                warnings: [err instanceof Error ? err.message : String(err)],
-                lastCheckedAt: new Date().toISOString(),
-            };
-        }
-        finally {
-            await cleanupMessageFile(probeMessageRef);
-        }
-        return {
-            healthy,
-            degraded,
-            warnings,
-            lastCheckedAt: new Date().toISOString(),
-        };
-    }
-    /**
-     * Map CLI output to telemetry event type and error category.
-     */
-    static mapCliResultToTelemetry(cliOutput) {
-        // spawnError is set by runCliProcess on ENOENT/EACCES/EMFILE — use it
-        if (cliOutput.spawnError === 'ENOENT') {
-            return { telemetryEventType: 'runtime_invocation_failed', errorCategory: 'runtime_unavailable', stderrExcerpt: cliOutput.stderr };
-        }
-        if (cliOutput.spawnError === 'EACCES' || cliOutput.spawnError === 'EMFILE') {
-            return { telemetryEventType: 'runtime_invocation_failed', errorCategory: 'execution_failed', stderrExcerpt: cliOutput.stderr };
-        }
-        if (cliOutput.timedOut) {
-            return { telemetryEventType: 'runtime_invocation_failed', errorCategory: 'timeout', stderrExcerpt: cliOutput.stderr };
-        }
-        if (cliOutput.exitCode !== null && cliOutput.exitCode !== 0) {
-            return { telemetryEventType: 'runtime_invocation_failed', errorCategory: 'execution_failed', stderrExcerpt: cliOutput.stderr };
-        }
-        return { telemetryEventType: 'runtime_invocation_succeeded', errorCategory: undefined, stderrExcerpt: undefined };
-    }
-    // OCRA-02: startRun synchronously invokes openclaw agent with correct CLI args
-    async startRun(input) {
-        // PRI-966 G2 P2 contract (declared capability boundary): StartRunInput.
-        // maxTokens is a per-request model output budget. This adapter delegates
-        // to the OpenClaw host CLI process, which exposes NO per-request
-        // output-token control — honoring the field here is impossible, and
-        // silently ignoring it is forbidden (rc-9). Fail loud as input_invalid
-        // BEFORE any CLI process starts.
-        if (input.maxTokens !== undefined) {
-            throw new PDRuntimeError('input_invalid', `OpenClawCliRuntimeAdapter does not support StartRunInput.maxTokens (received ${String(input.maxTokens)}): the host CLI owns its own model calls and exposes no per-request output-token control.`, {
-                maxTokens: input.maxTokens,
-                nextAction: 'Use a PiAi/L2 runtime adapter for per-request output budgets, or omit maxTokens for this runtime.',
-            });
-        }
-        const runId = crypto.randomUUID();
-        const startedAt = new Date().toISOString();
-        // Initialize state — cliOutput null until CLI completes.
-        // Capture outputSchemaRef so fetchOutput can validate against the runner's
-        // expected schema (e.g. diag-rootcause-output-v1 for Stage A) instead of
-        // hardcoding DiagnosticianOutputV1Schema.
-        const state = { runId, startedAt, cliOutput: null, completed: false, outputSchemaRef: input.outputSchemaRef };
-        this.runStateMap.set(runId, state);
-        // Build CLI args per D-02.
-        // PRI-633: the run's base-layer systemPrompt (agent role + protocol) is
-        // folded back into the message file. The OpenClaw host keeps full
-        // ownership of its own agent system prompt (DPB-07), so PD continues to
-        // deliver its instructions through the message channel; only the
-        // placement changed (appended section after the payload JSON instead of
-        // an instruction field inside it). Absent systemPrompt → unchanged bytes.
-        const payloadJson = typeof input.inputPayload === 'string'
-            ? input.inputPayload
-            : JSON.stringify(input.inputPayload);
-        const jsonPayload = input.systemPrompt
-            ? payloadJson + '\n\n' + input.systemPrompt
-            : payloadJson;
-        const timeoutSeconds = Math.ceil((input.timeoutMs ?? 600000) / 1000);
-        const agentId = input.agentSpec?.agentId ?? 'main';
-        const messageRef = await writeMessageFile(jsonPayload, this.workspaceDir);
-        // DPB-09 (LOCKED): --local only passed when runtimeMode === 'local'
-        // HG-03 (HARD GATE): No silent fallback — must be explicit
-        // Unique session ID per run — avoids session lock conflicts and context pollution
-        // between concurrent or sequential PD diagnostician runs on the same agent.
-        const sessionId = `pd-runtime-${runId}`;
-        const args = [
-            'agent',
-            '--agent', agentId,
-            '--message-file', messageRef.filePath,
-            '--session-id', sessionId,
-            '--json',
-        ];
-        if (this.runtimeMode === 'local') {
-            args.push('--local');
-        }
-        args.push('--timeout', String(timeoutSeconds));
-        // DPB-08 (LOCKED): Pass workspaceDir as cwd for workspace boundary control
-        // HG-02 (HARD GATE): Two distinct boundaries — cwd controls PD workspace
-        // TELE-02: runtime_invocation_started — CLI process about to spawn
-        this.eventEmitter.emitTelemetry({
-            eventType: 'runtime_invocation_started',
-            traceId: input.taskRef?.taskId ?? runId,
-            timestamp: new Date().toISOString(),
-            sessionId: 'openclaw-cli-adapter',
-            agentId: 'openclaw-cli-adapter',
-            payload: {
-                runId,
-                runtimeKind: 'openclaw-cli',
-                runtimeMode: this.runtimeMode,
-                timeoutMs: input.timeoutMs,
-            },
-        });
-        const cliOutput = await (async () => {
-            try {
-                return await this.cliProcessRunner({
-                    command: 'openclaw',
-                    args,
-                    cwd: this.workspaceDir,
-                    timeoutMs: input.timeoutMs,
-                });
-            }
-            finally {
-                await cleanupMessageFile(messageRef);
-            }
-        })();
-        // Store result in memory
-        state.cliOutput = cliOutput;
-        state.completed = true;
-        // TELE-03: runtime_invocation_succeeded/failed — CLI process completed
-        const endedAt = new Date().toISOString();
-        const { telemetryEventType, errorCategory, stderrExcerpt } = OpenClawCliRuntimeAdapter.mapCliResultToTelemetry(cliOutput);
-        this.eventEmitter.emitTelemetry({
-            eventType: telemetryEventType,
-            traceId: input.taskRef?.taskId ?? runId,
-            timestamp: endedAt,
-            sessionId: 'openclaw-cli-adapter',
-            agentId: 'openclaw-cli-adapter',
-            payload: {
-                runId,
-                runtimeKind: 'openclaw-cli',
-                runtimeMode: this.runtimeMode,
-                exitCode: cliOutput.exitCode,
-                timedOut: cliOutput.timedOut,
-                ...(errorCategory ? { errorCategory } : {}),
-                ...(stderrExcerpt ? { stderrExcerpt } : {}),
-            },
-        });
-        return { runId, runtimeKind: 'openclaw-cli', startedAt };
-    }
-    async pollRun(runId) {
-        const state = this.runStateMap.get(runId);
-        if (!state) {
-            throw new PDRuntimeError('output_invalid', `Run ${runId} not found`);
-        }
-        if (!state.completed || !state.cliOutput) {
-            return { runId, status: 'running', startedAt: state.startedAt };
-        }
-        const { cliOutput } = state;
-        if (cliOutput.timedOut) {
-            return {
-                runId,
-                status: 'timed_out',
-                startedAt: state.startedAt,
-                endedAt: new Date().toISOString(),
-                reason: 'CLI timeout exceeded',
-            };
-        }
-        if (cliOutput.exitCode !== null && cliOutput.exitCode !== 0) {
-            const stderrExcerpt = cliOutput.stderr
-                ? cliOutput.stderr.substring(0, 2000)
-                : undefined;
-            return {
-                runId,
-                status: 'failed',
-                startedAt: state.startedAt,
-                endedAt: new Date().toISOString(),
-                reason: stderrExcerpt
-                    ? `CLI exited with code ${cliOutput.exitCode}. stderr: ${stderrExcerpt}`
-                    : `CLI exited with code ${cliOutput.exitCode}`,
-            };
-        }
-        return {
-            runId,
-            status: 'succeeded',
-            startedAt: state.startedAt,
-            endedAt: new Date().toISOString(),
-        };
-    }
-    // OCRA-03: fetchOutput parses CliOutput.stdout and returns DiagnosticianOutputV1
-    // OCRA-05: Malformed JSON repair + evidence persistence on output_invalid
-    async fetchOutput(runId) {
-        const state = this.runStateMap.get(runId);
-        if (!state || !state.completed || !state.cliOutput) {
-            throw new PDRuntimeError('output_invalid', `Run ${runId} not completed`);
-        }
-        const { cliOutput } = state;
-        // OCRA-04: Map ENOENT (binary not found) to runtime_unavailable
-        // spawnError is set explicitly by runCliProcess when spawn fails
-        if (cliOutput.spawnError === 'ENOENT') {
-            throw new PDRuntimeError('runtime_unavailable', 'openclaw binary not found');
-        }
-        // OCRA-04: Map timeout to timeout
-        if (cliOutput.timedOut) {
-            throw new PDRuntimeError('timeout', 'CLI timeout exceeded');
-        }
-        // OCRA-04: Map non-zero exit to execution_failed
-        if (cliOutput.exitCode !== null && cliOutput.exitCode !== 0) {
-            const stderrExcerpt = cliOutput.stderr
-                ? cliOutput.stderr.substring(0, 2000)
-                : undefined;
-            throw new PDRuntimeError('execution_failed', stderrExcerpt
-                ? `CLI exited with code ${cliOutput.exitCode}. stderr: ${stderrExcerpt}`
-                : `CLI exited with code ${cliOutput.exitCode}`);
-        }
-        // OCRA-03: Parse CliOutput — the stdout may be raw JSON, or wrapped in an OpenClaw envelope
-        // (local or gateway). First extract the JSON value, then navigate to the diagnosis JSON.
-        let parsed;
-        const rawParsed = extractPayloadFromCliOutput(cliOutput.stdout, cliOutput.stderr);
-        if (rawParsed !== null) {
-            // Try envelope extraction first (cases 2 and 3)
-            const fromEnvelope = extractDiagnosisFromEnvelope(rawParsed);
-            parsed = fromEnvelope ?? rawParsed;
-        }
-        else {
-            parsed = null;
-        }
-        // OCRA-05: When initial JSON parse fails, attempt bounded repair via extractJsonObject
-        // and repairMalformedJson on the raw stdout/stderr text before giving up.
-        if (parsed === null) {
-            // Repair step 1: scan raw text for a JSON object using balanced-bracket extraction
-            const repairSources = [cliOutput.stdout, cliOutput.stderr ?? ''];
-            for (const source of repairSources) {
-                if (!source)
-                    continue;
-                const repaired = extractJsonObject(source);
-                if (repaired !== null) {
-                    parsed = repaired;
-                    break;
-                }
-            }
-            // Repair step 2: attempt syntactic repair of malformed JSON (e.g., unescaped quotes)
-            if (parsed === null) {
-                for (const source of repairSources) {
-                    if (!source)
-                        continue;
-                    const repaired = repairMalformedJson(source);
-                    if (repaired !== null) {
-                        parsed = repaired;
-                        break;
-                    }
-                }
-            }
-            if (parsed === null) {
-                // OCRA-05: Evidence persistence on output_invalid — no silent fallback (ERR-002)
-                // ERR-055/056: redact tokens/paths from raw output before persisting preview
-                const rawText = cliOutput.stdout || cliOutput.stderr || '';
-                const redacted = redactTelemetryString(rawText.substring(0, 2000));
-                const boundedPreview = truncatePreview(typeof redacted === 'string' ? redacted : '', 500);
-                throw new PDRuntimeError('output_invalid', 'Failed to parse CLI output as JSON', {
-                    parseFailureReason: 'no_json_object_found',
-                    boundedRawOutputPreview: boundedPreview,
-                    nextAction: 'Check openclaw agent output format; ensure agent returns valid JSON',
-                });
-            }
-        }
-        // OCRA-03: Validate against the schema named by outputSchemaRef.
-        // The split diagnostician pipeline runs 3 stages with DIFFERENT output
-        // shapes: Stage A (diag_rootcause) → DiagRootCauseOutputV1, Stage B
-        // (diag_distiller) → DiagDistillerOutputV1, Stage C (diag_router) →
-        // DiagnosticianOutputV1. Each runner passes outputSchemaRef to name its
-        // expected shape. Previously this hardcoded DiagnosticianOutputV1Schema,
-        // which rejected every valid Stage A/B output → 0 candidates.
-        // Resolution rules (rc-3-fail-loud-missing):
-        //   - outputSchemaRef present + in registry → validate against that schema
-        //   - outputSchemaRef present + NOT in registry → fail loud (unknown ref)
-        //   - outputSchemaRef absent → fall back to DiagnosticianOutputV1Schema
-        //     (backward compat for legacy callers / monolithic diagnostician path)
-        let schema;
-        if (state.outputSchemaRef) {
-            const resolved = resolveOutputSchema(state.outputSchemaRef);
-            if (!resolved) {
-                throw new PDRuntimeError('output_invalid', `Unknown outputSchemaRef: ${state.outputSchemaRef}`, {
-                    parseFailureReason: 'unknown_output_schema_ref',
-                    outputSchemaRef: state.outputSchemaRef,
-                    nextAction: `Register the schema in OUTPUT_SCHEMA_REGISTRY or pass a known ref (e.g. 'diag-rootcause-output-v1')`,
-                });
-            }
-            schema = resolved;
-        }
-        else {
-            schema = DiagnosticianOutputV1Schema;
-        }
-        // OCRA-05: On schema mismatch, include evidence with bounded preview (ERR-014/016/017)
-        // ERR-055/056: redact sensitive fields from parsed payload before persisting preview
-        if (!Value.Check(schema, parsed)) {
-            const schemaErrors = [...Value.Errors(schema, parsed)]
-                .slice(0, 10)
-                .map(e => ({ path: e.path, message: e.message }));
-            const redacted = redactSensitiveFields(parsed);
-            const boundedPreview = redacted.ok
-                ? safeStringifyPreview(redacted.value, 500)
-                : safeStringifyPreview(parsed, 500);
-            throw new PDRuntimeError('output_invalid', `CLI output does not match ${state.outputSchemaRef ?? 'diagnostician-output-v1'} schema`, {
-                parseFailureReason: 'schema_validation_failed',
-                outputSchemaRef: state.outputSchemaRef ?? 'diagnostician-output-v1',
-                boundedRawOutputPreview: boundedPreview,
-                schemaErrors,
-                nextAction: 'Review schema errors; check LLM output format and required fields',
-            });
-        }
-        return { runId, payload: parsed };
-    }
-    async cancelRun(runId) {
-        // For one-shot run: if still in-flight, mark as cancelled
-        const state = this.runStateMap.get(runId);
-        if (state && !state.completed) {
-            state.completed = true;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    async fetchArtifacts(_runId) {
-        // No artifact refs produced by openclaw-cli adapter directly
-        return [];
-    }
-}
-//# sourceMappingURL=openclaw-cli-runtime-adapter.js.map