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

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

@@ -1,11 +1,11 @@
-import { _ as splitCommandParts, a as hashAcpxProcessCommand, l as readAcpxProcessLeaseIdentity, r as createAcpxProcessLeaseId, u as withAcpxLeaseEnvironment } from "./process-lease-DSLDgiNl.js";
+import { d as withAcpxLeaseEnvironment, i as createAcpxProcessLeaseId, o as hashAcpxProcessCommand, t as ACPX_PROBE_LEASE_SESSION_KEY, u as readAcpxProcessLeaseIdentity, v as splitCommandParts } from "./process-lease-Cwvj7WGe.js";
 import { AcpRuntimeError } from "./runtime-api.js";
-import { c as CODEX_ACP_PACKAGE, n as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxProcessTree, u as OPENCLAW_CODEX_CONFIG_ARG } from "./process-reaper-DFwbcdPa.js";
+import { d as OPENCLAW_CODEX_CONFIG_ARG, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, r as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxPendingLease } from "./process-reaper-DzVuCxl3.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import fs from "node:fs/promises";
 import path, { resolve } from "node:path";
+import fs from "node:fs/promises";
+import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { ACPX_BACKEND_ID, AcpxRuntime as AcpxRuntime$1, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isRequestedModelUnsupportedError } from "acpx/runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
@@ -440,6 +440,7 @@ var AcpxRuntime = class {
 		this.ensureSessionTails = /* @__PURE__ */ new Map();
 		this.processLeaseTransitionTails = /* @__PURE__ */ new Map();
 		this.processLeaseOperationCounts = /* @__PURE__ */ new Map();
+		this.uncertainProcessLeaseIds = /* @__PURE__ */ new Set();
 		const { openclawProcessCleanup, ...delegateTestOptions } = testOptions ?? {};
 		this.processCleanupDeps = openclawProcessCleanup;
 		this.wrapperRoot = options.openclawWrapperRoot;
@@ -477,6 +478,7 @@ var AcpxRuntime = class {
 			agentName: normalizeAgentName(options.probeAgent) ?? "codex",
 			agentRegistry: this.agentRegistry
 		});
+		this.probeCommand = probeCommand;
 		const useBridgeSafeProbe = this.managedToolsMcpBridgeEnabled || shouldUseBridgeSafeDelegateForCommand(probeCommand);
 		this.probeDelegate = useBridgeSafeProbe ? this.bridgeSafeDelegate : this.delegate;
 	}
@@ -508,33 +510,22 @@ var AcpxRuntime = class {
 		if (!normalizedSessionKey) return;
 		this.managedToolsSessionDelegates.delete(normalizedSessionKey);
 	}
-	async resolveDelegateForHandle(handle) {
+	async loadOperationSnapshotForHandle(handle) {
 		const record = await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey);
-		return this.resolveDelegateForLoadedRecord(handle, record);
+		return {
+			record,
+			command: readAgentCommandFromRecord(record) ?? resolveAgentCommand({
+				agentName: readAgentFromHandle(handle),
+				agentRegistry: this.agentRegistry
+			})
+		};
 	}
-	resolveDelegateForLoadedRecord(handle, record) {
-		const recordCommand = readAgentCommandFromRecord(record);
-		if (recordCommand) return this.resolveDelegateForSession({
-			command: recordCommand,
-			sessionKey: handle.sessionKey
-		});
-		const command = resolveAgentCommand({
-			agentName: readAgentFromHandle(handle),
-			agentRegistry: this.agentRegistry
-		});
+	resolveDelegateForOperationSnapshot(handle, snapshot) {
 		return this.resolveDelegateForSession({
-			command,
+			command: snapshot.command,
 			sessionKey: handle.sessionKey
 		});
 	}
-	async resolveCommandForHandle(handle) {
-		const recordCommand = readAgentCommandFromRecord(await this.sessionStore.load(handle.acpxRecordId ?? handle.sessionKey));
-		if (recordCommand) return recordCommand;
-		return resolveAgentCommand({
-			agentName: readAgentFromHandle(handle),
-			agentRegistry: this.agentRegistry
-		});
-	}
 	commandWithLaunchLease(command) {
 		const launch = this.launchLeaseScope.getStore();
 		if (!launch) return command;
@@ -571,7 +562,7 @@ var AcpxRuntime = class {
 		const processLeaseStore = this.processLeaseStore;
 		const reusableIdentity = readAcpxProcessLeaseIdentity(params.reusableCommand);
 		const canReuseLeaseIdentity = reusableIdentity?.gatewayInstanceId === this.gatewayInstanceId;
-		const leaseId = canReuseLeaseIdentity ? reusableIdentity.leaseId : createAcpxProcessLeaseId();
+		const leaseId = canReuseLeaseIdentity ? reusableIdentity.leaseId : params.finalizeCompletedProbe ? `probe-${hashAcpxProcessCommand(`${this.gatewayInstanceId}\0${extractGeneratedWrapperPath(params.command)}`)}` : createAcpxProcessLeaseId();
 		const leasedCommand = withAcpxLeaseEnvironment({
 			command: params.command,
 			leaseId,
@@ -604,18 +595,18 @@ var AcpxRuntime = class {
 		});
 		try {
 			const result = await this.launchLeaseScope.run(launch, params.run);
-			await this.finalizeProcessLeaseForSession(params.sessionKey, launch);
+			if (params.finalizeCompletedProbe) await this.finalizeCompletedProbeLease(launch);
+			else await this.finalizeProcessLeaseForSession(params.sessionKey, launch);
 			return result;
 		} catch (error) {
-			await this.retirePendingProcessLease(launch);
+			await this.releaseProcessLeaseAfterUncertainFailure(launch);
 			throw error;
 		}
 	}
-	async prepareProcessLeaseForOperation(handle) {
+	async prepareProcessLeaseForOperation(handle, record) {
 		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);
@@ -690,25 +681,44 @@ var AcpxRuntime = class {
 			const lease = await processLeaseStore.load(identity.leaseId);
 			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId) return;
 			if (lease.rootPid <= 0) {
+				if (this.uncertainProcessLeaseIds.has(identity.leaseId)) return;
 				await processLeaseStore.markState(identity.leaseId, "lost");
 				return;
 			}
+			this.uncertainProcessLeaseIds.delete(identity.leaseId);
 			try {
 				const recordIdentity = readAcpxProcessLeaseIdentity(readAgentCommandFromRecord(await this.sessionStore.load(sessionId)));
 				if (recordIdentity?.leaseId !== identity.leaseId || recordIdentity.gatewayInstanceId !== identity.gatewayInstanceId) await processLeaseStore.markState(identity.leaseId, "lost");
 			} catch {}
 		});
 	}
-	async retirePendingProcessLease(identity) {
+	async finalizeCompletedProbeLease(identity) {
+		if (!this.processLeaseStore) return;
+		const processLeaseStore = this.processLeaseStore;
+		await this.releaseProcessLeaseOperation(identity, async () => {
+			const lease = await processLeaseStore.load(identity.leaseId);
+			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId) return;
+			if (lease.rootPid > 0) return;
+			await cleanupOpenClawOwnedAcpxPendingLease({
+				leaseId: lease.leaseId,
+				gatewayInstanceId: lease.gatewayInstanceId,
+				wrapperRoot: lease.wrapperRoot,
+				wrapperPath: lease.wrapperPath,
+				deps: this.processCleanupDeps
+			});
+		});
+	}
+	async releaseProcessLeaseAfterUncertainFailure(identity) {
 		if (!identity || !this.processLeaseStore) return;
+		this.uncertainProcessLeaseIds.add(identity.leaseId);
 		const processLeaseStore = this.processLeaseStore;
 		await this.releaseProcessLeaseOperation(identity, async () => {
 			const lease = await processLeaseStore.load(identity.leaseId);
-			if (lease?.gatewayInstanceId === identity.gatewayInstanceId && lease.rootPid <= 0) await processLeaseStore.markState(identity.leaseId, "lost");
+			if (!lease || lease.gatewayInstanceId !== identity.gatewayInstanceId || lease.rootPid > 0) this.uncertainProcessLeaseIds.delete(identity.leaseId);
 		});
 	}
-	async runWithProcessLeaseForHandle(handle, run) {
-		const identity = await this.prepareProcessLeaseForOperation(handle);
+	async runWithProcessLeaseForHandle(handle, record, run) {
+		const identity = await this.prepareProcessLeaseForOperation(handle, record);
 		try {
 			return await run();
 		} finally {
@@ -780,7 +790,7 @@ 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.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({
@@ -801,11 +811,21 @@ var AcpxRuntime = class {
 	isHealthy() {
 		return this.probeDelegate.isHealthy();
 	}
-	probeAvailability() {
-		return this.probeDelegate.probeAvailability();
+	async probeAvailability() {
+		await this.runWithLaunchLease({
+			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
+			command: this.probeCommand,
+			finalizeCompletedProbe: true,
+			run: () => this.probeDelegate.probeAvailability()
+		});
 	}
-	doctor() {
-		return this.probeDelegate.doctor();
+	async doctor() {
+		return await this.runWithLaunchLease({
+			sessionKey: ACPX_PROBE_LEASE_SESSION_KEY,
+			command: this.probeCommand,
+			finalizeCompletedProbe: true,
+			run: () => this.probeDelegate.doctor()
+		});
 	}
 	async ensureSession(input) {
 		return await this.runSerializedSessionEnsure(input.sessionKey, () => this.ensureSessionUnlocked(input));
@@ -868,11 +888,12 @@ var AcpxRuntime = class {
 		} : handle;
 	}
 	async *runTurn(input) {
-		const turnLease = await this.prepareProcessLeaseForOperation(input.handle);
+		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+		const turnLease = await this.prepareProcessLeaseForOperation(input.handle, record);
 		let command;
 		try {
-			command = await this.resolveCommandForHandle(input.handle);
-			const delegate = await this.resolveDelegateForHandle(input.handle);
+			command = (await this.loadOperationSnapshotForHandle(input.handle)).command;
+			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, await this.loadOperationSnapshotForHandle(input.handle));
 			for await (const event of delegate.runTurn(withOpenClawManagedTurnTimeout(input))) {
 				if (event.type !== "error" || !isCodexAcpCommand(command) || !isGenericInternalAcpErrorMessage(event.message)) {
 					yield event;
@@ -900,12 +921,11 @@ var AcpxRuntime = class {
 	}
 	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 snapshotPromise = this.loadOperationSnapshotForHandle(input.handle);
+		const turnLeasePromise = snapshotPromise.then(({ record }) => this.prepareProcessLeaseForOperation(input.handle, record));
+		const turnPromise = Promise.all([snapshotPromise, turnLeasePromise]).then(async ([snapshot]) => {
+			const { command } = snapshot;
+			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
 			try {
 				return {
 					command,
@@ -979,18 +999,20 @@ var AcpxRuntime = class {
 		return this.delegate.getCapabilities(input);
 	}
 	async getStatus(input) {
-		return (await this.resolveDelegateForHandle(input.handle)).getStatus(input);
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		return this.resolveDelegateForOperationSnapshot(input.handle, snapshot).getStatus(input);
 	}
 	async setMode(input) {
-		const delegate = await this.resolveDelegateForHandle(input.handle);
-		await this.runWithProcessLeaseForHandle(input.handle, () => delegate.setMode(input));
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.resolveDelegateForOperationSnapshot(input.handle, snapshot).setMode(input));
 	}
 	async setConfigOption(input) {
-		await this.runWithProcessLeaseForHandle(input.handle, () => this.setConfigOptionUnlocked(input));
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		await this.runWithProcessLeaseForHandle(input.handle, snapshot.record, () => this.setConfigOptionUnlocked(input, snapshot));
 	}
-	async setConfigOptionUnlocked(input) {
-		const delegate = await this.resolveDelegateForHandle(input.handle);
-		const command = await this.resolveCommandForHandle(input.handle);
+	async setConfigOptionUnlocked(input, snapshot) {
+		const { command } = snapshot;
+		const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
 		const key = input.key.trim().toLowerCase();
 		const isCodexAcp = isCodexAcpCommand(command);
 		if (WIRE_TIMEOUT_CONFIG_KEYS.has(key) && (isCodexAcp || isClaudeAcpCommand(command))) return;
@@ -1033,19 +1055,19 @@ var AcpxRuntime = class {
 		await delegate.setConfigOption(input);
 	}
 	async cancel(input) {
-		const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
-		await this.resolveDelegateForLoadedRecord(input.handle, record).cancel(input);
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		await this.resolveDelegateForOperationSnapshot(input.handle, snapshot).cancel(input);
 	}
 	async prepareFreshSession(input) {
 		this.sessionStore.markFresh(input.sessionKey);
 	}
 	async close(input) {
-		const closeLease = await this.prepareProcessLeaseForOperation(input.handle);
+		const snapshot = await this.loadOperationSnapshotForHandle(input.handle);
+		const closeLease = await this.prepareProcessLeaseForOperation(input.handle, snapshot.record);
 		let cleanupSucceeded = false;
 		try {
-			const record = await this.sessionStore.load(input.handle.acpxRecordId ?? input.handle.sessionKey);
+			const delegate = this.resolveDelegateForOperationSnapshot(input.handle, snapshot);
 			let closeSucceeded;
-			const delegate = this.resolveDelegateForLoadedRecord(input.handle, record);
 			try {
 				await delegate.close({
 					handle: input.handle,
@@ -1054,26 +1076,23 @@ var AcpxRuntime = class {
 				});
 				closeSucceeded = true;
 			} finally {
-				await this.cleanupProcessTreeForRecord(input.handle, record);
+				await this.cleanupProcessTreeForRecord(input.handle, snapshot.record);
 				cleanupSucceeded = true;
 			}
 			if (closeSucceeded) this.releaseManagedToolsDelegateForSession(input.handle.sessionKey);
 			if (closeSucceeded && input.discardPersistentState) this.sessionStore.markFresh(input.handle.sessionKey);
 		} finally {
 			if (cleanupSucceeded) await this.finalizeProcessLeaseForOperation(input.handle, closeLease);
-			else await this.retirePendingProcessLease(closeLease);
+			else await this.releaseProcessLeaseAfterUncertainFailure(closeLease);
 		}
 	}
 };
 /** Test-only hooks for ACPX runtime behavior that is otherwise private. */
 const testing = {
 	appendCodexAcpConfigOverrides,
-	assertSupportedRuntimeSessionMode,
-	classifyCodexAcpModelRequest,
 	isClaudeAcpCommand,
 	isCodexAcpCommand,
-	normalizeAgentCommand,
-	normalizeClaudeAcpModelOverride
+	normalizeAgentCommand
 };
 //#endregion
-export { ACPX_BACKEND_ID, AcpxRuntime, testing as __testing, testing, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState };
+export { ACPX_BACKEND_ID, AcpxRuntime, createAcpRuntime, createAgentRegistry, createFileSessionStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, testing };

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

@@ -1,19 +1,18 @@
-import { n as createLazyAcpRuntimeProxy } from "./register.runtime-BbS2JTTv.js";
-import "./config-schema-lrk5nlcV.js";
-import { _ as splitCommandParts, c as openAcpxProcessLeaseStateStore, d as ACPX_GATEWAY_INSTANCE_KEY, f as ACPX_GATEWAY_INSTANCE_NAMESPACE, g as quoteCommandPart, h as normalizeAcpxGatewayInstanceRecord, i as createAcpxProcessLeaseStore, n as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, t as OPENCLAW_ACPX_LEASE_ID_ARG } from "./process-lease-DSLDgiNl.js";
-import { registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "./runtime-api.js";
-import { a as resolveAcpxPluginRoot, c as CODEX_ACP_PACKAGE, i as resolveAcpxPluginConfig, l as LEGACY_CODEX_ACP_PACKAGE, o as toAcpMcpServers, r as reapStaleOpenClawOwnedAcpxOrphans, s as CODEX_ACP_BIN, t as cleanupOpenClawOwnedAcpxProcessTree, u as OPENCLAW_CODEX_CONFIG_ARG } from "./process-reaper-DFwbcdPa.js";
+import { n as createLazyAcpRuntimeProxy } from "./register.runtime-C29AY8LI.js";
+import "./config-schema-DN_uAi4R.js";
+import { _ as quoteCommandPart, a as createAcpxProcessLeaseStore, f as ACPX_GATEWAY_INSTANCE_KEY, g as normalizeAcpxGatewayInstanceRecord, l as openAcpxProcessLeaseStateStore, n as OPENCLAW_ACPX_LEASE_ID_ARG, p as ACPX_GATEWAY_INSTANCE_NAMESPACE, r as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, v as splitCommandParts } from "./process-lease-Cwvj7WGe.js";
+import { a as resolveAcpxPluginConfig, c as CODEX_ACP_BIN, d as OPENCLAW_CODEX_CONFIG_ARG, i as reapStaleOpenClawOwnedAcpxOrphans, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, o as resolveAcpxPluginRoot, s as toAcpMcpServers, t as cleanupOpenClawOwnedAcpxPendingLease, u as LEGACY_CODEX_ACP_PACKAGE } from "./process-reaper-DzVuCxl3.js";
 import { createRequire } from "node:module";
 import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { isRecord, normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs";
-import fs$1 from "node:fs/promises";
-import path from "node:path";
 import os from "node:os";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { inspect } from "node:util";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
 import { parse, stringify } from "smol-toml";
 //#region extensions/acpx/src/codex-trust-config.ts
@@ -893,14 +892,11 @@ function extractConfiguredAdapterArgs(params) {
 	if (isAcpBinName(parts[0] ?? "", params.binName)) return parts.slice(1);
 	if (basename(parts[0] ?? "") === "node" && isAcpBinName(parts[1] ?? "", params.binName)) return parts.slice(2);
 }
-function isConfigRecord(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 function mergeConfigRecords(base, override) {
 	const merged = { ...base };
 	for (const [key, value] of Object.entries(override)) {
 		const existing = merged[key];
-		const nextValue = isConfigRecord(existing) && isConfigRecord(value) ? mergeConfigRecords(existing, value) : value;
+		const nextValue = isRecord(existing) && isRecord(value) ? mergeConfigRecords(existing, value) : value;
 		Object.defineProperty(merged, key, {
 			value: nextValue,
 			configurable: true,
@@ -976,7 +972,7 @@ function buildCodexAcpWrapperCommand(wrapperPath, configuredCommand) {
 }
 async function persistMigratedCodexMcpConfig(params) {
 	const mcpServers = params.migratedConfig?.mcp_servers;
-	if (!isConfigRecord(mcpServers)) return;
+	if (!isRecord(mcpServers)) return;
 	const configPath = path.join(params.codexHome, "config.toml");
 	const merged = mergeConfigRecords(parse(await fs$1.readFile(configPath, "utf8")), { mcp_servers: mcpServers });
 	await fs$1.writeFile(configPath, stringify(merged), "utf8");
@@ -1025,8 +1021,7 @@ async function prepareAcpxCodexAuthConfig(params) {
 */
 const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
 const SKIP_RUNTIME_PROBE_ENV = "OPENCLAW_SKIP_ACPX_RUNTIME_PROBE";
-const ACPX_BACKEND_ID = "acpx";
-const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-By_lR8uk.js"));
+const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-BmzHUTK8.js"));
 /** Convert ACPX timeout seconds into timer-safe milliseconds. */
 function resolveAcpxTimerTimeoutMs(timeoutSeconds) {
 	if (timeoutSeconds === void 0) return;
@@ -1067,13 +1062,6 @@ function createLazyDefaultRuntime(params) {
 		}
 	};
 }
-function warnOnIgnoredLegacyCompatibilityConfig(params) {
-	const ignoredFields = [];
-	if (params.pluginConfig.legacyCompatibilityConfig.queueOwnerTtlSeconds != null) ignoredFields.push("queueOwnerTtlSeconds");
-	if (params.pluginConfig.legacyCompatibilityConfig.strictWindowsCmdWrapper === false) ignoredFields.push("strictWindowsCmdWrapper=false");
-	if (ignoredFields.length === 0) return;
-	params.logger?.warn(`embedded acpx runtime ignores legacy compatibility config: ${ignoredFields.join(", ")}`);
-}
 function formatDoctorDetail(detail) {
 	if (!detail) return null;
 	if (typeof detail === "string") return detail.trim() || null;
@@ -1152,21 +1140,22 @@ async function reapOpenAcpxProcessLeases(params) {
 	const leases = await params.leaseStore.listOpen(params.gatewayInstanceId);
 	const inspectedPids = [];
 	const terminatedPids = [];
-	const pendingLeaseRootResults = /* @__PURE__ */ new Map();
+	const legacyWrapperRoots = /* @__PURE__ */ new Set();
 	for (const lease of leases) {
 		if (lease.rootPid <= 0) {
+			legacyWrapperRoots.add(lease.wrapperRoot);
 			await params.leaseStore.markState(lease.leaseId, "closing");
-			let result = pendingLeaseRootResults.get(lease.wrapperRoot);
-			if (!result) {
-				result = await reapStaleOpenClawOwnedAcpxOrphans({
-					wrapperRoot: lease.wrapperRoot,
-					deps: params.deps
-				});
-				pendingLeaseRootResults.set(lease.wrapperRoot, result);
-				inspectedPids.push(...result.inspectedPids);
-				terminatedPids.push(...result.terminatedPids);
-			}
-			await params.leaseStore.markState(lease.leaseId, result.terminatedPids.length > 0 ? "closed" : "lost");
+			const result = await cleanupOpenClawOwnedAcpxPendingLease({
+				leaseId: lease.leaseId,
+				gatewayInstanceId: lease.gatewayInstanceId,
+				wrapperRoot: lease.wrapperRoot,
+				wrapperPath: lease.wrapperPath,
+				deps: params.deps
+			});
+			inspectedPids.push(...result.inspectedPids);
+			terminatedPids.push(...result.terminatedPids);
+			const retryableEvidenceFailure = result.skippedReason === "ambiguous-root" || result.skippedReason === "process-list-unavailable" || result.skippedReason === "unsupported-platform" || result.skippedReason === "unverified-root" || lease.sessionKey === "openclaw:acpx:probe" && result.skippedReason === "missing-root";
+			await params.leaseStore.markState(lease.leaseId, retryableEvidenceFailure ? "open" : result.terminatedPids.length > 0 ? "closed" : "lost");
 			continue;
 		}
 		await params.leaseStore.markState(lease.leaseId, "closing");
@@ -1179,7 +1168,15 @@ async function reapOpenAcpxProcessLeases(params) {
 		});
 		inspectedPids.push(...result.inspectedPids);
 		terminatedPids.push(...result.terminatedPids);
-		await params.leaseStore.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" ? "open" : result.terminatedPids.length > 0 ? "closed" : "lost");
+		await params.leaseStore.markState(lease.leaseId, result.skippedReason === "process-list-unavailable" || result.skippedReason === "unsupported-platform" ? "open" : result.terminatedPids.length > 0 ? "closed" : "lost");
+	}
+	for (const wrapperRoot of legacyWrapperRoots) {
+		const legacyResult = await reapStaleOpenClawOwnedAcpxOrphans({
+			wrapperRoot,
+			deps: params.deps
+		});
+		inspectedPids.push(...legacyResult.inspectedPids);
+		terminatedPids.push(...legacyResult.terminatedPids);
 	}
 	return {
 		inspectedPids,
@@ -1187,7 +1184,7 @@ async function reapOpenAcpxProcessLeases(params) {
 	};
 }
 /** Create the ACPX plugin service that owns runtime registration and cleanup. */
-function createAcpxRuntimeService(params = {}) {
+function createAcpxRuntimeService(params) {
 	let runtime = null;
 	let lifecycleRevision = 0;
 	return {
@@ -1225,10 +1222,6 @@ function createAcpxRuntimeService(params = {}) {
 				deps: params.processCleanupDeps
 			}));
 			if (startupReap.terminatedPids.length > 0) ctx.logger.info(`reaped ${startupReap.terminatedPids.length} stale OpenClaw-owned ACPX process${startupReap.terminatedPids.length === 1 ? "" : "es"}`);
-			warnOnIgnoredLegacyCompatibilityConfig({
-				pluginConfig,
-				logger: ctx.logger
-			});
 			const startedRuntime = await measureAcpxStartup(ctx, "runtime.create", () => params.runtimeFactory ? params.runtimeFactory({
 				pluginConfig,
 				gatewayInstanceId,
@@ -1246,11 +1239,11 @@ function createAcpxRuntimeService(params = {}) {
 			const shouldProbeRuntime = shouldProbeRuntimeAtStartup();
 			detailAcpxStartup(ctx, "probe-policy", [["startupProbeEnabledCount", shouldProbeRuntime ? 1 : 0], ["probeAgent", pluginConfig.probeAgent ?? "default"]]);
 			await measureAcpxStartup(ctx, "backend.register", () => {
-				registerAcpRuntimeBackend({
-					id: ACPX_BACKEND_ID,
+				const backend = {
 					runtime: startedRuntime,
 					...shouldProbeRuntime ? { healthy: () => runtime?.isHealthy() ?? false } : {}
-				});
+				};
+				params.backendLifecycle.publish(backend);
 				ctx.logger.info(`embedded acpx runtime backend registered (cwd: ${pluginConfig.cwd})`);
 			});
 			if (!shouldProbeRuntime) return;
@@ -1279,7 +1272,7 @@ function createAcpxRuntimeService(params = {}) {
 		},
 		async stop(_ctx) {
 			lifecycleRevision += 1;
-			unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
+			if (runtime) params.backendLifecycle.retract(runtime);
 			runtime = null;
 		}
 	};

package/openclaw.plugin.json

@@ -1,5 +1,9 @@
 {
   "id": "acpx",
+  "doctorContract": {
+    "configRepair": true,
+    "stateMigrations": true
+  },
   "activation": {
     "onStartup": true
   },
@@ -37,18 +41,11 @@
       "openClawToolsMcpBridge": {
         "type": "boolean"
       },
-      "strictWindowsCmdWrapper": {
-        "type": "boolean"
-      },
       "timeoutSeconds": {
         "type": "number",
         "minimum": 0.001,
         "default": 120
       },
-      "queueOwnerTtlSeconds": {
-        "type": "number",
-        "minimum": 0
-      },
       "piSessionCatalog": {
         "type": "object",
         "additionalProperties": false,
@@ -87,6 +84,7 @@
         "type": "object",
         "additionalProperties": {
           "type": "object",
+          "additionalProperties": false,
           "properties": {
             "command": {
               "type": "string",
@@ -129,21 +127,11 @@
       "help": "Default off. When enabled, inject the built-in OpenClaw core-tools MCP server into embedded ACP sessions so ACP agents can call selected built-in tools such as cron.",
       "advanced": true
     },
-    "strictWindowsCmdWrapper": {
-      "label": "Strict Windows cmd Wrapper",
-      "help": "Legacy compatibility field. The current embedded acpx/runtime package uses its own Windows command resolution behavior. Setting this to false is accepted for compatibility and logged as ignored.",
-      "advanced": true
-    },
     "timeoutSeconds": {
       "label": "Runtime Operation Timeout Seconds",
       "help": "Timeout for embedded ACP runtime startup and control operations. ACP turns use OpenClaw agent/run timeouts.",
       "advanced": true
     },
-    "queueOwnerTtlSeconds": {
-      "label": "Queue Owner TTL Seconds",
-      "help": "Reserved compatibility field for the older embedded ACPX queue-owner path. Accepted for compatibility and logged as ignored.",
-      "advanced": true
-    },
     "piSessionCatalog.enabled": {
       "label": "Pi Session Catalog",
       "help": "Auto-detect Pi sessions on the Gateway and paired nodes, then show them in the sessions sidebar."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/acpx",
-  "version": "2026.7.2-beta.7",
+  "version": "2026.8.1-beta.2",
   "description": "OpenClaw ACP runtime backend with plugin-owned session and transport management.",
   "repository": {
     "type": "git",
@@ -43,10 +43,10 @@
       ]
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.7"
+      "pluginApi": ">=2026.8.1-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.7",
+      "openclawVersion": "2026.8.1-beta.2",
       "staticAssets": [
         {
           "source": "./src/runtime-internals/mcp-proxy.mjs",
@@ -74,7 +74,7 @@
     "skills/**"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.7"
+    "openclaw": ">=2026.8.1-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {