@openclaw/codex 2026.9.7 → 2026.10.1-beta.1

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

@@ -1,41 +1,41 @@
 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 { n as defineCodexBuildState, t as codexBuildSymbol } from "./build-state-CIi3Ckqu.mjs";
+import { t as CODEX_APP_SERVER_AUTH_PROVIDER } from "./auth-profile-selection-hr8ocLtz.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 { a as resolveCodexAppServerStartOptionsForAgent, d as readCodexEffectiveConfig, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey, u as CODEX_SESSION_OVERRIDABLE_LAYER_TYPES } from "./config-options-HG_Rr3W_.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-C1VFoVPf.mjs";
+import { A as waitForCodexDesktopGeneration, C as retirePendingSharedClientEntryIfUnclaimed, D as waitForUnclaimedSharedClientStartup, _ as observeSharedClientAcquire, a as readCodexCliAuthFileApiKey, b as releaseSharedClientEntry, c as resolveCodexAppServerPreparedApiKeyCacheKey, d as getCurrentSharedClientEntry, f as getOrCreateSharedClientEntry, g as observeAcquire, h as notifyDesktopGenerationDrainChecks, i as fingerprintTokenAuthProfileCacheKey, j as readCodexDesktopArtifactTreeFingerprint, k as isCodexDesktopGenerationCurrent, l as closeSharedClientEntryIfUnclaimed, 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 createCodexAppServerStartupLifetime, v as ownCodexStartup, w as retireSharedCodexAppServerClientIfCurrent, x as retainSharedClientEntry, y as recordSharedClientAcquireBoundary } from "./auth-cache-key-CEd9QlIs.mjs";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-a0HDa2Mj.mjs";
 import { n as CodexAppServerAuthProfileUnavailableError, r as formatCodexAuthProfileUnavailableMessage } from "./auth-profile-recovery-BREezV0L.mjs";
+import { a as codexPrewriteRejectionCause } from "./rpc-error-hmWM21RB.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 { n as readCodexSessionMeta } from "./session-catalog-provenance-CmsOE5mh.mjs";
+import { n as observeCodexCatalogClient } from "./session-catalog-events-KIXOoSnQ.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-cUYrqu_a.mjs";
+import { a as resolveCodexAppServerAuthProfileStore, i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId, t as isCodexAppServerNativeAuthProfile } from "./auth-profile-CgHQ8Vot.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 { R as isUnsupportedCodexAppServerVersionError, t as CodexAppServerClient } from "./client-CBzEVDyb.mjs";
+import { n as isCodexWebSocketOpenFailure } from "./transport-websocket-zqJ0Cmtn.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { AgentHarnessPreflightError, resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
-import { runExec } from "openclaw/plugin-sdk/process-runtime";
 import { addTimerTimeoutGraceMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { resolveGlobalMap } from "openclaw/plugin-sdk/global-singleton";
+import { runExec } from "openclaw/plugin-sdk/process-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 as formatErrorMessage$1 } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { ensureAuthProfileStore, findPersistedAuthProfileCredential, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolvePersistedAuthProfileOwnerAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { hasUsableOAuthCredential, resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
-import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { assertDirectoryIdentitySync, readDirectoryIdentity } from "@openclaw/fs-safe/advanced";
 import { assertNoSymlinkParents, pathScope } from "openclaw/plugin-sdk/security-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 //#region extensions/codex/src/app-server/attempt-timeouts.ts
 const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;
@@ -50,11 +50,8 @@ var CodexAppServerStartupError = class extends Error {
 	}
 };
 function isCodexAppServerStartupError(error, reason) {
-	return error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_STARTUP_CANCELLED" && "reason" in error && (error.reason === "aborted" || error.reason === "timed_out") && (reason === void 0 || error.reason === reason);
-}
-function resolvePositiveIntegerTimeoutMs(value, fallbackMs) {
-	const fallback = resolveTimerTimeoutMs(fallbackMs, 1);
-	return resolveTimerTimeoutMs(value, fallback);
+	const cause = codexPrewriteRejectionCause(error);
+	return cause instanceof Error && "code" in cause && cause.code === "CODEX_APP_SERVER_STARTUP_CANCELLED" && "reason" in cause && (cause.reason === "aborted" || cause.reason === "timed_out") && (reason === void 0 || cause.reason === reason);
 }
 async function withCodexStartupTimeout(params) {
 	if (params.signal.aborted) throw new CodexAppServerStartupError("aborted");
@@ -94,12 +91,12 @@ async function withCodexStartupTimeout(params) {
 	}
 }
 function resolveCodexStartupTimeoutMs(params) {
-	const timeoutFloorMs = resolvePositiveIntegerTimeoutMs(params.timeoutFloorMs, CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS);
-	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
+	const timeoutFloorMs = resolveTimerTimeoutMs(params.timeoutFloorMs, CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS);
+	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, timeoutFloorMs);
 	return Math.max(timeoutFloorMs, timeoutMs);
 }
 function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
-	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
+	const timeout = resolveTimerTimeoutMs(timeoutMs, 1);
 	const grace = resolveTimerTimeoutMs(graceMs, 0, 0);
 	return addTimerTimeoutGraceMs(timeout, grace) ?? timeout;
 }
@@ -222,49 +219,27 @@ const DEFAULT_CODEX_COMPUTER_USE_BUNDLED_MARKETPLACE_PATH = resolveMacOSDesktopC
 const DEFAULT_BUNDLED_MARKETPLACE_NAME = "openai-bundled";
 async function ensureCodexComputerUseSharedPluginCache(params) {
 	if (!params.config.enabled || params.config.pluginCacheMode === "independent" || params.config.marketplaceName || params.config.marketplacePath) return false;
-	const bundledMarketplacePath = resolveComputerUseBundledMarketplacePath(params);
+	const bundledMarketplacePath = params.bundledMarketplacePath ?? resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath({ candidates: params.bundledMarketplacePathCandidates }) ?? params.bundledMarketplacePathCandidates?.[0] ?? DEFAULT_CODEX_COMPUTER_USE_BUNDLED_MARKETPLACE_PATH;
 	const sourcePluginRoot = path.join(bundledMarketplacePath, "plugins", params.config.pluginName);
 	const version = await readBundledPluginVersion(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");
-	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 {
-		return;
-	}
-}
-async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, boundary) {
+	const cachePath = path.join(params.codexHome, "plugins", "cache", params.config.marketplaceName ?? DEFAULT_BUNDLED_MARKETPLACE_NAME, params.config.pluginName, version);
 	const cacheRoot = path.dirname(cachePath);
-	const ownedParent = boundary.ownershipRoot ? await prepareOwnedServiceParent({
-		ownershipRoot: boundary.ownershipRoot,
-		codexHome: boundary.codexHome,
+	const ownedParent = params.ownershipRoot ? await prepareOwnedServiceParent({
+		ownershipRoot: params.ownershipRoot,
+		codexHome: params.codexHome,
 		targetParent: cacheRoot
 	}) : void 0;
 	if (!ownedParent) await fs$1.mkdir(cacheRoot, { recursive: true });
 	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) {
+		if (await readBundledPluginVersion(physicalCachePath) === version && !params.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;
+			if (cachedMcp === sourceMcp) return true;
 		}
 	}
 	const cacheName = path.basename(cachePath);
@@ -279,13 +254,13 @@ async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, bou
 		await waitForCodexDesktopGeneration();
 		if (ownedParent) await assertDirectoryIdentityStable(ownedParent, "Computer Use plugin cache parent");
 		if (stat) {
-			boundary.assertCurrent?.();
+			params.assertCurrent?.();
 			await fs$1.rename(physicalCachePath, backupPath);
 			backupCreated = true;
 		}
 		try {
 			if (ownedParent) await assertDirectoryIdentityStable(ownedParent, "Computer Use plugin cache parent");
-			boundary.assertCurrent?.();
+			params.assertCurrent?.();
 			await fs$1.rename(stagedPath, physicalCachePath);
 		} catch (error) {
 			if (backupCreated) try {
@@ -310,6 +285,17 @@ async function ensureRealDirectoryCopy(cachePath, sourcePluginRoot, version, bou
 			force: true
 		});
 	}
+	return true;
+}
+async function readBundledPluginVersion(sourcePluginRoot) {
+	const pluginJsonPath = path.join(sourcePluginRoot, ".codex-plugin", "plugin.json");
+	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 {
+		return;
+	}
 }
 //#endregion
 //#region extensions/codex/src/app-server/computer-use-unified.ts
@@ -1001,29 +987,22 @@ async function bridgeCodexAppServerStartOptions(params) {
 }
 function assertNoUnimportedAgentCodexAuthFile(params) {
 	if (params.authRequirement === "api-key" && resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: params.startOptions })) return;
-	const message = resolveUnimportedAgentCodexAuthMessage(params);
-	if (message) throw new AgentHarnessPreflightError(message);
-}
-function resolveUnimportedAgentCodexAuthMessage(params) {
 	if (params.startOptions.transport !== "stdio" || params.startOptions.homeScope === "user") return;
 	const codexHome = resolveCodexAppServerHomeDir(params.agentDir);
 	const authPath = path.join(codexHome, CODEX_AUTH_JSON_FILENAME);
 	if (!fs.existsSync(authPath)) return;
 	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.`;
+	throw new AgentHarnessPreflightError(`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.`);
 }
 function resolveCodexAppServerAuthProfile(params) {
 	const agentDir = params.agentDir?.trim() || resolveDefaultAgentDir(params.config ?? {});
 	const store = resolveCodexAppServerAuthProfileStore({
-		agentDir,
-		authProfileId: params.authProfileId,
-		authProfileStore: params.authProfileStore,
-		config: params.config
+		...params,
+		agentDir
 	});
 	const profileId = resolveCodexAppServerAuthProfileId({
-		authProfileId: params.authProfileId,
-		store,
-		config: params.config
+		...params,
+		store
 	});
 	if (!profileId) return;
 	const credential = store.profiles[profileId];
@@ -1117,10 +1096,8 @@ async function resolveCodexAppServerPreparedAuthHandoff(params) {
 	};
 	if (!authProfileId || params.authRequirement === "subscription" && !nativeAuthProfile) throw createCodexAppServerAuthError(params.requirePreparedAuth ? "Codex remote-exec cloud placement requires prepared OpenAI auth. Configure an OpenAI API-key, OAuth, or token profile; ambient CODEX_API_KEY, OPENAI_API_KEY, and native Codex auth are not allowed." : params.subscriptionProfileRequiredError);
 	const snapshot = await resolveCodexAppServerPreparedAuthProfileSnapshot({
-		authProfileId,
-		authProfileStore: params.authProfileStore,
-		agentDir: params.agentDir,
-		config: params.config
+		...params,
+		authProfileId
 	});
 	if (!snapshot) throw createCodexAppServerAuthError(params.requirePreparedAuth ? "Codex remote-exec cloud placement could not prepare the selected OpenAI auth profile. Repair or replace the profile, then retry." : params.subscriptionProfileUnusableError);
 	return {
@@ -1337,7 +1314,11 @@ async function applyCodexAppServerAuthProfile(params) {
 		});
 	}
 	if (loginParams) {
-		await params.client.request("account/login/start", loginParams, { assertCurrent: params.assertCurrent });
+		try {
+			await params.client.request("account/login/start", loginParams, { assertCurrent: params.assertCurrent });
+		} catch (error) {
+			throw codexPrewriteRejectionCause(error);
+		}
 		if (loginParams.type === "chatgptAuthTokens") {
 			params.assertCurrent?.();
 			return {
@@ -1363,9 +1344,8 @@ async function assertNativeCodexAccountMatchesRoute(client, authRequirement, ass
 	}
 	if (accountType === "chatgpt") throw createCodexAppServerAuthError("Codex Platform route requires an API-key account, but the native Codex home is signed in with a ChatGPT subscription. Sign that home in with `codex login --with-api-key`, or set appServer.homeScope=\"agent\" so OpenClaw can inject its own key.");
 }
-function createCodexAppServerAuthError(message, cause) {
-	const error = cause === void 0 ? new Error(message) : new Error(message, { cause });
-	return Object.assign(error, { status: 401 });
+function createCodexAppServerAuthError(message) {
+	return Object.assign(new Error(message), { status: 401 });
 }
 async function refreshCodexAppServerAuthTokens(params) {
 	const previousAccountId = params.previousAccountId?.trim();
@@ -1374,9 +1354,8 @@ async function refreshCodexAppServerAuthTokens(params) {
 	if (previousAccountId) {
 		const store = resolveCodexAppServerAuthProfileStore(params);
 		const profileId = resolveCodexAppServerAuthProfileId({
-			authProfileId: params.authProfileId,
-			store,
-			config: params.config
+			...params,
+			store
 		});
 		const credential = profileId ? store.profiles[profileId] : void 0;
 		const selectedAccountId = credential ? resolveExplicitChatgptAccountId(credential) ?? (credential.type === "oauth" ? resolveOpenAICodexAuthIdentity({ access: credential.access }).accountId : void 0) : void 0;
@@ -1395,16 +1374,10 @@ async function refreshCodexAppServerAuthTokens(params) {
 	};
 }
 async function resolveCodexAppServerAuthProfileLoginParamsInternal(params) {
-	const store = resolveCodexAppServerAuthProfileStore({
-		agentDir: params.agentDir,
-		authProfileId: params.authProfileId,
-		authProfileStore: params.authProfileStore,
-		config: params.config
-	});
+	const store = resolveCodexAppServerAuthProfileStore(params);
 	const profileId = resolveCodexAppServerAuthProfileId({
-		authProfileId: params.authProfileId,
-		store,
-		config: params.config
+		...params,
+		store
 	});
 	if (!profileId) return;
 	const credential = store.profiles[profileId];
@@ -1449,7 +1422,6 @@ async function resolveLoginParamsForCredential(profileId, credential, params) {
 			apiKey: value
 		} : buildChatgptAuthTokensParams(profileId, credential, value);
 	}
-	if (credential.type !== "oauth") return;
 	const resolvedCredential = await resolveOAuthCredentialForCodexAppServer(profileId, credential, {
 		agentDir: params.agentDir,
 		store: params.store,
@@ -1594,9 +1566,7 @@ function isCodexAppServerAuthProvider(provider) {
 }
 function shouldClearOpenAiApiKeyForCodexAuthProfile(params) {
 	const profileId = params.authProfileId?.trim();
-	return isCodexSubscriptionCredential(profileId ? params.store.profiles[profileId] : params.store.profiles[OPENAI_CODEX_DEFAULT_PROFILE_ID]);
-}
-function isCodexSubscriptionCredential(credential) {
+	const credential = profileId ? params.store.profiles[profileId] : params.store.profiles[OPENAI_CODEX_DEFAULT_PROFILE_ID];
 	if (!credential || !isCodexAppServerAuthProvider(credential.provider)) return false;
 	return credential.type === "oauth" || credential.type === "token";
 }
@@ -1638,6 +1608,7 @@ function createThreadOwnerToken(threadId, onInvalidated) {
 		invalidate: () => {
 			if (owner.invalidated) return;
 			owner.invalidated = true;
+			owner.releaseAfterProtection = void 0;
 			try {
 				onInvalidated?.();
 			} catch (error) {
@@ -1689,30 +1660,91 @@ function forgetThreadOwnership(runtime, threadId, owner) {
 	if (forgotten) owner.invalidate();
 	return forgotten;
 }
-/** Compaction discards client-authored catalog refreshes, not creation policy. */
-function revertRetainedThreadSkillsCatalog(runtime, threadId) {
+/** Compaction discards client-authored instruction refreshes, not creation policy. */
+function revertRetainedThreadInstructions(runtime, threadId) {
 	const retained = runtime.retainedThreads.get(threadId);
 	if (retained?.ephemeralPolicy) retained.ephemeralPolicy = {
 		...retained.ephemeralPolicy,
-		skillsInstructions: retained.ephemeralPolicy.nativeSkillsInstructions
+		refreshableInstructions: retained.ephemeralPolicy.nativeRefreshableInstructions
 	};
 }
-function createCodexEphemeralThreadPolicy({ developerInstructions, skillsInstructions }) {
+function createCodexEphemeralThreadPolicy({ developerInstructions, refreshableInstructions }) {
 	return {
 		developerInstructions,
-		skillsInstructions,
-		nativeSkillsInstructions: skillsInstructions
+		refreshableInstructions,
+		nativeRefreshableInstructions: refreshableInstructions
 	};
 }
+/** Final process settlement releases only the exact deferred physical claim. */
+function releaseThreadProtection(runtime, threadId) {
+	const count = runtime.protectedThreads.get(threadId) ?? 0;
+	if (count > 1) {
+		runtime.protectedThreads.set(threadId, count - 1);
+		return false;
+	}
+	runtime.protectedThreads.delete(threadId);
+	const claimed = runtime.claimedThreads.get(threadId);
+	const release = claimed?.releaseAfterProtection;
+	if (claimed) claimed.releaseAfterProtection = void 0;
+	if (release) release().catch((error) => {
+		embeddedAgentLog$1.warn("codex protected thread release failed", {
+			threadId,
+			reason: formatErrorMessage$1(error)
+		});
+	});
+	return true;
+}
+//#endregion
+//#region extensions/codex/src/app-server/client-workspace-state.ts
+function prepareCodexWorkspaceReferenceState(state, threadId, reference) {
+	const digest = createHash("sha256").update(reference ?? "").digest("hex");
+	const previous = state?.workspaceReferences.get(threadId) ?? { needsReintroduction: true };
+	if (state && !state.closed) state.workspaceReferences.set(threadId, previous);
+	return {
+		include: previous.needsReintroduction || previous.digest !== digest,
+		accepted: () => {
+			if (!state || state.closed || state.workspaceReferences.get(threadId) !== previous) return;
+			state.workspaceReferences.set(threadId, {
+				digest,
+				needsReintroduction: false
+			});
+		}
+	};
+}
+async function readCodexWorkspaceSessionMeta(client, state, sessionsRoot, boundRolloutPath, threadId, maxCachedSessions) {
+	let rolloutPath = boundRolloutPath;
+	if (!state || state.closed) throw new Error("Codex native metadata requires a live selected client");
+	const cached = state.sessionMetadata.get(threadId);
+	if (cached && cached.sessionsRoot === sessionsRoot && (!rolloutPath || cached.rolloutPath === rolloutPath)) return structuredClone(cached.metadata);
+	if (!rolloutPath) {
+		const { thread } = await client.request("thread/read", {
+			threadId,
+			includeTurns: false
+		});
+		if (thread.id !== threadId || !thread.path) throw new Error("Codex native metadata has no verified thread path");
+		rolloutPath = thread.path;
+	}
+	const metadata = await readCodexSessionMeta(sessionsRoot, rolloutPath, threadId);
+	if (state.closed || !metadata) throw new Error("Codex native metadata is unavailable on the selected client");
+	state.sessionMetadata.delete(threadId);
+	state.sessionMetadata.set(threadId, {
+		sessionsRoot,
+		rolloutPath,
+		metadata
+	});
+	pruneMapToMaxSize(state.sessionMetadata, maxCachedSessions);
+	return structuredClone(metadata);
+}
 //#endregion
 //#region extensions/codex/src/app-server/rate-limit-cache.ts
+/** Client-owned Codex app-server rate-limit snapshots. */
 const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 6e5;
 const SPARSE_ACCOUNT_METADATA_KEYS = [
 	"credits",
 	"individualLimit",
 	"planType"
 ];
-const rateLimitsByClient = /* @__PURE__ */ new WeakMap();
+const rateLimitsByClient = defineCodexBuildState("openclaw.codexAppServerRateLimits", () => /* @__PURE__ */ new WeakMap())();
 /** Replaces one physical client's cache with an authoritative rate-limit read response. */
 function rememberCodexRateLimitsRead(client, value, nowMs = Date.now()) {
 	if (value !== void 0) {
@@ -1811,9 +1843,11 @@ const CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS = 18e5;
 const CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE = 64;
 /** Return a deterministic error before Codex cancels its ten-second external-auth request. */
 const CODEX_EXTERNAL_AUTH_REFRESH_TIMEOUT_MS = 9e3;
-const configuredClients = /* @__PURE__ */ new WeakMap();
-const physicalThreadReleases = /* @__PURE__ */ new WeakMap();
-const claimedThreadReleaseTokens = /* @__PURE__ */ new WeakMap();
+const { configuredClients, physicalThreadReleases, claimedThreadReleaseTokens } = defineCodexBuildState("openclaw.codexAppServerClientRuntime", () => ({
+	configuredClients: /* @__PURE__ */ new WeakMap(),
+	physicalThreadReleases: /* @__PURE__ */ new WeakMap(),
+	claimedThreadReleaseTokens: /* @__PURE__ */ new WeakMap()
+}))();
 /** Only an initialized, still-open physical client can own retained native subscriptions. */
 function isCodexAppServerClientRuntimeLive(client) {
 	const runtime = configuredClients.get(client);
@@ -1829,46 +1863,11 @@ function forgetCodexWorkspaceReferences(client, threadId) {
 }
 /** Record accepted input without clearing a compaction observed during turn/start. */
 function prepareCodexWorkspaceReferences(client, threadId, reference) {
-	const runtime = configuredClients.get(client);
-	const digest = createHash("sha256").update(reference ?? "").digest("hex");
-	const previous = runtime?.workspaceReferences.get(threadId) ?? { needsReintroduction: true };
-	if (runtime && !runtime.closed) runtime.workspaceReferences.set(threadId, previous);
-	return {
-		include: previous.needsReintroduction || previous.digest !== digest,
-		accepted: () => {
-			if (!runtime || runtime.closed || runtime.workspaceReferences.get(threadId) !== previous) return;
-			runtime.workspaceReferences.set(threadId, {
-				digest,
-				needsReintroduction: false
-			});
-		}
-	};
+	return prepareCodexWorkspaceReferenceState(configuredClients.get(client), threadId, reference);
 }
 /** Immutable declarations are data owned by this physical client, never retained executors. */
 async function readCodexClientSessionMeta(client, sessionsRoot, boundRolloutPath, threadId) {
-	let rolloutPath = boundRolloutPath;
-	const runtime = configuredClients.get(client);
-	if (!runtime || runtime.closed) throw new Error("Codex native metadata requires a live selected client");
-	const cached = runtime.sessionMetadata.get(threadId);
-	if (cached && cached.sessionsRoot === sessionsRoot && (!rolloutPath || cached.rolloutPath === rolloutPath)) return structuredClone(cached.metadata);
-	if (!rolloutPath) {
-		const { thread } = await client.request("thread/read", {
-			threadId,
-			includeTurns: false
-		});
-		if (thread.id !== threadId || !thread.path) throw new Error("Codex native metadata has no verified thread path");
-		rolloutPath = thread.path;
-	}
-	const metadata = await readCodexSessionMeta(sessionsRoot, rolloutPath, threadId);
-	if (runtime.closed || !metadata) throw new Error("Codex native metadata is unavailable on the selected client");
-	runtime.sessionMetadata.delete(threadId);
-	runtime.sessionMetadata.set(threadId, {
-		sessionsRoot,
-		rolloutPath,
-		metadata
-	});
-	pruneMapToMaxSize(runtime.sessionMetadata, CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE);
-	return structuredClone(metadata);
+	return readCodexWorkspaceSessionMeta(client, configuredClients.get(client), sessionsRoot, boundRolloutPath, threadId, CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE);
 }
 /** Installs one auth-refresh handler and one rate-limit observer per physical client. */
 function ensureCodexAppServerClientRuntime(client, context) {
@@ -1922,7 +1921,6 @@ function ensureCodexAppServerClientRuntime(client, context) {
 				...runtime.context.authProfileStore ? { authProfileStore: runtime.context.authProfileStore } : {},
 				config: runtime.context.config
 			}), CODEX_EXTERNAL_AUTH_REFRESH_TIMEOUT_MS, "Codex app-server ChatGPT token refresh timed out before its external-auth deadline. Retry the request; if it persists, sign in again with OpenClaw.");
-			if (previousAccountId && tokens.chatgptAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
 			if (runtime.closed) throw new Error("Codex app-server client closed during ChatGPT token refresh.");
 			runtime.authHandoff = {
 				accessFingerprint: fingerprintTokenAuthProfileCacheKey(tokens.accessToken),
@@ -1975,7 +1973,7 @@ function scheduleRetainedThreadEviction(client, runtime) {
 	}, Math.max(0, expiresAt - Date.now()));
 	runtime.evictionTimer.unref?.();
 }
-async function releaseRetainedThread(client, runtime, threadId, assertCurrent) {
+async function releaseRetainedThread(client, runtime, threadId, assertCurrent, withCurrent) {
 	const pendingRelease = runtime.releasingThreads.get(threadId);
 	if (pendingRelease) {
 		await pendingRelease.completion;
@@ -1995,7 +1993,7 @@ async function releaseRetainedThread(client, runtime, threadId, assertCurrent) {
 		retainedOwnerToken: retained.ownerToken,
 		completion: Promise.resolve().then(() => {
 			assertCurrent?.();
-			return assertCurrent ? retained.release(threadId, assertCurrent) : retained.release(threadId);
+			return withCurrent ? retained.release(threadId, assertCurrent, withCurrent) : assertCurrent ? retained.release(threadId, assertCurrent) : retained.release(threadId);
 		})
 	};
 	runtime.releasingThreads.set(threadId, transition);
@@ -2051,8 +2049,8 @@ async function retainCodexAppServerLiveThread(client, threadId, releaseThread, c
 		ephemeralPolicy,
 		serviceTier,
 		expiresAt: ephemeralPolicy === void 0 ? Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS : Number.POSITIVE_INFINITY,
-		release: (releaseThread ? physicalThreadReleases.get(releaseThread) ?? releaseThread : void 0) ?? (async (releasedThreadId, assertCurrent) => {
-			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent);
+		release: (releaseThread ? physicalThreadReleases.get(releaseThread) ?? releaseThread : void 0) ?? (async (releasedThreadId, assertCurrent, withCurrent) => {
+			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent, withCurrent);
 		})
 	};
 	runtime.retainedThreads.set(threadId, retained);
@@ -2097,8 +2095,8 @@ async function claimCodexAppServerLiveThread(client, threadId, onInvalidated) {
 	}
 	return claimCodexAppServerThreadOwnership(client, runtime, threadId, runtime.retainedThreads.get(threadId) ?? {
 		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
-		release: async (releasedThreadId, assertCurrent) => {
-			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent);
+		release: async (releasedThreadId, assertCurrent, withCurrent) => {
+			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent, withCurrent);
 		}
 	}, onInvalidated);
 }
@@ -2113,13 +2111,13 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained,
 	const assertCurrent = () => {
 		if (claimed.invalidated || runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) throw new Error(`Codex thread subscription ownership changed: ${threadId}`);
 	};
-	const release = async (releasedThreadId, assertReleaseCurrent) => {
+	const release = async (releasedThreadId, assertReleaseCurrent, withCurrent) => {
 		if (releasedThreadId !== threadId || claimed.invalidated) {
 			assertReleaseCurrent?.();
 			return;
 		}
 		if (runtime.claimedThreads.get(threadId) !== claimed) {
-			if (runtime.retainedThreads.get(threadId)?.ownerToken === claimed) await releaseRetainedThread(client, runtime, threadId, assertReleaseCurrent);
+			if (runtime.retainedThreads.get(threadId)?.ownerToken === claimed) await releaseRetainedThread(client, runtime, threadId, assertReleaseCurrent, withCurrent);
 			else {
 				const pendingRelease = runtime.releasingThreads.get(threadId);
 				if (pendingRelease?.retainedOwnerToken === claimed) await pendingRelease.completion;
@@ -2127,6 +2125,10 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained,
 			}
 			return;
 		}
+		if (runtime.protectedThreads.has(threadId)) {
+			claimed.releaseAfterProtection = () => release(releasedThreadId, assertReleaseCurrent, withCurrent);
+			return;
+		}
 		const pendingRelease = runtime.releasingThreads.get(threadId);
 		if (pendingRelease) {
 			await pendingRelease.completion;
@@ -2138,7 +2140,7 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained,
 				return;
 			}
 			assertReleaseCurrent?.();
-			await (assertReleaseCurrent ? retained.release(releasedThreadId, assertReleaseCurrent) : retained.release(releasedThreadId));
+			await (withCurrent ? retained.release(releasedThreadId, assertReleaseCurrent, withCurrent) : assertReleaseCurrent ? retained.release(releasedThreadId, assertReleaseCurrent) : retained.release(releasedThreadId));
 		}) };
 		runtime.releasingThreads.set(threadId, transition);
 		try {
@@ -2169,9 +2171,9 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained,
 	};
 }
 /** Standalone incognito compaction retains its separately owned subscription. */
-function revertCodexAppServerLiveThreadSkillsCatalog(client, threadId) {
+function revertCodexAppServerLiveThreadInstructions(client, threadId) {
 	const runtime = configuredClients.get(client);
-	if (runtime && !runtime.closed) revertRetainedThreadSkillsCatalog(runtime, threadId);
+	if (runtime && !runtime.closed) revertRetainedThreadInstructions(runtime, threadId);
 }
 /** Distinguish active claimed ownership from an already-evicted idle subscription. */
 function hasCodexAppServerLiveThread(client, threadId) {
@@ -2185,7 +2187,7 @@ function hasCodexAppServerSiblingThreadWork(client, threadId) {
 	return hasSiblingThreadWork(configuredClients.get(client), threadId);
 }
 /** Release the exact physical subscription and finish only its observed ownership generation. */
-async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs, assertCurrent) {
+async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs, assertCurrent, withCurrent) {
 	const runtime = configuredClients.get(client);
 	const claimed = runtime?.claimedThreads.get(threadId);
 	const retained = runtime?.retainedThreads.get(threadId);
@@ -2203,7 +2205,8 @@ async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs,
 		assertCurrent?.();
 		await client.request("thread/unsubscribe", { threadId }, {
 			timeoutMs,
-			assertCurrent
+			assertCurrent,
+			...withCurrent ? { withCurrent } : {}
 		});
 		assertCurrent?.();
 		runtime?.workspaceReferences.delete(threadId);
@@ -2233,9 +2236,9 @@ async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs,
 	}
 }
 /** Reset/end owns the exact thread; failed generation retirement must never release its successor. */
-async function releaseCodexAppServerLiveThread(client, threadId, assertCurrent) {
+async function releaseCodexAppServerLiveThread(client, threadId, assertCurrent, withCurrent) {
 	const runtime = configuredClients.get(client);
-	return runtime ? await releaseRetainedThread(client, runtime, threadId, assertCurrent) : false;
+	return runtime ? await releaseRetainedThread(client, runtime, threadId, assertCurrent, withCurrent) : false;
 }
 /** Native child work pins its parent's subscription even after the foreground parent turn ends. */
 function protectCodexAppServerLiveThread(client, threadId) {
@@ -2248,16 +2251,14 @@ function protectCodexAppServerLiveThread(client, threadId) {
 		if (!protectedThread) return;
 		protectedThread = false;
 		if (runtime.closed) return;
-		const count = runtime.protectedThreads.get(threadId) ?? 0;
-		if (count <= 1) {
-			runtime.protectedThreads.delete(threadId);
+		if (releaseThreadProtection(runtime, threadId)) {
 			const retained = runtime.retainedThreads.get(threadId);
 			if (retained) {
 				if (retained.ephemeralPolicy === void 0) retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
 				runtime.retainedThreads.delete(threadId);
 				runtime.retainedThreads.set(threadId, retained);
 			}
-		} else runtime.protectedThreads.set(threadId, count - 1);
+		}
 		scheduleRetainedThreadEviction(client, runtime);
 		evictExcessIdleThreads(client, runtime).catch((error) => {
 			embeddedAgentLog$1.warn("codex retained thread unpin eviction failed", {
@@ -2442,7 +2443,11 @@ async function prepareCodexInferenceRoute(params) {
 		params.assertCurrent();
 	};
 	assertCurrent();
-	const snapshot = params.effectiveConfig ?? await readCodexEffectiveConfig(params.client, params.cwd, { signal: params.signal });
+	const snapshot = params.effectiveConfig ?? await readCodexEffectiveConfig(params.client, params.cwd, {
+		signal: params.signal,
+		assertCurrent: params.assertCurrent,
+		...params.authority ? { withCurrent: params.authority.withCurrent } : {}
+	});
 	assertCurrent();
 	const unsupported = () => {
 		if (owner.oauth) throw new Error("ChatGPT subscription sharing requires the managed public Responses inference route.");
@@ -2480,14 +2485,13 @@ async function prepareCodexInferenceRoute(params) {
 	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,
+		withCurrent: params.authority?.withCurrent
 	});
 	assertCurrent();
 	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 { isBlockedHostnameOrIp } = await import("openclaw/plugin-sdk/ssrf-runtime");
 	assertCurrent();
@@ -2503,7 +2507,6 @@ async function prepareCodexInferenceRoute(params) {
 	].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,
@@ -2513,47 +2516,59 @@ async function prepareCodexInferenceRoute(params) {
 		preserveCodexBackendRoutes,
 		modelPolicyEnforced
 	]);
-	let pending = owner.routes.get(key);
-	if (!pending) {
-		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,
-				oauth: owner.oauth,
-				preserveAzureUrlFeatures,
-				preserveCodexBackendRoutes,
-				bindModelExecution: createCodexInferenceModelBinding({
-					client,
-					provider,
-					modelPolicyEnforced,
+	const prepareRoute = () => {
+		assertCurrent();
+		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;
+		owner.memoryConfigured ||= memoryFeature === true;
+		let pending = owner.routes.get(key);
+		if (!pending) {
+			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-DUO5E2QQ.mjs"),
+				import("./native-subagent-monitor-CCEFO6qK.mjs").then((n) => n.n),
+				import("./inference-dispatch-B5UKEUyC.mjs")
+			]).then(([{ createCodexInferenceProxy }, native, { createCodexInferenceModelBinding }]) => {
+				assertClient();
+				return createCodexInferenceProxy({
+					upstream: target,
 					assertCurrent: assertClient,
-					memoryConfigured: () => owner.memoryConfigured,
-					captureModelSource: native.codexNativeSubagentMonitorRuntime.captureModelSource,
-					resolveModelThreadId: native.codexNativeSubagentMonitorRuntime.resolveModelThreadId
-				})
+					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);
+		}
+		return { pending };
+	};
+	const prepared = params.authority ? await params.authority.withCurrent(prepareRoute) : prepareRoute();
+	if (!prepared) return;
+	const route = await prepared.pending;
+	const publish = () => {
+		assertCurrent();
+		route.assertCurrent();
+		params.client.protectPrivateTransportSecret(new URL(route.baseUrl).pathname.split("/")[1] ?? "");
+		owner.handles.set(route, {
+			provider,
+			kind,
+			modelPolicyEnforced
 		});
-		owner.routes.set(key, pending);
-	}
-	const route = await pending;
-	assertCurrent();
-	route.assertCurrent();
-	params.client.protectPrivateTransportSecret(new URL(route.baseUrl).pathname.split("/")[1] ?? "");
-	owner.handles.set(route, {
-		provider,
-		kind,
-		modelPolicyEnforced
-	});
-	return route;
+		return route;
+	};
+	return params.authority ? await params.authority.withCurrent(publish) : publish();
 }
 /** Prepare a managed thread without changing an attached or unsupported native profile. */
 async function prepareCodexInferenceThreadConfig(params) {
@@ -2576,7 +2591,11 @@ async function prepareCodexInferenceThreadConfig(params) {
 	}
 	params.signal?.throwIfAborted();
 	params.assertCurrent();
-	const effectiveConfig = params.effectiveConfig ?? await readCodexEffectiveConfig(params.client, params.cwd, { signal: params.signal });
+	const effectiveConfig = params.effectiveConfig ?? await readCodexEffectiveConfig(params.client, params.cwd, {
+		signal: params.signal,
+		assertCurrent: params.assertCurrent,
+		...params.authority ? { withCurrent: params.authority.withCurrent } : {}
+	});
 	params.signal?.throwIfAborted();
 	params.assertCurrent();
 	const route = retained?.route ?? await prepareCodexInferenceRoute({
@@ -2590,8 +2609,10 @@ async function prepareCodexInferenceThreadConfig(params) {
 			includeTurns: false
 		}, {
 			signal: params.signal,
-			assertCurrent: params.assertCurrent
+			assertCurrent: params.assertCurrent,
+			withCurrent: params.authority?.withCurrent
 		});
+		params.signal?.throwIfAborted();
 		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");
 	}
@@ -2710,22 +2731,20 @@ async function acquireCodexNativeConfigFence(key, options = {}) {
 	const previous = state.get(key) ?? Promise.resolve();
 	const { promise: current, resolve: resolveCurrent } = createDeferred();
 	state.set(key, current);
-	try {
-		await waitForPreviousFence(previous, options);
-	} catch (error) {
-		previous.then(() => {
-			resolveCurrent();
-			if (state.get(key) === current) state.delete(key);
-		});
-		throw error;
-	}
 	let released = false;
-	return () => {
+	const release = () => {
 		if (released) return;
 		released = true;
 		resolveCurrent();
 		if (state.get(key) === current) state.delete(key);
 	};
+	try {
+		await waitForPreviousFence(previous, options);
+	} catch (error) {
+		previous.then(release);
+		throw error;
+	}
+	return release;
 }
 async function waitForPreviousFence(previous, options) {
 	if (options.signal?.aborted) throw new Error(options.abortMessage ?? "Codex native config fence aborted");
@@ -2761,20 +2780,25 @@ const pending = /* @__PURE__ */ new Set();
 const closing = /* @__PURE__ */ new Set();
 /** Owns delayed hook-relay cleanup across runtime scheduling and test teardown. */
 const nativeHookRelayUnregisterQueue = {
-	add(entry) {
+	schedule(relay, delayMs) {
+		const unregister = () => {
+			if (!pending.delete(entry)) return;
+			relay.unregister();
+			nativeHookRelayUnregisterQueue.track(relay.drain());
+		};
+		const entry = {
+			timeout: setTimeout(unregister, delayMs),
+			unregister
+		};
 		pending.add(entry);
-	},
-	delete(entry) {
-		return pending.delete(entry);
+		entry.timeout.unref();
 	},
 	track(operation) {
 		closing.add(operation);
 		operation.then(() => closing.delete(operation), () => closing.delete(operation));
 	},
 	async flush() {
-		while (pending.size > 0) {
-			const entry = pending.values().next().value;
-			if (!entry) break;
+		for (const entry of pending) {
 			clearTimeout(entry.timeout);
 			entry.unregister();
 		}
@@ -2804,7 +2828,8 @@ function resolveCodexAppServerSpawnIdentity(startOptions, resolvedNativeCommand)
 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";
+	const cause = codexPrewriteRejectionCause(error);
+	return cause instanceof Error && "code" in cause && cause.code === "CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED";
 }
 var CodexThreadStartRequestError = class extends Error {
 	constructor(cause) {
@@ -2865,6 +2890,7 @@ async function prepareCodexAppServerClient(options) {
 	};
 	assertCurrent();
 	const startedAt = performance.now();
+	observeAcquire(options, { boundary: "context" });
 	return {
 		context: await withCodexAppServerAcquireDeadline(options?.timeoutMs ?? 0, ownCodexStartup(lifetime, resolveCodexAppServerClientStartContext(options)), abandonSignal),
 		lifetime,
@@ -2915,7 +2941,8 @@ var CodexAppServerStartSelectionChangedError = class extends Error {
 };
 /** Cross-bundle-safe check for a managed executable selection retry. */
 function isCodexAppServerStartSelectionChangedError(error) {
-	return error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_START_SELECTION_CHANGED";
+	const cause = codexPrewriteRejectionCause(error);
+	return cause instanceof Error && "code" in cause && cause.code === "CODEX_APP_SERVER_START_SELECTION_CHANGED";
 }
 /**
 * Rechecks mutable Codex-owned plugin state immediately before thread start/resume.
@@ -3101,6 +3128,7 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 	const state = getSharedCodexAppServerClientState();
 	const { context, lifetime, abandonSignal, startedAt, assertCurrent } = await prepareCodexAppServerClient(options);
 	assertCurrent();
+	observeAcquire(options, { boundary: "entry-selection" });
 	const { usesNativeAuth, ...startContext } = context;
 	const { agentDir, authProfileId, authProfileStore, preparedAuth, authRequirement, startOptions, desktopGeneration } = startContext;
 	const remainingTimeoutMs = resolveRemainingAcquireTimeout(timeoutMs, startedAt);
@@ -3124,12 +3152,14 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 	entry.startupAbort ??= new AbortController();
 	entry.closeWhenIdle = false;
 	const releasePendingAcquire = retainSharedClientEntry(entry, "pendingAcquires");
+	const stopAcquireObservations = observeSharedClientAcquire(entry, options);
 	const startedCallback = options?.onStartedClient;
 	if (startedCallback) {
 		entry.onStartedClientCallbacks.add(startedCallback);
 		if (entry.client) startedCallback(entry.client);
 	}
 	const stopStartedClientNotifications = () => {
+		stopAcquireObservations();
 		if (startedCallback) entry.onStartedClientCallbacks.delete(startedCallback);
 	};
 	let cleanupAbandonSignal;
@@ -3172,6 +3202,7 @@ async function acquireSharedCodexAppServerClient(options, leased = false) {
 	} catch (error) {
 		releasePendingAcquire();
 		retirePendingSharedClientEntryIfUnclaimed(entry);
+		observeAcquire(options, { boundary: "cleanup" });
 		await waitForUnclaimedSharedClientStartup(entry);
 		throw error;
 	} finally {
@@ -3188,6 +3219,9 @@ function createSharedCodexAppServerClientStartup(params) {
 	const initialized = createDeferred();
 	const ready = ownCodexStartup(params.lifetime, startInitializedCodexAppServerClient({
 		...params,
+		onAcquireObservation: ({ boundary }) => {
+			recordSharedClientAcquireBoundary(params.entry, boundary);
+		},
 		onStartingClient: (starting) => {
 			params.entry.startupTransport = starting;
 		},
@@ -3231,6 +3265,10 @@ async function createIsolatedCodexAppServerClient(options) {
 	assertCurrent();
 	const timeoutMs = options?.timeoutMs ?? 0;
 	const { usesNativeAuth, ...startContext } = context;
+	observeAcquire(options, {
+		boundary: "entry-selection",
+		startup: "isolated"
+	});
 	return await ownCodexStartup(lifetime, startInitializedCodexAppServerClient({
 		...startContext,
 		lifetime,
@@ -3241,20 +3279,18 @@ async function createIsolatedCodexAppServerClient(options) {
 		timeoutMs: resolveRemainingAcquireTimeout(timeoutMs, startedAt),
 		abandonSignal,
 		assertCurrent: options?.assertCurrent,
+		onAcquireObservation: options?.onAcquireObservation,
 		onStartedClient: (client) => {
-			trackIsolatedCodexAppServerClient(client);
+			const state = getSharedCodexAppServerClientState();
+			state.isolatedClients.add(client);
+			client.addTransportExitHandler((exitedClient) => {
+				state.isolatedClients.delete(exitedClient);
+				notifyDesktopGenerationDrainChecks(state);
+			});
 			options?.onStartedClient?.(client);
 		}
 	}));
 }
-function trackIsolatedCodexAppServerClient(client) {
-	const state = getSharedCodexAppServerClientState();
-	state.isolatedClients.add(client);
-	client.addTransportExitHandler((exitedClient) => {
-		state.isolatedClients.delete(exitedClient);
-		notifyDesktopGenerationDrainChecks(state);
-	});
-}
 function startInitializedCodexAppServerClient(params) {
 	return withCodexWebSocketOpenRetry({
 		timeoutMs: params.timeoutMs ?? 0,
@@ -3276,6 +3312,7 @@ async function startInitializedCodexAppServerClientOnce(params) {
 	const startOptionsCandidates = resolveManagedFallbackStartOptions(params.startOptions);
 	for (const [index, startOptions] of startOptionsCandidates.entries()) {
 		params.assertCurrent?.();
+		observeAcquire(params, { boundary: "prestart-artifact-drain" });
 		const desktopCommand = isManagedCodexDesktopCommand(startOptions.command);
 		const desktopGeneration = params.desktopGeneration ?? (desktopCommand ? await waitForStartup(waitForCodexDesktopGeneration) : void 0);
 		const assertStartupCurrent = () => {
@@ -3312,7 +3349,7 @@ async function startInitializedCodexAppServerClientOnce(params) {
 		} finally {
 			artifactDrain?.cancel();
 		}
-		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-DDQ-HGXf.mjs") : void 0;
+		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-CUTOOnKw.mjs") : void 0;
 		const runtimeArtifactBeforeStart = runtimeArtifactModule ? await runtimeArtifactModule.captureCodexAppServerRuntimeArtifactBeforeStart({
 			startOptions,
 			spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions),
@@ -3326,6 +3363,7 @@ async function startInitializedCodexAppServerClientOnce(params) {
 		let starting;
 		let client;
 		try {
+			observeAcquire(params, { boundary: "transport-registration" });
 			client = await waitForStartup(() => {
 				starting = CodexAppServerClient.start(startOptions, () => {
 					assertStartupCurrent();
@@ -3335,7 +3373,10 @@ async function startInitializedCodexAppServerClientOnce(params) {
 				return starting;
 			});
 		} catch (error) {
-			if (starting) await ownCodexStartup(params.lifetime, starting.then((lateClient) => lateClient.closeAndWait(), () => {}));
+			if (starting) {
+				observeAcquire(params, { boundary: "cleanup" });
+				await ownCodexStartup(params.lifetime, starting.then((lateClient) => lateClient.closeAndWait(), () => {}));
+			}
 			throw error;
 		}
 		client.addCloseHandler((closedClient) => {
@@ -3353,18 +3394,21 @@ async function startInitializedCodexAppServerClientOnce(params) {
 			});
 			assertStartupCurrent();
 			params.onStartedClient?.(client);
+			observeAcquire(params, { boundary: "initialize" });
 			try {
 				await waitForStartup(() => client.initialize(), CODEX_APP_SERVER_INITIALIZE_TIMEOUT_MESSAGE, () => buildCodexAppServerInitializeTimeoutError(client));
 			} catch (error) {
-				if (shouldTryManagedFallbackStartOption(error, startOptions, index, startOptionsCandidates)) continue;
+				if (startOptions.commandSource === "resolved-managed" && index < startOptionsCandidates.length - 1 && isUnsupportedCodexAppServerVersionError(error)) continue;
 				throw error;
 			}
 			assertStartupCurrent();
 			params.onInitializedClient?.();
+			observeAcquire(params, { boundary: "catalog-observation" });
 			await waitForStartup(() => observeCodexCatalogClient(client, {
 				startOptions: params.requestedStartOptions,
 				agentDir: params.agentDir
 			}));
+			observeAcquire(params, { boundary: "runtime-binding" });
 			let runtimeArtifact;
 			if (runtimeArtifactModule && runtimeArtifactBeforeStart) {
 				runtimeArtifact = await runtimeArtifactModule.finalizeCodexAppServerRuntimeArtifact({
@@ -3385,6 +3429,7 @@ async function startInitializedCodexAppServerClientOnce(params) {
 				onAuthRefreshFailure: () => retireSharedCodexAppServerClientIfCurrent(client)
 			});
 			assertStartupCurrent();
+			observeAcquire(params, { boundary: "auth-handoff" });
 			const authHandoff = await waitForStartup(() => applyCodexAppServerAuthProfile({
 				client,
 				agentDir: params.agentDir,
@@ -3423,9 +3468,13 @@ async function startInitializedCodexAppServerClientOnce(params) {
 				}
 			}, () => Boolean(retireSharedCodexAppServerClientIfCurrent(client)));
 			ready = true;
+			observeAcquire(params, { boundary: "ready" });
 			return client;
 		} finally {
-			if (!ready) await ownCodexStartup(params.lifetime, client.closeAndWait());
+			if (!ready) {
+				observeAcquire(params, { boundary: "cleanup" });
+				await ownCodexStartup(params.lifetime, client.closeAndWait());
+			}
 		}
 	}
 	throw new Error("Managed Codex app-server fallback candidates were exhausted.");
@@ -3448,9 +3497,6 @@ function resolveManagedFallbackStartOptions(startOptions) {
 	}
 	return candidates;
 }
-function shouldTryManagedFallbackStartOption(error, startOptions, index, startOptionsCandidates) {
-	return startOptions.commandSource === "resolved-managed" && index < startOptionsCandidates.length - 1 && isUnsupportedCodexAppServerVersionError(error);
-}
 function clearSharedCodexAppServerClientIfCurrent(client) {
 	if (!client) return false;
 	const state = getSharedCodexAppServerClientState();
@@ -3500,11 +3546,8 @@ function createOlderDesktopGenerationDrainWait(params) {
 		cancel: () => void 0
 	};
 	const state = getSharedCodexAppServerClientState();
-	let settled = false;
 	const { promise, resolve: resolveWait } = createDeferred();
 	const cancel = () => {
-		if (settled) return;
-		settled = true;
 		state.desktopGenerationDrainChecks.delete(check);
 		resolveWait();
 	};
@@ -3523,13 +3566,12 @@ function createOlderDesktopGenerationDrainWait(params) {
 	};
 }
 function hasLiveOlderDesktopGenerationClient(params) {
-	for (const clients of [params.state.liveClients, params.state.isolatedClients]) for (const client of clients) if (isOlderDesktopGenerationClientForHome(client, params.generation, params.targetHome)) return true;
+	for (const clients of [params.state.liveClients, params.state.isolatedClients]) for (const client of clients) {
+		const metadata = params.state.startMetadata.get(client);
+		if (metadata?.desktopGeneration && metadata.desktopGeneration.epoch < params.generation.epoch && resolveCodexNativeConfigFenceKey({ client }) === 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);
-}
 async function clearSharedCodexAppServerClientIfCurrentAndWait(client, options) {
 	if (!client) return false;
 	const state = getSharedCodexAppServerClientState();
@@ -3555,21 +3597,6 @@ async function clearSharedCodexAppServerClientAndWait(options) {
 	}
 }
 globalThis[SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER] = clearSharedCodexAppServerClientAndWait;
-function getOrCreateSharedClientEntry(state, key) {
-	let entry = state.clients.get(key);
-	if (!entry) {
-		entry = {
-			key,
-			activeLeases: 0,
-			anonymousLeases: 0,
-			pendingAcquires: 0,
-			closeWhenIdle: false,
-			onStartedClientCallbacks: /* @__PURE__ */ new Set()
-		};
-		state.clients.set(key, entry);
-	}
-	return entry;
-}
 function clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client) {
 	const entry = getCurrentSharedClientEntry(client);
 	return {
@@ -3579,13 +3606,5 @@ function clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client) {
 		pendingAcquires: entry?.pendingAcquires ?? 0
 	};
 }
-function closeSharedClientEntryIfUnclaimed(entry) {
-	if (entry.activeLeases > 0 || entry.pendingAcquires > 0) return false;
-	const state = getSharedCodexAppServerClientState();
-	if (state.clients.get(entry.key) !== entry) return false;
-	state.clients.delete(entry.key);
-	entry.client?.close();
-	return Boolean(entry.client);
-}
 //#endregion
-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 };
+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, revertCodexAppServerLiveThreadInstructions 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 };