@openclaw/acpx 2026.7.2-beta.7 → 2026.7.33

package/dist/{service-CBZSAymH.js → .setup/service-CE4bgxXH.mjs}

@@ -1,21 +1,546 @@
-import { n as createLazyAcpRuntimeProxy } from "./register.runtime-BbS2JTTv.js";
-import "./config-schema-lrk5nlcV.js";
-import { _ as splitCommandParts, c as openAcpxProcessLeaseStateStore, d as ACPX_GATEWAY_INSTANCE_KEY, f as ACPX_GATEWAY_INSTANCE_NAMESPACE, g as quoteCommandPart, h as normalizeAcpxGatewayInstanceRecord, i as createAcpxProcessLeaseStore, n as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, t as OPENCLAW_ACPX_LEASE_ID_ARG } from "./process-lease-DSLDgiNl.js";
-import { registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "./runtime-api.js";
-import { a as resolveAcpxPluginRoot, c as CODEX_ACP_PACKAGE, i as resolveAcpxPluginConfig, l as LEGACY_CODEX_ACP_PACKAGE, o as toAcpMcpServers, r as reapStaleOpenClawOwnedAcpxOrphans, s as CODEX_ACP_BIN, t as cleanupOpenClawOwnedAcpxProcessTree, u as OPENCLAW_CODEX_CONFIG_ARG } from "./process-reaper-DFwbcdPa.js";
+import { n as createLazyAcpRuntimeProxy } from "./register.runtime-DjVBj71-.mjs";
+import { a as createAcpxProcessLeaseStore, d as ACPX_GATEWAY_INSTANCE_KEY, f as ACPX_GATEWAY_INSTANCE_NAMESPACE, h as normalizeAcpxGatewayInstanceRecord, l as openAcpxProcessLeaseStateStore, n as OPENCLAW_ACPX_LEASE_ID_ENV, r as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, t as OPENCLAW_ACPX_LEASE_ID_ARG } from "./process-lease-DiKkFj6F.mjs";
+import { registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "../runtime-api.js";
 import { createRequire } from "node:module";
-import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import fs from "node:fs";
-import fs$1 from "node:fs/promises";
+import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
+import fs from "node:fs/promises";
 import path from "node:path";
-import os from "node:os";
 import { randomUUID } from "node:crypto";
-import { inspect } from "node:util";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
+import { execFile } from "node:child_process";
+import { inspect, promisify } from "node:util";
+import fs$1 from "node:fs";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import os from "node:os";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
-import { parse, stringify } from "smol-toml";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region extensions/acpx/src/command-line.ts
+/**
+* Small shell-command helpers for ACPX-launched processes. Splitting supports
+* simple quoted command strings from config without invoking a shell parser.
+*/
+/** Quote one command argument for display or config serialization. */
+function quoteCommandPart(value) {
+	return JSON.stringify(value);
+}
+/** Split a command string into argv-like parts using simple quote/backslash rules. */
+function splitCommandParts(value) {
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let escaping = false;
+	for (const ch of value) {
+		if (escaping) {
+			current += ch;
+			escaping = false;
+			continue;
+		}
+		if (ch === "\\" && quote !== "'") {
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			if (ch === quote) quote = null;
+			else current += ch;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			if (current) {
+				parts.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += ch;
+	}
+	if (escaping) current += "\\";
+	if (current) parts.push(current);
+	return parts;
+}
+//#endregion
+//#region extensions/acpx/src/config-schema.ts
+/**
+* ACPX plugin configuration schema and public config types. Runtime setup uses
+* this file as the single source of truth for validation and defaulting.
+*/
+const ACPX_PERMISSION_MODES = [
+	"approve-all",
+	"approve-reads",
+	"deny-all"
+];
+const ACPX_NON_INTERACTIVE_POLICIES = ["deny", "fail"];
+const nonEmptyTrimmedString = (message) => z.string({ error: message }).trim().min(1, { error: message });
+const McpServerConfigSchema = z.object({
+	command: nonEmptyTrimmedString("command must be a non-empty string").describe("Command to run the MCP server"),
+	args: z.array(z.string({ error: "args must be an array of strings" }), { error: "args must be an array of strings" }).optional().describe("Arguments to pass to the command"),
+	env: z.record(z.string(), z.string({ error: "env values must be strings" }), { error: "env must be an object of strings" }).optional().describe("Environment variables for the MCP server")
+});
+/** Zod schema for validating raw ACPX plugin config from OpenClaw config. */
+const AcpxPluginConfigSchema = z.strictObject({
+	cwd: nonEmptyTrimmedString("cwd must be a non-empty string").optional(),
+	stateDir: nonEmptyTrimmedString("stateDir must be a non-empty string").optional(),
+	probeAgent: nonEmptyTrimmedString("probeAgent must be a non-empty string").optional(),
+	permissionMode: z.enum(ACPX_PERMISSION_MODES, { error: `permissionMode must be one of: ${ACPX_PERMISSION_MODES.join(", ")}` }).optional(),
+	nonInteractivePermissions: z.enum(ACPX_NON_INTERACTIVE_POLICIES, { error: `nonInteractivePermissions must be one of: ${ACPX_NON_INTERACTIVE_POLICIES.join(", ")}` }).optional(),
+	pluginToolsMcpBridge: z.boolean({ error: "pluginToolsMcpBridge must be a boolean" }).optional(),
+	openClawToolsMcpBridge: z.boolean({ error: "openClawToolsMcpBridge must be a boolean" }).optional(),
+	strictWindowsCmdWrapper: z.boolean({ error: "strictWindowsCmdWrapper must be a boolean" }).optional(),
+	timeoutSeconds: z.number({ error: "timeoutSeconds must be a number >= 0.001" }).min(.001, { error: "timeoutSeconds must be a number >= 0.001" }).default(120),
+	queueOwnerTtlSeconds: z.number({ error: "queueOwnerTtlSeconds must be a number >= 0" }).min(0, { error: "queueOwnerTtlSeconds must be a number >= 0" }).optional(),
+	mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
+	agents: z.record(z.string(), z.strictObject({
+		command: nonEmptyTrimmedString("agents.<id>.command must be a non-empty string"),
+		args: z.array(z.string({ error: "args must be an array of strings" })).optional()
+	})).optional()
+});
+//#endregion
+//#region extensions/acpx/src/config.ts
+/**
+* Resolves ACPX plugin config from raw user configuration. It locates the
+* plugin root, injects optional MCP bridge servers, and applies runtime defaults.
+*/
+const ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME = "openclaw-plugin-tools";
+const ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME = "openclaw-tools";
+const requireFromHere$2 = createRequire(import.meta.url);
+function isAcpxPluginRoot(dir) {
+	return fs$1.existsSync(path.join(dir, "openclaw.plugin.json")) && fs$1.existsSync(path.join(dir, "package.json"));
+}
+function resolveNearestAcpxPluginRoot(moduleUrl) {
+	let cursor = path.dirname(fileURLToPath(moduleUrl));
+	for (let i = 0; i < 3; i += 1) {
+		if (isAcpxPluginRoot(cursor)) return cursor;
+		const parent = path.dirname(cursor);
+		if (parent === cursor) break;
+		cursor = parent;
+	}
+	return path.resolve(path.dirname(fileURLToPath(moduleUrl)), "..");
+}
+function resolveWorkspaceAcpxPluginRoot(currentRoot) {
+	if (path.basename(currentRoot) !== "acpx" || path.basename(path.dirname(currentRoot)) !== "extensions" || path.basename(path.dirname(path.dirname(currentRoot))) !== "dist") return null;
+	const workspaceRoot = path.resolve(currentRoot, "..", "..", "..", "extensions", "acpx");
+	return isAcpxPluginRoot(workspaceRoot) ? workspaceRoot : null;
+}
+function resolveRepoAcpxPluginRoot(currentRoot) {
+	const workspaceRoot = path.join(currentRoot, "extensions", "acpx");
+	return isAcpxPluginRoot(workspaceRoot) ? workspaceRoot : null;
+}
+function resolveAcpxPluginRootFromOpenClawLayout(moduleUrl) {
+	let cursor = path.dirname(fileURLToPath(moduleUrl));
+	for (let i = 0; i < 5; i += 1) {
+		const candidates = [
+			path.join(cursor, "extensions", "acpx"),
+			path.join(cursor, "dist", "extensions", "acpx"),
+			path.join(cursor, "dist-runtime", "extensions", "acpx")
+		];
+		for (const candidate of candidates) if (isAcpxPluginRoot(candidate)) return candidate;
+		const parent = path.dirname(cursor);
+		if (parent === cursor) break;
+		cursor = parent;
+	}
+	return null;
+}
+/** Resolve the ACPX plugin root across source, dist, and dist-runtime layouts. */
+function resolveAcpxPluginRoot(moduleUrl = import.meta.url) {
+	const resolvedRoot = resolveNearestAcpxPluginRoot(moduleUrl);
+	return resolveWorkspaceAcpxPluginRoot(resolvedRoot) ?? resolveRepoAcpxPluginRoot(resolvedRoot) ?? resolveAcpxPluginRootFromOpenClawLayout(moduleUrl) ?? resolvedRoot;
+}
+const DEFAULT_PERMISSION_MODE = "approve-reads";
+const DEFAULT_NON_INTERACTIVE_POLICY = "fail";
+const DEFAULT_QUEUE_OWNER_TTL_SECONDS = .1;
+const DEFAULT_STRICT_WINDOWS_CMD_WRAPPER = true;
+function parseAcpxPluginConfig(value) {
+	if (value === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	const parsed = AcpxPluginConfigSchema.safeParse(value);
+	if (!parsed.success) return {
+		ok: false,
+		message: formatPluginConfigIssue(parsed.error.issues[0])
+	};
+	return {
+		ok: true,
+		value: parsed.data
+	};
+}
+function resolveOpenClawRoot(currentRoot) {
+	if (path.basename(currentRoot) === "acpx" && path.basename(path.dirname(currentRoot)) === "extensions") {
+		const parent = path.dirname(path.dirname(currentRoot));
+		if (path.basename(parent) === "dist") return path.dirname(parent);
+		return parent;
+	}
+	return path.resolve(currentRoot, "..");
+}
+function resolveTsxImportSpecifier() {
+	try {
+		return requireFromHere$2.resolve("tsx");
+	} catch {
+		return "tsx";
+	}
+}
+function shellQuoteCommandArg(arg) {
+	if (!/[\s'"\\$|&;<>{}()*?[\]~`]/.test(arg)) return arg;
+	return `'${arg.replace(/'/g, "'\"'\"'")}'`;
+}
+function resolvePluginToolsMcpServerConfig(moduleUrl = import.meta.url) {
+	const openClawRoot = resolveOpenClawRoot(resolveAcpxPluginRoot(moduleUrl));
+	const distEntry = path.join(openClawRoot, "dist", "mcp", "plugin-tools-serve.js");
+	if (fs$1.existsSync(distEntry)) return {
+		command: process.execPath,
+		args: [distEntry]
+	};
+	const sourceEntry = path.join(openClawRoot, "src", "mcp", "plugin-tools-serve.ts");
+	return {
+		command: process.execPath,
+		args: [
+			"--import",
+			resolveTsxImportSpecifier(),
+			sourceEntry
+		]
+	};
+}
+function resolveOpenClawToolsMcpServerConfig(moduleUrl = import.meta.url) {
+	const openClawRoot = resolveOpenClawRoot(resolveAcpxPluginRoot(moduleUrl));
+	const distEntry = path.join(openClawRoot, "dist", "mcp", "openclaw-tools-serve.js");
+	if (fs$1.existsSync(distEntry)) return {
+		command: process.execPath,
+		args: [distEntry]
+	};
+	const sourceEntry = path.join(openClawRoot, "src", "mcp", "openclaw-tools-serve.ts");
+	return {
+		command: process.execPath,
+		args: [
+			"--import",
+			resolveTsxImportSpecifier(),
+			sourceEntry
+		]
+	};
+}
+function resolveConfiguredMcpServers(params) {
+	const resolved = { ...params.mcpServers };
+	if (params.pluginToolsMcpBridge && resolved[ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME]) throw new Error(`mcpServers.${ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME} is reserved when pluginToolsMcpBridge=true`);
+	if (params.openClawToolsMcpBridge && resolved[ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME]) throw new Error(`mcpServers.${ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME} is reserved when openClawToolsMcpBridge=true`);
+	if (params.pluginToolsMcpBridge) resolved[ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME] = resolvePluginToolsMcpServerConfig(params.moduleUrl);
+	if (params.openClawToolsMcpBridge) resolved[ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME] = resolveOpenClawToolsMcpServerConfig(params.moduleUrl);
+	return resolved;
+}
+/** Convert OpenClaw MCP server config into ACPX runtime MCP server entries. */
+function toAcpMcpServers(mcpServers) {
+	return Object.entries(mcpServers).map(([name, server]) => ({
+		name,
+		command: server.command,
+		args: [...server.args ?? []],
+		env: Object.entries(server.env ?? {}).map(([envName, value]) => ({
+			name: envName,
+			value
+		}))
+	}));
+}
+/** Validate and normalize raw ACPX plugin config for runtime startup. */
+function resolveAcpxPluginConfig(params) {
+	const parsed = parseAcpxPluginConfig(params.rawConfig);
+	if (!parsed.ok) throw new Error(parsed.message);
+	const normalized = parsed.value ?? {};
+	const workspaceDir = params.workspaceDir?.trim() || process.cwd();
+	const fallbackCwd = workspaceDir;
+	const cwd = path.resolve(normalized.cwd?.trim() || fallbackCwd);
+	const stateDir = path.resolve(normalized.stateDir?.trim() || path.join(workspaceDir, "state"));
+	const pluginToolsMcpBridge = normalized.pluginToolsMcpBridge === true;
+	const openClawToolsMcpBridge = normalized.openClawToolsMcpBridge === true;
+	const mcpServers = resolveConfiguredMcpServers({
+		mcpServers: normalized.mcpServers,
+		pluginToolsMcpBridge,
+		openClawToolsMcpBridge,
+		moduleUrl: params.moduleUrl
+	});
+	const agents = Object.fromEntries(Object.entries(normalized.agents ?? {}).map(([name, entry]) => {
+		const cmd = entry.command.trim();
+		const cmdArgs = entry.args ?? [];
+		const fullCommand = cmdArgs.length > 0 ? `${cmd} ${cmdArgs.map(shellQuoteCommandArg).join(" ")}` : cmd;
+		return [normalizeLowercaseStringOrEmpty(name), fullCommand];
+	}));
+	return {
+		cwd,
+		stateDir,
+		probeAgent: normalizeLowercaseStringOrEmpty(normalized.probeAgent) || void 0,
+		permissionMode: normalized.permissionMode ?? DEFAULT_PERMISSION_MODE,
+		nonInteractivePermissions: normalized.nonInteractivePermissions ?? DEFAULT_NON_INTERACTIVE_POLICY,
+		pluginToolsMcpBridge,
+		openClawToolsMcpBridge,
+		strictWindowsCmdWrapper: normalized.strictWindowsCmdWrapper ?? DEFAULT_STRICT_WINDOWS_CMD_WRAPPER,
+		timeoutSeconds: normalized.timeoutSeconds ?? 120,
+		queueOwnerTtlSeconds: normalized.queueOwnerTtlSeconds ?? DEFAULT_QUEUE_OWNER_TTL_SECONDS,
+		legacyCompatibilityConfig: {
+			strictWindowsCmdWrapper: normalized.strictWindowsCmdWrapper,
+			queueOwnerTtlSeconds: normalized.queueOwnerTtlSeconds
+		},
+		mcpServers,
+		agents
+	};
+}
+//#endregion
+//#region extensions/acpx/src/process-reaper.ts
+/**
+* ACPX process ownership checks and cleanup. The reaper only terminates
+* OpenClaw-owned wrapper trees after validating paths, packages, and lease ids.
+*/
+const execFileAsync = promisify(execFile);
+const requireFromHere$1 = createRequire(import.meta.url);
+const GENERATED_WRAPPER_BASENAMES = /* @__PURE__ */ new Set(["codex-acp-wrapper.mjs", "claude-agent-acp-wrapper.mjs"]);
+const OPENCLAW_PLUGIN_DEPS_MARKER = "/plugin-runtime-deps/";
+const OWNED_ACP_PACKAGE_NAMES = [
+	"@zed-industries/codex-acp",
+	"@zed-industries/codex-acp-darwin-arm64",
+	"@zed-industries/codex-acp-darwin-x64",
+	"@zed-industries/codex-acp-linux-arm64",
+	"@zed-industries/codex-acp-linux-x64",
+	"@zed-industries/codex-acp-win32-arm64",
+	"@zed-industries/codex-acp-win32-x64",
+	"@agentclientprotocol/claude-agent-acp",
+	"acpx"
+];
+const ACP_PACKAGE_MARKERS = [...OWNED_ACP_PACKAGE_NAMES.map((packageName) => `/node_modules/${packageName}/`), "/acpx/dist/"];
+function normalizePathLike(value) {
+	return value.replaceAll("\\", "/");
+}
+function resolvePackageRoot(packageName) {
+	try {
+		return normalizePathLike(path.dirname(requireFromHere$1.resolve(`${packageName}/package.json`)));
+	} catch {
+		return;
+	}
+}
+function resolveOpenClawInstallRoot(pluginRoot) {
+	if (path.basename(pluginRoot) === "acpx" && path.basename(path.dirname(pluginRoot)) === "extensions") {
+		const parent = path.dirname(path.dirname(pluginRoot));
+		return path.basename(parent) === "dist" ? path.dirname(parent) : parent;
+	}
+	return path.resolve(pluginRoot, "..");
+}
+function resolveOwnedAcpPackageRootCandidates(packageName) {
+	const pluginRoot = resolveAcpxPluginRoot(import.meta.url);
+	const openClawRoot = resolveOpenClawInstallRoot(pluginRoot);
+	return [
+		resolvePackageRoot(packageName),
+		path.join(pluginRoot, "node_modules", packageName),
+		path.join(openClawRoot, "node_modules", packageName)
+	].flatMap((root) => root ? [normalizePathLike(root)] : []);
+}
+const OWNED_ACP_PACKAGE_ROOTS = Array.from(new Set(OWNED_ACP_PACKAGE_NAMES.flatMap(resolveOwnedAcpPackageRootCandidates)));
+function commandBelongsToResolvedAcpPackage(command) {
+	return OWNED_ACP_PACKAGE_ROOTS.some((root) => command.includes(`${root}/`));
+}
+function commandMentionsGeneratedWrapper(command) {
+	return Array.from(GENERATED_WRAPPER_BASENAMES).some((basename) => command.includes(basename));
+}
+function commandWrapperBelongsToRoot(command, wrapperRoot) {
+	if (!wrapperRoot) return true;
+	const normalizedCommand = normalizePathLike(command);
+	const normalizedRoot = normalizePathLike(wrapperRoot).replace(/\/+$/, "");
+	return Array.from(GENERATED_WRAPPER_BASENAMES).some((basename) => normalizedCommand.includes(`${normalizedRoot}/${basename}`));
+}
+/** Check whether a command references an OpenClaw-generated ACPX wrapper path. */
+function isOpenClawLeaseAwareAcpxProcessCommand(params) {
+	const command = params.command?.trim();
+	if (!command) return false;
+	const normalized = normalizePathLike(command);
+	return commandMentionsGeneratedWrapper(normalized) && commandWrapperBelongsToRoot(normalized, params.wrapperRoot);
+}
+function commandsReferToSameRootCommand(liveCommand, storedCommand) {
+	if (!storedCommand?.trim()) return true;
+	return normalizePathLike(liveCommand).trim() === normalizePathLike(storedCommand).trim();
+}
+function commandOptionEquals(parts, option, expected) {
+	if (!expected) return true;
+	const index = parts.indexOf(option);
+	return index >= 0 && parts[index + 1] === expected;
+}
+function liveCommandMatchesLeaseIdentity(params) {
+	if (!params.expectedLeaseId && !params.expectedGatewayInstanceId) return true;
+	const parts = splitCommandParts(params.command ?? "");
+	return commandOptionEquals(parts, "--openclaw-acpx-lease-id", params.expectedLeaseId) && commandOptionEquals(parts, "--openclaw-gateway-instance-id", params.expectedGatewayInstanceId);
+}
+/** Check whether a command is owned by OpenClaw ACPX runtime packages or wrappers. */
+function isOpenClawOwnedAcpxProcessCommand(params) {
+	const command = params.command?.trim();
+	if (!command) return false;
+	const normalized = normalizePathLike(command);
+	if (isOpenClawLeaseAwareAcpxProcessCommand({
+		command: normalized,
+		wrapperRoot: params.wrapperRoot
+	})) return true;
+	if (commandBelongsToResolvedAcpPackage(normalized)) return true;
+	if (!normalized.includes(OPENCLAW_PLUGIN_DEPS_MARKER)) return false;
+	return ACP_PACKAGE_MARKERS.some((marker) => normalized.includes(marker));
+}
+function parseProcessList(stdout) {
+	const processes = [];
+	for (const line of stdout.split(/\r?\n/)) {
+		const match = /^\s*(?<pid>\d+)\s+(?<ppid>\d+)\s+(?<command>.+?)\s*$/.exec(line);
+		if (!match?.groups) continue;
+		processes.push({
+			pid: Number.parseInt(match.groups.pid, 10),
+			ppid: Number.parseInt(match.groups.ppid, 10),
+			command: match.groups.command
+		});
+	}
+	return processes;
+}
+/** List host processes in the compact shape needed by ACPX cleanup. */
+async function listPlatformProcesses() {
+	if (process.platform === "win32") return [];
+	const { stdout } = await execFileAsync("ps", ["-axo", "pid=,ppid=,command="], { maxBuffer: 8388608 });
+	return parseProcessList(stdout);
+}
+function collectProcessTree(processes, rootPid) {
+	const childrenByParent = /* @__PURE__ */ new Map();
+	for (const processInfo of processes) {
+		const children = childrenByParent.get(processInfo.ppid) ?? [];
+		children.push(processInfo);
+		childrenByParent.set(processInfo.ppid, children);
+	}
+	const root = new Map(processes.map((processInfo) => [processInfo.pid, processInfo])).get(rootPid);
+	const collected = [];
+	if (root) collected.push(root);
+	const queue = [...childrenByParent.get(rootPid) ?? []];
+	while (queue.length > 0) {
+		const next = queue.shift();
+		if (!next || collected.some((processInfo) => processInfo.pid === next.pid)) continue;
+		collected.push(next);
+		queue.push(...childrenByParent.get(next.pid) ?? []);
+	}
+	return collected;
+}
+function uniquePids(processes) {
+	return Array.from(new Set(processes.map((processInfo) => processInfo.pid).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid)));
+}
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function terminatePids(pids, deps) {
+	const killProcess = deps?.killProcess ?? ((pid, signal) => process.kill(pid, signal));
+	const sleep = deps?.sleep ?? ((ms) => new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	}));
+	const terminated = [];
+	for (const pid of pids) try {
+		killProcess(pid, "SIGTERM");
+		terminated.push(pid);
+	} catch {}
+	if (terminated.length === 0) return terminated;
+	await sleep(750);
+	for (const pid of terminated) if (deps?.killProcess || isProcessAlive(pid)) try {
+		killProcess(pid, "SIGKILL");
+	} catch {}
+	return terminated;
+}
+/** Terminate one validated OpenClaw-owned ACPX wrapper process tree. */
+async function cleanupOpenClawOwnedAcpxProcessTree(params) {
+	const rootPid = params.rootPid;
+	if (!rootPid || rootPid <= 0 || rootPid === process.pid) return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "missing-root"
+	};
+	let processes;
+	try {
+		processes = await (params.deps?.listProcesses ?? listPlatformProcesses)();
+	} catch {
+		processes = [];
+	}
+	const listedTree = collectProcessTree(processes, rootPid);
+	if (listedTree.length === 0) return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "unverified-root"
+	};
+	const rootCommand = listedTree[0]?.command ?? params.rootCommand;
+	const liveCommandWasGeneratedWrapper = commandMentionsGeneratedWrapper(normalizePathLike(rootCommand ?? ""));
+	const storedCommandWasGeneratedWrapper = commandMentionsGeneratedWrapper(normalizePathLike(params.rootCommand ?? ""));
+	if (!liveCommandWasGeneratedWrapper && storedCommandWasGeneratedWrapper) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-openclaw-owned"
+	};
+	if (!liveCommandWasGeneratedWrapper && !commandsReferToSameRootCommand(rootCommand ?? "", params.rootCommand)) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-openclaw-owned"
+	};
+	if (!isOpenClawOwnedAcpxProcessCommand({
+		command: rootCommand,
+		wrapperRoot: params.wrapperRoot
+	})) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-openclaw-owned"
+	};
+	if (!liveCommandMatchesLeaseIdentity({
+		command: rootCommand,
+		expectedLeaseId: params.expectedLeaseId,
+		expectedGatewayInstanceId: params.expectedGatewayInstanceId
+	})) return {
+		inspectedPids: listedTree.map((processInfo) => processInfo.pid),
+		terminatedPids: [],
+		skippedReason: "not-openclaw-owned"
+	};
+	const pids = uniquePids(listedTree.toReversed());
+	return {
+		inspectedPids: uniquePids(listedTree),
+		terminatedPids: await terminatePids(pids, params.deps)
+	};
+}
+/** Reap orphaned OpenClaw-owned ACPX wrapper trees during runtime startup. */
+async function reapStaleOpenClawOwnedAcpxOrphans(params) {
+	if (process.platform === "win32") return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "unsupported-platform"
+	};
+	let processes;
+	try {
+		processes = await (params.deps?.listProcesses ?? listPlatformProcesses)();
+	} catch {
+		return {
+			inspectedPids: [],
+			terminatedPids: [],
+			skippedReason: "process-list-unavailable"
+		};
+	}
+	const orphanTrees = processes.filter((processInfo) => processInfo.ppid === 1 && isOpenClawOwnedAcpxProcessCommand({
+		command: processInfo.command,
+		wrapperRoot: params.wrapperRoot
+	})).map((orphan) => collectProcessTree(processes, orphan.pid));
+	return {
+		inspectedPids: uniquePids(orphanTrees.flat()),
+		terminatedPids: await terminatePids(uniquePids(orphanTrees.flatMap((tree) => tree.toReversed())), params.deps)
+	};
+}
+//#endregion
 //#region extensions/acpx/src/codex-trust-config.ts
 /**
 * Builds isolated Codex config for ACPX sessions. It preserves safe inherited
@@ -126,11 +651,9 @@ function extractTrustedCodexProjectPaths(configToml) {
 			continue;
 		}
 		const assignment = /^(?<key>"(?:\\.|[^"\\])*"|'[^']*'|[A-Za-z0-9_\-/.~:]+)\s*=\s*(?<value>.+)$/.exec(line);
-		const rawKey = assignment?.groups?.key;
-		const rawValue = assignment?.groups?.value;
-		if (!rawKey || rawValue === void 0) continue;
-		const key = parseTomlString(rawKey) ?? rawKey;
-		const value = rawValue.trim();
+		if (!assignment?.groups) continue;
+		const key = parseTomlString(assignment.groups.key) ?? assignment.groups.key;
+		const value = assignment.groups.value.trim();
 		if (inProjectsTable && /^\{.*\}$/.test(value)) {
 			if (/\btrust_level\s*=\s*["']trusted["']/.test(value) && key) trusted.add(key);
 			continue;
@@ -226,13 +749,15 @@ function renderIsolatedCodexConfig(params) {
 * Prepares isolated Codex and Claude ACP wrapper commands for ACPX. The bridge
 * copies safe auth/config state into plugin-owned homes and redacts diagnostics.
 */
+const CODEX_ACP_PACKAGE = "@zed-industries/codex-acp";
+const CODEX_ACP_BIN = "codex-acp";
 const CLAUDE_ACP_PACKAGE = "@agentclientprotocol/claude-agent-acp";
 const CLAUDE_ACP_BIN = "claude-agent-acp";
 const RUN_CONFIGURED_COMMAND_SENTINEL = "--openclaw-run-configured";
 const requireFromHere = createRequire(import.meta.url);
 function readSelfManifest() {
 	const manifestPath = path.join(resolveAcpxPluginRoot(import.meta.url), "package.json");
-	return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+	return JSON.parse(fs$1.readFileSync(manifestPath, "utf8"));
 }
 function readManifestDependencyVersion(packageName) {
 	const version = readSelfManifest().dependencies?.[packageName];
@@ -257,7 +782,7 @@ async function resolveInstalledAcpPackageBinPath(packageName, binName) {
 		if (manifest.name !== packageName) return;
 		const binPath = resolvePackageBinPath(packageJsonPath, manifest, binName);
 		if (!binPath) return;
-		await fs$1.access(binPath);
+		await fs.access(binPath);
 		return binPath;
 	} catch {
 		return;
@@ -381,10 +906,9 @@ function renderDiagnosticRedactionRuleSpecs() {
 }
 function buildAdapterWrapperScript(params) {
 	return `#!/usr/bin/env node
-import { appendFileSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
-import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath } from "node:url";
 
 ${params.envSetup}
@@ -394,7 +918,6 @@ const stderrLogMaxChars = 256 * 1024;
 const openClawWrapperArgs = new Set([
   ${quoteCommandPart(OPENCLAW_ACPX_LEASE_ID_ARG)},
   ${quoteCommandPart(OPENCLAW_GATEWAY_INSTANCE_ID_ARG)},
-  ${(params.openClawWrapperArgs ?? []).map(quoteCommandPart).join(",\n  ")}
 ]);
 
 function readOpenClawWrapperArg(args, name) {
@@ -406,21 +929,6 @@ function readOpenClawWrapperArg(args, name) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 
-function readOpenClawWrapperArgs(args, name) {
-  const values = [];
-  for (let index = 0; index < args.length; index += 1) {
-    if (args[index] !== name) {
-      continue;
-    }
-    const value = args[index + 1];
-    if (typeof value === "string" && value.trim()) {
-      values.push(value.trim());
-    }
-    index += 1;
-  }
-  return values;
-}
-
 function safeDiagnosticFilePart(value) {
   const sanitized = String(value || "").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120);
   return sanitized || "pid-" + process.pid;
@@ -431,6 +939,7 @@ function resolveStderrLogPath(args) {
     return undefined;
   }
   const leaseId =
+    process.env[${JSON.stringify(OPENCLAW_ACPX_LEASE_ID_ENV)}] ||
     readOpenClawWrapperArg(args, ${quoteCommandPart(OPENCLAW_ACPX_LEASE_ID_ARG)}) ||
     "pid-" + process.pid;
   const fileName = stderrLogFileNamePrefix + "." + safeDiagnosticFilePart(leaseId) + ".log";
@@ -450,25 +959,7 @@ function redactDiagnosticText(text) {
   return redacted;
 }
 
-function tailUtf16Safe(text, maxChars) {
-  let start = Math.max(0, text.length - maxChars);
-  const startsInsideSurrogatePair =
-    start > 0 &&
-    start < text.length &&
-    text.charCodeAt(start) >= 0xdc00 &&
-    text.charCodeAt(start) <= 0xdfff &&
-    text.charCodeAt(start - 1) >= 0xd800 &&
-    text.charCodeAt(start - 1) <= 0xdbff;
-  if (startsInsideSurrogatePair) {
-    start += 1;
-  }
-  return text.slice(start);
-}
-
 let pendingStderrLogText = "";
-// Pipe chunks can split a UTF-8 sequence. Preserve decoder state so diagnostic
-// capture does not manufacture replacement characters between chunks.
-const stderrDecoder = new StringDecoder("utf8");
 const stderrPrivateKeyEndPattern = /-----END [A-Z ]*PRIVATE KEY-----/;
 
 function hasUnclosedPrivateKeyBlock(text) {
@@ -493,7 +984,7 @@ function writeRedactedStderrLog(text) {
     appendFileSync(stderrLogPath, redactDiagnosticText(text), "utf8");
     const current = readFileSync(stderrLogPath, "utf8");
     if (current.length > stderrLogMaxChars) {
-      writeFileSync(stderrLogPath, tailUtf16Safe(current, stderrLogMaxChars), "utf8");
+      writeFileSync(stderrLogPath, current.slice(-stderrLogMaxChars), "utf8");
     }
   } catch {
     // Stderr capture is diagnostic-only; never break the ACP adapter.
@@ -512,7 +1003,7 @@ function flushFinalizedStderrLogText() {
   const lastLineBreak = pendingStderrLogText.lastIndexOf("\\n");
   if (lastLineBreak === -1) {
     if (pendingStderrLogText.length > stderrLogMaxChars) {
-      pendingStderrLogText = tailUtf16Safe(pendingStderrLogText, stderrLogMaxChars);
+      pendingStderrLogText = pendingStderrLogText.slice(-stderrLogMaxChars);
     }
     return;
   }
@@ -525,7 +1016,7 @@ function flushFinalizedStderrLogText() {
   }
   if (flushEnd <= 0) {
     if (pendingStderrLogText.length > stderrLogMaxChars) {
-      pendingStderrLogText = tailUtf16Safe(pendingStderrLogText, stderrLogMaxChars);
+      pendingStderrLogText = pendingStderrLogText.slice(-stderrLogMaxChars);
     }
     return;
   }
@@ -535,7 +1026,7 @@ function flushFinalizedStderrLogText() {
 }
 
 function appendStderrLog(chunk) {
-  const text = stderrDecoder.write(chunk);
+  const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
   if (!text) {
     return;
   }
@@ -544,7 +1035,6 @@ function appendStderrLog(chunk) {
 }
 
 function finishStderrLog() {
-  pendingStderrLogText += stderrDecoder.end();
   const text = redactIncompletePrivateKeyTail(pendingStderrLogText);
   pendingStderrLogText = "";
   writeRedactedStderrLog(text);
@@ -564,14 +1054,14 @@ function stripOpenClawWrapperArgs(args) {
 }
 
 const rawConfiguredArgs = process.argv.slice(2);
-${params.envConfigSetup ?? ""}
 const stderrLogPath = resolveStderrLogPath(rawConfiguredArgs);
-if (stderrLogPath) {
-  try {
-    rmSync(stderrLogPath, { force: true });
-  } catch {
-    // Diagnostic cleanup must never prevent the adapter from starting.
+
+try {
+  if (stderrLogPath) {
+    writeFileSync(stderrLogPath, "", "utf8");
   }
+} catch {
+  // Stderr capture is diagnostic-only; never break the ACP adapter.
 }
 
 const configuredArgs = stripOpenClawWrapperArgs(rawConfiguredArgs);
@@ -720,7 +1210,6 @@ function buildCodexAcpWrapperScript(installedBinPath) {
 		binName: CODEX_ACP_BIN,
 		installedBinPath,
 		stderrLogFileNamePrefix: "codex-acp-wrapper.stderr",
-		openClawWrapperArgs: [OPENCLAW_CODEX_CONFIG_ARG],
 		envSetup: `const codexHome = fileURLToPath(new URL("./codex-home/", import.meta.url));
 const codexAuthPath = fileURLToPath(new URL("./codex-home/auth.json", import.meta.url));
 const codexApiKey = (process.env.CODEX_API_KEY || process.env.OPENAI_API_KEY || "").trim();
@@ -754,59 +1243,7 @@ if (shouldWriteCodexApiKeyAuth) {
 const env = {
   ...process.env,
   CODEX_HOME: codexHome,
-};`,
-		envConfigSetup: `function isCodexConfigObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function mergeCodexConfig(base, override) {
-  const merged = Object.assign(Object.create(null), base);
-  for (const [key, value] of Object.entries(override)) {
-    const existing = merged[key];
-    merged[key] =
-      isCodexConfigObject(existing) && isCodexConfigObject(value)
-        ? mergeCodexConfig(existing, value)
-        : value;
-  }
-  return merged;
-}
-
-const openClawCodexConfigs = readOpenClawWrapperArgs(
-  rawConfiguredArgs,
-  ${quoteCommandPart(OPENCLAW_CODEX_CONFIG_ARG)},
-);
-if (openClawCodexConfigs.length > 0) {
-  let existingCodexConfig = {};
-  if (typeof env.CODEX_CONFIG === "string" && env.CODEX_CONFIG.trim()) {
-    try {
-      const parsedCodexConfig = JSON.parse(env.CODEX_CONFIG);
-      if (!parsedCodexConfig || typeof parsedCodexConfig !== "object" || Array.isArray(parsedCodexConfig)) {
-        throw new Error("CODEX_CONFIG must be a JSON object");
-      }
-      existingCodexConfig = parsedCodexConfig;
-    } catch {
-      console.error("[openclaw] CODEX_CONFIG must be a valid JSON object");
-      process.exit(1);
-    }
-  }
-  for (const openClawCodexConfig of openClawCodexConfigs) {
-    try {
-      const parsedOpenClawCodexConfig = JSON.parse(openClawCodexConfig);
-      if (
-        !parsedOpenClawCodexConfig ||
-        typeof parsedOpenClawCodexConfig !== "object" ||
-        Array.isArray(parsedOpenClawCodexConfig)
-      ) {
-        throw new Error("invalid OpenClaw Codex config");
-      }
-      existingCodexConfig = mergeCodexConfig(existingCodexConfig, parsedOpenClawCodexConfig);
-    } catch {
-      console.error("[openclaw] invalid generated Codex ACP startup config");
-      process.exit(1);
-    }
-  }
-  env.CODEX_CONFIG = JSON.stringify(existingCodexConfig);
-}`
+};`
 	});
 }
 function buildClaudeAcpWrapperScript(installedBinPath) {
@@ -822,7 +1259,7 @@ function buildClaudeAcpWrapperScript(installedBinPath) {
 }
 async function readSourceCodexConfig(codexHome) {
 	try {
-		return await fs$1.readFile(path.join(codexHome, "config.toml"), "utf8");
+		return await fs.readFile(path.join(codexHome, "config.toml"), "utf8");
 	} catch (error) {
 		if (error.code === "ENOENT") return;
 		throw error;
@@ -832,8 +1269,8 @@ async function prepareIsolatedCodexHome(params) {
 	const sourceConfig = await readSourceCodexConfig(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"));
 	const trustedProjectPaths = [...sourceConfig ? extractTrustedCodexProjectPaths(sourceConfig) : [], params.workspaceDir];
 	const codexHome = path.join(params.baseDir, "codex-home");
-	await fs$1.mkdir(codexHome, { recursive: true });
-	await fs$1.writeFile(path.join(codexHome, "config.toml"), renderIsolatedCodexConfig({
+	await fs.mkdir(codexHome, { recursive: true });
+	await fs.writeFile(path.join(codexHome, "config.toml"), renderIsolatedCodexConfig({
 		sourceConfigToml: sourceConfig,
 		projectPaths: trustedProjectPaths
 	}), "utf8");
@@ -841,20 +1278,20 @@ async function prepareIsolatedCodexHome(params) {
 }
 async function makeGeneratedWrapperExecutableIfPossible(wrapperPath) {
 	try {
-		await fs$1.chmod(wrapperPath, 493);
+		await fs.chmod(wrapperPath, 493);
 	} catch {}
 }
 async function writeCodexAcpWrapper(baseDir, installedBinPath) {
-	await fs$1.mkdir(baseDir, { recursive: true });
+	await fs.mkdir(baseDir, { recursive: true });
 	const wrapperPath = path.join(baseDir, "codex-acp-wrapper.mjs");
-	await fs$1.writeFile(wrapperPath, buildCodexAcpWrapperScript(installedBinPath), { encoding: "utf8" });
+	await fs.writeFile(wrapperPath, buildCodexAcpWrapperScript(installedBinPath), { encoding: "utf8" });
 	await makeGeneratedWrapperExecutableIfPossible(wrapperPath);
 	return wrapperPath;
 }
 async function writeClaudeAcpWrapper(baseDir, installedBinPath) {
-	await fs$1.mkdir(baseDir, { recursive: true });
+	await fs.mkdir(baseDir, { recursive: true });
 	const wrapperPath = path.join(baseDir, "claude-agent-acp-wrapper.mjs");
-	await fs$1.writeFile(wrapperPath, buildClaudeAcpWrapperScript(installedBinPath), { encoding: "utf8" });
+	await fs.writeFile(wrapperPath, buildClaudeAcpWrapperScript(installedBinPath), { encoding: "utf8" });
 	await makeGeneratedWrapperExecutableIfPossible(wrapperPath);
 	return wrapperPath;
 }
@@ -893,94 +1330,15 @@ function extractConfiguredAdapterArgs(params) {
 	if (isAcpBinName(parts[0] ?? "", params.binName)) return parts.slice(1);
 	if (basename(parts[0] ?? "") === "node" && isAcpBinName(parts[1] ?? "", params.binName)) return parts.slice(2);
 }
-function isConfigRecord(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function mergeConfigRecords(base, override) {
-	const merged = { ...base };
-	for (const [key, value] of Object.entries(override)) {
-		const existing = merged[key];
-		const nextValue = isConfigRecord(existing) && isConfigRecord(value) ? mergeConfigRecords(existing, value) : value;
-		Object.defineProperty(merged, key, {
-			value: nextValue,
-			configurable: true,
-			enumerable: true,
-			writable: true
-		});
-	}
-	return merged;
-}
-function parseLegacyCodexConfigAssignment(assignment) {
-	const separator = assignment.indexOf("=");
-	if (separator <= 0) throw new Error(`Invalid legacy Codex ACP config override: ${assignment}`);
-	const rawKey = assignment.slice(0, separator).trim();
-	const key = rawKey === "use_legacy_landlock" ? "features.use_legacy_landlock" : rawKey;
-	const rawValue = assignment.slice(separator + 1).trim();
-	try {
-		return parse(`${key} = ${rawValue}`);
-	} catch {
-		const literal = rawValue.replace(/^["']+|["']+$/g, "");
-		return parse(`${key} = ${JSON.stringify(literal)}`);
-	}
-}
-function migrateLegacyCodexArgs(args) {
-	let config = {};
-	const forwardedArgs = [];
-	let hadOverrides = false;
-	for (let index = 0; index < args.length; index += 1) {
-		const arg = args[index] ?? "";
-		let assignment;
-		if (arg === "-c" || arg === "--config") assignment = args[index += 1];
-		else if (arg.startsWith("--config=")) assignment = arg.slice(9);
-		else if (arg.startsWith("-c=")) assignment = arg.slice(3);
-		else if (arg.startsWith("-c") && arg.length > 2) assignment = arg.slice(2);
-		else {
-			forwardedArgs.push(arg);
-			continue;
-		}
-		if (!assignment) throw new Error(`Missing value for legacy Codex ACP option ${arg}`);
-		hadOverrides = true;
-		config = mergeConfigRecords(config, parseLegacyCodexConfigAssignment(assignment));
-	}
-	return {
-		config,
-		forwardedArgs,
-		hadOverrides
-	};
-}
-function resolveCodexAdapterLaunch(configuredCommand) {
-	const legacyAdapterArgs = extractConfiguredAdapterArgs({
-		configuredCommand,
-		packageName: LEGACY_CODEX_ACP_PACKAGE,
-		binName: CODEX_ACP_BIN
-	});
-	if (legacyAdapterArgs) {
-		const migration = migrateLegacyCodexArgs(legacyAdapterArgs);
-		return {
-			args: [...migration.hadOverrides ? [OPENCLAW_CODEX_CONFIG_ARG, JSON.stringify(migration.config)] : [], ...migration.forwardedArgs],
-			...migration.hadOverrides ? { migratedConfig: migration.config } : {}
-		};
-	}
-	const maintainedAdapterArgs = extractConfiguredAdapterArgs({
+function buildCodexAcpWrapperCommand(wrapperPath, configuredCommand) {
+	const configuredAdapterArgs = extractConfiguredAdapterArgs({
 		configuredCommand,
 		packageName: CODEX_ACP_PACKAGE,
 		binName: CODEX_ACP_BIN
 	});
-	if (!maintainedAdapterArgs) return;
-	return { args: maintainedAdapterArgs };
-}
-function buildCodexAcpWrapperCommand(wrapperPath, configuredCommand) {
-	const launch = resolveCodexAdapterLaunch(configuredCommand);
-	if (launch) return buildWrapperCommand(wrapperPath, launch.args);
+	if (configuredAdapterArgs) return buildWrapperCommand(wrapperPath, configuredAdapterArgs);
 	return buildWrapperCommand(wrapperPath, [RUN_CONFIGURED_COMMAND_SENTINEL, ...splitCommandParts(configuredCommand?.trim() ?? "")]);
 }
-async function persistMigratedCodexMcpConfig(params) {
-	const mcpServers = params.migratedConfig?.mcp_servers;
-	if (!isConfigRecord(mcpServers)) return;
-	const configPath = path.join(params.codexHome, "config.toml");
-	const merged = mergeConfigRecords(parse(await fs$1.readFile(configPath, "utf8")), { mcp_servers: mcpServers });
-	await fs$1.writeFile(configPath, stringify(merged), "utf8");
-}
 function buildClaudeAcpWrapperCommand(wrapperPath, configuredCommand) {
 	const configuredAdapterArgs = extractConfiguredAdapterArgs({
 		configuredCommand,
@@ -994,20 +1352,16 @@ function buildClaudeAcpWrapperCommand(wrapperPath, configuredCommand) {
 async function prepareAcpxCodexAuthConfig(params) {
 	params.logger;
 	const codexBaseDir = path.join(params.stateDir, "acpx");
-	const configuredCodexCommand = params.pluginConfig.agents.codex;
-	const configuredClaudeCommand = params.pluginConfig.agents.claude;
-	const codexLaunch = resolveCodexAdapterLaunch(configuredCodexCommand);
-	await persistMigratedCodexMcpConfig({
-		codexHome: await prepareIsolatedCodexHome({
-			baseDir: codexBaseDir,
-			workspaceDir: params.pluginConfig.cwd
-		}),
-		migratedConfig: codexLaunch?.migratedConfig
+	await prepareIsolatedCodexHome({
+		baseDir: codexBaseDir,
+		workspaceDir: params.pluginConfig.cwd
 	});
 	const installedCodexBinPath = await (params.resolveInstalledCodexAcpBinPath ?? resolveInstalledCodexAcpBinPath)();
 	const installedClaudeBinPath = await (params.resolveInstalledClaudeAcpBinPath ?? resolveInstalledClaudeAcpBinPath)();
 	const wrapperPath = await writeCodexAcpWrapper(codexBaseDir, installedCodexBinPath);
 	const claudeWrapperPath = await writeClaudeAcpWrapper(codexBaseDir, installedClaudeBinPath);
+	const configuredCodexCommand = params.pluginConfig.agents.codex;
+	const configuredClaudeCommand = params.pluginConfig.agents.claude;
 	return {
 		...params.pluginConfig,
 		agents: {
@@ -1023,10 +1377,14 @@ async function prepareAcpxCodexAuthConfig(params) {
 * ACPX plugin service lifecycle. It resolves config, prepares isolated adapter
 * wrappers, registers the ACP backend, and manages startup/cleanup probes.
 */
+var service_exports = /* @__PURE__ */ __exportAll({
+	createAcpxRuntimeService: () => createAcpxRuntimeService,
+	resolveAcpxTimerTimeoutMs: () => resolveAcpxTimerTimeoutMs
+});
 const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
 const SKIP_RUNTIME_PROBE_ENV = "OPENCLAW_SKIP_ACPX_RUNTIME_PROBE";
 const ACPX_BACKEND_ID = "acpx";
-const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-By_lR8uk.js"));
+const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-FxGnBh3l.mjs"));
 /** Convert ACPX timeout seconds into timer-safe milliseconds. */
 function resolveAcpxTimerTimeoutMs(timeoutSeconds) {
 	if (timeoutSeconds === void 0) return;
@@ -1047,7 +1405,6 @@ function createLazyDefaultRuntime(params) {
 				agentRegistry: module.createAgentRegistry({ overrides: params.pluginConfig.agents }),
 				probeAgent: params.pluginConfig.probeAgent,
 				mcpServers: toAcpMcpServers(params.pluginConfig.mcpServers),
-				pluginToolsMcpBridgeEnabled: params.pluginConfig.pluginToolsMcpBridge,
 				openclawToolsMcpBridgeEnabled: params.pluginConfig.openClawToolsMcpBridge,
 				permissionMode: params.pluginConfig.permissionMode,
 				nonInteractivePermissions: params.pluginConfig.nonInteractivePermissions,
@@ -1099,9 +1456,13 @@ function formatDoctorFailureMessage(report) {
 	const detailText = report.details?.map(formatDoctorDetail).filter(Boolean).join("; ").trim();
 	return detailText ? `${report.message} (${detailText})` : report.message;
 }
+function normalizeProbeAgent(value) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized ? normalized : void 0;
+}
 function resolveAllowedAgentsProbeAgent(ctx) {
 	for (const agent of ctx.config.acp?.allowedAgents ?? []) {
-		const normalized = normalizeLowercaseStringOrEmpty(agent);
+		const normalized = normalizeProbeAgent(agent);
 		if (normalized) return normalized;
 	}
 }
@@ -1179,7 +1540,7 @@ async function reapOpenAcpxProcessLeases(params) {
 		});
 		inspectedPids.push(...result.inspectedPids);
 		terminatedPids.push(...result.terminatedPids);
-		await params.leaseStore.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" ? "open" : result.terminatedPids.length > 0 ? "closed" : "lost");
+		await params.leaseStore.markState(lease.leaseId, result.terminatedPids.length > 0 ? "closed" : "lost");
 	}
 	return {
 		inspectedPids,
@@ -1214,8 +1575,8 @@ function createAcpxRuntimeService(params = {}) {
 			}));
 			const wrapperRoot = path.join(ctx.stateDir, "acpx");
 			await measureAcpxStartup(ctx, "filesystem.prepare", async () => {
-				await fs$1.mkdir(pluginConfig.stateDir, { recursive: true });
-				await fs$1.mkdir(wrapperRoot, { recursive: true });
+				await fs.mkdir(pluginConfig.stateDir, { recursive: true });
+				await fs.mkdir(wrapperRoot, { recursive: true });
 			});
 			const gatewayInstanceId = await measureAcpxStartup(ctx, "gateway-instance-id", () => resolveGatewayInstanceId(openKeyedStore));
 			const processLeaseStore = createAcpxProcessLeaseStore({ store: openAcpxProcessLeaseStateStore(openKeyedStore) });
@@ -1285,4 +1646,4 @@ function createAcpxRuntimeService(params = {}) {
 	};
 }
 //#endregion
-export { createAcpxRuntimeService, resolveAcpxTimerTimeoutMs };
+export { createAcpxRuntimeService, splitCommandParts as i, cleanupOpenClawOwnedAcpxProcessTree as n, isOpenClawLeaseAwareAcpxProcessCommand as r, resolveAcpxTimerTimeoutMs, service_exports as t };