@openclaw/codex 2026.9.5 → 2026.9.6

package/dist/.setup/{plugin-approval-roundtrip-CjfzafAZ.mjs → plugin-approval-roundtrip-C0MZzCuP.mjs}

@@ -1,4 +1,4 @@
-import { it as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-BpTtuLQ5.mjs";
+import { it as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-DA4VR4Eb.mjs";
 import { isApprovalNotFoundError, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/plugin-approval-roundtrip.ts

package/dist/.setup/{plugin-inventory-DUle8DLz.mjs → plugin-inventory-BoRei8Z4.mjs}

@@ -1,6 +1,6 @@
 import { f as resolveCodexPluginsPolicy } from "./config-parsing-CcB9iPoq.mjs";
-import { c as findCodexAppById } from "./plugin-app-cache-key-BOxKP7db.mjs";
-import "./config-CedDWjM-.mjs";
+import { c as findCodexAppById } from "./plugin-app-cache-key-B2CsSdnV.mjs";
+import "./config-BoTP_mrL.mjs";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/config-contracts.ts
 const CODEX_PLUGINS_MARKETPLACE_NAME = "openai-curated";
@@ -114,8 +114,16 @@ async function readCodexPluginInventory(params) {
 			apps
 		});
 	}
+	const missingKeys = /* @__PURE__ */ new Set();
+	for (const diagnostic of diagnostics) if (diagnostic.code === "plugin_missing" || diagnostic.code === "marketplace_missing") {
+		if (diagnostic.plugin) missingKeys.add(diagnostic.plugin.configKey);
+		embeddedAgentLog.error(diagnostic.message, { code: diagnostic.code });
+	}
 	return {
-		policy,
+		policy: {
+			...policy,
+			pluginPolicies: policy.pluginPolicies.filter((plugin) => !missingKeys.has(plugin.configKey))
+		},
 		records,
 		diagnostics,
 		...appInventory ? { appInventory } : {}
@@ -196,7 +204,7 @@ function readCachedAppInventory(params) {
 	if (!params.appCache || !params.appCacheKey) return;
 	const request = async (method, requestParams) => await params.request(method, requestParams);
 	return params.appCache.read({
-		key: params.appCacheKey,
+		key: params.appInventoryCacheKey ?? params.appCacheKey,
 		request,
 		nowMs: params.nowMs,
 		suppressRefresh: params.suppressAppInventoryRefresh
@@ -239,6 +247,7 @@ function resolveOwnedApps(params) {
 		return [];
 	}
 	const appInfos = params.appInventory?.snapshot?.apps ?? [];
+	const installedApps = params.appInventory?.snapshot?.installedApps ?? [];
 	return detailApps.map((app) => {
 		const info = findCodexAppById(appInfos, app.id);
 		if (!info) return {
@@ -251,9 +260,9 @@ function resolveOwnedApps(params) {
 		return Object.assign({
 			id: info.id,
 			name: app.name,
-			accessible: info.isAccessible,
-			enabled: info.isEnabled,
-			needsAuth: !info.isAccessible
+			accessible: true,
+			enabled: findCodexAppById(installedApps, info.id)?.enabled ?? false,
+			needsAuth: false
 		}, resolveOwnedAppApprovalOverrideKeys(info));
 	}).toSorted((left, right) => left.id.localeCompare(right.id));
 }

package/dist/.setup/{plugin-marketplace-discovery-P-Vndfqq.mjs → plugin-marketplace-discovery-CDOi8IFs.mjs}

@@ -9,6 +9,9 @@ function hasCodexAdminScope(ctx) {
 function canMutateCodexHost(ctx) {
 	return ctx.senderIsOwner === true || hasCodexAdminScope(ctx);
 }
+function assertCodexHostOwnerCurrent(ctx) {
+	if (!hasCodexAdminScope(ctx)) ctx.assertOwnerCurrent?.();
+}
 //#endregion
 //#region extensions/codex/src/plugin-marketplace-discovery.ts
 /** Read-only discovery of Codex-owned local, curated, and remote plugin marketplaces. */
@@ -134,4 +137,4 @@ function boundedCatalogText(value) {
 	return sanitized.replace(/\s+/g, " ").trim().slice(0, MAX_PLUGIN_METADATA_LENGTH);
 }
 //#endregion
-export { CODEX_HOST_INSPECTION_AUTH_ERROR as a, hasCodexAdminScope as c, CODEX_FULL_PERMISSIONS_AUTH_ERROR as i, filterCodexMarketplacePlugins as n, CODEX_NATIVE_EXECUTION_AUTH_ERROR as o, parseCodexPluginMarketplaceId as r, canMutateCodexHost as s, discoverCodexMarketplacePlugins as t };
+export { CODEX_HOST_INSPECTION_AUTH_ERROR as a, canMutateCodexHost as c, CODEX_FULL_PERMISSIONS_AUTH_ERROR as i, hasCodexAdminScope as l, filterCodexMarketplacePlugins as n, CODEX_NATIVE_EXECUTION_AUTH_ERROR as o, parseCodexPluginMarketplaceId as r, assertCodexHostOwnerCurrent as s, discoverCodexMarketplacePlugins as t };

package/dist/.setup/{plugin-metadata-cache-DsS5buNa.mjs → plugin-metadata-cache-Ctmo83k_.mjs}

@@ -1,15 +1,167 @@
-import { h as resolveCodexAppServerHomeDir } from "./config-security-BRQ2mgW9.mjs";
-import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-vXs2929Q.mjs";
-import { o as resolveCodexComputerUseConfig } from "./config-options-BsanJ8QG.mjs";
-import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-DP6Rib3P.mjs";
-import { n as describeControlFailure } from "./capabilities-_vXcZGSx.mjs";
-import { i as requestCodexAppServerJson } from "./request-BioXJLYa.mjs";
-import "./config-CedDWjM-.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
-import { $ as assertNotSymlink, D as acquireCodexNativeConfigFence, Q as resolveCodexManagedBundledMarketplacePath, Y as reconcileCodexComputerUseStartArtifacts, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-BpTtuLQ5.mjs";
+import { d as resolveCodexAppServerHomeDir } from "./config-security-BEReZ6go.mjs";
+import { o as resolveCodexComputerUseConfig } from "./config-options-BvaRs51b.mjs";
+import { d as resolveMacOSDesktopCodexBundledMarketplaceCandidates, l as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-BnshlFag.mjs";
+import { n as describeControlFailure } from "./capabilities-CDXOOFdZ.mjs";
+import { r as requestCodexAppServerClientJson } from "./request-D2L0zMrq.mjs";
+import "./config-BoTP_mrL.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
+import { $ as assertNotSymlink, D as acquireCodexNativeConfigFence, Q as resolveCodexManagedBundledMarketplacePath, Y as reconcileCodexComputerUseStartArtifacts, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError, x as withLeasedCodexAppServerClientStartSelectionRetry } from "./shared-client-DA4VR4Eb.mjs";
+import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-Cs08OXVQ.mjs";
+import { r as CodexAppServerUnsafeSubscriptionError, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-CEv1cKwF.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
+import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+//#region extensions/codex/src/app-server/computer-use-readiness.ts
+/** Computer Use readiness probes and their native subscription lifecycle. */
+function createComputerUseRequest(params) {
+	const assertCurrent = params.assertCurrent;
+	if (params.request) {
+		const request = params.request;
+		if (!assertCurrent) return request;
+		return async (method, requestParams, options) => {
+			if (method !== "thread/unsubscribe") assertCurrent();
+			return await request(method, requestParams, options);
+		};
+	}
+	const client = params.client;
+	if (!client) throw new Error("Computer Use setup requires an acquired app-server client");
+	return async (method, requestParams, options) => await client.request(method, requestParams, {
+		timeoutMs: options?.timeoutMs ?? params.timeoutMs,
+		signal: options?.signal ?? params.signal,
+		...method === "thread/unsubscribe" ? {} : { assertCurrent }
+	});
+}
+const COMPUTER_USE_LIVE_TEST_RETRY_COUNT = 1;
+const COMPUTER_USE_LIVE_TEST_THREAD_NAME = "OpenClaw Computer Use readiness probe";
+const COMPUTER_USE_LIST_APPS_TOOL = "list_apps";
+const COMPUTER_USE_UNIFIED_JS_TOOL = "js";
+const COMPUTER_USE_UNIFIED_JS_PROBE = "await cua.getState();";
+async function runCodexComputerUseLiveTest(params) {
+	const startedAt = Date.now();
+	let lastError;
+	let repair;
+	const probe = resolveComputerUseLiveTestProbe(params.tools);
+	for (let attempt = 0; attempt <= COMPUTER_USE_LIVE_TEST_RETRY_COUNT; attempt += 1) {
+		let threadId;
+		let outcome;
+		try {
+			threadId = (await params.request("thread/start", {
+				input: [],
+				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
+				ephemeral: true
+			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
+			if ((await params.request("mcpServer/tool/call", {
+				threadId,
+				server: params.config.mcpServerName,
+				tool: probe.tool,
+				arguments: probe.arguments
+			}, { timeoutMs: params.config.toolCallTimeoutMs })).isError === true) throw new Error(`Computer Use readiness tool ${params.config.mcpServerName}.${probe.tool} returned an error result`);
+			outcome = {
+				ok: true,
+				liveTest: {
+					status: "passed",
+					ok: true,
+					attempted: true,
+					attempts: attempt + 1,
+					timeoutMs: params.config.liveTestTimeoutMs,
+					retried: attempt > 0,
+					repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
+					durationMs: Math.max(0, Date.now() - startedAt),
+					message: "Computer Use live test passed."
+				}
+			};
+		} catch (error) {
+			outcome = {
+				ok: false,
+				error
+			};
+		}
+		let cleanupError;
+		if (threadId) try {
+			await cleanupComputerUseProbeThread(params, threadId);
+		} catch (error) {
+			cleanupError = toErrorObject(error, "Computer Use readiness cleanup failed");
+		}
+		if (!outcome.ok && (params.signal?.aborted || isCodexAppServerStartSelectionChangedError(outcome.error))) throw toErrorObject(outcome.error, "Computer Use live test failed");
+		if (cleanupError) throw cleanupError;
+		if (outcome.ok) return {
+			liveTest: outcome.liveTest,
+			...repair ? { repair } : {}
+		};
+		lastError = outcome.error;
+		if (attempt < COMPUTER_USE_LIVE_TEST_RETRY_COUNT && params.config.autoRepair) repair = await repairComputerUseMcpRuntime(params.request, params.config);
+	}
+	const errorMessage = describeControlFailure(lastError);
+	return {
+		liveTest: {
+			status: "failed",
+			ok: false,
+			attempted: true,
+			attempts: 2,
+			timeoutMs: params.config.liveTestTimeoutMs,
+			retried: true,
+			repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
+			durationMs: Math.max(0, Date.now() - startedAt),
+			message: `Computer Use live test failed after 2 attempts: ${errorMessage}`,
+			error: errorMessage
+		},
+		...repair ? { repair } : {}
+	};
+}
+function resolveComputerUseLiveTestProbe(tools) {
+	if (tools?.includes(COMPUTER_USE_UNIFIED_JS_TOOL) && !tools.includes(COMPUTER_USE_LIST_APPS_TOOL)) return {
+		tool: COMPUTER_USE_UNIFIED_JS_TOOL,
+		arguments: { code: COMPUTER_USE_UNIFIED_JS_PROBE }
+	};
+	return {
+		tool: COMPUTER_USE_LIST_APPS_TOOL,
+		arguments: {}
+	};
+}
+async function repairComputerUseMcpRuntime(request, config) {
+	try {
+		await request("config/mcpServer/reload", void 0, { timeoutMs: config.liveTestTimeoutMs });
+		return {
+			attempted: true,
+			killedPids: [],
+			warnings: [],
+			message: "Reloaded Computer Use MCP servers through Codex app-server."
+		};
+	} catch (error) {
+		const message = `Could not reload Computer Use MCP servers: ${describeControlFailure(error)}`;
+		return {
+			attempted: true,
+			killedPids: [],
+			warnings: [message],
+			message
+		};
+	}
+}
+async function cleanupComputerUseProbeThread(params, threadId) {
+	try {
+		await params.request("thread/unsubscribe", { threadId }, {
+			timeoutMs: params.config.liveTestTimeoutMs,
+			signal: AbortSignal.timeout(params.config.liveTestTimeoutMs)
+		});
+	} catch (error) {
+		if (params.client) await retireUnsafeCodexTurnClientBestEffort(params.client, "Computer Use readiness cleanup");
+		throw new CodexAppServerUnsafeSubscriptionError("Computer Use readiness cleanup failed", { cause: error });
+	}
+}
+function skippedLiveTestStatus(config, message) {
+	return {
+		status: "skipped",
+		ok: false,
+		attempted: false,
+		attempts: 0,
+		timeoutMs: config.liveTestTimeoutMs,
+		retried: false,
+		repaired: false,
+		message
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/computer-use.ts
 /**
 * Computer Use plugin/MCP readiness checks and optional install flow for Codex
@@ -31,11 +183,6 @@ const COMPUTER_USE_MARKETPLACE_NAME_PRIORITY = [
 	"openai-curated-remote",
 	"local"
 ];
-const COMPUTER_USE_LIVE_TEST_RETRY_COUNT = 1;
-const COMPUTER_USE_LIVE_TEST_THREAD_NAME = "OpenClaw Computer Use readiness probe";
-const COMPUTER_USE_LIST_APPS_TOOL = "list_apps";
-const COMPUTER_USE_UNIFIED_JS_TOOL = "js";
-const COMPUTER_USE_UNIFIED_JS_PROBE = "await cua.getState();";
 /** Reads Computer Use readiness without installing or mutating app-server state. */
 async function readCodexComputerUseStatus(params = {}) {
 	const config = resolveComputerUseConfig(params);
@@ -44,6 +191,7 @@ async function readCodexComputerUseStatus(params = {}) {
 		return await inspectCodexComputerUse({
 			...params,
 			computerUseConfig: config,
+			runLiveTest: true,
 			installPlugin: false
 		});
 	} catch (error) {
@@ -51,8 +199,8 @@ async function readCodexComputerUseStatus(params = {}) {
 	}
 }
 /**
-* Ensures Computer Use is ready when enabled, optionally installing when config
-* allows safe auto-install.
+* Ensures installation and MCP exposure before a turn, optionally installing when
+* config allows safe auto-install. Only strict startup waits for a live probe.
 */
 async function ensureCodexComputerUse(params = {}) {
 	const config = resolveComputerUseConfig(params);
@@ -60,19 +208,19 @@ async function ensureCodexComputerUse(params = {}) {
 	const status = await inspectCodexComputerUse({
 		...params,
 		computerUseConfig: config,
+		runLiveTest: config.strictReadiness,
 		installPlugin: false
 	});
 	if (status.ready) return status;
-	if (isNonStrictLiveTestStartupAllowed(status, config)) return status;
 	if (config.autoInstall) {
 		const blockedAutoInstallStatus = blockUnsafeAutoInstallStatus(config);
 		if (blockedAutoInstallStatus) throw new CodexComputerUseSetupError(blockedAutoInstallStatus);
 		const installedStatus = await inspectCodexComputerUse({
 			...params,
 			computerUseConfig: config,
+			runLiveTest: config.strictReadiness,
 			installPlugin: true
 		});
-		if (isNonStrictLiveTestStartupAllowed(installedStatus, config)) return installedStatus;
 		if (!installedStatus.ready) throw new CodexComputerUseSetupError(installedStatus);
 		return installedStatus;
 	}
@@ -93,13 +241,13 @@ async function installCodexComputerUse(params = {}) {
 	const status = await inspectCodexComputerUse({
 		...params,
 		computerUseConfig: config,
+		runLiveTest: true,
 		installPlugin: true
 	});
 	if (!status.ready) throw new CodexComputerUseSetupError(status);
 	return status;
 }
 async function inspectCodexComputerUse(params) {
-	if (!params.installPlugin) return await inspectCodexComputerUseWithoutFence(params);
 	const resolvedRuntime = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.pluginConfig,
 		managedCommandOrder: "desktop-first"
@@ -107,19 +255,57 @@ async function inspectCodexComputerUse(params) {
 	const operationTimeoutMs = params.timeoutMs ?? resolvedRuntime.requestTimeoutMs;
 	const deadline = operationTimeoutMs > 0 ? Date.now() + operationTimeoutMs : void 0;
 	const remainingTimeoutMs = () => deadline === void 0 ? operationTimeoutMs : Math.max(1, deadline - Date.now());
-	let leasedClient;
+	const clientOptions = {
+		startOptions: resolvedRuntime.start,
+		pluginConfig: params.pluginConfig,
+		config: params.config,
+		agentDir: params.agentDir,
+		abandonSignal: params.signal,
+		assertCurrent: params.assertCurrent
+	};
+	const lease = {};
 	try {
 		let client = params.client;
 		if (!client && !params.request) {
 			client = await getLeasedSharedCodexAppServerClient({
-				startOptions: resolvedRuntime.start,
-				pluginConfig: params.pluginConfig,
-				timeoutMs: remainingTimeoutMs(),
-				config: params.config,
-				agentDir: params.agentDir,
-				abandonSignal: params.signal
+				...clientOptions,
+				timeoutMs: remainingTimeoutMs()
+			});
+			lease.client = client;
+		}
+		if (!params.installPlugin) {
+			if (!lease.client) return await inspectCodexComputerUseWithoutFence(params);
+			return await withLeasedCodexAppServerClientStartSelectionRetry({
+				lease,
+				options: {
+					...clientOptions,
+					timeoutMs: remainingTimeoutMs()
+				},
+				signal: params.signal,
+				run: async (readClient, requestOptions) => {
+					const { assertCurrent } = requestOptions();
+					return await inspectCodexComputerUseWithoutFence({
+						...params,
+						client: readClient,
+						request: async (method, requestParams, options) => {
+							const scopedOptions = method === "thread/unsubscribe" ? {
+								timeoutMs: options?.timeoutMs ?? operationTimeoutMs,
+								signal: options?.signal,
+								assertCurrent
+							} : requestOptions();
+							return await requestCodexAppServerClientJson({
+								client: readClient,
+								method,
+								requestParams,
+								config: params.config,
+								timeoutMs: Math.min(options?.timeoutMs ?? operationTimeoutMs, scopedOptions.timeoutMs),
+								signal: scopedOptions.signal,
+								assertCurrent: scopedOptions.assertCurrent
+							});
+						}
+					});
+				}
 			});
-			leasedClient = client;
 		}
 		const explicitManagedInstall = client && !resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig }).autoInstall ? await resolveExplicitManagedComputerUseInstallContext({
 			...params,
@@ -170,7 +356,7 @@ async function inspectCodexComputerUse(params) {
 			if (releaseFenceOnReturn) release();
 		}
 	} finally {
-		if (leasedClient) releaseLeasedSharedCodexAppServerClient(leasedClient);
+		if (lease.client) releaseLeasedSharedCodexAppServerClient(lease.client);
 	}
 }
 async function inspectCodexComputerUseWithoutFence(params) {
@@ -201,8 +387,11 @@ async function inspectCodexComputerUseWithoutFence(params) {
 	if (!pluginInspection.ok) return pluginInspection.status;
 	return await readComputerUseTools({
 		request,
+		client: params.client,
+		signal: params.signal,
 		config: params.computerUseConfig,
 		plugin: pluginInspection.plugin,
+		runLiveTest: params.runLiveTest,
 		installPlugin: params.installPlugin,
 		releaseNativeConfigFence: params.releaseNativeConfigFence
 	});
@@ -227,7 +416,10 @@ async function prepareExplicitManagedComputerUseInstall(params) {
 		ownsIsolatedCodexHome: true,
 		desktopGeneration: context.desktopGeneration,
 		forceCacheRefresh: true,
-		assertCurrent: () => assertCodexAppServerClientStartSelectionCurrent({ client: context.client })
+		assertCurrent: () => {
+			params.assertCurrent?.();
+			assertCodexAppServerClientStartSelectionCurrent({ client: context.client });
+		}
 	});
 }
 async function resolveExplicitManagedComputerUseInstallContext(params) {
@@ -318,9 +510,12 @@ async function readComputerUseTools(params) {
 		reason: "ready",
 		message: "Computer Use is ready."
 	});
+	if (!params.runLiveTest) return status;
 	params.releaseNativeConfigFence?.();
 	const { liveTest, repair } = await runCodexComputerUseLiveTest({
 		request: params.request,
+		client: params.client,
+		signal: params.signal,
 		config: params.config,
 		tools
 	});
@@ -339,99 +534,6 @@ async function readComputerUseTools(params) {
 		message: liveTest.ok ? "Computer Use is ready." : compatibilityStartupAllowed ? `${liveTest.message} Startup is allowed because computerUse.strictReadiness is false.` : liveTest.message
 	};
 }
-function isNonStrictLiveTestStartupAllowed(status, config) {
-	return !config.strictReadiness && status.reason === "live_test_failed" && status.installed && status.pluginEnabled && status.mcpServerAvailable && status.installation.ok && status.exposure.ok;
-}
-async function runCodexComputerUseLiveTest(params) {
-	const startedAt = Date.now();
-	let lastError;
-	let repair;
-	const probe = resolveComputerUseLiveTestProbe(params.tools);
-	for (let attempt = 0; attempt <= COMPUTER_USE_LIVE_TEST_RETRY_COUNT; attempt += 1) {
-		let threadId;
-		try {
-			threadId = (await params.request("thread/start", {
-				input: [],
-				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
-				ephemeral: true
-			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
-			if ((await params.request("mcpServer/tool/call", {
-				threadId,
-				server: params.config.mcpServerName,
-				tool: probe.tool,
-				arguments: probe.arguments
-			}, { timeoutMs: params.config.toolCallTimeoutMs })).isError === true) throw new Error(`Computer Use readiness tool ${params.config.mcpServerName}.${probe.tool} returned an error result`);
-			return {
-				liveTest: {
-					status: "passed",
-					ok: true,
-					attempted: true,
-					attempts: attempt + 1,
-					timeoutMs: params.config.liveTestTimeoutMs,
-					retried: attempt > 0,
-					repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
-					durationMs: Math.max(0, Date.now() - startedAt),
-					message: "Computer Use live test passed."
-				},
-				...repair ? { repair } : {}
-			};
-		} catch (error) {
-			if (isCodexAppServerStartSelectionChangedError(error)) throw error;
-			lastError = error;
-		} finally {
-			if (threadId) await cleanupComputerUseProbeThread(params.request, threadId, params.config);
-		}
-		if (attempt < COMPUTER_USE_LIVE_TEST_RETRY_COUNT && params.config.autoRepair) repair = await repairComputerUseMcpRuntime(params.request, params.config);
-	}
-	const errorMessage = describeControlFailure(lastError);
-	return {
-		liveTest: {
-			status: "failed",
-			ok: false,
-			attempted: true,
-			attempts: 2,
-			timeoutMs: params.config.liveTestTimeoutMs,
-			retried: true,
-			repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
-			durationMs: Math.max(0, Date.now() - startedAt),
-			message: `Computer Use live test failed after 2 attempts: ${errorMessage}`,
-			error: errorMessage
-		},
-		...repair ? { repair } : {}
-	};
-}
-function resolveComputerUseLiveTestProbe(tools) {
-	if (tools?.includes(COMPUTER_USE_UNIFIED_JS_TOOL) && !tools.includes(COMPUTER_USE_LIST_APPS_TOOL)) return {
-		tool: COMPUTER_USE_UNIFIED_JS_TOOL,
-		arguments: { code: COMPUTER_USE_UNIFIED_JS_PROBE }
-	};
-	return {
-		tool: COMPUTER_USE_LIST_APPS_TOOL,
-		arguments: {}
-	};
-}
-async function repairComputerUseMcpRuntime(request, config) {
-	try {
-		await request("config/mcpServer/reload", void 0, { timeoutMs: config.liveTestTimeoutMs });
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [],
-			message: "Reloaded Computer Use MCP servers through Codex app-server."
-		};
-	} catch (error) {
-		const message = `Could not reload Computer Use MCP servers: ${describeControlFailure(error)}`;
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [message],
-			message
-		};
-	}
-}
-async function cleanupComputerUseProbeThread(request, threadId, config) {
-	await Promise.allSettled([request("thread/unsubscribe", { threadId }, { timeoutMs: config.liveTestTimeoutMs }), request("thread/archive", { threadId }, { timeoutMs: config.liveTestTimeoutMs })]);
-}
 async function resolveMarketplaceRef(params) {
 	let preferredMarketplaceName = params.config.marketplaceName;
 	if (params.config.marketplaceSource && params.allowAdd) {
@@ -694,44 +796,12 @@ function exposureStatusFromTools(config, tools) {
 		message: `Computer Use MCP server ${config.mcpServerName} exposes ${tools.length} tools.`
 	};
 }
-function skippedLiveTestStatus(config, message) {
-	return {
-		status: "skipped",
-		ok: false,
-		attempted: false,
-		attempts: 0,
-		timeoutMs: config.liveTestTimeoutMs,
-		retried: false,
-		repaired: false,
-		message
-	};
-}
 function pluginWarnings(plugin) {
 	const warnings = [];
 	const source = plugin.summary.source;
 	if (source && typeof source === "object" && "type" in source && source.type === "remote") warnings.push("Computer Use plugin is resolved from a remote marketplace; live local bundles are preferred.");
 	return warnings;
 }
-function createComputerUseRequest(params) {
-	if (params.request) return params.request;
-	if (params.client) return async (method, requestParams, options) => await params.client.request(method, requestParams, {
-		timeoutMs: options?.timeoutMs ?? params.timeoutMs,
-		signal: params.signal
-	});
-	const runtime = resolveCodexAppServerRuntimeOptions({
-		pluginConfig: params.pluginConfig,
-		managedCommandOrder: "desktop-first"
-	});
-	return async (method, requestParams, options) => await requestCodexAppServerJson({
-		method,
-		requestParams,
-		timeoutMs: options?.timeoutMs ?? params.timeoutMs ?? runtime.requestTimeoutMs,
-		pluginConfig: params.pluginConfig,
-		startOptions: runtime.start,
-		config: params.config,
-		agentDir: params.agentDir
-	});
-}
 function resolveComputerUseConfig(params) {
 	const overrides = params.forceEnable ? {
 		...params.overrides,

package/dist/.setup/protocol-CANUwXJ3.mjs

@@ -0,0 +1,17 @@
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/protocol.ts
+/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
+const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
+/** Asserts the experimental beforeTurnId request field before it crosses the app-server boundary. */
+function assertCodexThreadForkParams(value) {
+	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.beforeTurnId !== void 0 && value.beforeTurnId !== null && typeof value.beforeTurnId !== "string") throw new Error("Invalid Codex app-server thread/fork params");
+	return value;
+}
+function isJsonObject(value) {
+	return isRecord(value);
+}
+//#endregion
+export { isJsonObject as i, assertCodexThreadForkParams as n, flattenCodexDynamicToolFunctions as r, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as t };

package/dist/.setup/{provider-fFh_-VR3.mjs → provider-BOsxQHOM.mjs}

@@ -9,10 +9,14 @@ function buildCodexMigrationProvider(params = {}) {
 	return {
 		id: "codex",
 		label: "Codex",
-		description: "Import Codex memory and skills while keeping Codex native plugins and hooks explicit.",
+		description: [
+			"Import consolidated memories, selected Codex and personal AgentSkills, and selected eligible openai-curated plugins.",
+			"Auth credentials require separate consent. Sessions and chat history are not imported.",
+			"Codex config and hooks are saved for manual review, not activated. Source files are not moved or deleted."
+		].join(" "),
 		supportedItemKinds: ["memory", "auth"],
 		async detect(ctx) {
-			const { discoverCodexSource, hasCodexSource } = await import("./source-Bjp4UQij.mjs").then((n) => n.a);
+			const { discoverCodexSource, hasCodexSource } = await import("./source-CUzJq5WN.mjs").then((n) => n.a);
 			const source = await discoverCodexSource({
 				input: ctx.source,
 				memoryOnly: isMemoryOnlyMigration(ctx),
@@ -28,16 +32,16 @@ function buildCodexMigrationProvider(params = {}) {
 			};
 		},
 		async plan(ctx) {
-			const { buildCodexMigrationPlan } = await import("./plan-xD7WKYTM.mjs");
+			const { buildCodexMigrationPlan } = await import("./plan-CN3VwfNU.mjs");
 			return buildCodexMigrationPlan(ctx);
 		},
 		deferredApply: { retrySafe: true },
 		prepareApply(ctx) {
 			if (isMemoryOnlyMigration(ctx) || isAuthOnlyMigration(ctx)) return;
-			return import("./apply-CJ0ZfmBG.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
+			return import("./apply-DDOi8uNx.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
 		},
 		async apply(ctx, plan) {
-			const { applyCodexMigrationPlan } = await import("./apply-CJ0ZfmBG.mjs");
+			const { applyCodexMigrationPlan } = await import("./apply-DDOi8uNx.mjs");
 			return await applyCodexMigrationPlan({
 				ctx,
 				plan,