@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{shared-client-BpTtuLQ5.mjs → shared-client-DqyTMYug.mjs}

@@ -1,38 +1,43 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { n as defineCodexBuildState, t as codexBuildSymbol } from "./build-state-Xx9ybZqa.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { n as defineCodexBuildState, t as codexBuildSymbol } from "./build-state-Da1_z0kd.mjs";
 import { t as CODEX_APP_SERVER_AUTH_PROVIDER } from "./auth-profile-selection-DFu9e167.mjs";
-import { _ as resolveCodexAppServerUserHomeDir, g as resolveCodexAppServerLocalHomeDir, h as resolveCodexAppServerHomeDir, m as isJsonObject, v as withEphemeralCodexAuthStore } from "./config-security-BRQ2mgW9.mjs";
-import { n as isCodexAppServerProxyLaunch } from "./launch-args-DnMak49W.mjs";
-import { f as isUnsupportedCodexAppServerVersionError, t as CodexAppServerClient } from "./client-vXs2929Q.mjs";
-import { a as resolveCodexAppServerStartOptionsForAgent, d as readCodexEffectiveConfig, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey, u as CODEX_SESSION_OVERRIDABLE_LAYER_TYPES } from "./config-options-BsanJ8QG.mjs";
-import { c as resolveMacOSDesktopCodexAppPathCandidates, i as resolveManagedCodexNativeCommand, l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, r as resolveManagedCodexAppServerStartOptions, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexComputerUseServiceAppCandidates } from "./managed-binary-DP6Rib3P.mjs";
-import { _ as isCodexDesktopGenerationCurrent, a as readCodexCliAuthFileApiKey, c as resolveCodexAppServerPreparedApiKeyCacheKey, d as createCodexAppServerStartupLifetime, f as getCurrentSharedClientEntry, i as fingerprintTokenAuthProfileCacheKey, l as closeRetiredSharedClientEntry, m as retireSharedCodexAppServerClientIfCurrent, n as CODEX_AUTH_JSON_FILENAME, o as readFirstNonEmptyEnv, p as getSharedCodexAppServerClientState, r as fingerprintApiKeyAuthProfileCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey, t as CODEX_APP_SERVER_API_KEY_ENV_VARS, u as closeRetiredSharedClientEntryIfIdle, v as waitForCodexDesktopGeneration } from "./auth-cache-key-QirmgiCo.mjs";
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-Cmx94Oiy.mjs";
-import { n as withTimeout } from "./timeout-DZF05XrR.mjs";
-import { c as readCodexSessionMeta, n as observeCodexCatalogClient } from "./session-catalog-events-jMcYfQyd.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
-import { a as resolveCodexAppServerAuthProfileStore, i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId, t as isCodexAppServerNativeAuthProfile } from "./auth-profile-WqZtZfXN.mjs";
+import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
+import { a as withEphemeralCodexAuthStore, i as withClearedEnvironmentVariables, n as resolveCodexAppServerLocalHomeDir, r as resolveCodexAppServerUserHomeDir, t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import { a as resolveCodexAppServerStartOptionsForAgent, d as readCodexEffectiveConfig, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey, u as CODEX_SESSION_OVERRIDABLE_LAYER_TYPES } from "./config-options-CzyWLTJt.mjs";
+import { d as resolveMacOSDesktopCodexBundledMarketplaceCandidates, f as resolveMacOSDesktopCodexComputerUseServiceAppCandidates, i as resolveManagedCodexNativeCommand, l as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexAppPathCandidates } from "./managed-binary-kiWRhNRE.mjs";
+import { a as readCodexCliAuthFileApiKey, c as resolveCodexAppServerPreparedApiKeyCacheKey, d as waitForCodexDesktopGeneration, f as readCodexDesktopArtifactTreeFingerprint, i as fingerprintTokenAuthProfileCacheKey, n as CODEX_AUTH_JSON_FILENAME, o as readFirstNonEmptyEnv, r as fingerprintApiKeyAuthProfileCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey, t as CODEX_APP_SERVER_API_KEY_ENV_VARS, u as isCodexDesktopGenerationCurrent } from "./auth-cache-key-Dbvq-QgB.mjs";
+import { a as notifyDesktopGenerationDrainChecks, c as retainSharedClientEntry, d as retireSharedCodexAppServerClientIfCurrent, m as waitForUnclaimedSharedClientStartup, n as getCurrentSharedClientEntry, o as ownCodexStartup, r as getSharedCodexAppServerClientState, s as releaseSharedClientEntry, t as createCodexAppServerStartupLifetime, u as retirePendingSharedClientEntryIfUnclaimed } from "./shared-client-lifecycle-DJIgqgMw.mjs";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-Bdegpn2V.mjs";
+import { n as CodexAppServerAuthProfileUnavailableError, r as formatCodexAuthProfileUnavailableMessage } from "./auth-profile-recovery-BREezV0L.mjs";
+import { i as withTimeout } from "./timeout-CXOfNoaX.mjs";
+import { n as readCodexSessionMeta } from "./session-catalog-provenance-DoAvktcj.mjs";
+import { n as observeCodexCatalogClient } from "./session-catalog-events-DePDzzjc.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
+import { a as resolveCodexAppServerAuthProfileStore, i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId, t as isCodexAppServerNativeAuthProfile } from "./auth-profile-B0okYl2D.mjs";
+import { i as isCodexResponsesOAuthCredential, n as createCodexResponsesOAuth, o as resolveCodexResponsesOAuthProfileFingerprint, r as isCodexResponsesOAuth, t as CODEX_RESPONSES_OAUTH_PROVIDER } from "./responses-oauth-twnuTaAa.mjs";
+import { f as isUnsupportedCodexAppServerVersionError, t as CodexAppServerClient } from "./client-N0JpgSzF.mjs";
+import { n as isCodexWebSocketOpenFailure } from "./transport-websocket-BTBE-LD9.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { AgentHarnessPreflightError, resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
-import { addTimerTimeoutGraceMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { runExec } from "openclaw/plugin-sdk/process-runtime";
-import fs, { constants } from "node:fs";
+import { addTimerTimeoutGraceMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import fs, { constants, existsSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
+import { extractErrorCode } from "openclaw/plugin-sdk/error-runtime";
+import { resolveGlobalMap } from "openclaw/plugin-sdk/global-singleton";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { ensureAuthProfileStore, findPersistedAuthProfileCredential, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolvePersistedAuthProfileOwnerAgentDir } from "openclaw/plugin-sdk/agent-runtime";
-import { AgentHarnessPreflightError as AgentHarnessPreflightError$1, embeddedAgentLog as embeddedAgentLog$1, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AgentHarnessPreflightError as AgentHarnessPreflightError$1, embeddedAgentLog as embeddedAgentLog$1, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { hasUsableOAuthCredential, resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
-import { assertNoSymlinkParents } from "openclaw/plugin-sdk/security-runtime";
+import { assertDirectoryIdentitySync, readDirectoryIdentity } from "@openclaw/fs-safe/advanced";
+import { assertNoSymlinkParents, pathScope } from "openclaw/plugin-sdk/security-runtime";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 //#region extensions/codex/src/app-server/attempt-timeouts.ts
-/**
-* Timeout defaults and normalizers for Codex app-server startup and turn
-* liveness watches.
-*/
-/** Minimum startup timeout accepted by the Codex app-server harness. */
 const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;
 const TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS = 12e4;
 const TURN_FINALIZE_DRAIN_ABORT_GRACE_MS = 5e3;
@@ -51,7 +56,6 @@ function resolvePositiveIntegerTimeoutMs(value, fallbackMs) {
 	const fallback = resolveTimerTimeoutMs(fallbackMs, 1);
 	return resolveTimerTimeoutMs(value, fallback);
 }
-/** Runs startup work with abort and timeout handling plus optional cleanup. */
 async function withCodexStartupTimeout(params) {
 	if (params.signal.aborted) throw new CodexAppServerStartupError("aborted");
 	let timeout;
@@ -89,13 +93,11 @@ async function withCodexStartupTimeout(params) {
 		abortCleanup?.();
 	}
 }
-/** Resolves startup timeout while honoring the configured floor. */
 function resolveCodexStartupTimeoutMs(params) {
 	const timeoutFloorMs = resolvePositiveIntegerTimeoutMs(params.timeoutFloorMs, CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS);
 	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
 	return Math.max(timeoutFloorMs, timeoutMs);
 }
-/** Adds gateway grace time to a caller timeout without overflowing invalid values. */
 function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
 	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
 	const grace = resolveTimerTimeoutMs(graceMs, 0, 0);
@@ -166,17 +168,16 @@ async function assertOwnedCodexHomePath(params) {
 }
 async function readRealDirectoryIdentity(directoryPath, label) {
 	const logicalPath = path.resolve(directoryPath);
-	const before = await fs$1.lstat(logicalPath);
-	if (before.isSymbolicLink() || !before.isDirectory()) throw new Error(`${label} must be a real directory: ${logicalPath}`);
-	const realPath = await fs$1.realpath(logicalPath);
-	const [after, resolved] = await Promise.all([fs$1.lstat(logicalPath), fs$1.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 {
-		logicalPath,
-		realPath,
-		dev: after.dev,
-		ino: after.ino
-	};
+	try {
+		const identity = await readDirectoryIdentity(logicalPath);
+		assertDirectoryIdentitySync(logicalPath, identity);
+		return {
+			logicalPath,
+			...identity
+		};
+	} catch (cause) {
+		throw new Error(`${label} must remain a real directory: ${logicalPath}`, { cause });
+	}
 }
 async function assertOwnedServiceParentStable(parent) {
 	await assertDirectoryIdentityStable(parent, "Computer Use service parent");
@@ -184,14 +185,10 @@ async function assertOwnedServiceParentStable(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$1.lstat(expected.logicalPath);
-		if (current.isSymbolicLink() || !current.isDirectory() || current.dev !== expected.dev || current.ino !== expected.ino) return false;
-		return await fs$1.realpath(expected.logicalPath) === expected.realPath;
+		assertDirectoryIdentitySync(expected.logicalPath, expected);
+		return true;
 	} catch {
 		return false;
 	}
@@ -200,7 +197,7 @@ async function assertNotSymlink(filePath, label) {
 	try {
 		if ((await fs$1.lstat(filePath)).isSymbolicLink()) throw new Error(`${label} must not be a symbolic link: ${filePath}`);
 	} catch (error) {
-		if (hasNodeErrorCode$1(error, "ENOENT")) return;
+		if (extractErrorCode(error) === "ENOENT") return;
 		throw error;
 	}
 }
@@ -208,84 +205,43 @@ 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$1.lstat(current).catch((error) => {
-			if (hasNodeErrorCode$1(error, "ENOENT")) return;
-			throw error;
-		});
-		if (!existing) {
-			try {
-				await fs$1.mkdir(current, { mode: 448 });
-			} catch (error) {
-				if (!hasNodeErrorCode$1(error, "EEXIST")) throw error;
-			}
-			const created = await fs$1.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}`);
+	if (root !== target) {
+		const prepared = await pathScope(root, { label }).ensureDir(`${target}${path.sep}`, { mode: 448 });
+		if (!prepared.ok) throw new Error(`${label} must traverse real directories: ${prepared.error}`, { cause: prepared.diagnostic });
 	}
-	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
 /** Shared Computer Use plugin cache reconciliation for isolated Codex homes. */
 const DEFAULT_CODEX_COMPUTER_USE_BUNDLED_MARKETPLACE_PATH = resolveMacOSDesktopCodexBundledMarketplaceCandidates("darwin")[0] ?? "";
 const DEFAULT_BUNDLED_MARKETPLACE_NAME = "openai-bundled";
 async function ensureCodexComputerUseSharedPluginCache(params) {
-	if (!params.config.enabled) return skippedCacheResult("disabled", "Computer Use cache sharing skipped because it is disabled.");
-	if (params.config.pluginCacheMode === "independent") return skippedCacheResult("independent", "Computer Use cache sharing skipped because pluginCacheMode is independent.");
-	if (params.config.marketplaceName || params.config.marketplacePath) return skippedCacheResult("explicit_marketplace", "Computer Use cache sharing skipped because an explicit marketplace is configured.");
+	if (!params.config.enabled || params.config.pluginCacheMode === "independent" || params.config.marketplaceName || params.config.marketplacePath) return false;
 	const bundledMarketplacePath = resolveComputerUseBundledMarketplacePath(params);
 	const sourcePluginRoot = path.join(bundledMarketplacePath, "plugins", params.config.pluginName);
 	const version = await readBundledPluginVersion(sourcePluginRoot);
-	if (!version) return skippedCacheResult("source_missing", `Computer Use bundled plugin source was not found at ${sourcePluginRoot}.`);
-	const marketplaceName = params.config.marketplaceName ?? DEFAULT_BUNDLED_MARKETPLACE_NAME;
-	const cacheRoot = path.join(params.codexHome, "plugins", "cache", marketplaceName, params.config.pluginName);
-	const cachePath = path.join(cacheRoot, version);
-	return {
-		status: "shared",
-		changed: await ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, {
-			codexHome: params.codexHome,
-			ownershipRoot: params.ownershipRoot,
-			assertCurrent: params.assertCurrent,
-			forceRefresh: params.forceRefresh
-		}),
-		cachePath,
-		targetPath: sourcePluginRoot,
-		version,
-		removedStaleVersions: [],
-		warnings: [],
-		message: `Computer Use plugin cache ${cachePath} contains bundled plugin ${sourcePluginRoot}.`
-	};
+	if (!version) return false;
+	const cacheRoot = path.join(params.codexHome, "plugins", "cache", params.config.marketplaceName ?? DEFAULT_BUNDLED_MARKETPLACE_NAME, params.config.pluginName);
+	await ensureRealDirectoryCopy(path.join(cacheRoot, version), sourcePluginRoot, version, {
+		codexHome: params.codexHome,
+		ownershipRoot: params.ownershipRoot,
+		assertCurrent: params.assertCurrent,
+		forceRefresh: params.forceRefresh
+	});
+	return true;
 }
 function resolveComputerUseBundledMarketplacePath(params) {
 	return params.bundledMarketplacePath ?? resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath({ candidates: params.bundledMarketplacePathCandidates }) ?? params.bundledMarketplacePathCandidates?.[0] ?? DEFAULT_CODEX_COMPUTER_USE_BUNDLED_MARKETPLACE_PATH;
 }
 async function readBundledPluginVersion(sourcePluginRoot) {
 	const pluginJsonPath = path.join(sourcePluginRoot, ".codex-plugin", "plugin.json");
-	let raw;
-	try {
-		raw = await fs$1.readFile(pluginJsonPath, "utf8");
-	} catch {
-		return;
-	}
 	try {
+		const raw = await fs$1.readFile(pluginJsonPath, "utf8");
 		const parsed = JSON.parse(raw);
 		return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : void 0;
 	} catch {
@@ -303,7 +259,13 @@ async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, bou
 	const physicalCachePath = ownedParent ? path.join(ownedParent.realPath, path.basename(cachePath)) : cachePath;
 	const stat = await fs$1.lstat(physicalCachePath).catch(() => void 0);
 	if (stat?.isDirectory() && !stat.isSymbolicLink()) {
-		if (await readBundledPluginVersion(physicalCachePath) === version && !boundary.forceRefresh) return false;
+		if (await readBundledPluginVersion(physicalCachePath) === version && !boundary.forceRefresh) {
+			const [cachedMcp, sourceMcp] = await Promise.all([physicalCachePath, sourcePluginRoot].map(async (root) => fs$1.readFile(path.join(root, ".mcp.json"), "utf8").catch((error) => {
+				if (extractErrorCode(error) === "ENOENT") return;
+				throw error;
+			})));
+			if (cachedMcp === sourceMcp) return;
+		}
 	}
 	const cacheName = path.basename(cachePath);
 	const physicalCacheRoot = path.dirname(physicalCachePath);
@@ -312,7 +274,8 @@ async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, bou
 	const backupPath = path.join(physicalCacheRoot, `.${cacheName}.backup-${process.pid}-${Date.now()}`);
 	let backupCreated = false;
 	try {
-		await fs$1.cp(sourcePluginRoot, stagedPath, { recursive: true });
+		const physicalSourceRoot = await fs$1.realpath(sourcePluginRoot);
+		await fs$1.cp(physicalSourceRoot, stagedPath, { recursive: true });
 		await waitForCodexDesktopGeneration();
 		if (ownedParent) await assertDirectoryIdentityStable(ownedParent, "Computer Use plugin cache parent");
 		if (stat) {
@@ -341,7 +304,6 @@ async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, bou
 				force: true
 			});
 		}
-		return true;
 	} finally {
 		if (!ownedParent || await directoryIdentityIsStable(ownedParent)) await fs$1.rm(stagingRoot, {
 			recursive: true,
@@ -349,19 +311,148 @@ async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, bou
 		});
 	}
 }
-function skippedCacheResult(status, message) {
+//#endregion
+//#region extensions/codex/src/app-server/computer-use-unified.ts
+/** Materializes the desktop-owned unified MCP template for an isolated Computer Use home. */
+const UNIFIED_COMPUTER_USE_PLUGIN = "unified-computer-use";
+const UNIFIED_SERVER = "cua_repl";
+const CUA_REPL_ENTRY = "@oai/cua/tinyskyAlt";
+/** The selected desktop distribution owns both the plugin and its executable dependencies. */
+async function resolveCodexUnifiedComputerUseRuntime(candidate, codexHome, requestedPluginName, requestedServerName) {
+	const pluginName = requestedPluginName ?? "computer-use";
+	const serverName = requestedServerName ?? pluginName;
+	if (!(pluginName === "computer-use" && serverName === "computer-use") && !(pluginName === "unified-computer-use" && serverName === UNIFIED_SERVER)) return;
+	if ((await readObject(path.join(candidate.bundledMarketplacePath, "plugins", "computer-use", ".codex-plugin", "plugin.json")))?.mcpServers && requestedPluginName !== "unified-computer-use") return;
+	const pluginRoot = path.join(candidate.bundledMarketplacePath, "plugins", UNIFIED_COMPUTER_USE_PLUGIN);
+	const manifest = await readObject(path.join(pluginRoot, ".codex-plugin", "plugin.json"));
+	if (!manifest || manifest.name !== "unified-computer-use" || manifest.mcpServers !== "./.mcp.json") return;
+	const template = await readObject(path.join(pluginRoot, ".mcp.json"));
+	const servers = template?.mcpServers;
+	const server = isRecord(servers) ? servers[UNIFIED_SERVER] : void 0;
+	if (!template || !isRecord(servers) || !isRecord(server)) throw new Error("The selected desktop's unified Computer Use MCP template is invalid.");
+	const runtimeRoot = path.join(candidate.appBundlePath, "Contents", "Resources", "cua_node");
+	const modules = path.join(runtimeRoot, "lib", "node_modules");
+	const node = path.join(runtimeRoot, "bin", "node");
+	const nodeRepl = path.join(runtimeRoot, "bin", "node_repl");
+	const launcher = path.join(modules, "@oai", "cua-repl", "bin", "cua-repl.mjs");
+	const cuaRoot = path.join(modules, "@oai", "cua");
+	const cuaPackage = await readObject(path.join(cuaRoot, "package.json"));
+	const cuaEntry = isRecord(cuaPackage?.exports) ? cuaPackage.exports["./tinyskyAlt"] : void 0;
+	try {
+		if (typeof cuaEntry !== "string" || !cuaEntry.startsWith("./") || path.relative(cuaRoot, path.resolve(cuaRoot, cuaEntry)).startsWith("..")) throw new Error("The desktop CUA package does not expose its unified entry point.");
+		await Promise.all([
+			fs$1.access(node, constants.X_OK),
+			fs$1.access(nodeRepl, constants.X_OK),
+			fs$1.access(launcher, constants.R_OK),
+			fs$1.access(path.join(modules, "@oai", "sky", "package.json"), constants.R_OK),
+			fs$1.access(path.resolve(cuaRoot, cuaEntry), constants.R_OK)
+		]);
+	} catch (cause) {
+		throw new Error("The selected desktop's unified Computer Use runtime is incomplete.", { cause });
+	}
 	return {
-		status,
-		changed: false,
-		message,
-		removedStaleVersions: [],
-		warnings: status === "source_missing" ? [message] : []
+		pluginRoot,
+		sourceFingerprint: await readCodexDesktopArtifactTreeFingerprint(pluginRoot),
+		manifest,
+		mcp: {
+			...template,
+			mcpServers: {
+				...servers,
+				[UNIFIED_SERVER]: {
+					...server,
+					command: node,
+					args: [launcher],
+					enabled: true,
+					env_vars: [],
+					env: {
+						CODEX_HOME: codexHome,
+						CUA_REPL_NODE_REPL_PATH: nodeRepl,
+						CUA_REPL_ENABLED_SURFACES: "computer",
+						NODE_REPL_NODE_PATH: node,
+						NODE_REPL_NODE_MODULE_DIRS: modules,
+						NODE_REPL_TRUSTED_CODE_PATHS: [codexHome, modules].join(path.delimiter),
+						NODE_REPL_TRUSTED_SERVICES: JSON.stringify({ sky: "@oai/sky/service" }),
+						NODE_REPL_JS_BANNER: `await import(${JSON.stringify(CUA_REPL_ENTRY)});`,
+						SKY_CUA_SERVICE_PATH: path.join(codexHome, "computer-use", "Codex Computer Use.app")
+					}
+				}
+			}
+		}
+	};
+}
+async function publishCodexUnifiedComputerUsePlugin(target, runtime) {
+	const templatePath = path.join(runtime.pluginRoot, ".mcp.json");
+	await fs$1.cp(runtime.pluginRoot, target, {
+		recursive: true,
+		filter: (source) => source !== templatePath
+	});
+	await fs$1.writeFile(path.join(target, ".mcp.json"), `${JSON.stringify(runtime.mcp, null, 2)}\n`, { mode: 384 });
+}
+async function codexUnifiedComputerUsePluginMatches(target, runtime) {
+	return isDeepStrictEqual(await readObject(path.join(target, ".codex-plugin", "plugin.json")), runtime.manifest) && isDeepStrictEqual(await readObject(path.join(target, ".mcp.json")), runtime.mcp);
+}
+/** Preserve custom identities and legacy desktops; the legacy default follows its replacement. */
+async function resolveManagedCodexComputerUseConfig(config, marketplacePath) {
+	if (!marketplacePath || config.marketplaceSource || config.marketplaceName || config.marketplacePath || config.pluginName !== "computer-use" || config.mcpServerName !== "computer-use") return config;
+	const plugins = path.join(marketplacePath, "plugins");
+	const legacy = await readObject(path.join(plugins, "computer-use", ".codex-plugin", "plugin.json"));
+	if (!legacy || legacy.mcpServers) return config;
+	const unified = await readObject(path.join(plugins, UNIFIED_COMPUTER_USE_PLUGIN, ".codex-plugin", "plugin.json"));
+	const mcp = await readObject(path.join(plugins, UNIFIED_COMPUTER_USE_PLUGIN, ".mcp.json"));
+	const server = isRecord(mcp?.mcpServers) ? mcp.mcpServers[UNIFIED_SERVER] : void 0;
+	if (unified?.name !== "unified-computer-use" || !isRecord(server) || server.enabled !== true) return config;
+	return {
+		...config,
+		pluginName: UNIFIED_COMPUTER_USE_PLUGIN,
+		mcpServerName: UNIFIED_SERVER
 	};
 }
+/** A native plugin disable veto must survive an automatic identity replacement. */
+function isLegacyCodexComputerUsePluginDisabled(config) {
+	const plugin = isRecord(config) && isRecord(config.plugins) ? config.plugins["computer-use@openai-bundled"] : void 0;
+	return isRecord(plugin) && plugin.enabled === false;
+}
+/** Renaming a server must not discard an operator's legacy server or tool restrictions. */
+function hasLegacyCodexComputerUseMcpPolicy(config) {
+	if (!isRecord(config)) return false;
+	if (isRecord(config.mcp_servers) && Object.hasOwn(config.mcp_servers, "computer-use")) return true;
+	const plugin = isRecord(config.plugins) ? config.plugins["computer-use@openai-bundled"] : void 0;
+	return isRecord(plugin) && isRecord(plugin.mcp_servers) && Object.keys(plugin.mcp_servers).length > 0;
+}
+async function readObject(file) {
+	try {
+		const value = JSON.parse(await fs$1.readFile(file, "utf8"));
+		return isRecord(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/** Publish the cache from the same prepared source that native plugin/install consumes. */
+async function reconcileManagedCodexComputerUseCache(params) {
+	const config = params.config;
+	params.assertCurrent();
+	const bundledMarketplacePath = params.managedMarketplacePath ?? params.bundledMarketplacePath;
+	const cacheBinding = [
+		params.epoch ?? "manual",
+		bundledMarketplacePath ?? "default",
+		config.pluginName
+	].join("\0");
+	const shared = await ensureCodexComputerUseSharedPluginCache({
+		codexHome: params.codexHome,
+		config,
+		...params.ownershipRoot ? { ownershipRoot: params.ownershipRoot } : {},
+		...bundledMarketplacePath ? { bundledMarketplacePath } : {},
+		assertCurrent: params.assertCurrent,
+		forceRefresh: params.forceRefresh === true || params.previousCacheBinding !== cacheBinding
+	});
+	params.assertCurrent();
+	return shared ? cacheBinding : void 0;
+}
 //#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 UNIFIED_SOURCE_FINGERPRINT = ".openclaw-unified-source-fingerprint";
 const activeInstalls$1 = /* @__PURE__ */ new Map();
 function resolveCodexManagedBundledMarketplacePath(codexHome) {
 	return path.join(codexHome, ".tmp", "bundled-marketplaces", MARKETPLACE_NAME);
@@ -373,6 +464,7 @@ async function ensureCodexManagedBundledMarketplace(params) {
 		candidates
 	});
 	if (!source) return;
+	const unifiedRuntime = await resolveCodexUnifiedComputerUseRuntime(source, params.codexHome, params.computerUsePluginName, params.computerUseMcpServerName);
 	const parentPath = path.dirname(resolveCodexManagedBundledMarketplacePath(params.codexHome));
 	const targetPath = path.join(parentPath, MARKETPLACE_NAME);
 	const parent = await prepareOwnedServiceParent({
@@ -388,11 +480,12 @@ async function ensureCodexManagedBundledMarketplace(params) {
 		await active.promise.catch(() => void 0);
 		return await ensureCodexManagedBundledMarketplace(params);
 	}
-	const install = reconcileManagedWrapper({
+	const install = publishManagedWrapper({
 		parent,
 		physicalTargetPath,
 		targetPath,
 		source,
+		unifiedRuntime,
 		ownershipCandidates: params.ownershipCandidates ?? candidates,
 		assertCurrent: params.assertCurrent
 	});
@@ -407,12 +500,9 @@ async function ensureCodexManagedBundledMarketplace(params) {
 	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;
+	if (await wrapperMatches(physicalTargetPath, source.bundledMarketplacePath, params.unifiedRuntime)) return targetPath;
 	const stagingPath = await fs$1.mkdtemp(path.join(parent.realPath, `.${MARKETPLACE_NAME}.staging-`));
 	const backupPath = path.join(parent.realPath, `.${MARKETPLACE_NAME}.backup-${process.pid}-${Date.now()}`);
 	let backupCreated = false;
@@ -422,10 +512,22 @@ async function publishManagedWrapper(params) {
 			recursive: true,
 			mode: 448
 		});
-		await Promise.all([fs$1.symlink(path.join(source.bundledMarketplacePath, ".agents", "plugins", "marketplace.json"), path.join(manifestParent, "marketplace.json")), fs$1.symlink(path.join(source.bundledMarketplacePath, "plugins"), path.join(stagingPath, "plugins"))]);
+		await fs$1.symlink(path.join(source.bundledMarketplacePath, ".agents", "plugins", "marketplace.json"), path.join(manifestParent, "marketplace.json"));
+		if (params.unifiedRuntime) {
+			const pluginsPath = path.join(stagingPath, "plugins");
+			await fs$1.mkdir(pluginsPath);
+			for (const entry of await fs$1.readdir(path.join(source.bundledMarketplacePath, "plugins"))) {
+				const target = path.join(pluginsPath, entry);
+				if (entry === "unified-computer-use") await publishCodexUnifiedComputerUsePlugin(target, params.unifiedRuntime);
+				else await fs$1.symlink(path.join(source.bundledMarketplacePath, "plugins", entry), target);
+			}
+			await fs$1.writeFile(path.join(stagingPath, UNIFIED_SOURCE_FINGERPRINT), params.unifiedRuntime.sourceFingerprint, { mode: 384 });
+		} else await fs$1.symlink(path.join(source.bundledMarketplacePath, "plugins"), path.join(stagingPath, "plugins"));
+		await waitForCodexDesktopGeneration();
+		assertCurrent?.();
 		await assertDirectoryIdentityStable(parent, "managed bundled marketplace parent");
 		const existing = await fs$1.lstat(physicalTargetPath).catch((error) => {
-			if (hasNodeErrorCode(error, "ENOENT")) return;
+			if (extractErrorCode(error) === "ENOENT") return;
 			throw error;
 		});
 		if (existing && !existing.isDirectory()) throw new Error(`Managed bundled marketplace must be a real directory: ${targetPath}`);
@@ -448,7 +550,7 @@ async function publishManagedWrapper(params) {
 		if (backupCreated) try {
 			await assertDirectoryIdentityStable(parent, "managed bundled marketplace parent");
 			if (await fs$1.lstat(physicalTargetPath).catch(() => void 0)) {
-				if (!await wrapperMatches(physicalTargetPath, source.bundledMarketplacePath)) throw new Error("managed bundled marketplace replacement is no longer owned", { cause: error });
+				if (!await wrapperOwnedBySource(physicalTargetPath, source.bundledMarketplacePath)) throw new Error("managed bundled marketplace replacement is no longer owned", { cause: error });
 				await fs$1.rm(physicalTargetPath, { recursive: true });
 			}
 			await fs$1.rename(backupPath, physicalTargetPath);
@@ -479,22 +581,51 @@ async function isExpectedMarketplace(root) {
 		return false;
 	}
 }
-async function wrapperMatches(targetPath, sourcePath) {
+async function wrapperMatches(targetPath, sourcePath, unifiedRuntime) {
+	if (!await wrapperOwnedBySource(targetPath, sourcePath)) return false;
+	const plugins = await fs$1.lstat(path.join(targetPath, "plugins"));
+	if (unifiedRuntime && plugins.isDirectory()) {
+		const [sourceEntries, targetEntries] = await Promise.all([fs$1.readdir(path.join(sourcePath, "plugins")), fs$1.readdir(path.join(targetPath, "plugins"))]);
+		const sourceNames = new Set(sourceEntries);
+		if (sourceNames.size !== targetEntries.length || targetEntries.some((name) => !sourceNames.has(name))) return false;
+	}
+	return unifiedRuntime ? plugins.isDirectory() && await fs$1.readFile(path.join(targetPath, UNIFIED_SOURCE_FINGERPRINT), "utf8").catch(() => void 0) === unifiedRuntime.sourceFingerprint && await codexUnifiedComputerUsePluginMatches(path.join(targetPath, "plugins", "unified-computer-use"), unifiedRuntime) : plugins.isSymbolicLink();
+}
+async function wrapperOwnedBySource(targetPath, sourcePath) {
 	try {
 		const target = await fs$1.lstat(targetPath);
 		if (!target.isDirectory() || target.isSymbolicLink()) return false;
-		const [manifest, plugins] = await Promise.all([fs$1.readlink(path.join(targetPath, ".agents", "plugins", "marketplace.json")), fs$1.readlink(path.join(targetPath, "plugins"))]);
-		return manifest === path.join(sourcePath, ".agents", "plugins", "marketplace.json") && plugins === path.join(sourcePath, "plugins");
+		if (await fs$1.readlink(path.join(targetPath, ".agents", "plugins", "marketplace.json")) !== path.join(sourcePath, ".agents", "plugins", "marketplace.json")) return false;
+		const pluginsPath = path.join(targetPath, "plugins");
+		const plugins = await fs$1.lstat(pluginsPath);
+		if (plugins.isSymbolicLink()) return await fs$1.readlink(pluginsPath) === path.join(sourcePath, "plugins");
+		if (!plugins.isDirectory()) return false;
+		let hasUnifiedPlugin = false;
+		for (const entry of await fs$1.readdir(pluginsPath, { withFileTypes: true })) if (entry.name === "unified-computer-use" && entry.isDirectory()) {
+			const plugin = JSON.parse(await fs$1.readFile(path.join(pluginsPath, entry.name, ".codex-plugin", "plugin.json"), "utf8"));
+			if (!isRecord(plugin) || plugin.name !== "unified-computer-use") return false;
+			hasUnifiedPlugin = true;
+		} else if (!entry.isSymbolicLink() || await fs$1.readlink(path.join(pluginsPath, entry.name)) !== path.join(sourcePath, "plugins", entry.name)) return false;
+		return hasUnifiedPlugin;
 	} catch {
 		return false;
 	}
 }
 async function wrapperMatchesAnySource(targetPath, candidates) {
-	for (const candidate of candidates) if (await wrapperMatches(targetPath, candidate.bundledMarketplacePath)) return true;
+	for (const candidate of candidates) if (await wrapperOwnedBySource(targetPath, candidate.bundledMarketplacePath)) return true;
 	return false;
 }
-function hasNodeErrorCode(error, code) {
-	return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+async function resolveClientManagedBundledMarketplacePath(codexHome, agentDir) {
+	if (!codexHome || !agentDir) return;
+	const [actualRealHome, expectedRealHome] = await Promise.all([fs$1.realpath(codexHome).catch(() => void 0), fs$1.realpath(resolveCodexAppServerHomeDir(agentDir)).catch(() => void 0)]);
+	if (!actualRealHome || actualRealHome !== expectedRealHome) return;
+	const managedPath = resolveCodexManagedBundledMarketplacePath(codexHome);
+	return existsSync(managedPath) ? managedPath : void 0;
+}
+function resolveBundledComputerUseMarketplacePath(params) {
+	if (params.defaultBundledMarketplacePath) return existsSync(params.defaultBundledMarketplacePath) ? params.defaultBundledMarketplacePath : void 0;
+	if (!params.defaultBundledMarketplacePathCandidates) return;
+	return resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath({ candidates: params.defaultBundledMarketplacePathCandidates });
 }
 //#endregion
 //#region extensions/codex/src/app-server/computer-use-service.ts
@@ -546,7 +677,6 @@ async function ensureCodexComputerUseServiceApp(params) {
 		ownershipRoot,
 		targetParent,
 		targetPath,
-		platform,
 		sourceAppCandidates: candidates
 	});
 	const activeEntry = {
@@ -562,13 +692,20 @@ async function ensureCodexComputerUseServiceApp(params) {
 }
 async function ensureCodexComputerUseServiceAppOnce(params) {
 	const inspectServiceApp = params.inspectServiceApp ?? inspectTrustedServiceApp;
-	const source = await findUsableServiceApp(params.sourceAppCandidates ?? [], inspectServiceApp);
+	const source = await findUsableServiceApp(params.sourceAppCandidates, inspectServiceApp);
 	if (!source) return {
 		status: "source_missing",
 		changed: false,
 		targetPath: params.targetPath
 	};
 	const { path: sourcePath, identity: sourceIdentity } = source;
+	const alreadyCurrent = {
+		status: "already_current",
+		changed: false,
+		targetPath: params.targetPath,
+		sourcePath,
+		sourceBuild: sourceIdentity.build
+	};
 	const ownedParent = await prepareOwnedServiceParent({
 		ownershipRoot: params.ownershipRoot,
 		codexHome: params.codexHome,
@@ -577,19 +714,29 @@ async function ensureCodexComputerUseServiceAppOnce(params) {
 	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,
-		sourcePath,
-		sourceBuild: sourceIdentity.build
-	};
+	if (initialTarget.identity && identitiesMatch(initialTarget.identity, sourceIdentity)) return alreadyCurrent;
 	await assertOwnedServiceParentStable(ownedParent);
 	const stagingRoot = await fs$1.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(ownedParent.realPath, `.service-app.backup-${process.pid}-${Date.now()}`);
 	let backupCreated = false;
+	const restoreBackup = async () => {
+		await assertOwnedServiceParentStable(ownedParent);
+		await fs$1.rename(backupPath, operationTargetPath);
+		await assertOwnedServiceParentStable(ownedParent);
+		backupCreated = false;
+	};
+	const removeBackup = async () => {
+		await assertOwnedServiceParentStable(ownedParent);
+		await assertNotSymlink(backupPath, "Computer Use service backup");
+		await fs$1.rm(backupPath, {
+			recursive: true,
+			force: true
+		});
+		await assertOwnedServiceParentStable(ownedParent);
+		backupCreated = false;
+	};
 	try {
 		await (params.copyServiceApp ?? copyServiceAppWithDitto)(sourcePath, stagedPath);
 		await assertOwnedServiceParentStable(ownedParent);
@@ -612,23 +759,11 @@ async function ensureCodexComputerUseServiceAppOnce(params) {
 			backupCreated = true;
 			const movedTarget = await readServiceAppSnapshot(backupPath, inspectServiceApp);
 			if (movedTarget.identity && identitiesMatch(movedTarget.identity, sourceIdentity)) {
-				await assertOwnedServiceParentStable(ownedParent);
-				await fs$1.rename(backupPath, operationTargetPath);
-				await assertOwnedServiceParentStable(ownedParent);
-				backupCreated = false;
-				return {
-					status: "already_current",
-					changed: false,
-					targetPath: params.targetPath,
-					sourcePath,
-					sourceBuild: sourceIdentity.build
-				};
+				await restoreBackup();
+				return alreadyCurrent;
 			}
 			if (!snapshotsMatch(initialTarget, movedTarget)) {
-				await assertOwnedServiceParentStable(ownedParent);
-				await fs$1.rename(backupPath, operationTargetPath);
-				await assertOwnedServiceParentStable(ownedParent);
-				backupCreated = false;
+				await restoreBackup();
 				throw new Error("Computer Use service target changed to an unexpected generation during refresh.");
 			}
 		}
@@ -642,33 +777,11 @@ async function ensureCodexComputerUseServiceAppOnce(params) {
 			await assertNotSymlink(operationTargetPath, "Computer Use service target");
 			const winnerIdentity = await inspectServiceApp(operationTargetPath);
 			if (!winnerIdentity || !identitiesMatch(winnerIdentity, sourceIdentity)) {
-				if (backupCreated) {
-					if (!await pathExists$1(operationTargetPath)) {
-						await assertOwnedServiceParentStable(ownedParent);
-						await fs$1.rename(backupPath, operationTargetPath);
-						await assertOwnedServiceParentStable(ownedParent);
-						backupCreated = false;
-					}
-				}
+				if (backupCreated && !await pathExists$1(operationTargetPath)) await restoreBackup();
 				throw error;
 			}
-			if (backupCreated) {
-				await assertOwnedServiceParentStable(ownedParent);
-				await assertNotSymlink(backupPath, "Computer Use service backup");
-				await fs$1.rm(backupPath, {
-					recursive: true,
-					force: true
-				});
-				await assertOwnedServiceParentStable(ownedParent);
-				backupCreated = false;
-			}
-			return {
-				status: "already_current",
-				changed: false,
-				targetPath: params.targetPath,
-				sourcePath,
-				sourceBuild: sourceIdentity.build
-			};
+			if (backupCreated) await removeBackup();
+			return alreadyCurrent;
 		}
 		await assertNotSymlink(operationTargetPath, "Installed Computer Use service app");
 		const installedSnapshot = await readServiceAppSnapshot(operationTargetPath, inspectServiceApp);
@@ -688,16 +801,7 @@ async function ensureCodexComputerUseServiceAppOnce(params) {
 			}
 			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$1.rm(backupPath, {
-				recursive: true,
-				force: true
-			});
-			await assertOwnedServiceParentStable(ownedParent);
-			backupCreated = false;
-		}
+		if (backupCreated) await removeBackup();
 		return {
 			status: initialTarget.exists ? "refreshed" : "installed",
 			changed: true,
@@ -707,14 +811,14 @@ async function ensureCodexComputerUseServiceAppOnce(params) {
 			...initialTarget.identity ? { previousBuild: initialTarget.identity.build } : {}
 		};
 	} catch (error) {
-		if (backupCreated && await ownedServiceParentIsStable(ownedParent) && !await pathExists$1(operationTargetPath)) {
+		if (backupCreated && await directoryIdentityIsStable(ownedParent) && !await pathExists$1(operationTargetPath)) {
 			await assertOwnedServiceParentStable(ownedParent);
 			await fs$1.rename(backupPath, operationTargetPath);
 			backupCreated = false;
 		}
 		throw error;
 	} finally {
-		if (await ownedServiceParentIsStable(ownedParent) && await directoryIdentityIsStable(stagingRootIdentity)) await fs$1.rm(stagingRoot, {
+		if (await directoryIdentityIsStable(ownedParent) && await directoryIdentityIsStable(stagingRootIdentity)) await fs$1.rm(stagingRoot, {
 			recursive: true,
 			force: true
 		});
@@ -761,18 +865,10 @@ function filesystemSnapshotsMatch(left, right) {
 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 {
-		await fs$1.access(path.join(appPath, CLIENT_RELATIVE_PATH), constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
 async function inspectTrustedServiceApp(appPath) {
-	if (!await hasExecutableClient(appPath)) return;
 	const clientAppPath = path.join(appPath, CLIENT_APP_RELATIVE_PATH);
 	try {
+		await fs$1.access(path.join(appPath, CLIENT_RELATIVE_PATH), constants.X_OK);
 		await verifyTrustedBundle(appPath, SERVICE_BUNDLE_ID, true);
 		await verifyTrustedBundle(clientAppPath, CLIENT_BUNDLE_ID, false);
 		const [info, serviceSignature, clientSignature] = await Promise.all([
@@ -880,7 +976,10 @@ const scopedOAuthRefreshQueues = /* @__PURE__ */ new WeakMap();
 async function bridgeCodexAppServerStartOptions(params) {
 	if (params.startOptions.transport !== "stdio") return params.startOptions;
 	const scopeStartOptions = () => withCodexHomeEnvironment(withEphemeralCodexAuthStore(params), params.agentDir);
-	if (params.preparedAuth) return withClearedEnvironmentVariables(await scopeStartOptions(), CODEX_APP_SERVER_PREPARED_AUTH_ENV_VARS);
+	if (params.preparedAuth) {
+		const scopedStartOptions = await scopeStartOptions();
+		return withClearedEnvironmentVariables(scopedStartOptions, CODEX_APP_SERVER_PREPARED_AUTH_ENV_VARS);
+	}
 	if (params.authProfileId === null) return scopeStartOptions();
 	const store = resolveCodexAppServerAuthProfileStore({
 		agentDir: params.agentDir,
@@ -913,8 +1012,7 @@ function resolveUnimportedAgentCodexAuthMessage(params) {
 	const targetAgentId = params.agentId?.trim() || "<agent-id>";
 	return `A Codex auth file exists at ${authPath}, but agent-scoped Codex runs use OpenClaw's auth store and do not read that file. Preview only that credential import with \`openclaw migrate plan codex --from <codex-home> --agent ${targetAgentId} --include-secrets --item auth:openai\`, then run \`openclaw migrate apply codex --from <codex-home> --agent ${targetAgentId} --include-secrets --item auth:openai --yes\`. If the plan finds no credentials, remove the stale auth file.`;
 }
-/** Resolves prepared profile login material once so cache identity and RPC login cannot drift. */
-async function resolveCodexAppServerPreparedAuthProfileSnapshot(params) {
+function resolveCodexAppServerAuthProfile(params) {
 	const agentDir = params.agentDir?.trim() || resolveDefaultAgentDir(params.config ?? {});
 	const store = resolveCodexAppServerAuthProfileStore({
 		agentDir,
@@ -929,7 +1027,33 @@ async function resolveCodexAppServerPreparedAuthProfileSnapshot(params) {
 	});
 	if (!profileId) return;
 	const credential = store.profiles[profileId];
-	if (!credential || !isCodexAppServerAuthProfileCredential(credential)) return;
+	if (!credential || !isCodexAppServerAuthProvider(credential.provider)) return;
+	return {
+		agentDir,
+		store,
+		profileId,
+		credential
+	};
+}
+/** Resolves prepared profile login material once so cache identity and RPC login cannot drift. */
+async function resolveCodexAppServerPreparedAuthProfileSnapshot(params) {
+	const profile = resolveCodexAppServerAuthProfile(params);
+	if (!profile) return;
+	const { agentDir, store, profileId, credential } = profile;
+	if (isCodexResponsesOAuthCredential(credential)) return {
+		inferenceAuth: "host-oauth",
+		loginParams: {
+			type: "apiKey",
+			apiKey: `openclaw-local-${randomUUID()}`
+		},
+		secretFreeCacheKey: await resolveCodexResponsesOAuthProfileFingerprint({
+			profileId,
+			store,
+			agentDir,
+			config: params.config
+		})
+	};
+	if (credential.type === "oauth" && credential.authFlow === "chatgpt-identity") throw new Error("ChatGPT subscription sharing was not granted; sign in again and enable sharing.");
 	const loginParams = await resolveCodexAppServerAuthProfileLoginParamsInternal({
 		agentDir,
 		authProfileId: profileId,
@@ -950,6 +1074,22 @@ async function resolveCodexAppServerPreparedAuthProfileSnapshot(params) {
 /** Maps one prepared route to one mutually exclusive app-server auth handoff. */
 async function resolveCodexAppServerPreparedAuthHandoff(params) {
 	const usesNativeHome = params.homeScope === "user";
+	const selectedCredential = params.authProfileId ? params.authProfileStore.profiles[params.authProfileId] : void 0;
+	if (isCodexResponsesOAuthCredential(selectedCredential)) {
+		if (usesNativeHome || params.requirePreparedAuth || params.authRequirement !== "api-key") throw new Error("ChatGPT subscription sharing requires the managed local Codex API route and an isolated home.");
+		const snapshot = await resolveCodexAppServerPreparedAuthProfileSnapshot(params);
+		if (!snapshot || !params.authProfileId) throw new Error("ChatGPT subscription sharing could not prepare the selected profile.");
+		return {
+			authProfileId: params.authProfileId,
+			nativeAuthProfile: false,
+			preparedAuth: {
+				kind: "profile",
+				profileId: params.authProfileId,
+				store: params.authProfileStore,
+				snapshot
+			}
+		};
+	}
 	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 (usesNativeHome) return { nativeAuthProfile: true };
 	if (params.authRequirement === "api-key") {
@@ -964,6 +1104,7 @@ async function resolveCodexAppServerPreparedAuthHandoff(params) {
 		};
 	}
 	const authProfileId = params.authProfileId?.trim() || void 0;
+	if (authProfileId && !params.authProfileStore.profiles[authProfileId]) throw new CodexAppServerAuthProfileUnavailableError(formatCodexAuthProfileUnavailableMessage(authProfileId));
 	const nativeAuthProfile = isCodexAppServerNativeAuthProfile({
 		authProfileId,
 		authProfileStore: params.authProfileStore,
@@ -994,38 +1135,19 @@ async function resolveCodexAppServerPreparedAuthHandoff(params) {
 	};
 }
 async function resolveCodexAppServerAuthAccountCacheKey(params) {
-	const agentDir = params.agentDir?.trim() || resolveDefaultAgentDir(params.config ?? {});
-	const store = resolveCodexAppServerAuthProfileStore({
-		agentDir,
-		authProfileId: params.authProfileId,
-		authProfileStore: params.authProfileStore,
-		config: params.config
-	});
-	const profileId = resolveCodexAppServerAuthProfileId({
-		authProfileId: params.authProfileId,
+	const profile = resolveCodexAppServerAuthProfile(params);
+	if (!profile) return;
+	const { agentDir, store, profileId, credential } = profile;
+	const accountId = resolveChatgptAccountId(profileId, credential);
+	if (credential.type === "oauth") return accountId;
+	const value = (await resolveApiKeyForProfile({
+		cfg: params.config,
 		store,
-		config: params.config
-	});
-	if (!profileId) return;
-	const credential = store.profiles[profileId];
-	if (!credential || !isCodexAppServerAuthProfileCredential(credential)) return;
-	if (credential.type === "api_key") {
-		const apiKey = (await resolveApiKeyForProfile({
-			store,
-			profileId,
-			agentDir
-		}))?.apiKey?.trim();
-		return apiKey ? `${resolveChatgptAccountId(profileId, credential)}:${fingerprintApiKeyAuthProfileCacheKey(apiKey)}` : resolveChatgptAccountId(profileId, credential);
-	}
-	if (credential.type === "token") {
-		const accessToken = (await resolveApiKeyForProfile({
-			store,
-			profileId,
-			agentDir
-		}))?.apiKey?.trim();
-		return accessToken ? `${resolveChatgptAccountId(profileId, credential)}:${fingerprintTokenAuthProfileCacheKey(accessToken)}` : resolveChatgptAccountId(profileId, credential);
-	}
-	return resolveChatgptAccountId(profileId, credential);
+		profileId,
+		agentDir
+	}))?.apiKey?.trim();
+	if (!value) return accountId;
+	return `${accountId}:${credential.type === "api_key" ? fingerprintApiKeyAuthProfileCacheKey(value) : fingerprintTokenAuthProfileCacheKey(value)}`;
 }
 async function withCodexHomeEnvironment(startOptions, agentDir) {
 	const codexHome = resolveCodexAppServerLocalHomeDir(startOptions, agentDir);
@@ -1107,12 +1229,15 @@ async function reconcileCodexComputerUseStartArtifactsOnce(params) {
 		needsBundledMarketplace
 	}) : exactDesktopCandidate;
 	params.assertCurrent();
+	let marketplacePath;
 	if (provisioningAgentDir) {
 		if (desktopCandidates.length > 0 && !artifactCandidate) throw new CodexComputerUseCandidateArtifactsUnavailableError();
 		try {
-			const marketplacePath = usesManagedBundledMarketplace ? await ensureCodexManagedBundledMarketplace({
+			marketplacePath = usesManagedBundledMarketplace ? await ensureCodexManagedBundledMarketplace({
 				codexHome,
 				ownershipRoot: provisioningAgentDir,
+				computerUsePluginName: computerUseConfig.pluginName,
+				computerUseMcpServerName: computerUseConfig.mcpServerName,
 				...artifactCandidate ? {
 					appServerCommand: artifactCandidate.appServerCommandPath,
 					candidates: [artifactCandidate],
@@ -1143,21 +1268,17 @@ async function reconcileCodexComputerUseStartArtifactsOnce(params) {
 		}
 	}
 	params.assertCurrent();
-	const cacheBinding = [
-		params.desktopGeneration?.epoch ?? "manual",
-		artifactCandidate?.bundledMarketplacePath ?? "default",
-		computerUseConfig.pluginName
-	].join("\0");
-	const cache = await ensureCodexComputerUseSharedPluginCache({
+	return await reconcileManagedCodexComputerUseCache({
 		codexHome,
 		config: computerUseConfig,
-		...ownsIsolatedCodexHome ? { ownershipRoot: params.agentDir } : {},
-		...artifactCandidate ? { bundledMarketplacePath: artifactCandidate.bundledMarketplacePath } : {},
+		ownershipRoot: ownsIsolatedCodexHome ? params.agentDir : void 0,
+		managedMarketplacePath: marketplacePath,
+		bundledMarketplacePath: artifactCandidate?.bundledMarketplacePath,
+		epoch: params.desktopGeneration?.epoch,
 		assertCurrent: params.assertCurrent,
-		forceRefresh: params.forceCacheRefresh === true || params.previousCacheBinding !== cacheBinding
+		forceRefresh: params.forceCacheRefresh,
+		previousCacheBinding: params.previousCacheBinding
 	});
-	params.assertCurrent();
-	return cache.status === "shared" ? cacheBinding : void 0;
 }
 async function resolveCompleteComputerUseArtifactCandidate(params) {
 	for (const candidate of params.candidates) {
@@ -1195,10 +1316,14 @@ async function applyCodexAppServerAuthProfile(params) {
 	let loginParams = params.preparedAuth?.kind === "profile" ? params.preparedAuth.snapshot.loginParams : params.preparedAuth?.kind === "api-key" ? {
 		type: "apiKey",
 		apiKey: params.preparedAuth.apiKey
-	} : await resolveCodexAppServerAuthProfileLoginParams({
+	} : await resolveCodexAppServerAuthProfileLoginParamsInternal({
 		agentDir,
 		authProfileId: params.authProfileId ?? void 0,
-		authProfileStore: params.authProfileStore,
+		authProfileStore: resolveCodexAppServerAuthProfileStore({
+			...params,
+			agentDir,
+			authProfileId: params.authProfileId ?? void 0
+		}),
 		config: params.config
 	});
 	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.");
@@ -1231,8 +1356,7 @@ async function applyCodexAppServerAuthProfile(params) {
 */
 async function assertNativeCodexAccountMatchesRoute(client, authRequirement, assertCurrent) {
 	if (!authRequirement) return;
-	const response = await client.request("account/read", { refreshToken: false }, { assertCurrent });
-	const accountType = isJsonObject(response.account) ? response.account.type : void 0;
+	const accountType = (await client.request("account/read", { refreshToken: false }, { assertCurrent })).account?.type;
 	if (authRequirement === "subscription") {
 		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;
@@ -1243,28 +1367,6 @@ 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 {
-	constructor(..._args) {
-		super(..._args);
-		this.status = 401;
-		this.code = "selected_auth_profile_unavailable";
-	}
-};
-async function resolveCodexAppServerAuthProfileLoginParams(params) {
-	const store = resolveCodexAppServerAuthProfileStore(params);
-	const profileId = resolveCodexAppServerAuthProfileId({
-		authProfileId: params.authProfileId,
-		store,
-		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. 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,
-		authProfileStore: store
-	});
-}
 async function refreshCodexAppServerAuthTokens(params) {
 	const previousAccountId = params.previousAccountId?.trim();
 	const handoffAccountId = params.authHandoff?.chatgptAccountId.trim();
@@ -1285,8 +1387,7 @@ async function refreshCodexAppServerAuthTokens(params) {
 		forceOAuthRefresh: true
 	});
 	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.");
-	if (params.authHandoff && loginParams.chatgptAccountId !== params.authHandoff.chatgptAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
+	if (previousAccountId && loginParams.chatgptAccountId !== previousAccountId || params.authHandoff && loginParams.chatgptAccountId !== params.authHandoff.chatgptAccountId) 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,
@@ -1307,8 +1408,8 @@ async function resolveCodexAppServerAuthProfileLoginParamsInternal(params) {
 	});
 	if (!profileId) return;
 	const credential = store.profiles[profileId];
-	if (!credential) 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 (!isCodexAppServerAuthProfileCredential(credential)) 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.`);
+	if (!credential) throw new CodexAppServerAuthProfileUnavailableError(formatCodexAuthProfileUnavailableMessage(profileId));
+	if (!isCodexAppServerAuthProvider(credential.provider)) 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.`);
 	const loginParams = await resolveLoginParamsForCredential(profileId, credential, {
 		agentDir: params.agentDir,
 		store,
@@ -1331,30 +1432,22 @@ async function resolveCodexAppServerFallbackApiKeyLoginParams(params) {
 	};
 }
 async function resolveLoginParamsForCredential(profileId, credential, params) {
-	if (credential.type === "api_key") {
-		const apiKey = (await resolveApiKeyForProfile({
+	if (credential.type === "api_key" || credential.type === "token") {
+		const value = (await resolveApiKeyForProfile({
+			cfg: params.config,
 			store: params.preferStoreCredential ? params.store : ensureAuthProfileStore(params.agentDir, {
 				allowKeychainPrompt: false,
-				profileId
+				profileId,
+				config: params.config
 			}),
 			profileId,
 			agentDir: params.agentDir
 		}))?.apiKey?.trim();
-		return apiKey ? {
+		if (!value) return;
+		return credential.type === "api_key" ? {
 			type: "apiKey",
-			apiKey
-		} : void 0;
-	}
-	if (credential.type === "token") {
-		const accessToken = (await resolveApiKeyForProfile({
-			store: params.preferStoreCredential ? params.store : ensureAuthProfileStore(params.agentDir, {
-				allowKeychainPrompt: false,
-				profileId
-			}),
-			profileId,
-			agentDir: params.agentDir
-		}))?.apiKey?.trim();
-		return accessToken ? buildChatgptAuthTokensParams(profileId, credential, accessToken) : void 0;
+			apiKey: value
+		} : buildChatgptAuthTokensParams(profileId, credential, value);
 	}
 	if (credential.type !== "oauth") return;
 	const resolvedCredential = await resolveOAuthCredentialForCodexAppServer(profileId, credential, {
@@ -1384,7 +1477,7 @@ async function resolveOAuthCredentialForCodexAppServer(profileId, credential, pa
 		persistedCredential,
 		suppliedCredential: credential
 	});
-	if (params.preferStoreCredential && params.store.runtimePersistedProfileIds?.includes(profileId) && (persistedCredential?.type !== "oauth" || !isCodexAppServerAuthProvider(persistedCredential.provider))) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" is no longer available. Sign in again with OpenClaw, then retry.`);
+	if (params.preferStoreCredential && params.store.runtimePersistedProfileIds?.includes(profileId) && (persistedCredential?.type !== "oauth" || !isCodexAppServerAuthProvider(persistedCredential.provider))) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" is no longer an OpenAI OAuth credential in its persisted OpenClaw store. Run "openclaw doctor" to inspect credential ownership, or select an existing OpenAI profile.`);
 	const store = useScopedCredential ? params.store : resolveCodexAppServerAuthProfileStore({
 		agentDir: ownerAgentDir,
 		authProfileId: profileId,
@@ -1408,17 +1501,22 @@ async function resolveOAuthCredentialForCodexAppServer(profileId, credential, pa
 		profileId,
 		credential: overlaidOAuthCredential,
 		forceRefresh: params.forceRefresh && !reuseCompletedRotation,
-		expectedAccountId
+		expectedAccountId,
+		config: params.config
 	});
 	if (params.forceRefresh && !persistedOAuthCredential && overlaidOAuthCredential) {
 		if (reuseCompletedRotation) return overlaidOAuthCredential;
-		const refreshedRuntimeCredential = await refreshOAuthCredentialForRuntime({ credential: overlaidOAuthCredential });
+		const refreshedRuntimeCredential = await refreshOAuthCredentialForRuntime({
+			credential: overlaidOAuthCredential,
+			cfg: params.config
+		});
 		if (!refreshedRuntimeCredential?.access?.trim()) throw new Error(`Codex app-server auth profile "${profileId}" could not refresh. Sign in again with OpenClaw, then retry.`);
 		assertCodexOAuthRefreshWorkspace(profileId, refreshedRuntimeCredential, expectedAccountId);
 		store.profiles[profileId] = refreshedRuntimeCredential;
 		return refreshedRuntimeCredential;
 	}
 	const resolved = await resolveApiKeyForProfile({
+		cfg: params.config,
 		store,
 		profileId,
 		agentDir: ownerAgentDir,
@@ -1426,7 +1524,7 @@ async function resolveOAuthCredentialForCodexAppServer(profileId, credential, pa
 		allowProfileFallback: false,
 		...expectedAccountId ? { validateOAuthCredential: (candidate) => assertCodexOAuthRefreshWorkspace(profileId, candidate, expectedAccountId) } : {}
 	});
-	if (!resolved || resolved.credential?.type !== "oauth" || !isCodexAppServerAuthProvider(resolved.credential.provider) || !resolved.apiKey.trim()) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" is no longer available. Sign in again with OpenClaw, then retry.`);
+	if (!resolved || resolved.credential?.type !== "oauth" || !isCodexAppServerAuthProvider(resolved.credential.provider) || !resolved.apiKey.trim()) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" could not resolve usable OAuth credentials from its OpenClaw credential store. Run "openclaw doctor" to inspect credential ownership, or select an existing OpenAI profile.`);
 	const candidate = {
 		...resolved.credential,
 		access: resolved.apiKey
@@ -1470,7 +1568,10 @@ async function resolveScopedOAuthCredential(params) {
 		const current = params.store.profiles[params.profileId];
 		const credential = current?.type === "oauth" ? current : params.credential;
 		if (!params.forceRefresh && hasUsableOAuthCredential(credential)) return credential;
-		const refreshed = await refreshOAuthCredentialForRuntime({ credential });
+		const refreshed = await refreshOAuthCredentialForRuntime({
+			credential,
+			cfg: params.config
+		});
 		if (!refreshed?.access?.trim()) throw new Error(`Codex app-server auth profile "${params.profileId}" could not refresh. Sign in again with OpenClaw, then retry.`);
 		assertCodexOAuthRefreshWorkspace(params.profileId, refreshed, params.expectedAccountId);
 		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.`);
@@ -1486,15 +1587,11 @@ async function resolveScopedOAuthCredential(params) {
 }
 function assertCodexOAuthRefreshWorkspace(profileId, credential, expectedAccountId) {
 	if (!expectedAccountId) return;
-	const loginParams = buildChatgptAuthTokensParams(profileId, credential, credential.access.trim());
-	if (loginParams.type !== "chatgptAuthTokens" || loginParams.chatgptAccountId !== expectedAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
+	if (buildChatgptAuthTokensParams(profileId, credential, credential.access.trim()).chatgptAccountId !== expectedAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
 }
 function isCodexAppServerAuthProvider(provider) {
 	return provider.trim().toLowerCase() === CODEX_APP_SERVER_AUTH_PROVIDER;
 }
-function isCodexAppServerAuthProfileCredential(credential) {
-	return isCodexAppServerAuthProvider(credential.provider);
-}
 function shouldClearOpenAiApiKeyForCodexAuthProfile(params) {
 	const profileId = params.authProfileId?.trim();
 	return isCodexSubscriptionCredential(profileId ? params.store.profiles[profileId] : params.store.profiles[OPENAI_CODEX_DEFAULT_PROFILE_ID]);
@@ -1503,15 +1600,6 @@ function isCodexSubscriptionCredential(credential) {
 	if (!credential || !isCodexAppServerAuthProvider(credential.provider)) return false;
 	return credential.type === "oauth" || credential.type === "token";
 }
-function withClearedEnvironmentVariables(startOptions, envVars) {
-	const clearEnv = startOptions.clearEnv ?? [];
-	const missingEnvVars = envVars.filter((envVar) => !clearEnv.includes(envVar));
-	if (missingEnvVars.length === 0) return startOptions;
-	return {
-		...startOptions,
-		clearEnv: [...clearEnv, ...missingEnvVars]
-	};
-}
 function buildChatgptAuthTokensParams(profileId, credential, accessToken) {
 	const storedAccountId = resolveExplicitChatgptAccountId(credential);
 	const tokenAccountId = resolveOpenAICodexAuthIdentity({ access: accessToken }).accountId;
@@ -1555,7 +1643,7 @@ function createThreadOwnerToken(threadId, onInvalidated) {
 			} catch (error) {
 				embeddedAgentLog$1.warn("codex thread ownership invalidation failed", {
 					threadId,
-					reason: formatErrorMessage(error)
+					reason: formatErrorMessage$1(error)
 				});
 			}
 		}
@@ -1601,6 +1689,21 @@ function forgetThreadOwnership(runtime, threadId, owner) {
 	if (forgotten) owner.invalidate();
 	return forgotten;
 }
+/** Compaction discards client-authored catalog refreshes, not creation policy. */
+function revertRetainedThreadSkillsCatalog(runtime, threadId) {
+	const retained = runtime.retainedThreads.get(threadId);
+	if (retained?.ephemeralPolicy) retained.ephemeralPolicy = {
+		...retained.ephemeralPolicy,
+		skillsInstructions: retained.ephemeralPolicy.nativeSkillsInstructions
+	};
+}
+function createCodexEphemeralThreadPolicy({ developerInstructions, skillsInstructions }) {
+	return {
+		developerInstructions,
+		skillsInstructions,
+		nativeSkillsInstructions: skillsInstructions
+	};
+}
 //#endregion
 //#region extensions/codex/src/app-server/rate-limit-cache.ts
 const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 6e5;
@@ -1867,7 +1970,7 @@ function scheduleRetainedThreadEviction(client, runtime) {
 	runtime.evictionTimer = setTimeout(() => {
 		runtime.evictionTimer = void 0;
 		evictExpiredRetainedThreads(client, runtime).catch((error) => {
-			embeddedAgentLog$1.warn("codex retained thread expiry failed", { reason: formatErrorMessage(error) });
+			embeddedAgentLog$1.warn("codex retained thread expiry failed", { reason: formatErrorMessage$1(error) });
 		});
 	}, Math.max(0, expiresAt - Date.now()));
 	runtime.evictionTimer.unref?.();
@@ -1961,7 +2064,7 @@ async function retainCodexAppServerLiveThread(client, threadId, releaseThread, c
 		scheduleRetainedThreadEviction(client, runtime);
 		embeddedAgentLog$1.warn("codex retained thread capacity eviction failed", {
 			threadId,
-			reason: formatErrorMessage(error)
+			reason: formatErrorMessage$1(error)
 		});
 		return false;
 	}
@@ -2065,6 +2168,11 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained,
 		}
 	};
 }
+/** Standalone incognito compaction retains its separately owned subscription. */
+function revertCodexAppServerLiveThreadSkillsCatalog(client, threadId) {
+	const runtime = configuredClients.get(client);
+	if (runtime && !runtime.closed) revertRetainedThreadSkillsCatalog(runtime, threadId);
+}
 /** Distinguish active claimed ownership from an already-evicted idle subscription. */
 function hasCodexAppServerLiveThread(client, threadId) {
 	return hasThreadOwnership(configuredClients.get(client), threadId);
@@ -2154,25 +2262,156 @@ function protectCodexAppServerLiveThread(client, threadId) {
 		evictExcessIdleThreads(client, runtime).catch((error) => {
 			embeddedAgentLog$1.warn("codex retained thread unpin eviction failed", {
 				threadId,
-				reason: formatErrorMessage(error)
+				reason: formatErrorMessage$1(error)
 			});
 		});
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/client-startup-retry.ts
+/** Recovers physical startup, including acquisitions before thread preparation. */
+async function withCodexWebSocketOpenRetry(params) {
+	const startedAt = performance.now();
+	for (let attempt = 1;; attempt += 1) try {
+		return await params.start(resolveRemainingAcquireTimeout(params.timeoutMs, startedAt));
+	} catch (error) {
+		if (params.signal.aborted || attempt >= 3 || !isCodexWebSocketOpenFailure(error)) throw error;
+		const remaining = resolveRemainingAcquireTimeout(params.timeoutMs, startedAt);
+		const delay = 1e3 * 2 ** (attempt - 1);
+		await sleepWithAbort(remaining > 0 ? Math.min(delay, remaining) : delay, params.signal);
+	}
+}
+function resolveRemainingAcquireTimeout(timeoutMs, startedAt) {
+	if (!(timeoutMs > 0)) return timeoutMs;
+	const remaining = timeoutMs - (performance.now() - startedAt);
+	if (remaining <= 0) throw new CodexAppServerStartupError("timed_out", "codex app-server initialize timed out");
+	return remaining;
+}
+async function withCodexAppServerAcquireDeadline(timeoutMs, promise, signal, timeoutMessage = "codex app-server initialize timed out", timeoutErrorFactory) {
+	if (signal?.aborted) throw new CodexAppServerStartupError("aborted", "codex app-server initialize aborted");
+	const timed = withTimeout(promise, timeoutMs, timeoutMessage, () => timeoutErrorFactory?.() ?? new CodexAppServerStartupError("timed_out", timeoutMessage));
+	if (!signal) return await timed;
+	return await new Promise((resolve, reject) => {
+		const onAbort = () => reject(new CodexAppServerStartupError("aborted", "codex app-server initialize aborted"));
+		signal.addEventListener("abort", onAbort, { once: true });
+		timed.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+//#endregion
+//#region extensions/codex/src/app-server/inference-environment.ts
+function supportsInferenceEnvironment(native) {
+	if (native.CODEX_CA_CERTIFICATE?.trim() || native.SSL_CERT_FILE?.trim()) return false;
+	const names = [
+		"HTTP_PROXY",
+		"HTTPS_PROXY",
+		"ALL_PROXY",
+		"NO_PROXY"
+	];
+	for (const upper of names) {
+		const lower = upper.toLowerCase();
+		if (native[upper] !== process.env[upper] || native[lower] !== process.env[lower] || native[upper] !== void 0 && native[lower] !== void 0 && native[upper] !== native[lower]) return false;
+	}
+	const value = (name) => (native[name] ?? native[name.toLowerCase()])?.trim() || void 0;
+	const http = value("HTTP_PROXY");
+	const https = value("HTTPS_PROXY");
+	const all = value("ALL_PROXY");
+	if (!http && !https && !all) return true;
+	const noProxy = native.NO_PROXY ?? native.no_proxy ?? "";
+	if (noProxy === "*") return true;
+	if (native.REQUEST_METHOD !== void 0 || names.slice(0, 3).some((name) => {
+		const raw = native[name] ?? native[name.toLowerCase()];
+		return raw !== void 0 && raw !== raw.trim();
+	})) return false;
+	if ((https ?? all) !== (https ?? http ?? all)) return false;
+	const bypasses = noProxy.split(",").map((entry) => entry.trim()).filter(Boolean);
+	if (bypasses.some((entry) => ![
+		"127.0.0.1",
+		"localhost",
+		"::1",
+		"[::1]"
+	].includes(entry))) return false;
+	if ((http || all) && !bypasses.includes("127.0.0.1")) return false;
+	return /^https?:\/\//.test(https ?? all ?? "");
+}
+//#endregion
+//#region extensions/codex/src/app-server/inference-provider-config.ts
+function providerKind(name) {
+	if (name === "Amazon Bedrock" || name === "Amazon Bedrock Runtime") return;
+	return name === "OpenAI" ? "openai" : typeof name === "string" && name.toLowerCase() === "azure" ? "azure" : "other";
+}
+function hasProviderAws(config, provider) {
+	return readProviderField(config, provider, "aws") != null || Object.keys(config ?? {}).some((key) => key.startsWith(`model_providers.${provider}.aws.`));
+}
+function configuredProviders(...configs) {
+	const providers = /* @__PURE__ */ new Set(["openai"]);
+	for (const config of configs) {
+		for (const provider of Object.keys(isJsonObject(config?.model_providers) ? config.model_providers : {})) providers.add(provider);
+		for (const key of Object.keys(config ?? {})) {
+			const provider = /^model_providers\.([^.]+)(?:\.|$)/.exec(key)?.[1];
+			if (provider) providers.add(provider);
+		}
+	}
+	return providers;
+}
+function projectProviderRoutes(config, providers) {
+	let projected = config ?? {};
+	for (const [provider, route] of providers) projected = withProviderBaseUrl(projected, provider, route.baseUrl);
+	return projected;
+}
+function readProviderBaseUrl(config, provider) {
+	if (provider === "openai") return config?.openai_base_url;
+	return readProviderField(config, provider, "base_url");
+}
+function readProviderField(config, provider, field) {
+	const selected = (isJsonObject(config?.model_providers) ? config.model_providers : void 0)?.[provider];
+	const flat = config?.[`model_providers.${provider}`];
+	return config?.[`model_providers.${provider}.${field}`] ?? (isJsonObject(flat) ? flat[field] : void 0) ?? (isJsonObject(selected) ? selected[field] : void 0);
+}
+function withProviderBaseUrl(config, provider, baseUrl) {
+	if (provider === "openai") return {
+		...config,
+		openai_base_url: baseUrl
+	};
+	const providers = isJsonObject(config?.model_providers) ? config.model_providers : {};
+	const selected = providers[provider];
+	const providerKey = `model_providers.${provider}`;
+	const baseUrlKey = `${providerKey}.base_url`;
+	const flat = config?.[providerKey];
+	return {
+		...config,
+		model_providers: {
+			...providers,
+			[provider]: {
+				...isJsonObject(selected) ? selected : {},
+				base_url: baseUrl
+			}
+		},
+		...isJsonObject(flat) ? { [providerKey]: {
+			...flat,
+			base_url: baseUrl
+		} } : {},
+		...config?.[baseUrlKey] !== void 0 ? { [baseUrlKey]: baseUrl } : {}
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/inference-routing.ts
 const owners = defineCodexBuildState("openclaw.codexAppServerInferenceOwners", () => /* @__PURE__ */ new WeakMap())();
 const MAX_ROUTES = 8;
 const MAX_THREADS = 256;
-const NATIVE_OPENAI_UPSTREAMS = /* @__PURE__ */ new Set(["https://api.openai.com/v1", "https://chatgpt.com/backend-api/codex"]);
 /** Only managed native stdio startup calls this; locality or metadata cannot opt a client in. */
-function ownCodexInferenceClient(client) {
+function ownCodexInferenceClient(client, startOptions = {}, oauth) {
 	if (owners.has(client)) return;
+	if (!supportsInferenceEnvironment(resolveCodexAppServerSpawnEnv(startOptions))) {
+		if (oauth) throw new Error("ChatGPT subscription sharing requires the managed public Responses inference route with a compatible proxy and trust configuration.");
+		return;
+	}
 	const owner = {
 		closed: false,
+		memoryConfigured: false,
 		routes: /* @__PURE__ */ new Map(),
 		threads: /* @__PURE__ */ new Map(),
-		handles: /* @__PURE__ */ new Set()
+		handles: /* @__PURE__ */ new Map(),
+		oauth
 	};
 	owners.set(client, owner);
 	const close = () => {
@@ -2191,10 +2430,11 @@ function ownCodexInferenceClient(client) {
 	});
 }
 async function prepareCodexInferenceRoute(params) {
-	const owner = owners.get(params.client);
+	const client = params.client;
+	const owner = owners.get(client);
 	if (!owner) return;
 	const assertClient = () => {
-		if (owner.closed || owners.get(params.client) !== owner) throw new Error("Codex inference route ownership changed; reconnect before retrying");
+		if (owner.closed || owners.get(client) !== owner) throw new Error("Codex inference route ownership changed; reconnect before retrying");
 	};
 	const assertCurrent = () => {
 		assertClient();
@@ -2204,40 +2444,102 @@ async function prepareCodexInferenceRoute(params) {
 	assertCurrent();
 	const snapshot = params.effectiveConfig ?? await readCodexEffectiveConfig(params.client, params.cwd, { signal: params.signal });
 	assertCurrent();
-	if (snapshot.config.model_provider != null && snapshot.config.model_provider !== "openai") return;
-	if (isJsonObject(snapshot.config.features) && snapshot.config.features.respect_system_proxy === true) return;
-	const configured = snapshot.config.openai_base_url;
+	const unsupported = () => {
+		if (owner.oauth) throw new Error("ChatGPT subscription sharing requires the managed public Responses inference route.");
+	};
+	const selectedProvider = params.modelProvider ?? params.config?.model_provider ?? snapshot.config.model_provider ?? "openai";
+	if (owner.oauth && (snapshot.config.model_provider != null && snapshot.config.model_provider !== "openai" || selectedProvider !== "openai" && selectedProvider !== "openclaw_token_sharing")) return unsupported();
+	const provider = owner.oauth ? CODEX_RESPONSES_OAUTH_PROVIDER : selectedProvider;
+	if (typeof provider !== "string" || !provider.trim()) return unsupported();
+	const customProvider = !owner.oauth && provider !== "openai";
+	const providerField = (field) => readProviderField(params.config, provider, field) ?? readProviderField(snapshot.config, provider, field);
+	const nativeProviderName = owner.oauth ? "OpenClaw subscription sharing" : customProvider ? providerField("name") : "OpenAI";
+	const kind = providerKind(nativeProviderName);
+	const wireApi = customProvider ? providerField("wire_api") : "responses";
+	if (!kind || customProvider && ([
+		"amazon-bedrock",
+		"amazon-bedrock-runtime",
+		"ollama",
+		"lmstudio"
+	].includes(provider) || hasProviderAws(params.config, provider) || hasProviderAws(snapshot.config, provider) || wireApi != null && wireApi !== "responses")) return unsupported();
+	if ((params.config?.["features.respect_system_proxy"] ?? (isJsonObject(params.config?.features) ? params.config.features.respect_system_proxy : void 0) ?? (isJsonObject(snapshot.config.features) ? snapshot.config.features.respect_system_proxy : void 0)) === true) return unsupported();
+	const configured = customProvider ? providerField("base_url") : params.config?.openai_base_url ?? snapshot.config.openai_base_url;
 	if (configured != null && typeof configured !== "string") throw new Error("Codex inference upstream configuration is invalid");
+	if (typeof configured === "string" && (!configured.trim() || configured.includes("?") || configured.includes("#"))) return unsupported();
 	if (configured) {
 		let target;
 		try {
 			target = new URL(configured);
 		} catch {
-			return;
+			return unsupported();
 		}
-		if (!NATIVE_OPENAI_UPSTREAMS.has(target.href.replace(/\/$/, ""))) return;
+		if (target.protocol !== "https:" || target.username || target.password || target.hash || target.search || owner.oauth && target.href.replace(/\/$/, "") !== "https://api.openai.com/v1") return unsupported();
 	}
-	const origin = snapshot.origins?.openai_base_url;
-	if (origin && !CODEX_SESSION_OVERRIDABLE_LAYER_TYPES.has(origin.name.type)) return;
-	const account = await params.client.request("account/read", { refreshToken: false }, {
+	if (customProvider && !configured) return unsupported();
+	const configKey = customProvider ? `model_providers.${provider}.base_url` : "openai_base_url";
+	if (Object.entries(snapshot.origins ?? {}).filter(([key]) => customProvider ? key === "model_providers" || key === `model_providers.${provider}` || key === configKey : key === configKey).some(([, origin]) => !origin || !CODEX_SESSION_OVERRIDABLE_LAYER_TYPES.has(origin.name.type))) return unsupported();
+	const account = customProvider ? void 0 : await params.client.request("account/read", { refreshToken: false }, {
 		signal: params.signal,
 		assertCurrent
 	});
 	assertCurrent();
-	const type = isJsonObject(account.account) ? account.account.type : void 0;
-	if (type !== "apiKey" && type !== "chatgpt") return;
-	if (owner.authRoute && owner.authRoute !== type) throw new Error("Codex native account route changed; reconnect before retrying");
-	owner.authRoute = type;
+	const type = account?.account?.type;
+	if (owner.oauth && type !== "apiKey") return unsupported();
+	if (!customProvider && type !== "apiKey" && type !== "chatgpt") return unsupported();
+	if (!customProvider && owner.authRoute && owner.authRoute !== type) throw new Error("Codex native account route changed; reconnect before retrying");
+	if (type === "apiKey" || type === "chatgpt") owner.authRoute = type;
 	const target = new URL(configured || (type === "apiKey" ? "https://api.openai.com/v1" : "https://chatgpt.com/backend-api/codex"));
-	const key = target.toString();
+	const { isBlockedHostnameOrIp } = await import("openclaw/plugin-sdk/ssrf-runtime");
+	assertCurrent();
+	if (isBlockedHostnameOrIp(target.hostname)) return unsupported();
+	const nativeBaseUrl = typeof configured === "string" ? configured.toLowerCase() : target.href;
+	const preserveAzureUrlFeatures = typeof nativeProviderName === "string" && nativeProviderName.toLowerCase() === "azure" || [
+		"openai.azure.",
+		"cognitiveservices.azure.",
+		"aoai.azure.",
+		"azure-api.",
+		"azurefd.",
+		"windows.net/openai"
+	].some((marker) => nativeBaseUrl.includes(marker));
+	const preserveCodexBackendRoutes = nativeProviderName === "OpenAI" && (configured == null || configured.replace(/\/+$/, "").endsWith("/backend-api/codex"));
+	const memoryFeature = params.config?.["features.memories"] ?? (isJsonObject(params.config?.features) ? params.config.features.memories : void 0) ?? (isJsonObject(snapshot.config.features) ? snapshot.config.features.memories : void 0);
+	owner.memoryConfigured ||= memoryFeature === true;
+	const modelPolicyEnforced = params.modelPolicyEnforced !== false;
+	const key = JSON.stringify([
+		provider,
+		target.toString(),
+		kind,
+		preserveAzureUrlFeatures,
+		preserveCodexBackendRoutes,
+		modelPolicyEnforced
+	]);
 	let pending = owner.routes.get(key);
 	if (!pending) {
-		if (owner.routes.size >= MAX_ROUTES) throw new Error("Codex inference route limit reached");
-		pending = import("./inference-proxy-CC15HuSi.mjs").then(({ createCodexInferenceProxy }) => {
+		if (owner.routes.size >= MAX_ROUTES) {
+			if (params.optionalProjection) return unsupported();
+			throw new Error("Codex inference route limit reached; start a fresh managed native connection before retrying.");
+		}
+		pending = Promise.all([
+			import("./inference-proxy-DhcXOgUE.mjs"),
+			import("./native-subagent-monitor-Dpsmf2wz.mjs").then((n) => n.n),
+			import("./inference-dispatch-CMZtjQyz.mjs")
+		]).then(([{ createCodexInferenceProxy }, native, { createCodexInferenceModelBinding }]) => {
 			assertClient();
 			return createCodexInferenceProxy({
 				upstream: target,
-				assertCurrent: assertClient
+				assertCurrent: assertClient,
+				oauth: owner.oauth,
+				preserveAzureUrlFeatures,
+				preserveCodexBackendRoutes,
+				bindModelExecution: createCodexInferenceModelBinding({
+					client,
+					provider,
+					modelPolicyEnforced,
+					assertCurrent: assertClient,
+					memoryConfigured: () => owner.memoryConfigured,
+					captureModelSource: native.codexNativeSubagentMonitorRuntime.captureModelSource,
+					resolveModelThreadId: native.codexNativeSubagentMonitorRuntime.resolveModelThreadId
+				})
 			});
 		});
 		owner.routes.set(key, pending);
@@ -2246,14 +2548,41 @@ async function prepareCodexInferenceRoute(params) {
 	assertCurrent();
 	route.assertCurrent();
 	params.client.protectPrivateTransportSecret(new URL(route.baseUrl).pathname.split("/")[1] ?? "");
-	owner.handles.add(route);
+	owner.handles.set(route, {
+		provider,
+		kind,
+		modelPolicyEnforced
+	});
 	return route;
 }
 /** Prepare a managed thread without changing an attached or unsupported native profile. */
 async function prepareCodexInferenceThreadConfig(params) {
 	const { binding } = params;
-	if (binding?.connectionScope === "supervision" || binding?.preserveNativeModel === true) return;
-	const route = await prepareCodexInferenceRoute(params);
+	const owner = owners.get(params.client);
+	if (!owner) return;
+	if (owner.closed) throw new Error("Codex inference route ownership changed; reconnect before retrying");
+	const preserved = binding?.connectionScope === "supervision" || binding?.preserveNativeModel === true;
+	let retained = preserved && binding?.clientId === params.clientId ? owner.threads.get(binding.threadId) : void 0;
+	if (preserved) {
+		if (owner.oauth) throw new Error("ChatGPT subscription sharing cannot attach to a native Codex thread.");
+		if (!retained) return;
+		retained.route.assertCurrent();
+		if (owner.handles.get(retained.route)?.modelPolicyEnforced !== (params.modelPolicyEnforced !== false)) retained = void 0;
+		else if (!params.operatorBacked) return {
+			route: retained.route,
+			providers: retained.providers,
+			config: projectProviderRoutes(params.config, retained.providers)
+		};
+	}
+	params.signal?.throwIfAborted();
+	params.assertCurrent();
+	const effectiveConfig = params.effectiveConfig ?? await readCodexEffectiveConfig(params.client, params.cwd, { signal: params.signal });
+	params.signal?.throwIfAborted();
+	params.assertCurrent();
+	const route = retained?.route ?? await prepareCodexInferenceRoute({
+		...params,
+		effectiveConfig
+	});
 	if (!route) return;
 	if (binding?.clientId === params.clientId && !getCodexInferenceThread(params.client, binding.threadId)) {
 		const { thread } = await params.client.request("thread/read", {
@@ -2266,23 +2595,65 @@ async function prepareCodexInferenceThreadConfig(params) {
 		params.assertCurrent();
 		if (thread.id !== binding.threadId || thread.status?.type !== "notLoaded") throw new Error("Codex loaded thread has no owned inference route; reconnect before retrying");
 	}
-	if (params.config?.openai_base_url !== void 0 && params.config.openai_base_url !== route.upstream) throw new Error("Codex thread configuration conflicts with its trusted inference upstream");
-	return {
+	const provider = owner.handles.get(route)?.provider;
+	if (!provider) throw new Error("Codex inference provider ownership changed");
+	if (owner.oauth) return {
 		route,
 		config: {
 			...params.config,
-			openai_base_url: route.baseUrl
+			model_provider: CODEX_RESPONSES_OAUTH_PROVIDER,
+			model_providers: { [CODEX_RESPONSES_OAUTH_PROVIDER]: responsesOAuthProvider(route) }
 		}
 	};
+	if (!params.operatorBacked) return {
+		route,
+		config: withProviderBaseUrl(params.config, provider, route.baseUrl)
+	};
+	const providers = new Map(retained?.providers ?? [[provider, route]]);
+	for (const candidate of configuredProviders(effectiveConfig.config, params.config)) {
+		if (providers.has(candidate)) continue;
+		const sibling = await prepareCodexInferenceRoute({
+			...params,
+			effectiveConfig,
+			modelProvider: candidate,
+			optionalProjection: true
+		});
+		if (sibling) providers.set(candidate, sibling);
+	}
+	return {
+		route,
+		config: projectProviderRoutes(params.config, providers),
+		providers
+	};
+}
+function responsesOAuthProvider(route) {
+	return {
+		name: "OpenClaw subscription sharing",
+		base_url: route.baseUrl,
+		wire_api: "responses",
+		requires_openai_auth: true,
+		supports_websockets: false
+	};
 }
 /** Validate the exact private handle and unchanged upstream, not a localhost string exception. */
-function assertCodexInferenceRouteConfig(client, route, config) {
+function assertCodexInferenceRouteConfig(client, route, config, modelProvider, providers) {
 	if (!route) return;
 	const owner = owners.get(client);
-	if (!owner || owner.closed || !owner.handles.has(route) || config?.openai_base_url !== route.baseUrl) throw new Error("Codex parent-local inference route was overridden; no turn was sent");
+	const provider = (owner?.handles.get(route))?.provider;
+	const selectedProvider = modelProvider ?? config?.model_provider ?? provider;
+	const systemProxy = config?.["features.respect_system_proxy"] ?? (isJsonObject(config?.features) ? config.features.respect_system_proxy : void 0);
+	if (!owner || owner.closed || !provider || selectedProvider !== provider || systemProxy === true || readProviderBaseUrl(config, provider) !== route.baseUrl) throw new Error("Codex parent-local inference route was overridden; no turn was sent");
+	if (owner.oauth && (config?.model_provider !== "openclaw_token_sharing" || !isJsonObject(config?.model_providers) || !isDeepStrictEqual(config.model_providers["openclaw_token_sharing"], responsesOAuthProvider(route)) || Object.keys(config).some((key) => key.startsWith(`model_providers.openclaw_token_sharing`)))) throw new Error("Codex parent-local inference route was overridden; no turn was sent");
 	route.assertCurrent();
+	for (const [candidate, sibling] of providers ?? [[provider, route]]) {
+		const siblingDefinition = owner.handles.get(sibling);
+		const name = readProviderField(config, candidate, "name");
+		const wireApi = readProviderField(config, candidate, "wire_api");
+		if (siblingDefinition?.provider !== candidate || readProviderBaseUrl(config, candidate) !== sibling.baseUrl || candidate !== "openai" && (name !== void 0 && providerKind(name) !== siblingDefinition.kind || wireApi !== void 0 && wireApi !== "responses" || hasProviderAws(config, candidate))) throw new Error("Codex native provider inference route was overridden; no turn was sent");
+		sibling.assertCurrent();
+	}
 }
-function bindCodexInferenceThread(client, threadId, route) {
+function bindCodexInferenceThread(client, threadId, route, providers) {
 	const owner = owners.get(client);
 	if (!owner && !route) return;
 	if (!owner || owner.closed) throw new Error("Codex inference client is closed");
@@ -2291,30 +2662,53 @@ function bindCodexInferenceThread(client, threadId, route) {
 		return;
 	}
 	route.assertCurrent();
+	const provider = owner.handles.get(route)?.provider;
+	if (!provider) throw new Error("Codex inference provider ownership changed");
 	if (!owner.threads.has(threadId) && owner.threads.size >= MAX_THREADS) throw new Error("Codex inference thread limit reached; reconnect before retrying");
-	owner.threads.set(threadId, route);
+	const projected = new Map(providers ?? [[provider, route]]);
+	if (projected.get(provider) !== route) throw new Error("Codex inference provider ownership changed");
+	const assertCurrent = () => {
+		if (owner.closed || owners.get(client) !== owner) throw new Error("Codex inference client is closed");
+		for (const [candidate, routed] of projected) {
+			if (owner.handles.get(routed)?.provider !== candidate) throw new Error("Codex inference provider ownership changed");
+			routed.assertCurrent();
+		}
+	};
+	assertCurrent();
+	const qualification = owner.handles.get(route)?.modelPolicyEnforced ? Object.freeze({
+		assertCurrent,
+		hasProvider: (candidate) => {
+			assertCurrent();
+			const projectedRoute = projected.get(candidate);
+			return projectedRoute !== void 0 && owner.handles.get(projectedRoute)?.modelPolicyEnforced === true;
+		}
+	}) : void 0;
+	owner.threads.set(threadId, {
+		route,
+		providers: projected,
+		qualification
+	});
 }
 function getCodexInferenceThread(client, threadId) {
 	const owner = owners.get(client);
 	if (owner?.closed) throw new Error("Codex inference client is closed");
-	return owner?.threads.get(threadId);
+	return owner?.threads.get(threadId)?.route;
+}
+/** Configuration provenance for native restore admission, independent of the input's source. */
+function getCodexInferenceThreadQualification(client, threadId) {
+	const owner = owners.get(client);
+	if (owner?.closed) throw new Error("Codex inference client is closed");
+	return owner?.threads.get(threadId)?.qualification;
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-config-fence.ts
+/** Serializes this Gateway's native config writes with its config-loading requests. */
 const CODEX_NATIVE_CONFIG_FENCE_STATE = Symbol.for("openclaw.codexNativeConfigFenceState");
-function getFenceState() {
-	const globalState = globalThis;
-	globalState[CODEX_NATIVE_CONFIG_FENCE_STATE] ??= /* @__PURE__ */ new Map();
-	return globalState[CODEX_NATIVE_CONFIG_FENCE_STATE];
-}
 /** Acquires the per-CODEX_HOME fence and returns an idempotent release. */
 async function acquireCodexNativeConfigFence(key, options = {}) {
-	const state = getFenceState();
+	const state = resolveGlobalMap(CODEX_NATIVE_CONFIG_FENCE_STATE);
 	const previous = state.get(key) ?? Promise.resolve();
-	let resolveCurrent = () => void 0;
-	const current = new Promise((resolve) => {
-		resolveCurrent = resolve;
-	});
+	const { promise: current, resolve: resolveCurrent } = createDeferred();
 	state.set(key, current);
 	try {
 		await waitForPreviousFence(previous, options);
@@ -2407,9 +2801,14 @@ function resolveCodexAppServerSpawnIdentity(startOptions, resolvedNativeCommand)
 }
 //#endregion
 //#region extensions/codex/src/app-server/thread-lifecycle-errors.ts
+const CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED = "CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED";
+/** True when a pre-write context restart must replay on the newly selected owner. */
+function isCodexContextRestartSelectionChangedError(error) {
+	return error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED";
+}
 var CodexThreadStartRequestError = class extends Error {
 	constructor(cause) {
-		super(`thread/start: ${formatErrorMessage(cause)}`, { cause });
+		super(`thread/start: ${formatErrorMessage$1(cause)}`, { cause });
 		this.name = "CodexThreadStartRequestError";
 	}
 };
@@ -2433,10 +2832,6 @@ var CodexAdoptedThreadActiveError = class extends AgentHarnessPreflightError$1 {
 };
 //#endregion
 //#region extensions/codex/src/app-server/shared-client.ts
-/**
-* Owns shared and isolated Codex app-server client startup, auth application,
-* lease tracking, and teardown.
-*/
 var shared_client_exports = /* @__PURE__ */ __exportAll({
 	assertCodexAppServerClientStartSelectionCurrent: () => assertCodexAppServerClientStartSelectionCurrent,
 	captureCodexAppServerClientLifetime: () => captureCodexAppServerClientLifetime,
@@ -2455,7 +2850,6 @@ var shared_client_exports = /* @__PURE__ */ __exportAll({
 	releaseCodexAppServerClientLease: () => releaseCodexAppServerClientLease,
 	releaseLeasedSharedCodexAppServerClient: () => releaseLeasedSharedCodexAppServerClient,
 	resolveCodexNativeConfigFenceKey: () => resolveCodexNativeConfigFenceKey,
-	retainSharedCodexAppServerClientByInstanceId: () => retainSharedCodexAppServerClientByInstanceId,
 	retainSharedCodexAppServerClientIfCurrent: () => retainSharedCodexAppServerClientIfCurrent,
 	retireSharedCodexAppServerClientIfCurrent: () => retireSharedCodexAppServerClientIfCurrent,
 	waitForCodexAppServerClientDesktopGenerationDrain: () => waitForCodexAppServerClientDesktopGenerationDrain,
@@ -2463,12 +2857,6 @@ var shared_client_exports = /* @__PURE__ */ __exportAll({
 });
 const SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER = codexBuildSymbol("openclaw.codexAppServerClientDisposer");
 const CODEX_APP_SERVER_INITIALIZE_TIMEOUT_MESSAGE = "codex app-server initialize timed out";
-function ownCodexStartup(lifetime, operation) {
-	lifetime.pending.add(operation);
-	const release = () => lifetime.pending.delete(operation);
-	operation.then(release, release);
-	return operation;
-}
 async function prepareCodexAppServerClient(options) {
 	const lifetime = getSharedCodexAppServerClientState().startup;
 	const abandonSignal = options?.abandonSignal ? AbortSignal.any([lifetime.controller.signal, options.abandonSignal]) : lifetime.controller.signal;
@@ -2497,11 +2885,9 @@ function readCodexAppServerClientProcessIdentity(client) {
 		...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 getSharedCodexAppServerClientState().startMetadata.get(client)?.desktopGeneration;
 }
@@ -2548,19 +2934,14 @@ function assertCodexAppServerClientStartSelectionCurrent(params) {
 	});
 	if ((metadata.startOptions.managedCommandOrder ?? "package-first") !== (current.managedCommandOrder ?? "package-first")) throw new CodexAppServerStartSelectionChangedError();
 }
-/** Resolves the per-CODEX_HOME key used to serialize native config loading. */
 function resolveCodexNativeConfigFenceKey(params) {
 	const metadata = params.client ? getSharedCodexAppServerClientState().startMetadata.get(params.client) : void 0;
 	const startOptions = metadata?.startOptions ?? params.startOptions;
 	if (!startOptions || startOptions.transport !== "stdio") return;
-	const configuredHome = startOptions.env?.CODEX_HOME?.trim();
+	const configuredHome = startOptions.codexHome ?? startOptions.env?.CODEX_HOME?.trim();
 	const codexHome = configuredHome ? configuredHome : startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir() : resolveCodexAppServerHomeDir(params.agentDir ?? metadata?.agentDir ?? resolveDefaultAgentDir(params.config ?? {}));
 	return codexHome ? `codex-home:${path.resolve(codexHome)}` : void 0;
 }
-function inferAuthRequirement(preparedAuth) {
-	if (preparedAuth?.kind === "api-key") return "api-key";
-	return preparedAuth?.kind === "profile" ? "subscription" : void 0;
-}
 async function resolveCodexAppServerClientStartContext(options) {
 	const requestedStartOptions = options?.startOptions ?? resolveCodexAppServerRuntimeOptions({ pluginConfig: options?.pluginConfig }).start;
 	const agentDir = options?.agentDir ?? (requestedStartOptions.homeScope === "user" ? void 0 : resolveDefaultAgentDir(options?.config ?? {}));
@@ -2568,12 +2949,12 @@ async function resolveCodexAppServerClientStartContext(options) {
 	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. Select an existing OpenAI profile or sign in again with OpenClaw, then retry.`);
+	if (preparedAuth?.kind === "profile" && !preparedAuth.store.profiles[preparedAuth.profileId]) throw new CodexAppServerAuthProfileUnavailableError(formatCodexAuthProfileUnavailableMessage(preparedAuth.profileId));
 	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);
+	const preparedAuthRequirement = preparedAuth && (preparedAuth.kind === "api-key" || isCodexResponsesOAuth(preparedAuth) ? "api-key" : "subscription");
 	if (options?.authRequirement && preparedAuthRequirement && options.authRequirement !== preparedAuthRequirement) throw new Error("Prepared Codex auth does not satisfy the requested auth requirement.");
-	const authRequirement = options?.authRequirement ?? preparedAuthRequirement;
+	let 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 && preparedAuth?.kind !== "api-key" ? resolveCodexAppServerAuthProfileStore({
@@ -2594,7 +2975,7 @@ async function resolveCodexAppServerClientStartContext(options) {
 		agentDir,
 		config: options?.config
 	}) : void 0;
-	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.`);
+	if (preparedAuth?.kind === "profile" && !preparedAuthProfileSnapshot) throw new CodexAppServerAuthProfileUnavailableError(`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
@@ -2604,10 +2985,25 @@ async function resolveCodexAppServerClientStartContext(options) {
 		store: authProfileStore,
 		snapshot: preparedAuthProfileSnapshot
 	} : void 0;
+	if (isCodexResponsesOAuth(resolvedPreparedAuth)) {
+		if (authRequirement && authRequirement !== "api-key") throw new Error("ChatGPT subscription sharing requires the public OpenAI API route.");
+		authRequirement = "api-key";
+	}
 	const agentStartOptions = resolveCodexAppServerStartOptionsForAgent({
 		startOptions: requestedStartOptions,
 		agentDir
 	});
+	const startOptions = await bridgeCodexAppServerStartOptions({
+		startOptions: await resolveManagedCodexAppServerStartOptions(agentStartOptions),
+		agentId: options?.agentId,
+		agentDir,
+		authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
+		...(preparedAuth || isCodexResponsesOAuth(resolvedPreparedAuth)) && resolvedPreparedAuth ? { preparedAuth: resolvedPreparedAuth } : {},
+		authRequirement,
+		config: options?.config,
+		pluginConfig: options?.pluginConfig,
+		...authProfileStore ? { authProfileStore } : {}
+	});
 	return {
 		agentDir,
 		usesNativeAuth,
@@ -2616,17 +3012,7 @@ async function resolveCodexAppServerClientStartContext(options) {
 		requestedStartOptions,
 		preparedAuth: resolvedPreparedAuth,
 		authRequirement,
-		startOptions: await bridgeCodexAppServerStartOptions({
-			startOptions: await resolveManagedCodexAppServerStartOptions(agentStartOptions),
-			agentId: options?.agentId,
-			agentDir,
-			authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
-			...preparedAuth && resolvedPreparedAuth ? { preparedAuth: resolvedPreparedAuth } : {},
-			authRequirement,
-			config: options?.config,
-			pluginConfig: options?.pluginConfig,
-			...authProfileStore ? { authProfileStore } : {}
-		}),
+		startOptions,
 		...options?.pluginConfig !== void 0 ? { pluginConfig: options.pluginConfig } : {},
 		...desktopGeneration ? { desktopGeneration } : {}
 	};
@@ -2644,7 +3030,6 @@ function getSharedCodexAppServerClient(options) {
 function getLeasedSharedCodexAppServerClient(options) {
 	return acquireSharedCodexAppServerClient(options, true);
 }
-/** Releases one outstanding lease for a shared Codex app-server client. */
 function releaseLeasedSharedCodexAppServerClient(client) {
 	const entry = getSharedCodexAppServerClientState().entriesByClient.get(client);
 	if (!entry || entry.anonymousLeases === 0) return false;
@@ -2716,7 +3101,8 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 	const state = getSharedCodexAppServerClientState();
 	const { context, lifetime, abandonSignal, startedAt, assertCurrent } = await prepareCodexAppServerClient(options);
 	assertCurrent();
-	const { agentDir, usesNativeAuth, authProfileId, authProfileStore, preparedAuth, authRequirement, requestedStartOptions, startOptions, desktopGeneration, pluginConfig } = context;
+	const { usesNativeAuth, ...startContext } = context;
+	const { agentDir, authProfileId, authProfileStore, preparedAuth, authRequirement, startOptions, desktopGeneration } = startContext;
 	const remainingTimeoutMs = resolveRemainingAcquireTimeout(timeoutMs, startedAt);
 	const authIdentityCacheKey = preparedAuth?.kind === "api-key" ? resolveCodexAppServerPreparedApiKeyCacheKey(preparedAuth.apiKey) : preparedAuth?.snapshot.secretFreeCacheKey ?? (authRequirement === "api-key" && !authProfileId ? resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions }) : void 0);
 	const baseKey = `${codexAppServerStartOptionsKey(startOptions, {
@@ -2758,17 +3144,10 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 		if (options.abandonSignal.aborted) abandon();
 	}
 	const startup = entry.startup ?? (entry.startup = createSharedCodexAppServerClientStartup({
+		...startContext,
 		lifetime,
 		entry,
-		requestedStartOptions,
-		startOptions,
-		desktopGeneration,
-		...pluginConfig !== void 0 ? { pluginConfig } : {},
-		agentDir,
 		authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
-		authProfileStore,
-		preparedAuth,
-		authRequirement,
 		runtimeArtifactMode,
 		...options?.expectedRuntimeArtifact ? { expectedRuntimeArtifact: options.expectedRuntimeArtifact } : {},
 		abandonSignal: entry.startupAbort.signal,
@@ -2782,7 +3161,7 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 			agentDir,
 			authProfileId: usesNativeAuth ? void 0 : authProfileId,
 			...authProfileStore ? { authProfileStore } : {},
-			authMode: preparedAuth?.kind === "api-key" ? "prepared-api-key" : "profile",
+			authMode: preparedAuth?.kind === "api-key" || isCodexResponsesOAuth(preparedAuth) ? "prepared-api-key" : "profile",
 			config: options?.config
 		});
 		if (leased) {
@@ -2793,6 +3172,7 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 	} catch (error) {
 		releasePendingAcquire();
 		retirePendingSharedClientEntryIfUnclaimed(entry);
+		await waitForUnclaimedSharedClientStartup(entry);
 		throw error;
 	} finally {
 		cleanupAbandonSignal?.();
@@ -2800,30 +3180,17 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 		releasePendingAcquire();
 	}
 }
-async function withCodexAppServerAcquireDeadline(timeoutMs, promise, signal, timeoutMessage = CODEX_APP_SERVER_INITIALIZE_TIMEOUT_MESSAGE, timeoutErrorFactory) {
-	if (signal?.aborted) throw new CodexAppServerStartupError("aborted", "codex app-server initialize aborted");
-	const timed = withTimeout(promise, timeoutMs, timeoutMessage, () => timeoutErrorFactory?.() ?? new CodexAppServerStartupError("timed_out", timeoutMessage));
-	if (!signal) return await timed;
-	return await new Promise((resolve, reject) => {
-		const onAbort = () => reject(new CodexAppServerStartupError("aborted", "codex app-server initialize aborted"));
-		signal.addEventListener("abort", onAbort, { once: true });
-		timed.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-	});
-}
 function buildCodexAppServerInitializeTimeoutError(client) {
 	const stderr = client?.getStderrDiagnostic();
 	return new CodexAppServerStartupError("timed_out", stderr ? `${CODEX_APP_SERVER_INITIALIZE_TIMEOUT_MESSAGE}; stderr=${JSON.stringify(stderr)}` : CODEX_APP_SERVER_INITIALIZE_TIMEOUT_MESSAGE);
 }
-function resolveRemainingAcquireTimeout(timeoutMs, startedAt) {
-	if (!(timeoutMs > 0)) return timeoutMs;
-	const remaining = timeoutMs - (performance.now() - startedAt);
-	if (remaining <= 0) throw new CodexAppServerStartupError("timed_out", "codex app-server initialize timed out");
-	return remaining;
-}
 function createSharedCodexAppServerClientStartup(params) {
 	const initialized = createDeferred();
 	const ready = ownCodexStartup(params.lifetime, startInitializedCodexAppServerClient({
 		...params,
+		onStartingClient: (starting) => {
+			params.entry.startupTransport = starting;
+		},
 		onStartedClient: (startedClient) => {
 			const state = getSharedCodexAppServerClientState();
 			if (params.entry.client) state.entriesByClient.delete(params.entry.client);
@@ -2863,18 +3230,11 @@ async function createIsolatedCodexAppServerClient(options) {
 	const { context, lifetime, abandonSignal, startedAt, assertCurrent } = await prepareCodexAppServerClient(options);
 	assertCurrent();
 	const timeoutMs = options?.timeoutMs ?? 0;
-	const { agentDir, usesNativeAuth, authProfileId, authProfileStore, preparedAuth, authRequirement, requestedStartOptions, startOptions, desktopGeneration, pluginConfig } = context;
+	const { usesNativeAuth, ...startContext } = context;
 	return await ownCodexStartup(lifetime, startInitializedCodexAppServerClient({
+		...startContext,
 		lifetime,
-		requestedStartOptions,
-		startOptions,
-		...desktopGeneration ? { desktopGeneration } : {},
-		...pluginConfig !== void 0 ? { pluginConfig } : {},
-		agentDir,
-		authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
-		authProfileStore,
-		preparedAuth,
-		authRequirement,
+		authProfileId: usesNativeAuth || context.preparedAuth?.kind === "api-key" ? null : context.authProfileId,
 		runtimeArtifactMode: options?.runtimeArtifactMode ?? (options?.expectedRuntimeArtifact ? "capture" : void 0),
 		...options?.expectedRuntimeArtifact ? { expectedRuntimeArtifact: options.expectedRuntimeArtifact } : {},
 		config: options?.config,
@@ -2895,7 +3255,17 @@ function trackIsolatedCodexAppServerClient(client) {
 		notifyDesktopGenerationDrainChecks(state);
 	});
 }
-async function startInitializedCodexAppServerClient(params) {
+function startInitializedCodexAppServerClient(params) {
+	return withCodexWebSocketOpenRetry({
+		timeoutMs: params.timeoutMs ?? 0,
+		signal: params.abandonSignal ? AbortSignal.any([params.lifetime.controller.signal, params.abandonSignal]) : params.lifetime.controller.signal,
+		start: (timeoutMs) => startInitializedCodexAppServerClientOnce({
+			...params,
+			timeoutMs
+		})
+	});
+}
+async function startInitializedCodexAppServerClientOnce(params) {
 	const acquireStartedAt = performance.now();
 	const timeoutMs = params.timeoutMs ?? 0;
 	const abandonSignal = params.abandonSignal ? AbortSignal.any([params.lifetime.controller.signal, params.abandonSignal]) : params.lifetime.controller.signal;
@@ -2906,7 +3276,8 @@ async function startInitializedCodexAppServerClient(params) {
 	const startOptionsCandidates = resolveManagedFallbackStartOptions(params.startOptions);
 	for (const [index, startOptions] of startOptionsCandidates.entries()) {
 		params.assertCurrent?.();
-		const desktopGeneration = params.desktopGeneration ?? (isManagedCodexDesktopCommand(startOptions.command) ? await waitForStartup(waitForCodexDesktopGeneration) : void 0);
+		const desktopCommand = isManagedCodexDesktopCommand(startOptions.command);
+		const desktopGeneration = params.desktopGeneration ?? (desktopCommand ? await waitForStartup(waitForCodexDesktopGeneration) : void 0);
 		const assertStartupCurrent = () => {
 			params.assertCurrent?.();
 			if (abandonSignal.aborted) throw new CodexAppServerStartupError("aborted", "codex app-server initialize aborted");
@@ -2941,7 +3312,7 @@ async function startInitializedCodexAppServerClient(params) {
 		} finally {
 			artifactDrain?.cancel();
 		}
-		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-Dy38Z5iU.mjs") : void 0;
+		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-DDQ-HGXf.mjs") : void 0;
 		const runtimeArtifactBeforeStart = runtimeArtifactModule ? await runtimeArtifactModule.captureCodexAppServerRuntimeArtifactBeforeStart({
 			startOptions,
 			spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions),
@@ -2955,14 +3326,21 @@ async function startInitializedCodexAppServerClient(params) {
 		let starting;
 		let client;
 		try {
-			client = await waitForStartup(() => starting = CodexAppServerClient.start(startOptions, () => {
-				assertStartupCurrent();
-				resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt);
-			}));
+			client = await waitForStartup(() => {
+				starting = CodexAppServerClient.start(startOptions, () => {
+					assertStartupCurrent();
+					resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt);
+				});
+				params.onStartingClient?.(starting);
+				return starting;
+			});
 		} catch (error) {
-			if (starting) ownCodexStartup(params.lifetime, starting.then((lateClient) => lateClient.closeAndWait(), () => {}));
+			if (starting) await ownCodexStartup(params.lifetime, starting.then((lateClient) => lateClient.closeAndWait(), () => {}));
 			throw error;
 		}
+		client.addCloseHandler((closedClient) => {
+			ownCodexStartup(params.lifetime, closedClient.waitForCloseWork());
+		});
 		let ready = false;
 		try {
 			const nativeCommandAtStart = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
@@ -3001,7 +3379,7 @@ async function startInitializedCodexAppServerClient(params) {
 			ensureCodexAppServerClientRuntime(client, {
 				agentDir: params.agentDir,
 				authProfileId: params.authProfileId ?? void 0,
-				authMode: params.preparedAuth?.kind === "api-key" ? "prepared-api-key" : "profile",
+				authMode: params.preparedAuth?.kind === "api-key" || isCodexResponsesOAuth(params.preparedAuth) ? "prepared-api-key" : "profile",
 				...params.authProfileStore ? { authProfileStore: params.authProfileStore } : {},
 				config: params.config,
 				onAuthRefreshFailure: () => retireSharedCodexAppServerClientIfCurrent(client)
@@ -3018,7 +3396,18 @@ async function startInitializedCodexAppServerClient(params) {
 				assertCurrent: assertStartupCurrent,
 				...params.authProfileStore ? { authProfileStore: params.authProfileStore } : {}
 			}));
-			if (startOptions.transport === "stdio" && nativeCommandAtStart && !desktopGeneration && !isManagedCodexDesktopCommand(startOptions.command) && !isCodexAppServerProxyLaunch(startOptions.args)) ownCodexInferenceClient(client);
+			const ownsInference = startOptions.transport === "stdio" && nativeCommandAtStart && !isCodexAppServerProxyLaunch(startOptions.args);
+			if (isCodexResponsesOAuth(params.preparedAuth) && (!ownsInference || desktopGeneration || desktopCommand)) throw new Error("ChatGPT subscription sharing requires a managed local Codex process.");
+			if (ownsInference) {
+				const prepared = params.preparedAuth;
+				ownCodexInferenceClient(client, startOptions, isCodexResponsesOAuth(prepared) && prepared?.kind === "profile" ? createCodexResponsesOAuth({
+					profileId: prepared.profileId,
+					store: prepared.store,
+					fingerprint: prepared.snapshot.secretFreeCacheKey,
+					agentDir: params.agentDir,
+					config: params.config
+				}) : void 0);
+			}
 			recordCodexAppServerAuthHandoff(client, authHandoff);
 			if (runtimeArtifactModule && runtimeArtifact) runtimeArtifactModule.bindCodexAppServerRuntimeArtifact(client, runtimeArtifact);
 			assertStartupCurrent();
@@ -3036,7 +3425,7 @@ async function startInitializedCodexAppServerClient(params) {
 			ready = true;
 			return client;
 		} finally {
-			if (!ready) ownCodexStartup(params.lifetime, client.closeAndWait());
+			if (!ready) await ownCodexStartup(params.lifetime, client.closeAndWait());
 		}
 	}
 	throw new Error("Managed Codex app-server fallback candidates were exhausted.");
@@ -3062,7 +3451,6 @@ function resolveManagedFallbackStartOptions(startOptions) {
 function shouldTryManagedFallbackStartOption(error, startOptions, index, startOptionsCandidates) {
 	return startOptions.commandSource === "resolved-managed" && index < startOptionsCandidates.length - 1 && isUnsupportedCodexAppServerVersionError(error);
 }
-/** Clears and closes the shared entry only if it still owns the supplied client. */
 function clearSharedCodexAppServerClientIfCurrent(client) {
 	if (!client) return false;
 	const state = getSharedCodexAppServerClientState();
@@ -3085,24 +3473,10 @@ function captureSharedClientRegistration(client) {
 	const generation = readCodexAppServerClientDesktopGeneration(client);
 	return () => entry !== void 0 && state.clients.get(entry.key) === entry && entry.client === client && !entry.closeWhenIdle && !entry.closeError && !client.getCloseError() && (!generation || isCodexDesktopGenerationCurrent(generation));
 }
-/** Retains the matching shared client and returns a release callback. */
 function retainSharedCodexAppServerClientIfCurrent(client) {
 	const entry = getCurrentSharedClientEntry(client);
 	return entry ? retainSharedClientEntry(entry) : void 0;
 }
-/** Retains the live shared client whose initialized instance id matches a thread binding. */
-function retainSharedCodexAppServerClientByInstanceId(clientId) {
-	const normalizedClientId = clientId?.trim();
-	if (!normalizedClientId) return;
-	for (const entry of getSharedCodexAppServerClientState().clients.values()) {
-		const client = entry.client;
-		if (client?.getInstanceId() !== normalizedClientId || entry.closeWhenIdle || entry.closeError) continue;
-		return {
-			client,
-			release: retainSharedClientEntry(entry)
-		};
-	}
-}
 /** Captures physical ownership, independently of unrelated thread and reader leases. */
 function captureCodexAppServerClientLifetime(client, requiredOwnership) {
 	const state = getSharedCodexAppServerClientState();
@@ -3127,10 +3501,7 @@ function createOlderDesktopGenerationDrainWait(params) {
 	};
 	const state = getSharedCodexAppServerClientState();
 	let settled = false;
-	let resolveWait;
-	const promise = new Promise((resolve) => {
-		resolveWait = resolve;
-	});
+	const { promise, resolve: resolveWait } = createDeferred();
 	const cancel = () => {
 		if (settled) return;
 		settled = true;
@@ -3152,18 +3523,13 @@ function createOlderDesktopGenerationDrainWait(params) {
 	};
 }
 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;
+	for (const clients of [params.state.liveClients, params.state.isolatedClients]) for (const client of clients) if (isOlderDesktopGenerationClientForHome(client, params.generation, params.targetHome)) return true;
 	return false;
 }
 function isOlderDesktopGenerationClientForHome(client, generation, targetHome) {
 	const metadata = getSharedCodexAppServerClientState().startMetadata.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;
 	const state = getSharedCodexAppServerClientState();
@@ -3173,7 +3539,6 @@ async function clearSharedCodexAppServerClientIfCurrentAndWait(client, options)
 	await client.closeAndWait(options);
 	return true;
 }
-/** Clears all shared clients and waits for their processes to exit. */
 async function clearSharedCodexAppServerClientAndWait(options) {
 	const state = getSharedCodexAppServerClientState();
 	const lifetime = state.startup;
@@ -3205,7 +3570,6 @@ function getOrCreateSharedClientEntry(state, key) {
 	}
 	return entry;
 }
-/** Clears a matching shared client only when no lease or acquire currently claims it. */
 function clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client) {
 	const entry = getCurrentSharedClientEntry(client);
 	return {
@@ -3215,20 +3579,6 @@ function clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client) {
 		pendingAcquires: entry?.pendingAcquires ?? 0
 	};
 }
-function retainSharedClientEntry(entry, counter = "activeLeases") {
-	let released = false;
-	entry[counter] += 1;
-	return () => {
-		if (released) return;
-		released = true;
-		releaseSharedClientEntry(entry, counter);
-	};
-}
-function releaseSharedClientEntry(entry, counter) {
-	entry[counter] -= 1;
-	closeRetiredSharedClientEntryIfIdle(entry);
-	notifyDesktopGenerationDrainChecks(getSharedCodexAppServerClientState());
-}
 function closeSharedClientEntryIfUnclaimed(entry) {
 	if (entry.activeLeases > 0 || entry.pendingAcquires > 0) return false;
 	const state = getSharedCodexAppServerClientState();
@@ -3237,14 +3587,5 @@ function closeSharedClientEntryIfUnclaimed(entry) {
 	entry.client?.close();
 	return Boolean(entry.client);
 }
-function retirePendingSharedClientEntryIfUnclaimed(entry) {
-	if (entry.activeLeases > 0 || entry.pendingAcquires > 0) return;
-	entry.startupAbort?.abort(/* @__PURE__ */ new Error("Codex app-server startup was abandoned"));
-	entry.closeWhenIdle = true;
-	const state = getSharedCodexAppServerClientState();
-	if (state.clients.get(entry.key) === entry) state.clients.delete(entry.key);
-	if (!entry.client) return;
-	closeRetiredSharedClientEntry(entry);
-}
 //#endregion
-export { assertNotSymlink as $, getCodexInferenceThread as A, prepareCodexWorkspaceReferences as B, CodexThreadBindingConflictError as C, acquireCodexNativeConfigFence as D, nativeHookRelayUnregisterQueue as E, forgetCodexWorkspaceReferences as F, unsubscribeCodexAppServerLiveThread as G, readCodexClientSessionMeta as H, hasCodexAppServerLiveThread as I, rememberCodexRateLimitsRead as J, readCodexRateLimitsRevision as K, hasCodexAppServerSiblingThreadWork as L, claimCodexAppServerLiveThread as M, consumeCodexAppServerLiveThread as N, assertCodexInferenceRouteConfig as O, ensureCodexAppServerClientRuntime as P, resolveCodexManagedBundledMarketplacePath as Q, isCodexAppServerClientRuntimeLive as R, CodexAdoptedThreadActiveError as S, CodexThreadStartRequestError as T, releaseCodexAppServerLiveThread as U, protectCodexAppServerLiveThread as V, retainCodexAppServerLiveThread as W, resolveCodexAppServerAuthAccountCacheKey as X, reconcileCodexComputerUseStartArtifacts as Y, resolveCodexAppServerPreparedAuthHandoff as Z, retainSharedCodexAppServerClientByInstanceId as _, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as a, resolveCodexStartupTimeoutMs as at, waitForCodexAppServerClientDesktopGenerationDrain as b, getLeasedSharedCodexAppServerClient as c, readCodexAppServerClientDesktopGeneration as d, CodexAppServerStartupError as et, readCodexAppServerClientDesktopGenerationFingerprint as f, resolveCodexNativeConfigFenceKey as g, releaseLeasedSharedCodexAppServerClient as h, clearSharedCodexAppServerClientIfCurrent as i, resolveCodexGatewayTimeoutWithGraceMs as it, prepareCodexInferenceThreadConfig as j, bindCodexInferenceThread as k, getSharedCodexAppServerClient as l, releaseCodexAppServerClientLease as m, captureCodexAppServerClientLifetime as n, TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS as nt, clearSharedCodexAppServerClientIfCurrentAndWait as o, withCodexStartupTimeout as ot, readCodexAppServerClientProcessIdentity as p, readRecentCodexRateLimits as q, captureSharedCodexAppServerCatalogLifetime as r, isCodexAppServerStartupError as rt, createIsolatedCodexAppServerClient as s, assertCodexAppServerClientStartSelectionCurrent as t, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS as tt, isCodexAppServerStartSelectionChangedError as u, retainSharedCodexAppServerClientIfCurrent as v, CodexThreadClientReplacementError as w, withLeasedCodexAppServerClientStartSelectionRetry as x, shared_client_exports as y, isCodexAppServerLiveThreadClaimed as z };
+export { reconcileCodexComputerUseStartArtifacts as $, bindCodexInferenceThread as A, isCodexAppServerClientRuntimeLive as B, CodexThreadBindingConflictError as C, nativeHookRelayUnregisterQueue as D, isCodexContextRestartSelectionChangedError as E, consumeCodexAppServerLiveThread as F, releaseCodexAppServerLiveThread as G, prepareCodexWorkspaceReferences as H, ensureCodexAppServerClientRuntime as I, unsubscribeCodexAppServerLiveThread as J, retainCodexAppServerLiveThread as K, forgetCodexWorkspaceReferences as L, getCodexInferenceThreadQualification as M, prepareCodexInferenceThreadConfig as N, acquireCodexNativeConfigFence as O, claimCodexAppServerLiveThread as P, createCodexEphemeralThreadPolicy as Q, hasCodexAppServerLiveThread as R, CodexAdoptedThreadActiveError as S, CodexThreadStartRequestError as T, protectCodexAppServerLiveThread as U, isCodexAppServerLiveThreadClaimed as V, readCodexClientSessionMeta as W, readRecentCodexRateLimits as X, readCodexRateLimitsRevision as Y, rememberCodexRateLimitsRead as Z, retainSharedCodexAppServerClientIfCurrent as _, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as a, isLegacyCodexComputerUsePluginDisabled as at, withLeasedCodexAppServerClientStartSelectionRetry as b, getLeasedSharedCodexAppServerClient as c, assertNotSymlink as ct, readCodexAppServerClientDesktopGeneration as d, TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS as dt, resolveCodexAppServerAuthAccountCacheKey as et, readCodexAppServerClientDesktopGenerationFingerprint as f, isCodexAppServerStartupError as ft, resolveCodexNativeConfigFenceKey as g, releaseLeasedSharedCodexAppServerClient as h, withCodexStartupTimeout as ht, clearSharedCodexAppServerClientIfCurrent as i, hasLegacyCodexComputerUseMcpPolicy as it, getCodexInferenceThread as j, assertCodexInferenceRouteConfig as k, getSharedCodexAppServerClient as l, CodexAppServerStartupError as lt, releaseCodexAppServerClientLease as m, resolveCodexStartupTimeoutMs as mt, captureCodexAppServerClientLifetime as n, resolveBundledComputerUseMarketplacePath as nt, clearSharedCodexAppServerClientIfCurrentAndWait as o, resolveManagedCodexComputerUseConfig as ot, readCodexAppServerClientProcessIdentity as p, resolveCodexGatewayTimeoutWithGraceMs as pt, revertCodexAppServerLiveThreadSkillsCatalog as q, captureSharedCodexAppServerCatalogLifetime as r, resolveClientManagedBundledMarketplacePath as rt, createIsolatedCodexAppServerClient as s, ensureCodexComputerUseSharedPluginCache as st, assertCodexAppServerClientStartSelectionCurrent as t, resolveCodexAppServerPreparedAuthHandoff as tt, isCodexAppServerStartSelectionChangedError as u, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS as ut, shared_client_exports as v, CodexThreadClientReplacementError as w, CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED as x, waitForCodexAppServerClientDesktopGenerationDrain as y, hasCodexAppServerSiblingThreadWork as z };