@openclaw/codex 2026.8.1-beta.3 → 2026.8.2

package/dist/{node-exec-server.runtime-Bsu1LdFZ.js → node-exec-server.runtime-DirKVZ5h.js}

@@ -1,6 +1,5 @@
-import { z as closeCodexAppServerTransportAndWait } from "./shared-client-Dw-rzii0.js";
-import { t as createStdioTransport } from "./transport-stdio-DhoGy33Z.js";
-import { n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-By4FZC6i.js";
+import { n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-ZkGodW19.js";
+import { i as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-NT_Dpd9V.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
@@ -9,7 +8,7 @@ import { killProcessTree } from "openclaw/plugin-sdk/process-runtime";
 import { once } from "node:events";
 import { sanitizeEnvVars } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/codex/src/node-exec-server.runtime.ts
-const MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES = 64 * 1024 * 1024;
+const MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES = 67108864;
 const CODEX_EXEC_SERVER_TERMINATION_GRACE_MS = 1e3;
 const CODEX_EXEC_SERVER_REAP_TIMEOUT_MS = 5e3;
 const NODE_EXEC_SERVER_PLATFORM_ENVIRONMENT = /^(?:SYSTEMROOT|WINDIR|COMSPEC|PATHEXT|TEMP|TMP|TMPDIR)$/iu;
@@ -125,7 +124,8 @@ async function runCodexNodeExecServer(params) {
 				customAllowedPatterns: [NODE_EXEC_SERVER_PLATFORM_ENVIRONMENT]
 			}).allowed;
 			if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
-			const child = createStdioTransport({
+			params.assertExecAuthorized();
+			const child = await createStdioTransport({
 				transport: "stdio",
 				command: native,
 				commandSource: "resolved-managed",
@@ -138,7 +138,10 @@ async function runCodexNodeExecServer(params) {
 					...process.platform === "win32" ? { USERPROFILE: dir } : {}
 				},
 				clearEnv: ["NODE_OPTIONS"]
-			}, baseEnv);
+			}, baseEnv, () => {
+				if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+				params.assertExecAuthorized();
+			});
 			child.stdin.on("error", (error) => {
 				rejectDisconnected(error);
 			});

package/dist/{plugin-approval-roundtrip-C75Yiiwc.js → plugin-approval-roundtrip-CCWQGlAI.js}

@@ -1,4 +1,4 @@
-import { S as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-Dw-rzii0.js";
+import { F as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-B1tT5U6r.js";
 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
@@ -23,6 +23,7 @@ function codexApprovalTimeoutText(kind) {
 async function requestPluginApproval(params) {
 	const timeoutMs = DEFAULT_CODEX_APPROVAL_TIMEOUT_MS;
 	return params.hostCapabilities.requestApproval({
+		signal: params.signal,
 		title: truncateCodexApprovalDisplayText(params.title, MAX_PLUGIN_APPROVAL_TITLE_LENGTH),
 		description: truncateCodexApprovalDisplayText(params.description, MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH),
 		severity: params.severity,

package/dist/{plugin-marketplace-discovery-CSWDkMrP.js → plugin-marketplace-discovery-BXjIFEiw.js}

@@ -1,15 +1,16 @@
-import { M as isCodexFastServiceTier } from "./config-CpNeo5AE.js";
-import { a as getLeasedSharedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient } from "./shared-client-Dw-rzii0.js";
-import { o as isCodexAppServerNativeAuthProfile, r as bindingStoreKey, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-BTrLf9Qm.js";
-import { _ as resolveCodexAppServerRequestModelSelection, y as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-DKdrnTMX.js";
-import { r as formatCodexDisplayText } from "./command-formatters-D0nZ3qtd.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-DAvZwp96.js";
+import { k as isCodexFastServiceTier } from "./config-CcYL77O6.js";
+import { c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-B1tT5U6r.js";
+import { o as isCodexAppServerNativeAuthProfile, r as bindingStoreKey, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-D0zinCP1.js";
+import { E as resolveCodexAppServerRequestModelSelection, O as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-CGGKP720.js";
+import { r as formatCodexDisplayText } from "./command-formatters--UToCokS.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-CF7BmrDk.js";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { getSessionEntry, patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { ModelSelectionLockedError, applyModelOverrideWithAuthProfileCompatibility } from "openclaw/plugin-sdk/model-session-runtime";
 //#region extensions/codex/src/command-authorization.ts
 const CODEX_NATIVE_EXECUTION_AUTH_ERROR = "Only an owner or operator.admin can control Codex native execution.";
+const CODEX_HOST_INSPECTION_AUTH_ERROR = "Only an owner or operator.admin can inspect Codex host state.";
 const CODEX_FULL_PERMISSIONS_AUTH_ERROR = "Full Codex permissions require operator.admin. Choose Admin in the Control UI permission picker, or use an admin-authenticated CLI.";
 function hasCodexAdminScope(ctx) {
 	return ctx.gatewayClientScopes?.includes("operator.admin") === true;
@@ -126,15 +127,16 @@ async function setCodexConversationModel(params) {
 	const lookup = buildBindingLookup(params);
 	const binding = await requireThreadBinding(params.bindingStore, params.identity);
 	if (binding.connectionScope === "supervision") throw new ModelSelectionLockedError();
+	const modelProvider = resolveConversationControlModelProvider({
+		authProfileId: binding.authProfileId,
+		bindingModel: binding.model,
+		bindingModelProvider: binding.modelProvider,
+		currentModel: model,
+		...lookup
+	});
 	const modelSelection = resolveCodexAppServerRequestModelSelection({
 		model,
-		modelProvider: resolveConversationControlModelProvider({
-			authProfileId: binding.authProfileId,
-			bindingModel: binding.model,
-			bindingModelProvider: binding.modelProvider,
-			currentModel: model,
-			...lookup
-		}),
+		modelProvider,
 		authProfileId: binding.authProfileId,
 		...lookup
 	});
@@ -145,23 +147,23 @@ async function setCodexConversationModel(params) {
 	});
 	const nextModel = modelSelection.model;
 	const modelChanged = nextModel !== binding.model || nextModelProvider !== binding.modelProvider;
-	const session = params.session ?? (params.identity.kind === "session" && params.identity.sessionKey ? {
-		agentId: params.identity.agentId,
-		sessionId: params.identity.sessionId,
-		sessionKey: params.identity.sessionKey
-	} : void 0);
-	if (session) {
+	const projectionPatch = modelChanged && binding.contextEngine?.projection ? { contextEngine: {
+		...binding.contextEngine,
+		projection: void 0
+	} } : {};
+	const identity = params.identity;
+	if (identity.kind === "session" && identity.sessionKey) {
 		if (!await patchSessionEntry({
-			agentId: session.agentId,
-			storePath: resolveStorePath(params.config?.session?.store, { agentId: session.agentId }),
-			sessionKey: session.sessionKey,
+			agentId: identity.agentId,
+			storePath: resolveStorePath(params.config?.session?.store, { agentId: identity.agentId }),
+			sessionKey: identity.sessionKey,
 			requireWriteSuccess: true,
 			replaceEntry: true,
 			update: (entry) => {
-				if (entry.sessionId !== session.sessionId) throw new Error("Codex session changed while applying the model selection.");
+				if (entry.sessionId !== identity.sessionId) throw new Error("Codex session changed while applying the model selection.");
 				applyModelOverrideWithAuthProfileCompatibility({
 					cfg: params.config ?? {},
-					agentDir: params.agentDir ?? resolveAgentDir(params.config ?? {}, session.agentId),
+					agentDir: params.agentDir ?? resolveAgentDir(params.config ?? {}, identity.agentId),
 					entry,
 					currentProvider: binding.modelProvider ?? "openai",
 					selection: {
@@ -173,25 +175,11 @@ async function setCodexConversationModel(params) {
 				return entry;
 			}
 		})) throw new Error("Codex session changed while applying the model selection.");
-		if (params.identity.kind === "conversation") await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
-			model: nextModel,
-			modelProvider: nextModelProvider,
-			...modelChanged && binding.contextEngine?.projection ? { contextEngine: {
-				...binding.contextEngine,
-				projection: void 0
-			} } : {}
-		});
-		else if (modelChanged && binding.contextEngine?.projection) await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, { contextEngine: {
-			...binding.contextEngine,
-			projection: void 0
-		} });
+		if (modelChanged && binding.contextEngine?.projection) await patchThreadBinding(params.bindingStore, identity, binding.threadId, projectionPatch);
 	} else await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
 		model: nextModel,
 		modelProvider: nextModelProvider,
-		...modelChanged && binding.contextEngine?.projection ? { contextEngine: {
-			...binding.contextEngine,
-			projection: void 0
-		} } : {}
+		...projectionPatch
 	});
 	return `Codex model set to ${formatCodexDisplayText(nextModel)}.`;
 }
@@ -223,12 +211,11 @@ async function setCodexConversationPermissions(params) {
 		replaceEntry: true,
 		update: (entry) => {
 			if (entry.sessionId !== params.session.sessionId) throw new Error("Codex session changed while applying the permission mode.");
-			if (params.mode === "yolo") entry.permissionMode = "full";
-			else delete entry.permissionMode;
+			entry.permissionMode = params.mode === "yolo" ? "full" : "guarded";
 			return entry;
 		}
 	})) throw new Error("Codex session changed while applying the permission mode.");
-	return `Codex permissions set to ${params.mode === "yolo" ? "full access" : "default"}.`;
+	return `Codex permissions set to ${params.mode === "yolo" ? "full access" : "guarded"}.`;
 }
 function parseCodexFastModeArg(arg) {
 	const normalized = arg?.trim().toLowerCase();
@@ -240,10 +227,15 @@ function parseCodexPermissionsModeArg(arg) {
 	const normalized = arg?.trim().toLowerCase();
 	if (!normalized || normalized === "status") return;
 	if (normalized === "yolo" || normalized === "full" || normalized === "full-access") return "yolo";
-	if (normalized === "default" || normalized === "guardian") return "default";
+	if ([
+		"default",
+		"guardian",
+		"guarded",
+		"approve"
+	].includes(normalized)) return "default";
 }
 function formatPermissionsMode(mode) {
-	return mode === "full" ? "full access" : "default";
+	return mode === "full" ? "full access" : mode ?? "default";
 }
 async function requireThreadBinding(bindingStore, identity) {
 	const binding = await bindingStore.read(identity);
@@ -396,4 +388,4 @@ function boundedCatalogText(value) {
 	return sanitized.replace(/\s+/g, " ").trim().slice(0, MAX_PLUGIN_DESCRIPTION_LENGTH);
 }
 //#endregion
-export { parseCodexPermissionsModeArg as a, setCodexConversationModel as c, stopCodexConversationTurn as d, trackCodexConversationActiveTurn as f, hasCodexAdminScope as g, canMutateCodexHost as h, parseCodexFastModeArg as i, setCodexConversationPermissions as l, CODEX_NATIVE_EXECUTION_AUTH_ERROR as m, parseCodexPluginMarketplaceId as n, readCodexConversationActiveTurn as o, CODEX_FULL_PERMISSIONS_AUTH_ERROR as p, formatPermissionsMode as r, setCodexConversationFastMode as s, discoverCodexMarketplacePlugins as t, steerCodexConversationTurn as u };
+export { hasCodexAdminScope as _, parseCodexPermissionsModeArg as a, setCodexConversationModel as c, stopCodexConversationTurn as d, trackCodexConversationActiveTurn as f, canMutateCodexHost as g, CODEX_NATIVE_EXECUTION_AUTH_ERROR as h, parseCodexFastModeArg as i, setCodexConversationPermissions as l, CODEX_HOST_INSPECTION_AUTH_ERROR as m, parseCodexPluginMarketplaceId as n, readCodexConversationActiveTurn as o, CODEX_FULL_PERMISSIONS_AUTH_ERROR as p, formatPermissionsMode as r, setCodexConversationFastMode as s, discoverCodexMarketplacePlugins as t, steerCodexConversationTurn as u };

package/dist/{plugin-metadata-cache-BXH5NF-4.js → plugin-metadata-cache-DQQm4gWT.js}

@@ -1,91 +1,11 @@
-import { i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig } from "./config-CpNeo5AE.js";
-import { M as isCodexAppServerConnectionClosedError, N as isCodexAppServerIndeterminateRequestCancellationError, P as isCodexAppServerIndeterminateTransportError, a as getLeasedSharedCodexAppServerClient, dt as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, l as releaseLeasedSharedCodexAppServerClient, u as resolveCodexNativeConfigFenceKey, v as acquireCodexNativeConfigFence } from "./shared-client-Dw-rzii0.js";
-import { n as describeControlFailure } from "./capabilities-CH3K57v4.js";
-import { r as requestCodexAppServerJson } from "./request-DSK0W6YI.js";
+import { P as resolveCodexAppServerHomeDir, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig } from "./config-CcYL77O6.js";
+import { At as reconcileCodexComputerUseStartArtifacts, G as isCodexAppServerConnectionClosedError, K as isCodexAppServerIndeterminateRequestCancellationError, O as acquireCodexNativeConfigFence, S as waitForCodexAppServerClientDesktopGenerationDrain, Ut as resolveCodexManagedBundledMarketplacePath, Wt as assertNotSymlink, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, q as isCodexAppServerIndeterminateTransportError, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-B1tT5U6r.js";
+import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-ZkGodW19.js";
+import { i as requestCodexAppServerJson } from "./request-BWxweEdK.js";
+import { n as describeControlFailure } from "./capabilities-D6m_TdVy.js";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { existsSync } from "node:fs";
-import { runExec } from "openclaw/plugin-sdk/process-runtime";
-//#region extensions/codex/src/app-server/computer-use-process-repair.ts
-const COMPUTER_USE_PROCESS_LIST_TIMEOUT_MS = 2e3;
-const COMPUTER_USE_PROCESS_LIST_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
-function scopedRepairUnavailableStatus() {
-	return {
-		attempted: false,
-		killedPids: [],
-		warnings: ["Computer Use auto-repair skipped because no scoped Codex app-server process was available."],
-		message: "Computer Use stale child repair requires a scoped local app-server PID."
-	};
-}
-async function killStaleComputerUseMcpChildren(options = {}) {
-	if (process.platform !== "darwin") return {
-		attempted: true,
-		killedPids: [],
-		warnings: [`Computer Use stale child repair is currently macOS-only, not ${process.platform}.`],
-		message: "Computer Use stale child repair skipped on this platform."
-	};
-	if (!options.ancestorPid || !Number.isSafeInteger(options.ancestorPid) || options.ancestorPid <= 0) return scopedRepairUnavailableStatus();
-	let stdout;
-	try {
-		stdout = (await runExec("/bin/ps", ["-axo", "pid=,ppid=,command="], {
-			logOutput: false,
-			maxBuffer: COMPUTER_USE_PROCESS_LIST_MAX_BUFFER_BYTES,
-			timeoutMs: COMPUTER_USE_PROCESS_LIST_TIMEOUT_MS
-		})).stdout;
-	} catch (error) {
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [`Could not list processes for Computer Use repair: ${describeControlFailure(error)}`],
-			message: "Computer Use stale child repair could not inspect running processes."
-		};
-	}
-	const killedPids = [];
-	const warnings = [];
-	const processInfos = parsePsOutput(stdout);
-	for (const processInfo of processInfos) {
-		if (!isStaleComputerUseMcpChild(processInfo.command)) continue;
-		if (!isDescendantOfPid(processInfo.pid, options.ancestorPid, processInfos)) continue;
-		try {
-			process.kill(processInfo.pid, "SIGTERM");
-			killedPids.push(processInfo.pid);
-		} catch (error) {
-			warnings.push(`Could not terminate stale Computer Use MCP child pid ${processInfo.pid}: ${describeControlFailure(error)}`);
-		}
-	}
-	return {
-		attempted: true,
-		killedPids,
-		warnings,
-		message: killedPids.length === 0 ? "No stale Computer Use MCP children were found under the scoped Codex app-server process." : `Terminated ${killedPids.length} stale Computer Use MCP child process${killedPids.length === 1 ? "" : "es"} under the scoped Codex app-server process.`
-	};
-}
-function parsePsOutput(stdout) {
-	return stdout.split(/\r?\n/u).flatMap((line) => {
-		const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/u.exec(line);
-		if (!match) return [];
-		return [{
-			pid: Number(match[1]),
-			ppid: Number(match[2]),
-			command: match[3] ?? ""
-		}];
-	}).filter((processInfo) => Number.isSafeInteger(processInfo.pid) && processInfo.pid > 0 && Number.isSafeInteger(processInfo.ppid) && processInfo.ppid >= 0);
-}
-function isStaleComputerUseMcpChild(command) {
-	return command.includes("SkyComputerUseClient") && /(?:^|\s)mcp(?:\s|$)/u.test(command);
-}
-function isDescendantOfPid(pid, ancestorPid, processInfos) {
-	const parents = new Map(processInfos.map((processInfo) => [processInfo.pid, processInfo.ppid]));
-	const seen = /* @__PURE__ */ new Set();
-	let current = pid;
-	while (!seen.has(current)) {
-		seen.add(current);
-		const parent = parents.get(current);
-		if (!parent || parent <= 0) return false;
-		if (parent === ancestorPid) return true;
-		current = parent;
-	}
-	return false;
-}
-//#endregion
 //#region extensions/codex/src/app-server/computer-use.ts
 /**
 * Computer Use plugin/MCP readiness checks and optional install flow for Codex
@@ -99,8 +19,9 @@ var CodexComputerUseSetupError = class extends Error {
 	}
 };
 const CURATED_MARKETPLACE_POLL_INTERVAL_MS = 2e3;
+const BUNDLED_MARKETPLACE_NAME = "openai-bundled";
 const COMPUTER_USE_MARKETPLACE_NAME_PRIORITY = [
-	"openai-bundled",
+	BUNDLED_MARKETPLACE_NAME,
 	"openai-curated",
 	"openai-api-curated",
 	"openai-curated-remote",
@@ -172,72 +93,96 @@ async function installCodexComputerUse(params = {}) {
 }
 async function inspectCodexComputerUse(params) {
 	if (!params.installPlugin) return await inspectCodexComputerUseWithoutFence(params);
-	const runtime = params.client ? void 0 : resolveCodexAppServerRuntimeOptions({
+	const resolvedRuntime = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.pluginConfig,
 		managedCommandOrder: "desktop-first"
 	});
-	const fenceKey = resolveCodexNativeConfigFenceKey({
-		client: params.client,
-		startOptions: runtime?.start,
-		agentDir: params.agentDir,
-		config: params.config
-	});
-	if (!fenceKey) return await inspectCodexComputerUseWithoutFence(params);
-	const release = await acquireCodexNativeConfigFence(fenceKey, {
-		signal: params.signal,
-		timeoutMs: params.timeoutMs ?? runtime?.requestTimeoutMs,
-		timeoutMessage: "Codex Computer Use install timed out waiting for native config",
-		abortMessage: "Codex Computer Use install aborted waiting for native config"
-	});
-	let releaseFenceOnReturn = true;
+	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;
 	try {
 		let client = params.client;
 		if (!client && !params.request) {
-			if (!runtime) throw new Error("Computer Use install could not resolve its app-server runtime");
 			client = await getLeasedSharedCodexAppServerClient({
-				startOptions: runtime.start,
+				startOptions: resolvedRuntime.start,
 				pluginConfig: params.pluginConfig,
-				timeoutMs: params.timeoutMs ?? runtime.requestTimeoutMs,
+				timeoutMs: remainingTimeoutMs(),
 				config: params.config,
 				agentDir: params.agentDir,
 				abandonSignal: params.signal
 			});
 			leasedClient = client;
 		}
-		try {
-			return await inspectCodexComputerUseWithoutFence({
-				...params,
-				releaseNativeConfigFence: release,
-				...client ? {
-					client,
-					timeoutMs: params.timeoutMs ?? runtime?.requestTimeoutMs
-				} : {}
+		const explicitManagedInstall = client && !resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig }).autoInstall ? await resolveExplicitManagedComputerUseInstallContext({
+			...params,
+			client
+		}) : void 0;
+		if (explicitManagedInstall) {
+			await waitForCodexAppServerClientDesktopGenerationDrain({
+				client: explicitManagedInstall.client,
+				timeoutMs: remainingTimeoutMs(),
+				...params.signal ? { signal: params.signal } : {}
 			});
-		} catch (error) {
-			if (client && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error) || isCodexAppServerConnectionClosedError(error))) {
-				releaseFenceOnReturn = false;
-				await client.closeAndRunAfterExit(release, "Computer Use config mutation");
+			assertCodexAppServerClientStartSelectionCurrent({ client: explicitManagedInstall.client });
+		}
+		const inspectionParams = {
+			...params,
+			...client ? { client } : {},
+			timeoutMs: remainingTimeoutMs(),
+			...explicitManagedInstall ? { explicitManagedInstall } : {}
+		};
+		const fenceKey = resolveCodexNativeConfigFenceKey({
+			client,
+			startOptions: resolvedRuntime.start,
+			agentDir: params.agentDir,
+			config: params.config
+		});
+		if (!fenceKey) return await inspectCodexComputerUseWithoutFence(inspectionParams);
+		const release = await acquireCodexNativeConfigFence(fenceKey, {
+			signal: params.signal,
+			timeoutMs: remainingTimeoutMs(),
+			timeoutMessage: "Codex Computer Use install timed out waiting for native config",
+			abortMessage: "Codex Computer Use install aborted waiting for native config"
+		});
+		let releaseFenceOnReturn = true;
+		try {
+			try {
+				return await inspectCodexComputerUseWithoutFence({
+					...inspectionParams,
+					releaseNativeConfigFence: release
+				});
+			} catch (error) {
+				if (client && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error) || isCodexAppServerConnectionClosedError(error))) {
+					releaseFenceOnReturn = false;
+					await client.closeAndRunAfterExit(release, "Computer Use config mutation");
+				}
+				throw error;
 			}
-			throw error;
 		} finally {
-			if (leasedClient) releaseLeasedSharedCodexAppServerClient(leasedClient);
+			if (releaseFenceOnReturn) release();
 		}
 	} finally {
-		if (releaseFenceOnReturn) release();
+		if (leasedClient) releaseLeasedSharedCodexAppServerClient(leasedClient);
 	}
 }
 async function inspectCodexComputerUseWithoutFence(params) {
 	const request = createComputerUseRequest(params);
-	const repairComputerUseMcpChildren = params.repairComputerUseMcpChildren ?? (params.client ? () => killStaleComputerUseMcpChildren({ ancestorPid: params.client?.getTransportPid() }) : void 0);
-	if (params.installPlugin) await request("experimentalFeature/enablement/set", { enablement: { plugins: true } });
+	if (params.installPlugin) {
+		if (!resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig }).autoInstall) await prepareExplicitManagedComputerUseInstall(params);
+		await request("experimentalFeature/enablement/set", { enablement: { plugins: true } });
+	}
+	const managedMarketplacePath = await resolveClientManagedBundledMarketplacePath(params.client, params.agentDir);
+	const managedCodexHome = managedMarketplacePath ? params.client?.getRuntimeIdentity()?.codexHome : void 0;
+	if (params.installPlugin && managedCodexHome) await assertNotSymlink(path.join(managedCodexHome, "config.toml"), "Codex config");
 	const marketplace = await resolveMarketplaceRef({
 		request,
 		config: params.computerUseConfig,
 		allowAdd: params.installPlugin,
 		signal: params.signal,
-		defaultBundledMarketplacePath: params.defaultBundledMarketplacePath,
-		defaultBundledMarketplacePathCandidates: params.defaultBundledMarketplacePathCandidates
+		defaultBundledMarketplacePath: params.defaultBundledMarketplacePath ?? managedMarketplacePath,
+		defaultBundledMarketplacePathCandidates: params.defaultBundledMarketplacePathCandidates,
+		managedCodexHome
 	});
 	if (!marketplace.marketplace) return unavailableStatus(params.computerUseConfig, "marketplace_missing", marketplace.message ?? `No Codex marketplace containing ${params.computerUseConfig.pluginName} is registered. Configure computerUse.marketplaceSource or computerUse.marketplacePath, then run /codex computer-use install.`);
 	const pluginInspection = await ensureComputerUsePlugin({
@@ -252,10 +197,59 @@ async function inspectCodexComputerUseWithoutFence(params) {
 		config: params.computerUseConfig,
 		plugin: pluginInspection.plugin,
 		installPlugin: params.installPlugin,
-		repairComputerUseMcpChildren,
 		releaseNativeConfigFence: params.releaseNativeConfigFence
 	});
 }
+async function prepareExplicitManagedComputerUseInstall(params) {
+	const context = params.explicitManagedInstall;
+	if (!context) return;
+	await reconcileCodexComputerUseStartArtifacts({
+		startOptions: {
+			transport: "stdio",
+			command: context.command,
+			commandSource: "resolved-managed",
+			args: ["app-server"],
+			headers: {},
+			env: { CODEX_HOME: context.codexHome }
+		},
+		agentDir: context.agentDir,
+		pluginConfig: { computerUse: {
+			...params.computerUseConfig,
+			autoInstall: true
+		} },
+		ownsIsolatedCodexHome: true,
+		desktopGeneration: context.desktopGeneration,
+		forceCacheRefresh: true,
+		assertCurrent: () => assertCodexAppServerClientStartSelectionCurrent({ client: context.client })
+	});
+}
+async function resolveExplicitManagedComputerUseInstallContext(params) {
+	if (!params.agentDir) return;
+	const codexHome = params.client.getRuntimeIdentity()?.codexHome;
+	const processIdentity = readCodexAppServerClientProcessIdentity(params.client);
+	const command = processIdentity?.nativeCommand ?? (processIdentity && isManagedCodexDesktopCommand(processIdentity.command, "darwin") ? processIdentity.command : void 0);
+	if (!codexHome || !command) return;
+	const desktopGeneration = readCodexAppServerClientDesktopGeneration(params.client);
+	if (!desktopGeneration) throw new Error("Codex Computer Use install requires a desktop-generation-bound client; reconnect and retry.");
+	const expectedHome = resolveCodexAppServerHomeDir(params.agentDir);
+	const [actualRealHome, expectedRealHome] = await Promise.all([fs.realpath(codexHome).catch(() => void 0), fs.realpath(expectedHome).catch(() => void 0)]);
+	if (!actualRealHome || actualRealHome !== expectedRealHome) return;
+	return {
+		client: params.client,
+		agentDir: params.agentDir,
+		codexHome,
+		command,
+		desktopGeneration
+	};
+}
+async function resolveClientManagedBundledMarketplacePath(client, agentDir) {
+	const codexHome = client?.getRuntimeIdentity()?.codexHome;
+	if (!codexHome || !agentDir) return;
+	const [actualRealHome, expectedRealHome] = await Promise.all([fs.realpath(codexHome).catch(() => void 0), fs.realpath(resolveCodexAppServerHomeDir(agentDir)).catch(() => void 0)]);
+	if (!actualRealHome || actualRealHome !== expectedRealHome) return;
+	const managedPath = resolveCodexManagedBundledMarketplacePath(codexHome);
+	return existsSync(managedPath) ? managedPath : void 0;
+}
 async function ensureComputerUsePlugin(params) {
 	let plugin = await readComputerUsePlugin(params.request, params.marketplace, params.config.pluginName);
 	if (!plugin.summary.installed || !plugin.summary.enabled) {
@@ -320,8 +314,7 @@ async function readComputerUseTools(params) {
 	params.releaseNativeConfigFence?.();
 	const { liveTest, repair } = await runCodexComputerUseLiveTest({
 		request: params.request,
-		config: params.config,
-		repairComputerUseMcpChildren: params.repairComputerUseMcpChildren
+		config: params.config
 	});
 	const compatibilityStartupAllowed = !liveTest.ok && !params.config.strictReadiness;
 	return {
@@ -351,8 +344,6 @@ async function runCodexComputerUseLiveTest(params) {
 			threadId = (await params.request("thread/start", {
 				input: [],
 				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
-				sandbox: "danger-full-access",
-				approvalPolicy: "never",
 				ephemeral: true
 			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
 			await params.request("mcpServer/tool/call", {
@@ -369,19 +360,19 @@ async function runCodexComputerUseLiveTest(params) {
 					attempts: attempt + 1,
 					timeoutMs: params.config.liveTestTimeoutMs,
 					retried: attempt > 0,
-					repaired: Boolean(repair?.attempted),
+					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;
-			if (attempt >= COMPUTER_USE_LIVE_TEST_RETRY_COUNT) break;
-			if (params.config.autoRepair) repair = params.repairComputerUseMcpChildren ? await params.repairComputerUseMcpChildren() : scopedRepairUnavailableStatus();
 		} 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 {
@@ -392,7 +383,7 @@ async function runCodexComputerUseLiveTest(params) {
 			attempts: 2,
 			timeoutMs: params.config.liveTestTimeoutMs,
 			retried: true,
-			repaired: Boolean(repair?.attempted),
+			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
@@ -400,6 +391,25 @@ async function runCodexComputerUseLiveTest(params) {
 		...repair ? { repair } : {}
 	};
 }
+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 })]);
 }
@@ -420,6 +430,12 @@ async function resolveMarketplaceRef(params) {
 	let candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
 	const bundledMarketplacePath = resolveBundledComputerUseMarketplacePath(params);
 	if (candidates.length === 0 && bundledMarketplacePath && shouldAddBundledComputerUseMarketplace(params)) {
+		if (params.managedCodexHome) await migrateLegacyBundledMarketplaceSource({
+			request: params.request,
+			bundledMarketplacePath,
+			legacySources: params.defaultBundledMarketplacePathCandidates,
+			userConfigPath: path.join(params.managedCodexHome, "config.toml")
+		});
 		const added = await params.request("marketplace/add", { source: bundledMarketplacePath });
 		preferredMarketplaceName ??= added.marketplaceName;
 		candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
@@ -444,6 +460,16 @@ async function resolveMarketplaceRef(params) {
 	const marketplace = candidates[0];
 	return marketplace ? { marketplace } : {};
 }
+async function migrateLegacyBundledMarketplaceSource(params) {
+	const response = await params.request("config/read", { includeLayers: false });
+	const bundled = response.config.marketplaces?.[BUNDLED_MARKETPLACE_NAME];
+	const sourceOrigin = response.origins[`marketplaces.${BUNDLED_MARKETPLACE_NAME}.source`];
+	if (bundled?.source_type !== "local" || !bundled.source || sourceOrigin?.name.type !== "user" || sourceOrigin.name.profile !== null || path.resolve(sourceOrigin.name.file) !== path.resolve(params.userConfigPath)) return;
+	const configuredSource = path.resolve(bundled.source);
+	if (configuredSource === path.resolve(params.bundledMarketplacePath)) return;
+	if (!(params.legacySources ?? resolveMacOSDesktopCodexBundledMarketplaceCandidates()).some((source) => path.resolve(source) === configuredSource)) return;
+	await params.request("marketplace/remove", { marketplaceName: BUNDLED_MARKETPLACE_NAME });
+}
 async function listComputerUseMarketplaceCandidates(request, config) {
 	return findComputerUseMarketplaces(await request("plugin/list", { cwds: [] }), config.pluginName);
 }
@@ -456,6 +482,7 @@ function shouldAddBundledComputerUseMarketplace(params) {
 }
 function resolveBundledComputerUseMarketplacePath(params) {
 	if (params.defaultBundledMarketplacePath) return existsSync(params.defaultBundledMarketplacePath) ? params.defaultBundledMarketplacePath : void 0;
+	if (!params.defaultBundledMarketplacePathCandidates) return;
 	return resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath({ candidates: params.defaultBundledMarketplacePathCandidates });
 }
 function findComputerUseMarketplaces(listed, pluginName) {
@@ -694,7 +721,7 @@ function resolveComputerUseConfig(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/plugin-metadata-cache.ts
-const CODEX_PLUGIN_METADATA_CACHE_TTL_MS = 3600 * 1e3;
+const CODEX_PLUGIN_METADATA_CACHE_TTL_MS = 36e5;
 /** Process-local plugin metadata cache with coalesced loads per query. */
 var CodexPluginMetadataCache = class {
 	constructor(nowMs = Date.now) {
@@ -793,4 +820,4 @@ function buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams, catal
 	]);
 }
 //#endregion
-export { runCodexComputerUseLiveTest as a, readCodexComputerUseStatus as i, ensureCodexComputerUse as n, killStaleComputerUseMcpChildren as o, installCodexComputerUse as r, defaultCodexPluginMetadataCache as t };
+export { runCodexComputerUseLiveTest as a, readCodexComputerUseStatus as i, ensureCodexComputerUse as n, installCodexComputerUse as r, defaultCodexPluginMetadataCache as t };