@openclaw/acpx 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/{process-reaper-BIOtp_Ek.js → process-reaper-DFwbcdPa.js}

@@ -1,5 +1,5 @@
 import { t as AcpxPluginConfigSchema } from "./config-schema-lrk5nlcV.js";
-import "./process-lease-CU1cFI4I.js";
+import { _ as splitCommandParts } from "./process-lease-DSLDgiNl.js";
 import { createRequire } from "node:module";
 import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -13,54 +13,6 @@ const CODEX_ACP_BIN = "codex-acp";
 const LEGACY_CODEX_ACP_PACKAGE = "@zed-industries/codex-acp";
 const OPENCLAW_CODEX_CONFIG_ARG = "--openclaw-codex-config";
 //#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.ts
 /**
 * Resolves ACPX plugin config from raw user configuration. It locates the
@@ -439,7 +391,11 @@ async function cleanupOpenClawOwnedAcpxProcessTree(params) {
 	try {
 		processes = await (params.deps?.listProcesses ?? listPlatformProcesses)();
 	} catch {
-		processes = [];
+		return {
+			inspectedPids: [],
+			terminatedPids: [],
+			skippedReason: "process-list-unavailable"
+		};
 	}
 	const listedTree = collectProcessTree(processes, rootPid);
 	if (listedTree.length === 0) return {
@@ -510,4 +466,4 @@ async function reapStaleOpenClawOwnedAcpxOrphans(params) {
 	};
 }
 //#endregion
-export { resolveAcpxPluginRoot as a, splitCommandParts as c, LEGACY_CODEX_ACP_PACKAGE as d, OPENCLAW_CODEX_CONFIG_ARG as f, resolveAcpxPluginConfig as i, CODEX_ACP_BIN as l, isOpenClawLeaseAwareAcpxProcessCommand as n, toAcpMcpServers as o, reapStaleOpenClawOwnedAcpxOrphans as r, quoteCommandPart as s, cleanupOpenClawOwnedAcpxProcessTree as t, CODEX_ACP_PACKAGE as u };
+export { resolveAcpxPluginRoot as a, CODEX_ACP_PACKAGE as c, resolveAcpxPluginConfig as i, LEGACY_CODEX_ACP_PACKAGE as l, isOpenClawLeaseAwareAcpxProcessCommand as n, toAcpMcpServers as o, reapStaleOpenClawOwnedAcpxOrphans as r, CODEX_ACP_BIN as s, cleanupOpenClawOwnedAcpxProcessTree as t, OPENCLAW_CODEX_CONFIG_ARG as u };

package/dist/{register.runtime-Dajn8myc.js → register.runtime-BbS2JTTv.js}

@@ -200,7 +200,7 @@ function createLazyAcpRuntimeProxy(resolveRuntime) {
 * immediately, then imports the heavier service only when a session needs it.
 */
 const ACPX_BACKEND_ID = "acpx";
-const loadServiceModule = createLazyRuntimeModule(() => import("./service-DOsKw_R1.js"));
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-CBZSAymH.js"));
 async function startRealService(state) {
 	if (state.realRuntime) return state.realRuntime;
 	if (!state.ctx) throw new Error("ACPX runtime service is not started");

package/dist/register.runtime.js

@@ -1,2 +1,2 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-Dajn8myc.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-BbS2JTTv.js";
 export { createAcpxRuntimeService };

package/dist/{runtime-CN4JQkdV.js → runtime-By_lR8uk.js}

@@ -1,6 +1,6 @@
-import { a as hashAcpxProcessCommand, l as withAcpxLeaseEnvironment, r as createAcpxProcessLeaseId } from "./process-lease-CU1cFI4I.js";
+import { _ as splitCommandParts, a as hashAcpxProcessCommand, l as readAcpxProcessLeaseIdentity, r as createAcpxProcessLeaseId, u as withAcpxLeaseEnvironment } from "./process-lease-DSLDgiNl.js";
 import { AcpRuntimeError } from "./runtime-api.js";
-import { c as splitCommandParts, f as OPENCLAW_CODEX_CONFIG_ARG, n as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxProcessTree, u as CODEX_ACP_PACKAGE } from "./process-reaper-BIOtp_Ek.js";
+import { c as CODEX_ACP_PACKAGE, n as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxProcessTree, u as OPENCLAW_CODEX_CONFIG_ARG } from "./process-reaper-DFwbcdPa.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -128,29 +128,42 @@ function createResetAwareSessionStore(baseStore, params) {
 			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 = withOpenClawLeaseSessionMetadata({
-					...record,
-					agentCommand: stableAgentCommand
-				}, {
-					openclawLeaseId: launch.leaseId,
-					openclawGatewayInstanceId: launch.gatewayInstanceId
-				});
+			const leasedCommand = launch?.leasedCommand ?? agentCommand;
+			const leaseIdentity = launch ?? readAcpxProcessLeaseIdentity(leasedCommand);
+			if (params?.leaseStore && params.gatewayInstanceId && params.wrapperRoot && (!launch || sessionName === launch.sessionKey) && leasedCommand && leaseIdentity?.gatewayInstanceId === params.gatewayInstanceId && isOpenClawLeaseAwareAcpxProcessCommand({
+				command: leasedCommand,
+				wrapperRoot: params.wrapperRoot
+			})) {
+				const existing = await params.leaseStore.load(leaseIdentity.leaseId);
+				if (!existing || existing.gatewayInstanceId === leaseIdentity.gatewayInstanceId && existing.sessionKey === sessionName && existing.wrapperRoot === params.wrapperRoot) {
+					const lifecycleRecord = Boolean(launch && launch.resolvedCommand !== launch.leasedCommand) ? {
+						...record,
+						pid: void 0,
+						processId: void 0,
+						agentStartedAt: void 0
+					} : record;
+					const rootPid = readRecordAgentPid(lifecycleRecord);
+					if (rootPid) await params.leaseStore.save({
+						leaseId: leaseIdentity.leaseId,
+						gatewayInstanceId: leaseIdentity.gatewayInstanceId,
+						sessionKey: sessionName,
+						wrapperRoot: params.wrapperRoot,
+						wrapperPath: extractGeneratedWrapperPath(leasedCommand),
+						rootPid,
+						...existing?.rootPid === rootPid && existing.processGroupId ? { processGroupId: existing.processGroupId } : {},
+						commandHash: hashAcpxProcessCommand(leasedCommand),
+						startedAt: existing?.rootPid === rootPid ? existing.startedAt : Date.now(),
+						state: "open"
+					});
+					recordToSave = withOpenClawLeaseSessionMetadata({
+						...lifecycleRecord,
+						agentCommand: leasedCommand
+					}, {
+						openclawLeaseId: leaseIdentity.leaseId,
+						openclawGatewayInstanceId: leaseIdentity.gatewayInstanceId
+					});
+				}
 			}
 			await baseStore.save(recordToSave);
 			if (sessionName) freshSessionKeys.delete(sessionName);
@@ -362,6 +375,9 @@ function quoteShellArg(value) {
 	if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) return value;
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
+function normalizeAgentCommand(command) {
+	return (Array.isArray(command) ? command.map((part) => quoteShellArg(part)).join(" ") : command).trim() || void 0;
+}
 function appendCodexAcpConfigOverrides(command, override) {
 	const config = {
 		...override.model ? { model: override.model } : {},
@@ -373,7 +389,7 @@ function appendCodexAcpConfigOverrides(command, override) {
 function createModelScopedAgentRegistry(params) {
 	return {
 		resolve(agentName) {
-			const command = params.agentRegistry.resolve(agentName);
+			const command = normalizeAgentCommand(params.agentRegistry.resolve(agentName)) ?? "";
 			const override = params.scope.getStore();
 			if (!override || normalizeAgentName(agentName) !== CODEX_ACP_AGENT_ID || !isCodexAcpCommand(command)) return params.leaseCommand(command);
 			return params.leaseCommand(appendCodexAcpConfigOverrides(command, override));
@@ -386,8 +402,7 @@ function createModelScopedAgentRegistry(params) {
 function resolveAgentCommand(params) {
 	const normalizedAgentName = normalizeAgentName(params.agentName);
 	if (!normalizedAgentName) return;
-	const resolvedCommand = params.agentRegistry.resolve(normalizedAgentName);
-	return typeof resolvedCommand === "string" ? resolvedCommand.trim() || void 0 : void 0;
+	return normalizeAgentCommand(params.agentRegistry.resolve(normalizedAgentName));
 }
 function shouldUseBridgeSafeDelegateForCommand(command) {
 	return isOpenClawBridgeCommand(command);
@@ -422,6 +437,9 @@ var AcpxRuntime = class {
 		this.codexAcpModelOverrideScope = new AsyncLocalStorage();
 		this.managedToolsSessionDelegates = /* @__PURE__ */ new Map();
 		this.launchLeaseScope = new AsyncLocalStorage();
+		this.ensureSessionTails = /* @__PURE__ */ new Map();
+		this.processLeaseTransitionTails = /* @__PURE__ */ new Map();
+		this.processLeaseOperationCounts = /* @__PURE__ */ new Map();
 		const { openclawProcessCleanup, ...delegateTestOptions } = testOptions ?? {};
 		this.processCleanupDeps = openclawProcessCleanup;
 		this.wrapperRoot = options.openclawWrapperRoot;
@@ -434,7 +452,8 @@ var AcpxRuntime = class {
 		this.sessionStore = createResetAwareSessionStore(options.sessionStore, {
 			gatewayInstanceId: this.gatewayInstanceId,
 			leaseStore: this.processLeaseStore,
-			launchScope: this.launchLeaseScope
+			launchScope: this.launchLeaseScope,
+			wrapperRoot: this.wrapperRoot
 		});
 		this.agentRegistry = options.agentRegistry;
 		this.scopedAgentRegistry = createModelScopedAgentRegistry({
@@ -519,47 +538,206 @@ var AcpxRuntime = class {
 	commandWithLaunchLease(command) {
 		const launch = this.launchLeaseScope.getStore();
 		if (!launch) return command;
-		launch.stableCommand = command;
+		if (command === launch.stableCommand) return launch.resolvedCommand;
 		return withAcpxLeaseEnvironment({
 			command,
 			leaseId: launch.leaseId,
 			gatewayInstanceId: launch.gatewayInstanceId
 		});
 	}
-	async canReuseStablePersistentSession(params) {
-		if (params.mode !== "persistent" || !params.command) return false;
+	async readReusablePersistentSessionCommand(params) {
+		if (params.mode !== "persistent" || !params.command) return;
 		const existing = await this.sessionStore.load(params.sessionKey);
-		if (!existing || readRecordResetOnNextEnsure(existing)) return false;
+		if (!existing || readRecordResetOnNextEnsure(existing)) return;
 		const recordCwd = readRecordCwd(existing);
-		if (!recordCwd || resolve(recordCwd) !== resolve(params.cwd?.trim() || this.cwd)) return false;
-		if (readRecordAgentCommand(existing) !== params.command) return false;
+		if (!recordCwd || resolve(recordCwd) !== resolve(params.cwd?.trim() || this.cwd)) return;
+		const recordCommand = readRecordAgentCommand(existing);
+		if (!recordCommand) return;
+		const leaseIdentity = readAcpxProcessLeaseIdentity(recordCommand);
+		if (leaseIdentity && leaseIdentity.gatewayInstanceId !== this.gatewayInstanceId) return;
+		if (recordCommand !== (leaseIdentity ? withAcpxLeaseEnvironment({
+			command: params.command,
+			leaseId: leaseIdentity.leaseId,
+			gatewayInstanceId: leaseIdentity.gatewayInstanceId
+		}) : params.command)) return;
 		const existingSessionId = typeof existing === "object" && existing !== null ? existing.acpSessionId : void 0;
-		return !params.resumeSessionId || existingSessionId === params.resumeSessionId;
+		return !params.resumeSessionId || existingSessionId === params.resumeSessionId ? recordCommand : void 0;
 	}
 	async runWithLaunchLease(params) {
-		if (params.enabled === false || !params.command || !this.wrapperRoot || !this.gatewayInstanceId || !this.processLeaseStore || !isOpenClawLeaseAwareAcpxProcessCommand({
+		if (!params.command || !this.wrapperRoot || !this.gatewayInstanceId || !this.processLeaseStore || !isOpenClawLeaseAwareAcpxProcessCommand({
 			command: params.command,
 			wrapperRoot: this.wrapperRoot
 		})) return await params.run();
+		const processLeaseStore = this.processLeaseStore;
+		const reusableIdentity = readAcpxProcessLeaseIdentity(params.reusableCommand);
+		const canReuseLeaseIdentity = reusableIdentity?.gatewayInstanceId === this.gatewayInstanceId;
+		const leaseId = canReuseLeaseIdentity ? reusableIdentity.leaseId : createAcpxProcessLeaseId();
+		const leasedCommand = withAcpxLeaseEnvironment({
+			command: params.command,
+			leaseId,
+			gatewayInstanceId: this.gatewayInstanceId
+		});
 		const launch = {
-			leaseId: createAcpxProcessLeaseId(),
+			leaseId,
 			gatewayInstanceId: this.gatewayInstanceId,
 			sessionKey: params.sessionKey,
 			wrapperRoot: this.wrapperRoot,
-			stableCommand: params.command
+			stableCommand: params.command,
+			resolvedCommand: params.reusableCommand ?? leasedCommand,
+			leasedCommand
 		};
-		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"
+		await this.retainProcessLeaseOperation(launch, async () => {
+			const reusableLease = canReuseLeaseIdentity ? await processLeaseStore.load(launch.leaseId) : void 0;
+			if (reusableLease && (reusableLease.gatewayInstanceId !== launch.gatewayInstanceId || reusableLease.sessionKey !== launch.sessionKey || reusableLease.wrapperRoot !== launch.wrapperRoot)) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", `ACPX process lease ${launch.leaseId} belongs to another session`);
+			if (!(!reusableLease && (!params.reusableCommand || params.reusableCommand === leasedCommand))) return;
+			await processLeaseStore.save({
+				leaseId: launch.leaseId,
+				gatewayInstanceId: launch.gatewayInstanceId,
+				sessionKey: launch.sessionKey,
+				wrapperRoot: launch.wrapperRoot,
+				wrapperPath: extractGeneratedWrapperPath(leasedCommand),
+				rootPid: 0,
+				commandHash: hashAcpxProcessCommand(leasedCommand),
+				startedAt: Date.now(),
+				state: "open"
+			});
+		});
+		try {
+			const result = await this.launchLeaseScope.run(launch, params.run);
+			await this.finalizeProcessLeaseForSession(params.sessionKey, launch);
+			return result;
+		} catch (error) {
+			await this.retirePendingProcessLease(launch);
+			throw error;
+		}
+	}
+	async prepareProcessLeaseForOperation(handle) {
+		if (!this.processLeaseStore || !this.gatewayInstanceId || !this.wrapperRoot) return;
+		const processLeaseStore = this.processLeaseStore;
+		const wrapperRoot = this.wrapperRoot;
+		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
+		const recordPid = readRecordAgentPid(record);
+		const command = readAgentCommandFromRecord(record);
+		const identity = readAcpxProcessLeaseIdentity(command);
+		if (!command || !isOpenClawLeaseAwareAcpxProcessCommand({
+			command,
+			wrapperRoot
+		})) return;
+		if (!identity) return;
+		if (identity.gatewayInstanceId !== this.gatewayInstanceId) throw new AcpRuntimeError("ACP_TURN_FAILED", `ACPX process lease ${identity.leaseId} belongs to another gateway`);
+		await this.retainProcessLeaseOperation(identity, async () => {
+			const existing = await processLeaseStore.load(identity.leaseId);
+			if (!existing) {
+				await processLeaseStore.save({
+					leaseId: identity.leaseId,
+					gatewayInstanceId: identity.gatewayInstanceId,
+					sessionKey: handle.sessionKey,
+					wrapperRoot,
+					wrapperPath: extractGeneratedWrapperPath(command),
+					rootPid: recordPid ?? 0,
+					commandHash: hashAcpxProcessCommand(command),
+					startedAt: Date.now(),
+					state: "open"
+				});
+				return;
+			}
+			if (existing.gatewayInstanceId !== identity.gatewayInstanceId || existing.sessionKey !== handle.sessionKey || existing.wrapperRoot !== wrapperRoot) throw new AcpRuntimeError("ACP_TURN_FAILED", `ACPX process lease ${identity.leaseId} belongs to another session`);
 		});
-		return await this.launchLeaseScope.run(launch, params.run);
+		return identity;
+	}
+	async runSerializedProcessLeaseTransition(leaseId, run) {
+		const previous = this.processLeaseTransitionTails.get(leaseId) ?? Promise.resolve();
+		let release;
+		const current = new Promise((resolve) => {
+			release = resolve;
+		});
+		const tail = previous.then(() => current);
+		this.processLeaseTransitionTails.set(leaseId, tail);
+		await previous;
+		try {
+			return await run();
+		} finally {
+			release();
+			if (this.processLeaseTransitionTails.get(leaseId) === tail) this.processLeaseTransitionTails.delete(leaseId);
+		}
+	}
+	async retainProcessLeaseOperation(identity, prepare) {
+		await this.runSerializedProcessLeaseTransition(identity.leaseId, async () => {
+			await prepare();
+			this.processLeaseOperationCounts.set(identity.leaseId, (this.processLeaseOperationCounts.get(identity.leaseId) ?? 0) + 1);
+		});
+	}
+	async releaseProcessLeaseOperation(identity, finalize) {
+		if (!identity) return;
+		await this.runSerializedProcessLeaseTransition(identity.leaseId, async () => {
+			const count = this.processLeaseOperationCounts.get(identity.leaseId) ?? 0;
+			if (count > 1) {
+				this.processLeaseOperationCounts.set(identity.leaseId, count - 1);
+				return;
+			}
+			if (count === 0) return;
+			this.processLeaseOperationCounts.delete(identity.leaseId);
+			await finalize();
+		});
+	}
+	async finalizeProcessLeaseForOperation(handle, identity) {
+		await this.finalizeProcessLeaseForSession(handle.acpxRecordId ?? handle.sessionKey, identity);
+	}
+	async finalizeProcessLeaseForSession(sessionId, identity) {
+		if (!identity || !this.processLeaseStore) return;
+		const processLeaseStore = this.processLeaseStore;
+		await this.releaseProcessLeaseOperation(identity, async () => {
+			const lease = await processLeaseStore.load(identity.leaseId);
+			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId) return;
+			if (lease.rootPid <= 0) {
+				await processLeaseStore.markState(identity.leaseId, "lost");
+				return;
+			}
+			try {
+				const recordIdentity = readAcpxProcessLeaseIdentity(readAgentCommandFromRecord(await this.sessionStore.load(sessionId)));
+				if (recordIdentity?.leaseId !== identity.leaseId || recordIdentity.gatewayInstanceId !== identity.gatewayInstanceId) await processLeaseStore.markState(identity.leaseId, "lost");
+			} catch {}
+		});
+	}
+	async retirePendingProcessLease(identity) {
+		if (!identity || !this.processLeaseStore) return;
+		const processLeaseStore = this.processLeaseStore;
+		await this.releaseProcessLeaseOperation(identity, async () => {
+			const lease = await processLeaseStore.load(identity.leaseId);
+			if (lease?.gatewayInstanceId === identity.gatewayInstanceId && lease.rootPid <= 0) await processLeaseStore.markState(identity.leaseId, "lost");
+		});
+	}
+	async runWithProcessLeaseForHandle(handle, run) {
+		const identity = await this.prepareProcessLeaseForOperation(handle);
+		try {
+			return await run();
+		} finally {
+			await this.finalizeProcessLeaseForOperation(handle, identity);
+		}
+	}
+	async finalizeProcessLeaseAfter(handle, identityPromise, resultPromise) {
+		try {
+			return await resultPromise;
+		} finally {
+			await this.finalizeProcessLeaseForOperation(handle, await identityPromise);
+		}
+	}
+	async runSerializedSessionEnsure(sessionKey, run) {
+		const key = sessionKey.trim() || sessionKey;
+		const previous = this.ensureSessionTails.get(key) ?? Promise.resolve();
+		let release;
+		const current = new Promise((resolve) => {
+			release = resolve;
+		});
+		const tail = previous.then(() => current);
+		this.ensureSessionTails.set(key, tail);
+		await previous;
+		try {
+			return await run();
+		} finally {
+			release();
+			if (this.ensureSessionTails.get(key) === tail) this.ensureSessionTails.delete(key);
+		}
 	}
 	async withCodexWrapperDiagnostics(params) {
 		try {
@@ -602,7 +780,7 @@ var AcpxRuntime = class {
 				wrapperRoot: lease.wrapperRoot,
 				deps: this.processCleanupDeps
 			});
-			await this.processLeaseStore?.markState(lease.leaseId, result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
+			await this.processLeaseStore?.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" ? "open" : result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
 			return;
 		}
 		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommand({
@@ -630,6 +808,9 @@ var AcpxRuntime = class {
 		return this.probeDelegate.doctor();
 	}
 	async ensureSession(input) {
+		return await this.runSerializedSessionEnsure(input.sessionKey, () => this.ensureSessionUnlocked(input));
+	}
+	async ensureSessionUnlocked(input) {
 		assertSupportedRuntimeSessionMode(input.mode);
 		const command = resolveAgentCommand({
 			agentName: input.agent,
@@ -655,7 +836,7 @@ var AcpxRuntime = class {
 			model: claudeModelOverride
 		} : input;
 		const stableLaunchCommand = codexModelOverride && command ? appendCodexAcpConfigOverrides(command, codexModelOverride) : command;
-		const shouldStartWithLease = !await this.canReuseStablePersistentSession({
+		const reusableCommand = await this.readReusablePersistentSessionCommand({
 			sessionKey: input.sessionKey,
 			mode: input.mode,
 			cwd: input.cwd,
@@ -665,7 +846,7 @@ var AcpxRuntime = class {
 		const handle = !codexModelOverride ? await this.runWithLaunchLease({
 			sessionKey: ensureInput.sessionKey,
 			command: stableLaunchCommand,
-			enabled: shouldStartWithLease,
+			reusableCommand,
 			run: () => this.withCodexWrapperDiagnostics({
 				command: stableLaunchCommand,
 				fallbackCode: "ACP_SESSION_INIT_FAILED",
@@ -674,7 +855,7 @@ var AcpxRuntime = class {
 		}) : await this.runWithLaunchLease({
 			sessionKey: input.sessionKey,
 			command: stableLaunchCommand,
-			enabled: shouldStartWithLease,
+			reusableCommand,
 			run: () => this.codexAcpModelOverrideScope.run(codexModelOverride, () => this.withCodexWrapperDiagnostics({
 				command: stableLaunchCommand,
 				fallbackCode: "ACP_SESSION_INIT_FAILED",
@@ -687,9 +868,11 @@ var AcpxRuntime = class {
 		} : handle;
 	}
 	async *runTurn(input) {
-		const command = await this.resolveCommandForHandle(input.handle);
-		const delegate = await this.resolveDelegateForHandle(input.handle);
+		const turnLease = await this.prepareProcessLeaseForOperation(input.handle);
+		let command;
 		try {
+			command = await this.resolveCommandForHandle(input.handle);
+			const delegate = await this.resolveDelegateForHandle(input.handle);
 			for await (const event of delegate.runTurn(withOpenClawManagedTurnTimeout(input))) {
 				if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
 					yield event;
@@ -711,11 +894,18 @@ var AcpxRuntime = class {
 			const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
 			if (!stderrTail) throw error;
 			throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
+		} finally {
+			await this.finalizeProcessLeaseForOperation(input.handle, turnLease);
 		}
 	}
 	startTurn(input) {
 		const readCodexTurnFailureStderr = () => this.readCodexTurnFailureStderr({ handle: input.handle });
-		const turnPromise = Promise.all([this.resolveCommandForHandle(input.handle), this.resolveDelegateForHandle(input.handle)]).then(async ([command, delegate]) => {
+		const turnLeasePromise = this.prepareProcessLeaseForOperation(input.handle);
+		const turnPromise = Promise.all([
+			turnLeasePromise,
+			this.resolveCommandForHandle(input.handle),
+			this.resolveDelegateForHandle(input.handle)
+		]).then(async ([, command, delegate]) => {
 			try {
 				return {
 					command,
@@ -756,7 +946,7 @@ var AcpxRuntime = class {
 					throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
 				}
 			} },
-			result: turnPromise.then(async ({ command, turn }) => {
+			result: this.finalizeProcessLeaseAfter(input.handle, turnLeasePromise, turnPromise.then(async ({ command, turn }) => {
 				try {
 					const result = await turn.result;
 					if (result.status !== "failed" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(result.error.message)) return result;
@@ -776,7 +966,7 @@ var AcpxRuntime = class {
 					if (!stderrTail) throw error;
 					throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
 				}
-			}),
+			})),
 			cancel(inputArgs) {
 				return turnPromise.then(({ turn }) => turn.cancel(inputArgs));
 			},
@@ -792,9 +982,13 @@ var AcpxRuntime = class {
 		return (await this.resolveDelegateForHandle(input.handle)).getStatus(input);
 	}
 	async setMode(input) {
-		await (await this.resolveDelegateForHandle(input.handle)).setMode(input);
+		const delegate = await this.resolveDelegateForHandle(input.handle);
+		await this.runWithProcessLeaseForHandle(input.handle, () => delegate.setMode(input));
 	}
 	async setConfigOption(input) {
+		await this.runWithProcessLeaseForHandle(input.handle, () => this.setConfigOptionUnlocked(input));
+	}
+	async setConfigOptionUnlocked(input) {
 		const delegate = await this.resolveDelegateForHandle(input.handle);
 		const command = await this.resolveCommandForHandle(input.handle);
 		const key = input.key.trim().toLowerCase();
@@ -846,21 +1040,29 @@ var AcpxRuntime = class {
 		this.sessionStore.markFresh(input.sessionKey);
 	}
 	async close(input) {
-		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
-		let closeSucceeded;
-		const delegate = this.resolveDelegateForLoadedRecord(input.handle, record);
+		const closeLease = await this.prepareProcessLeaseForOperation(input.handle);
+		let cleanupSucceeded = false;
 		try {
-			await delegate.close({
-				handle: input.handle,
-				reason: input.reason,
-				discardPersistentState: input.discardPersistentState
-			});
-			closeSucceeded = true;
+			const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+			let closeSucceeded;
+			const delegate = this.resolveDelegateForLoadedRecord(input.handle, record);
+			try {
+				await delegate.close({
+					handle: input.handle,
+					reason: input.reason,
+					discardPersistentState: input.discardPersistentState
+				});
+				closeSucceeded = true;
+			} finally {
+				await this.cleanupProcessTreeForRecord(input.handle, record);
+				cleanupSucceeded = true;
+			}
+			if (closeSucceeded) this.releaseManagedToolsDelegateForSession(input.handle.sessionKey);
+			if (closeSucceeded && input.discardPersistentState) this.sessionStore.markFresh(input.handle.sessionKey);
 		} finally {
-			await this.cleanupProcessTreeForRecord(input.handle, record);
+			if (cleanupSucceeded) await this.finalizeProcessLeaseForOperation(input.handle, closeLease);
+			else await this.retirePendingProcessLease(closeLease);
 		}
-		if (closeSucceeded) this.releaseManagedToolsDelegateForSession(input.handle.sessionKey);
-		if (closeSucceeded && input.discardPersistentState) this.sessionStore.markFresh(input.handle.sessionKey);
 	}
 };
 /** Test-only hooks for ACPX runtime behavior that is otherwise private. */
@@ -870,6 +1072,7 @@ const testing = {
 	classifyCodexAcpModelRequest,
 	isClaudeAcpCommand,
 	isCodexAcpCommand,
+	normalizeAgentCommand,
 	normalizeClaudeAcpModelOverride
 };
 //#endregion

package/dist/{service-DOsKw_R1.js → service-CBZSAymH.js}

@@ -1,8 +1,8 @@
-import { n as createLazyAcpRuntimeProxy } from "./register.runtime-Dajn8myc.js";
+import { n as createLazyAcpRuntimeProxy } from "./register.runtime-BbS2JTTv.js";
 import "./config-schema-lrk5nlcV.js";
-import { c as openAcpxProcessLeaseStateStore, d as ACPX_GATEWAY_INSTANCE_NAMESPACE, i as createAcpxProcessLeaseStore, m as normalizeAcpxGatewayInstanceRecord, n as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, t as OPENCLAW_ACPX_LEASE_ID_ARG, u as ACPX_GATEWAY_INSTANCE_KEY } from "./process-lease-CU1cFI4I.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 splitCommandParts, d as LEGACY_CODEX_ACP_PACKAGE, f as OPENCLAW_CODEX_CONFIG_ARG, i as resolveAcpxPluginConfig, l as CODEX_ACP_BIN, o as toAcpMcpServers, r as reapStaleOpenClawOwnedAcpxOrphans, s as quoteCommandPart, t as cleanupOpenClawOwnedAcpxProcessTree, u as CODEX_ACP_PACKAGE } from "./process-reaper-BIOtp_Ek.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 { createRequire } from "node:module";
 import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
@@ -1026,7 +1026,7 @@ async function prepareAcpxCodexAuthConfig(params) {
 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-CN4JQkdV.js"));
+const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-By_lR8uk.js"));
 /** Convert ACPX timeout seconds into timer-safe milliseconds. */
 function resolveAcpxTimerTimeoutMs(timeoutSeconds) {
 	if (timeoutSeconds === void 0) return;
@@ -1179,7 +1179,7 @@ async function reapOpenAcpxProcessLeases(params) {
 		});
 		inspectedPids.push(...result.inspectedPids);
 		terminatedPids.push(...result.terminatedPids);
-		await params.leaseStore.markState(lease.leaseId, result.terminatedPids.length > 0 ? "closed" : "lost");
+		await params.leaseStore.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" ? "open" : result.terminatedPids.length > 0 ? "closed" : "lost");
 	}
 	return {
 		inspectedPids,