@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/{shared-client-kIBbGjk4.js → shared-client-kNkljY-R.js}

@@ -1,87 +1,173 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { A as resolveCodexAppServerUserHomeDir, _ as resolveCodexAppServerStartOptionsForAgent, g as resolveCodexAppServerRuntimeOptions, o as isCodexAppServerNativeAuthProfile, p as codexAppServerStartOptionsKey, v as resolveCodexComputerUseConfig } from "./session-binding-DPxIvMgE.js";
-import { n as resolveCodexAppServerSpawnEnv, t as createStdioTransport } from "./transport-stdio-DIImwDVS.js";
-import { createRequire } from "node:module";
+import { F as resolveCodexAppServerLocalHomeDir, I as resolveCodexAppServerUserHomeDir, L as withEphemeralCodexAuthStore, P as resolveCodexAppServerHomeDir, a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey } from "./config-Cxw3Cl3k.js";
+import { a as CODEX_APP_SERVER_VERSION, c as resolveMacOSDesktopCodexAppPathCandidates, l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, n as resolveManagedCodexAppServerStartOptions, o as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, r as resolveManagedCodexNativeCommand, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexComputerUseServiceAppCandidates } from "./managed-binary-ZkGodW19.js";
+import { o as isCodexAppServerNativeAuthProfile } from "./session-binding-q2WSTVmC.js";
+import { a as hasCodexAppServerNaturalExit, i as closeCodexAppServerTransportAndWait, n as resolveCodexAppServerSpawnEnv, r as closeCodexAppServerTransport, t as createStdioTransport } from "./transport-stdio-C7-s9TLG.js";
+import { l as readCodexDynamicToolCallParams } from "./protocol-validators-Bg5rpNxk.js";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import fs, { access } from "node:fs/promises";
+import fs from "node:fs/promises";
 import path from "node:path";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { addTimerTimeoutGraceMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, OPENCLAW_VERSION, embeddedAgentLog, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { addTimerTimeoutGraceMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { AgentHarnessPreflightError, OPENCLAW_VERSION, embeddedAgentLog, formatErrorMessage, formatToolExecutionErrorMessage, normalizeQuestionTimeoutSeconds, resolveToolExecutionErrorKind } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import fsSync, { constants, existsSync, readFileSync, realpathSync } from "node:fs";
+import fsSync, { constants, existsSync, watch } from "node:fs";
 import os from "node:os";
 import { isDeepStrictEqual } from "node:util";
 import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveAuthProfileOrder, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
-import { hasUsableOAuthCredential } from "openclaw/plugin-sdk/provider-auth";
+import { hasUsableOAuthCredential, resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
 import { readSecretFile } from "openclaw/plugin-sdk/secret-file";
+import { assertNoSymlinkParents, withTimeout } from "openclaw/plugin-sdk/security-runtime";
 import { runExec } from "openclaw/plugin-sdk/process-runtime";
+import { EventEmitter } from "node:events";
 import { createInterface } from "node:readline";
 import { coerceErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { EventEmitter } from "node:events";
+import { parse } from "semver";
+import { hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import net from "node:net";
 import { PassThrough, Writable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import WebSocket from "ws";
-import { fileURLToPath } from "node:url";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { withTimeout } from "openclaw/plugin-sdk/security-runtime";
-//#region extensions/codex/src/app-server/auth-start-options.ts
-const CODEX_APP_SERVER_HOME_DIRNAME = "codex-home";
-const CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE = "cli_auth_credentials_store=\"ephemeral\"";
-function resolveCodexAppServerHomeDir(agentDir) {
-	return path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME);
-}
-/** Resolves the local CODEX_HOME used when starting one app-server connection. */
-function resolveCodexAppServerLocalHomeDir(startOptions, agentDir, env = process.env) {
-	const configured = startOptions.env?.CODEX_HOME;
-	if (configured?.trim()) return configured;
-	return startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir(env) : resolveCodexAppServerHomeDir(agentDir);
-}
-/** Forces OpenClaw-owned Codex auth to remain process-local. */
-function withEphemeralCodexAuthStore(params) {
-	const { startOptions } = params;
-	if (!(startOptions.commandSource === "managed" || startOptions.commandSource === "resolved-managed") || !params.preparedAuth && params.authProfileId === null) return startOptions;
-	if (startOptions.args.at(-2) === "-c" && startOptions.args.at(-1) === CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE) return startOptions;
+//#region extensions/codex/src/app-server/computer-use-service-path.ts
+/** Filesystem ownership guards for isolated Computer Use service provisioning. */
+async function assertOwnedServicePath(params) {
+	await assertOwnedCodexHomePath({
+		ownershipRoot: params.ownershipRoot,
+		codexHome: params.codexHome,
+		allowMissing: true
+	});
+	assertPathAtOrInside(params.ownershipRoot, params.targetParent, "Computer Use service parent");
+	await assertNoSymlinkParents({
+		rootDir: params.ownershipRoot,
+		targetPath: params.targetParent,
+		allowMissing: true,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+	await assertNotSymlink(params.targetPath, "Computer Use service target");
+}
+async function ensureOwnedCodexHome(codexHomeInput, ownershipRootInput = path.dirname(path.resolve(codexHomeInput))) {
+	const codexHome = path.resolve(codexHomeInput);
+	const ownershipRoot = path.resolve(ownershipRootInput);
+	await fs.mkdir(ownershipRoot, {
+		recursive: true,
+		mode: 448
+	});
+	await assertOwnedCodexHomePath({
+		ownershipRoot,
+		codexHome,
+		allowMissing: true
+	});
+	await ensureRealDirectoryTree(ownershipRoot, codexHome, "isolated Codex home");
+	await assertOwnedCodexHomePath({
+		ownershipRoot,
+		codexHome,
+		allowMissing: false
+	});
+}
+async function prepareOwnedServiceParent(params) {
+	await ensureOwnedCodexHome(params.codexHome, params.ownershipRoot);
+	await ensureRealDirectoryTree(params.ownershipRoot, params.targetParent, "Computer Use service parent");
+	await assertNoSymlinkParents({
+		rootDir: params.ownershipRoot,
+		targetPath: params.targetParent,
+		allowMissing: false,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+	const [rootIdentity, parentIdentity] = await Promise.all([readRealDirectoryIdentity(params.ownershipRoot, "Computer Use ownership root"), readRealDirectoryIdentity(params.targetParent, "Computer Use service parent")]);
+	assertPathAtOrInside(rootIdentity.realPath, parentIdentity.realPath, "canonical Computer Use service parent");
+	return parentIdentity;
+}
+async function assertOwnedCodexHomePath(params) {
+	await readRealDirectoryIdentity(params.ownershipRoot, "Computer Use ownership root");
+	assertPathAtOrInside(params.ownershipRoot, params.codexHome, "isolated Codex home");
+	await assertNoSymlinkParents({
+		rootDir: params.ownershipRoot,
+		targetPath: params.codexHome,
+		allowMissing: params.allowMissing,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+}
+async function readRealDirectoryIdentity(directoryPath, label) {
+	const logicalPath = path.resolve(directoryPath);
+	const before = await fs.lstat(logicalPath);
+	if (before.isSymbolicLink() || !before.isDirectory()) throw new Error(`${label} must be a real directory: ${logicalPath}`);
+	const realPath = await fs.realpath(logicalPath);
+	const [after, resolved] = await Promise.all([fs.lstat(logicalPath), fs.lstat(realPath)]);
+	if (after.isSymbolicLink() || !after.isDirectory() || !resolved.isDirectory() || before.dev !== after.dev || before.ino !== after.ino || after.dev !== resolved.dev || after.ino !== resolved.ino) throw new Error(`${label} changed while its ownership boundary was being established.`);
 	return {
-		...startOptions,
-		args: [
-			...startOptions.args,
-			"-c",
-			CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE
-		]
+		logicalPath,
+		realPath,
+		dev: after.dev,
+		ino: after.ino
 	};
 }
-//#endregion
-//#region extensions/codex/src/app-server/desktop-app-paths.ts
-/** Shared path candidates for Codex's macOS desktop app bundle. */
-const MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES = [{
-	appName: "ChatGPT.app",
-	appBundlePath: "/Applications/ChatGPT.app",
-	appServerCommandPath: "/Applications/ChatGPT.app/Contents/Resources/codex",
-	bundledMarketplacePath: "/Applications/ChatGPT.app/Contents/Resources/plugins/openai-bundled",
-	computerUseServiceAppPaths: ["/Applications/ChatGPT.app/Contents/Resources/cua_node/lib/node_modules/@oai/sky/Codex Computer Use.app", "/Applications/ChatGPT.app/Contents/Resources/plugins/openai-bundled/plugins/computer-use/Codex Computer Use.app"]
-}, {
-	appName: "Codex.app",
-	appBundlePath: "/Applications/Codex.app",
-	appServerCommandPath: "/Applications/Codex.app/Contents/Resources/codex",
-	bundledMarketplacePath: "/Applications/Codex.app/Contents/Resources/plugins/openai-bundled",
-	computerUseServiceAppPaths: ["/Applications/Codex.app/Contents/Resources/plugins/openai-bundled/plugins/computer-use/Codex Computer Use.app", "/Applications/Codex.app/Contents/Resources/cua_node/lib/node_modules/@oai/sky/Codex Computer Use.app"]
-}];
-function resolveMacOSDesktopCodexBundledMarketplaceCandidates(platform = process.platform) {
-	return platform === "darwin" ? MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES.map((candidate) => candidate.bundledMarketplacePath) : [];
-}
-function resolveMacOSDesktopCodexComputerUseServiceAppCandidates(platform = process.platform, appServerCommand) {
-	if (platform !== "darwin") return [];
-	const matchingCandidate = appServerCommand ? MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES.find((candidate) => path.resolve(candidate.appServerCommandPath) === path.resolve(appServerCommand)) : void 0;
-	const orderedCandidates = matchingCandidate ? [matchingCandidate, ...MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES.filter((candidate) => candidate !== matchingCandidate)] : MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES;
-	return [...new Set(orderedCandidates.flatMap((candidate) => candidate.computerUseServiceAppPaths))];
-}
-function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}) {
-	const candidates = params.candidates ?? resolveMacOSDesktopCodexBundledMarketplaceCandidates(params.platform);
-	const pathExists = params.pathExists ?? existsSync;
-	return candidates.find((candidate) => pathExists(candidate));
+async function assertOwnedServiceParentStable(parent) {
+	await assertDirectoryIdentityStable(parent, "Computer Use service parent");
+}
+async function assertDirectoryIdentityStable(expected, label) {
+	if (!await directoryIdentityIsStable(expected)) throw new Error(`${label} changed during refresh; refusing to mutate the replacement path.`);
+}
+async function ownedServiceParentIsStable(parent) {
+	return await directoryIdentityIsStable(parent);
+}
+async function directoryIdentityIsStable(expected) {
+	try {
+		const current = await fs.lstat(expected.logicalPath);
+		if (current.isSymbolicLink() || !current.isDirectory() || current.dev !== expected.dev || current.ino !== expected.ino) return false;
+		return await fs.realpath(expected.logicalPath) === expected.realPath;
+	} catch {
+		return false;
+	}
+}
+async function assertNotSymlink(filePath, label) {
+	try {
+		if ((await fs.lstat(filePath)).isSymbolicLink()) throw new Error(`${label} must not be a symbolic link: ${filePath}`);
+	} catch (error) {
+		if (hasNodeErrorCode$1(error, "ENOENT")) return;
+		throw error;
+	}
+}
+async function ensureRealDirectoryTree(ownershipRoot, directoryPath, label) {
+	const root = path.resolve(ownershipRoot);
+	const target = path.resolve(directoryPath);
+	assertPathAtOrInside(root, target, label);
+	const relative = path.relative(root, target);
+	let current = root;
+	for (const segment of relative.split(path.sep).filter(Boolean)) {
+		current = path.join(current, segment);
+		const existing = await fs.lstat(current).catch((error) => {
+			if (hasNodeErrorCode$1(error, "ENOENT")) return;
+			throw error;
+		});
+		if (!existing) {
+			try {
+				await fs.mkdir(current, { mode: 448 });
+			} catch (error) {
+				if (!hasNodeErrorCode$1(error, "EEXIST")) throw error;
+			}
+			const created = await fs.lstat(current);
+			if (created.isSymbolicLink() || !created.isDirectory()) throw new Error(`${label} changed while its directory tree was being created: ${current}`);
+		} else if (existing.isSymbolicLink() || !existing.isDirectory()) throw new Error(`${label} must traverse real directories: ${current}`);
+	}
+	await assertNoSymlinkParents({
+		rootDir: root,
+		targetPath: target,
+		allowMissing: false,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+	await readRealDirectoryIdentity(target, label);
+}
+function assertPathAtOrInside(rootPath, candidatePath, label) {
+	const relative = path.relative(path.resolve(rootPath), path.resolve(candidatePath));
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw new Error(`${label} must remain inside ${path.resolve(rootPath)}.`);
+}
+function hasNodeErrorCode$1(error, code) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
 }
 //#endregion
 //#region extensions/codex/src/app-server/computer-use-cache.ts
@@ -101,7 +187,12 @@ async function ensureCodexComputerUseSharedPluginCache(params) {
 	const cachePath = path.join(cacheRoot, version);
 	return {
 		status: "shared",
-		changed: await ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version),
+		changed: await ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, {
+			codexHome: params.codexHome,
+			ownershipRoot: params.ownershipRoot,
+			assertCurrent: params.assertCurrent,
+			forceRefresh: params.forceRefresh
+		}),
 		cachePath,
 		targetPath: sourcePluginRoot,
 		version,
@@ -128,42 +219,57 @@ async function readBundledPluginVersion(sourcePluginRoot) {
 		return;
 	}
 }
-async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version) {
-	await fs.mkdir(path.dirname(cachePath), { recursive: true });
-	const stat = await fs.lstat(cachePath).catch(() => void 0);
+async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, boundary) {
+	const cacheRoot = path.dirname(cachePath);
+	const ownedParent = boundary.ownershipRoot ? await prepareOwnedServiceParent({
+		ownershipRoot: boundary.ownershipRoot,
+		codexHome: boundary.codexHome,
+		targetParent: cacheRoot
+	}) : void 0;
+	if (!ownedParent) await fs.mkdir(cacheRoot, { recursive: true });
+	const physicalCachePath = ownedParent ? path.join(ownedParent.realPath, path.basename(cachePath)) : cachePath;
+	const stat = await fs.lstat(physicalCachePath).catch(() => void 0);
 	if (stat?.isDirectory() && !stat.isSymbolicLink()) {
-		if (await readBundledPluginVersion(cachePath) === version) return false;
+		if (await readBundledPluginVersion(physicalCachePath) === version && !boundary.forceRefresh) return false;
 	}
-	const cacheRoot = path.dirname(cachePath);
 	const cacheName = path.basename(cachePath);
-	const stagingRoot = await fs.mkdtemp(path.join(cacheRoot, `.${cacheName}.staging-`));
+	const physicalCacheRoot = path.dirname(physicalCachePath);
+	const stagingRoot = await fs.mkdtemp(path.join(physicalCacheRoot, `.${cacheName}.staging-`));
 	const stagedPath = path.join(stagingRoot, cacheName);
-	const backupPath = path.join(cacheRoot, `.${cacheName}.backup-${process.pid}-${Date.now()}`);
+	const backupPath = path.join(physicalCacheRoot, `.${cacheName}.backup-${process.pid}-${Date.now()}`);
 	let backupCreated = false;
 	try {
 		await fs.cp(sourcePluginRoot, stagedPath, { recursive: true });
+		if (ownedParent) await assertDirectoryIdentityStable(ownedParent, "Computer Use plugin cache parent");
 		if (stat) {
-			await fs.rename(cachePath, backupPath);
+			boundary.assertCurrent?.();
+			await fs.rename(physicalCachePath, backupPath);
 			backupCreated = true;
 		}
 		try {
-			await fs.rename(stagedPath, cachePath);
+			if (ownedParent) await assertDirectoryIdentityStable(ownedParent, "Computer Use plugin cache parent");
+			boundary.assertCurrent?.();
+			await fs.rename(stagedPath, physicalCachePath);
 		} catch (error) {
 			if (backupCreated) try {
-				await fs.rename(backupPath, cachePath);
+				if (ownedParent) await assertDirectoryIdentityStable(ownedParent, "Computer Use plugin cache parent");
+				await fs.rename(backupPath, physicalCachePath);
 				backupCreated = false;
 			} catch (restoreError) {
 				throw new Error(`Failed to install Computer Use cache ${cachePath} and restore its prior copy: ${String(error)}`, { cause: restoreError });
 			}
 			throw error;
 		}
-		if (backupCreated) await fs.rm(backupPath, {
-			recursive: true,
-			force: true
-		});
+		if (backupCreated) {
+			if (ownedParent) await assertDirectoryIdentityStable(ownedParent, "Computer Use plugin cache parent");
+			await fs.rm(backupPath, {
+				recursive: true,
+				force: true
+			});
+		}
 		return true;
 	} finally {
-		await fs.rm(stagingRoot, {
+		if (!ownedParent || await directoryIdentityIsStable(ownedParent)) await fs.rm(stagingRoot, {
 			recursive: true,
 			force: true
 		});
@@ -179,108 +285,360 @@ function skippedCacheResult(status, message) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/computer-use-marketplace.ts
+/** Managed local wrapper for Codex's reserved bundled marketplace. */
+const MARKETPLACE_NAME = "openai-bundled";
+const activeInstalls$1 = /* @__PURE__ */ new Map();
+function resolveCodexManagedBundledMarketplacePath(codexHome) {
+	return path.join(codexHome, ".tmp", "bundled-marketplaces", MARKETPLACE_NAME);
+}
+async function ensureCodexManagedBundledMarketplace(params) {
+	const candidates = params.candidates ?? resolveMacOSDesktopCodexAppPathCandidates();
+	const source = await resolveCodexManagedBundledMarketplaceSource({
+		...params,
+		candidates
+	});
+	if (!source) return;
+	const parentPath = path.dirname(resolveCodexManagedBundledMarketplacePath(params.codexHome));
+	const targetPath = path.join(parentPath, MARKETPLACE_NAME);
+	const parent = await prepareOwnedServiceParent({
+		ownershipRoot: params.ownershipRoot,
+		codexHome: params.codexHome,
+		targetParent: parentPath
+	});
+	const physicalTargetPath = path.join(parent.realPath, MARKETPLACE_NAME);
+	await assertNotSymlink(physicalTargetPath, "managed bundled marketplace");
+	const active = activeInstalls$1.get(physicalTargetPath);
+	if (active) {
+		if (active.sourcePath === source.bundledMarketplacePath) return await active.promise;
+		await active.promise.catch(() => void 0);
+		return await ensureCodexManagedBundledMarketplace(params);
+	}
+	const install = reconcileManagedWrapper({
+		parent,
+		physicalTargetPath,
+		targetPath,
+		source,
+		ownershipCandidates: params.ownershipCandidates ?? candidates,
+		assertCurrent: params.assertCurrent
+	});
+	const activeEntry = {
+		sourcePath: source.bundledMarketplacePath,
+		promise: install
+	};
+	activeInstalls$1.set(physicalTargetPath, activeEntry);
+	const clearActive = () => {
+		if (activeInstalls$1.get(physicalTargetPath) === activeEntry) activeInstalls$1.delete(physicalTargetPath);
+	};
+	install.then(clearActive, clearActive);
+	return await install;
+}
+async function reconcileManagedWrapper(params) {
+	if (await wrapperMatches(params.physicalTargetPath, params.source.bundledMarketplacePath)) return params.targetPath;
+	return await publishManagedWrapper(params);
+}
+async function publishManagedWrapper(params) {
+	const { parent, physicalTargetPath, targetPath, source, ownershipCandidates, assertCurrent } = params;
+	const stagingPath = await fs.mkdtemp(path.join(parent.realPath, `.${MARKETPLACE_NAME}.staging-`));
+	const backupPath = path.join(parent.realPath, `.${MARKETPLACE_NAME}.backup-${process.pid}-${Date.now()}`);
+	let backupCreated = false;
+	try {
+		const manifestParent = path.join(stagingPath, ".agents", "plugins");
+		await fs.mkdir(manifestParent, {
+			recursive: true,
+			mode: 448
+		});
+		await Promise.all([fs.symlink(path.join(source.bundledMarketplacePath, ".agents", "plugins", "marketplace.json"), path.join(manifestParent, "marketplace.json")), fs.symlink(path.join(source.bundledMarketplacePath, "plugins"), path.join(stagingPath, "plugins"))]);
+		await assertDirectoryIdentityStable(parent, "managed bundled marketplace parent");
+		const existing = await fs.lstat(physicalTargetPath).catch((error) => {
+			if (hasNodeErrorCode(error, "ENOENT")) return;
+			throw error;
+		});
+		if (existing && !existing.isDirectory()) throw new Error(`Managed bundled marketplace must be a real directory: ${targetPath}`);
+		if (existing && !await wrapperMatchesAnySource(physicalTargetPath, ownershipCandidates)) throw new Error(`Refusing to replace an unowned bundled marketplace directory: ${targetPath}`);
+		if (existing) {
+			assertCurrent?.();
+			await fs.rename(physicalTargetPath, backupPath);
+			backupCreated = true;
+			await assertDirectoryIdentityStable(parent, "managed bundled marketplace parent");
+		}
+		assertCurrent?.();
+		await fs.rename(stagingPath, physicalTargetPath);
+		await assertDirectoryIdentityStable(parent, "managed bundled marketplace parent");
+		if (backupCreated) {
+			await fs.rm(backupPath, { recursive: true });
+			backupCreated = false;
+		}
+		return targetPath;
+	} catch (error) {
+		if (backupCreated) try {
+			await assertDirectoryIdentityStable(parent, "managed bundled marketplace parent");
+			if (await fs.lstat(physicalTargetPath).catch(() => void 0)) {
+				if (!await wrapperMatches(physicalTargetPath, source.bundledMarketplacePath)) throw new Error("managed bundled marketplace replacement is no longer owned", { cause: error });
+				await fs.rm(physicalTargetPath, { recursive: true });
+			}
+			await fs.rename(backupPath, physicalTargetPath);
+			backupCreated = false;
+		} catch (restoreError) {
+			throw new Error(`Failed to restore the prior managed bundled marketplace: ${String(error)}`, { cause: restoreError });
+		}
+		throw error;
+	} finally {
+		if (await directoryIdentityIsStable(parent)) await fs.rm(stagingPath, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function resolveCodexManagedBundledMarketplaceSource(params) {
+	const candidates = params.candidates ?? resolveMacOSDesktopCodexAppPathCandidates();
+	const command = params.appServerCommand && path.resolve(params.appServerCommand);
+	const ordered = command ? candidates.filter((candidate) => path.resolve(candidate.appServerCommandPath) === command) : candidates;
+	for (const candidate of ordered) if (await isExpectedMarketplace(candidate.bundledMarketplacePath)) return candidate;
+}
+async function isExpectedMarketplace(root) {
+	try {
+		const manifest = JSON.parse(await fs.readFile(path.join(root, ".agents", "plugins", "marketplace.json"), "utf8"));
+		await fs.access(path.join(root, "plugins", "computer-use", ".codex-plugin", "plugin.json"));
+		return isRecord(manifest) && manifest.name === MARKETPLACE_NAME && Array.isArray(manifest.plugins) && manifest.plugins.some((plugin) => isRecord(plugin) && plugin.name === "computer-use");
+	} catch {
+		return false;
+	}
+}
+async function wrapperMatches(targetPath, sourcePath) {
+	try {
+		const target = await fs.lstat(targetPath);
+		if (!target.isDirectory() || target.isSymbolicLink()) return false;
+		const [manifest, plugins] = await Promise.all([fs.readlink(path.join(targetPath, ".agents", "plugins", "marketplace.json")), fs.readlink(path.join(targetPath, "plugins"))]);
+		return manifest === path.join(sourcePath, ".agents", "plugins", "marketplace.json") && plugins === path.join(sourcePath, "plugins");
+	} catch {
+		return false;
+	}
+}
+async function wrapperMatchesAnySource(targetPath, candidates) {
+	for (const candidate of candidates) if (await wrapperMatches(targetPath, candidate.bundledMarketplacePath)) return true;
+	return false;
+}
+function hasNodeErrorCode(error, code) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+//#endregion
 //#region extensions/codex/src/app-server/computer-use-service.ts
 /** Native Computer Use service provisioning for isolated Codex homes. */
 const SERVICE_APP_NAME = "Codex Computer Use.app";
-const CLIENT_RELATIVE_PATH = path.join("Contents", "SharedSupport", "SkyComputerUseClient.app", "Contents", "MacOS", "SkyComputerUseClient");
+const SERVICE_BUNDLE_ID = "com.openai.sky.CUAService";
+const CLIENT_BUNDLE_ID = "com.openai.sky.CUAService.cli";
+const OPENAI_TEAM_ID = "2DC432GLL2";
+const CLIENT_APP_RELATIVE_PATH = path.join("Contents", "SharedSupport", "SkyComputerUseClient.app");
+const CLIENT_RELATIVE_PATH = path.join(CLIENT_APP_RELATIVE_PATH, "Contents", "MacOS", "SkyComputerUseClient");
 const COPY_TIMEOUT_MS = 12e4;
+const INSPECT_TIMEOUT_MS = 3e4;
 const activeInstalls = /* @__PURE__ */ new Map();
-/** Ensures the official native client exists beneath the CODEX_HOME used by its launcher. */
+/** Finds the first signed native service from one ordered desktop owner set. */
+async function resolveCodexComputerUseServiceAppSourcePath(params) {
+	const platform = params.platform ?? process.platform;
+	if (platform !== "darwin") return;
+	return (await findUsableServiceApp(params.sourceAppCandidates ?? resolveMacOSDesktopCodexComputerUseServiceAppCandidates(platform, params.appServerCommand), params.inspectServiceApp ?? inspectTrustedServiceApp))?.path;
+}
+/** Synchronizes the CODEX_HOME native client with the selected signed desktop distribution. */
 async function ensureCodexComputerUseServiceApp(params) {
 	const platform = params.platform ?? process.platform;
 	if (platform !== "darwin") return {
 		status: "unsupported",
 		changed: false
 	};
-	const targetPath = path.join(path.resolve(params.codexHome), "computer-use", SERVICE_APP_NAME);
+	const codexHome = path.resolve(params.codexHome);
+	const ownershipRoot = path.resolve(params.ownershipRoot ?? path.dirname(codexHome));
+	const targetParent = path.join(codexHome, "computer-use");
+	const targetPath = path.join(targetParent, SERVICE_APP_NAME);
+	await ensureOwnedCodexHome(codexHome, ownershipRoot);
+	await assertOwnedServicePath({
+		ownershipRoot,
+		codexHome,
+		targetParent,
+		targetPath
+	});
+	const candidates = params.sourceAppCandidates ?? resolveMacOSDesktopCodexComputerUseServiceAppCandidates(platform, params.appServerCommand);
+	const syncKey = [targetPath, ...candidates].join("\0");
 	const active = activeInstalls.get(targetPath);
-	if (active) return await active;
+	if (active) {
+		if (active.syncKey === syncKey) return await active.promise;
+		await active.promise.catch(() => void 0);
+		return await ensureCodexComputerUseServiceApp(params);
+	}
 	const install = ensureCodexComputerUseServiceAppOnce({
 		...params,
+		codexHome,
+		ownershipRoot,
+		targetParent,
 		targetPath,
-		platform
+		platform,
+		sourceAppCandidates: candidates
 	});
-	activeInstalls.set(targetPath, install);
-	try {
-		return await install;
-	} finally {
-		if (activeInstalls.get(targetPath) === install) activeInstalls.delete(targetPath);
-	}
+	const activeEntry = {
+		syncKey,
+		promise: install
+	};
+	activeInstalls.set(targetPath, activeEntry);
+	const clearActive = () => {
+		if (activeInstalls.get(targetPath) === activeEntry) activeInstalls.delete(targetPath);
+	};
+	install.then(clearActive, clearActive);
+	return await install;
 }
 async function ensureCodexComputerUseServiceAppOnce(params) {
-	if (await hasExecutableClient(params.targetPath)) return {
-		status: "already_installed",
+	const inspectServiceApp = params.inspectServiceApp ?? inspectTrustedServiceApp;
+	const source = await findUsableServiceApp(params.sourceAppCandidates ?? [], inspectServiceApp);
+	if (!source) return {
+		status: "source_missing",
 		changed: false,
 		targetPath: params.targetPath
 	};
-	const sourcePath = await findUsableServiceApp(params.sourceAppCandidates ?? resolveMacOSDesktopCodexComputerUseServiceAppCandidates(params.platform, params.appServerCommand));
-	if (!sourcePath) return {
-		status: "source_missing",
+	const { path: sourcePath, identity: sourceIdentity } = source;
+	const ownedParent = await prepareOwnedServiceParent({
+		ownershipRoot: params.ownershipRoot,
+		codexHome: params.codexHome,
+		targetParent: params.targetParent
+	});
+	const operationTargetPath = path.join(ownedParent.realPath, SERVICE_APP_NAME);
+	await assertNotSymlink(operationTargetPath, "Computer Use service target");
+	const initialTarget = await readServiceAppSnapshot(operationTargetPath, inspectServiceApp);
+	if (initialTarget.identity && identitiesMatch(initialTarget.identity, sourceIdentity)) return {
+		status: "already_current",
 		changed: false,
-		targetPath: params.targetPath
+		targetPath: params.targetPath,
+		sourcePath,
+		sourceBuild: sourceIdentity.build
 	};
-	const targetParent = path.dirname(params.targetPath);
-	await fs.mkdir(targetParent, { recursive: true });
-	const stagingRoot = await fs.mkdtemp(path.join(targetParent, ".service-app.staging-"));
+	await assertOwnedServiceParentStable(ownedParent);
+	const stagingRoot = await fs.mkdtemp(path.join(ownedParent.realPath, ".service-app.staging-"));
+	const stagingRootIdentity = await readRealDirectoryIdentity(stagingRoot, "Computer Use service staging directory");
 	const stagedPath = path.join(stagingRoot, SERVICE_APP_NAME);
-	const backupPath = path.join(targetParent, `.service-app.backup-${process.pid}-${Date.now()}`);
+	const backupPath = path.join(ownedParent.realPath, `.service-app.backup-${process.pid}-${Date.now()}`);
 	let backupCreated = false;
 	try {
 		await (params.copyServiceApp ?? copyServiceAppWithDitto)(sourcePath, stagedPath);
-		if (!await hasExecutableClient(stagedPath)) throw new Error(`Copied Computer Use service app is incomplete at ${stagedPath}.`);
-		if (await pathExists$1(params.targetPath)) {
-			await fs.rename(params.targetPath, backupPath);
+		await assertOwnedServiceParentStable(ownedParent);
+		await assertDirectoryIdentityStable(stagingRootIdentity, "Computer Use service staging directory");
+		await assertNotSymlink(stagedPath, "Copied Computer Use service app");
+		const stagedIdentity = await inspectServiceApp(stagedPath);
+		if (!stagedIdentity || !identitiesMatch(stagedIdentity, sourceIdentity)) throw new Error(`Copied Computer Use service app at ${stagedPath} does not match its selected signed source.`);
+		const stagedSnapshot = await readServiceAppSnapshot(stagedPath, inspectServiceApp);
+		const currentSourceIdentity = await inspectServiceApp(sourcePath);
+		await assertOwnedServiceParentStable(ownedParent);
+		if (!currentSourceIdentity || !identitiesMatch(currentSourceIdentity, sourceIdentity)) throw new Error("Selected Computer Use service source changed during refresh.");
+		await assertNotSymlink(operationTargetPath, "Computer Use service target");
+		if (await pathExists$1(operationTargetPath)) {
+			await assertOwnedServiceParentStable(ownedParent);
+			params.assertCurrent?.();
+			await fs.rename(operationTargetPath, backupPath);
+			await assertOwnedServiceParentStable(ownedParent);
 			backupCreated = true;
-			if (await hasExecutableClient(backupPath)) {
-				await fs.rename(backupPath, params.targetPath);
+			const movedTarget = await readServiceAppSnapshot(backupPath, inspectServiceApp);
+			if (movedTarget.identity && identitiesMatch(movedTarget.identity, sourceIdentity)) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await fs.rename(backupPath, operationTargetPath);
+				await assertOwnedServiceParentStable(ownedParent);
 				backupCreated = false;
 				return {
-					status: "already_installed",
+					status: "already_current",
 					changed: false,
 					targetPath: params.targetPath,
-					sourcePath
+					sourcePath,
+					sourceBuild: sourceIdentity.build
 				};
 			}
+			if (!snapshotsMatch(initialTarget, movedTarget)) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await fs.rename(backupPath, operationTargetPath);
+				await assertOwnedServiceParentStable(ownedParent);
+				backupCreated = false;
+				throw new Error("Computer Use service target changed to an unexpected generation during refresh.");
+			}
 		}
 		try {
-			await fs.rename(stagedPath, params.targetPath);
+			await assertOwnedServiceParentStable(ownedParent);
+			params.assertCurrent?.();
+			await fs.rename(stagedPath, operationTargetPath);
+			await assertOwnedServiceParentStable(ownedParent);
 		} catch (error) {
-			if (!await hasExecutableClient(params.targetPath)) {
+			await assertOwnedServiceParentStable(ownedParent);
+			await assertNotSymlink(operationTargetPath, "Computer Use service target");
+			const winnerIdentity = await inspectServiceApp(operationTargetPath);
+			if (!winnerIdentity || !identitiesMatch(winnerIdentity, sourceIdentity)) {
 				if (backupCreated) {
-					await fs.rename(backupPath, params.targetPath);
-					backupCreated = false;
+					if (!await pathExists$1(operationTargetPath)) {
+						await assertOwnedServiceParentStable(ownedParent);
+						await fs.rename(backupPath, operationTargetPath);
+						await assertOwnedServiceParentStable(ownedParent);
+						backupCreated = false;
+					}
 				}
 				throw error;
 			}
 			if (backupCreated) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await assertNotSymlink(backupPath, "Computer Use service backup");
 				await fs.rm(backupPath, {
 					recursive: true,
 					force: true
 				});
+				await assertOwnedServiceParentStable(ownedParent);
 				backupCreated = false;
 			}
 			return {
-				status: "already_installed",
+				status: "already_current",
 				changed: false,
 				targetPath: params.targetPath,
-				sourcePath
+				sourcePath,
+				sourceBuild: sourceIdentity.build
 			};
 		}
+		await assertNotSymlink(operationTargetPath, "Installed Computer Use service app");
+		const installedSnapshot = await readServiceAppSnapshot(operationTargetPath, inspectServiceApp);
+		if (!installedSnapshot.identity || !identitiesMatch(installedSnapshot.identity, sourceIdentity)) {
+			if (filesystemSnapshotsMatch(installedSnapshot, stagedSnapshot)) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await fs.rm(operationTargetPath, {
+					recursive: true,
+					force: true
+				});
+				await assertOwnedServiceParentStable(ownedParent);
+				if (backupCreated) {
+					await fs.rename(backupPath, operationTargetPath);
+					await assertOwnedServiceParentStable(ownedParent);
+					backupCreated = false;
+				}
+			}
+			throw new Error("Installed Computer Use service app failed post-install identity verification.");
+		}
 		if (backupCreated) {
+			await assertOwnedServiceParentStable(ownedParent);
+			await assertNotSymlink(backupPath, "Computer Use service backup");
 			await fs.rm(backupPath, {
 				recursive: true,
 				force: true
 			});
+			await assertOwnedServiceParentStable(ownedParent);
 			backupCreated = false;
 		}
 		return {
-			status: "installed",
+			status: initialTarget.exists ? "refreshed" : "installed",
 			changed: true,
 			targetPath: params.targetPath,
-			sourcePath
+			sourcePath,
+			sourceBuild: sourceIdentity.build,
+			...initialTarget.identity ? { previousBuild: initialTarget.identity.build } : {}
 		};
+	} catch (error) {
+		if (backupCreated && await ownedServiceParentIsStable(ownedParent) && !await pathExists$1(operationTargetPath)) {
+			await assertOwnedServiceParentStable(ownedParent);
+			await fs.rename(backupPath, operationTargetPath);
+			backupCreated = false;
+		}
+		throw error;
 	} finally {
-		await fs.rm(stagingRoot, {
+		if (await ownedServiceParentIsStable(ownedParent) && await directoryIdentityIsStable(stagingRootIdentity)) await fs.rm(stagingRoot, {
 			recursive: true,
 			force: true
 		});
@@ -289,8 +647,43 @@ async function ensureCodexComputerUseServiceAppOnce(params) {
 async function pathExists$1(filePath) {
 	return await fs.lstat(filePath).then(() => true, () => false);
 }
-async function findUsableServiceApp(candidates) {
-	for (const candidate of candidates) if (await hasExecutableClient(candidate)) return candidate;
+async function findUsableServiceApp(candidates, inspectServiceApp) {
+	for (const candidate of candidates) {
+		const identity = await inspectServiceApp(candidate);
+		if (identity) return {
+			path: candidate,
+			identity
+		};
+	}
+}
+async function readServiceAppSnapshot(appPath, inspectServiceApp) {
+	if (!await pathExists$1(appPath)) return { exists: false };
+	return {
+		exists: true,
+		identity: await inspectServiceApp(appPath),
+		filesystemKey: await readServiceAppFilesystemKey(appPath)
+	};
+}
+async function readServiceAppFilesystemKey(appPath) {
+	const paths = [
+		appPath,
+		path.join(appPath, "Contents", "Info.plist"),
+		path.join(appPath, CLIENT_RELATIVE_PATH)
+	];
+	return (await Promise.all(paths.map(async (entryPath) => await fs.stat(entryPath).then((stat) => `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`, () => "missing")))).join("|");
+}
+function snapshotsMatch(left, right) {
+	if (left.exists !== right.exists) return false;
+	if (!left.exists) return true;
+	if (left.filesystemKey && right.filesystemKey && left.filesystemKey !== right.filesystemKey) return false;
+	if (left.identity || right.identity) return Boolean(left.identity && right.identity && identitiesMatch(left.identity, right.identity));
+	return left.filesystemKey !== void 0 && left.filesystemKey === right.filesystemKey;
+}
+function filesystemSnapshotsMatch(left, right) {
+	return Boolean(left.exists && right.exists && left.filesystemKey && right.filesystemKey && left.filesystemKey === right.filesystemKey);
+}
+function identitiesMatch(left, right) {
+	return left.bundleId === right.bundleId && left.version === right.version && left.build === right.build && left.cdHash === right.cdHash && left.teamId === right.teamId && left.clientBundleId === right.clientBundleId && left.clientCdHash === right.clientCdHash && left.clientTeamId === right.clientTeamId;
 }
 async function hasExecutableClient(appPath) {
 	try {
@@ -300,6 +693,90 @@ async function hasExecutableClient(appPath) {
 		return false;
 	}
 }
+async function inspectTrustedServiceApp(appPath) {
+	if (!await hasExecutableClient(appPath)) return;
+	const clientAppPath = path.join(appPath, CLIENT_APP_RELATIVE_PATH);
+	try {
+		await verifyTrustedBundle(appPath, SERVICE_BUNDLE_ID, true);
+		await verifyTrustedBundle(clientAppPath, CLIENT_BUNDLE_ID, false);
+		const [info, serviceSignature, clientSignature] = await Promise.all([
+			readBundleInfo(appPath),
+			readCodeSignature(appPath),
+			readCodeSignature(clientAppPath)
+		]);
+		if (!info || serviceSignature.identifier !== SERVICE_BUNDLE_ID || serviceSignature.teamId !== OPENAI_TEAM_ID || clientSignature.identifier !== CLIENT_BUNDLE_ID || clientSignature.teamId !== OPENAI_TEAM_ID) return;
+		return {
+			bundleId: serviceSignature.identifier,
+			version: info.version,
+			build: info.build,
+			cdHash: serviceSignature.cdHash,
+			teamId: serviceSignature.teamId,
+			clientBundleId: clientSignature.identifier,
+			clientCdHash: clientSignature.cdHash,
+			clientTeamId: clientSignature.teamId
+		};
+	} catch {
+		return;
+	}
+}
+async function verifyTrustedBundle(appPath, bundleId, deep) {
+	const requirement = `anchor apple generic and certificate leaf[subject.OU] = "${OPENAI_TEAM_ID}" and identifier "${bundleId}"`;
+	await runExec("/usr/bin/codesign", [
+		"--verify",
+		"--strict",
+		...deep ? ["--deep"] : [],
+		`-R=${requirement}`,
+		appPath
+	], {
+		logOutput: false,
+		timeoutMs: INSPECT_TIMEOUT_MS
+	});
+}
+async function readBundleInfo(appPath) {
+	const result = await runExec("/usr/bin/plutil", [
+		"-convert",
+		"json",
+		"-o",
+		"-",
+		"--",
+		path.join(appPath, "Contents", "Info.plist")
+	], {
+		logOutput: false,
+		timeoutMs: INSPECT_TIMEOUT_MS
+	});
+	const parsed = JSON.parse(result.stdout);
+	if (!isRecord(parsed)) return;
+	const version = parsed.CFBundleShortVersionString;
+	const build = parsed.CFBundleVersion;
+	return typeof version === "string" && version && typeof build === "string" && build ? {
+		version,
+		build
+	} : void 0;
+}
+async function readCodeSignature(appPath) {
+	const result = await runExec("/usr/bin/codesign", [
+		"-d",
+		"--verbose=4",
+		appPath
+	], {
+		logOutput: false,
+		timeoutMs: INSPECT_TIMEOUT_MS
+	});
+	const output = `${result.stdout}\n${result.stderr}`;
+	const identifier = readCodeSignField(output, "Identifier");
+	const teamId = readCodeSignField(output, "TeamIdentifier");
+	const cdHash = readCodeSignField(output, "CDHash").toLowerCase();
+	if (!identifier || !teamId || !/^[a-f0-9]+$/.test(cdHash)) throw new Error(`Could not inspect the signed identity at ${appPath}.`);
+	return {
+		identifier,
+		teamId,
+		cdHash
+	};
+}
+function readCodeSignField(output, field) {
+	const prefix = `${field}=`;
+	return output.split(/\r?\n/u).find((candidate) => candidate.startsWith(prefix))?.slice(prefix.length).trim() ?? "";
+}
 async function copyServiceAppWithDitto(sourcePath, targetPath) {
 	await runExec("/usr/bin/ditto", [
 		"--noqtn",
@@ -344,10 +821,12 @@ const CODEX_APP_SERVER_PREPARED_AUTH_ENV_VARS = [
 const CODEX_APP_SERVER_HOME_ENV_VARS = [CODEX_HOME_ENV_VAR, HOME_ENV_VAR];
 const CODEX_AUTH_JSON_FILENAME = "auth.json";
 const CODEX_HOME_DIRNAME = ".codex";
+const MAX_COMPUTER_USE_ARTIFACT_OWNERS = 128;
+const activeComputerUseArtifactReconciliations = /* @__PURE__ */ new Map();
 const scopedOAuthRefreshQueues = /* @__PURE__ */ new WeakMap();
 async function bridgeCodexAppServerStartOptions(params) {
 	if (params.startOptions.transport !== "stdio") return params.startOptions;
-	const scopeStartOptions = () => withCodexHomeEnvironment(withEphemeralCodexAuthStore(params), params.agentDir, params.pluginConfig);
+	const scopeStartOptions = () => withCodexHomeEnvironment(withEphemeralCodexAuthStore(params), params.agentDir);
 	if (params.preparedAuth) return withClearedEnvironmentVariables(await scopeStartOptions(), CODEX_APP_SERVER_PREPARED_AUTH_ENV_VARS);
 	if (params.authProfileId === null) return scopeStartOptions();
 	const store = resolveCodexAppServerAuthProfileStore({
@@ -374,8 +853,7 @@ function assertNoUnimportedAgentCodexAuthFile(params) {
 	if (message) throw new AgentHarnessPreflightError(message);
 }
 function resolveUnimportedAgentCodexAuthMessage(params) {
-	const managedCodexCli = params.startOptions.commandSource === "managed" || params.startOptions.commandSource === "resolved-managed";
-	if (params.startOptions.transport !== "stdio" || !managedCodexCli || params.startOptions.homeScope === "user") return;
+	if (params.startOptions.transport !== "stdio" || params.startOptions.homeScope === "user") return;
 	const codexHome = resolveCodexAppServerHomeDir(params.agentDir);
 	const authPath = path.join(codexHome, CODEX_AUTH_JSON_FILENAME);
 	if (!fsSync.existsSync(authPath)) return;
@@ -447,7 +925,7 @@ async function resolveCodexAppServerPreparedAuthProfileSnapshot(params) {
 	const accountId = loginParams.type === "chatgptAuthTokens" ? loginParams.chatgptAccountId : resolveChatgptAccountId(profileId, credential);
 	const stableChatgptAccountId = resolveStableChatgptAccountId(credential);
 	const secretFreeCacheKey = credential.type === "api_key" && loginParams.type === "apiKey" ? `${accountId}:${fingerprintApiKeyAuthProfileCacheKey(loginParams.apiKey)}` : loginParams.type === "chatgptAuthTokens" && (credential.type === "token" || !stableChatgptAccountId) ? `${accountId}:${fingerprintTokenAuthProfileCacheKey(loginParams.accessToken)}` : accountId;
-	const chatgptAccountId = resolveExplicitChatgptAccountId(credential);
+	const chatgptAccountId = loginParams.type === "chatgptAuthTokens" ? loginParams.chatgptAccountId : void 0;
 	return {
 		loginParams,
 		secretFreeCacheKey,
@@ -458,7 +936,8 @@ async function resolveCodexAppServerPreparedAuthProfileSnapshot(params) {
 async function resolveCodexAppServerPreparedAuthHandoff(params) {
 	const usesNativeHome = params.homeScope === "user";
 	if (params.requirePreparedAuth && usesNativeHome) throw createCodexAppServerAuthError("Codex remote-exec cloud placement requires prepared OpenAI auth. Configure an OpenAI API-key, OAuth, or token profile and use appServer.homeScope=\"agent\"; ambient credentials and native Codex auth are not allowed.");
-	if (params.authRequirement === "api-key" && !usesNativeHome) {
+	if (usesNativeHome) return { nativeAuthProfile: true };
+	if (params.authRequirement === "api-key") {
 		const apiKey = params.resolvedApiKey?.trim();
 		if (!apiKey) throw new Error("Prepared Codex API-key route is missing its resolved API key.");
 		return {
@@ -476,7 +955,7 @@ async function resolveCodexAppServerPreparedAuthHandoff(params) {
 		agentDir: params.agentDir,
 		config: params.config
 	});
-	if (usesNativeHome || params.authRequirement !== "subscription" && !params.requirePreparedAuth) return {
+	if (params.authRequirement !== "subscription" && !params.requirePreparedAuth) return {
 		authProfileId,
 		nativeAuthProfile
 	};
@@ -575,26 +1054,10 @@ function fingerprintCodexCliAuthFileApiKeyCacheKey(apiKey) {
 	hash.update(apiKey);
 	return `CODEX_AUTH_JSON:sha256:${hash.digest("hex")}`;
 }
-async function withCodexHomeEnvironment(startOptions, agentDir, pluginConfig) {
+async function withCodexHomeEnvironment(startOptions, agentDir) {
 	const codexHome = resolveCodexAppServerLocalHomeDir(startOptions, agentDir);
 	const nativeHome = startOptions.env?.[HOME_ENV_VAR]?.trim() ? startOptions.env[HOME_ENV_VAR] : void 0;
 	await fs.mkdir(codexHome, { recursive: true });
-	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
-	await ensureCodexComputerUseSharedPluginCache({
-		codexHome,
-		config: computerUseConfig
-	});
-	if (computerUseConfig.enabled && computerUseConfig.autoInstall) try {
-		await ensureCodexComputerUseServiceApp({
-			codexHome,
-			appServerCommand: startOptions.command
-		});
-	} catch (error) {
-		throw new AgentHarnessPreflightError("Codex Computer Use client provisioning failed.", {
-			cause: error,
-			scope: "harness"
-		});
-	}
 	if (nativeHome) await fs.mkdir(nativeHome, { recursive: true });
 	const nextStartOptions = {
 		...startOptions,
@@ -609,6 +1072,138 @@ async function withCodexHomeEnvironment(startOptions, agentDir, pluginConfig) {
 	else delete nextStartOptions.clearEnv;
 	return nextStartOptions;
 }
+/** Reconciles Computer Use artifacts for the exact managed command about to start. */
+async function reconcileCodexComputerUseStartArtifacts(params) {
+	if (params.startOptions.transport !== "stdio") return;
+	const codexHome = resolveCodexAppServerLocalHomeDir(params.startOptions, params.agentDir);
+	const key = path.resolve(codexHome);
+	let owner = activeComputerUseArtifactReconciliations.get(key);
+	if (!owner) {
+		owner = {
+			active: 0,
+			tail: Promise.resolve()
+		};
+		activeComputerUseArtifactReconciliations.set(key, owner);
+	} else {
+		activeComputerUseArtifactReconciliations.delete(key);
+		activeComputerUseArtifactReconciliations.set(key, owner);
+	}
+	owner.active += 1;
+	const epoch = params.desktopGeneration?.epoch;
+	if (epoch !== void 0 && (owner.latestEpoch === void 0 || epoch > owner.latestEpoch)) owner.latestEpoch = epoch;
+	const assertCurrent = () => {
+		params.assertCurrent?.();
+		if (epoch !== void 0 && owner.latestEpoch !== epoch) throw new Error("Codex Computer Use artifact reconciliation was superseded.");
+	};
+	const operation = owner.tail.catch(() => void 0).then(async () => {
+		assertCurrent();
+		const appliedCacheBinding = await reconcileCodexComputerUseStartArtifactsOnce({
+			...params,
+			codexHome,
+			assertCurrent,
+			previousCacheBinding: owner.appliedCacheBinding
+		});
+		assertCurrent();
+		owner.appliedCacheBinding = appliedCacheBinding;
+	});
+	const settled = operation.then(() => void 0, () => void 0);
+	owner.tail = settled;
+	try {
+		await operation;
+	} finally {
+		owner.active = Math.max(0, owner.active - 1);
+		if (owner.active === 0 && owner.latestEpoch === void 0 && activeComputerUseArtifactReconciliations.get(key) === owner && owner.tail === settled) activeComputerUseArtifactReconciliations.delete(key);
+		pruneComputerUseArtifactOwners();
+	}
+}
+async function reconcileCodexComputerUseStartArtifactsOnce(params) {
+	const codexHome = params.codexHome;
+	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig });
+	const ownsIsolatedCodexHome = params.ownsIsolatedCodexHome ?? (params.startOptions.homeScope !== "user" && !params.startOptions.env?.[CODEX_HOME_ENV_VAR]?.trim());
+	const shouldProvisionComputerUse = computerUseConfig.enabled && computerUseConfig.autoInstall && ownsIsolatedCodexHome;
+	if (shouldProvisionComputerUse) await ensureOwnedCodexHome(codexHome, params.agentDir);
+	else await fs.mkdir(codexHome, { recursive: true });
+	const desktopCandidates = resolveMacOSDesktopCodexAppPathCandidates();
+	const exactDesktopCandidate = desktopCandidates.find((candidate) => path.resolve(candidate.appServerCommandPath) === path.resolve(params.startOptions.command));
+	const usesManagedBundledMarketplace = !computerUseConfig.marketplaceSource && !computerUseConfig.marketplacePath && !computerUseConfig.marketplaceName;
+	const needsBundledMarketplace = usesManagedBundledMarketplace || computerUseConfig.pluginCacheMode === "shared" && !computerUseConfig.marketplaceName && !computerUseConfig.marketplacePath;
+	const artifactCandidate = shouldProvisionComputerUse ? await resolveCompleteComputerUseArtifactCandidate({
+		candidates: exactDesktopCandidate ? [exactDesktopCandidate] : desktopCandidates,
+		needsBundledMarketplace
+	}) : exactDesktopCandidate;
+	params.assertCurrent();
+	if (shouldProvisionComputerUse) {
+		if (desktopCandidates.length > 0 && !artifactCandidate) throw new CodexComputerUseCandidateArtifactsUnavailableError();
+		try {
+			const marketplacePath = usesManagedBundledMarketplace ? await ensureCodexManagedBundledMarketplace({
+				codexHome,
+				ownershipRoot: params.agentDir,
+				...artifactCandidate ? {
+					appServerCommand: artifactCandidate.appServerCommandPath,
+					candidates: [artifactCandidate],
+					ownershipCandidates: desktopCandidates
+				} : {},
+				assertCurrent: params.assertCurrent
+			}) : void 0;
+			params.assertCurrent();
+			if (usesManagedBundledMarketplace && desktopCandidates.length > 0 && !marketplacePath) throw new CodexComputerUseCandidateArtifactsUnavailableError();
+			const service = await ensureCodexComputerUseServiceApp({
+				codexHome,
+				ownershipRoot: params.agentDir,
+				...artifactCandidate ? {
+					appServerCommand: artifactCandidate.appServerCommandPath,
+					sourceAppCandidates: artifactCandidate.computerUseServiceAppPaths
+				} : {},
+				assertCurrent: params.assertCurrent
+			});
+			params.assertCurrent();
+			if (desktopCandidates.length > 0 && service.status === "source_missing") throw new CodexComputerUseCandidateArtifactsUnavailableError();
+		} catch (error) {
+			params.assertCurrent();
+			if (error instanceof CodexComputerUseCandidateArtifactsUnavailableError) throw error;
+			throw new AgentHarnessPreflightError("Codex Computer Use client provisioning failed.", {
+				cause: error,
+				scope: "harness"
+			});
+		}
+	}
+	params.assertCurrent();
+	const cacheBinding = [
+		params.desktopGeneration?.epoch ?? "manual",
+		artifactCandidate?.bundledMarketplacePath ?? "default",
+		computerUseConfig.pluginName
+	].join("\0");
+	const cache = await ensureCodexComputerUseSharedPluginCache({
+		codexHome,
+		config: computerUseConfig,
+		...ownsIsolatedCodexHome ? { ownershipRoot: params.agentDir } : {},
+		...artifactCandidate ? { bundledMarketplacePath: artifactCandidate.bundledMarketplacePath } : {},
+		assertCurrent: params.assertCurrent,
+		forceRefresh: params.forceCacheRefresh === true || params.previousCacheBinding !== cacheBinding
+	});
+	params.assertCurrent();
+	return cache.status === "shared" ? cacheBinding : void 0;
+}
+async function resolveCompleteComputerUseArtifactCandidate(params) {
+	for (const candidate of params.candidates) {
+		if (params.needsBundledMarketplace && !await resolveCodexManagedBundledMarketplaceSource({ candidates: [candidate] })) continue;
+		if (await resolveCodexComputerUseServiceAppSourcePath({ sourceAppCandidates: candidate.computerUseServiceAppPaths })) return candidate;
+	}
+}
+function pruneComputerUseArtifactOwners() {
+	while (activeComputerUseArtifactReconciliations.size > MAX_COMPUTER_USE_ARTIFACT_OWNERS) {
+		const inactive = [...activeComputerUseArtifactReconciliations].find(([, owner]) => owner.active === 0);
+		if (!inactive) return;
+		activeComputerUseArtifactReconciliations.delete(inactive[0]);
+	}
+}
+var CodexComputerUseCandidateArtifactsUnavailableError = class extends Error {
+	constructor() {
+		super("The selected Codex desktop app does not contain complete Computer Use artifacts.");
+		this.code = "CODEX_COMPUTER_USE_CANDIDATE_ARTIFACTS_UNAVAILABLE";
+		this.name = "CodexComputerUseCandidateArtifactsUnavailableError";
+	}
+};
 function withoutClearedCodexHomeEnv(clearEnv) {
 	if (!clearEnv) return;
 	const reserved = new Set(CODEX_APP_SERVER_HOME_ENV_VARS);
@@ -616,36 +1211,27 @@ function withoutClearedCodexHomeEnv(clearEnv) {
 	return filtered.length === clearEnv.length ? clearEnv : filtered;
 }
 async function applyCodexAppServerAuthProfile(params) {
-	if (params.preparedAuth?.kind === "profile") {
-		await params.client.request("account/login/start", params.preparedAuth.snapshot.loginParams);
-		return;
-	}
-	if (params.preparedAuth?.kind === "api-key") {
-		await params.client.request("account/login/start", {
-			type: "apiKey",
-			apiKey: params.preparedAuth.apiKey
-		});
-		return;
-	}
-	if (params.authProfileId === null) {
+	if (!params.preparedAuth && params.authProfileId === null) {
 		await assertNativeCodexAccountMatchesRoute(params.client, params.authRequirement);
 		return;
 	}
 	let loginParams;
 	try {
-		loginParams = await resolveCodexAppServerAuthProfileLoginParams({
+		loginParams = params.preparedAuth?.kind === "profile" ? params.preparedAuth.snapshot.loginParams : params.preparedAuth?.kind === "api-key" ? {
+			type: "apiKey",
+			apiKey: params.preparedAuth.apiKey
+		} : await resolveCodexAppServerAuthProfileLoginParams({
 			agentDir: params.agentDir,
-			authProfileId: params.authProfileId,
+			authProfileId: params.authProfileId ?? void 0,
 			authProfileStore: params.authProfileStore,
 			config: params.config
 		});
 	} catch (error) {
-		if (params.authRequirement === "subscription" && error instanceof CodexAppServerAuthProfileUnavailableError) throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.", error);
+		if (params.authRequirement === "subscription" && error instanceof CodexAppServerAuthProfileUnavailableError) throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials. Sign in with `openclaw models auth login --provider openai`, select that profile, then retry.", error);
 		throw error;
 	}
-	if (params.authRequirement === "subscription" && loginParams?.type !== "chatgptAuthTokens") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.");
+	if (params.authRequirement === "subscription" && loginParams?.type !== "chatgptAuthTokens") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials. Sign in with `openclaw models auth login --provider openai`, select that profile, then retry.");
 	if (!loginParams) {
-		if (params.authRequirement === "subscription") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.");
 		if (params.authRequirement !== "api-key" || params.startOptions?.transport !== "stdio") return;
 		const env = resolveCodexAppServerSpawnEnv(params.startOptions, process.env);
 		const fallbackLoginParams = await resolveCodexAppServerFallbackApiKeyLoginParams({
@@ -670,7 +1256,7 @@ async function assertNativeCodexAccountMatchesRoute(client, authRequirement) {
 	const response = await client.request("account/read", { refreshToken: false });
 	const accountType = isJsonObject(response.account) ? response.account.type : void 0;
 	if (authRequirement === "subscription") {
-		if (accountType !== "chatgpt") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.");
+		if (accountType !== "chatgpt") throw createCodexAppServerAuthError("Codex subscription route requires ChatGPT auth in the native Codex home. Run `codex login` for that home, or use appServer.homeScope=\"agent\" with an OpenClaw OAuth profile, then retry.");
 		return;
 	}
 	if (accountType === "chatgpt") throw createCodexAppServerAuthError("Codex Platform route requires an API-key account, but the native Codex home is signed in with a ChatGPT subscription. Sign that home in with `codex login --with-api-key`, or set appServer.homeScope=\"agent\" so OpenClaw can inject its own key.");
@@ -679,7 +1265,12 @@ function createCodexAppServerAuthError(message, cause) {
 	const error = cause === void 0 ? new Error(message) : new Error(message, { cause });
 	return Object.assign(error, { status: 401 });
 }
-var CodexAppServerAuthProfileUnavailableError = class extends Error {};
+var CodexAppServerAuthProfileUnavailableError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.status = 401;
+	}
+};
 async function resolveCodexAppServerAuthProfileLoginParams(params) {
 	const store = resolveCodexAppServerAuthProfileStore(params);
 	const profileId = resolveCodexAppServerAuthProfileId({
@@ -688,7 +1279,7 @@ async function resolveCodexAppServerAuthProfileLoginParams(params) {
 		config: params.config
 	});
 	const profile = profileId ? store.profiles[profileId] : void 0;
-	if (profileId && !profile) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" was not found.`);
+	if (profileId && !profile) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" was not found. Select an existing OpenAI profile or sign in again with OpenClaw, then retry.`);
 	if (profileId && profile && !isCodexAppServerAuthProfileCredential(profile)) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" must use the canonical OpenAI auth provider; run "openclaw doctor --fix" to migrate legacy provider IDs.`);
 	return await resolveCodexAppServerAuthProfileLoginParamsInternal({
 		...params,
@@ -696,11 +1287,24 @@ async function resolveCodexAppServerAuthProfileLoginParams(params) {
 	});
 }
 async function refreshCodexAppServerAuthTokens(params) {
+	const previousAccountId = params.previousAccountId?.trim();
+	if (previousAccountId) {
+		const store = resolveCodexAppServerAuthProfileStore(params);
+		const profileId = resolveCodexAppServerAuthProfileId({
+			authProfileId: params.authProfileId,
+			store,
+			config: params.config
+		});
+		const credential = profileId ? store.profiles[profileId] : void 0;
+		const selectedAccountId = credential ? resolveExplicitChatgptAccountId(credential) ?? (credential.type === "oauth" ? resolveOpenAICodexAuthIdentity({ access: credential.access }).accountId : void 0) : void 0;
+		if (selectedAccountId && selectedAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed before Codex token refresh. Retry to start a client for the selected workspace.");
+	}
 	const loginParams = await resolveCodexAppServerAuthProfileLoginParamsInternal({
 		...params,
 		forceOAuthRefresh: true
 	});
-	if (!loginParams || loginParams.type !== "chatgptAuthTokens") throw new Error("Codex app-server ChatGPT token refresh requires an OAuth auth profile.");
+	if (!loginParams || loginParams.type !== "chatgptAuthTokens") throw new Error("Codex app-server ChatGPT token refresh requires an OAuth auth profile. Sign in with `openclaw models auth login --provider openai`, select that profile, then retry.");
+	if (previousAccountId && loginParams.chatgptAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
 	return {
 		accessToken: loginParams.accessToken,
 		chatgptAccountId: loginParams.chatgptAccountId,
@@ -721,7 +1325,7 @@ async function resolveCodexAppServerAuthProfileLoginParamsInternal(params) {
 	});
 	if (!profileId) return;
 	const credential = store.profiles[profileId];
-	if (!credential) throw new Error(`Codex app-server auth profile "${profileId}" was not found.`);
+	if (!credential) throw new Error(`Codex app-server auth profile "${profileId}" was not found. Select an existing OpenAI profile or sign in again with OpenClaw, then retry.`);
 	if (!isCodexAppServerAuthProfileCredential(credential)) throw new Error(`Codex app-server auth profile "${profileId}" must use the canonical OpenAI auth provider; run "openclaw doctor --fix" to migrate legacy provider IDs.`);
 	const loginParams = await resolveLoginParamsForCredential(profileId, credential, {
 		agentDir: params.agentDir,
@@ -730,7 +1334,7 @@ async function resolveCodexAppServerAuthProfileLoginParamsInternal(params) {
 		forceOAuthRefresh: params.forceOAuthRefresh === true,
 		config: params.config
 	});
-	if (!loginParams) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" does not contain usable credentials.`);
+	if (!loginParams) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" does not contain usable credentials. Repair or replace the selected OpenAI credential, then retry.`);
 	return loginParams;
 }
 async function resolveCodexAppServerFallbackApiKeyLoginParams(params) {
@@ -844,7 +1448,7 @@ async function resolveOAuthCredentialForCodexAppServer(profileId, credential, pa
 	});
 	if (params.forceRefresh && !persistedOAuthCredential && overlaidOAuthCredential) {
 		const refreshedRuntimeCredential = await refreshOAuthCredentialForRuntime({ credential: overlaidOAuthCredential });
-		if (!refreshedRuntimeCredential?.access?.trim()) throw new Error(`Codex app-server auth profile "${profileId}" could not refresh.`);
+		if (!refreshedRuntimeCredential?.access?.trim()) throw new Error(`Codex app-server auth profile "${profileId}" could not refresh. Sign in again with OpenClaw, then retry.`);
 		store.profiles[profileId] = refreshedRuntimeCredential;
 		return refreshedRuntimeCredential;
 	}
@@ -872,8 +1476,8 @@ function shouldUseScopedOAuthCredential(params) {
 	return !isDeepStrictEqual(persisted, params.suppliedCredential) && !hasMatchingOAuthIdentity(persisted, params.suppliedCredential);
 }
 function hasMatchingOAuthIdentity(persisted, supplied) {
-	const persistedAccountId = persisted.accountId?.trim();
-	const suppliedAccountId = supplied.accountId?.trim();
+	const persistedAccountId = resolveOpenAICodexAuthIdentity(persisted).accountId?.trim();
+	const suppliedAccountId = resolveOpenAICodexAuthIdentity(supplied).accountId?.trim();
 	if (persistedAccountId && suppliedAccountId) return persistedAccountId === suppliedAccountId;
 	const persistedEmail = persisted.email?.trim().toLowerCase();
 	const suppliedEmail = supplied.email?.trim().toLowerCase();
@@ -890,8 +1494,8 @@ async function resolveScopedOAuthCredential(params) {
 		const credential = current?.type === "oauth" ? current : params.credential;
 		if (!params.forceRefresh && hasUsableOAuthCredential(credential)) return credential;
 		const refreshed = await refreshOAuthCredentialForRuntime({ credential });
-		if (!refreshed?.access?.trim()) throw new Error(`Codex app-server auth profile "${params.profileId}" could not refresh.`);
-		if (!isDeepStrictEqual(params.store.profiles[params.profileId], credential)) throw new Error(`Codex app-server auth profile "${params.profileId}" changed while refreshing.`);
+		if (!refreshed?.access?.trim()) throw new Error(`Codex app-server auth profile "${params.profileId}" could not refresh. Sign in again with OpenClaw, then retry.`);
+		if (!isDeepStrictEqual(params.store.profiles[params.profileId], credential)) throw new Error(`Codex app-server auth profile "${params.profileId}" changed while refreshing. Retry with the newly selected OpenAI profile.`);
 		params.store.profiles[params.profileId] = refreshed;
 		return refreshed;
 	})();
@@ -938,10 +1542,15 @@ function readFirstNonEmptyEnvEntry(env, keys) {
 	}
 }
 function buildChatgptAuthTokensParams(profileId, credential, accessToken) {
+	const storedAccountId = resolveExplicitChatgptAccountId(credential);
+	const tokenAccountId = resolveOpenAICodexAuthIdentity({ access: accessToken }).accountId;
+	if (storedAccountId && tokenAccountId && storedAccountId !== tokenAccountId) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" has a different ChatGPT account ID than its access token. Sign in again before retrying.`);
+	const chatgptAccountId = storedAccountId ?? tokenAccountId;
+	if (!chatgptAccountId) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" is missing its ChatGPT account ID. Sign in again before retrying.`);
 	return {
 		type: "chatgptAuthTokens",
 		accessToken,
-		chatgptAccountId: resolveChatgptAccountId(profileId, credential),
+		chatgptAccountId,
 		chatgptPlanType: resolveChatgptPlanType(credential)
 	};
 }
@@ -1061,12 +1670,46 @@ function readLimitId(snapshot) {
 	return typeof value === "string" && value.trim() ? value.trim() : "codex";
 }
 //#endregion
+//#region extensions/codex/src/app-server/timeout.ts
+/**
+* Thin Codex app-server timeout adapter around OpenClaw's shared security
+* runtime timeout helper.
+*/
+function resolveAbortError(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error("Codex app-server operation aborted", { cause: signal.reason });
+}
+/** Awaits a promise with a Codex-specific timeout error message. */
+async function withTimeout$1(promise, timeoutMs, timeoutMessage, createError) {
+	return await withTimeout(promise, timeoutMs, {
+		message: timeoutMessage,
+		...createError ? { createError } : {}
+	});
+}
+/** Bounds an operation by both its owner lifecycle and one total wall-clock budget. */
+async function withAbortableTimeout(params) {
+	const signal = params.signal;
+	if (signal?.aborted) throw resolveAbortError(signal);
+	let removeAbortListener;
+	const operation = signal ? Promise.race([params.promise, new Promise((_, reject) => {
+		const onAbort = () => reject(resolveAbortError(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+	})]) : params.promise;
+	try {
+		return await withTimeout$1(operation, params.timeoutMs, params.timeoutMessage, params.createTimeoutError);
+	} finally {
+		removeAbortListener?.();
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/client-runtime.ts
 /** Client-scoped Codex auth and account observers. */
 /** Match Codex's native grace window without retaining inactive conversations indefinitely. */
 const CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS = 30 * 6e4;
 /** Native-child parents are active ownership, so only otherwise-idle threads count against this cap. */
 const CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE = 64;
+/** Return a deterministic error before Codex cancels its ten-second external-auth request. */
+const CODEX_EXTERNAL_AUTH_REFRESH_TIMEOUT_MS = 9e3;
 const configuredClients = /* @__PURE__ */ new WeakMap();
 const physicalThreadReleases = /* @__PURE__ */ new WeakMap();
 const claimedThreadReleaseTokens = /* @__PURE__ */ new WeakMap();
@@ -1080,7 +1723,10 @@ function ensureCodexAppServerClientRuntime(client, context) {
 	const existing = configuredClients.get(client);
 	if (existing) {
 		if (existing.closed) return;
-		existing.context = context;
+		existing.context = {
+			...existing.context,
+			config: context.config
+		};
 		return;
 	}
 	const runtime = {
@@ -1105,12 +1751,21 @@ function ensureCodexAppServerClientRuntime(client, context) {
 	client.addRequestHandler(async (request) => {
 		if (request.method !== "account/chatgptAuthTokens/refresh") return;
 		if (runtime.context.authMode === "prepared-api-key") throw new Error("ChatGPT token refresh is unavailable for prepared Codex API-key auth.");
-		return await refreshCodexAppServerAuthTokens({
-			agentDir: runtime.context.agentDir,
-			authProfileId: runtime.context.authProfileId,
-			...runtime.context.authProfileStore ? { authProfileStore: runtime.context.authProfileStore } : {},
-			config: runtime.context.config
-		});
+		const previousAccountId = isJsonObject(request.params) && typeof request.params.previousAccountId === "string" ? request.params.previousAccountId.trim() || void 0 : void 0;
+		try {
+			const tokens = await withTimeout$1(refreshCodexAppServerAuthTokens({
+				agentDir: runtime.context.agentDir,
+				authProfileId: runtime.context.authProfileId,
+				...previousAccountId ? { previousAccountId } : {},
+				...runtime.context.authProfileStore ? { authProfileStore: runtime.context.authProfileStore } : {},
+				config: runtime.context.config
+			}), CODEX_EXTERNAL_AUTH_REFRESH_TIMEOUT_MS, "Codex app-server ChatGPT token refresh timed out before its external-auth deadline. Retry the request; if it persists, sign in again with OpenClaw.");
+			if (previousAccountId && tokens.chatgptAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
+			return { ...tokens };
+		} catch (error) {
+			runtime.context.onAuthRefreshFailure?.();
+			throw error;
+		}
 	});
 	client.addNotificationHandler((notification) => {
 		if (notification.method === "account/rateLimits/updated") {
@@ -1146,10 +1801,11 @@ function scheduleRetainedThreadEviction(client, runtime) {
 	}, Math.max(0, expiresAt - Date.now()));
 	runtime.evictionTimer.unref?.();
 }
-async function releaseRetainedThread(client, runtime, threadId) {
+async function releaseRetainedThread(client, runtime, threadId, assertCurrent) {
 	const pendingRelease = runtime.releasingThreads.get(threadId);
 	if (pendingRelease) {
 		await pendingRelease.completion;
+		assertCurrent?.();
 		return false;
 	}
 	const retained = runtime.retainedThreads.get(threadId);
@@ -1161,7 +1817,10 @@ async function releaseRetainedThread(client, runtime, threadId) {
 	}
 	runtime.retainedThreads.delete(threadId);
 	scheduleRetainedThreadEviction(client, runtime);
-	const transition = { completion: Promise.resolve().then(() => retained.release(threadId)) };
+	const transition = { completion: Promise.resolve().then(() => {
+		assertCurrent?.();
+		return assertCurrent ? retained.release(threadId, assertCurrent) : retained.release(threadId);
+	}) };
 	runtime.releasingThreads.set(threadId, transition);
 	try {
 		await transition.completion;
@@ -1201,15 +1860,15 @@ async function retainCodexAppServerLiveThread(client, threadId, releaseThread, c
 	const pendingRelease = runtime.releasingThreads.get(threadId);
 	if (pendingRelease) {
 		await pendingRelease.completion;
-		if (runtime.closed || claimed !== void 0 && runtime.claimedThreads.get(threadId) !== claimed) return false;
+		return false;
 	}
 	runtime.retainedThreads.delete(threadId);
 	const retained = {
 		configFingerprint,
 		serviceTier,
 		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
-		release: (releaseThread ? physicalThreadReleases.get(releaseThread) ?? releaseThread : void 0) ?? (async (releasedThreadId) => {
-			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3);
+		release: (releaseThread ? physicalThreadReleases.get(releaseThread) ?? releaseThread : void 0) ?? (async (releasedThreadId, assertCurrent) => {
+			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent);
 		})
 	};
 	runtime.retainedThreads.set(threadId, retained);
@@ -1253,8 +1912,8 @@ async function claimCodexAppServerLiveThread(client, threadId) {
 	}
 	return claimCodexAppServerThreadOwnership(client, runtime, threadId, runtime.retainedThreads.get(threadId) ?? {
 		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
-		release: async (releasedThreadId) => {
-			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3);
+		release: async (releasedThreadId, assertCurrent) => {
+			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent);
 		}
 	});
 }
@@ -1263,7 +1922,7 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained)
 	const claimed = Symbol(threadId);
 	runtime.claimedThreads.set(threadId, claimed);
 	scheduleRetainedThreadEviction(client, runtime);
-	const release = async (releasedThreadId) => {
+	const release = async (releasedThreadId, assertCurrent) => {
 		if (releasedThreadId !== threadId || runtime.claimedThreads.get(threadId) !== claimed) return;
 		const pendingRelease = runtime.releasingThreads.get(threadId);
 		if (pendingRelease) {
@@ -1272,7 +1931,8 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained)
 		}
 		const transition = { completion: Promise.resolve().then(async () => {
 			if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) return;
-			await retained.release(releasedThreadId);
+			assertCurrent?.();
+			await (assertCurrent ? retained.release(releasedThreadId, assertCurrent) : retained.release(releasedThreadId));
 		}) };
 		runtime.releasingThreads.set(threadId, transition);
 		try {
@@ -1291,22 +1951,32 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained)
 	};
 }
 /** Distinguish active claimed ownership from an already-evicted idle subscription. */
+function hasCodexAppServerLiveThread(client, threadId) {
+	const runtime = configuredClients.get(client);
+	return runtime !== void 0 && !runtime.closed && (runtime.retainedThreads.has(threadId) || runtime.releasingThreads.has(threadId) || runtime.claimedThreads.has(threadId));
+}
 function isCodexAppServerLiveThreadClaimed(client, threadId) {
 	const runtime = configuredClients.get(client);
 	return runtime !== void 0 && !runtime.closed && runtime.claimedThreads.has(threadId);
 }
-/** Release the exact physical subscription and finish only its observed claim generation. */
-async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs) {
+/** Release the exact physical subscription and finish only its observed ownership generation. */
+async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs, assertCurrent) {
 	const runtime = configuredClients.get(client);
 	const claimed = runtime?.claimedThreads.get(threadId);
+	const retained = runtime?.retainedThreads.get(threadId);
 	let transition = runtime?.releasingThreads.get(threadId);
 	if (transition?.physicalRelease) {
 		await transition.physicalRelease;
+		assertCurrent?.();
 		return;
 	}
 	const physicalRelease = Promise.resolve().then(async () => {
-		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) !== claimed) return;
-		await client.request("thread/unsubscribe", { threadId }, { timeoutMs });
+		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) !== claimed || retained !== void 0 && runtime?.retainedThreads.get(threadId) !== retained) return;
+		assertCurrent?.();
+		await client.request("thread/unsubscribe", { threadId }, {
+			timeoutMs,
+			assertCurrent
+		});
 	});
 	const ownsTransition = runtime !== void 0 && transition === void 0;
 	if (transition) transition.physicalRelease = physicalRelease;
@@ -1319,15 +1989,19 @@ async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs)
 	}
 	try {
 		await physicalRelease;
+		if (retained !== void 0 && runtime?.retainedThreads.get(threadId) === retained) {
+			runtime.retainedThreads.delete(threadId);
+			scheduleRetainedThreadEviction(client, runtime);
+		}
 		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) === claimed) runtime.claimedThreads.delete(threadId);
 	} finally {
 		if (ownsTransition && runtime.releasingThreads.get(threadId) === transition) runtime.releasingThreads.delete(threadId);
 	}
 }
 /** Reset/end owns the exact thread; failed generation retirement must never release its successor. */
-async function releaseCodexAppServerLiveThread(client, threadId) {
+async function releaseCodexAppServerLiveThread(client, threadId, assertCurrent) {
 	const runtime = configuredClients.get(client);
-	return runtime ? await releaseRetainedThread(client, runtime, threadId) : false;
+	return runtime ? await releaseRetainedThread(client, runtime, threadId, assertCurrent) : false;
 }
 /** Native child work pins its parent's subscription even after the foreground parent turn ends. */
 function protectCodexAppServerLiveThread(client, threadId) {
@@ -1345,11 +2019,9 @@ function protectCodexAppServerLiveThread(client, threadId) {
 			runtime.protectedThreads.delete(threadId);
 			const retained = runtime.retainedThreads.get(threadId);
 			if (retained) {
+				retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
 				runtime.retainedThreads.delete(threadId);
-				runtime.retainedThreads.set(threadId, {
-					...retained,
-					expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS
-				});
+				runtime.retainedThreads.set(threadId, retained);
 			}
 		} else runtime.protectedThreads.set(threadId, count - 1);
 		scheduleRetainedThreadEviction(client, runtime);
@@ -1362,6 +2034,462 @@ function protectCodexAppServerLiveThread(client, threadId) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/dynamic-tool-response-state.ts
+/** Retains the host-owned app preview without adding it to Codex's response payload. */
+function withDynamicToolTranscriptDetails(response, details) {
+	if (details === void 0) return response;
+	Object.defineProperty(response, "transcriptDetails", {
+		configurable: true,
+		enumerable: false,
+		value: details
+	});
+	return response;
+}
+function withDynamicToolTerminalResolution(response, terminalResolution) {
+	if (terminalResolution) {
+		Object.defineProperties(response, {
+			terminalResolution: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution
+			},
+			executionStarted: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution.executionStarted
+			},
+			...terminalResolution.executedArguments ? { executedArguments: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution.executedArguments
+			} } : {}
+		});
+		withDynamicToolSideEffectEvidence(response, terminalResolution.sideEffectEvidence);
+	}
+	return response;
+}
+function withDynamicToolExecutionState(response, state) {
+	Object.defineProperties(response, {
+		executedArguments: {
+			configurable: true,
+			enumerable: false,
+			value: state.executedArguments
+		},
+		executionStarted: {
+			configurable: true,
+			enumerable: false,
+			value: state.executionStarted
+		}
+	});
+	return withDynamicToolSideEffectEvidence(response, state.sideEffectEvidence === true);
+}
+function withDynamicToolSideEffectEvidence(response, sideEffectEvidence) {
+	if (!sideEffectEvidence) {
+		delete response.sideEffectEvidence;
+		return response;
+	}
+	Object.defineProperty(response, "sideEffectEvidence", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+	return response;
+}
+function createFailedDynamicToolResponse(message, options) {
+	const response = {
+		contentItems: [{
+			type: "inputText",
+			text: message
+		}],
+		success: false
+	};
+	Object.defineProperties(response, {
+		diagnosticTerminalReason: {
+			configurable: true,
+			enumerable: false,
+			value: options?.terminalReason ?? "failed"
+		},
+		diagnosticTerminalType: {
+			configurable: true,
+			enumerable: false,
+			value: "error"
+		}
+	});
+	if (options?.executionStarted !== void 0) Object.defineProperty(response, "executionStarted", {
+		configurable: true,
+		enumerable: false,
+		value: options.executionStarted
+	});
+	if (options?.executedArguments !== void 0) Object.defineProperty(response, "executedArguments", {
+		configurable: true,
+		enumerable: false,
+		value: options.executedArguments
+	});
+	return withDynamicToolSideEffectEvidence(response, options?.sideEffectEvidence === true);
+}
+//#endregion
+//#region extensions/codex/src/app-server/tool-abort-terminal-reason.ts
+/** Leaf helper shared by native and dynamic tool diagnostics. */
+const CODEX_TIMEOUT_ABORT_REASONS = /* @__PURE__ */ new Set([
+	"codex_startup_timeout",
+	"turn_completion_idle_timeout",
+	"turn_progress_idle_timeout",
+	"turn_terminal_idle_timeout"
+]);
+/** Preserves timeout provenance when an enclosing run aborts an active tool. */
+function resolveCodexToolAbortTerminalReason(signal) {
+	try {
+		const reason = signal.reason;
+		if (typeof reason === "string") {
+			if (CODEX_TIMEOUT_ABORT_REASONS.has(reason)) return "timed_out";
+			return reason === "client_closed" ? "failed" : "cancelled";
+		}
+		if (reason && typeof reason === "object") {
+			const record = reason;
+			if (record.name === "TimeoutError" || record.reason === "timeout") return "timed_out";
+		}
+	} catch {
+		return "cancelled";
+	}
+	return "cancelled";
+}
+//#endregion
+//#region extensions/codex/src/app-server/dynamic-tool-execution.ts
+/**
+* Timeout, terminal-release, and diagnostic helpers for Codex dynamic tool
+* calls.
+*/
+/** Default timeout for Codex dynamic tool calls. */
+const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 9e4;
+/** Hard cap for per-call Codex dynamic tool timeout overrides. */
+const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 6e5;
+const CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS = 3e4;
+const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12e4;
+const CODEX_DYNAMIC_COMPUTER_GATEWAY_TIMEOUT_MS = 3e4;
+const CODEX_DYNAMIC_COMPUTER_COMPLETION_GRACE_MS = 3e4;
+/** Timeout for image-understanding style dynamic tool calls. */
+const CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS = 6e4;
+/** Timeout for message-delivery dynamic tool calls. */
+const CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS = 6e5;
+/** Outer default for collector waits: full swarm budget plus completion grace. */
+const CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS = 63e4;
+const LOG_FIELD_MAX_LENGTH = 160;
+function normalizeLogField(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.replaceAll(String.fromCharCode(27), " ").replaceAll("\r", " ").replaceAll("\n", " ").replaceAll("	", " ").trim();
+	if (!normalized) return;
+	return normalized.length > LOG_FIELD_MAX_LENGTH ? `${truncateUtf16Safe(normalized, LOG_FIELD_MAX_LENGTH - 3)}...` : normalized;
+}
+function readNumericTimeoutMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return Math.max(0, Math.floor(value));
+	if (typeof value === "string") {
+		const parsed = parseStrictNonNegativeInteger(value);
+		if (parsed !== void 0) return Math.max(0, Math.floor(parsed));
+	}
+}
+function formatDynamicToolTimeoutDetails(params) {
+	const tool = normalizeLogField(params.call.tool) ?? "unknown";
+	const baseMeta = {
+		tool: params.call.tool,
+		toolCallId: params.call.callId,
+		threadId: params.call.threadId,
+		turnId: params.call.turnId,
+		timeoutMs: params.timeoutMs,
+		timeoutKind: "codex_dynamic_tool_rpc"
+	};
+	if (tool !== "process" || !isJsonObject(params.call.arguments)) return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms while running tool ${tool}.`,
+		consoleMessage: `codex dynamic tool timeout: tool=${tool} toolTimeoutMs=${params.timeoutMs}; per-tool-call watchdog, not session idle`,
+		meta: baseMeta
+	};
+	const action = normalizeLogField(params.call.arguments.action);
+	const sessionId = normalizeLogField(params.call.arguments.sessionId);
+	const requestedTimeoutMs = readNumericTimeoutMs(params.call.arguments.timeout);
+	const actionPart = action ? ` action=${action}` : "";
+	const sessionPart = sessionId ? ` sessionId=${sessionId}` : "";
+	const requestedPart = requestedTimeoutMs === void 0 ? "" : ` requestedWaitMs=${requestedTimeoutMs}`;
+	const retryHint = action === "poll" ? "; repeated lines usually mean process-poll retry churn, not model progress" : "";
+	const responseTarget = action || sessionId ? ` while waiting for process${actionPart}${sessionPart}` : " while waiting for the process tool";
+	return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms${responseTarget}. This is a tool RPC timeout, not a session idle timeout.`,
+		consoleMessage: `codex process tool timeout:${actionPart}${sessionPart} toolTimeoutMs=${params.timeoutMs}${requestedPart}; per-tool-call watchdog, not session idle${retryHint}`,
+		meta: {
+			...baseMeta,
+			processAction: action,
+			processSessionId: sessionId,
+			processRequestedTimeoutMs: requestedTimeoutMs
+		}
+	};
+}
+/**
+* Runs a dynamic tool call with run-abort and the budget prepared by
+* resolveDynamicToolCallTimeoutMs, preserving tool-specific completion grace.
+*/
+async function handleDynamicToolCallWithTimeout(params) {
+	let didNotifyAgentToolResult = false;
+	const conservativeRaceResponses = /* @__PURE__ */ new WeakSet();
+	const finalizeTerminal = (response) => {
+		const executionSnapshot = params.toolBridge.consumeToolExecutionSnapshot?.(params.call.callId);
+		const ownerKey = params.toolBridge.sideEffectOwnerKeyForTool?.(params.call.tool);
+		const observedExecutionStarted = executionSnapshot?.executionStarted ?? (conservativeRaceResponses.has(response) ? void 0 : response.executionStarted);
+		const terminalResolution = params.observeToolTerminal?.({
+			toolCallId: params.call.callId,
+			toolName: params.call.tool,
+			arguments: response.executedArguments ?? executionSnapshot?.executedArguments ?? params.call.arguments,
+			...params.toolMeta ? { meta: params.toolMeta } : {},
+			...ownerKey ? { ownerMutation: { ownerKey } } : {},
+			...observedExecutionStarted !== void 0 ? { executionStarted: observedExecutionStarted } : {},
+			outcome: response.success ? "success" : "failure",
+			...!response.success ? { failure: { error: readDynamicToolResponseText(response) } } : {}
+		});
+		return withDynamicToolTerminalResolution(response, terminalResolution);
+	};
+	const createFailedAfterPossibleDispatch = (message, terminalReason) => {
+		const response = createFailedDynamicToolResponse(message, {
+			executionStarted: true,
+			sideEffectEvidence: true,
+			terminalReason
+		});
+		conservativeRaceResponses.add(response);
+		return response;
+	};
+	const notifyAgentToolResult = (event) => {
+		if (didNotifyAgentToolResult) return;
+		didNotifyAgentToolResult = true;
+		try {
+			params.onAgentToolResult?.(event);
+		} catch (error) {
+			embeddedAgentLog.warn(`onAgentToolResult handler failed: tool=${params.call.tool} error=${String(error)}`);
+		}
+	};
+	const notifyFailedToolResult = (message, terminalReason = "failed") => {
+		notifyAgentToolResult({
+			toolName: params.call.tool,
+			result: {
+				content: [{
+					type: "text",
+					text: message
+				}],
+				details: {
+					status: terminalReason,
+					error: message
+				}
+			},
+			isError: true
+		});
+	};
+	if (params.signal.aborted) {
+		const message = "OpenClaw dynamic tool call aborted before execution.";
+		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
+		params.onFallbackSelected?.();
+		notifyFailedToolResult(message, terminalReason);
+		return finalizeTerminal(createFailedDynamicToolResponse(message, {
+			executionStarted: false,
+			terminalReason
+		}));
+	}
+	const controller = new AbortController();
+	let timeout;
+	let timedOut = false;
+	let resolveAbort;
+	const abortFromRun = () => {
+		const message = "OpenClaw dynamic tool call aborted.";
+		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
+		params.onFallbackSelected?.();
+		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
+		notifyFailedToolResult(message, terminalReason);
+		resolveAbort?.(createFailedAfterPossibleDispatch(message, terminalReason));
+	};
+	const abortPromise = new Promise((resolve) => {
+		resolveAbort = resolve;
+	});
+	const timeoutPromise = new Promise((resolve) => {
+		const { timeoutMs } = params;
+		timeout = setTimeout(() => {
+			timedOut = true;
+			const timeoutDetails = formatDynamicToolTimeoutDetails({
+				call: params.call,
+				timeoutMs
+			});
+			params.onFallbackSelected?.();
+			controller.abort(new Error(timeoutDetails.responseMessage));
+			params.onTimeout?.();
+			embeddedAgentLog.warn("codex dynamic tool call timed out", {
+				...timeoutDetails.meta,
+				consoleMessage: timeoutDetails.consoleMessage
+			});
+			notifyFailedToolResult(timeoutDetails.responseMessage, "timed_out");
+			resolve(createFailedAfterPossibleDispatch(timeoutDetails.responseMessage, "timed_out"));
+		}, timeoutMs);
+		timeout.unref?.();
+	});
+	try {
+		params.signal.addEventListener("abort", abortFromRun, { once: true });
+		if (params.signal.aborted) abortFromRun();
+		const response = await Promise.race([
+			params.toolBridge.handleToolCall(params.call, {
+				signal: controller.signal,
+				onAgentToolResult: notifyAgentToolResult,
+				toolCallOrdinal: params.toolCallOrdinal,
+				retainExecutionSnapshot: true
+			}),
+			abortPromise,
+			timeoutPromise
+		]);
+		if (!response.success && !didNotifyAgentToolResult) notifyFailedToolResult(readDynamicToolResponseText(response), response.diagnosticTerminalReason ?? "failed");
+		return finalizeTerminal(response);
+	} catch (error) {
+		const terminalReason = params.signal.aborted ? resolveCodexToolAbortTerminalReason(params.signal) : resolveToolExecutionErrorKind(error);
+		const message = formatToolExecutionErrorMessage(error, "OpenClaw dynamic tool call failed.");
+		notifyFailedToolResult(message, terminalReason);
+		return finalizeTerminal(createFailedAfterPossibleDispatch(message, terminalReason));
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		params.signal.removeEventListener("abort", abortFromRun);
+		resolveAbort = void 0;
+		if (!timedOut && !controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("OpenClaw dynamic tool call finished."));
+	}
+}
+function readDynamicToolResponseText(response) {
+	return response.contentItems.flatMap((item) => item.type === "inputText" && typeof item.text === "string" ? [item.text] : []).join("\n").trim() || "OpenClaw dynamic tool call failed.";
+}
+/** Strips OpenClaw-only metadata before sending a dynamic tool response to Codex. */
+function toCodexDynamicToolProtocolResponse(response) {
+	return {
+		contentItems: response.contentItems,
+		success: response.success
+	};
+}
+/** Adds async-started progress details when a tool result continues out of band. */
+function toCodexDynamicToolProgressResponse(response, protocolResponse) {
+	const transcriptDetails = isJsonObject(response.transcriptDetails) ? response.transcriptDetails : void 0;
+	const mcpAppPreview = isJsonObject(transcriptDetails?.mcpAppPreview) ? transcriptDetails.mcpAppPreview : void 0;
+	const progressDetails = mcpAppPreview ? { mcpAppPreview } : void 0;
+	if (response.asyncStarted !== true && progressDetails === void 0) return protocolResponse;
+	return {
+		...protocolResponse,
+		...progressDetails ? { details: progressDetails } : {},
+		...response.asyncStarted === true ? { details: {
+			...progressDetails,
+			async: true,
+			status: "started"
+		} } : {}
+	};
+}
+/** Decides whether a terminal dynamic tool response can release the Codex turn. */
+function shouldReleaseTurnAfterTerminalDynamicTool(state) {
+	return !state.completed && !state.aborted && state.responseSuccess && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && state.activeTurnItemIdsCount === 0 && state.pendingOpenClawDynamicToolCompletionIdsCount === 0;
+}
+/** Returns true when a non-async result should block terminal-release shortcuts. */
+function shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response) {
+	return response.asyncStarted !== true;
+}
+/** Resolves whether terminal diagnostic state should release, wait, or stay idle. */
+function resolveTerminalDynamicToolBatchAction(state) {
+	if (state.activeAppServerTurnRequests > 0 || state.activeTurnItemIdsCount > 0 || state.pendingOpenClawDynamicToolCompletionIdsCount > 0) return "wait";
+	if (state.currentTurnHadNonTerminalDynamicToolResult) return "clear-nonterminal-batch";
+	if (state.hasPendingTerminalDynamicToolRelease) return "release-pending-terminal";
+	return "idle";
+}
+/** Returns true for diagnostic events that terminate a dynamic tool call. */
+function isDynamicToolTerminalDiagnosticEvent(event) {
+	return event.type === "tool.execution.completed" || event.type === "tool.execution.error" || event.type === "tool.execution.blocked";
+}
+/** Matches terminal diagnostics to a specific dynamic tool call id/name. */
+function isMatchingDynamicToolTerminalDiagnostic(params) {
+	if (params.event.toolCallId !== params.call.callId || params.event.toolName !== params.call.tool) return false;
+	if (params.runId !== void 0) return params.event.runId === params.runId;
+	if (params.sessionId !== void 0) return params.event.sessionId === params.sessionId;
+	if (params.sessionKey !== void 0) return params.event.sessionKey === params.sessionKey;
+	return params.event.runId === void 0 && params.event.sessionId === void 0 && params.event.sessionKey === void 0;
+}
+/** Checks pending diagnostics for a terminal event matching a tool call. */
+function hasPendingDynamicToolTerminalDiagnostic(params) {
+	return hasPendingInternalDiagnosticEvent((event) => {
+		if (!isDynamicToolTerminalDiagnosticEvent(event)) return false;
+		return isMatchingDynamicToolTerminalDiagnostic({
+			event,
+			call: params.call,
+			runId: params.runId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey
+		});
+	});
+}
+/** Resolves per-tool timeout, applying media/message defaults and hard caps. */
+function resolveDynamicToolCallTimeoutMs(params) {
+	const args = isJsonObject(params.call.arguments) ? params.call.arguments : void 0;
+	if (params.call.tool === "ask_user" || params.call.tool === "secrets" && args?.action === "request") try {
+		return normalizeQuestionTimeoutSeconds(args?.timeoutSeconds) * 1e3 + CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS;
+	} catch {
+		return CODEX_DYNAMIC_TOOL_TIMEOUT_MS;
+	}
+	if (params.call.tool === "computer") return clampDynamicToolTimeoutMs(readComputerToolTimeoutMs(params.call.arguments));
+	if (params.call.tool === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
+	if (params.call.tool === "agents_wait") {
+		const requestedMs = readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS;
+		return Math.max(1, Math.min(63e4, Math.floor(requestedMs)));
+	}
+	return clampDynamicToolTimeoutMs(readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? CODEX_DYNAMIC_TOOL_TIMEOUT_MS);
+}
+/** Transport guard stays outside the handler's bounded tool wait and completion grace. */
+function resolveDynamicToolServerRequestTimeoutMs(call) {
+	return Math.max(63e4, call ? resolveDynamicToolCallTimeoutMs({
+		call,
+		config: void 0
+	}) : 0) + CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS;
+}
+function readComputerToolTimeoutMs(value) {
+	const args = isJsonObject(value) ? value : void 0;
+	const action = typeof args?.action === "string" ? args.action : void 0;
+	const gatewayTimeoutMs = readPositiveFiniteTimeoutMs(args?.timeoutMs) ?? CODEX_DYNAMIC_COMPUTER_GATEWAY_TIMEOUT_MS;
+	const gatewayCallCount = action === "screenshot" || action === "wait" ? 3 : 4;
+	return (action === "wait" || action === "hold_key" ? Math.max(0, Number(args?.duration) || 0) * 1e3 : 0) + gatewayCallCount * gatewayTimeoutMs + CODEX_DYNAMIC_COMPUTER_COMPLETION_GRACE_MS;
+}
+function readDynamicToolCallTimeoutMs(value) {
+	if (!isJsonObject(value)) return;
+	const timeoutMs = readPositiveFiniteTimeoutMs(value.timeoutMs);
+	if (timeoutMs !== void 0) return timeoutMs;
+	const timeoutSecondsMs = readDynamicToolTimeoutSecondsAsMs(value.timeoutSeconds);
+	return timeoutSecondsMs === void 0 ? void 0 : addTimerTimeoutGraceMs(timeoutSecondsMs, CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS);
+}
+function readConfiguredDynamicToolTimeoutMs(toolName, config) {
+	if (toolName === "image_generate") {
+		const imageModel = config?.agents?.defaults?.mediaModels?.image;
+		if (!imageModel || typeof imageModel !== "object") return CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+		return readPositiveFiniteTimeoutMs(imageModel.timeoutMs) ?? CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+	}
+	if (toolName === "view_image") {
+		const candidates = (config?.tools?.media?.models ?? []).filter((entry) => !entry.capabilities || entry.capabilities.includes("image"));
+		const capabilityTimeoutMs = readTimeoutSecondsAsMs(config?.tools?.media?.image?.timeoutSeconds);
+		return Math.max(capabilityTimeoutMs ?? CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS, ...candidates.map((entry) => readTimeoutSecondsAsMs(entry.timeoutSeconds) ?? capabilityTimeoutMs ?? CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS));
+	}
+	if (toolName === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
+}
+function readTimeoutSecondsAsMs(value) {
+	const seconds = readPositiveFiniteTimeoutMs(value);
+	return seconds === void 0 ? void 0 : seconds * 1e3;
+}
+function readDynamicToolTimeoutSecondsAsMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) return;
+	return value * 1e3;
+}
+function readPositiveFiniteTimeoutMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function clampDynamicToolTimeoutMs(timeoutMs) {
+	return Math.max(1, Math.min(CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS, Math.floor(timeoutMs)));
+}
+//#endregion
+//#region extensions/codex/src/app-server/elicitation-response.ts
+function createCodexElicitationResponse(action, content = null, meta = null) {
+	return {
+		action,
+		content,
+		_meta: meta
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/rpc-error.ts
 /** RPC error wrapper that preserves app-server error code and data. */
 var CodexAppServerRpcError = class extends Error {
@@ -1558,71 +2686,6 @@ function websocketFrameToText(data) {
 	return Buffer.from(data).toString("utf8");
 }
 //#endregion
-//#region extensions/codex/src/app-server/transport.ts
-/** Starts graceful transport shutdown and schedules a force kill fallback. */
-function closeCodexAppServerTransport(child, options = {}) {
-	child.stdin.end?.();
-	child.stdin.destroy?.();
-	const forceKillDelayMs = options.forceKillDelayMs ?? 1e3;
-	const forceKill = setTimeout(() => {
-		if (hasCodexAppServerTransportExited(child)) return;
-		signalCodexAppServerTransport(child, "SIGKILL");
-	}, Math.max(1, forceKillDelayMs));
-	forceKill.unref?.();
-	child.once("exit", () => {
-		clearTimeout(forceKill);
-		child.stdout.destroy?.();
-		child.stderr.destroy?.();
-	});
-	child.unref?.();
-	child.stdout.unref?.();
-	child.stderr.unref?.();
-	child.stdin.unref?.();
-}
-/** Closes a transport and waits briefly for an exit event. */
-async function closeCodexAppServerTransportAndWait(child, options = {}) {
-	if (!hasCodexAppServerTransportExited(child)) closeCodexAppServerTransport(child, options);
-	return await waitForCodexAppServerTransportExit(child, options.exitTimeoutMs ?? 2e3);
-}
-function hasCodexAppServerTransportExited(child) {
-	return child.exitCode !== null && child.exitCode !== void 0 ? true : child.signalCode !== null && child.signalCode !== void 0;
-}
-async function waitForCodexAppServerTransportExit(child, timeoutMs) {
-	if (hasCodexAppServerTransportExited(child)) return true;
-	return await new Promise((resolve) => {
-		let settled = false;
-		const onExit = () => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeout);
-			resolve(true);
-		};
-		const timeout = setTimeout(() => {
-			if (settled) return;
-			settled = true;
-			child.off?.("exit", onExit);
-			resolve(false);
-		}, Math.max(1, timeoutMs));
-		child.once("exit", onExit);
-	});
-}
-function signalCodexAppServerTransport(child, signal) {
-	if (child.pid && process.platform !== "win32") try {
-		process.kill(-child.pid, signal);
-		return;
-	} catch {}
-	child.kill?.(signal);
-}
-//#endregion
-//#region extensions/codex/src/app-server/version.ts
-/**
-* Version and package pins for the managed Codex app-server runtime.
-*/
-/** Exact Codex app-server version shipped and supported by the OpenClaw Codex bridge. */
-const CODEX_APP_SERVER_VERSION = "0.147.0";
-/** npm package name for the managed Codex app-server binary. */
-const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
-//#endregion
 //#region extensions/codex/src/app-server/client.ts
 /**
 * JSON-RPC client for Codex app-server transports, including request/response
@@ -1631,11 +2694,11 @@ const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
 const CODEX_APP_SERVER_PARSE_LOG_MAX = 500;
 const CODEX_APP_SERVER_PARSE_BUFFER_MAX = 8 * 1024 * 1024;
 const CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES = 1e3;
-const CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS = 66e4;
 const CODEX_APP_SERVER_STDERR_TAIL_MAX = 2e3;
 const CODEX_APP_SERVER_OVERLOADED_ERROR_CODE = -32001;
 const CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES = 3;
 const CODEX_APP_SERVER_OVERLOAD_RETRY_BASE_MS = 50;
+const CODEX_APP_SERVER_PENDING_STARTUP_WARNINGS_MAX = 32;
 const CODEX_APP_SERVER_CLIENT_INSTANCE_IDS = /* @__PURE__ */ new WeakMap();
 const UNPAIRED_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
 /** Process-local generation fence for bindings tied to one app-server client instance. */
@@ -1649,6 +2712,10 @@ function getCodexAppServerClientInstanceId(client) {
 function resolveCodexAppServerClientInstanceId(client) {
 	return client.getInstanceId?.call(client) ?? getCodexAppServerClientInstanceId(client);
 }
+/** Codex rejects this exact code before enqueueing, including mutating requests. */
+function isCodexAppServerOverloadError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === CODEX_APP_SERVER_OVERLOADED_ERROR_CODE;
+}
 var CodexAppServerLocalRequestCancellationError = class extends Error {
 	constructor(method, reason, mayHaveWritten) {
 		super(`${method} ${reason}`);
@@ -1704,9 +2771,11 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.pending = /* @__PURE__ */ new Map();
 		this.requestHandlers = /* @__PURE__ */ new Set();
 		this.notificationHandlers = /* @__PURE__ */ new Set();
+		this.pendingStartupWarnings = [];
 		this.closeHandlers = /* @__PURE__ */ new Set();
 		this.nextId = 1;
 		this.initialized = false;
+		this.modelCatalogRevision = 0;
 		this.closed = false;
 		this.transportExited = false;
 		this.stderrTail = "";
@@ -1732,7 +2801,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		child.stdin.on?.("error", (error) => this.closeWithError(toStringifiedError(error)));
 	}
 	/** Starts a new app-server client using resolved runtime start options. */
-	static start(options) {
+	static async start(options, assertCurrent) {
 		const defaults = resolveCodexAppServerRuntimeOptions().start;
 		const startOptions = {
 			...defaults,
@@ -1741,7 +2810,18 @@ var CodexAppServerClient = class CodexAppServerClient {
 		};
 		if (startOptions.transport === "stdio" && startOptions.commandSource === "managed") throw new Error("Managed Codex app-server start options must be resolved before spawn.");
 		if (startOptions.transport === "websocket" || startOptions.transport === "unix") return new CodexAppServerClient(createWebSocketTransport(startOptions));
-		return new CodexAppServerClient(createStdioTransport(startOptions));
+		let client;
+		try {
+			await createStdioTransport(startOptions, process.env, assertCurrent, (child) => {
+				client = new CodexAppServerClient(child);
+			});
+			return client;
+		} catch (error) {
+			assertCurrent?.();
+			if (client?.transportExited && hasCodexAppServerNaturalExit(client.child)) throw buildCodexAppServerExitError(client.child.exitCode, client.child.signalCode, client.stderrTail);
+			const stderr = client?.getStderrDiagnostic();
+			throw stderr ? new Error(`${coerceErrorMessage(error)}; stderr=${JSON.stringify(stderr)}`, { cause: error }) : error;
+		}
 	}
 	/** Builds a client around a fake transport for tests. */
 	static fromTransportForTests(child) {
@@ -1756,7 +2836,14 @@ var CodexAppServerClient = class CodexAppServerClient {
 				title: "OpenClaw",
 				version: OPENCLAW_VERSION
 			},
-			capabilities: { experimentalApi: true }
+			capabilities: {
+				experimentalApi: true,
+				extensions: {
+					"openai/standard-form-input": {},
+					"openai/form": {},
+					"io.modelcontextprotocol/ui": { mimeTypes: ["text/html;profile=mcp-app"] }
+				}
+			}
 		});
 		this.serverVersion = assertSupportedCodexAppServerVersion(response);
 		this.runtimeIdentity = buildCodexAppServerRuntimeIdentity(response, this.serverVersion);
@@ -1783,6 +2870,10 @@ var CodexAppServerClient = class CodexAppServerClient {
 	getInstanceId() {
 		return this.instanceId;
 	}
+	/** Account/config observations become stale before a mutation can enter the wire. */
+	getModelCatalogRevision() {
+		return this.modelCatalogRevision;
+	}
 	/** Installs the spawn-owner check run before config-loading thread requests. */
 	setThreadSessionRequestGuard(guard) {
 		this.threadSessionRequestGuard = guard;
@@ -1792,8 +2883,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		return this.child.pid;
 	}
 	request(method, params, optionsInput) {
-		let options = optionsInput;
-		options ??= {};
+		const options = optionsInput ?? {};
 		if (this.closed) return Promise.reject(this.closeError ?? /* @__PURE__ */ new Error("codex app-server client is closed"));
 		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false));
 		const guard = method === "thread/start" || method === "thread/resume" || method === "thread/fork" ? this.threadSessionRequestGuard : void 0;
@@ -1828,11 +2918,11 @@ var CodexAppServerClient = class CodexAppServerClient {
 					const elapsedMs = Date.now() - guardStartedAt;
 					const remainingTimeoutMs = options.timeoutMs === void 0 ? void 0 : options.timeoutMs - elapsedMs;
 					if (remainingTimeoutMs !== void 0 && remainingTimeoutMs <= 0) throw new CodexAppServerLocalRequestCancellationError(method, "timed out", false);
-					return await this.requestWithoutThreadSessionGuard(method, params, {
+					return await this.requestWithOverloadRetry(method, params, {
 						...options,
 						...remainingTimeoutMs !== void 0 ? { timeoutMs: remainingTimeoutMs } : {}
-					}, () => {
-						requestMayHaveWritten = true;
+					}, (mayHaveWritten) => {
+						requestMayHaveWritten = mayHaveWritten;
 					});
 				} catch (error) {
 					if (requestMayHaveWritten && !(error instanceof CodexAppServerRpcError)) {
@@ -1845,12 +2935,9 @@ var CodexAppServerClient = class CodexAppServerClient {
 				}
 			})();
 		}
-		return this.requestWithoutThreadSessionGuard(method, params, options);
-	}
-	requestWithoutThreadSessionGuard(method, params, options, onWriteAttempt) {
-		return this.requestWithOverloadRetry(method, params, options, onWriteAttempt);
+		return this.requestWithOverloadRetry(method, params, options);
 	}
-	async requestWithOverloadRetry(method, params, options, onWriteAttempt) {
+	async requestWithOverloadRetry(method, params, options, onWriteStateChange) {
 		const deadline = options.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) ? Date.now() + options.timeoutMs : void 0;
 		for (let retry = 0;; retry += 1) {
 			if (options.signal?.aborted) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false);
@@ -1860,9 +2947,10 @@ var CodexAppServerClient = class CodexAppServerClient {
 				return await this.requestOnce(method, params, {
 					...options,
 					...remainingTimeoutMs !== void 0 ? { timeoutMs: remainingTimeoutMs } : {}
-				}, onWriteAttempt);
+				}, onWriteStateChange);
 			} catch (error) {
-				if (!(error instanceof CodexAppServerRpcError) || error.code !== CODEX_APP_SERVER_OVERLOADED_ERROR_CODE || retry >= CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES) throw error;
+				if (!isCodexAppServerOverloadError(error) || retry >= CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES) throw error;
+				onWriteStateChange?.(false);
 				const backoffMs = Math.round(CODEX_APP_SERVER_OVERLOAD_RETRY_BASE_MS * 2 ** retry * (.75 + Math.random() * .5));
 				await this.waitForOverloadRetry(method, backoffMs, deadline, options.signal);
 			}
@@ -1891,10 +2979,11 @@ var CodexAppServerClient = class CodexAppServerClient {
 			if (signal?.aborted) abortListener();
 		});
 	}
-	requestOnce(method, params, options, onWriteAttempt) {
+	requestOnce(method, params, options, onWriteStateChange) {
 		if (this.closed) return Promise.reject(this.closeError ?? /* @__PURE__ */ new Error("codex app-server client is closed"));
 		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false));
 		const id = this.nextId++;
+		if (method === "account/login/start" || method === "account/logout" || method === "config/value/write" || method === "config/batchWrite") this.modelCatalogRevision += 1;
 		const message = {
 			id,
 			method,
@@ -1944,8 +3033,9 @@ var CodexAppServerClient = class CodexAppServerClient {
 				return;
 			}
 			try {
+				options.assertCurrent?.();
 				mayHaveWritten = true;
-				onWriteAttempt?.();
+				onWriteStateChange?.(true);
 				this.writeMessage(message, (error) => rejectPending(error));
 			} catch (error) {
 				rejectPending(toStringifiedError(error));
@@ -1967,6 +3057,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 	/** Registers a notification handler and returns its disposer. */
 	addNotificationHandler(handler) {
 		this.notificationHandlers.add(handler);
+		for (const notification of this.pendingStartupWarnings.splice(0)) this.handleNotification(notification);
 		return () => this.notificationHandlers.delete(handler);
 	}
 	/** Registers a close handler and returns its disposer. */
@@ -1974,6 +3065,16 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.closeHandlers.add(handler);
 		return () => this.closeHandlers.delete(handler);
 	}
+	/** Registers a handler for physical transport exit and returns its disposer. */
+	addTransportExitHandler(handler) {
+		if (this.transportExited) {
+			handler(this);
+			return () => void 0;
+		}
+		const onExit = () => handler(this);
+		this.child.once("exit", onExit);
+		return () => this.child.off?.("exit", onExit);
+	}
 	/** Closes the transport without waiting for process/socket shutdown. */
 	close() {
 		if (!this.markClosed(/* @__PURE__ */ new Error("codex app-server client is closed"))) return;
@@ -2136,8 +3237,9 @@ var CodexAppServerClient = class CodexAppServerClient {
 	}
 	async runServerRequestHandlers(request) {
 		const controller = new AbortController();
-		const timeoutResponse = timeoutServerRequestResponse(request);
-		if (!timeoutResponse) return await this.runServerRequestHandlersWithoutTimeout(request, controller.signal);
+		if (request.method !== "item/tool/call") return await this.runServerRequestHandlersWithoutTimeout(request, controller.signal);
+		const timeoutMs = resolveDynamicToolServerRequestTimeoutMs(readCodexDynamicToolCallParams(request.params));
+		const timeoutResponse = timeoutServerRequestResponse(timeoutMs);
 		let timeout;
 		try {
 			return await Promise.race([this.runServerRequestHandlersWithoutTimeout(request, controller.signal), new Promise((resolve) => {
@@ -2145,11 +3247,11 @@ var CodexAppServerClient = class CodexAppServerClient {
 					embeddedAgentLog.warn("codex app-server server request timed out", {
 						id: request.id,
 						method: request.method,
-						timeoutMs: CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS
+						timeoutMs
 					});
 					controller.abort(/* @__PURE__ */ new Error("codex app-server server request timed out"));
 					resolve(timeoutResponse);
-				}, CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS);
+				}, timeoutMs);
 				timeout.unref?.();
 			})]);
 		} finally {
@@ -2164,6 +3266,12 @@ var CodexAppServerClient = class CodexAppServerClient {
 		}
 	}
 	handleNotification(notification) {
+		if (notification.method === "account/updated") this.modelCatalogRevision += 1;
+		if (this.notificationHandlers.size === 0 && notification.method === "configWarning") {
+			if (this.pendingStartupWarnings.length === CODEX_APP_SERVER_PENDING_STARTUP_WARNINGS_MAX) this.pendingStartupWarnings.shift();
+			this.pendingStartupWarnings.push(notification);
+			return;
+		}
 		for (const handler of this.notificationHandlers) try {
 			Promise.resolve(handler(notification)).catch((error) => {
 				embeddedAgentLog.warn("codex app-server notification handler failed", { error });
@@ -2206,18 +3314,17 @@ function defaultServerRequestResponse(request) {
 		scope: "turn"
 	};
 	if (request.method === "item/tool/requestUserInput") return { answers: {} };
-	if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
+	if (request.method === "mcpServer/elicitation/request") return createCodexElicitationResponse("decline", null, { message: "OpenClaw has no interactive handler for this elicitation." });
 	return {};
 }
 function stringifyCodexAppServerMessage(message) {
 	return JSON.stringify(message, (_key, value) => typeof value === "string" ? value.replace(UNPAIRED_SURROGATE_RE, "") : value) ?? "null";
 }
-function timeoutServerRequestResponse(request) {
-	if (request.method !== "item/tool/call") return;
+function timeoutServerRequestResponse(timeoutMs) {
 	return {
 		contentItems: [{
 			type: "inputText",
-			text: `OpenClaw dynamic tool call timed out after ${CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS}ms before sending a response to Codex.`
+			text: `OpenClaw dynamic tool call timed out after ${timeoutMs}ms before sending a response to Codex.`
 		}],
 		success: false
 	};
@@ -2226,14 +3333,20 @@ function timeoutServerRequestResponse(request) {
 var CodexAppServerVersionError = class extends Error {
 	constructor(detectedVersion) {
 		const detected = detectedVersion ? `detected ${detectedVersion}` : "OpenClaw could not determine the running Codex version";
-		super(`Codex app-server ${CODEX_APP_SERVER_VERSION} is required, but ${detected}. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
+		super(`Codex app-server ${MIN_SUPPORTED_CODEX_APP_SERVER_VERSION} or newer is required, but ${detected}. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
 		this.name = "CodexAppServerVersionError";
 		this.detectedVersion = detectedVersion;
 	}
 };
 function assertSupportedCodexAppServerVersion(response) {
 	const detectedVersion = readCodexVersionFromUserAgent(response.userAgent);
-	if (detectedVersion !== "0.147.0") throw new CodexAppServerVersionError(detectedVersion);
+	if (!detectedVersion) throw new CodexAppServerVersionError(detectedVersion);
+	const detected = parse(detectedVersion);
+	if (!detected || detected.compare("0.149.0") < 0) throw new CodexAppServerVersionError(detectedVersion);
+	if (detected.compare("0.151.0") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
+		detectedVersion,
+		validatedVersion: CODEX_APP_SERVER_VERSION
+	});
 	return detectedVersion;
 }
 function isUnsupportedCodexAppServerVersionError(error) {
@@ -2316,6 +3429,8 @@ const CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 5 * 6e4;
 const CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS = 5 * 6e4;
 /** Long terminal idle watch for app-server turns that never send completion. */
 const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
+const TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS = 2 * 6e4;
+const TURN_FINALIZE_DRAIN_ABORT_GRACE_MS = 5e3;
 var CodexAppServerStartupError = class extends Error {
 	constructor(reason, message = reason === "timed_out" ? "codex app-server startup timed out" : "codex app-server startup aborted") {
 		super(message);
@@ -2397,204 +3512,322 @@ function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
 	return addTimerTimeoutGraceMs(timeout, resolveTimerTimeoutMs(graceMs, 0, 0)) ?? timeout;
 }
 //#endregion
-//#region extensions/codex/src/app-server/managed-binary.ts
-/**
-* Resolves the managed Codex app-server binary shipped with or installed beside
-* the Codex plugin before stdio startup.
-*/
-const CODEX_PLUGIN_ROOT = resolveDefaultCodexPluginRoot(path.dirname(fileURLToPath(import.meta.url)));
-const MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS = ["/Applications/ChatGPT.app/Contents/Resources/codex", "/Applications/Codex.app/Contents/Resources/codex"];
-/** Rewrites managed stdio start options to point at an executable Codex binary path. */
-async function resolveManagedCodexAppServerStartOptions(startOptions, options = {}) {
-	if (startOptions.transport !== "stdio" || startOptions.commandSource !== "managed") return startOptions;
-	const platform = options.platform ?? process.platform;
-	const paths = resolveManagedCodexAppServerPaths({
-		platform,
-		pluginRoot: options.pluginRoot,
-		managedCommandOrder: startOptions.managedCommandOrder
-	});
-	const pathExists = options.pathExists ?? commandPathExists;
-	const commandPaths = await findManagedCodexAppServerCommandPaths({
-		candidateCommandPaths: paths.candidateCommandPaths,
-		pathExists,
-		platform
-	});
-	const commandPath = expectDefined(commandPaths[0], "resolved managed Codex command path");
-	const managedFallbackCommandPaths = commandPaths.slice(1);
-	return {
-		...startOptions,
-		command: commandPath,
-		commandSource: "resolved-managed",
-		...managedFallbackCommandPaths.length > 0 ? { managedFallbackCommandPaths } : {}
-	};
-}
-/** Resolves the native artifact behind a successful managed launcher selection. */
-function resolveManagedCodexNativeCommand(command, options = {}) {
-	const platform = options.platform ?? process.platform;
-	if (platform === "darwin" && MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS.some((candidate) => candidate === command)) return command;
-	const target = resolveCodexNativeTarget(platform, options.arch ?? process.arch);
-	if (!target) return;
-	const packageRoot = resolveManagedCodexPackageRootForCommand(command, platform);
-	if (!packageRoot) return;
-	const resolvePackageJson = options.resolvePackageJson ?? resolvePackageJsonFromRoot;
-	const pathExists = options.pathExists ?? existsSync;
-	for (const packageName of [target.packageName, MANAGED_CODEX_APP_SERVER_PACKAGE]) {
-		const packageJsonPath = resolvePackageJson(packageName, packageRoot);
-		if (!packageJsonPath) continue;
-		const candidate = path.join(path.dirname(packageJsonPath), "vendor", target.triple, "bin", platform === "win32" ? "codex.exe" : "codex");
-		if (pathExists(candidate)) return candidate;
-	}
-}
-function resolveManagedCodexPackageRootForCommand(command, platform) {
-	const pathApi = pathForPlatform(platform);
-	const commandPaths = [command];
+//#region extensions/codex/src/app-server/desktop-generation-fingerprint.ts
+const MAX_COMPUTER_USE_PLUGIN_TREE_ENTRIES = 4096;
+/** Fingerprints every desktop candidate that can own a managed fallback artifact. */
+async function readMacOSDesktopGenerationFingerprint(candidates = resolveMacOSDesktopCodexAppPathCandidates("darwin")) {
+	const entries = [];
+	for (const candidate of candidates) {
+		const command = await statFingerprint(candidate.appServerCommandPath);
+		entries.push(`candidate:${candidate.appName}:${candidate.appServerCommandPath}:${command}`);
+		for (const artifactPath of resolveMacOSDesktopGenerationPaths(candidate)) entries.push(`${artifactPath}\0${await statFingerprint(artifactPath)}`);
+		const pluginRoot = resolveComputerUsePluginRoot(candidate);
+		entries.push(`${pluginRoot}\0${await directoryTreeFingerprint(pluginRoot)}`);
+	}
+	return createHash("sha256").update(entries.join("\0")).digest("hex");
+}
+function resolveMacOSDesktopGenerationPaths(candidate) {
+	return [
+		candidate.appBundlePath,
+		path.join(candidate.bundledMarketplacePath, ".agents", "plugins", "marketplace.json"),
+		...candidate.computerUseServiceAppPaths.flatMap((servicePath) => [
+			servicePath,
+			path.join(servicePath, "Contents", "Info.plist"),
+			path.join(servicePath, "Contents", "SharedSupport", "SkyComputerUseClient.app", "Contents", "MacOS", "SkyComputerUseClient")
+		])
+	];
+}
+function resolveComputerUsePluginRoot(candidate) {
+	return path.join(candidate.bundledMarketplacePath, "plugins", "computer-use");
+}
+/** Stable roots that cover bundle replacement and recursive artifact updates. */
+function resolveMacOSDesktopGenerationWatchPaths(candidates = resolveMacOSDesktopCodexAppPathCandidates("darwin")) {
+	const watched = /* @__PURE__ */ new Set(["/Applications"]);
+	for (const candidate of candidates) watched.add(candidate.appBundlePath);
+	return [...watched];
+}
+async function directoryTreeFingerprint(root) {
+	let rootStat;
 	try {
-		commandPaths.unshift(realpathSync(command));
-	} catch {}
-	for (const commandPath of commandPaths) {
-		let current = pathApi.dirname(commandPath);
-		while (true) {
-			if (pathApi.basename(current) === "codex" && pathApi.basename(pathApi.dirname(current)) === "@openai") return current;
-			if (pathApi.basename(current) === ".bin") return pathApi.join(pathApi.dirname(current), "@openai", "codex");
-			const parent = pathApi.dirname(current);
-			if (parent === current) break;
-			current = parent;
+		rootStat = await fs.lstat(root, { bigint: true });
+	} catch (error) {
+		if (isNodeError(error, "ENOENT") || isNodeError(error, "ENOTDIR")) return "missing";
+		throw error;
+	}
+	if (!rootStat.isDirectory()) return statFingerprint(root);
+	let entryCount = 0;
+	const hash = createHash("sha256");
+	hash.update("openclaw-codex-computer-use-plugin-tree-v1\0");
+	const visit = async (directory, relativeDirectory, before) => {
+		hash.update(`directory\0${relativeDirectory}\0${statTuple(before)}\0`);
+		const entries = (await fs.readdir(directory, { withFileTypes: true })).toSorted((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+		for (const entry of entries) {
+			entryCount += 1;
+			if (entryCount > MAX_COMPUTER_USE_PLUGIN_TREE_ENTRIES) throw new Error("Codex Computer Use plugin exceeds the bounded tree size");
+			const entryPath = path.join(directory, entry.name);
+			const relativePath = path.join(relativeDirectory, entry.name);
+			const entryStat = await fs.lstat(entryPath, { bigint: true });
+			if (entryStat.isDirectory()) await visit(entryPath, relativePath, entryStat);
+			else hash.update(`entry\0${relativePath}\0${await statFingerprint(entryPath)}\0`);
 		}
+		if (!sameStat(before, await fs.lstat(directory, { bigint: true }))) throw new Error(`Codex desktop artifact changed while fingerprinting: ${directory}`);
+	};
+	await visit(root, ".", rootStat);
+	return hash.digest("hex");
+}
+async function statFingerprint(filePath) {
+	try {
+		const entry = await fs.lstat(filePath, { bigint: true });
+		const type = entry.isSymbolicLink() ? "link" : entry.isDirectory() ? "directory" : entry.isFile() ? "file" : "other";
+		const own = statTuple(entry);
+		if (!entry.isSymbolicLink()) return `${type}:${own}:${entry.isFile() ? await readFileFingerprint(filePath, entry, false) : ""}`;
+		const [link, realPath, target] = await Promise.all([
+			fs.readlink(filePath),
+			fs.realpath(filePath),
+			fs.stat(filePath, { bigint: true })
+		]);
+		const content = target.isFile() ? await readFileFingerprint(filePath, target, true) : "";
+		return `${type}:${own}:${link}:${realPath}:${statTuple(target)}:${content}`;
+	} catch (error) {
+		if (isNodeError(error, "ENOENT") || isNodeError(error, "ENOTDIR")) return "missing";
+		throw error;
 	}
 }
-function resolveCodexNativeTarget(platform, arch) {
-	if ((platform === "linux" || platform === "android") && arch === "x64") return {
-		packageName: "@openai/codex-linux-x64",
-		triple: "x86_64-unknown-linux-musl"
-	};
-	if ((platform === "linux" || platform === "android") && arch === "arm64") return {
-		packageName: "@openai/codex-linux-arm64",
-		triple: "aarch64-unknown-linux-musl"
-	};
-	if (platform === "darwin" && arch === "x64") return {
-		packageName: "@openai/codex-darwin-x64",
-		triple: "x86_64-apple-darwin"
-	};
-	if (platform === "darwin" && arch === "arm64") return {
-		packageName: "@openai/codex-darwin-arm64",
-		triple: "aarch64-apple-darwin"
+async function readFileFingerprint(filePath, expected, followsSymlink) {
+	const noFollow = followsSymlink ? 0 : constants.O_NOFOLLOW ?? 0;
+	const handle = await fs.open(filePath, constants.O_RDONLY | noFollow);
+	try {
+		const before = await handle.stat({ bigint: true });
+		if (!sameStat(before, expected)) throw new Error(`Codex desktop artifact changed while fingerprinting: ${filePath}`);
+		const hash = createHash("sha256");
+		for await (const chunk of handle.createReadStream({ autoClose: false })) hash.update(chunk);
+		if (!sameStat(before, await handle.stat({ bigint: true }))) throw new Error(`Codex desktop artifact changed while fingerprinting: ${filePath}`);
+		return hash.digest("hex");
+	} finally {
+		await handle.close();
+	}
+}
+function sameStat(left, right) {
+	return statTuple(left) === statTuple(right);
+}
+function statTuple(stat) {
+	return [
+		stat.dev,
+		stat.ino,
+		stat.mode,
+		stat.size,
+		stat.mtimeNs,
+		stat.ctimeNs
+	].join(":");
+}
+function isNodeError(error, code) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+//#endregion
+//#region extensions/codex/src/app-server/desktop-generation-owner.ts
+const SETTLE_DELAY_MS = 1e3;
+/** Coalesces filesystem invalidations into one stable desktop generation. */
+function createCodexDesktopGenerationOwner(params) {
+	let generation = params.initialGeneration;
+	let invalidation = 0;
+	let dirty = false;
+	let refresh;
+	let stopped = false;
+	const markDirty = () => {
+		invalidation += 1;
+		dirty = true;
 	};
-	if (platform === "win32" && arch === "x64") return {
-		packageName: "@openai/codex-win32-x64",
-		triple: "x86_64-pc-windows-msvc"
+	const reconcile = () => {
+		if (refresh) return refresh;
+		refresh = (async () => {
+			for (;;) {
+				if (stopped) throw new Error("Codex desktop generation owner stopped");
+				const observedInvalidation = invalidation;
+				const first = await params.readFingerprint();
+				await delay(SETTLE_DELAY_MS);
+				if (stopped) throw new Error("Codex desktop generation owner stopped");
+				const second = await params.readFingerprint();
+				if (stopped) throw new Error("Codex desktop generation owner stopped");
+				if (observedInvalidation !== invalidation || first !== second) continue;
+				const previous = generation;
+				generation = previous?.fingerprint === second ? previous : {
+					epoch: (previous?.epoch ?? 0) + 1,
+					fingerprint: second
+				};
+				dirty = false;
+				if (previous && generation !== previous) params.onGenerationChange?.(generation);
+				return generation;
+			}
+		})().finally(() => {
+			refresh = void 0;
+		});
+		return refresh;
 	};
-	if (platform === "win32" && arch === "arm64") return {
-		packageName: "@openai/codex-win32-arm64",
-		triple: "aarch64-pc-windows-msvc"
+	return {
+		read: () => generation,
+		markDirty,
+		wait: () => dirty ? reconcile() : Promise.resolve(generation),
+		refresh: () => {
+			markDirty();
+			return reconcile();
+		},
+		isCurrent: (candidate) => Boolean(candidate && !dirty && generation && candidate.epoch === generation.epoch && candidate.fingerprint === generation.fingerprint),
+		stop: () => {
+			stopped = true;
+		}
 	};
 }
-function resolvePackageJsonFromRoot(packageName, root) {
-	try {
-		return createRequire(path.join(root, "package.json")).resolve(`${packageName}/package.json`);
-	} catch {
-		return;
-	}
+function delay(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
 }
-/** Returns the preferred and fallback managed Codex binary paths for a plugin root. */
-function resolveManagedCodexAppServerPaths(params) {
-	const platform = params.platform ?? process.platform;
-	const candidateCommandPaths = resolveManagedCodexAppServerCommandCandidates(params.pluginRoot ?? CODEX_PLUGIN_ROOT, platform, params.managedCommandOrder ?? "package-first");
+//#endregion
+//#region extensions/codex/src/app-server/desktop-generation.ts
+/** Lifecycle-owned generation for managed macOS Codex desktop artifacts. */
+const APPLICATIONS_PATH = "/Applications";
+const REARM_INITIAL_DELAY_MS = 100;
+const REARM_MAX_DELAY_MS = 3e4;
+const DESKTOP_GENERATION_STATE = Symbol.for("openclaw.codexDesktopGenerationState");
+function state() {
+	const globalState = globalThis;
+	return globalState[DESKTOP_GENERATION_STATE] ??= {};
+}
+function waitForCodexDesktopGeneration() {
+	return state().owner?.wait() ?? Promise.resolve(void 0);
+}
+function isCodexDesktopGenerationCurrent(generation) {
+	return state().owner?.isCurrent(generation) ?? false;
+}
+function createCodexDesktopGenerationService(params, runtime = {
+	platform: process.platform,
+	readFingerprint: readMacOSDesktopGenerationFingerprint,
+	resolveWatchPaths: resolveMacOSDesktopGenerationWatchPaths,
+	pathExists: existsSync,
+	watchPath: (watchedPath, options, listener) => watch(watchedPath, options, listener)
+}) {
 	return {
-		commandPath: candidateCommandPaths[0] ?? "",
-		candidateCommandPaths
-	};
-}
-function resolveManagedCodexAppServerCommandCandidates(pluginRoot, platform, managedCommandOrder) {
-	const pathApi = pathForPlatform(platform);
-	const commandName = platform === "win32" ? "codex.cmd" : "codex";
-	const roots = resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform);
-	const packageCommandPaths = [...roots.map((root) => pathApi.join(root, "node_modules", ".bin", commandName)), ...resolveManagedCodexPackageBinCandidates(roots, platform)];
-	const desktopCommandPaths = resolveDesktopCodexAppServerCommandCandidates(platform);
-	const orderedCommandPaths = managedCommandOrder === "desktop-first" ? [...desktopCommandPaths, ...packageCommandPaths] : [...packageCommandPaths, ...desktopCommandPaths];
-	return [...new Set(orderedCommandPaths)];
-}
-function resolveDesktopCodexAppServerCommandCandidates(platform) {
-	return platform === "darwin" ? [...MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS] : [];
-}
-function resolveDefaultCodexPluginRoot(moduleDir) {
-	const moduleBaseName = path.basename(moduleDir);
-	if (moduleBaseName === "dist" || moduleBaseName === "dist-runtime") return path.dirname(moduleDir);
-	return path.resolve(moduleDir, "..", "..");
-}
-function resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform) {
-	const pathApi = pathForPlatform(platform);
-	const directRoots = [
-		pluginRoot,
-		pathApi.dirname(pluginRoot),
-		pathApi.dirname(pathApi.dirname(pluginRoot)),
-		isDistExtensionRoot(pluginRoot, platform) ? pathApi.dirname(pathApi.dirname(pathApi.dirname(pluginRoot))) : null
-	].filter((root) => Boolean(root));
-	return [.../* @__PURE__ */ new Set([...directRoots, ...resolveNearestNodeModulesProjectRoots(directRoots, platform)])];
-}
-function resolveNearestNodeModulesProjectRoots(roots, platform) {
-	const pathApi = pathForPlatform(platform);
-	const projectRoots = [];
-	for (const root of roots) {
-		let current = pathApi.resolve(root);
-		while (true) {
-			if (pathApi.basename(current) === "node_modules") {
-				projectRoots.push(pathApi.dirname(current));
-				break;
+		id: "codex-desktop-generation",
+		async start(ctx) {
+			if (runtime.platform !== "darwin") return;
+			const current = state();
+			current.context = ctx;
+			current.readFingerprint = runtime.readFingerprint;
+			current.resolveWatchPaths = runtime.resolveWatchPaths;
+			current.pathExists = runtime.pathExists;
+			current.watchPath = runtime.watchPath;
+			current.owner = createCodexDesktopGenerationOwner({
+				readFingerprint: current.readFingerprint,
+				onGenerationChange: params.onGenerationChange,
+				initialGeneration: current.lastGeneration
+			});
+			armWatchers(current);
+			refreshGeneration(current, current.owner, current.owner.refresh());
+		},
+		async stop() {
+			const current = state();
+			current.lastGeneration = current.owner?.read() ?? current.lastGeneration;
+			current.owner?.stop();
+			current.owner = void 0;
+			current.armEpoch = (current.armEpoch ?? 0) + 1;
+			current.context = void 0;
+			current.readFingerprint = void 0;
+			current.resolveWatchPaths = void 0;
+			current.pathExists = void 0;
+			current.watchPath = void 0;
+			current.watchHealthy = void 0;
+			current.rearmDelayMs = void 0;
+			if (current.rearmTimer) {
+				clearTimeout(current.rearmTimer);
+				current.rearmTimer = void 0;
 			}
-			const parent = pathApi.dirname(current);
-			if (parent === current) break;
-			current = parent;
+			closeWatchers(current);
 		}
-	}
-	return projectRoots;
+	};
 }
-function resolveManagedCodexPackageBinCandidates(roots, platform) {
-	if (platform === "win32") return [];
-	const candidates = [];
-	for (const root of roots) {
-		const candidate = resolveManagedCodexPackageBinCandidate(root);
-		if (candidate) candidates.push(candidate);
+function armWatchers(current) {
+	const owner = current.owner;
+	if (!owner || current.watchers) return false;
+	const armEpoch = (current.armEpoch ?? 0) + 1;
+	current.armEpoch = armEpoch;
+	const watchers = /* @__PURE__ */ new Set();
+	current.watchers = watchers;
+	const candidateNames = new Set(resolveMacOSDesktopCodexAppPathCandidates("darwin").map((candidate) => candidate.appName));
+	let complete = true;
+	for (const watchedPath of current.resolveWatchPaths?.() ?? []) {
+		if (!current.pathExists?.(watchedPath)) continue;
+		try {
+			const watcher = current.watchPath?.(watchedPath, { recursive: watchedPath !== APPLICATIONS_PATH }, (_eventType, filename) => {
+				if (!isCurrentArm(current, owner, watchers, armEpoch)) return;
+				if (watchedPath === APPLICATIONS_PATH && filename && !candidateNames.has(filename.toString().split(path.sep)[0] ?? "")) return;
+				owner.markDirty();
+				scheduleRearm(current, owner);
+			});
+			if (!watcher) {
+				complete = false;
+				reportWatcherFailure(current, owner, /* @__PURE__ */ new Error(`Could not watch ${watchedPath}`));
+				scheduleRearm(current, owner);
+				continue;
+			}
+			watchers.add(watcher);
+			watcher.on("error", (error) => {
+				if (!isCurrentArm(current, owner, watchers, armEpoch)) return;
+				reportWatcherFailure(current, owner, error);
+				scheduleRearm(current, owner);
+			});
+		} catch (error) {
+			complete = false;
+			reportWatcherFailure(current, owner, error);
+			scheduleRearm(current, owner);
+		}
 	}
-	return candidates;
-}
-function resolveManagedCodexPackageBinCandidate(root) {
-	try {
-		const packageJsonPath = createRequire(path.join(root, "package.json")).resolve(`${MANAGED_CODEX_APP_SERVER_PACKAGE}/package.json`);
-		const packageRoot = path.dirname(packageJsonPath);
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-		const packageBin = packageJson.bin && typeof packageJson.bin === "object" ? packageJson.bin : void 0;
-		const binPath = typeof packageJson.bin === "string" ? packageJson.bin : typeof packageBin?.codex === "string" ? packageBin.codex : null;
-		return binPath ? path.resolve(packageRoot, binPath) : null;
-	} catch {
-		return null;
+	current.watchHealthy = complete;
+	if (complete) current.rearmDelayMs = REARM_INITIAL_DELAY_MS;
+	return complete;
+}
+function reportWatcherFailure(current, owner, error) {
+	if (current.watchHealthy === false) return;
+	current.watchHealthy = false;
+	owner.markDirty();
+	current.context?.serviceHealth?.reportFailure(error);
+	current.context?.logger.warn(`codex desktop generation watcher failed: ${String(error)}`);
+}
+function isCurrentArm(current, owner, watchers, armEpoch) {
+	return current.owner === owner && current.watchers === watchers && current.armEpoch === armEpoch;
+}
+function scheduleRearm(current, owner) {
+	if (current.rearmTimer) {
+		if (current.watchHealthy === false) return;
+		clearTimeout(current.rearmTimer);
 	}
+	const delayMs = current.watchHealthy === false ? current.rearmDelayMs ?? REARM_INITIAL_DELAY_MS : REARM_INITIAL_DELAY_MS;
+	if (current.watchHealthy === false) current.rearmDelayMs = Math.min(delayMs * 2, REARM_MAX_DELAY_MS);
+	current.rearmTimer = setTimeout(() => {
+		current.rearmTimer = void 0;
+		if (current.owner !== owner) return;
+		const wasUnhealthy = current.watchHealthy === false;
+		closeWatchers(current);
+		if (!armWatchers(current) || wasUnhealthy) owner.markDirty();
+		refreshGeneration(current, owner, owner.wait());
+	}, delayMs);
+	current.rearmTimer.unref();
+}
+function logRefreshFailure(current, owner) {
+	return (error) => {
+		if (current.owner !== owner) return;
+		current.context?.serviceHealth?.reportFailure(error);
+		current.context?.logger.warn(`codex desktop generation refresh failed: ${String(error)}`);
+	};
 }
-function isDistExtensionRoot(pluginRoot, platform) {
-	const pathApi = pathForPlatform(platform);
-	const extensionsDir = pathApi.dirname(pluginRoot);
-	const distDir = pathApi.dirname(extensionsDir);
-	return pathApi.basename(extensionsDir) === "extensions" && (pathApi.basename(distDir) === "dist" || pathApi.basename(distDir) === "dist-runtime");
-}
-function pathForPlatform(platform) {
-	return platform === "win32" ? path.win32 : path.posix;
-}
-async function findManagedCodexAppServerCommandPaths(params) {
-	const commandPaths = [];
-	for (const commandPath of params.candidateCommandPaths) if (await params.pathExists(commandPath, params.platform)) commandPaths.push(commandPath);
-	if (commandPaths.length > 0) return commandPaths;
-	throw new Error([
-		`Managed Codex app-server binary was not found for ${MANAGED_CODEX_APP_SERVER_PACKAGE}.`,
-		"Reinstall or update OpenClaw, or run pnpm install in a source checkout.",
-		"Set plugins.entries.codex.config.appServer.command or OPENCLAW_CODEX_APP_SERVER_BIN to use a custom Codex binary."
-	].join(" "));
+function refreshGeneration(current, owner, refresh) {
+	refresh.then(() => {
+		if (current.owner === owner && current.watchHealthy) current.context?.serviceHealth?.clearFailure();
+	}).catch(logRefreshFailure(current, owner));
 }
-async function commandPathExists(filePath, platform) {
-	try {
-		await access(filePath, platform === "win32" ? constants.F_OK : constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
+function closeWatchers(current) {
+	const watchers = current.watchers;
+	current.watchers = void 0;
+	for (const watcher of watchers ?? []) watcher.close();
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-config-fence.ts
@@ -2659,37 +3892,31 @@ async function waitForPreviousFence(previous, options) {
 	});
 }
 //#endregion
-//#region extensions/codex/src/app-server/timeout.ts
-/**
-* Thin Codex app-server timeout adapter around OpenClaw's shared security
-* runtime timeout helper.
-*/
-function resolveAbortError(signal) {
-	return signal.reason instanceof Error ? signal.reason : new Error("Codex app-server operation aborted", { cause: signal.reason });
-}
-/** Awaits a promise with a Codex-specific timeout error message. */
-async function withTimeout$1(promise, timeoutMs, timeoutMessage, createError) {
-	return await withTimeout(promise, timeoutMs, {
-		message: timeoutMessage,
-		...createError ? { createError } : {}
-	});
-}
-/** Bounds an operation by both its owner lifecycle and one total wall-clock budget. */
-async function withAbortableTimeout(params) {
-	const signal = params.signal;
-	if (signal?.aborted) throw resolveAbortError(signal);
-	let removeAbortListener;
-	const operation = signal ? Promise.race([params.promise, new Promise((_, reject) => {
-		const onAbort = () => reject(resolveAbortError(signal));
-		signal.addEventListener("abort", onAbort, { once: true });
-		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-	})]) : params.promise;
-	try {
-		return await withTimeout$1(operation, params.timeoutMs, params.timeoutMessage, params.createTimeoutError);
-	} finally {
-		removeAbortListener?.();
+//#region extensions/codex/src/app-server/thread-lifecycle-errors.ts
+var CodexThreadStartRequestError = class extends Error {
+	constructor(cause) {
+		super(`thread/start: ${formatErrorMessage(cause)}`, { cause });
+		this.name = "CodexThreadStartRequestError";
 	}
-}
+};
+var CodexThreadBindingConflictError = class extends Error {
+	constructor(threadId, operation) {
+		super(`Codex thread binding changed while ${operation}: ${threadId}`);
+		this.name = "CodexThreadBindingConflictError";
+	}
+};
+var CodexRestrictedToolSurfaceAttestationError = class extends Error {
+	constructor(cause) {
+		super("Codex restricted-tool-surface MCP attestation failed", { cause });
+		this.name = "CodexRestrictedToolSurfaceAttestationError";
+	}
+};
+var CodexAdoptedThreadActiveError = class extends Error {
+	constructor() {
+		super("Codex session became active in another runner; wait for it to finish before continuing");
+		this.name = "CodexAdoptedThreadActiveError";
+	}
+};
 //#endregion
 //#region extensions/codex/src/app-server/shared-client.ts
 /**
@@ -2698,6 +3925,8 @@ async function withAbortableTimeout(params) {
 */
 var shared_client_exports = /* @__PURE__ */ __exportAll({
 	assertCodexAppServerClientStartSelectionCurrent: () => assertCodexAppServerClientStartSelectionCurrent,
+	captureExclusiveSharedCodexAppServerClient: () => captureExclusiveSharedCodexAppServerClient,
+	captureSharedCodexAppServerCatalogLifetime: () => captureSharedCodexAppServerCatalogLifetime,
 	clearSharedCodexAppServerClientAndWait: () => clearSharedCodexAppServerClientAndWait,
 	clearSharedCodexAppServerClientIfCurrent: () => clearSharedCodexAppServerClientIfCurrent,
 	clearSharedCodexAppServerClientIfCurrentAndUnclaimed: () => clearSharedCodexAppServerClientIfCurrentAndUnclaimed,
@@ -2706,6 +3935,9 @@ var shared_client_exports = /* @__PURE__ */ __exportAll({
 	getLeasedSharedCodexAppServerClient: () => getLeasedSharedCodexAppServerClient,
 	getSharedCodexAppServerClient: () => getSharedCodexAppServerClient,
 	isCodexAppServerStartSelectionChangedError: () => isCodexAppServerStartSelectionChangedError,
+	readCodexAppServerClientDesktopGeneration: () => readCodexAppServerClientDesktopGeneration,
+	readCodexAppServerClientDesktopGenerationFingerprint: () => readCodexAppServerClientDesktopGenerationFingerprint,
+	readCodexAppServerClientProcessIdentity: () => readCodexAppServerClientProcessIdentity,
 	releaseCodexAppServerClientLease: () => releaseCodexAppServerClientLease,
 	releaseLeasedSharedCodexAppServerClient: () => releaseLeasedSharedCodexAppServerClient,
 	resolveCodexAppServerSpawnIdentity: () => resolveCodexAppServerSpawnIdentity,
@@ -2713,6 +3945,8 @@ var shared_client_exports = /* @__PURE__ */ __exportAll({
 	retainSharedCodexAppServerClientByInstanceId: () => retainSharedCodexAppServerClientByInstanceId,
 	retainSharedCodexAppServerClientIfCurrent: () => retainSharedCodexAppServerClientIfCurrent,
 	retireSharedCodexAppServerClientIfCurrent: () => retireSharedCodexAppServerClientIfCurrent,
+	retireSharedCodexAppServerClientsBeforeDesktopGeneration: () => retireSharedCodexAppServerClientsBeforeDesktopGeneration,
+	waitForCodexAppServerClientDesktopGenerationDrain: () => waitForCodexAppServerClientDesktopGenerationDrain,
 	withLeasedCodexAppServerClientStartSelectionRetry: () => withLeasedCodexAppServerClientStartSelectionRetry
 });
 const CODEX_APP_SERVER_INITIALIZE_TIMEOUT_MESSAGE = "codex app-server initialize timed out";
@@ -2724,8 +3958,10 @@ function getSharedCodexAppServerClientState() {
 	globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE] ??= {
 		clients: /* @__PURE__ */ new Map(),
 		liveClients: /* @__PURE__ */ new Set(),
+		isolatedClients: /* @__PURE__ */ new Set(),
 		entriesByClient: /* @__PURE__ */ new WeakMap(),
-		leasedReleases: /* @__PURE__ */ new WeakMap()
+		leasedReleases: /* @__PURE__ */ new WeakMap(),
+		desktopGenerationDrainChecks: /* @__PURE__ */ new Set()
 	};
 	return globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE];
 }
@@ -2734,6 +3970,41 @@ function getCodexAppServerClientStartMetadata() {
 	globalState[CODEX_APP_SERVER_CLIENT_START_METADATA] ??= /* @__PURE__ */ new WeakMap();
 	return globalState[CODEX_APP_SERVER_CLIENT_START_METADATA];
 }
+/** Reads the exact successful spawn selection plus its initialized runtime identity. */
+function readCodexAppServerClientProcessIdentity(client) {
+	const metadata = getCodexAppServerClientStartMetadata().get(client);
+	if (!metadata) return;
+	const runtimeIdentity = client.getRuntimeIdentity();
+	return {
+		clientId: client.getInstanceId(),
+		...resolveCodexAppServerSpawnIdentity(metadata.startOptions, metadata.nativeCommand),
+		...runtimeIdentity?.serverVersion ? { serverVersion: runtimeIdentity.serverVersion } : {},
+		...runtimeIdentity?.userAgent ? { userAgent: runtimeIdentity.userAgent } : {}
+	};
+}
+/** Returns the lifecycle fingerprint that owns a managed desktop client. */
+function readCodexAppServerClientDesktopGenerationFingerprint(client) {
+	return readCodexAppServerClientDesktopGeneration(client)?.fingerprint;
+}
+/** Returns the lifecycle generation that owns a managed desktop client. */
+function readCodexAppServerClientDesktopGeneration(client) {
+	return getCodexAppServerClientStartMetadata().get(client)?.desktopGeneration;
+}
+/** Waits until older physical desktop clients for this client's Codex home exit. */
+async function waitForCodexAppServerClientDesktopGenerationDrain(params) {
+	const metadata = getCodexAppServerClientStartMetadata().get(params.client);
+	if (!metadata?.desktopGeneration) return;
+	const drain = createOlderDesktopGenerationDrainWait({
+		generation: metadata.desktopGeneration,
+		startOptions: metadata.startOptions,
+		agentDir: metadata.agentDir
+	});
+	try {
+		await withCodexAppServerAcquireDeadline(params.timeoutMs ?? 0, drain.promise, params.signal, "Codex Computer Use install timed out waiting for older desktop clients");
+	} finally {
+		drain.cancel();
+	}
+}
 /** Resolves non-secret spawn identity before startup; argv is represented only by its hash. */
 function resolveCodexAppServerSpawnIdentity(startOptions, resolvedNativeCommand) {
 	const nativeCommand = resolvedNativeCommand ?? (startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0);
@@ -2764,6 +4035,7 @@ function isCodexAppServerStartSelectionChangedError(error) {
 function assertCodexAppServerClientStartSelectionCurrent(params) {
 	const metadata = getCodexAppServerClientStartMetadata().get(params.client);
 	if (!metadata) return;
+	if (metadata.desktopGeneration && !isCodexDesktopGenerationCurrent(metadata.desktopGeneration)) throw new CodexAppServerStartSelectionChangedError();
 	const requestedStartOptions = params.startOptions ?? metadata.requestedStartOptions;
 	if (requestedStartOptions.commandSource !== "managed") return;
 	const current = resolveCodexAppServerStartOptionsForAgent({
@@ -2775,7 +4047,7 @@ function assertCodexAppServerClientStartSelectionCurrent(params) {
 /** Resolves the per-CODEX_HOME key used to serialize native config loading. */
 function resolveCodexNativeConfigFenceKey(params) {
 	const metadata = params.client ? getCodexAppServerClientStartMetadata().get(params.client) : void 0;
-	const startOptions = params.startOptions ?? metadata?.startOptions;
+	const startOptions = metadata?.startOptions ?? params.startOptions;
 	if (!startOptions || startOptions.transport !== "stdio") return;
 	const configuredHome = startOptions.env?.CODEX_HOME?.trim();
 	const agentDir = params.agentDir ?? metadata?.agentDir ?? resolveDefaultAgentDir(params.config ?? {});
@@ -2789,10 +4061,11 @@ function inferAuthRequirement(preparedAuth) {
 async function resolveCodexAppServerClientStartContext(options) {
 	const agentDir = options?.agentDir ?? resolveDefaultAgentDir(options?.config ?? {});
 	const requestedStartOptions = options?.startOptions ?? resolveCodexAppServerRuntimeOptions().start;
+	const desktopGeneration = shouldTrackDesktopGeneration(requestedStartOptions, options?.pluginConfig) ? await waitForCodexDesktopGeneration() : void 0;
 	const preparedAuth = options?.preparedAuth;
 	const preparedApiKey = preparedAuth?.kind === "api-key" ? preparedAuth.apiKey.trim() : void 0;
 	if (preparedAuth && options?.authProfileId !== void 0) throw new Error("Prepared Codex auth cannot also select a legacy auth profile.");
-	if (preparedAuth?.kind === "profile" && !preparedAuth.store.profiles[preparedAuth.profileId]) throw new Error(`Prepared Codex auth profile "${preparedAuth.profileId}" was not found.`);
+	if (preparedAuth?.kind === "profile" && !preparedAuth.store.profiles[preparedAuth.profileId]) throw new Error(`Prepared Codex auth profile "${preparedAuth.profileId}" was not found. Select an existing OpenAI profile or sign in again with OpenClaw, then retry.`);
 	if (preparedAuth?.kind === "api-key" && !preparedApiKey) throw new Error("Prepared Codex API-key auth is missing its resolved key.");
 	if (preparedAuth && requestedStartOptions.homeScope === "user") throw new Error("Prepared Codex auth requires an isolated app-server home.");
 	const preparedAuthRequirement = inferAuthRequirement(preparedAuth);
@@ -2800,11 +4073,11 @@ async function resolveCodexAppServerClientStartContext(options) {
 	const authRequirement = options?.authRequirement ?? preparedAuthRequirement;
 	const usesNativeAuth = !preparedAuth && (options?.authProfileId === null || requestedStartOptions.homeScope === "user");
 	const requestedAuthProfileId = preparedAuth?.kind === "profile" ? preparedAuth.profileId : options?.authProfileId ?? void 0;
-	const authProfileStore = preparedAuth?.kind === "profile" ? preparedAuth.store : !usesNativeAuth && options?.authProfileStore ? resolveCodexAppServerAuthProfileStore({
+	const authProfileStore = preparedAuth?.kind === "profile" ? preparedAuth.store : !usesNativeAuth && preparedAuth?.kind !== "api-key" ? resolveCodexAppServerAuthProfileStore({
 		agentDir,
 		authProfileId: requestedAuthProfileId,
-		authProfileStore: options.authProfileStore,
-		config: options.config
+		authProfileStore: options?.authProfileStore,
+		config: options?.config
 	}) : options?.authProfileStore;
 	const authProfileId = preparedAuth?.kind === "profile" ? preparedAuth.profileId : usesNativeAuth || preparedAuth?.kind === "api-key" ? void 0 : resolveCodexAppServerAuthProfileIdForAgent({
 		authProfileId: requestedAuthProfileId,
@@ -2812,18 +4085,20 @@ async function resolveCodexAppServerClientStartContext(options) {
 		config: options?.config,
 		...authProfileStore ? { authProfileStore } : {}
 	});
-	const preparedAuthProfileSnapshot = preparedAuth?.kind === "profile" ? preparedAuth.snapshot ?? await resolveCodexAppServerPreparedAuthProfileSnapshot({
+	const preparedAuthProfileSnapshot = !usesNativeAuth && authProfileId ? (preparedAuth?.kind === "profile" ? preparedAuth.snapshot : void 0) ?? await resolveCodexAppServerPreparedAuthProfileSnapshot({
 		authProfileId,
 		authProfileStore,
 		agentDir,
 		config: options?.config
 	}) : void 0;
-	if (preparedAuth?.kind === "profile" && !preparedAuthProfileSnapshot) throw new Error(`Prepared Codex auth profile "${preparedAuth.profileId}" is unusable.`);
+	if (preparedAuth?.kind === "profile" && !preparedAuthProfileSnapshot) throw new Error(`Prepared Codex auth profile "${preparedAuth.profileId}" is unusable. Repair or replace the selected OpenAI profile, then retry.`);
 	const resolvedPreparedAuth = preparedAuth?.kind === "api-key" ? {
 		kind: "api-key",
 		apiKey: preparedApiKey
-	} : preparedAuth?.kind === "profile" ? {
-		...preparedAuth,
+	} : preparedAuthProfileSnapshot && authProfileId && authProfileStore ? {
+		kind: "profile",
+		profileId: authProfileId,
+		store: authProfileStore,
 		snapshot: preparedAuthProfileSnapshot
 	} : void 0;
 	return {
@@ -2842,51 +4117,20 @@ async function resolveCodexAppServerClientStartContext(options) {
 			agentId: options?.agentId,
 			agentDir,
 			authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
-			...resolvedPreparedAuth ? { preparedAuth: resolvedPreparedAuth } : {},
+			...preparedAuth && resolvedPreparedAuth ? { preparedAuth: resolvedPreparedAuth } : {},
 			authRequirement,
 			config: options?.config,
 			pluginConfig: options?.pluginConfig,
 			...authProfileStore ? { authProfileStore } : {}
-		})
-	};
-}
-function resolveWarmSharedCodexAppServerClientIdentity(options) {
-	if (!options?.config || typeof options.config !== "object" || !options.startOptions || options.pluginConfig !== void 0 || options.authProfileStore !== void 0 || options.preparedAuth !== void 0 || options.runtimeArtifactMode !== void 0 || options.expectedRuntimeArtifact !== void 0) return;
-	const authProfileSelector = options.authProfileId === null ? ["native"] : options.authProfileId === void 0 ? ["implicit"] : ["profile", options.authProfileId];
-	return {
-		config: options.config,
-		startOptions: options.startOptions,
-		selectorKey: JSON.stringify([
-			options.agentDir ?? resolveDefaultAgentDir(options.config),
-			authProfileSelector,
-			options.authBindingFingerprint ?? null,
-			options.authRequirement ?? null
-		])
+		}),
+		...options?.pluginConfig !== void 0 ? { pluginConfig: options.pluginConfig } : {},
+		...desktopGeneration ? { desktopGeneration } : {}
 	};
 }
-function readWarmSharedCodexAppServerClient(state, identity) {
-	const aliases = state.warmClientsByConfig?.get(identity.config)?.get(identity.startOptions);
-	const warm = aliases?.get(identity.selectorKey);
-	if (!warm) return;
-	if (state.clients.get(warm.key) !== warm.entry || warm.entry.client !== warm.client || warm.entry.closeWhenIdle || warm.entry.closeError) {
-		aliases?.delete(identity.selectorKey);
-		return;
-	}
-	return warm;
-}
-function rememberWarmSharedCodexAppServerClient(state, identity, warm) {
-	state.warmClientsByConfig ??= /* @__PURE__ */ new WeakMap();
-	let byStartOptions = state.warmClientsByConfig.get(identity.config);
-	if (!byStartOptions) {
-		byStartOptions = /* @__PURE__ */ new WeakMap();
-		state.warmClientsByConfig.set(identity.config, byStartOptions);
-	}
-	let aliases = byStartOptions.get(identity.startOptions);
-	if (!aliases) {
-		aliases = /* @__PURE__ */ new Map();
-		byStartOptions.set(identity.startOptions, aliases);
-	}
-	aliases.set(identity.selectorKey, warm);
+function shouldTrackDesktopGeneration(startOptions, pluginConfig) {
+	if (startOptions.transport !== "stdio") return false;
+	if (resolveCodexComputerUseConfig({ pluginConfig }).enabled && (startOptions.commandSource === "managed" || startOptions.commandSource === "resolved-managed")) return true;
+	return startOptions.commandSource === "managed" && (startOptions.managedCommandOrder ?? "package-first") === "desktop-first";
 }
 /** Gets or starts a shared Codex app-server client without retaining a lease. */
 async function getSharedCodexAppServerClient(options) {
@@ -2918,7 +4162,7 @@ function releaseCodexAppServerClientLease(lease) {
 	lease.client = void 0;
 	return client ? releaseLeasedSharedCodexAppServerClient(client) : false;
 }
-/** Retries one config-loading request after moving its lease to the current owner. */
+/** Retries one config-loading operation with a shared deadline and current client lease. */
 async function withLeasedCodexAppServerClientStartSelectionRetry(params) {
 	let client = params.lease.client;
 	if (!client) throw new Error("Codex app-server selection retry requires an active client lease");
@@ -2934,43 +4178,49 @@ async function withLeasedCodexAppServerClientStartSelectionRetry(params) {
 			...signal ? { signal } : {}
 		};
 	};
-	for (let attempt = 0; attempt < 2; attempt += 1) try {
-		return await params.run(client, requestOptions());
-	} catch (error) {
-		if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
-		retireSharedCodexAppServerClientIfCurrent(client);
-		params.lease.client = void 0;
-		if (!releaseLeasedSharedCodexAppServerClient(client)) {
-			client.close();
-			throw new Error("Codex app-server selection retry requires a leased shared client", { cause: error });
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		const attemptClient = client;
+		let scopeActive = true;
+		const assertCurrent = () => {
+			if (!scopeActive || params.lease.client !== attemptClient) throw new CodexAppServerStartupError("aborted", "Codex app-server request scope is closed");
+		};
+		try {
+			requestOptions();
+			return await params.run(client, () => {
+				assertCurrent();
+				return {
+					...requestOptions(),
+					assertCurrent
+				};
+			});
+		} catch (error) {
+			if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
+			retireSharedCodexAppServerClientIfCurrent(client);
+			params.lease.client = void 0;
+			if (!releaseLeasedSharedCodexAppServerClient(client)) {
+				client.close();
+				throw new Error("Codex app-server selection retry requires a leased shared client", { cause: error });
+			}
+			const replacementOptions = requestOptions();
+			client = await getLeasedSharedCodexAppServerClient({
+				...params.options,
+				timeoutMs: replacementOptions.timeoutMs,
+				...signal ? { abandonSignal: signal } : {}
+			});
+			params.lease.client = client;
+			params.onClientChange?.(client);
+		} finally {
+			scopeActive = false;
 		}
-		const replacementOptions = requestOptions();
-		client = await getLeasedSharedCodexAppServerClient({
-			...params.options,
-			timeoutMs: replacementOptions.timeoutMs,
-			...signal ? { abandonSignal: signal } : {}
-		});
-		params.lease.client = client;
-		params.onClientChange(client);
 	}
 	throw new Error("Codex app-server selection retry loop exited unexpectedly");
 }
 async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 	if (options?.abandonSignal?.aborted) throw new CodexAppServerStartupError("aborted", "codex app-server initialize aborted");
-	const state = getSharedCodexAppServerClientState();
-	const warmIdentity = resolveWarmSharedCodexAppServerClientIdentity(options);
-	const warmClient = warmIdentity ? readWarmSharedCodexAppServerClient(state, warmIdentity) : void 0;
-	if (warmClient) {
-		options?.onStartedClient?.(warmClient.client);
-		const release = leaseOptions?.leased ? retainSharedClientEntry(warmClient.entry) : void 0;
-		return release ? {
-			client: warmClient.client,
-			release
-		} : { client: warmClient.client };
-	}
 	const acquireStartedAt = Date.now();
 	const timeoutMs = options?.timeoutMs ?? 0;
-	const { agentDir, usesNativeAuth, authProfileId, authProfileStore, preparedAuth, authRequirement, requestedStartOptions, startOptions } = await withCodexAppServerAcquireDeadline(timeoutMs, resolveCodexAppServerClientStartContext(options), options?.abandonSignal);
+	const state = getSharedCodexAppServerClientState();
+	const { agentDir, usesNativeAuth, authProfileId, authProfileStore, preparedAuth, authRequirement, requestedStartOptions, startOptions, desktopGeneration, pluginConfig } = await withCodexAppServerAcquireDeadline(timeoutMs, resolveCodexAppServerClientStartContext(options), options?.abandonSignal);
 	const remainingTimeoutMs = resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt);
 	const authIdentityCacheKey = preparedAuth?.kind === "api-key" ? resolveCodexAppServerPreparedApiKeyCacheKey(preparedAuth.apiKey) : preparedAuth?.snapshot.secretFreeCacheKey ?? (authRequirement === "api-key" && !authProfileId ? resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions }) : void 0);
 	const baseKey = `${codexAppServerStartOptionsKey(startOptions, {
@@ -2978,12 +4228,18 @@ async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 		authBindingFingerprint: options?.authBindingFingerprint,
 		agentDir: usesNativeAuth ? void 0 : agentDir,
 		fallbackApiKeyCacheKey: authIdentityCacheKey
-	})}\0auth-requirement:${authRequirement ?? "native"}`;
+	})}\0auth-requirement:${authRequirement ?? "native"}${desktopGeneration ? `\0desktop-generation:${desktopGeneration.epoch}` : ""}`;
 	const runtimeArtifactMode = options?.runtimeArtifactMode ?? (options?.expectedRuntimeArtifact ? "capture" : void 0);
 	const expectedRuntimeArtifactKey = options?.expectedRuntimeArtifact ? createHash("sha256").update(options.expectedRuntimeArtifact.id).update("\0").update(options.expectedRuntimeArtifact.fingerprint).digest("hex") : "mint";
 	const key = runtimeArtifactMode ? `${baseKey}\0runtime-artifact:capture-v1:${expectedRuntimeArtifactKey}` : baseKey;
-	const entry = getOrCreateSharedClientEntry(state, key);
-	if (runtimeArtifactMode) entry.runtimeArtifactStartupAbort ??= new AbortController();
+	let entry = getOrCreateSharedClientEntry(state, key);
+	const existingClient = entry.client;
+	const existingGeneration = existingClient ? getCodexAppServerClientStartMetadata().get(existingClient)?.desktopGeneration : void 0;
+	if (existingClient && existingGeneration && !isCodexDesktopGenerationCurrent(existingGeneration)) {
+		retireSharedCodexAppServerClientIfCurrent(existingClient);
+		entry = getOrCreateSharedClientEntry(state, key);
+	}
+	entry.startupAbort ??= new AbortController();
 	entry.closeWhenIdle = false;
 	const releasePendingAcquire = retainPendingSharedClientAcquire(entry);
 	const startedCallback = options?.onStartedClient;
@@ -3010,6 +4266,8 @@ async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 		key,
 		requestedStartOptions,
 		startOptions,
+		desktopGeneration,
+		...pluginConfig !== void 0 ? { pluginConfig } : {},
 		agentDir,
 		authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
 		authProfileStore,
@@ -3017,7 +4275,8 @@ async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 		authRequirement,
 		runtimeArtifactMode,
 		...options?.expectedRuntimeArtifact ? { expectedRuntimeArtifact: options.expectedRuntimeArtifact } : {},
-		runtimeArtifactSignal: entry.runtimeArtifactStartupAbort?.signal,
+		runtimeArtifactSignal: entry.startupAbort.signal,
+		abandonSignal: entry.startupAbort.signal,
 		config: options?.config
 	}));
 	try {
@@ -3032,11 +4291,6 @@ async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 			config: options?.config
 		});
 		const release = leaseOptions?.leased ? retainSharedClientEntry(entry) : void 0;
-		if (warmIdentity) rememberWarmSharedCodexAppServerClient(state, warmIdentity, {
-			key,
-			entry,
-			client
-		});
 		return release ? {
 			client,
 			release
@@ -3076,6 +4330,8 @@ function createSharedCodexAppServerClientStartup(params) {
 	const ready = startInitializedCodexAppServerClient({
 		requestedStartOptions: params.requestedStartOptions,
 		startOptions: params.startOptions,
+		...params.desktopGeneration ? { desktopGeneration: params.desktopGeneration } : {},
+		...params.pluginConfig !== void 0 ? { pluginConfig: params.pluginConfig } : {},
 		agentDir: params.agentDir,
 		authProfileId: params.authProfileId,
 		authProfileStore: params.authProfileStore,
@@ -3084,27 +4340,33 @@ function createSharedCodexAppServerClientStartup(params) {
 		runtimeArtifactMode: params.runtimeArtifactMode,
 		...params.expectedRuntimeArtifact ? { expectedRuntimeArtifact: params.expectedRuntimeArtifact } : {},
 		runtimeArtifactSignal: params.runtimeArtifactSignal,
+		abandonSignal: params.abandonSignal,
 		config: params.config,
 		onStartedClient: (startedClient) => {
 			const state = getSharedCodexAppServerClientState();
 			params.entry.client = startedClient;
-			state.entriesByClient.set(startedClient, params.entry);
 			state.liveClients.add(startedClient);
+			startedClient.addTransportExitHandler((exitedClient) => {
+				state.liveClients.delete(exitedClient);
+				notifyDesktopGenerationDrainChecks(state);
+			});
 			startedClient.addCloseHandler((closedClient) => {
-				getSharedCodexAppServerClientState().liveClients.delete(closedClient);
-				clearSharedClientEntryIfCurrent(params.key, closedClient);
+				if (state.entriesByClient.get(closedClient) === params.entry) clearSharedClientEntryIfCurrent(params.key, closedClient);
 			});
 			for (const callback of params.entry.onStartedClientCallbacks) callback(startedClient);
 			retirePendingSharedClientEntryIfUnclaimed(params.key, params.entry);
 		},
 		onInitializedClient: () => initialized.resolve()
 	}).then((client) => {
+		const state = getSharedCodexAppServerClientState();
 		params.entry.client = client;
+		state.entriesByClient.set(client, params.entry);
 		return client;
 	}, (error) => {
 		initialized.reject(error);
 		throw error;
 	});
+	initialized.promise.catch(() => void 0);
 	ready.catch(() => void 0);
 	return {
 		initialized: initialized.promise,
@@ -3116,10 +4378,12 @@ async function createIsolatedCodexAppServerClient(options) {
 	if (options?.abandonSignal?.aborted) throw new CodexAppServerStartupError("aborted", "codex app-server initialize aborted");
 	const acquireStartedAt = Date.now();
 	const timeoutMs = options?.timeoutMs ?? 0;
-	const { agentDir, usesNativeAuth, authProfileId, authProfileStore, preparedAuth, authRequirement, requestedStartOptions, startOptions } = await withCodexAppServerAcquireDeadline(timeoutMs, resolveCodexAppServerClientStartContext(options), options?.abandonSignal);
+	const { agentDir, usesNativeAuth, authProfileId, authProfileStore, preparedAuth, authRequirement, requestedStartOptions, startOptions, desktopGeneration, pluginConfig } = await withCodexAppServerAcquireDeadline(timeoutMs, resolveCodexAppServerClientStartContext(options), options?.abandonSignal);
 	return await startInitializedCodexAppServerClient({
 		requestedStartOptions,
 		startOptions,
+		...desktopGeneration ? { desktopGeneration } : {},
+		...pluginConfig !== void 0 ? { pluginConfig } : {},
 		agentDir,
 		authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
 		authProfileStore,
@@ -3131,7 +4395,18 @@ async function createIsolatedCodexAppServerClient(options) {
 		config: options?.config,
 		timeoutMs: resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt),
 		abandonSignal: options?.abandonSignal,
-		onStartedClient: options?.onStartedClient
+		onStartedClient: (client) => {
+			trackIsolatedCodexAppServerClient(client);
+			options?.onStartedClient?.(client);
+		}
+	});
+}
+function trackIsolatedCodexAppServerClient(client) {
+	const state = getSharedCodexAppServerClientState();
+	state.isolatedClients.add(client);
+	client.addTransportExitHandler((exitedClient) => {
+		state.isolatedClients.delete(exitedClient);
+		notifyDesktopGenerationDrainChecks(state);
 	});
 }
 async function startInitializedCodexAppServerClient(params) {
@@ -3139,7 +4414,41 @@ async function startInitializedCodexAppServerClient(params) {
 	const timeoutMs = params.timeoutMs ?? 0;
 	const startOptionsCandidates = resolveManagedFallbackStartOptions(params.startOptions);
 	for (const [index, startOptions] of startOptionsCandidates.entries()) {
-		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-BVSPdd6g.js") : void 0;
+		const desktopGeneration = params.desktopGeneration ?? (isManagedCodexDesktopCommand(startOptions.command) ? await withCodexAppServerAcquireDeadline(resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt), waitForCodexDesktopGeneration(), params.abandonSignal) : void 0);
+		const assertDesktopGenerationCurrent = () => {
+			if (params.abandonSignal?.aborted) throw new CodexAppServerStartupError("aborted", "codex app-server initialize aborted");
+			if (desktopGeneration && !isCodexDesktopGenerationCurrent(desktopGeneration)) throw new CodexAppServerStartSelectionChangedError();
+		};
+		const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig });
+		const ownsIsolatedCodexHome = params.requestedStartOptions.homeScope !== "user" && !params.requestedStartOptions.env?.CODEX_HOME?.trim();
+		const artifactDrain = desktopGeneration && ownsIsolatedCodexHome && computerUseConfig.enabled && (computerUseConfig.autoInstall || computerUseConfig.pluginCacheMode === "shared") ? createOlderDesktopGenerationDrainWait({
+			generation: desktopGeneration,
+			startOptions,
+			agentDir: params.agentDir
+		}) : void 0;
+		try {
+			if (artifactDrain) await withCodexAppServerAcquireDeadline(resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt), artifactDrain.promise, params.abandonSignal);
+			await reconcileCodexComputerUseStartArtifacts({
+				startOptions,
+				agentDir: params.agentDir,
+				pluginConfig: params.pluginConfig,
+				...desktopGeneration ? { desktopGeneration } : {},
+				assertCurrent: assertDesktopGenerationCurrent,
+				ownsIsolatedCodexHome
+			});
+		} catch (error) {
+			if (isCodexComputerUseCandidateArtifactsUnavailableError(error)) {
+				if (index + 1 < startOptionsCandidates.length) continue;
+				throw new AgentHarnessPreflightError("Codex Computer Use artifacts are unavailable from the installed desktop apps.", {
+					cause: error,
+					scope: "harness"
+				});
+			}
+			throw error;
+		} finally {
+			artifactDrain?.cancel();
+		}
+		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-DeBvleJw.js") : void 0;
 		const nativeCommandBeforeStart = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
 		const runtimeArtifactBeforeStart = runtimeArtifactModule ? await runtimeArtifactModule.captureCodexAppServerRuntimeArtifactBeforeStart({
 			startOptions,
@@ -3150,7 +4459,26 @@ async function startInitializedCodexAppServerClient(params) {
 			if (index + 1 < startOptionsCandidates.length) continue;
 			throw new Error("Codex app-server runtime artifact does not match verified inference");
 		}
-		const client = CodexAppServerClient.start(startOptions);
+		assertDesktopGenerationCurrent();
+		let starting;
+		let client;
+		try {
+			client = await withCodexAppServerAcquireDeadline(resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt), starting = CodexAppServerClient.start(startOptions, () => {
+				assertDesktopGenerationCurrent();
+				resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt);
+			}), params.abandonSignal);
+		} catch (error) {
+			starting?.then((lateClient) => lateClient.close(), () => {});
+			throw error;
+		}
+		const nativeCommandAtStart = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
+		getCodexAppServerClientStartMetadata().set(client, {
+			requestedStartOptions: params.requestedStartOptions,
+			startOptions,
+			agentDir: params.agentDir,
+			...nativeCommandAtStart ? { nativeCommand: nativeCommandAtStart } : {},
+			...desktopGeneration ? { desktopGeneration } : {}
+		});
 		params.onStartedClient?.(client);
 		let initialize;
 		try {
@@ -3161,6 +4489,12 @@ async function startInitializedCodexAppServerClient(params) {
 			if (shouldTryManagedFallbackStartOption(error, startOptions, index, startOptionsCandidates)) continue;
 			throw error;
 		}
+		try {
+			assertDesktopGenerationCurrent();
+		} catch (error) {
+			client.close();
+			throw error;
+		}
 		params.onInitializedClient?.();
 		let runtimeArtifact;
 		try {
@@ -3184,9 +4518,11 @@ async function startInitializedCodexAppServerClient(params) {
 			authProfileId: params.authProfileId ?? void 0,
 			authMode: params.preparedAuth?.kind === "api-key" ? "prepared-api-key" : "profile",
 			...params.authProfileStore ? { authProfileStore: params.authProfileStore } : {},
-			config: params.config
+			config: params.config,
+			onAuthRefreshFailure: () => retireSharedCodexAppServerClientIfCurrent(client)
 		});
 		try {
+			assertDesktopGenerationCurrent();
 			await withCodexAppServerAcquireDeadline(resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt), applyCodexAppServerAuthProfile({
 				client,
 				agentDir: params.agentDir,
@@ -3197,14 +4533,8 @@ async function startInitializedCodexAppServerClient(params) {
 				config: params.config,
 				...params.authProfileStore ? { authProfileStore: params.authProfileStore } : {}
 			}), params.abandonSignal);
-			const nativeCommand = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
 			if (runtimeArtifactModule && runtimeArtifact) runtimeArtifactModule.bindCodexAppServerRuntimeArtifact(client, runtimeArtifact);
-			getCodexAppServerClientStartMetadata().set(client, {
-				requestedStartOptions: params.requestedStartOptions,
-				startOptions,
-				agentDir: params.agentDir,
-				...nativeCommand ? { nativeCommand } : {}
-			});
+			assertDesktopGenerationCurrent();
 			const fenceKey = resolveCodexNativeConfigFenceKey({ client });
 			if (fenceKey) client.setThreadSessionRequestGuard(async (options) => {
 				const release = await acquireCodexNativeConfigFence(fenceKey, options);
@@ -3224,6 +4554,9 @@ async function startInitializedCodexAppServerClient(params) {
 	}
 	throw new Error("Managed Codex app-server fallback candidates were exhausted.");
 }
+function isCodexComputerUseCandidateArtifactsUnavailableError(error) {
+	return error !== null && typeof error === "object" && "code" in error && error.code === "CODEX_COMPUTER_USE_CANDIDATE_ARTIFACTS_UNAVAILABLE";
+}
 function resolveManagedFallbackStartOptions(startOptions) {
 	const commands = [startOptions.command, ...startOptions.managedFallbackCommandPaths ?? []];
 	const candidates = [];
@@ -3253,6 +4586,15 @@ function clearSharedCodexAppServerClientIfCurrent(client) {
 	}
 	return false;
 }
+/** Captures a revocable observation of the exact shared client and native account/config. */
+function captureSharedCodexAppServerCatalogLifetime(client) {
+	const state = getSharedCodexAppServerClientState();
+	const entry = state.entriesByClient.get(client);
+	const key = [...state.clients].find(([, candidate]) => candidate === entry)?.[0];
+	const generation = readCodexAppServerClientDesktopGeneration(client);
+	const revision = client.getModelCatalogRevision();
+	return () => key !== void 0 && state.clients.get(key) === entry && entry?.client === client && !entry.closeWhenIdle && !entry.closeError && !client.getCloseError() && client.getModelCatalogRevision() === revision && (!generation || isCodexDesktopGenerationCurrent(generation));
+}
 /** Retains the matching shared client and returns a release callback. */
 function retainSharedCodexAppServerClientIfCurrent(client) {
 	if (!client) return;
@@ -3272,6 +4614,20 @@ function retainSharedCodexAppServerClientByInstanceId(clientId) {
 		};
 	}
 }
+/** Captures sole physical-client ownership across awaited configuration adoption. */
+function captureExclusiveSharedCodexAppServerClient(client) {
+	const state = getSharedCodexAppServerClientState();
+	for (const [key, entry] of state.clients) {
+		if (entry.client !== client) continue;
+		const generation = entry.leaseGeneration;
+		const assertExclusive = () => {
+			if (state.clients.get(key) !== entry || entry.client !== client || entry.closeWhenIdle || entry.closeError || entry.activeLeases !== 1 || entry.pendingAcquires !== 0 || entry.leaseGeneration !== generation) throw new CodexAdoptedThreadActiveError();
+		};
+		assertExclusive();
+		return assertExclusive;
+	}
+	throw new CodexAdoptedThreadActiveError();
+}
 /**
 * Retires a matching shared client. Default is graceful: detach from the map
 * (future acquisitions get a fresh client) and close once leases drain.
@@ -3315,6 +4671,62 @@ function retireSharedCodexAppServerClientIfCurrent(client, opts) {
 		};
 	}
 }
+/** Gracefully retires exact clients attached to an older desktop generation. */
+function retireSharedCodexAppServerClientsBeforeDesktopGeneration(generation) {
+	const state = getSharedCodexAppServerClientState();
+	for (const entry of state.clients.values()) {
+		const client = entry.client;
+		const attached = client ? getCodexAppServerClientStartMetadata().get(client) : void 0;
+		if (client && attached?.desktopGeneration && attached.desktopGeneration.epoch < generation.epoch) retireSharedCodexAppServerClientIfCurrent(client);
+	}
+}
+function createOlderDesktopGenerationDrainWait(params) {
+	const targetHome = resolveCodexNativeConfigFenceKey({
+		startOptions: params.startOptions,
+		agentDir: params.agentDir
+	});
+	if (!targetHome) return {
+		promise: Promise.resolve(),
+		cancel: () => void 0
+	};
+	const state = getSharedCodexAppServerClientState();
+	let settled = false;
+	let resolveWait;
+	const promise = new Promise((resolve) => {
+		resolveWait = resolve;
+	});
+	const cancel = () => {
+		if (settled) return;
+		settled = true;
+		state.desktopGenerationDrainChecks.delete(check);
+		resolveWait();
+	};
+	const check = () => {
+		if (!hasLiveOlderDesktopGenerationClient({
+			state,
+			generation: params.generation,
+			targetHome
+		})) cancel();
+	};
+	state.desktopGenerationDrainChecks.add(check);
+	check();
+	return {
+		promise,
+		cancel
+	};
+}
+function hasLiveOlderDesktopGenerationClient(params) {
+	for (const client of params.state.liveClients) if (isOlderDesktopGenerationClientForHome(client, params.generation, params.targetHome)) return true;
+	for (const client of params.state.isolatedClients) if (isOlderDesktopGenerationClientForHome(client, params.generation, params.targetHome)) return true;
+	return false;
+}
+function isOlderDesktopGenerationClientForHome(client, generation, targetHome) {
+	const metadata = getCodexAppServerClientStartMetadata().get(client);
+	return Boolean(metadata?.desktopGeneration && metadata.desktopGeneration.epoch < generation.epoch && resolveCodexNativeConfigFenceKey({ client }) === targetHome);
+}
+function notifyDesktopGenerationDrainChecks(state) {
+	for (const check of state.desktopGenerationDrainChecks) check();
+}
 /** Clears a matching shared client and waits for its process to exit. */
 async function clearSharedCodexAppServerClientIfCurrentAndWait(client, options) {
 	if (!client) return false;
@@ -3331,7 +4743,6 @@ async function clearSharedCodexAppServerClientAndWait(options) {
 	const state = getSharedCodexAppServerClientState();
 	const clients = collectSharedClients(state);
 	state.clients.clear();
-	state.warmClientsByConfig = /* @__PURE__ */ new WeakMap();
 	await Promise.all(clients.map((client) => client.closeAndWait(options)));
 }
 globalThis[SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER] = clearSharedCodexAppServerClientAndWait;
@@ -3341,6 +4752,7 @@ function getOrCreateSharedClientEntry(state, key) {
 		entry = {
 			activeLeases: 0,
 			pendingAcquires: 0,
+			leaseGeneration: 0,
 			closeWhenIdle: false,
 			onStartedClientCallbacks: /* @__PURE__ */ new Set()
 		};
@@ -3376,22 +4788,26 @@ function clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client) {
 }
 function retainPendingSharedClientAcquire(entry) {
 	let released = false;
+	entry.leaseGeneration += 1;
 	entry.pendingAcquires += 1;
 	return () => {
 		if (released) return;
 		released = true;
 		entry.pendingAcquires = Math.max(0, entry.pendingAcquires - 1);
 		closeRetiredSharedClientEntryIfIdle(entry);
+		notifyDesktopGenerationDrainChecks(getSharedCodexAppServerClientState());
 	};
 }
 function retainSharedClientEntry(entry) {
 	let released = false;
+	entry.leaseGeneration += 1;
 	entry.activeLeases += 1;
 	return () => {
 		if (released) return;
 		released = true;
 		entry.activeLeases = Math.max(0, entry.activeLeases - 1);
 		closeRetiredSharedClientEntryIfIdle(entry);
+		notifyDesktopGenerationDrainChecks(getSharedCodexAppServerClientState());
 	};
 }
 function closeRetiredSharedClientEntryIfIdle(entry) {
@@ -3419,7 +4835,7 @@ function closeSharedClientEntryIfUnclaimed(key, entry) {
 }
 function retirePendingSharedClientEntryIfUnclaimed(key, entry) {
 	if (entry.activeLeases > 0 || entry.pendingAcquires > 0) return;
-	entry.runtimeArtifactStartupAbort?.abort(/* @__PURE__ */ new Error("Codex runtime artifact startup was abandoned"));
+	entry.startupAbort?.abort(/* @__PURE__ */ new Error("Codex app-server startup was abandoned"));
 	entry.closeWhenIdle = true;
 	const state = getSharedCodexAppServerClientState();
 	if (state.clients.get(key) === entry) state.clients.delete(key);
@@ -3430,4 +4846,4 @@ function collectSharedClients(state) {
 	return [...state.liveClients];
 }
 //#endregion
-export { resolveCodexAppServerAuthProfileId as $, isCodexAppServerApprovalRequest as A, claimCodexAppServerLiveThread as B, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as C, resolveCodexTurnTerminalIdleTimeoutMs as D, resolveCodexTurnCompletionIdleTimeoutMs as E, isCodexAppServerPrewriteRequestCancellationError as F, protectCodexAppServerLiveThread as G, ensureCodexAppServerClientRuntime as H, isCodexAppServerRequestTimeoutError as I, unsubscribeCodexAppServerLiveThread as J, releaseCodexAppServerLiveThread as K, isUnsupportedCodexAppServerVersionError as L, isCodexAppServerConnectionClosedError as M, isCodexAppServerIndeterminateRequestCancellationError as N, withCodexStartupTimeout as O, isCodexAppServerIndeterminateTransportError as P, resolveCodexAppServerAuthAccountCacheKey as Q, resolveCodexAppServerClientInstanceId as R, resolveCodexGatewayTimeoutWithGraceMs as S, resolveCodexTurnAssistantCompletionIdleTimeoutMs as T, isCodexAppServerClientRuntimeLive as U, consumeCodexAppServerLiveThread as V, isCodexAppServerLiveThreadClaimed as W, readRecentCodexRateLimits as X, readCodexRateLimitsRevision as Y, rememberCodexRateLimitsRead as Z, withTimeout$1 as _, getLeasedSharedCodexAppServerClient as a, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as at, CodexAppServerStartupError as b, releaseCodexAppServerClientLease as c, isJsonObject as ct, retainSharedCodexAppServerClientByInstanceId as d, resolveCodexAppServerLocalHomeDir as dt, resolveCodexAppServerAuthProfileIdForAgent as et, retainSharedCodexAppServerClientIfCurrent as f, withAbortableTimeout as g, withLeasedCodexAppServerClientStartSelectionRetry as h, createIsolatedCodexAppServerClient as i, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as it, isCodexAppServerBrokenPipeError as j, getCodexAppServerClientInstanceId as k, releaseLeasedSharedCodexAppServerClient as l, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as lt, shared_client_exports as m, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as n, resolveCodexAppServerPreparedApiKeyCacheKey as nt, getSharedCodexAppServerClient as o, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as ot, retireSharedCodexAppServerClientIfCurrent as p, retainCodexAppServerLiveThread as q, clearSharedCodexAppServerClientIfCurrentAndWait as r, resolveCodexAppServerPreparedAuthHandoff as rt, isCodexAppServerStartSelectionChangedError as s, flattenCodexDynamicToolFunctions as st, clearSharedCodexAppServerClientIfCurrent as t, resolveCodexAppServerFallbackApiKeyCacheKey as tt, resolveCodexNativeConfigFenceKey as u, resolveCodexAppServerHomeDir as ut, acquireCodexNativeConfigFence as v, resolveCodexStartupTimeoutMs as w, isCodexAppServerStartupError as x, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as y, CodexAppServerRpcError as z };
+export { CodexAppServerRpcError as $, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as A, reconcileCodexComputerUseStartArtifacts as At, resolveCodexTurnTerminalIdleTimeoutMs as B, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as Bt, withLeasedCodexAppServerClientStartSelectionRetry as C, retainCodexAppServerLiveThread as Ct, CodexThreadStartRequestError as D, readCodexRateLimitsRevision as Dt, CodexThreadBindingConflictError as E, withTimeout$1 as Et, resolveCodexGatewayTimeoutWithGraceMs as F, resolveCodexAppServerFallbackApiKeyCacheKey as Ft, isCodexAppServerConnectionClosedError as G, getCodexAppServerClientInstanceId as H, isJsonObject as Ht, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as I, resolveCodexAppServerPreparedApiKeyCacheKey as It, isCodexAppServerOverloadError as J, isCodexAppServerIndeterminateRequestCancellationError as K, resolveCodexStartupTimeoutMs as L, resolveCodexAppServerPreparedAuthHandoff as Lt, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS as M, resolveCodexAppServerAuthProfileId as Mt, TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS as N, resolveCodexAppServerAuthProfileIdForAgent as Nt, acquireCodexNativeConfigFence as O, readRecentCodexRateLimits as Ot, isCodexAppServerStartupError as P, resolveCodexAppServerAuthProfileStore as Pt, resolveCodexAppServerClientInstanceId as Q, resolveCodexTurnAssistantCompletionIdleTimeoutMs as R, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as Rt, waitForCodexAppServerClientDesktopGenerationDrain as S, releaseCodexAppServerLiveThread as St, CodexRestrictedToolSurfaceAttestationError as T, withAbortableTimeout as Tt, isCodexAppServerApprovalRequest as U, resolveCodexManagedBundledMarketplacePath as Ut, withCodexStartupTimeout as V, flattenCodexDynamicToolFunctions as Vt, isCodexAppServerBrokenPipeError as W, assertNotSymlink as Wt, isCodexAppServerRequestTimeoutError as X, isCodexAppServerPrewriteRequestCancellationError as Y, isUnsupportedCodexAppServerVersionError as Z, retainSharedCodexAppServerClientByInstanceId as _, ensureCodexAppServerClientRuntime as _t, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as a, resolveDynamicToolCallTimeoutMs as at, retireSharedCodexAppServerClientsBeforeDesktopGeneration as b, isCodexAppServerLiveThreadClaimed as bt, getLeasedSharedCodexAppServerClient as c, shouldReleaseTurnAfterTerminalDynamicTool as ct, readCodexAppServerClientDesktopGeneration as d, resolveCodexToolAbortTerminalReason as dt, createCodexElicitationResponse as et, readCodexAppServerClientDesktopGenerationFingerprint as f, createFailedDynamicToolResponse as ft, resolveCodexNativeConfigFenceKey as g, consumeCodexAppServerLiveThread as gt, releaseLeasedSharedCodexAppServerClient as h, claimCodexAppServerLiveThread as ht, clearSharedCodexAppServerClientIfCurrent as i, isMatchingDynamicToolTerminalDiagnostic as it, CodexAppServerStartupError as j, resolveCodexAppServerAuthAccountCacheKey as jt, createCodexDesktopGenerationService as k, rememberCodexRateLimitsRead as kt, getSharedCodexAppServerClient as l, toCodexDynamicToolProgressResponse as lt, releaseCodexAppServerClientLease as m, withDynamicToolTranscriptDetails as mt, captureExclusiveSharedCodexAppServerClient as n, hasPendingDynamicToolTerminalDiagnostic as nt, clearSharedCodexAppServerClientIfCurrentAndWait as o, resolveTerminalDynamicToolBatchAction as ot, readCodexAppServerClientProcessIdentity as p, withDynamicToolExecutionState as pt, isCodexAppServerIndeterminateTransportError as q, captureSharedCodexAppServerCatalogLifetime as r, isDynamicToolTerminalDiagnosticEvent as rt, createIsolatedCodexAppServerClient as s, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as st, assertCodexAppServerClientStartSelectionCurrent as t, handleDynamicToolCallWithTimeout as tt, isCodexAppServerStartSelectionChangedError as u, toCodexDynamicToolProtocolResponse as ut, retainSharedCodexAppServerClientIfCurrent as v, hasCodexAppServerLiveThread as vt, CodexAdoptedThreadActiveError as w, unsubscribeCodexAppServerLiveThread as wt, shared_client_exports as x, protectCodexAppServerLiveThread as xt, retireSharedCodexAppServerClientIfCurrent as y, isCodexAppServerClientRuntimeLive as yt, resolveCodexTurnCompletionIdleTimeoutMs as z, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as zt };