@openclaw/acpx 2026.9.2 → 2026.9.3

package/dist/{runtime-memQfUBo.js → runtime-CSNBTQIs.js}

@@ -1,14 +1,17 @@
-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 { _ as splitCommandParts, a as hashAcpxProcessCommand, g as renderAgentCommand, l as readAcpxProcessLeaseIdentity, t as ACPX_PROBE_LEASE_SESSION_KEY, u as withAcpxLeaseArgs } from "./process-lease-B83BGiLj.js";
 import { AcpRuntimeError } from "./runtime-api.js";
 import { t as resolveAcpxSessionResource } from "./session-resource-UWe7qD3m.js";
-import { a as CODEX_ACP_PACKAGE, i as isOpenClawLeaseAwareAcpxProcessCommand, n as cleanupOpenClawOwnedAcpxPendingLease, o as OPENCLAW_CODEX_CONFIG_ARG, r as cleanupOpenClawOwnedAcpxProcessTree } from "./service-COMUTA5A.js";
+import { a as CODEX_ACP_PACKAGE, i as isOpenClawLeaseAwareAcpxProcessCommand, n as cleanupOpenClawOwnedAcpxPendingLease, o as OPENCLAW_CODEX_CONFIG_ARG, r as cleanupOpenClawOwnedAcpxProcessTree } from "./service-BAf6nuci.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path, { resolve } from "node:path";
 import fs from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { isDeepStrictEqual } from "node:util";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, decodeAcpxRuntimeHandleState as decodeAcpxRuntimeHandleState$1, encodeAcpxRuntimeHandleState, isRequestedModelUnsupportedError } from "acpx/runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/acpx/src/session-owner.ts
 function requireAcpxOwnerMigration(sessionKey) {
@@ -48,17 +51,11 @@ function toAcpxResourceInput(input) {
 const ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME = "openclaw-plugin-tools";
 const ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME = "openclaw-tools";
 const OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY_ENV = "OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY";
-function withOpenClawManagedTurnTimeout(input) {
-	return {
-		...input,
-		timeoutMs: 0
-	};
-}
-function withOpenClawLeaseSessionMetadata(record, metadata) {
+function withOpenClawLeaseSessionMetadata(record, lease) {
 	return {
 		...record,
-		openclawLeaseId: metadata.openclawLeaseId,
-		openclawGatewayInstanceId: metadata.openclawGatewayInstanceId
+		openclawLeaseId: lease.leaseId,
+		openclawGatewayInstanceId: lease.gatewayInstanceId
 	};
 }
 const CODEX_WRAPPER_STDERR_LOG_PREFIX = "codex-acp-wrapper.stderr";
@@ -75,8 +72,7 @@ function isGenericInternalAcpErrorMessage(message) {
 	return message.trim() === "Internal error";
 }
 function isGenericInternalAcpError(error) {
-	if (!(error instanceof Error)) return false;
-	return isGenericInternalAcpErrorMessage(error.message);
+	return error instanceof Error && isGenericInternalAcpErrorMessage(error.message);
 }
 async function readCodexWrapperStderrTail(params) {
 	if (!params.wrapperRoot || !params.leaseId) return "";
@@ -93,9 +89,7 @@ function readSessionRecordName(record) {
 	return typeof name === "string" ? name.trim() : "";
 }
 function readRecordAgentCommand(record) {
-	if (typeof record !== "object" || record === null) return;
-	const { agentCommand } = record;
-	return typeof agentCommand === "string" ? agentCommand.trim() || void 0 : void 0;
+	return record?.agentArgv ?? record?.agentCommand;
 }
 function readRecordCwd(record) {
 	if (typeof record !== "object" || record === null) return;
@@ -151,10 +145,7 @@ function createResetAwareSessionStore(baseStore, params) {
 				rootPid: readRecordAgentPid(record)
 			});
 			if (!lease) return record;
-			return withOpenClawLeaseSessionMetadata(record, {
-				openclawLeaseId: lease.leaseId,
-				openclawGatewayInstanceId: lease.gatewayInstanceId
-			});
+			return withOpenClawLeaseSessionMetadata(record, lease);
 		},
 		async save(record) {
 			let recordToSave = record;
@@ -169,7 +160,9 @@ function createResetAwareSessionStore(baseStore, params) {
 			})) {
 				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) ? {
+					const adoptingLease = Boolean(launch && !isDeepStrictEqual(splitCommandParts(launch.resolvedCommand), splitCommandParts(launch.leasedCommand)));
+					const persistedCommand = launch && !adoptingLease ? launch.resolvedCommand : leasedCommand;
+					const lifecycleRecord = adoptingLease ? {
 						...record,
 						pid: void 0,
 						processId: void 0,
@@ -184,17 +177,15 @@ function createResetAwareSessionStore(baseStore, params) {
 						wrapperPath: extractGeneratedWrapperPath(leasedCommand),
 						rootPid,
 						...existing?.rootPid === rootPid && existing.processGroupId ? { processGroupId: existing.processGroupId } : {},
-						commandHash: hashAcpxProcessCommand(leasedCommand),
+						commandHash: hashAcpxProcessCommand(persistedCommand),
 						startedAt: existing?.rootPid === rootPid ? existing.startedAt : Date.now(),
 						state: "open"
 					});
 					recordToSave = withOpenClawLeaseSessionMetadata({
 						...lifecycleRecord,
-						agentCommand: leasedCommand
-					}, {
-						openclawLeaseId: leaseIdentity.leaseId,
-						openclawGatewayInstanceId: leaseIdentity.gatewayInstanceId
-					});
+						agentCommand: renderAgentCommand(persistedCommand),
+						agentArgv: Array.isArray(persistedCommand) ? persistedCommand : void 0
+					}, leaseIdentity);
 				}
 			}
 			await baseStore.save(recordToSave);
@@ -234,18 +225,7 @@ function readAgentFromSessionKey(sessionKey) {
 	return normalizeAgentName(/^agent:(?<agent>[^:]+):/i.exec(normalized)?.groups?.agent);
 }
 function readAgentFromHandle(handle) {
-	const decoded = decodeAcpxRuntimeHandleState(handle.runtimeSessionName);
-	if (typeof decoded === "object" && decoded !== null) {
-		const { agent } = decoded;
-		if (typeof agent === "string") return normalizeAgentName(agent) ?? readAgentFromSessionKey(handle.sessionKey);
-	}
-	return readAgentFromSessionKey(handle.sessionKey);
-}
-function readAgentCommandFromRecord(record) {
-	return readRecordAgentCommand(record);
-}
-function readAgentPidFromRecord(record) {
-	return readRecordAgentPid(record);
+	return normalizeAgentName(decodeAcpxRuntimeHandleState(handle.runtimeSessionName)?.agent) ?? readAgentFromSessionKey(handle.sessionKey);
 }
 function basename(value) {
 	return value.split(/[\\/]/).pop() ?? value;
@@ -277,7 +257,7 @@ function stripModuleExtension(value) {
 }
 function isAcpCommand(command, params) {
 	if (!command) return false;
-	const parts = unwrapEnvCommand(splitCommandParts(command.trim()));
+	const parts = unwrapEnvCommand(splitCommandParts(command));
 	if (!parts.length) return false;
 	if (parts.some((part) => matchesPackageSpec(part, params.packageName))) return true;
 	const commandName = basename(parts[0] ?? "");
@@ -288,7 +268,7 @@ function isAcpCommand(command, params) {
 }
 function isOpenClawBridgeCommand(command) {
 	if (!command) return false;
-	const parts = unwrapEnvCommand(splitCommandParts(command.trim()));
+	const parts = unwrapEnvCommand(splitCommandParts(command));
 	if (basename(parts[0] ?? "") === OPENCLAW_BRIDGE_EXECUTABLE) return parts[1] === OPENCLAW_BRIDGE_SUBCOMMAND;
 	if (basename(parts[0] ?? "") !== "node") return false;
 	const scriptName = basename(parts[1] ?? "");
@@ -306,15 +286,13 @@ function isClaudeAcpCommand(command) {
 		executableName: "claude-agent-acp"
 	});
 }
-function failUnsupportedCodexAcpModel(rawModel, detail) {
-	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", detail ?? `Codex ACP model "${rawModel}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
+function failUnsupportedCodexAcpModel(rawModel) {
+	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", `Codex ACP model "${rawModel}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
 }
-const SUPPORTED_RUNTIME_SESSION_MODES = /* @__PURE__ */ new Set(["persistent", "oneshot"]);
 const WIRE_TIMEOUT_CONFIG_KEYS = /* @__PURE__ */ new Set(["timeout", "timeout_seconds"]);
 function assertSupportedRuntimeSessionMode(mode) {
-	if (typeof mode === "string" && SUPPORTED_RUNTIME_SESSION_MODES.has(mode)) return;
-	const supported = Array.from(SUPPORTED_RUNTIME_SESSION_MODES).join(", ");
-	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", `Unsupported ACP runtime session mode ${JSON.stringify(mode)}. Expected one of: ${supported}.`);
+	if (mode === "persistent" || mode === "oneshot") return;
+	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", `Unsupported ACP runtime session mode ${JSON.stringify(mode)}. Expected one of: persistent, oneshot.`);
 }
 function failUnsupportedCodexAcpThinking(rawThinking) {
 	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", `Codex ACP thinking level "${rawThinking}" is not supported. Use off, minimal, low, medium, high, or xhigh.`);
@@ -350,12 +328,12 @@ function classifyCodexAcpModelRequest(rawModel, rawThinking) {
 		modelReasoningEffort = normalizeCodexAcpReasoningEffort(value.slice(slashIndex + 1));
 		model = value.slice(0, slashIndex).trim();
 	}
-	if (hadOpenAiQualifier && (!model || model.includes("/"))) failUnsupportedCodexAcpModel(raw, `Codex ACP model "${raw}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
+	if (hadOpenAiQualifier && (!model || model.includes("/"))) failUnsupportedCodexAcpModel(raw);
 	if (!model || model.includes("/")) return thinkingOnlyOverride ? {
 		kind: "unsupported",
 		thinkingOverride: thinkingOnlyOverride
 	} : { kind: "unsupported" };
-	const reasoningEffort = thinkingReasoningEffort ?? modelReasoningEffort;
+	const reasoningEffort = rawThinking?.trim() ? thinkingReasoningEffort : modelReasoningEffort;
 	return {
 		kind: "override",
 		override: {
@@ -397,48 +375,32 @@ async function ensureDelegateSessionWithModelFallback(delegate, input) {
 	try {
 		return await delegate.ensureSession(withAcpxSessionOptions(input));
 	} catch (error) {
-		if (!input.model || !isAcpModelCapabilityMissingError(error)) throw error;
-		return await delegate.ensureSession(withAcpxSessionOptions({
-			...input,
-			model: void 0
-		}));
+		if (input.modelExplicit || !input.model || !isAcpModelCapabilityMissingError(error)) throw error;
+		return {
+			...await delegate.ensureSession(withAcpxSessionOptions({
+				...input,
+				model: void 0
+			})),
+			appliedModel: { kind: "dropped" }
+		};
 	}
 }
-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 } : {},
 		...override.reasoningEffort ? { model_reasoning_effort: override.reasoningEffort } : {}
 	};
 	if (Object.keys(config).length === 0) return command;
-	return `${command} ${OPENCLAW_CODEX_CONFIG_ARG} ${quoteShellArg(JSON.stringify(config))}`;
-}
-function createModelScopedAgentRegistry(params) {
-	return {
-		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));
-		},
-		list() {
-			return params.agentRegistry.list();
-		}
-	};
+	return [
+		...splitCommandParts(command),
+		OPENCLAW_CODEX_CONFIG_ARG,
+		JSON.stringify(config)
+	];
 }
 function resolveAgentCommand(params) {
 	const normalizedAgentName = normalizeAgentName(params.agentName);
 	if (!normalizedAgentName) return;
-	return normalizeAgentCommand(params.agentRegistry.resolve(normalizedAgentName));
-}
-function shouldUseBridgeSafeDelegateForCommand(command) {
-	return isOpenClawBridgeCommand(command);
+	return splitCommandParts(params.agentRegistry.resolve(normalizedAgentName));
 }
 function shouldUseDistinctBridgeDelegate(options) {
 	const { mcpServers } = options;
@@ -473,11 +435,11 @@ function withManagedToolsMcpSessionEnv(params) {
 var AcpxRuntime = class {
 	constructor(options, testOptions) {
 		this.ownerAwareSessions = 1;
-		this.codexAcpModelOverrideScope = new AsyncLocalStorage();
+		this.launchCommandScope = new AsyncLocalStorage();
 		this.managedToolsSessionDelegates = /* @__PURE__ */ new Map();
 		this.launchLeaseScope = new AsyncLocalStorage();
-		this.ensureSessionTails = /* @__PURE__ */ new Map();
-		this.processLeaseTransitionTails = /* @__PURE__ */ new Map();
+		this.sessionEnsureQueue = new KeyedAsyncQueue();
+		this.processLeaseTransitionQueue = new KeyedAsyncQueue();
 		this.processLeaseOperationCounts = /* @__PURE__ */ new Map();
 		this.uncertainProcessLeaseIds = /* @__PURE__ */ new Set();
 		this.legacyBareSessionKeys = new Set(options.openclawLegacyBareSessionKeys);
@@ -497,11 +459,13 @@ var AcpxRuntime = class {
 			wrapperRoot: this.wrapperRoot
 		});
 		this.agentRegistry = options.agentRegistry;
-		this.scopedAgentRegistry = createModelScopedAgentRegistry({
-			agentRegistry: this.agentRegistry,
-			scope: this.codexAcpModelOverrideScope,
-			leaseCommand: (command) => this.commandWithLaunchLease(command)
-		});
+		this.scopedAgentRegistry = {
+			resolve: (agentName) => {
+				const launch = this.launchCommandScope.getStore();
+				return launch && launch.agent === normalizeAgentName(agentName) && launch.command ? launch.command : this.agentRegistry.resolve(agentName);
+			},
+			list: () => this.agentRegistry.list()
+		};
 		const sharedOptions = {
 			...options,
 			sessionStore: this.sessionStore,
@@ -514,16 +478,17 @@ var AcpxRuntime = class {
 			...sharedOptions,
 			mcpServers: []
 		}, this.delegateTestOptions) : this.delegate;
+		this.probeAgent = normalizeAgentName(options.probeAgent) ?? "codex";
 		const probeCommand = resolveAgentCommand({
-			agentName: normalizeAgentName(options.probeAgent) ?? "codex",
+			agentName: this.probeAgent,
 			agentRegistry: this.agentRegistry
 		});
 		this.probeCommand = probeCommand;
-		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || shouldUseBridgeSafeDelegateForCommand(probeCommand);
+		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || isOpenClawBridgeCommand(probeCommand);
 		this.probeDelegate = useBridgeSafeProbe ? this.bridgeSafeDelegate : this.delegate;
 	}
 	resolveDelegateForSession(params) {
-		if (shouldUseBridgeSafeDelegateForCommand(params.command)) return this.bridgeSafeDelegate;
+		if (isOpenClawBridgeCommand(params.command)) return this.bridgeSafeDelegate;
 		return this.resolveManagedToolsDelegateForSession(params);
 	}
 	resolveManagedToolsDelegateForSession(target) {
@@ -544,12 +509,6 @@ var AcpxRuntime = class {
 		this.managedToolsSessionDelegates.set(normalizedSessionKey, delegate);
 		return delegate;
 	}
-	releaseManagedToolsDelegateForSession(sessionKey) {
-		if (!this.managedToolsMcpBridgeEnabled) return;
-		const normalizedSessionKey = sessionKey.trim();
-		if (!normalizedSessionKey) return;
-		this.managedToolsSessionDelegates.delete(normalizedSessionKey);
-	}
 	async loadOperationSnapshotForHandle(handle) {
 		assertAcpxSessionOwnerLocator({
 			...handle,
@@ -558,7 +517,7 @@ var AcpxRuntime = class {
 		const record = await this.sessionStore.load(handle.acpxRecordId ?? resolveAcpxSessionResource(handle));
 		return {
 			record,
-			command: readAgentCommandFromRecord(record) ?? resolveAgentCommand({
+			command: readRecordAgentCommand(record) ?? resolveAgentCommand({
 				agentName: readAgentFromHandle(handle),
 				agentRegistry: this.agentRegistry
 			})
@@ -571,16 +530,6 @@ var AcpxRuntime = class {
 			agentId: handle.agentId
 		});
 	}
-	commandWithLaunchLease(command) {
-		const launch = this.launchLeaseScope.getStore();
-		if (!launch) return command;
-		if (command === launch.stableCommand) return launch.resolvedCommand;
-		return withAcpxLeaseEnvironment({
-			command,
-			leaseId: launch.leaseId,
-			gatewayInstanceId: launch.gatewayInstanceId
-		});
-	}
 	async readReusablePersistentSessionCommand(params) {
 		if (params.mode !== "persistent" || !params.command) return;
 		const existing = await this.sessionStore.load(params.sessionKey);
@@ -591,24 +540,27 @@ var AcpxRuntime = class {
 		if (!recordCommand) return;
 		const leaseIdentity = readAcpxProcessLeaseIdentity(recordCommand);
 		if (leaseIdentity && leaseIdentity.gatewayInstanceId !== this.gatewayInstanceId) return;
-		if (recordCommand !== (leaseIdentity ? withAcpxLeaseEnvironment({
+		const stableRecordCommand = leaseIdentity ? withAcpxLeaseArgs({
 			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 ? recordCommand : void 0;
+		}) : params.command;
+		if (!isDeepStrictEqual(splitCommandParts(recordCommand), splitCommandParts(stableRecordCommand))) return;
+		return !params.resumeSessionId || existing.acpSessionId === params.resumeSessionId ? recordCommand : void 0;
 	}
 	async runWithLaunchLease(params) {
 		if (!params.command || !this.wrapperRoot || !this.gatewayInstanceId || !this.processLeaseStore || !isOpenClawLeaseAwareAcpxProcessCommand({
 			command: params.command,
 			wrapperRoot: this.wrapperRoot
-		})) return await params.run();
+		})) return await this.launchCommandScope.run({
+			agent: normalizeAgentName(params.agent) ?? params.agent,
+			command: params.reusableCommand ?? params.command
+		}, 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({
+		const leaseId = canReuseLeaseIdentity ? reusableIdentity.leaseId : params.finalizeCompletedProbe ? `probe-${hashAcpxProcessCommand(`${this.gatewayInstanceId}\0${extractGeneratedWrapperPath(params.command)}`)}` : randomUUID();
+		const leasedCommand = withAcpxLeaseArgs({
 			command: params.command,
 			leaseId,
 			gatewayInstanceId: this.gatewayInstanceId
@@ -618,14 +570,13 @@ var AcpxRuntime = class {
 			gatewayInstanceId: this.gatewayInstanceId,
 			sessionKey: params.sessionKey,
 			wrapperRoot: this.wrapperRoot,
-			stableCommand: params.command,
 			resolvedCommand: params.reusableCommand ?? leasedCommand,
 			leasedCommand
 		};
 		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;
+			if (!(!reusableLease && (!params.reusableCommand || isDeepStrictEqual(splitCommandParts(params.reusableCommand), splitCommandParts(leasedCommand))))) return;
 			await processLeaseStore.save({
 				leaseId: launch.leaseId,
 				gatewayInstanceId: launch.gatewayInstanceId,
@@ -639,7 +590,10 @@ var AcpxRuntime = class {
 			});
 		});
 		try {
-			const result = await this.launchLeaseScope.run(launch, params.run);
+			const result = await this.launchLeaseScope.run(launch, () => this.launchCommandScope.run({
+				agent: normalizeAgentName(params.agent) ?? params.agent,
+				command: launch.resolvedCommand
+			}, params.run));
 			if (params.finalizeCompletedProbe) await this.finalizeCompletedProbeLease(launch);
 			else await this.finalizeProcessLeaseForSession(params.sessionKey, launch);
 			return result;
@@ -653,7 +607,7 @@ var AcpxRuntime = class {
 		const processLeaseStore = this.processLeaseStore;
 		const wrapperRoot = this.wrapperRoot;
 		const recordPid = readRecordAgentPid(record);
-		const command = readAgentCommandFromRecord(record);
+		const command = readRecordAgentCommand(record);
 		const identity = readAcpxProcessLeaseIdentity(command);
 		if (!command || !isOpenClawLeaseAwareAcpxProcessCommand({
 			command,
@@ -681,31 +635,15 @@ var AcpxRuntime = class {
 		});
 		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 this.processLeaseTransitionQueue.enqueue(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 () => {
+		await this.processLeaseTransitionQueue.enqueue(identity.leaseId, async () => {
 			const count = this.processLeaseOperationCounts.get(identity.leaseId) ?? 0;
 			if (count > 1) {
 				this.processLeaseOperationCounts.set(identity.leaseId, count - 1);
@@ -733,7 +671,7 @@ var AcpxRuntime = class {
 			this.uncertainProcessLeaseIds.delete(identity.leaseId);
 			try {
 				const record = await this.sessionStore.load(sessionId);
-				const recordIdentity = readAcpxProcessLeaseIdentity(readAgentCommandFromRecord(record));
+				const recordIdentity = readAcpxProcessLeaseIdentity(readRecordAgentCommand(record));
 				if (recordIdentity?.leaseId !== identity.leaseId || recordIdentity.gatewayInstanceId !== identity.gatewayInstanceId) await processLeaseStore.markState(identity.leaseId, "lost");
 			} catch {}
 		});
@@ -778,29 +716,12 @@ var AcpxRuntime = class {
 			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 {
 			return await params.run();
 		} catch (error) {
 			if (!isCodexAcpCommand(params.command) || !isGenericInternalAcpError(error)) throw error;
-			const stderrTail = await readCodexWrapperStderrTail({
+			const stderrTail = params.handle ? await this.readCodexTurnFailureStderr({ handle: params.handle }) : await readCodexWrapperStderrTail({
 				wrapperRoot: this.wrapperRoot,
 				leaseId: this.launchLeaseScope.getStore()?.leaseId
 			});
@@ -817,7 +738,7 @@ var AcpxRuntime = class {
 	}
 	async cleanupProcessTreeForRecord(handle, record) {
 		const leaseId = readOpenClawLeaseIdFromRecord(record);
-		const rootPid = readAgentPidFromRecord(record);
+		const rootPid = readRecordAgentPid(record);
 		const sessionKeys = [resolveAcpxSessionResource(handle), readSessionRecordName(record)];
 		const selectedLease = selectCurrentSessionLease({
 			leases: this.gatewayInstanceId && this.processLeaseStore ? await this.processLeaseStore.listOpen(this.gatewayInstanceId) : [],
@@ -830,7 +751,7 @@ var AcpxRuntime = class {
 			await this.processLeaseStore?.markState(lease.leaseId, "closing");
 			const result = await cleanupOpenClawOwnedAcpxProcessTree({
 				rootPid: lease.rootPid,
-				rootCommand: readAgentCommandFromRecord(record),
+				rootCommand: record?.agentCommand,
 				expectedLeaseId: lease.leaseId,
 				expectedGatewayInstanceId: lease.gatewayInstanceId,
 				wrapperRoot: lease.wrapperRoot,
@@ -839,7 +760,7 @@ var AcpxRuntime = class {
 			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({
+		const rootCommand = readRecordAgentCommand(record) ?? resolveAgentCommand({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -847,7 +768,7 @@ var AcpxRuntime = class {
 		const expectedGatewayInstanceId = readOpenClawGatewayInstanceIdFromRecord(record);
 		await cleanupOpenClawOwnedAcpxProcessTree({
 			rootPid,
-			rootCommand,
+			rootCommand: renderAgentCommand(rootCommand),
 			...leaseId ? { expectedLeaseId: leaseId } : {},
 			...expectedGatewayInstanceId ? { expectedGatewayInstanceId } : {},
 			wrapperRoot: this.wrapperRoot,
@@ -859,6 +780,7 @@ var AcpxRuntime = class {
 	}
 	async probeAvailability() {
 		await this.runWithLaunchLease({
+			agent: this.probeAgent,
 			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
 			command: this.probeCommand,
 			finalizeCompletedProbe: true,
@@ -867,6 +789,7 @@ var AcpxRuntime = class {
 	}
 	async doctor() {
 		return await this.runWithLaunchLease({
+			agent: this.probeAgent,
 			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
 			command: this.probeCommand,
 			finalizeCompletedProbe: true,
@@ -875,7 +798,7 @@ var AcpxRuntime = class {
 	}
 	async ensureSession(input) {
 		const resource = assertAcpxSessionOwnerLocator(input, this.legacyBareSessionKeys);
-		return await this.runSerializedSessionEnsure(resource, () => this.ensureSessionUnlocked(input));
+		return await this.sessionEnsureQueue.enqueue(resource.trim() || resource, () => this.ensureSessionUnlocked(input));
 	}
 	async ensureSessionUnlocked(logicalInput) {
 		assertSupportedRuntimeSessionMode(logicalInput.mode);
@@ -920,83 +843,63 @@ var AcpxRuntime = class {
 			resumeSessionId: input.resumeSessionId
 		});
 		return {
-			...!codexModelOverride ? await this.runWithLaunchLease({
+			...await this.runWithLaunchLease({
+				agent: ensureInput.agent,
 				sessionKey: ensureInput.sessionKey,
 				command: stableLaunchCommand,
 				reusableCommand,
 				run: () => this.withCodexWrapperDiagnostics({
 					command: stableLaunchCommand,
 					fallbackCode: "ACP_SESSION_INIT_FAILED",
-					run: () => ensureDelegateSessionWithModelFallback(delegate, ensureInput)
+					run: () => codexModelOverride ? delegate.ensureSession(withAcpxSessionOptions(ensureInput)) : ensureDelegateSessionWithModelFallback(delegate, ensureInput)
 				})
-			}) : await this.runWithLaunchLease({
-				sessionKey: input.sessionKey,
-				command: stableLaunchCommand,
-				reusableCommand,
-				run: () => this.codexAcpModelOverrideScope.run(codexModelOverride, () => this.withCodexWrapperDiagnostics({
-					command: stableLaunchCommand,
-					fallbackCode: "ACP_SESSION_INIT_FAILED",
-					run: () => delegate.ensureSession(withAcpxSessionOptions(ensureInput))
-				}))
 			}),
 			...logicalTarget,
 			...appliedModel ? { appliedModel } : {}
 		};
 	}
 	async *runTurn(input) {
-		assertAcpxSessionOwnerLocator({
-			...input.handle,
-			persistedHandle: input.handle
-		}, this.legacyBareSessionKeys);
-		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? resolveAcpxSessionResource(input.handle));
-		const turnLease = await this.prepareProcessLeaseForOperation(input.handle, record);
-		let command;
+		const turn = this.startTurn(input);
+		turn.result.catch(() => {});
+		let completed = false;
 		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(toAcpxResourceInput(input)))) {
-				if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
-					yield event;
-					continue;
-				}
-				const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
-				if (!stderrTail) {
-					yield event;
-					continue;
-				}
-				yield {
-					...event,
-					code: "ACP_TURN_FAILED",
-					message: `Internal error: ${stderrTail}`
-				};
-			}
-		} catch (error) {
-			if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
-			const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
-			if (!stderrTail) throw error;
-			throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
+			yield* turn.events;
+			const result = await turn.result;
+			completed = true;
+			yield result.status === "failed" ? {
+				type: "error",
+				...result.error
+			} : {
+				type: "done",
+				...result.stopReason ? { stopReason: result.stopReason } : {}
+			};
 		} finally {
-			await this.finalizeProcessLeaseForOperation(input.handle, turnLease);
+			if (!completed) {
+				await turn.cancel({ reason: "stream-closed" }).catch(() => {});
+				await turn.closeStream({ reason: "stream-closed" }).catch(() => {});
+				await turn.result.catch(() => {});
+			}
 		}
 	}
 	startTurn(input) {
-		const readCodexTurnFailureStderr = () => this.readCodexTurnFailureStderr({ handle: input.handle });
+		const withTurnDiagnostics = (command, run) => this.withCodexWrapperDiagnostics({
+			command,
+			handle: input.handle,
+			fallbackCode: "ACP_TURN_FAILED",
+			run
+		});
 		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 turnPromise = Promise.all([snapshotPromise, turnLeasePromise]).then(([snapshot]) => {
 			const { command } = snapshot;
 			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
-			try {
-				return {
-					command,
-					turn: delegate.startTurn(withOpenClawManagedTurnTimeout(toAcpxResourceInput(input)))
-				};
-			} catch (error) {
-				if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
-				const stderrTail = await readCodexTurnFailureStderr();
-				if (!stderrTail) throw error;
-				throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
-			}
+			return withTurnDiagnostics(command, async () => ({
+				command,
+				turn: delegate.startTurn({
+					...toAcpxResourceInput(input),
+					timeoutMs: 0
+				})
+			}));
 		});
 		return {
 			requestId: input.requestId,
@@ -1006,50 +909,26 @@ var AcpxRuntime = class {
 			events: { async *[Symbol.asyncIterator]() {
 				const { command, turn } = await turnPromise;
 				try {
-					for await (const event of turn.events) {
-						if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
-							yield event;
-							continue;
-						}
-						const stderrTail = await readCodexTurnFailureStderr();
-						if (!stderrTail) {
-							yield event;
-							continue;
-						}
-						yield {
-							...event,
-							code: "ACP_TURN_FAILED",
-							message: `Internal error: ${stderrTail}`
-						};
-					}
+					yield* turn.events;
 				} catch (error) {
-					if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
-					const stderrTail = await readCodexTurnFailureStderr();
-					if (!stderrTail) throw error;
-					throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
+					if (!isGenericInternalAcpError(error)) throw error;
+					await withTurnDiagnostics(command, () => Promise.reject(error));
 				}
 			} },
-			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;
-					const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
-					if (!stderrTail) return result;
-					return {
-						status: "failed",
-						error: {
-							...result.error,
-							code: "ACP_TURN_FAILED",
-							message: `Internal error: ${stderrTail}`
-						}
-					};
-				} catch (error) {
-					if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
-					const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
-					if (!stderrTail) throw error;
-					throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
-				}
-			})),
+			result: this.finalizeProcessLeaseAfter(input.handle, turnLeasePromise, turnPromise.then(({ command, turn }) => withTurnDiagnostics(command, async () => {
+				const result = await turn.result;
+				if (result.status !== "failed" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(result.error.message)) return result;
+				const stderrTail = await this.readCodexTurnFailureStderr({ handle: input.handle });
+				if (!stderrTail) return result;
+				return {
+					status: "failed",
+					error: {
+						...result.error,
+						code: "ACP_TURN_FAILED",
+						message: `Internal error: ${stderrTail}`
+					}
+				};
+			}))),
 			cancel(inputArgs) {
 				return turnPromise.then(({ turn }) => turn.cancel(inputArgs));
 			},
@@ -1129,20 +1008,19 @@ var AcpxRuntime = class {
 		let cleanupSucceeded = false;
 		try {
 			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
-			let closeSucceeded;
+			const handle = toAcpxResourceInput(input).handle;
 			try {
 				await delegate.close({
-					handle: toAcpxResourceInput(input).handle,
+					handle,
 					reason: input.reason,
 					discardPersistentState: input.discardPersistentState
 				});
-				closeSucceeded = true;
+				if (this.managedToolsSessionDelegates.get(handle.sessionKey) === delegate) this.managedToolsSessionDelegates.delete(handle.sessionKey);
 			} finally {
 				await this.cleanupProcessTreeForRecord(input.handle, snapshot.record);
 				cleanupSucceeded = true;
 			}
-			if (closeSucceeded) this.releaseManagedToolsDelegateForSession(resolveAcpxSessionResource(input.handle));
-			if (closeSucceeded && input.discardPersistentState) await this.prepareFreshSession({
+			if (input.discardPersistentState) await this.prepareFreshSession({
 				...input.handle,
 				persistedHandle: input.handle
 			});
@@ -1156,8 +1034,7 @@ var AcpxRuntime = class {
 const testing = {
 	appendCodexAcpConfigOverrides,
 	isClaudeAcpCommand,
-	isCodexAcpCommand,
-	normalizeAgentCommand
+	isCodexAcpCommand
 };
 //#endregion
 export { ACPX_BACKEND_ID, AcpxRuntime, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, testing };