crewx-agent-cli 0.2.5 → 0.2.7

package/dist/adapters.js

@@ -1,31 +1,55 @@
-import { spawn } from 'node:child_process';
-import { once } from 'node:events';
-import { chmod, mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { AgentAdapterSchema } from 'crewx-agent-protocol';
-import { CLI_VERSION, DEFAULT_RUN_TIMEOUT_MS, MAX_AGENT_OUTPUT_BYTES } from './constants.js';
-import { CliError } from './errors.js';
+import { spawn, } from "node:child_process";
+import { createHash } from "node:crypto";
+import { once } from "node:events";
+import { chmod, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ACPX_HARNESSES, AgentAdapterSchema, } from "crewx-agent-protocol";
+import { CLI_VERSION, DEFAULT_RUN_TIMEOUT_MS, MAX_AGENT_OUTPUT_BYTES, } from "./constants.js";
+import { CliError } from "./errors.js";
 const DEFAULT_RUNTIME_PROBE_TIMEOUT_MS = 5_000;
 const OPENCLAW_RUNTIME_PROBE_TIMEOUT_MS = 30_000;
 const OPENCLAW_SETUP_TIMEOUT_MS = 60_000;
+const ACPX_PROBE_COMMANDS = {
+    gemini: "gemini",
+    cursor: "cursor-agent",
+    copilot: "copilot",
+    droid: "droid",
+    "fast-agent": "uvx",
+    "grok-build": "grok",
+    iflow: "iflow",
+    kilocode: "npx",
+    kimi: "kimi",
+    kiro: "kiro-cli-chat",
+    mux: "npx",
+    opencode: "npx",
+    pool: "pool",
+    qoder: "qodercli",
+    qwen: "qwen",
+    trae: "traecli",
+    zeroclaw: "zeroclaw",
+};
 export function adapterProbePlan(adapter) {
-    return adapter === 'hermes'
-        ? { args: ['acp', '--check'], timeoutMs: DEFAULT_RUNTIME_PROBE_TIMEOUT_MS }
-        : adapter === 'openclaw'
-            ? { args: ['agents', 'list', '--json'], timeoutMs: OPENCLAW_RUNTIME_PROBE_TIMEOUT_MS }
-            : { args: ['--version'], timeoutMs: DEFAULT_RUNTIME_PROBE_TIMEOUT_MS };
+    return adapter === "hermes"
+        ? { args: ["acp", "--check"], timeoutMs: DEFAULT_RUNTIME_PROBE_TIMEOUT_MS }
+        : adapter === "openclaw"
+            ? {
+                args: ["agents", "list", "--json"],
+                timeoutMs: OPENCLAW_RUNTIME_PROBE_TIMEOUT_MS,
+            }
+            : { args: ["--version"], timeoutMs: DEFAULT_RUNTIME_PROBE_TIMEOUT_MS };
 }
 const CLAUDE_STANDARD_CREWX_TOOLS = [
-    'WebSearch',
-    'WebFetch',
+    "WebSearch",
+    "WebFetch",
     'Bash(node "$CREWX_CLI_PATH" task *)',
     'Bash(node "$CREWX_CLI_PATH" doc *)',
     'Bash(node "$CREWX_CLI_PATH" memory *)',
     'Bash(node "$CREWX_CLI_PATH" integration *)',
 ];
 function terminateChild(child, signal) {
-    if (process.platform !== 'win32' && child.pid) {
+    if (process.platform !== "win32" && child.pid) {
         try {
             process.kill(-child.pid, signal);
             return;
@@ -45,7 +69,7 @@ function observeChild(child) {
     let closed = false;
     return {
         close: new Promise((resolve) => {
-            child.once('close', (exitCode, signal) => {
+            child.once("close", (exitCode, signal) => {
                 closed = true;
                 resolve([exitCode, signal]);
             });
@@ -61,7 +85,7 @@ function destroyChildPipes(child) {
 async function terminateAndWait(child, lifecycle, graceMs) {
     if (lifecycle.isClosed() || child.exitCode !== null)
         return;
-    terminateChild(child, 'SIGTERM');
+    terminateChild(child, "SIGTERM");
     let graceTimer;
     await Promise.race([
         lifecycle.close,
@@ -73,7 +97,7 @@ async function terminateAndWait(child, lifecycle, graceMs) {
         clearTimeout(graceTimer);
     if (lifecycle.isClosed() || child.exitCode !== null)
         return;
-    terminateChild(child, 'SIGKILL');
+    terminateChild(child, "SIGKILL");
     let killTimer;
     await Promise.race([
         lifecycle.close,
@@ -89,7 +113,7 @@ async function terminateAndWait(child, lifecycle, graceMs) {
 export function parseAdapter(value) {
     const result = AgentAdapterSchema.safeParse(value);
     if (!result.success) {
-        throw new CliError(`Unknown adapter "${value}". Choose codex, claude, pi, hermes, or openclaw.`);
+        throw new CliError(`Unknown adapter "${value}". Run \`crewx doctor --json\` to list supported harnesses.`);
     }
     return result.data;
 }
@@ -97,105 +121,107 @@ export function parseAdapter(value) {
 export function buildAdapterInvocation(adapter, profile = {}, codingCommand) {
     if (codingCommand?.trim())
         return buildCustomInvocation(codingCommand);
-    const modelArgs = profile.model ? ['--model', profile.model] : [];
-    const restricted = profile.chatOnly === true || profile.permissionPreset === 'read_only';
-    const codexPermissionArgs = profile.permissionPreset === 'full_access'
-        ? ['--dangerously-bypass-approvals-and-sandbox']
+    const modelArgs = profile.model ? ["--model", profile.model] : [];
+    const restricted = profile.chatOnly === true || profile.permissionPreset === "read_only";
+    const codexPermissionArgs = profile.permissionPreset === "full_access"
+        ? ["--dangerously-bypass-approvals-and-sandbox"]
         : [
-            '-c',
+            "-c",
             'approval_policy="never"',
-            '--sandbox',
-            restricted ? 'read-only' : 'workspace-write',
+            "--sandbox",
+            restricted ? "read-only" : "workspace-write",
         ];
     switch (adapter) {
-        case 'codex':
+        case "codex":
             return {
-                command: 'codex',
+                command: "codex",
                 args: [
-                    '--search',
-                    'exec',
-                    '--json',
-                    '--color',
-                    'never',
-                    '--skip-git-repo-check',
-                    '--ephemeral',
+                    "--search",
+                    "exec",
+                    "--json",
+                    "--color",
+                    "never",
+                    "--skip-git-repo-check",
+                    "--ephemeral",
                     ...modelArgs,
                     ...codexPermissionArgs,
-                    '-',
+                    "-",
                 ],
-                output: 'jsonl',
-                prompt: { type: 'stdin' },
+                output: "jsonl",
+                prompt: { type: "stdin" },
             };
-        case 'claude':
+        case "claude":
             return {
-                command: 'claude',
+                command: "claude",
                 args: [
-                    '--print',
-                    '--output-format',
-                    'stream-json',
-                    '--verbose',
-                    '--no-session-persistence',
+                    "--print",
+                    "--output-format",
+                    "stream-json",
+                    "--verbose",
+                    "--no-session-persistence",
                     ...modelArgs,
-                    ...(!restricted && profile.permissionPreset !== 'full_access'
-                        ? ['--allowedTools', ...CLAUDE_STANDARD_CREWX_TOOLS]
+                    ...(!restricted && profile.permissionPreset !== "full_access"
+                        ? ["--allowedTools", ...CLAUDE_STANDARD_CREWX_TOOLS]
                         : []),
                     ...(restricted
-                        ? ['--permission-mode', 'plan']
-                        : profile.permissionPreset === 'full_access'
-                            ? ['--dangerously-skip-permissions']
-                            : ['--permission-mode', 'acceptEdits']),
+                        ? ["--permission-mode", "plan"]
+                        : profile.permissionPreset === "full_access"
+                            ? ["--dangerously-skip-permissions"]
+                            : ["--permission-mode", "acceptEdits"]),
                 ],
-                output: 'jsonl',
-                prompt: { type: 'stdin' },
+                output: "jsonl",
+                prompt: { type: "stdin" },
             };
-        case 'pi':
+        case "pi":
             return {
-                command: 'pi',
+                command: "pi",
                 args: [
-                    '--mode',
-                    'json',
-                    '--print',
-                    '--no-approve',
-                    '--no-session',
+                    "--mode",
+                    "json",
+                    "--print",
+                    "--no-approve",
+                    "--no-session",
                     ...modelArgs,
-                    ...(restricted ? ['--tools', 'read,grep,find,ls'] : []),
+                    ...(restricted ? ["--tools", "read,grep,find,ls"] : []),
                 ],
-                output: 'jsonl',
-                prompt: { type: 'stdin' },
+                output: "jsonl",
+                prompt: { type: "stdin" },
             };
-        case 'hermes':
+        case "hermes":
             return {
-                command: 'hermes',
-                args: ['acp'],
-                output: 'jsonl',
-                prompt: { type: 'stdin' },
+                command: "hermes",
+                args: ["acp"],
+                output: "jsonl",
+                prompt: { type: "stdin" },
             };
-        case 'openclaw':
+        case "openclaw":
             if (!profile.runtimeAgentId?.trim()) {
-                throw new CliError('OpenClaw requires an explicit configured agent ID.');
+                throw new CliError("OpenClaw requires an explicit configured agent ID.");
             }
             return {
-                command: 'openclaw',
+                command: "openclaw",
                 args: [
-                    'agent',
-                    '--local',
-                    '--agent',
+                    "agent",
+                    "--local",
+                    "--agent",
                     profile.runtimeAgentId.trim(),
-                    '--session-key',
-                    profile.sessionKey ?? 'main',
-                    '--json',
-                    '--timeout',
-                    '0',
+                    "--session-key",
+                    profile.sessionKey ?? "main",
+                    "--json",
+                    "--timeout",
+                    "0",
                     ...modelArgs,
                 ],
-                output: 'json',
-                prompt: { type: 'file', flag: '--message-file' },
+                output: "json",
+                prompt: { type: "file", flag: "--message-file" },
             };
+        default:
+            throw new CliError(`${adapter} is available through the ACP runtime, not the native command adapter.`);
     }
 }
 export function parseCodingCommand(value) {
     const tokens = [];
-    let token = '';
+    let token = "";
     let quote;
     let escaped = false;
     let started = false;
@@ -206,25 +232,25 @@ export function parseCodingCommand(value) {
             started = true;
             continue;
         }
-        if (character === '\\' && quote !== 'single') {
+        if (character === "\\" && quote !== "single") {
             escaped = true;
             started = true;
             continue;
         }
-        if (character === "'" && quote !== 'double') {
-            quote = quote === 'single' ? undefined : 'single';
+        if (character === "'" && quote !== "double") {
+            quote = quote === "single" ? undefined : "single";
             started = true;
             continue;
         }
-        if (character === '"' && quote !== 'single') {
-            quote = quote === 'double' ? undefined : 'double';
+        if (character === '"' && quote !== "single") {
+            quote = quote === "double" ? undefined : "double";
             started = true;
             continue;
         }
         if (/\s/.test(character) && !quote) {
             if (started) {
                 tokens.push(token);
-                token = '';
+                token = "";
                 started = false;
             }
             continue;
@@ -233,63 +259,66 @@ export function parseCodingCommand(value) {
         started = true;
     }
     if (escaped || quote)
-        throw new CliError('The coding command contains an unfinished quote or escape.');
+        throw new CliError("The coding command contains an unfinished quote or escape.");
     if (started)
         tokens.push(token);
     if (tokens.length === 0 || !tokens[0])
-        throw new CliError('The coding command cannot be empty.');
+        throw new CliError("The coding command cannot be empty.");
     return tokens;
 }
 function buildCustomInvocation(value) {
     const tokens = parseCodingCommand(value);
     const command = tokens[0];
     const args = tokens.slice(1);
-    const promptIndexes = args.flatMap((argument, index) => (argument === '{prompt}' ? [index] : []));
+    const promptIndexes = args.flatMap((argument, index) => argument === "{prompt}" ? [index] : []);
     if (promptIndexes.length > 1)
-        throw new CliError('Use {prompt} at most once in the coding command.');
+        throw new CliError("Use {prompt} at most once in the coding command.");
     const index = promptIndexes[0] ?? args.length;
     if (promptIndexes.length === 1)
         args.splice(index, 1);
     return {
         command,
         args,
-        output: 'text',
-        prompt: { type: 'argument', index },
+        output: "text",
+        prompt: { type: "argument", index },
     };
 }
 function contentText(value) {
-    if (typeof value === 'string' && value.trim())
+    if (typeof value === "string" && value.trim())
         return value;
     if (!Array.isArray(value))
         return undefined;
     const parts = [];
     for (const part of value) {
-        if (typeof part === 'string') {
+        if (typeof part === "string") {
             parts.push(part);
         }
-        else if (typeof part === 'object' && part !== null) {
+        else if (typeof part === "object" && part !== null) {
             const record = part;
-            if ((record.type === 'text' || record.type === 'output_text') && typeof record.text === 'string') {
+            if ((record.type === "text" || record.type === "output_text") &&
+                typeof record.text === "string") {
                 parts.push(record.text);
             }
         }
     }
-    return parts.length > 0 ? parts.join('') : undefined;
+    return parts.length > 0 ? parts.join("") : undefined;
 }
 function finalPiAssistantMessage(event) {
     // Pi's message_start/message_update/message_end events all carry the current,
     // cumulative assistant snapshot. Publishing those snapshots produces a new
     // CrewX message for every token. agent_end is Pi's single terminal event for
     // a run, and its messages array contains the completed agent turns.
-    if (event.type !== 'agent_end' || event.willRetry === true || !Array.isArray(event.messages)) {
+    if (event.type !== "agent_end" ||
+        event.willRetry === true ||
+        !Array.isArray(event.messages)) {
         return undefined;
     }
     for (let index = event.messages.length - 1; index >= 0; index -= 1) {
         const candidate = event.messages[index];
-        if (typeof candidate !== 'object' || candidate === null)
+        if (typeof candidate !== "object" || candidate === null)
             continue;
         const message = candidate;
-        if (message.role !== 'assistant')
+        if (message.role !== "assistant")
             continue;
         const text = contentText(message.content);
         if (text)
@@ -305,45 +334,50 @@ export function parseAdapterLine(adapter, line) {
     catch {
         return { raw: line };
     }
-    if (typeof raw !== 'object' || raw === null)
+    if (typeof raw !== "object" || raw === null)
         return { raw };
     const event = raw;
-    const eventType = typeof event.type === 'string' ? event.type : undefined;
+    const eventType = typeof event.type === "string" ? event.type : undefined;
     let message;
     let role;
-    if (adapter === 'codex') {
-        const item = typeof event.item === 'object' && event.item !== null ? event.item : undefined;
-        if (item?.type === 'agent_message') {
+    if (adapter === "codex") {
+        const item = typeof event.item === "object" && event.item !== null
+            ? event.item
+            : undefined;
+        if (item?.type === "agent_message") {
             message = contentText(item.text) ?? contentText(item.content);
-            role = 'assistant';
+            role = "assistant";
         }
-        else if (eventType === 'agent_message') {
+        else if (eventType === "agent_message") {
             message = contentText(event.message) ?? contentText(event.text);
-            role = 'assistant';
+            role = "assistant";
         }
     }
-    else if (adapter === 'claude') {
-        const messageObject = typeof event.message === 'object' && event.message !== null
+    else if (adapter === "claude") {
+        const messageObject = typeof event.message === "object" && event.message !== null
             ? event.message
             : undefined;
-        if (eventType === 'result' && event.is_error !== true) {
+        if (eventType === "result" && event.is_error !== true) {
             message = contentText(event.result);
-            role = 'assistant';
+            role = "assistant";
         }
-        else if (eventType === 'assistant' || messageObject?.role === 'assistant') {
+        else if (eventType === "assistant" ||
+            messageObject?.role === "assistant") {
             message = contentText(messageObject?.content ?? event.content);
-            role = 'assistant';
+            role = "assistant";
         }
-        else if (eventType === 'content_block_delta') {
-            const delta = typeof event.delta === 'object' && event.delta !== null ? event.delta : undefined;
+        else if (eventType === "content_block_delta") {
+            const delta = typeof event.delta === "object" && event.delta !== null
+                ? event.delta
+                : undefined;
             message = contentText(delta?.text);
-            role = 'assistant';
+            role = "assistant";
         }
     }
-    else if (adapter === 'pi') {
+    else if (adapter === "pi") {
         message = finalPiAssistantMessage(event);
         if (message) {
-            role = 'assistant';
+            role = "assistant";
         }
     }
     return {
@@ -354,7 +388,7 @@ export function parseAdapterLine(adapter, line) {
     };
 }
 function record(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
+    return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
         : undefined;
 }
@@ -364,7 +398,7 @@ function openClawError(code, message, cause) {
         ...(cause !== undefined ? { cause } : {}),
     });
 }
-function publicOpenClawDiagnostic(value) {
+export function publicOpenClawDiagnostic(value) {
     return value
         .replace(/(^|[\s"'`=:(])(?:\/(?!\/)[^\s"'`),;]+)+/g, "$1<local-path>")
         .replace(/(^|[\s"'`=:(])[A-Za-z]:\\[^\s"'`),;]+/g, "$1<local-path>");
@@ -374,34 +408,34 @@ async function resolvedPath(value, label) {
         return await realpath(value);
     }
     catch (error) {
-        throw openClawError('openclaw_workspace_unavailable', `${label} does not resolve to an accessible local directory.`, error);
+        throw openClawError("openclaw_workspace_unavailable", `${label} does not resolve to an accessible local directory.`, error);
     }
 }
 async function openClawJsonProbe(args, options, timeoutMs = OPENCLAW_RUNTIME_PROBE_TIMEOUT_MS) {
     const spawnProcess = options.spawnProcess ?? spawn;
     let child;
     try {
-        child = spawnProcess('openclaw', args, {
+        child = spawnProcess("openclaw", args, {
             cwd: options.cwd,
             env: runtimeEnvironment(options.environment),
             shell: false,
-            detached: process.platform !== 'win32',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"],
         });
     }
     catch (error) {
-        throw openClawError('openclaw_unavailable', 'Unable to start openclaw. Is it installed and on PATH?', error);
+        throw openClawError("openclaw_unavailable", "Unable to start openclaw. Is it installed and on PATH?", error);
     }
-    let stdout = '';
-    let stderr = '';
+    let stdout = "";
+    let stderr = "";
     let bytes = 0;
     let exceeded = false;
     let forceKill;
     const stopProbe = () => {
         if (child.exitCode !== null)
             return;
-        terminateChild(child, 'SIGTERM');
-        forceKill ??= setTimeout(() => terminateChild(child, 'SIGKILL'), 5_000);
+        terminateChild(child, "SIGTERM");
+        forceKill ??= setTimeout(() => terminateChild(child, "SIGKILL"), 5_000);
         forceKill.unref();
     };
     const consume = (stream, chunk) => {
@@ -413,14 +447,14 @@ async function openClawJsonProbe(args, options, timeoutMs = OPENCLAW_RUNTIME_PRO
             stopProbe();
             return;
         }
-        if (stream === 'stdout')
+        if (stream === "stdout")
             stdout += chunk.toString();
         else
             stderr += chunk.toString();
     };
-    child.stdout.on('data', (chunk) => consume('stdout', chunk));
-    child.stderr.on('data', (chunk) => consume('stderr', chunk));
-    child.stdin.on('error', () => undefined);
+    child.stdout.on("data", (chunk) => consume("stdout", chunk));
+    child.stderr.on("data", (chunk) => consume("stderr", chunk));
+    child.stdin.on("error", () => undefined);
     child.stdin.end();
     let timedOut = false;
     const timeout = setTimeout(() => {
@@ -430,25 +464,25 @@ async function openClawJsonProbe(args, options, timeoutMs = OPENCLAW_RUNTIME_PRO
     timeout.unref();
     try {
         const [code] = (await Promise.race([
-            once(child, 'close'),
-            once(child, 'error').then(([error]) => {
+            once(child, "close"),
+            once(child, "error").then(([error]) => {
                 throw error;
             }),
         ]));
         if (timedOut) {
-            throw openClawError('openclaw_probe_timeout', `OpenClaw preflight timed out while running ${[args[0], args[1]].filter(Boolean).join(' ')}.`);
+            throw openClawError("openclaw_probe_timeout", `OpenClaw preflight timed out while running ${[args[0], args[1]].filter(Boolean).join(" ")}.`);
         }
         if (exceeded) {
-            throw openClawError('openclaw_probe_output_too_large', 'OpenClaw preflight exceeded its 1048576 byte output limit.');
+            throw openClawError("openclaw_probe_output_too_large", "OpenClaw preflight exceeded its 1048576 byte output limit.");
         }
         if (code !== 0) {
-            throw openClawError('openclaw_probe_failed', `OpenClaw preflight failed: ${publicOpenClawDiagnostic(stderr.trim()) || `exit ${String(code)}`}`);
+            throw openClawError("openclaw_probe_failed", `OpenClaw preflight failed: ${publicOpenClawDiagnostic(stderr.trim()) || `exit ${String(code)}`}`);
         }
         try {
             return JSON.parse(stdout);
         }
         catch (error) {
-            throw openClawError('openclaw_probe_invalid_json', 'OpenClaw preflight returned invalid JSON.', error);
+            throw openClawError("openclaw_probe_invalid_json", "OpenClaw preflight returned invalid JSON.", error);
         }
     }
     finally {
@@ -462,117 +496,123 @@ async function openClawJsonProbe(args, options, timeoutMs = OPENCLAW_RUNTIME_PRO
 export async function verifyOpenClawRuntime(options) {
     const agentId = options.profile.runtimeAgentId?.trim();
     if (!agentId) {
-        throw openClawError('openclaw_agent_id_missing', 'OpenClaw requires an explicit configured agent ID.');
+        throw openClawError("openclaw_agent_id_missing", "OpenClaw requires an explicit configured agent ID.");
     }
-    const desiredWorkspace = await resolvedPath(options.cwd, 'CrewX assignment directory');
-    let agents = await openClawJsonProbe(['agents', 'list', '--json'], options);
+    const desiredWorkspace = await resolvedPath(options.cwd, "CrewX assignment directory");
+    let agents = await openClawJsonProbe(["agents", "list", "--json"], options);
     if (!Array.isArray(agents)) {
-        throw openClawError('openclaw_agent_list_invalid', 'OpenClaw returned an invalid agent list.');
+        throw openClawError("openclaw_agent_list_invalid", "OpenClaw returned an invalid agent list.");
     }
     let selected = agents.map(record).find((agent) => agent?.id === agentId);
-    if (!selected && agentId.startsWith('crewx-')) {
+    if (!selected && agentId.startsWith("crewx-")) {
         await openClawJsonProbe([
-            'agents',
-            'add',
+            "agents",
+            "add",
             agentId,
-            '--workspace',
+            "--workspace",
             desiredWorkspace,
-            '--non-interactive',
-            '--json',
+            "--non-interactive",
+            "--json",
         ], options, OPENCLAW_SETUP_TIMEOUT_MS);
-        agents = await openClawJsonProbe(['agents', 'list', '--json'], options);
+        agents = await openClawJsonProbe(["agents", "list", "--json"], options);
         if (!Array.isArray(agents)) {
-            throw openClawError('openclaw_agent_list_invalid', 'OpenClaw returned an invalid agent list after setup.');
+            throw openClawError("openclaw_agent_list_invalid", "OpenClaw returned an invalid agent list after setup.");
         }
         selected = agents.map(record).find((agent) => agent?.id === agentId);
         if (!selected) {
-            throw openClawError('openclaw_agent_setup_failed', `CrewX created OpenClaw agent "${agentId}", but OpenClaw did not return it.`);
+            throw openClawError("openclaw_agent_setup_failed", `CrewX created OpenClaw agent "${agentId}", but OpenClaw did not return it.`);
         }
     }
     if (!selected) {
-        throw openClawError('openclaw_agent_missing', `OpenClaw agent "${agentId}" is not configured. Run \`openclaw agents list --json\` to choose one.`);
+        throw openClawError("openclaw_agent_missing", `OpenClaw agent "${agentId}" is not configured. Run \`openclaw agents list --json\` to choose one.`);
     }
-    if (typeof selected.workspace !== 'string' || !selected.workspace.trim()) {
-        throw openClawError('openclaw_workspace_missing', `OpenClaw agent "${agentId}" does not report a workspace.`);
+    if (typeof selected.workspace !== "string" || !selected.workspace.trim()) {
+        throw openClawError("openclaw_workspace_missing", `OpenClaw agent "${agentId}" does not report a workspace.`);
     }
     const configuredWorkspace = await resolvedPath(selected.workspace, `OpenClaw agent "${agentId}" workspace`);
     if (configuredWorkspace !== desiredWorkspace) {
-        throw openClawError('openclaw_workspace_mismatch', `OpenClaw agent "${agentId}" is bound to a different local workspace than the CrewX-approved folder. OpenClaw has no per-run --cwd; create or select a dedicated OpenClaw agent for the approved folder, then retry.`);
+        throw openClawError("openclaw_workspace_mismatch", `OpenClaw agent "${agentId}" is bound to a different local workspace than the CrewX-approved folder. OpenClaw has no per-run --cwd; create or select a dedicated OpenClaw agent for the approved folder, then retry.`);
     }
-    const models = record(await openClawJsonProbe(['models', 'status', '--agent', agentId, '--json'], options, OPENCLAW_SETUP_TIMEOUT_MS));
-    if (!models || (typeof models.agentId === 'string' && models.agentId !== agentId)) {
-        throw openClawError('openclaw_model_status_invalid', `OpenClaw did not return model status for agent "${agentId}". Run \`openclaw models status --agent "${agentId}" --json\`.`);
+    const models = record(await openClawJsonProbe(["models", "status", "--agent", agentId, "--json"], options, OPENCLAW_SETUP_TIMEOUT_MS));
+    if (!models ||
+        (typeof models.agentId === "string" && models.agentId !== agentId)) {
+        throw openClawError("openclaw_model_status_invalid", `OpenClaw did not return model status for agent "${agentId}". Run \`openclaw models status --agent "${agentId}" --json\`.`);
     }
-    const resolvedModel = typeof models.resolvedDefault === 'string' && models.resolvedDefault.trim()
+    const resolvedModel = typeof models.resolvedDefault === "string" && models.resolvedDefault.trim()
         ? models.resolvedDefault.trim()
-        : typeof models.defaultModel === 'string' && models.defaultModel.trim()
+        : typeof models.defaultModel === "string" && models.defaultModel.trim()
             ? models.defaultModel.trim()
             : undefined;
     if (!resolvedModel) {
-        throw openClawError('openclaw_model_missing', `OpenClaw agent "${agentId}" has no default model. Configure one, then run \`openclaw models status --agent "${agentId}" --json\`.`);
+        throw openClawError("openclaw_model_missing", `OpenClaw agent "${agentId}" has no default model. Configure one, then run \`openclaw models status --agent "${agentId}" --json\`.`);
     }
     const allowedModels = Array.isArray(models.allowed)
-        ? models.allowed.filter((value) => typeof value === 'string')
+        ? models.allowed.filter((value) => typeof value === "string")
         : [];
     if (allowedModels.length > 0 && !allowedModels.includes(resolvedModel)) {
-        throw openClawError('openclaw_model_unavailable', `OpenClaw agent "${agentId}" resolves to model "${resolvedModel}", but that model is not allowed. Run \`openclaw models status --agent "${agentId}" --json\` and select an allowed model.`);
+        throw openClawError("openclaw_model_unavailable", `OpenClaw agent "${agentId}" resolves to model "${resolvedModel}", but that model is not allowed. Run \`openclaw models status --agent "${agentId}" --json\` and select an allowed model.`);
     }
     const auth = record(models.auth);
     const missingProviders = Array.isArray(auth?.missingProvidersInUse)
-        ? auth.missingProvidersInUse.filter((value) => typeof value === 'string')
+        ? auth.missingProvidersInUse.filter((value) => typeof value === "string")
         : [];
     if (missingProviders.length > 0) {
-        throw openClawError('openclaw_auth_missing', `OpenClaw agent "${agentId}" is missing authentication for ${missingProviders.join(', ')}. Run \`openclaw models auth --agent "${agentId}" --help\`, configure the provider, then verify with \`openclaw models status --agent "${agentId}" --json\`.`);
+        throw openClawError("openclaw_auth_missing", `OpenClaw agent "${agentId}" is missing authentication for ${missingProviders.join(", ")}. Run \`openclaw models auth --agent "${agentId}" --help\`, configure the provider, then verify with \`openclaw models status --agent "${agentId}" --json\`.`);
     }
     const authRoutes = Array.isArray(auth?.runtimeAuthRoutes)
         ? auth.runtimeAuthRoutes.map(record).filter((route) => route !== undefined)
         : [];
     if (authRoutes.length > 0 &&
-        !authRoutes.some((route) => route.status === 'usable')) {
-        throw openClawError('openclaw_auth_unusable', `OpenClaw agent "${agentId}" has no usable authentication route for "${resolvedModel}" (credentials may be expired or cooling down). Run \`openclaw models auth --agent "${agentId}" list --json\`, repair authentication, then retry.`);
+        !authRoutes.some((route) => route.status === "usable")) {
+        throw openClawError("openclaw_auth_unusable", `OpenClaw agent "${agentId}" has no usable authentication route for "${resolvedModel}" (credentials may be expired or cooling down). Run \`openclaw models auth --agent "${agentId}" list --json\`, repair authentication, then retry.`);
     }
-    const sessionLeaf = options.profile.sessionKey ?? 'main';
+    const sessionLeaf = options.profile.sessionKey ?? "main";
     const fullSessionKey = `agent:${agentId}:${sessionLeaf}`;
-    const explanation = record(await openClawJsonProbe(['sandbox', 'explain', '--session', fullSessionKey, '--json'], options));
+    const explanation = record(await openClawJsonProbe(["sandbox", "explain", "--session", fullSessionKey, "--json"], options));
     const sandbox = record(explanation?.sandbox);
-    if (explanation?.agentId !== agentId || explanation?.sessionKey !== fullSessionKey || !sandbox) {
-        throw openClawError('openclaw_sandbox_invalid', 'OpenClaw sandbox preflight did not describe the requested agent session.');
+    if (explanation?.agentId !== agentId ||
+        explanation?.sessionKey !== fullSessionKey ||
+        !sandbox) {
+        throw openClawError("openclaw_sandbox_invalid", "OpenClaw sandbox preflight did not describe the requested agent session.");
     }
-    const effectiveHostRoot = typeof sandbox.effectiveHostWorkspaceRoot === 'string'
-        ? await resolvedPath(sandbox.effectiveHostWorkspaceRoot, 'OpenClaw effective workspace')
+    const effectiveHostRoot = typeof sandbox.effectiveHostWorkspaceRoot === "string"
+        ? await resolvedPath(sandbox.effectiveHostWorkspaceRoot, "OpenClaw effective workspace")
         : undefined;
     if (effectiveHostRoot !== desiredWorkspace) {
-        throw openClawError('openclaw_sandbox_workspace_mismatch', 'OpenClaw sandbox policy does not expose the exact CrewX assignment directory.');
+        throw openClawError("openclaw_sandbox_workspace_mismatch", "OpenClaw sandbox policy does not expose the exact CrewX assignment directory.");
     }
     if (sandbox.sessionIsSandboxed === true) {
-        if (sandbox.backend !== 'docker' ||
-            sandbox.workspaceAccess !== 'rw' ||
-            typeof sandbox.runtimeWorkdir !== 'string') {
-            throw openClawError('openclaw_sandbox_read_only', 'OpenClaw must grant rw workspace access for CrewX coding assignments.');
+        if (sandbox.backend !== "docker" ||
+            sandbox.workspaceAccess !== "rw" ||
+            typeof sandbox.runtimeWorkdir !== "string") {
+            throw openClawError("openclaw_sandbox_read_only", "OpenClaw must grant rw workspace access for CrewX coding assignments.");
         }
-        const mounts = Array.isArray(sandbox.workspaceMounts) ? sandbox.workspaceMounts.map(record) : [];
+        const mounts = Array.isArray(sandbox.workspaceMounts)
+            ? sandbox.workspaceMounts.map(record)
+            : [];
         let writableWorkspaceMount = false;
         for (const mount of mounts) {
-            if (typeof mount?.hostRoot === 'string' &&
-                typeof mount.containerRoot === 'string' &&
+            if (typeof mount?.hostRoot === "string" &&
+                typeof mount.containerRoot === "string" &&
                 mount.containerRoot === sandbox.runtimeWorkdir &&
                 mount.writable === true &&
-                (await resolvedPath(mount.hostRoot, 'OpenClaw sandbox mount')) === desiredWorkspace) {
+                (await resolvedPath(mount.hostRoot, "OpenClaw sandbox mount")) ===
+                    desiredWorkspace) {
                 writableWorkspaceMount = true;
                 break;
             }
         }
         if (!writableWorkspaceMount) {
-            throw openClawError('openclaw_sandbox_mount_missing', 'OpenClaw sandbox policy does not mount the CrewX assignment directory read-write at its runtime workdir.');
+            throw openClawError("openclaw_sandbox_mount_missing", "OpenClaw sandbox policy does not mount the CrewX assignment directory read-write at its runtime workdir.");
         }
     }
     else {
-        if (typeof sandbox.runtimeWorkdir !== 'string') {
-            throw openClawError('openclaw_runtime_workdir_missing', 'OpenClaw did not report its direct runtime working directory.');
+        if (typeof sandbox.runtimeWorkdir !== "string") {
+            throw openClawError("openclaw_runtime_workdir_missing", "OpenClaw did not report its direct runtime working directory.");
         }
-        const runtimeWorkdir = await resolvedPath(sandbox.runtimeWorkdir, 'OpenClaw runtime working directory');
+        const runtimeWorkdir = await resolvedPath(sandbox.runtimeWorkdir, "OpenClaw runtime working directory");
         if (runtimeWorkdir !== desiredWorkspace) {
-            throw openClawError('openclaw_runtime_workdir_mismatch', 'OpenClaw direct runtime workdir does not match the CrewX assignment directory.');
+            throw openClawError("openclaw_runtime_workdir_mismatch", "OpenClaw direct runtime workdir does not match the CrewX assignment directory.");
         }
     }
 }
@@ -582,36 +622,36 @@ function openClawMessages(value) {
         return [];
     return payloads.flatMap((payload) => {
         const text = record(payload)?.text;
-        return typeof text === 'string' && text.trim() ? [text] : [];
+        return typeof text === "string" && text.trim() ? [text] : [];
     });
 }
 function createLineConsumer(callback) {
-    let pending = '';
+    let pending = "";
     return {
         write(chunk) {
             pending += chunk.toString();
             while (true) {
-                const newline = pending.indexOf('\n');
+                const newline = pending.indexOf("\n");
                 if (newline < 0)
                     break;
-                const line = pending.slice(0, newline).replace(/\r$/, '');
+                const line = pending.slice(0, newline).replace(/\r$/, "");
                 pending = pending.slice(newline + 1);
                 if (line.length > 0)
                     callback(line);
             }
         },
         end() {
-            const line = pending.replace(/\r$/, '');
+            const line = pending.replace(/\r$/, "");
             if (line.length > 0)
                 callback(line);
-            pending = '';
+            pending = "";
         },
     };
 }
 const ALLOWED_RUNTIME_CONTROL_VARIABLES = [
-    'CREWX_URL',
-    'CREWX_TOKEN',
-    'CREWX_CLI_PATH',
+    "CREWX_URL",
+    "CREWX_TOKEN",
+    "CREWX_CLI_PATH",
 ];
 /**
  * Coding runtimes inherit provider credentials and ordinary process settings,
@@ -622,7 +662,7 @@ const ALLOWED_RUNTIME_CONTROL_VARIABLES = [
 export function runtimeEnvironment(environment = {}, controlEnvironment = {}, inherited = process.env) {
     const result = {};
     for (const [key, value] of Object.entries({ ...inherited, ...environment })) {
-        if (key.toUpperCase().startsWith('CREWX_'))
+        if (key.toUpperCase().startsWith("CREWX_"))
             continue;
         if (value !== undefined)
             result[key] = value;
@@ -635,23 +675,31 @@ export function runtimeEnvironment(environment = {}, controlEnvironment = {}, in
     return result;
 }
 async function materializeInvocation(invocation, prompt) {
-    if (invocation.prompt.type === 'stdin') {
-        return { args: invocation.args, stdin: prompt, cleanup: async () => undefined };
+    if (invocation.prompt.type === "stdin") {
+        return {
+            args: invocation.args,
+            stdin: prompt,
+            cleanup: async () => undefined,
+        };
     }
-    if (invocation.prompt.type === 'argument') {
+    if (invocation.prompt.type === "argument") {
         const args = [...invocation.args];
         args.splice(invocation.prompt.index, 0, prompt);
-        return { args, stdin: '', cleanup: async () => undefined };
+        return { args, stdin: "", cleanup: async () => undefined };
     }
-    const directory = await mkdtemp(join(tmpdir(), 'crewx-prompt-'));
+    const directory = await mkdtemp(join(tmpdir(), "crewx-prompt-"));
     try {
         await chmod(directory, 0o700);
-        const path = join(directory, 'prompt.txt');
-        await writeFile(path, prompt, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        const path = join(directory, "prompt.txt");
+        await writeFile(path, prompt, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
         await chmod(path, 0o600);
         return {
             args: [...invocation.args, invocation.prompt.flag, path],
-            stdin: '',
+            stdin: "",
             cleanup: async () => rm(directory, { recursive: true, force: true }),
         };
     }
@@ -660,7 +708,7 @@ async function materializeInvocation(invocation, prompt) {
         throw error;
     }
 }
-function emitMessage(options, messages, message, role = 'assistant') {
+function emitMessage(options, messages, message, role = "assistant") {
     if (!message.trim())
         return;
     messages.push(message);
@@ -668,9 +716,9 @@ function emitMessage(options, messages, message, role = 'assistant') {
 }
 async function runSpawnAdapter(options) {
     if (!options.prompt.trim())
-        throw new CliError('Agent prompt cannot be empty.');
+        throw new CliError("Agent prompt cannot be empty.");
     const invocation = buildAdapterInvocation(options.adapter, options.profile, options.codingCommand);
-    if (options.adapter === 'openclaw' && !options.codingCommand) {
+    if (options.adapter === "openclaw" && !options.codingCommand) {
         await verifyOpenClawRuntime({
             cwd: options.cwd,
             profile: options.profile ?? {},
@@ -686,8 +734,8 @@ async function runSpawnAdapter(options) {
             cwd: options.cwd,
             env: runtimeEnvironment(options.environment, options.controlEnvironment),
             shell: false,
-            detached: process.platform !== 'win32',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"],
         });
     }
     catch (error) {
@@ -699,7 +747,9 @@ async function runSpawnAdapter(options) {
     const stderr = [];
     const messages = [];
     const finalMessageOnly = !options.codingCommand &&
-        (options.adapter === 'codex' || options.adapter === 'claude' || options.adapter === 'pi');
+        (options.adapter === "codex" ||
+            options.adapter === "claude" ||
+            options.adapter === "pi");
     let pendingFinalMessage;
     const maxOutputBytes = options.maxOutputBytes ?? MAX_AGENT_OUTPUT_BYTES;
     let outputBytes = 0;
@@ -710,7 +760,10 @@ async function runSpawnAdapter(options) {
         options.onStdout?.(line, parsed);
         if (parsed.message) {
             if (finalMessageOnly) {
-                pendingFinalMessage = { message: parsed.message, role: parsed.role ?? 'assistant' };
+                pendingFinalMessage = {
+                    message: parsed.message,
+                    role: parsed.role ?? "assistant",
+                };
             }
             else {
                 emitMessage(options, messages, parsed.message, parsed.role);
@@ -730,21 +783,21 @@ async function runSpawnAdapter(options) {
     });
     let timedOut = false;
     let terminating = false;
-    const terminationGraceMs = options.adapter === 'openclaw' ? 60_000 : 5_000;
+    const terminationGraceMs = options.adapter === "openclaw" ? 60_000 : 5_000;
     const abort = () => {
         if (lifecycle.isClosed() || child.exitCode !== null || terminating)
             return;
         terminating = true;
-        terminateChild(child, 'SIGTERM');
+        terminateChild(child, "SIGTERM");
         forceKill = setTimeout(() => {
             if (!lifecycle.isClosed())
-                terminateChild(child, 'SIGKILL');
+                terminateChild(child, "SIGKILL");
         }, terminationGraceMs);
         hardStop = setTimeout(() => {
             if (lifecycle.isClosed())
                 return;
             forcedClosed = true;
-            terminateChild(child, 'SIGKILL');
+            terminateChild(child, "SIGKILL");
             destroyChildPipes(child);
             rejectTermination?.(new CliError(`${invocation.command} did not close after forced termination.`));
         }, terminationGraceMs + 1_000);
@@ -760,27 +813,27 @@ async function runSpawnAdapter(options) {
         }
         consumer(chunk);
     };
-    child.stdout.on('data', (chunk) => consumeOutput(stdoutLines.write, chunk));
-    child.stderr.on('data', (chunk) => consumeOutput(stderrLines.write, chunk));
+    child.stdout.on("data", (chunk) => consumeOutput(stdoutLines.write, chunk));
+    child.stderr.on("data", (chunk) => consumeOutput(stderrLines.write, chunk));
     if (options.signal?.aborted)
         abort();
-    options.signal?.addEventListener('abort', abort, { once: true });
+    options.signal?.addEventListener("abort", abort, { once: true });
     const runTimeout = setTimeout(() => {
         timedOut = true;
         abort();
     }, options.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS);
     const spawnError = new Promise((_resolve, reject) => {
-        child.once('error', (error) => {
+        child.once("error", (error) => {
             reject(new CliError(`Unable to start ${invocation.command}. Is it installed and on PATH?`, 1, { cause: error }));
         });
     });
     const stdinError = new Promise((_resolve, reject) => {
-        child.stdin.once('error', (error) => {
+        child.stdin.once("error", (error) => {
             reject(new CliError(`${invocation.command} closed its input before receiving the prompt.`, 1, { cause: error }));
         });
     });
     try {
-        child.stdin.end(materialized.stdin, 'utf8');
+        child.stdin.end(materialized.stdin, "utf8");
         const [exitCode, signal] = (await Promise.race([
             lifecycle.close,
             spawnError,
@@ -797,9 +850,9 @@ async function runSpawnAdapter(options) {
         if (exitCode === 0 && !options.signal?.aborted && pendingFinalMessage) {
             emitMessage(options, messages, pendingFinalMessage.message, pendingFinalMessage.role);
         }
-        const completeOutput = stdout.join('\n').trim();
+        const completeOutput = stdout.join("\n").trim();
         if (exitCode === 0 && messages.length === 0 && completeOutput) {
-            if (invocation.output === 'json') {
+            if (invocation.output === "json") {
                 let parsed;
                 try {
                     parsed = JSON.parse(completeOutput);
@@ -810,20 +863,26 @@ async function runSpawnAdapter(options) {
                 for (const message of openClawMessages(parsed))
                     emitMessage(options, messages, message);
             }
-            else if (invocation.output === 'text') {
+            else if (invocation.output === "text") {
                 emitMessage(options, messages, completeOutput);
             }
         }
-        if (exitCode === 0 && !options.signal?.aborted && options.adapter === 'openclaw' && messages.length === 0) {
-            throw new CliError('OpenClaw completed without a visible assistant response.');
+        if (exitCode === 0 &&
+            !options.signal?.aborted &&
+            options.adapter === "openclaw" &&
+            messages.length === 0) {
+            throw new CliError("OpenClaw completed without a visible assistant response.");
         }
-        if (exitCode === 0 && !options.signal?.aborted && finalMessageOnly && messages.length === 0) {
+        if (exitCode === 0 &&
+            !options.signal?.aborted &&
+            finalMessageOnly &&
+            messages.length === 0) {
             throw new CliError(`${invocation.command} completed without a visible assistant response.`);
         }
         return { exitCode, signal, messages, stdout, stderr };
     }
     finally {
-        options.signal?.removeEventListener('abort', abort);
+        options.signal?.removeEventListener("abort", abort);
         clearTimeout(runTimeout);
         if (forceKill)
             clearTimeout(forceKill);
@@ -836,23 +895,24 @@ async function runSpawnAdapter(options) {
     }
 }
 async function runHermesAcp(options) {
-    const restricted = options.profile?.chatOnly === true || options.profile?.permissionPreset === 'read_only';
+    const restricted = options.profile?.chatOnly === true ||
+        options.profile?.permissionPreset === "read_only";
     if (restricted) {
-        throw new CliError('Hermes does not expose a trustworthy read-only ACP mode. Use a sandboxed custom command or choose standard/full access.');
+        throw new CliError("Hermes does not expose a trustworthy read-only ACP mode. Use a sandboxed custom command or choose standard/full access.");
     }
     const spawnProcess = options.spawnProcess ?? spawn;
     let child;
     try {
-        child = spawnProcess('hermes', ['acp'], {
+        child = spawnProcess("hermes", ["acp"], {
             cwd: options.cwd,
             env: runtimeEnvironment(options.environment, options.controlEnvironment),
             shell: false,
-            detached: process.platform !== 'win32',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"],
         });
     }
     catch (error) {
-        throw new CliError('Unable to start hermes. Is it installed and on PATH?', 1, { cause: error });
+        throw new CliError("Unable to start hermes. Is it installed and on PATH?", 1, { cause: error });
     }
     const lifecycle = observeChild(child);
     const stdout = [];
@@ -861,7 +921,7 @@ async function runHermesAcp(options) {
     const pending = new Map();
     let nextId = 1;
     let sessionId;
-    let finalText = '';
+    let finalText = "";
     let forceKill;
     let hardStop;
     let forcedClosed = false;
@@ -872,19 +932,19 @@ async function runHermesAcp(options) {
     let abortRuntime = () => undefined;
     let terminating = false;
     const write = (value) => {
-        child.stdin.write(`${JSON.stringify(value)}\n`, 'utf8');
+        child.stdin.write(`${JSON.stringify(value)}\n`, "utf8");
     };
     const request = (method, params) => {
         const id = nextId++;
         return new Promise((resolve, reject) => {
             pending.set(id, { resolve, reject });
-            write({ jsonrpc: '2.0', id, method, params });
+            write({ jsonrpc: "2.0", id, method, params });
         });
     };
     const resultOf = async (method, params) => {
         const response = await request(method, params);
         if (response.error)
-            throw new CliError(`Hermes ACP ${method} failed: ${response.error.message ?? 'unknown error'}`);
+            throw new CliError(`Hermes ACP ${method} failed: ${response.error.message ?? "unknown error"}`);
         return response.result;
     };
     const stdoutLines = createLineConsumer((line) => {
@@ -898,14 +958,17 @@ async function runHermesAcp(options) {
             return;
         }
         const message = record(value);
-        const method = typeof message?.method === 'string' ? message.method : undefined;
-        options.onStdout?.(line, { raw: value, ...(method ? { eventType: method } : {}) });
-        if (typeof message?.id === 'number' && !method) {
+        const method = typeof message?.method === "string" ? message.method : undefined;
+        options.onStdout?.(line, {
+            raw: value,
+            ...(method ? { eventType: method } : {}),
+        });
+        if (typeof message?.id === "number" && !method) {
             const waiter = pending.get(message.id);
             if (waiter) {
                 pending.delete(message.id);
                 const response = {};
-                if (Object.hasOwn(message, 'result'))
+                if (Object.hasOwn(message, "result"))
                     response.result = message.result;
                 const rpcError = record(message.error);
                 if (rpcError)
@@ -914,27 +977,30 @@ async function runHermesAcp(options) {
             }
             return;
         }
-        if (method === 'session/update') {
+        if (method === "session/update") {
             const update = record(record(message?.params)?.update);
             const content = record(update?.content);
-            if (update?.sessionUpdate === 'agent_message_chunk' && content?.type === 'text' && typeof content.text === 'string') {
+            if (update?.sessionUpdate === "agent_message_chunk" &&
+                content?.type === "text" &&
+                typeof content.text === "string") {
                 finalText += content.text;
             }
             return;
         }
-        if (method === 'session/request_permission' && (typeof message?.id === 'number' || typeof message?.id === 'string')) {
+        if (method === "session/request_permission" &&
+            (typeof message?.id === "number" || typeof message?.id === "string")) {
             const offered = record(message.params)?.options;
             const allowed = Array.isArray(offered)
-                ? ['allow_once', 'allow_session'].find((optionId) => offered.some((option) => record(option)?.optionId === optionId))
+                ? ["allow_once", "allow_session"].find((optionId) => offered.some((option) => record(option)?.optionId === optionId))
                 : undefined;
-            const fullAccess = options.profile?.permissionPreset === 'full_access';
+            const fullAccess = options.profile?.permissionPreset === "full_access";
             write({
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id: message.id,
                 result: {
                     outcome: fullAccess && allowed
-                        ? { outcome: 'selected', optionId: allowed }
-                        : { outcome: 'cancelled' },
+                        ? { outcome: "selected", optionId: allowed }
+                        : { outcome: "cancelled" },
                 },
             });
         }
@@ -954,80 +1020,94 @@ async function runHermesAcp(options) {
         }
         consumer(chunk);
     };
-    child.stdout.on('data', (chunk) => consumeOutput(stdoutLines.write, chunk));
-    child.stderr.on('data', (chunk) => consumeOutput(stderrLines.write, chunk));
+    child.stdout.on("data", (chunk) => consumeOutput(stdoutLines.write, chunk));
+    child.stderr.on("data", (chunk) => consumeOutput(stderrLines.write, chunk));
     const failPending = (error) => {
         for (const waiter of pending.values())
             waiter.reject(error);
         pending.clear();
     };
-    child.once('error', (error) => failPending(new CliError('Hermes ACP process failed.', 1, { cause: error })));
-    child.stdin.once('error', (error) => failPending(new CliError('Hermes closed its ACP input unexpectedly.', 1, { cause: error })));
-    child.once('close', () => failPending(new CliError('Hermes ACP process closed before the request completed.')));
+    child.once("error", (error) => failPending(new CliError("Hermes ACP process failed.", 1, { cause: error })));
+    child.stdin.once("error", (error) => failPending(new CliError("Hermes closed its ACP input unexpectedly.", 1, {
+        cause: error,
+    })));
+    child.once("close", () => failPending(new CliError("Hermes ACP process closed before the request completed.")));
     const abort = () => {
         if (sessionId)
-            write({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId } });
+            write({
+                jsonrpc: "2.0",
+                method: "session/cancel",
+                params: { sessionId },
+            });
         if (lifecycle.isClosed() || child.exitCode !== null || terminating)
             return;
         terminating = true;
-        terminateChild(child, 'SIGTERM');
+        terminateChild(child, "SIGTERM");
         forceKill = setTimeout(() => {
             if (!lifecycle.isClosed())
-                terminateChild(child, 'SIGKILL');
+                terminateChild(child, "SIGKILL");
         }, 5_000);
         forceKill.unref();
         hardStop = setTimeout(() => {
             if (lifecycle.isClosed())
                 return;
             forcedClosed = true;
-            terminateChild(child, 'SIGKILL');
+            terminateChild(child, "SIGKILL");
             destroyChildPipes(child);
-            failPending(new CliError('Hermes did not close after forced termination.'));
+            failPending(new CliError("Hermes did not close after forced termination."));
         }, 6_000);
     };
     abortRuntime = abort;
     if (options.signal?.aborted)
         abort();
-    options.signal?.addEventListener('abort', abort, { once: true });
+    options.signal?.addEventListener("abort", abort, { once: true });
     const runTimeout = setTimeout(() => {
         timedOut = true;
         abort();
     }, options.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS);
     try {
-        const initialized = record(await resultOf('initialize', {
+        const initialized = record(await resultOf("initialize", {
             protocolVersion: 1,
-            clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
-            clientInfo: { name: 'crewx', version: CLI_VERSION },
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false,
+            },
+            clientInfo: { name: "crewx", version: CLI_VERSION },
         }));
         if (initialized?.protocolVersion !== 1)
-            throw new CliError('Hermes returned an unsupported ACP protocol version.');
-        const created = record(await resultOf('session/new', { cwd: options.cwd, mcpServers: [] }));
-        if (typeof created?.sessionId !== 'string' || !created.sessionId) {
-            throw new CliError('Hermes did not return an ACP session id.');
+            throw new CliError("Hermes returned an unsupported ACP protocol version.");
+        const created = record(await resultOf("session/new", { cwd: options.cwd, mcpServers: [] }));
+        if (typeof created?.sessionId !== "string" || !created.sessionId) {
+            throw new CliError("Hermes did not return an ACP session id.");
         }
         sessionId = created.sessionId;
-        await resultOf('session/set_mode', {
+        await resultOf("session/set_mode", {
             sessionId,
-            modeId: options.profile?.permissionPreset === 'full_access' ? 'dont_ask' : 'accept_edits',
+            modeId: options.profile?.permissionPreset === "full_access"
+                ? "dont_ask"
+                : "accept_edits",
         });
         if (options.profile?.model) {
-            await resultOf('session/set_model', { sessionId, modelId: options.profile.model });
+            await resultOf("session/set_model", {
+                sessionId,
+                modelId: options.profile.model,
+            });
         }
-        await resultOf('session/prompt', {
+        await resultOf("session/prompt", {
             sessionId,
-            prompt: [{ type: 'text', text: options.prompt }],
+            prompt: [{ type: "text", text: options.prompt }],
         });
         if (timedOut)
-            throw new CliError('Hermes exceeded the CrewX run timeout.');
+            throw new CliError("Hermes exceeded the CrewX run timeout.");
         if (outputLimitExceeded) {
             throw new CliError(`hermes exceeded the ${String(maxOutputBytes)} byte CrewX output limit.`);
         }
         if (!finalText.trim())
-            throw new CliError('Hermes completed without a visible assistant response.');
+            throw new CliError("Hermes completed without a visible assistant response.");
         emitMessage(options, messages, finalText);
         child.stdin.end();
-        const terminateTimer = setTimeout(() => terminateChild(child, 'SIGTERM'), 2_000);
-        const killTimer = setTimeout(() => terminateChild(child, 'SIGKILL'), 7_000);
+        const terminateTimer = setTimeout(() => terminateChild(child, "SIGTERM"), 2_000);
+        const killTimer = setTimeout(() => terminateChild(child, "SIGKILL"), 7_000);
         let shutdownTimer;
         terminateTimer.unref();
         killTimer.unref();
@@ -1036,7 +1116,7 @@ async function runHermesAcp(options) {
             new Promise((resolve) => {
                 shutdownTimer = setTimeout(() => {
                     forcedClosed = true;
-                    terminateChild(child, 'SIGKILL');
+                    terminateChild(child, "SIGKILL");
                     destroyChildPipes(child);
                     resolve([child.exitCode, null]);
                 }, 8_000);
@@ -1057,7 +1137,7 @@ async function runHermesAcp(options) {
         };
     }
     finally {
-        options.signal?.removeEventListener('abort', abort);
+        options.signal?.removeEventListener("abort", abort);
         clearTimeout(runTimeout);
         if (forceKill)
             clearTimeout(forceKill);
@@ -1068,40 +1148,211 @@ async function runHermesAcp(options) {
         }
     }
 }
+export function usesAcpRuntime(adapter, profile = {}) {
+    if (!ACPX_HARNESSES.includes(adapter))
+        return false;
+    return (profile.transport === "acp" ||
+        !["codex", "claude", "pi", "openclaw"].includes(adapter));
+}
+function acpWorkerEntrypoint() {
+    return fileURLToPath(new URL("./acp-worker.js", import.meta.url));
+}
+async function runAcpxAdapter(options) {
+    const spawnProcess = options.spawnProcess ?? spawn;
+    let child;
+    try {
+        child = spawnProcess(process.execPath, [acpWorkerEntrypoint()], {
+            cwd: options.cwd,
+            env: runtimeEnvironment(options.environment, options.controlEnvironment),
+            shell: false,
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        throw new CliError(`Unable to start the ${options.adapter} ACP runtime.`, 1, { cause: error });
+    }
+    const lifecycle = observeChild(child);
+    const stdout = [];
+    const stderr = [];
+    const messages = [];
+    let finalText = "";
+    let resultEnvelope;
+    let workerError;
+    let outputBytes = 0;
+    let outputLimitExceeded = false;
+    let timedOut = false;
+    let terminating = false;
+    let forceKill;
+    const abort = () => {
+        if (lifecycle.isClosed() || child.exitCode !== null || terminating)
+            return;
+        terminating = true;
+        terminateChild(child, "SIGTERM");
+        forceKill = setTimeout(() => {
+            if (!lifecycle.isClosed())
+                terminateChild(child, "SIGKILL");
+        }, 5_000);
+        forceKill.unref();
+    };
+    const consume = (callback, chunk) => {
+        if (outputLimitExceeded)
+            return;
+        outputBytes += Buffer.byteLength(chunk);
+        if (outputBytes > (options.maxOutputBytes ?? MAX_AGENT_OUTPUT_BYTES)) {
+            outputLimitExceeded = true;
+            abort();
+            return;
+        }
+        callback(chunk);
+    };
+    const stdoutLines = createLineConsumer((line) => {
+        stdout.push(line);
+        let envelope;
+        try {
+            envelope = JSON.parse(line);
+        }
+        catch {
+            workerError = { message: "The ACP worker returned invalid JSON." };
+            return;
+        }
+        if (envelope.type === "event" && envelope.event) {
+            const eventType = typeof envelope.event.type === "string"
+                ? `acp:${envelope.event.type}`
+                : "acp:event";
+            options.onStdout?.(line, { raw: envelope.event, eventType });
+            if (envelope.event.type === "text_delta" &&
+                envelope.event.stream !== "thought" &&
+                typeof envelope.event.text === "string") {
+                finalText += envelope.event.text;
+            }
+            return;
+        }
+        if (envelope.type === "result")
+            resultEnvelope = envelope.result;
+        if (envelope.type === "error")
+            workerError = envelope.error;
+    });
+    const stderrLines = createLineConsumer((line) => {
+        stderr.push(line);
+        options.onStderr?.(line);
+    });
+    child.stdout.on("data", (chunk) => consume(stdoutLines.write, chunk));
+    child.stderr.on("data", (chunk) => consume(stderrLines.write, chunk));
+    if (options.signal?.aborted)
+        abort();
+    options.signal?.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(() => {
+        timedOut = true;
+        abort();
+    }, options.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS);
+    const request = {
+        harness: options.adapter,
+        prompt: options.prompt,
+        cwd: options.cwd,
+        sessionKey: options.profile?.sessionKey ??
+            `crewx-${createHash("sha256")
+                .update(JSON.stringify(["local", options.adapter, options.cwd]))
+                .digest("hex")
+                .slice(0, 48)}`,
+        timeoutMs: options.timeoutMs ?? DEFAULT_RUN_TIMEOUT_MS,
+        profile: {
+            ...(options.profile?.model ? { model: options.profile.model } : {}),
+            ...(options.profile?.permissionPreset
+                ? { permissionPreset: options.profile.permissionPreset }
+                : {}),
+            ...(options.profile?.chatOnly !== undefined
+                ? { chatOnly: options.profile.chatOnly }
+                : {}),
+        },
+    };
+    try {
+        child.stdin.end(JSON.stringify(request), "utf8");
+        const [exitCode, signal] = (await Promise.race([
+            lifecycle.close,
+            once(child, "error").then(([error]) => {
+                throw error;
+            }),
+        ]));
+        stdoutLines.end();
+        stderrLines.end();
+        if (timedOut)
+            throw new CliError(`${options.adapter} ACP exceeded the CrewX run timeout.`);
+        if (outputLimitExceeded) {
+            throw new CliError(`${options.adapter} ACP exceeded the CrewX output limit.`);
+        }
+        if (options.signal?.aborted)
+            return { exitCode, signal, messages, stdout, stderr };
+        const failure = workerError ?? resultEnvelope?.error;
+        if (failure?.message) {
+            throw new CliError(failure.message, 1, {
+                code: failure.code ?? "acp_runtime_failed",
+            });
+        }
+        if (resultEnvelope?.status !== "completed" || exitCode !== 0) {
+            throw new CliError(`${options.adapter} ACP runtime failed to complete.`, 1, {
+                code: "acp_runtime_failed",
+            });
+        }
+        if (!finalText.trim()) {
+            throw new CliError(`${options.adapter} ACP completed without a visible assistant response.`);
+        }
+        emitMessage(options, messages, finalText);
+        return { exitCode: 0, signal: null, messages, stdout, stderr };
+    }
+    finally {
+        options.signal?.removeEventListener("abort", abort);
+        clearTimeout(timeout);
+        if (forceKill)
+            clearTimeout(forceKill);
+        if (!lifecycle.isClosed() && child.exitCode === null) {
+            await terminateAndWait(child, lifecycle, 5_000);
+        }
+    }
+}
 export async function runAdapter(options) {
     if (!options.prompt.trim())
-        throw new CliError('Agent prompt cannot be empty.');
+        throw new CliError("Agent prompt cannot be empty.");
     if (options.codingCommand &&
-        (options.profile?.chatOnly === true || options.profile?.permissionPreset === 'read_only')) {
-        throw new CliError('A custom coding command cannot prove read-only or chat-only enforcement.');
+        (options.profile?.chatOnly === true ||
+            options.profile?.permissionPreset === "read_only")) {
+        throw new CliError("A custom coding command cannot prove read-only or chat-only enforcement.");
+    }
+    if (!options.codingCommand &&
+        usesAcpRuntime(options.adapter, options.profile)) {
+        return runAcpxAdapter(options);
     }
-    if (options.adapter === 'openclaw' &&
-        (options.profile?.chatOnly === true || options.profile?.permissionPreset === 'read_only')) {
-        throw new CliError('OpenClaw read-only and chat-only policy cannot be verified per run.');
+    if (options.adapter === "openclaw" &&
+        (options.profile?.chatOnly === true ||
+            options.profile?.permissionPreset === "read_only")) {
+        throw new CliError("OpenClaw read-only and chat-only policy cannot be verified per run.");
     }
-    if (options.adapter === 'hermes' && !options.codingCommand)
+    if (options.adapter === "hermes" && !options.codingCommand)
         return runHermesAcp(options);
     return runSpawnAdapter(options);
 }
 export async function probeAdapter(adapter, spawnProcess = spawn, timeoutMs) {
     const plan = adapterProbePlan(adapter);
     const effectiveTimeoutMs = timeoutMs ?? plan.timeoutMs;
-    const command = adapter;
+    const command = ACPX_PROBE_COMMANDS[adapter] ?? adapter;
     const probeArgs = plan.args;
     let child;
     try {
         child = spawnProcess(command, probeArgs, {
             env: runtimeEnvironment(),
             shell: false,
-            detached: process.platform !== 'win32',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"],
         });
     }
     catch (error) {
-        return { available: false, error: error instanceof Error ? error.message : String(error) };
+        return {
+            available: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
     const lifecycle = observeChild(child);
-    let output = '';
+    let output = "";
     let outputBytes = 0;
     let outputLimitExceeded = false;
     let forceKill;
@@ -1118,19 +1369,19 @@ export async function probeAdapter(adapter, spawnProcess = spawn, timeoutMs) {
         if (lifecycle.isClosed() || child.exitCode !== null || terminating)
             return;
         terminating = true;
-        terminateChild(child, 'SIGTERM');
+        terminateChild(child, "SIGTERM");
         forceKill = setTimeout(() => {
             if (!lifecycle.isClosed())
-                terminateChild(child, 'SIGKILL');
+                terminateChild(child, "SIGKILL");
         }, terminationGraceMs);
         hardStop = setTimeout(() => {
             if (lifecycle.isClosed())
                 return;
             forcedClosed = true;
-            terminateChild(child, 'SIGKILL');
+            terminateChild(child, "SIGKILL");
             destroyChildPipes(child);
             const message = outputLimitExceeded
-                ? 'probe output exceeded 1048576 bytes'
+                ? "probe output exceeded 1048576 bytes"
                 : `probe timed out after ${String(effectiveTimeoutMs)}ms`;
             rejectTermination?.(new CliError(message));
         }, terminationGraceMs + 100);
@@ -1146,13 +1397,13 @@ export async function probeAdapter(adapter, spawnProcess = spawn, timeoutMs) {
         }
         output += chunk.toString();
     };
-    child.stdout.on('data', (chunk) => {
+    child.stdout.on("data", (chunk) => {
         consume(chunk);
     });
-    child.stderr.on('data', (chunk) => {
+    child.stderr.on("data", (chunk) => {
         consume(chunk);
     });
-    child.stdin.on('error', () => undefined);
+    child.stdin.on("error", () => undefined);
     child.stdin.end();
     const timeout = setTimeout(() => {
         timedOut = true;
@@ -1162,23 +1413,32 @@ export async function probeAdapter(adapter, spawnProcess = spawn, timeoutMs) {
         const [code] = (await Promise.race([
             lifecycle.close,
             terminationFailure,
-            once(child, 'error').then(([error]) => {
+            once(child, "error").then(([error]) => {
                 throw error;
             }),
         ]));
         if (timedOut)
-            return { available: false, error: `probe timed out after ${String(effectiveTimeoutMs)}ms` };
+            return {
+                available: false,
+                error: `probe timed out after ${String(effectiveTimeoutMs)}ms`,
+            };
         if (outputLimitExceeded)
-            return { available: false, error: 'probe output exceeded 1048576 bytes' };
-        const version = adapter === 'hermes' || adapter === 'openclaw'
-            ? 'ready'
+            return { available: false, error: "probe output exceeded 1048576 bytes" };
+        const version = adapter === "hermes" || adapter === "openclaw"
+            ? "ready"
             : output.trim().split(/\r?\n/, 1)[0];
         return code === 0
             ? { available: true, ...(version ? { version } : {}) }
-            : { available: false, error: version || `exited with code ${String(code)}` };
+            : {
+                available: false,
+                error: version || `exited with code ${String(code)}`,
+            };
     }
     catch (error) {
-        return { available: false, error: error instanceof Error ? error.message : String(error) };
+        return {
+            available: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
     finally {
         clearTimeout(timeout);