@openclaw/acpx 2026.5.7 → 2026.5.9-beta.1

package/dist/process-reaper-DKzgrZt9.js

@@ -0,0 +1,331 @@
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import { readJsonFileWithFallback, writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region extensions/acpx/src/process-lease.ts
+const OPENCLAW_ACPX_LEASE_ID_ENV = "OPENCLAW_ACPX_LEASE_ID";
+const OPENCLAW_GATEWAY_INSTANCE_ID_ENV = "OPENCLAW_GATEWAY_INSTANCE_ID";
+const OPENCLAW_ACPX_LEASE_ID_ARG = "--openclaw-acpx-lease-id";
+const OPENCLAW_GATEWAY_INSTANCE_ID_ARG = "--openclaw-gateway-instance-id";
+const LEASE_FILE = "process-leases.json";
+function normalizeLease(value) {
+	if (typeof value !== "object" || value === null) return;
+	const record = value;
+	if (typeof record.leaseId !== "string" || typeof record.gatewayInstanceId !== "string" || typeof record.sessionKey !== "string" || typeof record.wrapperRoot !== "string" || typeof record.wrapperPath !== "string" || typeof record.rootPid !== "number" || typeof record.commandHash !== "string" || typeof record.startedAt !== "number" || ![
+		"open",
+		"closing",
+		"closed",
+		"lost"
+	].includes(String(record.state))) return;
+	return {
+		leaseId: record.leaseId,
+		gatewayInstanceId: record.gatewayInstanceId,
+		sessionKey: record.sessionKey,
+		wrapperRoot: record.wrapperRoot,
+		wrapperPath: record.wrapperPath,
+		rootPid: record.rootPid,
+		...typeof record.processGroupId === "number" ? { processGroupId: record.processGroupId } : {},
+		commandHash: record.commandHash,
+		startedAt: record.startedAt,
+		state: record.state
+	};
+}
+async function readLeaseFile(filePath) {
+	const { value } = await readJsonFileWithFallback(filePath, {
+		version: 1,
+		leases: []
+	});
+	return {
+		version: 1,
+		leases: Array.isArray(value.leases) ? value.leases.map(normalizeLease).filter((lease) => !!lease) : []
+	};
+}
+function writeLeaseFile(filePath, value) {
+	return writeJsonFileAtomically(filePath, value);
+}
+function createAcpxProcessLeaseStore(params) {
+	const filePath = path.join(params.stateDir, LEASE_FILE);
+	let updateQueue = Promise.resolve();
+	async function update(mutator) {
+		const run = updateQueue.then(async () => {
+			await fs.mkdir(params.stateDir, { recursive: true });
+			await writeLeaseFile(filePath, {
+				version: 1,
+				leases: mutator((await readLeaseFile(filePath)).leases)
+			});
+		});
+		updateQueue = run.catch(() => {});
+		await run;
+	}
+	async function readCurrent() {
+		await updateQueue;
+		return await readLeaseFile(filePath);
+	}
+	return {
+		async load(leaseId) {
+			return (await readCurrent()).leases.find((lease) => lease.leaseId === leaseId);
+		},
+		async listOpen(gatewayInstanceId) {
+			return (await readCurrent()).leases.filter((lease) => (lease.state === "open" || lease.state === "closing") && (!gatewayInstanceId || lease.gatewayInstanceId === gatewayInstanceId));
+		},
+		async save(lease) {
+			await update((leases) => [...leases.filter((entry) => entry.leaseId !== lease.leaseId), lease]);
+		},
+		async markState(leaseId, state) {
+			await update((leases) => leases.map((lease) => lease.leaseId === leaseId ? {
+				...lease,
+				state
+			} : lease));
+		}
+	};
+}
+function createAcpxProcessLeaseId() {
+	return randomUUID();
+}
+function hashAcpxProcessCommand(command) {
+	return createHash("sha256").update(command).digest("hex");
+}
+function quoteEnvValue(value) {
+	return /^[A-Za-z0-9_./:=@+-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+function withAcpxLeaseEnvironment(params) {
+	if ((params.platform ?? process.platform) === "win32") return params.command;
+	return [
+		"env",
+		`${OPENCLAW_ACPX_LEASE_ID_ENV}=${quoteEnvValue(params.leaseId)}`,
+		`${OPENCLAW_GATEWAY_INSTANCE_ID_ENV}=${quoteEnvValue(params.gatewayInstanceId)}`,
+		params.command,
+		OPENCLAW_ACPX_LEASE_ID_ARG,
+		quoteEnvValue(params.leaseId),
+		OPENCLAW_GATEWAY_INSTANCE_ID_ARG,
+		quoteEnvValue(params.gatewayInstanceId)
+	].join(" ");
+}
+//#endregion
+//#region extensions/acpx/src/process-reaper.ts
+const execFileAsync = promisify(execFile);
+const GENERATED_WRAPPER_BASENAMES = new Set(["codex-acp-wrapper.mjs", "claude-agent-acp-wrapper.mjs"]);
+const OPENCLAW_PLUGIN_DEPS_MARKER = "/plugin-runtime-deps/";
+const ACP_PACKAGE_MARKERS = [
+	"/@zed-industries/codex-acp/",
+	"/@agentclientprotocol/claude-agent-acp/",
+	"/acpx/dist/"
+];
+function normalizePathLike(value) {
+	return value.replaceAll("\\", "/");
+}
+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}`));
+}
+function commandsReferToSameRootCommand(liveCommand, storedCommand) {
+	if (!storedCommand?.trim()) return true;
+	return normalizePathLike(liveCommand).trim() === normalizePathLike(storedCommand).trim();
+}
+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;
+}
+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);
+}
+function isOpenClawOwnedAcpxProcessCommand(params) {
+	const command = params.command?.trim();
+	if (!command) return false;
+	const normalized = normalizePathLike(command);
+	if (commandMentionsGeneratedWrapper(normalized)) return commandWrapperBelongsToRoot(normalized, params.wrapperRoot);
+	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;
+}
+async function listPlatformProcesses() {
+	if (process.platform === "win32") return [];
+	const { stdout } = await execFileAsync("ps", ["-axo", "pid=,ppid=,command="], { maxBuffer: 8 * 1024 * 1024 });
+	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;
+}
+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)
+	};
+}
+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
+export { OPENCLAW_GATEWAY_INSTANCE_ID_ARG as a, hashAcpxProcessCommand as c, OPENCLAW_ACPX_LEASE_ID_ARG as i, withAcpxLeaseEnvironment as l, isOpenClawOwnedAcpxProcessCommand as n, createAcpxProcessLeaseId as o, reapStaleOpenClawOwnedAcpxOrphans as r, createAcpxProcessLeaseStore as s, cleanupOpenClawOwnedAcpxProcessTree as t };

package/dist/register.runtime.js

@@ -4,7 +4,7 @@ const ACPX_BACKEND_ID = "acpx";
 const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
 let serviceModulePromise = null;
 function loadServiceModule() {
-	serviceModulePromise ??= import("./service-DXpBsJTq.js");
+	serviceModulePromise ??= import("./service-DzKX5ybC.js");
 	return serviceModulePromise;
 }
 function shouldRunStartupProbe(env = process.env) {

package/dist/{runtime-B3LWev_t.js → runtime-QqpvXys6.js}

@@ -1,5 +1,7 @@
 import { AcpRuntimeError } from "./runtime-api.js";
+import { c as hashAcpxProcessCommand, l as withAcpxLeaseEnvironment, n as isOpenClawOwnedAcpxProcessCommand, o as createAcpxProcessLeaseId, t as cleanupOpenClawOwnedAcpxProcessTree } from "./process-reaper-DKzgrZt9.js";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { resolve } from "node:path";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState } from "acpx/runtime";
 //#region extensions/acpx/src/runtime.ts
 function readSessionRecordName(record) {
@@ -7,17 +9,94 @@ function readSessionRecordName(record) {
 	const { name } = record;
 	return typeof name === "string" ? name.trim() : "";
 }
-function createResetAwareSessionStore(baseStore) {
+function readRecordAgentCommand(record) {
+	if (typeof record !== "object" || record === null) return;
+	const { agentCommand } = record;
+	return typeof agentCommand === "string" ? agentCommand.trim() || void 0 : void 0;
+}
+function readRecordCwd(record) {
+	if (typeof record !== "object" || record === null) return;
+	const { cwd } = record;
+	return typeof cwd === "string" ? cwd.trim() || void 0 : void 0;
+}
+function readRecordResetOnNextEnsure(record) {
+	if (typeof record !== "object" || record === null) return false;
+	const { acpx } = record;
+	if (typeof acpx !== "object" || acpx === null) return false;
+	return acpx.reset_on_next_ensure === true;
+}
+function readRecordAgentPid(record) {
+	if (typeof record !== "object" || record === null) return;
+	const { pid, processId } = record;
+	const rawPid = pid ?? processId;
+	const numericPid = typeof rawPid === "number" ? rawPid : typeof rawPid === "string" ? Number.parseInt(rawPid, 10) : void 0;
+	return numericPid && Number.isInteger(numericPid) && numericPid > 0 ? numericPid : void 0;
+}
+function readOpenClawLeaseIdFromRecord(record) {
+	if (typeof record !== "object" || record === null) return;
+	const { openclawLeaseId } = record;
+	return typeof openclawLeaseId === "string" ? openclawLeaseId.trim() || void 0 : void 0;
+}
+function extractGeneratedWrapperPath(command) {
+	return splitCommandParts(command ?? "").find((part) => basename(part) === "codex-acp-wrapper.mjs" || basename(part) === "claude-agent-acp-wrapper.mjs") ?? "";
+}
+function selectCurrentSessionLease(params) {
+	const sessionKeys = new Set(params.sessionKeys.map((entry) => entry.trim()).filter(Boolean));
+	const candidates = params.leases.filter((lease) => sessionKeys.has(lease.sessionKey));
+	if (params.rootPid) return candidates.find((lease) => lease.rootPid === params.rootPid);
+	let selected;
+	for (const lease of candidates) if (!selected || lease.startedAt > selected.startedAt) selected = lease;
+	return selected;
+}
+function createResetAwareSessionStore(baseStore, params) {
 	const freshSessionKeys = /* @__PURE__ */ new Set();
 	return {
 		async load(sessionId) {
 			const normalized = sessionId.trim();
 			if (normalized && freshSessionKeys.has(normalized)) return;
-			return await baseStore.load(sessionId);
+			const record = await baseStore.load(sessionId);
+			if (!record || !params?.leaseStore || !params.gatewayInstanceId) return record;
+			const sessionName = readSessionRecordName(record) || normalized;
+			const lease = selectCurrentSessionLease({
+				leases: await params.leaseStore.listOpen(params.gatewayInstanceId),
+				sessionKeys: [sessionName, normalized],
+				rootPid: readRecordAgentPid(record)
+			});
+			if (!lease) return record;
+			return {
+				...record,
+				openclawLeaseId: lease.leaseId,
+				openclawGatewayInstanceId: lease.gatewayInstanceId
+			};
 		},
 		async save(record) {
-			await baseStore.save(record);
+			let recordToSave = record;
+			const launch = params?.launchScope?.getStore();
 			const sessionName = readSessionRecordName(record);
+			const rootPid = readRecordAgentPid(record);
+			const agentCommand = readRecordAgentCommand(record);
+			const stableAgentCommand = launch?.stableCommand ?? agentCommand;
+			if (launch && params?.leaseStore && sessionName === launch.sessionKey && rootPid && stableAgentCommand) {
+				const lease = {
+					leaseId: launch.leaseId,
+					gatewayInstanceId: launch.gatewayInstanceId,
+					sessionKey: launch.sessionKey,
+					wrapperRoot: launch.wrapperRoot,
+					wrapperPath: extractGeneratedWrapperPath(stableAgentCommand),
+					rootPid,
+					commandHash: hashAcpxProcessCommand(stableAgentCommand),
+					startedAt: Date.now(),
+					state: "open"
+				};
+				await params.leaseStore.save(lease);
+				recordToSave = {
+					...record,
+					agentCommand: stableAgentCommand,
+					openclawLeaseId: launch.leaseId,
+					openclawGatewayInstanceId: launch.gatewayInstanceId
+				};
+			}
+			await baseStore.save(recordToSave);
 			if (sessionName) freshSessionKeys.delete(sessionName);
 		},
 		markFresh(sessionKey) {
@@ -67,9 +146,10 @@ function readAgentFromHandle(handle) {
 	return readAgentFromSessionKey(handle.sessionKey);
 }
 function readAgentCommandFromRecord(record) {
-	if (typeof record !== "object" || record === null) return;
-	const { agentCommand } = record;
-	return typeof agentCommand === "string" ? agentCommand.trim() || void 0 : void 0;
+	return readRecordAgentCommand(record);
+}
+function readAgentPidFromRecord(record) {
+	return readRecordAgentPid(record);
 }
 function splitCommandParts(value) {
 	const parts = [];
@@ -197,8 +277,8 @@ function createModelScopedAgentRegistry(params) {
 		resolve(agentName) {
 			const command = params.agentRegistry.resolve(agentName);
 			const override = params.scope.getStore();
-			if (!override || normalizeAgentName(agentName) !== CODEX_ACP_AGENT_ID || typeof command !== "string" || !isCodexAcpCommand(command)) return command;
-			return appendCodexAcpConfigOverrides(command, override);
+			if (!override || normalizeAgentName(agentName) !== CODEX_ACP_AGENT_ID || typeof command !== "string" || !isCodexAcpCommand(command)) return params.leaseCommand(command);
+			return params.leaseCommand(appendCodexAcpConfigOverrides(command, override));
 		},
 		list() {
 			return params.agentRegistry.list();
@@ -228,22 +308,34 @@ function shouldUseDistinctBridgeDelegate(options) {
 var AcpxRuntime = class {
 	constructor(options, testOptions) {
 		this.codexAcpModelOverrideScope = new AsyncLocalStorage();
-		this.sessionStore = createResetAwareSessionStore(options.sessionStore);
+		this.launchLeaseScope = new AsyncLocalStorage();
+		const { openclawProcessCleanup, ...delegateTestOptions } = testOptions ?? {};
+		this.processCleanupDeps = openclawProcessCleanup;
+		this.wrapperRoot = options.openclawWrapperRoot;
+		this.gatewayInstanceId = options.openclawGatewayInstanceId;
+		this.processLeaseStore = options.openclawProcessLeaseStore;
+		this.cwd = options.cwd;
+		this.sessionStore = createResetAwareSessionStore(options.sessionStore, {
+			gatewayInstanceId: this.gatewayInstanceId,
+			leaseStore: this.processLeaseStore,
+			launchScope: this.launchLeaseScope
+		});
 		this.agentRegistry = options.agentRegistry;
 		this.scopedAgentRegistry = createModelScopedAgentRegistry({
 			agentRegistry: this.agentRegistry,
-			scope: this.codexAcpModelOverrideScope
+			scope: this.codexAcpModelOverrideScope,
+			leaseCommand: (command) => this.commandWithLaunchLease(command)
 		});
 		const sharedOptions = {
 			...options,
 			sessionStore: this.sessionStore,
 			agentRegistry: this.scopedAgentRegistry
 		};
-		this.delegate = new AcpxRuntime$1(sharedOptions, testOptions);
+		this.delegate = new AcpxRuntime$1(sharedOptions, delegateTestOptions);
 		this.bridgeSafeDelegate = shouldUseDistinctBridgeDelegate(options) ? new AcpxRuntime$1({
 			...sharedOptions,
 			mcpServers: []
-		}, testOptions) : this.delegate;
+		}, delegateTestOptions) : this.delegate;
 		this.probeDelegate = this.resolveDelegateForAgent(resolveProbeAgentName(options));
 	}
 	resolveDelegateForAgent(agentName) {
@@ -257,7 +349,11 @@ var AcpxRuntime = class {
 		return shouldUseBridgeSafeDelegateForCommand(command) ? this.bridgeSafeDelegate : this.delegate;
 	}
 	async resolveDelegateForHandle(handle) {
-		const recordCommand = readAgentCommandFromRecord(await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey));
+		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
+		return this.resolveDelegateForLoadedRecord(handle, record);
+	}
+	resolveDelegateForLoadedRecord(handle, record) {
+		const recordCommand = readAgentCommandFromRecord(record);
 		if (recordCommand) return this.resolveDelegateForCommand(recordCommand);
 		return this.resolveDelegateForAgent(readAgentFromHandle(handle));
 	}
@@ -269,6 +365,87 @@ var AcpxRuntime = class {
 			agentRegistry: this.agentRegistry
 		});
 	}
+	commandWithLaunchLease(command) {
+		const launch = this.launchLeaseScope.getStore();
+		if (!command || !launch) return command;
+		launch.stableCommand = command;
+		return withAcpxLeaseEnvironment({
+			command,
+			leaseId: launch.leaseId,
+			gatewayInstanceId: launch.gatewayInstanceId
+		});
+	}
+	async canReuseStablePersistentSession(params) {
+		if (params.mode !== "persistent" || !params.command) return false;
+		const existing = await this.sessionStore.load(params.sessionKey);
+		if (!existing || readRecordResetOnNextEnsure(existing)) return false;
+		const recordCwd = readRecordCwd(existing);
+		if (!recordCwd || resolve(recordCwd) !== resolve(params.cwd?.trim() || this.cwd)) return false;
+		if (readRecordAgentCommand(existing) !== params.command) return false;
+		const existingSessionId = typeof existing === "object" && existing !== null ? existing.acpSessionId : void 0;
+		return !params.resumeSessionId || existingSessionId === params.resumeSessionId;
+	}
+	async runWithLaunchLease(params) {
+		if (params.enabled === false || !params.command || !this.wrapperRoot || !this.gatewayInstanceId || !this.processLeaseStore || !isOpenClawOwnedAcpxProcessCommand({
+			command: params.command,
+			wrapperRoot: this.wrapperRoot
+		})) return await params.run();
+		const launch = {
+			leaseId: createAcpxProcessLeaseId(),
+			gatewayInstanceId: this.gatewayInstanceId,
+			sessionKey: params.sessionKey,
+			wrapperRoot: this.wrapperRoot,
+			stableCommand: params.command
+		};
+		await this.processLeaseStore.save({
+			leaseId: launch.leaseId,
+			gatewayInstanceId: launch.gatewayInstanceId,
+			sessionKey: launch.sessionKey,
+			wrapperRoot: launch.wrapperRoot,
+			wrapperPath: extractGeneratedWrapperPath(params.command),
+			rootPid: 0,
+			commandHash: hashAcpxProcessCommand(params.command),
+			startedAt: Date.now(),
+			state: "open"
+		});
+		return await this.launchLeaseScope.run(launch, params.run);
+	}
+	async cleanupProcessTreeForRecord(handle, record) {
+		const leaseId = readOpenClawLeaseIdFromRecord(record);
+		const rootPid = readAgentPidFromRecord(record);
+		const sessionKeys = [handle.sessionKey, readSessionRecordName(record)];
+		const selectedLease = selectCurrentSessionLease({
+			leases: this.gatewayInstanceId && this.processLeaseStore ? await this.processLeaseStore.listOpen(this.gatewayInstanceId) : [],
+			sessionKeys,
+			rootPid
+		});
+		const loadedLease = leaseId ? await this.processLeaseStore?.load(leaseId) : void 0;
+		const lease = selectedLease ?? (loadedLease && loadedLease.gatewayInstanceId === this.gatewayInstanceId && (!rootPid || loadedLease.rootPid === rootPid) && sessionKeys.includes(loadedLease.sessionKey) ? loadedLease : void 0);
+		if (lease && lease.gatewayInstanceId === this.gatewayInstanceId && lease.rootPid > 0) {
+			await this.processLeaseStore?.markState(lease.leaseId, "closing");
+			const result = await cleanupOpenClawOwnedAcpxProcessTree({
+				rootPid: lease.rootPid,
+				rootCommand: readAgentCommandFromRecord(record),
+				expectedLeaseId: lease.leaseId,
+				expectedGatewayInstanceId: lease.gatewayInstanceId,
+				wrapperRoot: lease.wrapperRoot,
+				deps: this.processCleanupDeps
+			});
+			await this.processLeaseStore?.markState(lease.leaseId, result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
+			return;
+		}
+		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommandForName({
+			agentName: readAgentFromHandle(handle),
+			agentRegistry: this.agentRegistry
+		});
+		if (!rootPid || !rootCommand) return;
+		await cleanupOpenClawOwnedAcpxProcessTree({
+			rootPid,
+			rootCommand,
+			wrapperRoot: this.wrapperRoot,
+			deps: this.processCleanupDeps
+		});
+	}
 	isHealthy() {
 		return this.probeDelegate.isHealthy();
 	}
@@ -286,12 +463,30 @@ var AcpxRuntime = class {
 		});
 		const delegate = this.resolveDelegateForCommand(command);
 		const codexModelOverride = normalizeAgentName(input.agent) === CODEX_ACP_AGENT_ID && isCodexAcpCommand(command) ? normalizeCodexAcpModelOverride(input.model, input.thinking) : void 0;
-		if (!codexModelOverride) return delegate.ensureSession(input);
+		const stableLaunchCommand = codexModelOverride && command ? appendCodexAcpConfigOverrides(command, codexModelOverride) : command;
+		const shouldStartWithLease = !await this.canReuseStablePersistentSession({
+			sessionKey: input.sessionKey,
+			mode: input.mode,
+			cwd: input.cwd,
+			command: stableLaunchCommand,
+			resumeSessionId: input.resumeSessionId
+		});
+		if (!codexModelOverride) return await this.runWithLaunchLease({
+			sessionKey: input.sessionKey,
+			command: stableLaunchCommand,
+			enabled: shouldStartWithLease,
+			run: () => delegate.ensureSession(input)
+		});
 		const normalizedInput = {
 			...input,
 			...codexAcpSessionModelId(codexModelOverride) ? { model: codexAcpSessionModelId(codexModelOverride) } : {}
 		};
-		return this.codexAcpModelOverrideScope.run(codexModelOverride, () => delegate.ensureSession(normalizedInput));
+		return await this.runWithLaunchLease({
+			sessionKey: input.sessionKey,
+			command: stableLaunchCommand,
+			enabled: shouldStartWithLease,
+			run: () => this.codexAcpModelOverrideScope.run(codexModelOverride, () => delegate.ensureSession(normalizedInput))
+		});
 	}
 	async *runTurn(input) {
 		yield* (await this.resolveDelegateForHandle(input.handle)).runTurn(input);
@@ -332,18 +527,26 @@ var AcpxRuntime = class {
 		await delegate.setConfigOption(input);
 	}
 	async cancel(input) {
-		await (await this.resolveDelegateForHandle(input.handle)).cancel(input);
+		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+		await this.resolveDelegateForLoadedRecord(input.handle, record).cancel(input);
 	}
 	async prepareFreshSession(input) {
 		this.sessionStore.markFresh(input.sessionKey);
 	}
 	async close(input) {
-		await (await this.resolveDelegateForHandle(input.handle)).close({
-			handle: input.handle,
-			reason: input.reason,
-			discardPersistentState: input.discardPersistentState
-		});
-		if (input.discardPersistentState) this.sessionStore.markFresh(input.handle.sessionKey);
+		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+		let closeSucceeded = false;
+		try {
+			await this.resolveDelegateForLoadedRecord(input.handle, record).close({
+				handle: input.handle,
+				reason: input.reason,
+				discardPersistentState: input.discardPersistentState
+			});
+			closeSucceeded = true;
+		} finally {
+			await this.cleanupProcessTreeForRecord(input.handle, record);
+		}
+		if (closeSucceeded && input.discardPersistentState) this.sessionStore.markFresh(input.handle.sessionKey);
 	}
 };
 const __testing = {

package/dist/{service-DXpBsJTq.js → service-DzKX5ybC.js}

@@ -1,14 +1,146 @@
 import { registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "./runtime-api.js";
+import { a as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, i as OPENCLAW_ACPX_LEASE_ID_ARG, r as reapStaleOpenClawOwnedAcpxOrphans, s as createAcpxProcessLeaseStore, t as cleanupOpenClawOwnedAcpxProcessTree } from "./process-reaper-DKzgrZt9.js";
 import { createRequire } from "node:module";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
+import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
 import { inspect } from "node:util";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import fsSync from "node:fs";
-import path from "node:path";
+import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
 import { z } from "openclaw/plugin-sdk/zod";
+//#region extensions/acpx/src/codex-trust-config.ts
+function stripTomlComment(line) {
+	let quote = null;
+	let escaping = false;
+	for (let index = 0; index < line.length; index += 1) {
+		const ch = line[index];
+		if (escaping) {
+			escaping = false;
+			continue;
+		}
+		if (quote === "\"" && ch === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			if (ch === quote) quote = null;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			continue;
+		}
+		if (ch === "#") return line.slice(0, index);
+	}
+	return line;
+}
+function parseTomlString(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) try {
+		return JSON.parse(trimmed);
+	} catch {
+		return;
+	}
+	if (trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+}
+function parseTomlDottedKey(value) {
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let escaping = false;
+	for (const ch of value.trim()) {
+		if (escaping) {
+			current += ch;
+			escaping = false;
+			continue;
+		}
+		if (quote === "\"" && ch === "\\") {
+			current += ch;
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			current += ch;
+			if (ch === quote) quote = null;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			current += ch;
+			continue;
+		}
+		if (ch === ".") {
+			parts.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	if (current.trim()) parts.push(current.trim());
+	return parts.map((part) => parseTomlString(part) ?? part);
+}
+function parseProjectHeader(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]") || trimmed.startsWith("[[")) return;
+	const parts = parseTomlDottedKey(trimmed.slice(1, -1));
+	return parts.length === 2 && parts[0] === "projects" ? parts[1] : void 0;
+}
+function parseTrustedInlineProjectEntries(value) {
+	const trusted = [];
+	for (const match of value.matchAll(/(?<key>"(?:\\.|[^"\\])*"|'[^']*'|[A-Za-z0-9_\-/.~:]+)\s*=\s*\{(?<body>[^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g)) {
+		const key = match.groups?.key;
+		const body = match.groups?.body;
+		if (!key || !body || !/\btrust_level\s*=\s*["']trusted["']/.test(body)) continue;
+		const projectPath = parseTomlString(key) ?? key.trim();
+		if (projectPath) trusted.push(projectPath);
+	}
+	return trusted;
+}
+function extractTrustedCodexProjectPaths(configToml) {
+	const trusted = /* @__PURE__ */ new Set();
+	let currentProjectPath;
+	let inProjectsTable = false;
+	for (const rawLine of configToml.split(/\r?\n/)) {
+		const line = stripTomlComment(rawLine).trim();
+		if (!line) continue;
+		if (line.startsWith("[")) {
+			currentProjectPath = parseProjectHeader(line);
+			inProjectsTable = line === "[projects]";
+			continue;
+		}
+		if (currentProjectPath && /^trust_level\s*=\s*["']trusted["']\s*$/.test(line)) {
+			trusted.add(currentProjectPath);
+			continue;
+		}
+		const assignment = /^(?<key>"(?:\\.|[^"\\])*"|'[^']*'|[A-Za-z0-9_\-/.~:]+)\s*=\s*(?<value>.+)$/.exec(line);
+		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;
+		}
+		if (key === "projects" || inProjectsTable) for (const projectPath of parseTrustedInlineProjectEntries(value)) trusted.add(projectPath);
+	}
+	return Array.from(trusted);
+}
+function renderIsolatedCodexProjectTrustConfig(projectPaths) {
+	return [
+		"# Generated by OpenClaw for Codex ACP sessions.",
+		...Array.from(new Set(projectPaths.map((projectPath) => projectPath.trim()).filter(Boolean).map((projectPath) => path.resolve(projectPath)))).toSorted((left, right) => left.localeCompare(right)).flatMap((projectPath) => [
+			"",
+			`[projects.${JSON.stringify(projectPath)}]`,
+			"trust_level = \"trusted\""
+		]),
+		""
+	].join("\n");
+}
+//#endregion
 //#region extensions/acpx/src/config-schema.ts
 const ACPX_PERMISSION_MODES = [
 	"approve-all",
@@ -34,7 +166,10 @@ const AcpxPluginConfigSchema = z.strictObject({
 	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") })).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
@@ -116,6 +251,10 @@ function resolveTsxImportSpecifier() {
 		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");
@@ -185,7 +324,12 @@ function resolveAcpxPluginConfig(params) {
 		openClawToolsMcpBridge,
 		moduleUrl: params.moduleUrl
 	});
-	const agents = Object.fromEntries(Object.entries(normalized.agents ?? {}).map(([name, entry]) => [normalizeLowercaseStringOrEmpty(name), entry.command.trim()]));
+	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,
@@ -276,7 +420,7 @@ function resolvePackageBinPath(packageJsonPath, manifest, binName) {
 async function resolveInstalledAcpPackageBinPath(packageName, binName) {
 	try {
 		const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
-		const manifest = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+		const { value: manifest } = await readJsonFileWithFallback(packageJsonPath, {});
 		if (manifest.name !== packageName) return;
 		const binPath = resolvePackageBinPath(packageJsonPath, manifest, binName);
 		if (!binPath) return;
@@ -300,7 +444,25 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 ${params.envSetup}
-const configuredArgs = process.argv.slice(2);
+const openClawWrapperArgs = new Set([
+  ${quoteCommandPart(OPENCLAW_ACPX_LEASE_ID_ARG)},
+  ${quoteCommandPart(OPENCLAW_GATEWAY_INSTANCE_ID_ARG)},
+]);
+
+function stripOpenClawWrapperArgs(args) {
+  const stripped = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (openClawWrapperArgs.has(value)) {
+      index += 1;
+      continue;
+    }
+    stripped.push(value);
+  }
+  return stripped;
+}
+
+const configuredArgs = stripOpenClawWrapperArgs(process.argv.slice(2));
 
 function resolveNpmCliPath() {
   const candidate = path.resolve(
@@ -342,23 +504,78 @@ if (!command) {
 }
 
 const child = spawn(command, args, {
+  detached: process.platform !== "win32",
   env,
   stdio: "inherit",
   windowsHide: true,
 });
 
+let forceKillTimer;
+let orphanCleanupStarted = false;
+
+function killChildTree(signal, options = {}) {
+  if (!child.pid || (!options.force && child.killed)) {
+    return;
+  }
+  if (process.platform !== "win32") {
+    try {
+      // The adapter can spawn grandchildren; signaling the process group keeps
+      // the generated wrapper from leaving an ACP tree behind.
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+      // Fall back to direct child signaling below.
+    }
+  }
+  child.kill(signal);
+}
+
 for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
   process.once(signal, () => {
-    child.kill(signal);
+    killChildTree(signal);
   });
 }
 
+const originalParentPid = process.ppid;
+const parentWatcher =
+  process.platform === "win32"
+    ? undefined
+    : setInterval(() => {
+        if (process.ppid === originalParentPid || process.ppid !== 1) {
+          return;
+        }
+        if (orphanCleanupStarted) {
+          return;
+        }
+        orphanCleanupStarted = true;
+        if (parentWatcher) {
+          clearInterval(parentWatcher);
+        }
+        killChildTree("SIGTERM");
+        // Keep the wrapper alive long enough for stubborn adapters to receive
+        // a forced fallback signal after SIGTERM.
+        forceKillTimer = setTimeout(() => {
+          killChildTree("SIGKILL", { force: true });
+          process.exit(1);
+        }, 1_500);
+      }, 1_000);
+parentWatcher?.unref?.();
+
 child.on("error", (error) => {
   console.error(\`[openclaw] failed to launch ${params.displayName} ACP wrapper: \${error.message}\`);
   process.exit(1);
 });
 
 child.on("exit", (code, signal) => {
+  if (parentWatcher) {
+    clearInterval(parentWatcher);
+  }
+  if (orphanCleanupStarted) {
+    return;
+  }
+  if (forceKillTimer) {
+    clearTimeout(forceKillTimer);
+  }
   if (code !== null) {
     process.exit(code);
   }
@@ -390,10 +607,20 @@ function buildClaudeAcpWrapperScript(installedBinPath) {
 };`
 	});
 }
-async function prepareIsolatedCodexHome(baseDir) {
-	const codexHome = path.join(baseDir, "codex-home");
+async function readSourceCodexConfig(codexHome) {
+	try {
+		return await fs.readFile(path.join(codexHome, "config.toml"), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+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.mkdir(codexHome, { recursive: true });
-	await fs.writeFile(path.join(codexHome, "config.toml"), "# Generated by OpenClaw for Codex ACP sessions.\n", "utf8");
+	await fs.writeFile(path.join(codexHome, "config.toml"), renderIsolatedCodexProjectTrustConfig(trustedProjectPaths), "utf8");
 	return codexHome;
 }
 async function makeGeneratedWrapperExecutableIfPossible(wrapperPath) {
@@ -471,7 +698,10 @@ function buildClaudeAcpWrapperCommand(wrapperPath, configuredCommand) {
 async function prepareAcpxCodexAuthConfig(params) {
 	params.logger;
 	const codexBaseDir = path.join(params.stateDir, "acpx");
-	await prepareIsolatedCodexHome(codexBaseDir);
+	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);
@@ -493,7 +723,7 @@ const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
 const ACPX_BACKEND_ID = "acpx";
 let runtimeModulePromise = null;
 function loadRuntimeModule() {
-	runtimeModulePromise ??= import("./runtime-B3LWev_t.js");
+	runtimeModulePromise ??= import("./runtime-QqpvXys6.js");
 	return runtimeModulePromise;
 }
 function createLazyDefaultRuntime(params) {
@@ -504,6 +734,9 @@ function createLazyDefaultRuntime(params) {
 		runtimePromise ??= loadRuntimeModule().then((module) => {
 			runtime = new module.AcpxRuntime({
 				cwd: params.pluginConfig.cwd,
+				openclawGatewayInstanceId: params.gatewayInstanceId,
+				openclawProcessLeaseStore: params.processLeaseStore,
+				openclawWrapperRoot: params.wrapperRoot,
 				sessionStore: module.createFileSessionStore({ stateDir: params.pluginConfig.stateDir }),
 				agentRegistry: module.createAgentRegistry({ overrides: params.pluginConfig.agents }),
 				probeAgent: params.pluginConfig.probeAgent,
@@ -603,6 +836,57 @@ function resolveAllowedAgentsProbeAgent(ctx) {
 function shouldRunStartupProbe(env = process.env) {
 	return env[ENABLE_STARTUP_PROBE_ENV] === "1";
 }
+async function resolveGatewayInstanceId(stateDir) {
+	const filePath = path.join(stateDir, "gateway-instance-id");
+	try {
+		const existing = (await fs.readFile(filePath, "utf8")).trim();
+		if (existing) return existing;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	const next = randomUUID();
+	await fs.mkdir(stateDir, { recursive: true });
+	await fs.writeFile(filePath, `${next}\n`, { mode: 384 });
+	return next;
+}
+async function reapOpenAcpxProcessLeases(params) {
+	const leases = await params.leaseStore.listOpen(params.gatewayInstanceId);
+	const inspectedPids = [];
+	const terminatedPids = [];
+	const pendingLeaseRootResults = /* @__PURE__ */ new Map();
+	for (const lease of leases) {
+		if (lease.rootPid <= 0) {
+			await params.leaseStore.markState(lease.leaseId, "closing");
+			let result = pendingLeaseRootResults.get(lease.wrapperRoot);
+			if (!result) {
+				result = await reapStaleOpenClawOwnedAcpxOrphans({
+					wrapperRoot: lease.wrapperRoot,
+					deps: params.deps
+				});
+				pendingLeaseRootResults.set(lease.wrapperRoot, result);
+				inspectedPids.push(...result.inspectedPids);
+				terminatedPids.push(...result.terminatedPids);
+			}
+			await params.leaseStore.markState(lease.leaseId, result.terminatedPids.length > 0 ? "closed" : "lost");
+			continue;
+		}
+		await params.leaseStore.markState(lease.leaseId, "closing");
+		const result = await cleanupOpenClawOwnedAcpxProcessTree({
+			rootPid: lease.rootPid,
+			expectedLeaseId: lease.leaseId,
+			expectedGatewayInstanceId: lease.gatewayInstanceId,
+			wrapperRoot: lease.wrapperRoot,
+			deps: params.deps
+		});
+		inspectedPids.push(...result.inspectedPids);
+		terminatedPids.push(...result.terminatedPids);
+		await params.leaseStore.markState(lease.leaseId, result.terminatedPids.length > 0 ? "closed" : "lost");
+	}
+	return {
+		inspectedPids,
+		terminatedPids
+	};
+}
 function createAcpxRuntimeService(params = {}) {
 	let runtime = null;
 	let lifecycleRevision = 0;
@@ -625,16 +909,32 @@ function createAcpxRuntimeService(params = {}) {
 				stateDir: ctx.stateDir,
 				logger: ctx.logger
 			});
+			const wrapperRoot = path.join(ctx.stateDir, "acpx");
 			await fs.mkdir(pluginConfig.stateDir, { recursive: true });
+			await fs.mkdir(wrapperRoot, { recursive: true });
+			const gatewayInstanceId = await resolveGatewayInstanceId(ctx.stateDir);
+			const processLeaseStore = createAcpxProcessLeaseStore({ stateDir: wrapperRoot });
+			const startupReap = await reapOpenAcpxProcessLeases({
+				gatewayInstanceId,
+				leaseStore: processLeaseStore,
+				deps: params.processCleanupDeps
+			});
+			if (startupReap.terminatedPids.length > 0) ctx.logger.info(`reaped ${startupReap.terminatedPids.length} stale OpenClaw-owned ACPX process${startupReap.terminatedPids.length === 1 ? "" : "es"}`);
 			warnOnIgnoredLegacyCompatibilityConfig({
 				pluginConfig,
 				logger: ctx.logger
 			});
 			runtime = params.runtimeFactory ? await params.runtimeFactory({
 				pluginConfig,
+				gatewayInstanceId,
+				processLeaseStore,
+				wrapperRoot,
 				logger: ctx.logger
 			}) : createLazyDefaultRuntime({
 				pluginConfig,
+				gatewayInstanceId,
+				processLeaseStore,
+				wrapperRoot,
 				logger: ctx.logger
 			});
 			registerAcpRuntimeBackend({

package/openclaw.plugin.json

@@ -85,6 +85,10 @@
             "command": {
               "type": "string",
               "minLength": 1
+            },
+            "args": {
+              "type": "array",
+              "items": { "type": "string" }
             }
           },
           "required": ["command"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/acpx",
-  "version": "2026.5.7",
+  "version": "2026.5.9-beta.1",
   "description": "OpenClaw ACP runtime backend",
   "repository": {
     "type": "git",
@@ -10,7 +10,7 @@
   "dependencies": {
     "@agentclientprotocol/claude-agent-acp": "0.32.0",
     "@zed-industries/codex-acp": "0.13.0",
-    "acpx": "0.6.1"
+    "acpx": "0.7.0"
   },
   "devDependencies": {
     "@openclaw/plugin-sdk": "workspace:*"
@@ -25,10 +25,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.5.7"
+      "pluginApi": ">=2026.5.9-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.7",
+      "openclawVersion": "2026.5.9-beta.1",
       "staticAssets": [
         {
           "source": "./src/runtime-internals/mcp-proxy.mjs",
@@ -58,7 +58,7 @@
     "skills/**"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.7"
+    "openclaw": ">=2026.5.9-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {