@openclaw/acpx 2026.7.2-beta.7 → 2026.7.33

package/dist/{runtime-By_lR8uk.js → .setup/runtime-FxGnBh3l.mjs}

@@ -1,20 +1,18 @@
-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 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";
+import { i as createAcpxProcessLeaseId, o as hashAcpxProcessCommand, u as withAcpxLeaseEnvironment } from "./process-lease-DiKkFj6F.mjs";
+import { AcpRuntimeError } from "../runtime-api.js";
+import { i as splitCommandParts, n as cleanupOpenClawOwnedAcpxProcessTree, r as isOpenClawLeaseAwareAcpxProcessCommand } from "./service-CE4bgxXH.mjs";
 import fs from "node:fs/promises";
 import path, { resolve } from "node:path";
+import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-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 { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/acpx/src/runtime.ts
 /**
 * OpenClaw ACPX runtime adapter. It wraps the upstream acpx runtime with
 * OpenClaw session metadata, lease tracking, model scoping, and cleanup policy.
 */
-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) {
@@ -50,7 +48,8 @@ function isGenericInternalAcpError(error) {
 async function readCodexWrapperStderrTail(params) {
 	if (!params.wrapperRoot || !params.leaseId) return "";
 	try {
-		return compactDiagnosticText(redactSensitiveText(sliceUtf16Safe(await fs.readFile(path.join(params.wrapperRoot, codexWrapperStderrLogFileName(params.leaseId)), "utf8"), -6e3)));
+		const text = await fs.readFile(path.join(params.wrapperRoot, codexWrapperStderrLogFileName(params.leaseId)), "utf8");
+		return compactDiagnosticText(redactSensitiveText(text.slice(-6e3)));
 	} catch {
 		return "";
 	}
@@ -128,42 +127,29 @@ 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 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
-					});
-				}
+			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
+				});
 			}
 			await baseStore.save(recordToSave);
 			if (sessionName) freshSessionKeys.delete(sessionName);
@@ -179,6 +165,12 @@ const OPENCLAW_BRIDGE_SUBCOMMAND = "acp";
 const CODEX_ACP_AGENT_ID = "codex";
 const CODEX_ACP_OPENCLAW_PREFIX = "openai/";
 const CLAUDE_ACP_OPENCLAW_PREFIX = "anthropic/";
+const CODEX_ACP_REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+]);
 const CODEX_ACP_THINKING_ALIASES = /* @__PURE__ */ new Map([
 	["off", void 0],
 	["minimal", "low"],
@@ -222,14 +214,9 @@ function isEnvAssignment(value) {
 	return /^[A-Za-z_][A-Za-z0-9_]*=/.test(value);
 }
 function unwrapEnvCommand(parts) {
-	const command = parts.at(0);
-	if (!command || basename(command) !== "env") return parts;
+	if (!parts.length || basename(parts[0]) !== "env") return parts;
 	let index = 1;
-	while (true) {
-		const part = parts.at(index);
-		if (!part || !isEnvAssignment(part)) break;
-		index += 1;
-	}
+	while (index < parts.length && isEnvAssignment(parts[index])) index += 1;
 	return parts.slice(index);
 }
 function matchesExecutableName(value, executableName) {
@@ -264,7 +251,7 @@ function isOpenClawBridgeCommand(command) {
 }
 function isCodexAcpCommand(command) {
 	return isAcpCommand(command, {
-		packageName: CODEX_ACP_PACKAGE,
+		packageName: "@zed-industries/codex-acp",
 		executableName: "codex-acp"
 	});
 }
@@ -293,50 +280,27 @@ function normalizeCodexAcpReasoningEffort(rawThinking) {
 	if (!CODEX_ACP_THINKING_ALIASES.has(normalized)) failUnsupportedCodexAcpThinking(rawThinking ?? "");
 	return CODEX_ACP_THINKING_ALIASES.get(normalized);
 }
-function isCodexAcpReasoningEffortAlias(value) {
-	const normalized = value?.trim().toLowerCase();
-	return Boolean(normalized && CODEX_ACP_THINKING_ALIASES.has(normalized));
-}
-function classifyCodexAcpModelRequest(rawModel, rawThinking) {
+function normalizeCodexAcpModelOverride(rawModel, rawThinking) {
 	const raw = rawModel?.trim();
 	const thinkingReasoningEffort = normalizeCodexAcpReasoningEffort(rawThinking);
-	const thinkingOnlyOverride = thinkingReasoningEffort ? { reasoningEffort: thinkingReasoningEffort } : void 0;
-	if (!raw) return {
-		kind: "override",
-		override: thinkingOnlyOverride ?? {}
-	};
+	if (!raw) return thinkingReasoningEffort ? { reasoningEffort: thinkingReasoningEffort } : void 0;
 	let value = raw;
-	let hadOpenAiQualifier = false;
-	if (value.toLowerCase().startsWith(CODEX_ACP_OPENCLAW_PREFIX)) {
-		value = value.slice(7);
-		hadOpenAiQualifier = true;
-	}
-	let model = value.trim();
-	let modelReasoningEffort;
-	const slashIndex = value.lastIndexOf("/");
-	if (slashIndex >= 0 && isCodexAcpReasoningEffortAlias(value.slice(slashIndex + 1))) {
-		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 (!model || model.includes("/")) return thinkingOnlyOverride ? {
-		kind: "unsupported",
-		thinkingOverride: thinkingOnlyOverride
-	} : { kind: "unsupported" };
+	if (value.toLowerCase().startsWith(CODEX_ACP_OPENCLAW_PREFIX)) value = value.slice(7);
+	const parts = value.split("/");
+	if (parts.length > 2) failUnsupportedCodexAcpModel(raw, `Codex ACP model "${raw}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
+	const model = (parts[0] ?? "").trim();
+	const modelReasoningEffort = normalizeCodexAcpReasoningEffort(parts[1]);
+	if (!model) failUnsupportedCodexAcpModel(raw, `Codex ACP model "${raw}" is not supported. Use openai/<model> or <model>/<reasoning-effort>.`);
 	const reasoningEffort = thinkingReasoningEffort ?? modelReasoningEffort;
+	if (reasoningEffort && !CODEX_ACP_REASONING_EFFORTS.has(reasoningEffort)) failUnsupportedCodexAcpThinking(reasoningEffort);
 	return {
-		kind: "override",
-		override: {
-			model,
-			...reasoningEffort ? { reasoningEffort } : {}
-		}
+		model,
+		...reasoningEffort ? { reasoningEffort } : {}
 	};
 }
-function withCodexSessionModel(input, override) {
-	const next = { ...input };
-	if (override?.model) next.model = override.model;
-	else delete next.model;
-	return next;
+function codexAcpSessionModelId(override) {
+	if (!override.model) return "";
+	return override.reasoningEffort ? `${override.model}/${override.reasoningEffort}` : override.model;
 }
 function normalizeClaudeAcpModelOverride(rawModel) {
 	const raw = rawModel?.trim();
@@ -351,9 +315,8 @@ function withAcpxSessionOptions(input) {
 		...existingOptions,
 		model
 	} : existingOptions;
-	const { modelExplicit: _modelExplicit, ...rest } = input;
 	return {
-		...rest,
+		...input,
 		...sessionOptions ? { sessionOptions } : {}
 	};
 }
@@ -375,21 +338,16 @@ 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))}`;
+	const configArgs = override.model ? [`model=${override.model}`] : [];
+	if (override.reasoningEffort) configArgs.push(`model_reasoning_effort=${override.reasoningEffort}`);
+	if (configArgs.length === 0) return command;
+	return `${command} ${configArgs.map((arg) => `-c ${quoteShellArg(arg)}`).join(" ")}`;
 }
 function createModelScopedAgentRegistry(params) {
 	return {
 		resolve(agentName) {
-			const command = normalizeAgentCommand(params.agentRegistry.resolve(agentName)) ?? "";
+			const command = 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));
@@ -402,7 +360,15 @@ function createModelScopedAgentRegistry(params) {
 function resolveAgentCommand(params) {
 	const normalizedAgentName = normalizeAgentName(params.agentName);
 	if (!normalizedAgentName) return;
-	return normalizeAgentCommand(params.agentRegistry.resolve(normalizedAgentName));
+	const resolvedCommand = params.agentRegistry.resolve(normalizedAgentName);
+	return typeof resolvedCommand === "string" ? resolvedCommand.trim() || void 0 : void 0;
+}
+function resolveProbeAgentName(options) {
+	const { probeAgent } = options;
+	return normalizeAgentName(typeof probeAgent === "string" ? probeAgent : void 0) ?? "codex";
+}
+function resolveAgentCommandForName(params) {
+	return resolveAgentCommand(params);
 }
 function shouldUseBridgeSafeDelegateForCommand(command) {
 	return isOpenClawBridgeCommand(command);
@@ -411,14 +377,12 @@ function shouldUseDistinctBridgeDelegate(options) {
 	const { mcpServers } = options;
 	return Array.isArray(mcpServers) && mcpServers.length > 0;
 }
-function withManagedToolsMcpSessionEnv(params) {
+function withOpenClawToolsMcpSessionEnv(params) {
 	const sessionKey = params.sessionKey.trim();
-	if (!params.pluginToolsEnabled && !params.openclawToolsEnabled || !sessionKey || !params.mcpServers?.length) return params.mcpServers;
+	if (!params.enabled || !sessionKey || !params.mcpServers?.length) return params.mcpServers;
 	let changed = false;
 	const nextServers = params.mcpServers.map((server) => {
-		const isManagedPluginTools = params.pluginToolsEnabled && server.name === ACPX_PLUGIN_TOOLS_MCP_SERVER_NAME;
-		const isManagedOpenClawTools = params.openclawToolsEnabled && server.name === ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME;
-		if (!isManagedPluginTools && !isManagedOpenClawTools || !("command" in server)) return server;
+		if (server.name !== ACPX_OPENCLAW_TOOLS_MCP_SERVER_NAME || !("command" in server)) return server;
 		changed = true;
 		const env = [...server.env.filter((entry) => entry.name !== OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY_ENV), {
 			name: OPENCLAW_TOOLS_MCP_AGENT_SESSION_KEY_ENV,
@@ -435,25 +399,19 @@ function withManagedToolsMcpSessionEnv(params) {
 var AcpxRuntime = class {
 	constructor(options, testOptions) {
 		this.codexAcpModelOverrideScope = new AsyncLocalStorage();
-		this.managedToolsSessionDelegates = /* @__PURE__ */ new Map();
+		this.openclawToolsSessionDelegates = /* @__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;
 		this.gatewayInstanceId = options.openclawGatewayInstanceId;
 		this.processLeaseStore = options.openclawProcessLeaseStore;
-		this.pluginToolsMcpBridgeEnabled = options.pluginToolsMcpBridgeEnabled === true;
 		this.openclawToolsMcpBridgeEnabled = options.openclawToolsMcpBridgeEnabled === true;
-		this.managedToolsMcpBridgeEnabled = this.pluginToolsMcpBridgeEnabled || this.openclawToolsMcpBridgeEnabled;
 		this.cwd = options.cwd;
 		this.sessionStore = createResetAwareSessionStore(options.sessionStore, {
 			gatewayInstanceId: this.gatewayInstanceId,
 			leaseStore: this.processLeaseStore,
-			launchScope: this.launchLeaseScope,
-			wrapperRoot: this.wrapperRoot
+			launchScope: this.launchLeaseScope
 		});
 		this.agentRegistry = options.agentRegistry;
 		this.scopedAgentRegistry = createModelScopedAgentRegistry({
@@ -473,40 +431,44 @@ var AcpxRuntime = class {
 			...sharedOptions,
 			mcpServers: []
 		}, this.delegateTestOptions) : this.delegate;
-		const probeCommand = resolveAgentCommand({
-			agentName: normalizeAgentName(options.probeAgent) ?? "codex",
+		this.probeDelegate = this.openclawToolsMcpBridgeEnabled ? this.bridgeSafeDelegate : this.resolveDelegateForAgent(resolveProbeAgentName(options));
+	}
+	resolveDelegateForAgent(agentName) {
+		const command = resolveAgentCommandForName({
+			agentName,
 			agentRegistry: this.agentRegistry
 		});
-		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || shouldUseBridgeSafeDelegateForCommand(probeCommand);
-		this.probeDelegate = useBridgeSafeProbe ? this.bridgeSafeDelegate : this.delegate;
+		return this.resolveDelegateForCommand(command);
+	}
+	resolveDelegateForCommand(command) {
+		return shouldUseBridgeSafeDelegateForCommand(command) ? this.bridgeSafeDelegate : this.delegate;
 	}
 	resolveDelegateForSession(params) {
 		if (shouldUseBridgeSafeDelegateForCommand(params.command)) return this.bridgeSafeDelegate;
-		return this.resolveManagedToolsDelegateForSession(params.sessionKey);
+		return this.resolveOpenClawToolsDelegateForSession(params.sessionKey);
 	}
-	resolveManagedToolsDelegateForSession(sessionKey) {
-		if (!this.managedToolsMcpBridgeEnabled) return this.delegate;
+	resolveOpenClawToolsDelegateForSession(sessionKey) {
+		if (!this.openclawToolsMcpBridgeEnabled) return this.delegate;
 		const normalizedSessionKey = sessionKey.trim();
 		if (!normalizedSessionKey) return this.delegate;
-		const cached = this.managedToolsSessionDelegates.get(normalizedSessionKey);
+		const cached = this.openclawToolsSessionDelegates.get(normalizedSessionKey);
 		if (cached) return cached;
 		const delegate = new AcpxRuntime$1({
 			...this.delegateOptions,
-			mcpServers: withManagedToolsMcpSessionEnv({
-				pluginToolsEnabled: this.pluginToolsMcpBridgeEnabled,
-				openclawToolsEnabled: this.openclawToolsMcpBridgeEnabled,
+			mcpServers: withOpenClawToolsMcpSessionEnv({
+				enabled: this.openclawToolsMcpBridgeEnabled,
 				mcpServers: this.delegateOptions.mcpServers,
 				sessionKey: normalizedSessionKey
 			})
 		}, this.delegateTestOptions);
-		this.managedToolsSessionDelegates.set(normalizedSessionKey, delegate);
+		this.openclawToolsSessionDelegates.set(normalizedSessionKey, delegate);
 		return delegate;
 	}
-	releaseManagedToolsDelegateForSession(sessionKey) {
-		if (!this.managedToolsMcpBridgeEnabled) return;
+	releaseOpenClawToolsDelegateForSession(sessionKey) {
+		if (!this.openclawToolsMcpBridgeEnabled) return;
 		const normalizedSessionKey = sessionKey.trim();
 		if (!normalizedSessionKey) return;
-		this.managedToolsSessionDelegates.delete(normalizedSessionKey);
+		this.openclawToolsSessionDelegates.delete(normalizedSessionKey);
 	}
 	async resolveDelegateForHandle(handle) {
 		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
@@ -518,7 +480,7 @@ var AcpxRuntime = class {
 			command: recordCommand,
 			sessionKey: handle.sessionKey
 		});
-		const command = resolveAgentCommand({
+		const command = resolveAgentCommandForName({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -530,7 +492,7 @@ var AcpxRuntime = class {
 	async resolveCommandForHandle(handle) {
 		const recordCommand = readAgentCommandFromRecord(await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey));
 		if (recordCommand) return recordCommand;
-		return resolveAgentCommand({
+		return resolveAgentCommandForName({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -538,206 +500,47 @@ var AcpxRuntime = class {
 	commandWithLaunchLease(command) {
 		const launch = this.launchLeaseScope.getStore();
 		if (!launch) return command;
-		if (command === launch.stableCommand) return launch.resolvedCommand;
+		launch.stableCommand = command;
 		return withAcpxLeaseEnvironment({
 			command,
 			leaseId: launch.leaseId,
 			gatewayInstanceId: launch.gatewayInstanceId
 		});
 	}
-	async readReusablePersistentSessionCommand(params) {
-		if (params.mode !== "persistent" || !params.command) return;
+	async canReuseStablePersistentSession(params) {
+		if (params.mode !== "persistent" || !params.command) return false;
 		const existing = await this.sessionStore.load(params.sessionKey);
-		if (!existing || readRecordResetOnNextEnsure(existing)) return;
+		if (!existing || readRecordResetOnNextEnsure(existing)) return false;
 		const recordCwd = readRecordCwd(existing);
-		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;
+		if (!recordCwd || resolve(recordCwd) !== resolve(params.cwd?.trim() || this.cwd)) return false;
+		if (readRecordAgentCommand(existing) !== params.command) return false;
 		const existingSessionId = typeof existing === "object" && existing !== null ? existing.acpSessionId : void 0;
-		return !params.resumeSessionId || existingSessionId === params.resumeSessionId ? recordCommand : void 0;
+		return !params.resumeSessionId || existingSessionId === params.resumeSessionId;
 	}
 	async runWithLaunchLease(params) {
-		if (!params.command || !this.wrapperRoot || !this.gatewayInstanceId || !this.processLeaseStore || !isOpenClawLeaseAwareAcpxProcessCommand({
+		if (params.enabled === false || !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,
+			leaseId: createAcpxProcessLeaseId(),
 			gatewayInstanceId: this.gatewayInstanceId,
 			sessionKey: params.sessionKey,
 			wrapperRoot: this.wrapperRoot,
-			stableCommand: params.command,
-			resolvedCommand: params.reusableCommand ?? leasedCommand,
-			leasedCommand
+			stableCommand: params.command
 		};
-		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 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;
+		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"
 		});
-		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);
-		}
+		return await this.launchLeaseScope.run(launch, params.run);
 	}
 	async withCodexWrapperDiagnostics(params) {
 		try {
@@ -780,10 +583,10 @@ var AcpxRuntime = class {
 				wrapperRoot: lease.wrapperRoot,
 				deps: this.processCleanupDeps
 			});
-			await this.processLeaseStore?.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" ? "open" : result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
+			await this.processLeaseStore?.markState(lease.leaseId, result.terminatedPids.length > 0 || result.skippedReason === "missing-root" ? "closed" : "lost");
 			return;
 		}
-		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommand({
+		const rootCommand = readAgentCommandFromRecord(record) ?? resolveAgentCommandForName({
 			agentName: readAgentFromHandle(handle),
 			agentRegistry: this.agentRegistry
 		});
@@ -808,11 +611,8 @@ 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({
+		const command = resolveAgentCommandForName({
 			agentName: input.agent,
 			agentRegistry: this.agentRegistry
 		});
@@ -820,59 +620,49 @@ var AcpxRuntime = class {
 			command,
 			sessionKey: input.sessionKey
 		});
-		const isCodexAcp = normalizeAgentName(input.agent) === CODEX_ACP_AGENT_ID && isCodexAcpCommand(command);
 		const claudeModelOverride = isClaudeAcpCommand(command) ? normalizeClaudeAcpModelOverride(input.model) : void 0;
-		const codexClassification = isCodexAcp ? classifyCodexAcpModelRequest(input.model, input.thinking) : void 0;
-		if (codexClassification?.kind === "unsupported" && input.modelExplicit) failUnsupportedCodexAcpModel(input.model ?? "");
-		const classifiedCodexOverride = codexClassification?.kind === "override" ? codexClassification.override : codexClassification?.thinkingOverride;
-		const codexModelOverride = classifiedCodexOverride && Object.keys(classifiedCodexOverride).length > 0 ? classifiedCodexOverride : void 0;
-		const requestedModel = input.model?.trim();
-		const appliedModel = isCodexAcp && requestedModel ? codexModelOverride?.model ? {
-			kind: "applied",
-			model: requestedModel
-		} : { kind: "dropped" } : void 0;
-		const ensureInput = isCodexAcp ? withCodexSessionModel(input, codexModelOverride) : claudeModelOverride ? {
+		const codexModelOverride = normalizeAgentName(input.agent) === CODEX_ACP_AGENT_ID && isCodexAcpCommand(command) ? normalizeCodexAcpModelOverride(input.model, input.thinking) : void 0;
+		const ensureInput = claudeModelOverride ? {
 			...input,
 			model: claudeModelOverride
 		} : input;
 		const stableLaunchCommand = codexModelOverride && command ? appendCodexAcpConfigOverrides(command, codexModelOverride) : command;
-		const reusableCommand = await this.readReusablePersistentSessionCommand({
+		const shouldStartWithLease = !await this.canReuseStablePersistentSession({
 			sessionKey: input.sessionKey,
 			mode: input.mode,
 			cwd: input.cwd,
 			command: stableLaunchCommand,
 			resumeSessionId: input.resumeSessionId
 		});
-		const handle = !codexModelOverride ? await this.runWithLaunchLease({
+		if (!codexModelOverride) return await this.runWithLaunchLease({
 			sessionKey: ensureInput.sessionKey,
 			command: stableLaunchCommand,
-			reusableCommand,
+			enabled: shouldStartWithLease,
 			run: () => this.withCodexWrapperDiagnostics({
 				command: stableLaunchCommand,
 				fallbackCode: "ACP_SESSION_INIT_FAILED",
 				run: () => ensureDelegateSessionWithModelFallback(delegate, ensureInput)
 			})
-		}) : await this.runWithLaunchLease({
+		});
+		const normalizedInput = {
+			...ensureInput,
+			...codexAcpSessionModelId(codexModelOverride) ? { model: codexAcpSessionModelId(codexModelOverride) } : {}
+		};
+		return await this.runWithLaunchLease({
 			sessionKey: input.sessionKey,
 			command: stableLaunchCommand,
-			reusableCommand,
+			enabled: shouldStartWithLease,
 			run: () => this.codexAcpModelOverrideScope.run(codexModelOverride, () => this.withCodexWrapperDiagnostics({
 				command: stableLaunchCommand,
 				fallbackCode: "ACP_SESSION_INIT_FAILED",
-				run: () => delegate.ensureSession(withAcpxSessionOptions(ensureInput))
+				run: () => delegate.ensureSession(withAcpxSessionOptions(normalizedInput))
 			}))
 		});
-		return appliedModel ? {
-			...handle,
-			appliedModel
-		} : handle;
 	}
 	async *runTurn(input) {
-		const turnLease = await this.prepareProcessLeaseForOperation(input.handle);
-		let command;
+		const command = await this.resolveCommandForHandle(input.handle);
+		const delegate = await this.resolveDelegateForHandle(input.handle);
 		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;
@@ -894,18 +684,11 @@ 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 turnLeasePromise = this.prepareProcessLeaseForOperation(input.handle);
-		const turnPromise = Promise.all([
-			turnLeasePromise,
-			this.resolveCommandForHandle(input.handle),
-			this.resolveDelegateForHandle(input.handle)
-		]).then(async ([, command, delegate]) => {
+		const turnPromise = Promise.all([this.resolveCommandForHandle(input.handle), this.resolveDelegateForHandle(input.handle)]).then(async ([command, delegate]) => {
 			try {
 				return {
 					command,
@@ -946,7 +729,7 @@ var AcpxRuntime = class {
 					throw new AcpRuntimeError("ACP_TURN_FAILED", `Internal error: ${stderrTail}`, { cause: error });
 				}
 			} },
-			result: this.finalizeProcessLeaseAfter(input.handle, turnLeasePromise, turnPromise.then(async ({ command, turn }) => {
+			result: turnPromise.then(async ({ command, turn }) => {
 				try {
 					const result = await turn.result;
 					if (result.status !== "failed" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(result.error.message)) return result;
@@ -966,7 +749,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));
 			},
@@ -975,52 +758,38 @@ var AcpxRuntime = class {
 			}
 		};
 	}
-	getCapabilities(input) {
-		return this.delegate.getCapabilities(input);
+	getCapabilities() {
+		return this.delegate.getCapabilities();
 	}
 	async getStatus(input) {
 		return (await this.resolveDelegateForHandle(input.handle)).getStatus(input);
 	}
 	async setMode(input) {
-		const delegate = await this.resolveDelegateForHandle(input.handle);
-		await this.runWithProcessLeaseForHandle(input.handle, () => delegate.setMode(input));
+		await (await this.resolveDelegateForHandle(input.handle)).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();
 		const isCodexAcp = isCodexAcpCommand(command);
 		if (WIRE_TIMEOUT_CONFIG_KEYS.has(key) && (isCodexAcp || isClaudeAcpCommand(command))) return;
 		if (isCodexAcp) {
-			if (key === "model") {
-				const classification = classifyCodexAcpModelRequest(input.value);
-				if (classification.kind === "unsupported") failUnsupportedCodexAcpModel(input.value);
-				const { override } = classification;
-				if (override.model) await delegate.setConfigOption({
-					...input,
-					key: "model",
-					value: override.model
-				});
-				if (override.reasoningEffort) await delegate.setConfigOption({
-					...input,
-					key: "reasoning_effort",
-					value: override.reasoningEffort
-				});
-				return;
-			}
-			if (key === "thinking" || key === "thought_level" || key === "reasoning_effort") {
-				const classification = classifyCodexAcpModelRequest(void 0, input.value);
-				const reasoningEffort = classification.kind === "override" ? classification.override.reasoningEffort : void 0;
-				if (!reasoningEffort) return;
-				await delegate.setConfigOption({
-					...input,
-					key: "reasoning_effort",
-					value: reasoningEffort
-				});
-				return;
+			if (key === "model" || key === "thinking" || key === "thought_level" || key === "reasoning_effort") {
+				const override = key === "model" ? normalizeCodexAcpModelOverride(input.value) : normalizeCodexAcpModelOverride(void 0, input.value);
+				if (!override && key !== "model") return;
+				if (override) {
+					if (override.model) await delegate.setConfigOption({
+						...input,
+						key: "model",
+						value: override.model
+					});
+					if (override.reasoningEffort) await delegate.setConfigOption({
+						...input,
+						key: "reasoning_effort",
+						value: override.reasoningEffort
+					});
+					return;
+				}
 			}
 		}
 		if (isClaudeAcpCommand(command) && key === "model") {
@@ -1040,40 +809,32 @@ var AcpxRuntime = class {
 		this.sessionStore.markFresh(input.sessionKey);
 	}
 	async close(input) {
-		const closeLease = await this.prepareProcessLeaseForOperation(input.handle);
-		let cleanupSucceeded = false;
+		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+		let closeSucceeded;
+		const delegate = this.resolveDelegateForLoadedRecord(input.handle, record);
 		try {
-			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);
+			await delegate.close({
+				handle: input.handle,
+				reason: input.reason,
+				discardPersistentState: input.discardPersistentState
+			});
+			closeSucceeded = true;
 		} finally {
-			if (cleanupSucceeded) await this.finalizeProcessLeaseForOperation(input.handle, closeLease);
-			else await this.retirePendingProcessLease(closeLease);
+			await this.cleanupProcessTreeForRecord(input.handle, record);
 		}
+		if (closeSucceeded) this.releaseOpenClawToolsDelegateForSession(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,
+	codexAcpSessionModelId,
 	isClaudeAcpCommand,
 	isCodexAcpCommand,
-	normalizeAgentCommand,
-	normalizeClaudeAcpModelOverride
+	normalizeClaudeAcpModelOverride,
+	normalizeCodexAcpModelOverride
 };
 //#endregion
 export { ACPX_BACKEND_ID, AcpxRuntime, testing as __testing, testing, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState };