@openclaw/acpx 2026.9.1-beta.1 → 2026.9.2

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

@@ -1,14 +1,45 @@
 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 { d as OPENCLAW_CODEX_CONFIG_ARG, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, r as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxPendingLease } from "./process-reaper-DduWm_7N.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 { 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 { 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 { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, decodeAcpxRuntimeHandleState as decodeAcpxRuntimeHandleState$1, encodeAcpxRuntimeHandleState, isRequestedModelUnsupportedError } from "acpx/runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
+//#region extensions/acpx/src/session-owner.ts
+function requireAcpxOwnerMigration(sessionKey) {
+	throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", `ACP session "${sessionKey}" has an unqualified or unverifiable backend locator. Stop the Gateway and run "openclaw doctor --fix" to migrate ownership without losing history, then restart.`, { detailCode: "SESSION_OWNER_MIGRATION_REQUIRED" });
+}
+function assertAcpxSessionOwnerLocator(target, legacyBareSessionKeys) {
+	const resource = resolveAcpxSessionResource(target);
+	const qualified = resource === target.sessionKey.trim().toLowerCase();
+	const persisted = target.persistedHandle;
+	if (!qualified && (legacyBareSessionKeys?.has(target.sessionKey.trim().toLowerCase()) || legacyBareSessionKeys?.has(resource) && !persisted)) requireAcpxOwnerMigration(target.sessionKey);
+	if (persisted) {
+		const decoded = decodeAcpxRuntimeHandleState$1(persisted.runtimeSessionName);
+		if (!qualified && !decoded || decoded && (decoded.name !== resource || persisted.acpxRecordId && decoded.acpxRecordId !== persisted.acpxRecordId)) requireAcpxOwnerMigration(target.sessionKey);
+	}
+	return resource;
+}
+/** Preserve physical oneshot record IDs and the upstream-encoded runtime handle. */
+function toAcpxResourceInput(input) {
+	const sessionKey = assertAcpxSessionOwnerLocator({
+		...input.handle,
+		persistedHandle: input.handle
+	});
+	return {
+		...input,
+		handle: {
+			...input.handle,
+			sessionKey
+		}
+	};
+}
+//#endregion
 //#region extensions/acpx/src/runtime.ts
 /**
 * OpenClaw ACPX runtime adapter. It wraps the upstream acpx runtime with
@@ -50,7 +81,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(sliceUtf16Safe(text, -6e3)));
 	} catch {
 		return "";
 	}
@@ -178,7 +210,7 @@ const OPENCLAW_BRIDGE_EXECUTABLE = "openclaw";
 const OPENCLAW_BRIDGE_SUBCOMMAND = "acp";
 const CODEX_ACP_AGENT_ID = "codex";
 const CODEX_ACP_OPENCLAW_PREFIX = "openai/";
-const CLAUDE_ACP_OPENCLAW_PREFIX = "anthropic/";
+const CLAUDE_ACP_OPENCLAW_PREFIX = /^(?:anthropic|amazon-bedrock)\//i;
 const CODEX_ACP_THINKING_ALIASES = /* @__PURE__ */ new Map([
 	["off", void 0],
 	["minimal", "low"],
@@ -341,8 +373,9 @@ function withCodexSessionModel(input, override) {
 function normalizeClaudeAcpModelOverride(rawModel) {
 	const raw = rawModel?.trim();
 	if (!raw) return;
-	if (!raw.toLowerCase().startsWith(CLAUDE_ACP_OPENCLAW_PREFIX)) return raw;
-	return raw.slice(10).trim() || void 0;
+	const prefix = raw.match(CLAUDE_ACP_OPENCLAW_PREFIX);
+	if (!prefix) return raw;
+	return raw.slice(prefix[0].length).trim() || void 0;
 }
 function withAcpxSessionOptions(input) {
 	const existingOptions = input.sessionOptions;
@@ -426,7 +459,12 @@ function withManagedToolsMcpSessionEnv(params) {
 		}];
 		return {
 			...server,
-			env
+			env,
+			args: params.agentId ? [
+				...server.args,
+				"--openclaw-agent-id",
+				params.agentId
+			] : server.args
 		};
 	});
 	return changed ? nextServers : params.mcpServers;
@@ -434,6 +472,7 @@ function withManagedToolsMcpSessionEnv(params) {
 /** OpenClaw-managed ACP runtime implementation backed by the upstream acpx runtime. */
 var AcpxRuntime = class {
 	constructor(options, testOptions) {
+		this.ownerAwareSessions = 1;
 		this.codexAcpModelOverrideScope = new AsyncLocalStorage();
 		this.managedToolsSessionDelegates = /* @__PURE__ */ new Map();
 		this.launchLeaseScope = new AsyncLocalStorage();
@@ -441,6 +480,7 @@ var AcpxRuntime = class {
 		this.processLeaseTransitionTails = /* @__PURE__ */ new Map();
 		this.processLeaseOperationCounts = /* @__PURE__ */ new Map();
 		this.uncertainProcessLeaseIds = /* @__PURE__ */ new Set();
+		this.legacyBareSessionKeys = new Set(options.openclawLegacyBareSessionKeys);
 		const { openclawProcessCleanup, ...delegateTestOptions } = testOptions ?? {};
 		this.processCleanupDeps = openclawProcessCleanup;
 		this.wrapperRoot = options.openclawWrapperRoot;
@@ -484,12 +524,11 @@ var AcpxRuntime = class {
 	}
 	resolveDelegateForSession(params) {
 		if (shouldUseBridgeSafeDelegateForCommand(params.command)) return this.bridgeSafeDelegate;
-		return this.resolveManagedToolsDelegateForSession(params.sessionKey);
+		return this.resolveManagedToolsDelegateForSession(params);
 	}
-	resolveManagedToolsDelegateForSession(sessionKey) {
+	resolveManagedToolsDelegateForSession(target) {
 		if (!this.managedToolsMcpBridgeEnabled) return this.delegate;
-		const normalizedSessionKey = sessionKey.trim();
-		if (!normalizedSessionKey) return this.delegate;
+		const normalizedSessionKey = resolveAcpxSessionResource(target);
 		const cached = this.managedToolsSessionDelegates.get(normalizedSessionKey);
 		if (cached) return cached;
 		const delegate = new AcpxRuntime$1({
@@ -498,7 +537,8 @@ var AcpxRuntime = class {
 				pluginToolsEnabled: this.pluginToolsMcpBridgeEnabled,
 				openclawToolsEnabled: this.openclawToolsMcpBridgeEnabled,
 				mcpServers: this.delegateOptions.mcpServers,
-				sessionKey: normalizedSessionKey
+				sessionKey: target.sessionKey,
+				agentId: target.agentId
 			})
 		}, this.delegateTestOptions);
 		this.managedToolsSessionDelegates.set(normalizedSessionKey, delegate);
@@ -511,7 +551,11 @@ var AcpxRuntime = class {
 		this.managedToolsSessionDelegates.delete(normalizedSessionKey);
 	}
 	async loadOperationSnapshotForHandle(handle) {
-		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
+		assertAcpxSessionOwnerLocator({
+			...handle,
+			persistedHandle: handle
+		}, this.legacyBareSessionKeys);
+		const record = await this.sessionStore.load(handle.acpxRecordId ?? resolveAcpxSessionResource(handle));
 		return {
 			record,
 			command: readAgentCommandFromRecord(record) ?? resolveAgentCommand({
@@ -523,7 +567,8 @@ var AcpxRuntime = class {
 	resolveDelegateForOperationSnapshot(handle, snapshot) {
 		return this.resolveDelegateForSession({
 			command: snapshot.command,
-			sessionKey: handle.sessionKey
+			sessionKey: handle.sessionKey,
+			agentId: handle.agentId
 		});
 	}
 	commandWithLaunchLease(command) {
@@ -622,7 +667,7 @@ var AcpxRuntime = class {
 				await processLeaseStore.save({
 					leaseId: identity.leaseId,
 					gatewayInstanceId: identity.gatewayInstanceId,
-					sessionKey: handle.sessionKey,
+					sessionKey: resolveAcpxSessionResource(handle),
 					wrapperRoot,
 					wrapperPath: extractGeneratedWrapperPath(command),
 					rootPid: recordPid ?? 0,
@@ -632,7 +677,7 @@ var AcpxRuntime = class {
 				});
 				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`);
+			if (existing.gatewayInstanceId !== identity.gatewayInstanceId || existing.sessionKey !== resolveAcpxSessionResource(handle) || existing.wrapperRoot !== wrapperRoot) throw new AcpRuntimeError("ACP_TURN_FAILED", `ACPX process lease ${identity.leaseId} belongs to another session`);
 		});
 		return identity;
 	}
@@ -672,7 +717,7 @@ var AcpxRuntime = class {
 		});
 	}
 	async finalizeProcessLeaseForOperation(handle, identity) {
-		await this.finalizeProcessLeaseForSession(handle.acpxRecordId ?? handle.sessionKey, identity);
+		await this.finalizeProcessLeaseForSession(handle.acpxRecordId ?? resolveAcpxSessionResource(handle), identity);
 	}
 	async finalizeProcessLeaseForSession(sessionId, identity) {
 		if (!identity || !this.processLeaseStore) return;
@@ -687,7 +732,8 @@ var AcpxRuntime = class {
 			}
 			this.uncertainProcessLeaseIds.delete(identity.leaseId);
 			try {
-				const recordIdentity = readAcpxProcessLeaseIdentity(readAgentCommandFromRecord(await this.sessionStore.load(sessionId)));
+				const record = await this.sessionStore.load(sessionId);
+				const recordIdentity = readAcpxProcessLeaseIdentity(readAgentCommandFromRecord(record));
 				if (recordIdentity?.leaseId !== identity.leaseId || recordIdentity.gatewayInstanceId !== identity.gatewayInstanceId) await processLeaseStore.markState(identity.leaseId, "lost");
 			} catch {}
 		});
@@ -763,7 +809,7 @@ var AcpxRuntime = class {
 		}
 	}
 	async readCodexTurnFailureStderr(params) {
-		const record = await this.sessionStore.load(params.handle.acpxRecordId ?? params.handle.sessionKey);
+		const record = await this.sessionStore.load(params.handle.acpxRecordId ?? resolveAcpxSessionResource(params.handle));
 		return readCodexWrapperStderrTail({
 			wrapperRoot: this.wrapperRoot,
 			leaseId: readOpenClawLeaseIdFromRecord(record)
@@ -772,7 +818,7 @@ var AcpxRuntime = class {
 	async cleanupProcessTreeForRecord(handle, record) {
 		const leaseId = readOpenClawLeaseIdFromRecord(record);
 		const rootPid = readAgentPidFromRecord(record);
-		const sessionKeys = [handle.sessionKey, readSessionRecordName(record)];
+		const sessionKeys = [resolveAcpxSessionResource(handle), readSessionRecordName(record)];
 		const selectedLease = selectCurrentSessionLease({
 			leases: this.gatewayInstanceId && this.processLeaseStore ? await this.processLeaseStore.listOpen(this.gatewayInstanceId) : [],
 			sessionKeys,
@@ -828,18 +874,28 @@ var AcpxRuntime = class {
 		});
 	}
 	async ensureSession(input) {
-		return await this.runSerializedSessionEnsure(input.sessionKey, () => this.ensureSessionUnlocked(input));
+		const resource = assertAcpxSessionOwnerLocator(input, this.legacyBareSessionKeys);
+		return await this.runSerializedSessionEnsure(resource, () => this.ensureSessionUnlocked(input));
 	}
-	async ensureSessionUnlocked(input) {
-		assertSupportedRuntimeSessionMode(input.mode);
+	async ensureSessionUnlocked(logicalInput) {
+		assertSupportedRuntimeSessionMode(logicalInput.mode);
 		const command = resolveAgentCommand({
-			agentName: input.agent,
+			agentName: logicalInput.agent,
 			agentRegistry: this.agentRegistry
 		});
 		const delegate = this.resolveDelegateForSession({
 			command,
-			sessionKey: input.sessionKey
+			sessionKey: logicalInput.sessionKey,
+			agentId: logicalInput.agentId
 		});
+		const logicalTarget = {
+			sessionKey: logicalInput.sessionKey,
+			agentId: logicalInput.agentId
+		};
+		const input = {
+			...logicalInput,
+			sessionKey: resolveAcpxSessionResource(logicalInput)
+		};
 		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;
@@ -863,38 +919,42 @@ var AcpxRuntime = class {
 			command: stableLaunchCommand,
 			resumeSessionId: input.resumeSessionId
 		});
-		const handle = !codexModelOverride ? await this.runWithLaunchLease({
-			sessionKey: ensureInput.sessionKey,
-			command: stableLaunchCommand,
-			reusableCommand,
-			run: () => this.withCodexWrapperDiagnostics({
+		return {
+			...!codexModelOverride ? await this.runWithLaunchLease({
+				sessionKey: ensureInput.sessionKey,
 				command: stableLaunchCommand,
-				fallbackCode: "ACP_SESSION_INIT_FAILED",
-				run: () => ensureDelegateSessionWithModelFallback(delegate, ensureInput)
-			})
-		}) : await this.runWithLaunchLease({
-			sessionKey: input.sessionKey,
-			command: stableLaunchCommand,
-			reusableCommand,
-			run: () => this.codexAcpModelOverrideScope.run(codexModelOverride, () => this.withCodexWrapperDiagnostics({
+				reusableCommand,
+				run: () => this.withCodexWrapperDiagnostics({
+					command: stableLaunchCommand,
+					fallbackCode: "ACP_SESSION_INIT_FAILED",
+					run: () => ensureDelegateSessionWithModelFallback(delegate, ensureInput)
+				})
+			}) : await this.runWithLaunchLease({
+				sessionKey: input.sessionKey,
 				command: stableLaunchCommand,
-				fallbackCode: "ACP_SESSION_INIT_FAILED",
-				run: () => delegate.ensureSession(withAcpxSessionOptions(ensureInput))
-			}))
-		});
-		return appliedModel ? {
-			...handle,
-			appliedModel
-		} : handle;
+				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) {
-		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+		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;
 		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))) {
+			for await (const event of delegate.runTurn(withOpenClawManagedTurnTimeout(toAcpxResourceInput(input)))) {
 				if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
 					yield event;
 					continue;
@@ -929,7 +989,7 @@ var AcpxRuntime = class {
 			try {
 				return {
 					command,
-					turn: delegate.startTurn(withOpenClawManagedTurnTimeout(input))
+					turn: delegate.startTurn(withOpenClawManagedTurnTimeout(toAcpxResourceInput(input)))
 				};
 			} catch (error) {
 				if (!isCodexAcpCommand(command) || !isGenericInternalAcpError(error)) throw error;
@@ -999,23 +1059,24 @@ var AcpxRuntime = class {
 		};
 	}
 	getCapabilities(input) {
-		return this.delegate.getCapabilities(input);
+		return this.delegate.getCapabilities(input?.handle ? toAcpxResourceInput({ handle: input.handle }) : input);
 	}
 	async getStatus(input) {
 		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		return this.resolveDelegateForOperationSnapshot(input.handle, snapshot).getStatus(input);
+		return this.resolveDelegateForOperationSnapshot(input.handle, snapshot).getStatus(toAcpxResourceInput(input));
 	}
 	async setMode(input) {
 		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).setMode(input));
+		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).setMode(toAcpxResourceInput(input)));
 	}
 	async setConfigOption(input) {
 		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.setConfigOptionUnlocked(input, snapshot));
+		return await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.setConfigOptionUnlocked(input, snapshot));
 	}
-	async setConfigOptionUnlocked(input, snapshot) {
+	async setConfigOptionUnlocked(logicalInput, snapshot) {
 		const { command } = snapshot;
-		const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
+		const delegate = this.resolveDelegateForOperationSnapshot(logicalInput.handle, snapshot);
+		const input = toAcpxResourceInput(logicalInput);
 		const key = input.key.trim().toLowerCase();
 		const isCodexAcp = isCodexAcpCommand(command);
 		if (WIRE_TIMEOUT_CONFIG_KEYS.has(key) && (isCodexAcp || isClaudeAcpCommand(command))) return;
@@ -1024,45 +1085,43 @@ var AcpxRuntime = class {
 				const classification = classifyCodexAcpModelRequest(input.value);
 				if (classification.kind === "unsupported") failUnsupportedCodexAcpModel(input.value);
 				const { override } = classification;
-				if (override.model) await delegate.setConfigOption({
+				const modelResult = override.model ? await delegate.setConfigOption({
 					...input,
 					key: "model",
 					value: override.model
-				});
-				if (override.reasoningEffort) await delegate.setConfigOption({
+				}) : void 0;
+				if (override.reasoningEffort) return await delegate.setConfigOption({
 					...input,
 					key: "reasoning_effort",
 					value: override.reasoningEffort
 				});
-				return;
+				return modelResult;
 			}
 			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({
+				if (!reasoningEffort) throw new AcpRuntimeError("ACP_BACKEND_UNSUPPORTED_CONTROL", "Clearing Codex reasoning effort on an existing session is unsupported. Choose a supported explicit effort; the current effort is unchanged.");
+				return await delegate.setConfigOption({
 					...input,
 					key: "reasoning_effort",
 					value: reasoningEffort
 				});
-				return;
 			}
 		}
-		if (isClaudeAcpCommand(command) && key === "model") {
-			await delegate.setConfigOption({
-				...input,
-				value: normalizeClaudeAcpModelOverride(input.value) ?? input.value
-			});
-			return;
-		}
-		await delegate.setConfigOption(input);
+		if (isClaudeAcpCommand(command) && key === "model") return await delegate.setConfigOption({
+			...input,
+			value: normalizeClaudeAcpModelOverride(input.value) ?? input.value
+		});
+		return await delegate.setConfigOption(input);
 	}
 	async cancel(input) {
 		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
-		await this.resolveDelegateForOperationSnapshot(input.handle, snapshot).cancel(input);
+		await this.resolveDelegateForOperationSnapshot(input.handle, snapshot).cancel(toAcpxResourceInput(input));
 	}
 	async prepareFreshSession(input) {
-		this.sessionStore.markFresh(input.sessionKey);
+		const resource = assertAcpxSessionOwnerLocator(input, this.legacyBareSessionKeys);
+		this.sessionStore.markFresh(resource);
+		this.legacyBareSessionKeys.delete(resource);
 	}
 	async close(input) {
 		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
@@ -1073,7 +1132,7 @@ var AcpxRuntime = class {
 			let closeSucceeded;
 			try {
 				await delegate.close({
-					handle: input.handle,
+					handle: toAcpxResourceInput(input).handle,
 					reason: input.reason,
 					discardPersistentState: input.discardPersistentState
 				});
@@ -1082,8 +1141,11 @@ var AcpxRuntime = class {
 				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);
+			if (closeSucceeded) this.releaseManagedToolsDelegateForSession(resolveAcpxSessionResource(input.handle));
+			if (closeSucceeded && input.discardPersistentState) await this.prepareFreshSession({
+				...input.handle,
+				persistedHandle: input.handle
+			});
 		} finally {
 			if (cleanupSucceeded) await this.finalizeProcessLeaseForOperation(input.handle, closeLease);
 			else await this.releaseProcessLeaseAfterUncertainFailure(closeLease);