@openclaw/acpx 2026.7.2-beta.5 → 2026.8.1-beta.2

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

@@ -1,11 +1,11 @@
-import { a as hashAcpxProcessCommand, l as withAcpxLeaseEnvironment, r as createAcpxProcessLeaseId } from "./process-lease-CU1cFI4I.js";
+import { d as withAcpxLeaseEnvironment, i as createAcpxProcessLeaseId, o as hashAcpxProcessCommand, t as ACPX_PROBE_LEASE_SESSION_KEY, u as readAcpxProcessLeaseIdentity, v as splitCommandParts } from "./process-lease-Cwvj7WGe.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 { d as OPENCLAW_CODEX_CONFIG_ARG, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, r as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxPendingLease } from "./process-reaper-DzVuCxl3.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";
-import fs from "node:fs/promises";
 import path, { resolve } from "node:path";
+import fs from "node:fs/promises";
+import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isRequestedModelUnsupportedError } from "acpx/runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-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,10 @@ 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();
+		this.uncertainProcessLeaseIds = /* @__PURE__ */ new Set();
 		const { openclawProcessCleanup, ...delegateTestOptions } = testOptions ?? {};
 		this.processCleanupDeps = openclawProcessCleanup;
 		this.wrapperRoot = options.openclawWrapperRoot;
@@ -434,7 +453,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({
@@ -458,6 +478,7 @@ var AcpxRuntime = class {
 			agentName: normalizeAgentName(options.probeAgent) ?? "codex",
 			agentRegistry: this.agentRegistry
 		});
+		this.probeCommand = probeCommand;
 		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || shouldUseBridgeSafeDelegateForCommand(probeCommand);
 		this.probeDelegate = useBridgeSafeProbe ? this.bridgeSafeDelegate : this.delegate;
 	}
@@ -489,77 +510,244 @@ var AcpxRuntime = class {
 		if (!normalizedSessionKey) return;
 		this.managedToolsSessionDelegates.delete(normalizedSessionKey);
 	}
-	async resolveDelegateForHandle(handle) {
+	async loadOperationSnapshotForHandle(handle) {
 		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
-		return this.resolveDelegateForLoadedRecord(handle, record);
+		return {
+			record,
+			command: readAgentCommandFromRecord(record) ?? resolveAgentCommand({
+				agentName: readAgentFromHandle(handle),
+				agentRegistry: this.agentRegistry
+			})
+		};
 	}
-	resolveDelegateForLoadedRecord(handle, record) {
-		const recordCommand = readAgentCommandFromRecord(record);
-		if (recordCommand) return this.resolveDelegateForSession({
-			command: recordCommand,
-			sessionKey: handle.sessionKey
-		});
-		const command = resolveAgentCommand({
-			agentName: readAgentFromHandle(handle),
-			agentRegistry: this.agentRegistry
-		});
+	resolveDelegateForOperationSnapshot(handle, snapshot) {
 		return this.resolveDelegateForSession({
-			command,
+			command: snapshot.command,
 			sessionKey: handle.sessionKey
 		});
 	}
-	async resolveCommandForHandle(handle) {
-		const recordCommand = readAgentCommandFromRecord(await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey));
-		if (recordCommand) return recordCommand;
-		return resolveAgentCommand({
-			agentName: readAgentFromHandle(handle),
-			agentRegistry: this.agentRegistry
-		});
-	}
 	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 : params.finalizeCompletedProbe ? `probe-${hashAcpxProcessCommand(`${this.gatewayInstanceId}\0${extractGeneratedWrapperPath(params.command)}`)}` : 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);
+			if (params.finalizeCompletedProbe) await this.finalizeCompletedProbeLease(launch);
+			else await this.finalizeProcessLeaseForSession(params.sessionKey, launch);
+			return result;
+		} catch (error) {
+			await this.releaseProcessLeaseAfterUncertainFailure(launch);
+			throw error;
+		}
+	}
+	async prepareProcessLeaseForOperation(handle, record) {
+		if (!this.processLeaseStore || !this.gatewayInstanceId || !this.wrapperRoot) return;
+		const processLeaseStore = this.processLeaseStore;
+		const wrapperRoot = this.wrapperRoot;
+		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 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();
 		});
-		return await this.launchLeaseScope.run(launch, params.run);
+	}
+	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) {
+				if (this.uncertainProcessLeaseIds.has(identity.leaseId)) return;
+				await processLeaseStore.markState(identity.leaseId, "lost");
+				return;
+			}
+			this.uncertainProcessLeaseIds.delete(identity.leaseId);
+			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 finalizeCompletedProbeLease(identity) {
+		if (!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) return;
+			await cleanupOpenClawOwnedAcpxPendingLease({
+				leaseId: lease.leaseId,
+				gatewayInstanceId: lease.gatewayInstanceId,
+				wrapperRoot: lease.wrapperRoot,
+				wrapperPath: lease.wrapperPath,
+				deps: this.processCleanupDeps
+			});
+		});
+	}
+	async releaseProcessLeaseAfterUncertainFailure(identity) {
+		if (!identity || !this.processLeaseStore) return;
+		this.uncertainProcessLeaseIds.add(identity.leaseId);
+		const processLeaseStore = this.processLeaseStore;
+		await this.releaseProcessLeaseOperation(identity, async () => {
+			const lease = await processLeaseStore.load(identity.leaseId);
+			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId || lease.rootPid > 0) this.uncertainProcessLeaseIds.delete(identity.leaseId);
+		});
+	}
+	async runWithProcessLeaseForHandle(handle, record, run) {
+		const identity = await this.prepareProcessLeaseForOperation(handle, record);
+		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 +790,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" || result.skippedReason === "unsupported-platform" ? "open" : result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
 			return;
 		}
 		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommand({
@@ -623,13 +811,26 @@ var AcpxRuntime = class {
 	isHealthy() {
 		return this.probeDelegate.isHealthy();
 	}
-	probeAvailability() {
-		return this.probeDelegate.probeAvailability();
+	async probeAvailability() {
+		await this.runWithLaunchLease({
+			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
+			command: this.probeCommand,
+			finalizeCompletedProbe: true,
+			run: () => this.probeDelegate.probeAvailability()
+		});
 	}
-	doctor() {
-		return this.probeDelegate.doctor();
+	async doctor() {
+		return await this.runWithLaunchLease({
+			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
+			command: this.probeCommand,
+			finalizeCompletedProbe: true,
+			run: () => 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 +856,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 +866,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 +875,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 +888,12 @@ var AcpxRuntime = class {
 		} : handle;
 	}
 	async *runTurn(input) {
-		const command = await this.resolveCommandForHandle(input.handle);
-		const delegate = await this.resolveDelegateForHandle(input.handle);
+		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+		const turnLease = await this.prepareProcessLeaseForOperation(input.handle, record);
+		let command;
 		try {
+			command = (await this.loadOperationSnapshotForHandle(input.handle)).command;
+			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, await this.loadOperationSnapshotForHandle(input.handle));
 			for await (const event of delegate.runTurn(withOpenClawManagedTurnTimeout(input))) {
 				if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
 					yield event;
@@ -711,11 +915,17 @@ 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 snapshotPromise = this.loadOperationSnapshotForHandle(input.handle);
+		const turnLeasePromise = snapshotPromise.then(({ record }) => this.prepareProcessLeaseForOperation(input.handle, record));
+		const turnPromise = Promise.all([snapshotPromise, turnLeasePromise]).then(async ([snapshot]) => {
+			const { command } = snapshot;
+			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
 			try {
 				return {
 					command,
@@ -756,7 +966,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 +986,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));
 			},
@@ -789,14 +999,20 @@ var AcpxRuntime = class {
 		return this.delegate.getCapabilities(input);
 	}
 	async getStatus(input) {
-		return (await this.resolveDelegateForHandle(input.handle)).getStatus(input);
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		return this.resolveDelegateForOperationSnapshot(input.handle, snapshot).getStatus(input);
 	}
 	async setMode(input) {
-		await (await this.resolveDelegateForHandle(input.handle)).setMode(input);
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).setMode(input));
 	}
 	async setConfigOption(input) {
-		const delegate = await this.resolveDelegateForHandle(input.handle);
-		const command = await this.resolveCommandForHandle(input.handle);
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.setConfigOptionUnlocked(input, snapshot));
+	}
+	async setConfigOptionUnlocked(input, snapshot) {
+		const { command } = snapshot;
+		const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
 		const key = input.key.trim().toLowerCase();
 		const isCodexAcp = isCodexAcpCommand(command);
 		if (WIRE_TIMEOUT_CONFIG_KEYS.has(key) && (isCodexAcp || isClaudeAcpCommand(command))) return;
@@ -839,38 +1055,44 @@ var AcpxRuntime = class {
 		await delegate.setConfigOption(input);
 	}
 	async cancel(input) {
-		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
-		await this.resolveDelegateForLoadedRecord(input.handle, record).cancel(input);
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		await this.resolveDelegateForOperationSnapshot(input.handle, snapshot).cancel(input);
 	}
 	async prepareFreshSession(input) {
 		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 snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		const closeLease = await this.prepareProcessLeaseForOperation(input.handle, snapshot.record);
+		let cleanupSucceeded = false;
 		try {
-			await delegate.close({
-				handle: input.handle,
-				reason: input.reason,
-				discardPersistentState: input.discardPersistentState
-			});
-			closeSucceeded = true;
+			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
+			let closeSucceeded;
+			try {
+				await delegate.close({
+					handle: input.handle,
+					reason: input.reason,
+					discardPersistentState: input.discardPersistentState
+				});
+				closeSucceeded = true;
+			} finally {
+				await this.cleanupProcessTreeForRecord(input.handle, snapshot.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.releaseProcessLeaseAfterUncertainFailure(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. */
 const testing = {
 	appendCodexAcpConfigOverrides,
-	assertSupportedRuntimeSessionMode,
-	classifyCodexAcpModelRequest,
 	isClaudeAcpCommand,
 	isCodexAcpCommand,
-	normalizeClaudeAcpModelOverride
+	normalizeAgentCommand
 };
 //#endregion
-export { ACPX_BACKEND_ID, AcpxRuntime, testing as __testing, testing, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState };
+export { ACPX_BACKEND_ID, AcpxRuntime, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, testing };