@openclaw/codex 2026.9.1-beta.1 → 2026.9.1

package/dist/{shared-client-DKz23hHY.js → shared-client-DxcfF9KX.js}

@@ -1,58 +1,142 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { S as resolveCodexAppServerUserHomeDir, a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey } from "./config-giW8X0QA.js";
-import { a as CODEX_APP_SERVER_VERSION, c as resolveMacOSDesktopCodexAppPathCandidates, l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, n as resolveManagedCodexAppServerStartOptions, o as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, r as resolveManagedCodexNativeCommand, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexComputerUseServiceAppCandidates } from "./managed-binary-DFYK4DWq.js";
-import { o as isCodexAppServerNativeAuthProfile } from "./session-binding-Bcynfd-_.js";
-import { n as resolveCodexAppServerSpawnEnv, t as createStdioTransport } from "./transport-stdio-DhoGy33Z.js";
+import { t as isCodexAppServerProxyLaunch } from "./launch-args-RXQwn8zV.js";
+import { F as resolveCodexAppServerHomeDir, I as resolveCodexAppServerLocalHomeDir, L as resolveCodexAppServerUserHomeDir, R as withEphemeralCodexAuthStore, a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey } from "./config-BhmfC1s6.js";
+import { c as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, d as resolveMacOSDesktopCodexComputerUseServiceAppCandidates, l as resolveMacOSDesktopCodexAppPathCandidates, n as resolveManagedCodexAppServerStartOptions, o as CODEX_APP_SERVER_VERSION, r as resolveManagedCodexNativeCommand, s as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexBundledMarketplaceCandidates } from "./managed-binary-4-Vjz5GH.js";
+import { o as isCodexAppServerNativeAuthProfile } from "./session-binding-BHuTCRZQ.js";
+import { a as hasCodexAppServerNaturalExit, i as closeCodexAppServerTransportAndWait, n as resolveCodexAppServerSpawnEnv, r as closeCodexAppServerTransport, t as createStdioTransport } from "./transport-stdio-CyPldczm.js";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { addTimerTimeoutGraceMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, OPENCLAW_VERSION, embeddedAgentLog, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { addTimerTimeoutGraceMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { AgentHarnessPreflightError, OPENCLAW_VERSION, embeddedAgentLog, formatErrorMessage, formatToolExecutionErrorMessage, normalizeQuestionTimeoutSeconds, resolveToolExecutionErrorKind } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { createZstdDecompress } from "node:zlib";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import fsSync, { constants, existsSync, watch } from "node:fs";
+import fsSync, { constants as constants$1, existsSync, watch } from "node:fs";
 import os from "node:os";
 import { isDeepStrictEqual } from "node:util";
-import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveAuthProfileOrder, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
-import { hasUsableOAuthCredential, resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
+import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
+import { hasUsableOAuthCredential, resolveAuthProfileOrder, resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
 import { readSecretFile } from "openclaw/plugin-sdk/secret-file";
 import { assertNoSymlinkParents, withTimeout } from "openclaw/plugin-sdk/security-runtime";
 import { runExec } from "openclaw/plugin-sdk/process-runtime";
-import { execFile } from "node:child_process";
+import { EventEmitter } from "node:events";
 import { createInterface } from "node:readline";
 import { coerceErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { parse } from "semver";
-import { EventEmitter } from "node:events";
+import { hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { Compile } from "typebox/compile";
 import net from "node:net";
 import { PassThrough, Writable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import WebSocket from "ws";
-//#region extensions/codex/src/app-server/auth-start-options.ts
-const CODEX_APP_SERVER_HOME_DIRNAME = "codex-home";
-const CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE = "cli_auth_credentials_store=\"ephemeral\"";
-function resolveCodexAppServerHomeDir(agentDir) {
-	return path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME);
-}
-/** Resolves the local CODEX_HOME used when starting one app-server connection. */
-function resolveCodexAppServerLocalHomeDir(startOptions, agentDir, env = process.env) {
-	const configured = startOptions.env?.CODEX_HOME;
-	if (configured?.trim()) return configured;
-	return startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir(env) : resolveCodexAppServerHomeDir(agentDir);
-}
-/** Forces OpenClaw-owned Codex auth to remain process-local. */
-function withEphemeralCodexAuthStore(params) {
-	const { startOptions } = params;
-	if (!(startOptions.commandSource === "managed" || startOptions.commandSource === "resolved-managed") || !params.preparedAuth && params.authProfileId === null) return startOptions;
-	if (startOptions.args.at(-2) === "-c" && startOptions.args.at(-1) === CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE) return startOptions;
-	return {
-		...startOptions,
-		args: [
-			...startOptions.args,
-			"-c",
-			CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE
-		]
-	};
+//#region extensions/codex/src/app-server/protocol.ts
+/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
+const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
+const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
+const CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES = ["atlas", "chatgpt"];
+function isJsonObject(value) {
+	return isRecord(value);
+}
+function isRpcResponse(message) {
+	return "id" in message && !("method" in message);
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-provenance.ts
+const MAX_SESSION_META_BYTES = 1048576;
+const SESSION_META_READ_CHUNK_BYTES = 65536;
+const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
+const provenanceByPath = /* @__PURE__ */ new Map();
+function cacheProvenance(key, value) {
+	provenanceByPath.delete(key);
+	provenanceByPath.set(key, value);
+	while (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) {
+		const oldest = provenanceByPath.keys().next().value;
+		if (oldest === void 0) break;
+		provenanceByPath.delete(oldest);
+	}
+}
+/** Undefined means the metadata line is not durable enough to cache yet. */
+async function readCodexSessionMeta(sessionsRoot, rolloutPath, threadId) {
+	let safeRoot;
+	try {
+		safeRoot = await root(sessionsRoot, {
+			hardlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER,
+			symlinks: "reject"
+		});
+	} catch {
+		return;
+	}
+	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
+	for (const candidate of candidates) {
+		let opened;
+		try {
+			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
+		} catch {
+			continue;
+		}
+		const input = opened.handle.createReadStream({
+			autoClose: false,
+			highWaterMark: SESSION_META_READ_CHUNK_BYTES
+		});
+		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
+		try {
+			const chunks = [];
+			let bytesReadTotal = 0;
+			let line;
+			for await (const value of reader) {
+				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
+				if (remaining <= 0) break;
+				const bounded = chunk.subarray(0, remaining);
+				bytesReadTotal += bounded.length;
+				const newline = bounded.indexOf(10);
+				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
+				if (newline >= 0) {
+					line = Buffer.concat(chunks).toString("utf8");
+					break;
+				}
+			}
+			if (!line) continue;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (!isJsonObject(parsed) || parsed.type !== "session_meta" || !isJsonObject(parsed.payload)) return null;
+			const payload = parsed.payload;
+			return payload.id === threadId ? payload : null;
+		} catch {
+			continue;
+		} finally {
+			reader.destroy();
+			input.destroy();
+			await opened.handle.close().catch(() => void 0);
+		}
+	}
+}
+/**
+* Codex 0.147 reports OpenClaw app-server rollouts as `vscode`, so the rollout's
+* immutable session metadata is the authoritative historical provenance.
+*/
+async function isOpenClawManagedCodexThread(thread, localSessionsRoot) {
+	const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+	if (!localSessionsRoot || !rolloutPath) return false;
+	const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
+	const cached = provenanceByPath.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const metadata = await readCodexSessionMeta(localSessionsRoot, rolloutPath, thread.id);
+	const managed = metadata === void 0 ? void 0 : metadata?.originator === "openclaw";
+	if (managed !== void 0) cacheProvenance(cacheKey, managed);
+	return managed ?? false;
 }
 //#endregion
 //#region extensions/codex/src/app-server/computer-use-service-path.ts
@@ -713,7 +797,7 @@ function identitiesMatch(left, right) {
 }
 async function hasExecutableClient(appPath) {
 	try {
-		await fs.access(path.join(appPath, CLIENT_RELATIVE_PATH), constants.X_OK);
+		await fs.access(path.join(appPath, CLIENT_RELATIVE_PATH), constants$1.X_OK);
 		return true;
 	} catch {
 		return false;
@@ -814,21 +898,6 @@ async function copyServiceAppWithDitto(sourcePath, targetPath) {
 	});
 }
 //#endregion
-//#region extensions/codex/src/app-server/protocol.ts
-/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
-const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
-function flattenCodexDynamicToolFunctions(tools) {
-	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
-}
-const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
-const CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES = ["atlas", "chatgpt"];
-function isJsonObject(value) {
-	return isRecord(value);
-}
-function isRpcResponse(message) {
-	return "id" in message && !("method" in message);
-}
-//#endregion
 //#region extensions/codex/src/app-server/auth-bridge.ts
 const CODEX_APP_SERVER_AUTH_PROVIDER = "openai";
 const CODEX_APP_SERVER_EXTERNAL_CLI_PROVIDER_IDS = [CODEX_APP_SERVER_AUTH_PROVIDER];
@@ -879,8 +948,7 @@ function assertNoUnimportedAgentCodexAuthFile(params) {
 	if (message) throw new AgentHarnessPreflightError(message);
 }
 function resolveUnimportedAgentCodexAuthMessage(params) {
-	const managedCodexCli = params.startOptions.commandSource === "managed" || params.startOptions.commandSource === "resolved-managed";
-	if (params.startOptions.transport !== "stdio" || !managedCodexCli || params.startOptions.homeScope === "user") return;
+	if (params.startOptions.transport !== "stdio" || params.startOptions.homeScope === "user") return;
 	const codexHome = resolveCodexAppServerHomeDir(params.agentDir);
 	const authPath = path.join(codexHome, CODEX_AUTH_JSON_FILENAME);
 	if (!fsSync.existsSync(authPath)) return;
@@ -1238,36 +1306,21 @@ function withoutClearedCodexHomeEnv(clearEnv) {
 	return filtered.length === clearEnv.length ? clearEnv : filtered;
 }
 async function applyCodexAppServerAuthProfile(params) {
-	if (params.preparedAuth?.kind === "profile") {
-		await params.client.request("account/login/start", params.preparedAuth.snapshot.loginParams);
-		return;
-	}
-	if (params.preparedAuth?.kind === "api-key") {
-		await params.client.request("account/login/start", {
-			type: "apiKey",
-			apiKey: params.preparedAuth.apiKey
-		});
-		return;
-	}
-	if (params.authProfileId === null) {
+	if (!params.preparedAuth && params.authProfileId === null) {
 		await assertNativeCodexAccountMatchesRoute(params.client, params.authRequirement);
 		return;
 	}
-	let loginParams;
-	try {
-		loginParams = await resolveCodexAppServerAuthProfileLoginParams({
-			agentDir: params.agentDir,
-			authProfileId: params.authProfileId,
-			authProfileStore: params.authProfileStore,
-			config: params.config
-		});
-	} catch (error) {
-		if (params.authRequirement === "subscription" && error instanceof CodexAppServerAuthProfileUnavailableError) throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.", error);
-		throw error;
-	}
-	if (params.authRequirement === "subscription" && loginParams?.type !== "chatgptAuthTokens") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.");
+	const loginParams = params.preparedAuth?.kind === "profile" ? params.preparedAuth.snapshot.loginParams : params.preparedAuth?.kind === "api-key" ? {
+		type: "apiKey",
+		apiKey: params.preparedAuth.apiKey
+	} : await resolveCodexAppServerAuthProfileLoginParams({
+		agentDir: params.agentDir,
+		authProfileId: params.authProfileId ?? void 0,
+		authProfileStore: params.authProfileStore,
+		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.");
 	if (!loginParams) {
-		if (params.authRequirement === "subscription") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.");
 		if (params.authRequirement !== "api-key" || params.startOptions?.transport !== "stdio") return;
 		const env = resolveCodexAppServerSpawnEnv(params.startOptions, process.env);
 		const fallbackLoginParams = await resolveCodexAppServerFallbackApiKeyLoginParams({
@@ -1292,7 +1345,7 @@ async function assertNativeCodexAccountMatchesRoute(client, authRequirement) {
 	const response = await client.request("account/read", { refreshToken: false });
 	const accountType = isJsonObject(response.account) ? response.account.type : void 0;
 	if (authRequirement === "subscription") {
-		if (accountType !== "chatgpt") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.");
+		if (accountType !== "chatgpt") throw createCodexAppServerAuthError("Codex subscription route requires ChatGPT auth in the native Codex home. Run `codex login` for that home, or use appServer.homeScope=\"agent\" with an OpenClaw OAuth profile, then retry.");
 		return;
 	}
 	if (accountType === "chatgpt") throw createCodexAppServerAuthError("Codex Platform route requires an API-key account, but the native Codex home is signed in with a ChatGPT subscription. Sign that home in with `codex login --with-api-key`, or set appServer.homeScope=\"agent\" so OpenClaw can inject its own key.");
@@ -1301,7 +1354,13 @@ function createCodexAppServerAuthError(message, cause) {
 	const error = cause === void 0 ? new Error(message) : new Error(message, { cause });
 	return Object.assign(error, { status: 401 });
 }
-var CodexAppServerAuthProfileUnavailableError = class extends Error {};
+var CodexAppServerAuthProfileUnavailableError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.status = 401;
+		this.code = "selected_auth_profile_unavailable";
+	}
+};
 async function resolveCodexAppServerAuthProfileLoginParams(params) {
 	const store = resolveCodexAppServerAuthProfileStore(params);
 	const profileId = resolveCodexAppServerAuthProfileId({
@@ -1310,7 +1369,7 @@ async function resolveCodexAppServerAuthProfileLoginParams(params) {
 		config: params.config
 	});
 	const profile = profileId ? store.profiles[profileId] : void 0;
-	if (profileId && !profile) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" was not found.`);
+	if (profileId && !profile) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" was not found. Select an existing OpenAI profile or sign in again with OpenClaw, then retry.`);
 	if (profileId && profile && !isCodexAppServerAuthProfileCredential(profile)) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" must use the canonical OpenAI auth provider; run "openclaw doctor --fix" to migrate legacy provider IDs.`);
 	return await resolveCodexAppServerAuthProfileLoginParamsInternal({
 		...params,
@@ -1328,14 +1387,14 @@ async function refreshCodexAppServerAuthTokens(params) {
 		});
 		const credential = profileId ? store.profiles[profileId] : void 0;
 		const selectedAccountId = credential ? resolveExplicitChatgptAccountId(credential) ?? (credential.type === "oauth" ? resolveOpenAICodexAuthIdentity({ access: credential.access }).accountId : void 0) : void 0;
-		if (selectedAccountId && selectedAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed before Codex token refresh.");
+		if (selectedAccountId && selectedAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed before Codex token refresh. Retry to start a client for the selected workspace.");
 	}
 	const loginParams = await resolveCodexAppServerAuthProfileLoginParamsInternal({
 		...params,
 		forceOAuthRefresh: true
 	});
-	if (!loginParams || loginParams.type !== "chatgptAuthTokens") throw new Error("Codex app-server ChatGPT token refresh requires an OAuth auth profile.");
-	if (previousAccountId && loginParams.chatgptAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh.");
+	if (!loginParams || loginParams.type !== "chatgptAuthTokens") throw new Error("Codex app-server ChatGPT token refresh requires an OAuth auth profile. Sign in with `openclaw models auth login --provider openai`, select that profile, then retry.");
+	if (previousAccountId && loginParams.chatgptAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
 	return {
 		accessToken: loginParams.accessToken,
 		chatgptAccountId: loginParams.chatgptAccountId,
@@ -1356,8 +1415,8 @@ async function resolveCodexAppServerAuthProfileLoginParamsInternal(params) {
 	});
 	if (!profileId) return;
 	const credential = store.profiles[profileId];
-	if (!credential) throw new Error(`Codex app-server auth profile "${profileId}" was not found.`);
-	if (!isCodexAppServerAuthProfileCredential(credential)) throw new Error(`Codex app-server auth profile "${profileId}" must use the canonical OpenAI auth provider; run "openclaw doctor --fix" to migrate legacy provider IDs.`);
+	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.`);
 	const loginParams = await resolveLoginParamsForCredential(profileId, credential, {
 		agentDir: params.agentDir,
 		store,
@@ -1365,7 +1424,7 @@ async function resolveCodexAppServerAuthProfileLoginParamsInternal(params) {
 		forceOAuthRefresh: params.forceOAuthRefresh === true,
 		config: params.config
 	});
-	if (!loginParams) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" does not contain usable credentials.`);
+	if (!loginParams) throw new CodexAppServerAuthProfileUnavailableError(`Codex app-server auth profile "${profileId}" does not contain usable credentials. Repair or replace the selected OpenAI credential, then retry.`);
 	return loginParams;
 }
 async function resolveCodexAppServerFallbackApiKeyLoginParams(params) {
@@ -1479,7 +1538,7 @@ async function resolveOAuthCredentialForCodexAppServer(profileId, credential, pa
 	});
 	if (params.forceRefresh && !persistedOAuthCredential && overlaidOAuthCredential) {
 		const refreshedRuntimeCredential = await refreshOAuthCredentialForRuntime({ credential: overlaidOAuthCredential });
-		if (!refreshedRuntimeCredential?.access?.trim()) throw new Error(`Codex app-server auth profile "${profileId}" could not refresh.`);
+		if (!refreshedRuntimeCredential?.access?.trim()) throw new Error(`Codex app-server auth profile "${profileId}" could not refresh. Sign in again with OpenClaw, then retry.`);
 		store.profiles[profileId] = refreshedRuntimeCredential;
 		return refreshedRuntimeCredential;
 	}
@@ -1507,8 +1566,8 @@ function shouldUseScopedOAuthCredential(params) {
 	return !isDeepStrictEqual(persisted, params.suppliedCredential) && !hasMatchingOAuthIdentity(persisted, params.suppliedCredential);
 }
 function hasMatchingOAuthIdentity(persisted, supplied) {
-	const persistedAccountId = persisted.accountId?.trim();
-	const suppliedAccountId = supplied.accountId?.trim();
+	const persistedAccountId = resolveOpenAICodexAuthIdentity(persisted).accountId?.trim();
+	const suppliedAccountId = resolveOpenAICodexAuthIdentity(supplied).accountId?.trim();
 	if (persistedAccountId && suppliedAccountId) return persistedAccountId === suppliedAccountId;
 	const persistedEmail = persisted.email?.trim().toLowerCase();
 	const suppliedEmail = supplied.email?.trim().toLowerCase();
@@ -1525,8 +1584,8 @@ async function resolveScopedOAuthCredential(params) {
 		const credential = current?.type === "oauth" ? current : params.credential;
 		if (!params.forceRefresh && hasUsableOAuthCredential(credential)) return credential;
 		const refreshed = await refreshOAuthCredentialForRuntime({ credential });
-		if (!refreshed?.access?.trim()) throw new Error(`Codex app-server auth profile "${params.profileId}" could not refresh.`);
-		if (!isDeepStrictEqual(params.store.profiles[params.profileId], credential)) throw new Error(`Codex app-server auth profile "${params.profileId}" changed while refreshing.`);
+		if (!refreshed?.access?.trim()) throw new Error(`Codex app-server auth profile "${params.profileId}" could not refresh. Sign in again with OpenClaw, then retry.`);
+		if (!isDeepStrictEqual(params.store.profiles[params.profileId], credential)) throw new Error(`Codex app-server auth profile "${params.profileId}" changed while refreshing. Retry with the newly selected OpenAI profile.`);
 		params.store.profiles[params.profileId] = refreshed;
 		return refreshed;
 	})();
@@ -1604,7 +1663,7 @@ function resolveExplicitChatgptAccountId(credential) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/rate-limit-cache.ts
-const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 10 * 6e4;
+const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 6e5;
 const SPARSE_ACCOUNT_METADATA_KEYS = [
 	"credits",
 	"individualLimit",
@@ -1736,7 +1795,7 @@ async function withAbortableTimeout(params) {
 //#region extensions/codex/src/app-server/client-runtime.ts
 /** Client-scoped Codex auth and account observers. */
 /** Match Codex's native grace window without retaining inactive conversations indefinitely. */
-const CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS = 30 * 6e4;
+const CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS = 18e5;
 /** Native-child parents are active ownership, so only otherwise-idle threads count against this cap. */
 const CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE = 64;
 /** Return a deterministic error before Codex cancels its ten-second external-auth request. */
@@ -1749,6 +1808,32 @@ function isCodexAppServerClientRuntimeLive(client) {
 	const runtime = configuredClients.get(client);
 	return runtime !== void 0 && !runtime.closed;
 }
+/** 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);
+}
 /** Installs one auth-refresh handler and one rate-limit observer per physical client. */
 function ensureCodexAppServerClientRuntime(client, context) {
 	const existing = configuredClients.get(client);
@@ -1766,7 +1851,8 @@ function ensureCodexAppServerClientRuntime(client, context) {
 		retainedThreads: /* @__PURE__ */ new Map(),
 		claimedThreads: /* @__PURE__ */ new Map(),
 		releasingThreads: /* @__PURE__ */ new Map(),
-		protectedThreads: /* @__PURE__ */ new Map()
+		protectedThreads: /* @__PURE__ */ new Map(),
+		sessionMetadata: /* @__PURE__ */ new Map()
 	};
 	configuredClients.set(client, runtime);
 	client.addCloseHandler(() => {
@@ -1778,20 +1864,26 @@ function ensureCodexAppServerClientRuntime(client, context) {
 		runtime.retainedThreads.clear();
 		runtime.claimedThreads.clear();
 		runtime.protectedThreads.clear();
+		runtime.sessionMetadata.clear();
 	});
 	client.addRequestHandler(async (request) => {
 		if (request.method !== "account/chatgptAuthTokens/refresh") return;
 		if (runtime.context.authMode === "prepared-api-key") throw new Error("ChatGPT token refresh is unavailable for prepared Codex API-key auth.");
 		const previousAccountId = isJsonObject(request.params) && typeof request.params.previousAccountId === "string" ? request.params.previousAccountId.trim() || void 0 : void 0;
-		const tokens = await withTimeout$1(refreshCodexAppServerAuthTokens({
-			agentDir: runtime.context.agentDir,
-			authProfileId: runtime.context.authProfileId,
-			...previousAccountId ? { previousAccountId } : {},
-			...runtime.context.authProfileStore ? { authProfileStore: runtime.context.authProfileStore } : {},
-			config: runtime.context.config
-		}), CODEX_EXTERNAL_AUTH_REFRESH_TIMEOUT_MS, "Codex app-server ChatGPT token refresh timed out before its external-auth deadline");
-		if (previousAccountId && tokens.chatgptAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh.");
-		return { ...tokens };
+		try {
+			const tokens = await withTimeout$1(refreshCodexAppServerAuthTokens({
+				agentDir: runtime.context.agentDir,
+				authProfileId: runtime.context.authProfileId,
+				...previousAccountId ? { previousAccountId } : {},
+				...runtime.context.authProfileStore ? { authProfileStore: runtime.context.authProfileStore } : {},
+				config: runtime.context.config
+			}), CODEX_EXTERNAL_AUTH_REFRESH_TIMEOUT_MS, "Codex app-server ChatGPT token refresh timed out before its external-auth deadline. Retry the request; if it persists, sign in again with OpenClaw.");
+			if (previousAccountId && tokens.chatgptAccountId !== previousAccountId) throw new Error("ChatGPT workspace changed during Codex token refresh. Retry to start a client for the selected workspace.");
+			return { ...tokens };
+		} catch (error) {
+			runtime.context.onAuthRefreshFailure?.();
+			throw error;
+		}
 	});
 	client.addNotificationHandler((notification) => {
 		if (notification.method === "account/rateLimits/updated") {
@@ -1805,6 +1897,7 @@ function ensureCodexAppServerClientRuntime(client, context) {
 				if (releasing) releasing.invalidated = true;
 				runtime.retainedThreads.delete(threadId);
 				runtime.claimedThreads.delete(threadId);
+				runtime.sessionMetadata.delete(threadId);
 				scheduleRetainedThreadEviction(client, runtime);
 			}
 		}
@@ -1827,10 +1920,11 @@ function scheduleRetainedThreadEviction(client, runtime) {
 	}, Math.max(0, expiresAt - Date.now()));
 	runtime.evictionTimer.unref?.();
 }
-async function releaseRetainedThread(client, runtime, threadId) {
+async function releaseRetainedThread(client, runtime, threadId, assertCurrent) {
 	const pendingRelease = runtime.releasingThreads.get(threadId);
 	if (pendingRelease) {
 		await pendingRelease.completion;
+		assertCurrent?.();
 		return false;
 	}
 	const retained = runtime.retainedThreads.get(threadId);
@@ -1842,14 +1936,17 @@ async function releaseRetainedThread(client, runtime, threadId) {
 	}
 	runtime.retainedThreads.delete(threadId);
 	scheduleRetainedThreadEviction(client, runtime);
-	const transition = { completion: Promise.resolve().then(() => retained.release(threadId)) };
+	const transition = { completion: Promise.resolve().then(() => {
+		assertCurrent?.();
+		return assertCurrent ? retained.release(threadId, assertCurrent) : retained.release(threadId);
+	}) };
 	runtime.releasingThreads.set(threadId, transition);
 	try {
 		await transition.completion;
 		return true;
 	} catch (error) {
 		if (!runtime.closed && !transition.invalidated && runtime.releasingThreads.get(threadId) === transition && !runtime.retainedThreads.has(threadId) && !runtime.claimedThreads.has(threadId)) {
-			retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
+			if (retained.ephemeralPolicy === void 0) retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
 			const newerThreads = [...runtime.retainedThreads.entries()].filter(([candidateThreadId]) => !olderThreadIds.has(candidateThreadId));
 			for (const [candidateThreadId] of newerThreads) runtime.retainedThreads.delete(candidateThreadId);
 			runtime.retainedThreads.set(threadId, retained);
@@ -1867,14 +1964,15 @@ async function evictExpiredRetainedThreads(client, runtime) {
 	scheduleRetainedThreadEviction(client, runtime);
 }
 async function evictExcessIdleThreads(client, runtime) {
-	let idleThreadIds = [...runtime.retainedThreads.keys()].filter((threadId) => !runtime.protectedThreads.has(threadId));
+	const idleThreads = () => [...runtime.retainedThreads].filter(([threadId, thread]) => thread.ephemeralPolicy === void 0 && !runtime.protectedThreads.has(threadId));
+	let idleThreadIds = idleThreads();
 	while (idleThreadIds.length > CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE) {
-		await releaseRetainedThread(client, runtime, idleThreadIds[0]);
-		idleThreadIds = [...runtime.retainedThreads.keys()].filter((threadId) => !runtime.protectedThreads.has(threadId));
+		await releaseRetainedThread(client, runtime, idleThreadIds[0][0]);
+		idleThreadIds = idleThreads();
 	}
 }
 /** Retain separately owned Codex subscriptions; completing B must never cold-restart A. */
-async function retainCodexAppServerLiveThread(client, threadId, releaseThread, configFingerprint, serviceTier) {
+async function retainCodexAppServerLiveThread(client, threadId, releaseThread, configFingerprint, serviceTier, ephemeralPolicy) {
 	const runtime = configuredClients.get(client);
 	if (!runtime || runtime.closed) return false;
 	const claimed = runtime.claimedThreads.get(threadId);
@@ -1882,15 +1980,16 @@ async function retainCodexAppServerLiveThread(client, threadId, releaseThread, c
 	const pendingRelease = runtime.releasingThreads.get(threadId);
 	if (pendingRelease) {
 		await pendingRelease.completion;
-		if (runtime.closed || claimed !== void 0 && runtime.claimedThreads.get(threadId) !== claimed) return false;
+		return false;
 	}
 	runtime.retainedThreads.delete(threadId);
 	const retained = {
 		configFingerprint,
+		ephemeralPolicy,
 		serviceTier,
-		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
-		release: (releaseThread ? physicalThreadReleases.get(releaseThread) ?? releaseThread : void 0) ?? (async (releasedThreadId) => {
-			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3);
+		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);
 		})
 	};
 	runtime.retainedThreads.set(threadId, retained);
@@ -1934,8 +2033,8 @@ async function claimCodexAppServerLiveThread(client, threadId) {
 	}
 	return claimCodexAppServerThreadOwnership(client, runtime, threadId, runtime.retainedThreads.get(threadId) ?? {
 		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
-		release: async (releasedThreadId) => {
-			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3);
+		release: async (releasedThreadId, assertCurrent) => {
+			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent);
 		}
 	});
 }
@@ -1944,16 +2043,26 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained)
 	const claimed = Symbol(threadId);
 	runtime.claimedThreads.set(threadId, claimed);
 	scheduleRetainedThreadEviction(client, runtime);
-	const release = async (releasedThreadId) => {
-		if (releasedThreadId !== threadId || runtime.claimedThreads.get(threadId) !== claimed) return;
+	const assertCurrent = () => {
+		if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) throw new Error(`Codex thread subscription ownership changed: ${threadId}`);
+	};
+	const release = async (releasedThreadId, assertReleaseCurrent) => {
+		if (releasedThreadId !== threadId || runtime.claimedThreads.get(threadId) !== claimed) {
+			assertReleaseCurrent?.();
+			return;
+		}
 		const pendingRelease = runtime.releasingThreads.get(threadId);
 		if (pendingRelease) {
 			await pendingRelease.completion;
 			return;
 		}
 		const transition = { completion: Promise.resolve().then(async () => {
-			if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) return;
-			await retained.release(releasedThreadId);
+			if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) {
+				assertReleaseCurrent?.();
+				return;
+			}
+			assertReleaseCurrent?.();
+			await (assertReleaseCurrent ? retained.release(releasedThreadId, assertReleaseCurrent) : retained.release(releasedThreadId));
 		}) };
 		runtime.releasingThreads.set(threadId, transition);
 		try {
@@ -1962,95 +2071,3099 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained)
 		} finally {
 			if (runtime.releasingThreads.get(threadId) === transition) runtime.releasingThreads.delete(threadId);
 		}
-	};
-	physicalThreadReleases.set(release, retained.release);
-	claimedThreadReleaseTokens.set(release, claimed);
+	};
+	physicalThreadReleases.set(release, retained.release);
+	claimedThreadReleaseTokens.set(release, claimed);
+	return {
+		assertCurrent,
+		configFingerprint: retained.configFingerprint,
+		ephemeralPolicy: retained.ephemeralPolicy,
+		serviceTier: retained.serviceTier,
+		release
+	};
+}
+/** Distinguish active claimed ownership from an already-evicted idle subscription. */
+function hasCodexAppServerLiveThread(client, threadId) {
+	const runtime = configuredClients.get(client);
+	return runtime !== void 0 && !runtime.closed && (runtime.retainedThreads.has(threadId) || runtime.releasingThreads.has(threadId) || runtime.claimedThreads.has(threadId));
+}
+function isCodexAppServerLiveThreadClaimed(client, threadId) {
+	const runtime = configuredClients.get(client);
+	return runtime !== void 0 && !runtime.closed && runtime.claimedThreads.has(threadId);
+}
+/** Release the exact physical subscription and finish only its observed ownership generation. */
+async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs, assertCurrent) {
+	const runtime = configuredClients.get(client);
+	const claimed = runtime?.claimedThreads.get(threadId);
+	const retained = runtime?.retainedThreads.get(threadId);
+	let transition = runtime?.releasingThreads.get(threadId);
+	if (transition?.physicalRelease) {
+		await transition.physicalRelease;
+		assertCurrent?.();
+		return;
+	}
+	const physicalRelease = Promise.resolve().then(async () => {
+		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) !== claimed || retained !== void 0 && runtime?.retainedThreads.get(threadId) !== retained) {
+			assertCurrent?.();
+			return;
+		}
+		assertCurrent?.();
+		await client.request("thread/unsubscribe", { threadId }, {
+			timeoutMs,
+			assertCurrent
+		});
+		assertCurrent?.();
+	});
+	const ownsTransition = runtime !== void 0 && transition === void 0;
+	if (transition) transition.physicalRelease = physicalRelease;
+	else if (runtime) {
+		transition = {
+			completion: physicalRelease,
+			physicalRelease
+		};
+		runtime.releasingThreads.set(threadId, transition);
+	}
+	try {
+		await physicalRelease;
+		if (retained !== void 0 && runtime?.retainedThreads.get(threadId) === retained) {
+			runtime.retainedThreads.delete(threadId);
+			scheduleRetainedThreadEviction(client, runtime);
+		}
+		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) === claimed) runtime.claimedThreads.delete(threadId);
+	} finally {
+		if (ownsTransition && runtime.releasingThreads.get(threadId) === transition) runtime.releasingThreads.delete(threadId);
+	}
+}
+/** Reset/end owns the exact thread; failed generation retirement must never release its successor. */
+async function releaseCodexAppServerLiveThread(client, threadId, assertCurrent) {
+	const runtime = configuredClients.get(client);
+	return runtime ? await releaseRetainedThread(client, runtime, threadId, assertCurrent) : false;
+}
+/** Native child work pins its parent's subscription even after the foreground parent turn ends. */
+function protectCodexAppServerLiveThread(client, threadId) {
+	const runtime = configuredClients.get(client);
+	if (!runtime || runtime.closed) return () => void 0;
+	runtime.protectedThreads.set(threadId, (runtime.protectedThreads.get(threadId) ?? 0) + 1);
+	scheduleRetainedThreadEviction(client, runtime);
+	let protectedThread = true;
+	return () => {
+		if (!protectedThread) return;
+		protectedThread = false;
+		if (runtime.closed) return;
+		const count = runtime.protectedThreads.get(threadId) ?? 0;
+		if (count <= 1) {
+			runtime.protectedThreads.delete(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.warn("codex retained thread unpin eviction failed", {
+				threadId,
+				reason: formatErrorMessage(error)
+			});
+		});
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/dynamic-tool-response-state.ts
+/** Retains the host-owned app preview without adding it to Codex's response payload. */
+function withDynamicToolTranscriptDetails(response, details) {
+	if (details === void 0) return response;
+	Object.defineProperty(response, "transcriptDetails", {
+		configurable: true,
+		enumerable: false,
+		value: details
+	});
+	return response;
+}
+function withDynamicToolTerminalResolution(response, terminalResolution) {
+	if (terminalResolution) {
+		Object.defineProperties(response, {
+			terminalResolution: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution
+			},
+			executionStarted: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution.executionStarted
+			},
+			...terminalResolution.executedArguments ? { executedArguments: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution.executedArguments
+			} } : {}
+		});
+		withDynamicToolSideEffectEvidence(response, terminalResolution.sideEffectEvidence);
+	}
+	return response;
+}
+function withDynamicToolExecutionState(response, state) {
+	Object.defineProperties(response, {
+		executedArguments: {
+			configurable: true,
+			enumerable: false,
+			value: state.executedArguments
+		},
+		executionStarted: {
+			configurable: true,
+			enumerable: false,
+			value: state.executionStarted
+		}
+	});
+	return withDynamicToolSideEffectEvidence(response, state.sideEffectEvidence === true);
+}
+function withDynamicToolSideEffectEvidence(response, sideEffectEvidence) {
+	if (!sideEffectEvidence) {
+		delete response.sideEffectEvidence;
+		return response;
+	}
+	Object.defineProperty(response, "sideEffectEvidence", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+	return response;
+}
+function createFailedDynamicToolResponse(message, options) {
+	const response = {
+		contentItems: [{
+			type: "inputText",
+			text: message
+		}],
+		success: false
+	};
+	Object.defineProperties(response, {
+		diagnosticTerminalReason: {
+			configurable: true,
+			enumerable: false,
+			value: options?.terminalReason ?? "failed"
+		},
+		diagnosticTerminalType: {
+			configurable: true,
+			enumerable: false,
+			value: "error"
+		}
+	});
+	if (options?.executionStarted !== void 0) Object.defineProperty(response, "executionStarted", {
+		configurable: true,
+		enumerable: false,
+		value: options.executionStarted
+	});
+	if (options?.executedArguments !== void 0) Object.defineProperty(response, "executedArguments", {
+		configurable: true,
+		enumerable: false,
+		value: options.executedArguments
+	});
+	return withDynamicToolSideEffectEvidence(response, options?.sideEffectEvidence === true);
+}
+//#endregion
+//#region extensions/codex/src/app-server/tool-abort-terminal-reason.ts
+/** Leaf helper shared by native and dynamic tool diagnostics. */
+const CODEX_TIMEOUT_ABORT_REASONS = /* @__PURE__ */ new Set([
+	"codex_startup_timeout",
+	"turn_completion_idle_timeout",
+	"turn_progress_idle_timeout",
+	"turn_terminal_idle_timeout"
+]);
+/** Preserves timeout provenance when an enclosing run aborts an active tool. */
+function resolveCodexToolAbortTerminalReason(signal) {
+	try {
+		const reason = signal.reason;
+		if (typeof reason === "string") {
+			if (CODEX_TIMEOUT_ABORT_REASONS.has(reason)) return "timed_out";
+			return reason === "client_closed" ? "failed" : "cancelled";
+		}
+		if (reason && typeof reason === "object") {
+			const record = reason;
+			if (record.name === "TimeoutError" || record.reason === "timeout") return "timed_out";
+		}
+	} catch {
+		return "cancelled";
+	}
+	return "cancelled";
+}
+//#endregion
+//#region extensions/codex/src/app-server/dynamic-tool-execution.ts
+/**
+* Timeout, terminal-release, and diagnostic helpers for Codex dynamic tool
+* calls.
+*/
+/** Default timeout for Codex dynamic tool calls. */
+const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 9e4;
+/** Hard cap for per-call Codex dynamic tool timeout overrides. */
+const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 6e5;
+const CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS = 3e4;
+const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12e4;
+const CODEX_DYNAMIC_COMPUTER_GATEWAY_TIMEOUT_MS = 3e4;
+const CODEX_DYNAMIC_COMPUTER_COMPLETION_GRACE_MS = 3e4;
+/** Timeout for image-understanding style dynamic tool calls. */
+const CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS = 6e4;
+/** Timeout for message-delivery dynamic tool calls. */
+const CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS = 6e5;
+/** Outer default for collector waits: full swarm budget plus completion grace. */
+const CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS = 63e4;
+const LOG_FIELD_MAX_LENGTH = 160;
+function normalizeLogField(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.replaceAll(String.fromCharCode(27), " ").replaceAll("\r", " ").replaceAll("\n", " ").replaceAll("	", " ").trim();
+	if (!normalized) return;
+	return normalized.length > LOG_FIELD_MAX_LENGTH ? `${truncateUtf16Safe(normalized, 157)}...` : normalized;
+}
+function readNumericTimeoutMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return Math.max(0, Math.floor(value));
+	if (typeof value === "string") {
+		const parsed = parseStrictNonNegativeInteger(value);
+		if (parsed !== void 0) return Math.max(0, Math.floor(parsed));
+	}
+}
+function formatDynamicToolTimeoutDetails(params) {
+	const tool = normalizeLogField(params.call.tool) ?? "unknown";
+	const baseMeta = {
+		tool: params.call.tool,
+		toolCallId: params.call.callId,
+		threadId: params.call.threadId,
+		turnId: params.call.turnId,
+		timeoutMs: params.timeoutMs,
+		timeoutKind: "codex_dynamic_tool_rpc"
+	};
+	if (tool !== "process" || !isJsonObject(params.call.arguments)) return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms while running tool ${tool}.`,
+		consoleMessage: `codex dynamic tool timeout: tool=${tool} toolTimeoutMs=${params.timeoutMs}; per-tool-call watchdog, not session idle`,
+		meta: baseMeta
+	};
+	const action = normalizeLogField(params.call.arguments.action);
+	const sessionId = normalizeLogField(params.call.arguments.sessionId);
+	const requestedTimeoutMs = readNumericTimeoutMs(params.call.arguments.timeout);
+	const actionPart = action ? ` action=${action}` : "";
+	const sessionPart = sessionId ? ` sessionId=${sessionId}` : "";
+	const requestedPart = requestedTimeoutMs === void 0 ? "" : ` requestedWaitMs=${requestedTimeoutMs}`;
+	const retryHint = action === "poll" ? "; repeated lines usually mean process-poll retry churn, not model progress" : "";
+	const responseTarget = action || sessionId ? ` while waiting for process${actionPart}${sessionPart}` : " while waiting for the process tool";
+	return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms${responseTarget}. This is a tool RPC timeout, not a session idle timeout.`,
+		consoleMessage: `codex process tool timeout:${actionPart}${sessionPart} toolTimeoutMs=${params.timeoutMs}${requestedPart}; per-tool-call watchdog, not session idle${retryHint}`,
+		meta: {
+			...baseMeta,
+			processAction: action,
+			processSessionId: sessionId,
+			processRequestedTimeoutMs: requestedTimeoutMs
+		}
+	};
+}
+/**
+* Runs a dynamic tool call with run-abort and the budget prepared by
+* resolveDynamicToolCallTimeoutMs, preserving tool-specific completion grace.
+*/
+async function handleDynamicToolCallWithTimeout(params) {
+	let didNotifyAgentToolResult = false;
+	const conservativeRaceResponses = /* @__PURE__ */ new WeakSet();
+	const finalizeTerminal = (response) => {
+		const executionSnapshot = params.toolBridge.consumeToolExecutionSnapshot?.(params.call.callId);
+		const ownerKey = params.toolBridge.sideEffectOwnerKeyForTool?.(params.call.tool);
+		const observedExecutionStarted = executionSnapshot?.executionStarted ?? (conservativeRaceResponses.has(response) ? void 0 : response.executionStarted);
+		const terminalResolution = params.observeToolTerminal?.({
+			toolCallId: params.call.callId,
+			toolName: params.call.tool,
+			arguments: response.executedArguments ?? executionSnapshot?.executedArguments ?? params.call.arguments,
+			...params.toolMeta ? { meta: params.toolMeta } : {},
+			...ownerKey ? { ownerMutation: { ownerKey } } : {},
+			...observedExecutionStarted !== void 0 ? { executionStarted: observedExecutionStarted } : {},
+			outcome: response.success ? "success" : "failure",
+			...!response.success ? { failure: { error: readDynamicToolResponseText(response) } } : {}
+		});
+		return withDynamicToolTerminalResolution(response, terminalResolution);
+	};
+	const createFailedAfterPossibleDispatch = (message, terminalReason) => {
+		const response = createFailedDynamicToolResponse(message, {
+			executionStarted: true,
+			sideEffectEvidence: true,
+			terminalReason
+		});
+		conservativeRaceResponses.add(response);
+		return response;
+	};
+	const notifyAgentToolResult = (event) => {
+		if (didNotifyAgentToolResult) return;
+		didNotifyAgentToolResult = true;
+		try {
+			params.onAgentToolResult?.(event);
+		} catch (error) {
+			embeddedAgentLog.warn(`onAgentToolResult handler failed: tool=${params.call.tool} error=${String(error)}`);
+		}
+	};
+	const notifyFailedToolResult = (message, terminalReason = "failed") => {
+		notifyAgentToolResult({
+			toolName: params.call.tool,
+			result: {
+				content: [{
+					type: "text",
+					text: message
+				}],
+				details: {
+					status: terminalReason,
+					error: message
+				}
+			},
+			isError: true
+		});
+	};
+	if (params.signal.aborted) {
+		const message = "OpenClaw dynamic tool call aborted before execution.";
+		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
+		params.onFallbackSelected?.();
+		notifyFailedToolResult(message, terminalReason);
+		return finalizeTerminal(createFailedDynamicToolResponse(message, {
+			executionStarted: false,
+			terminalReason
+		}));
+	}
+	const controller = new AbortController();
+	let timeout;
+	let timedOut = false;
+	let resolveAbort;
+	const abortFromRun = () => {
+		const message = "OpenClaw dynamic tool call aborted.";
+		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
+		params.onFallbackSelected?.();
+		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
+		notifyFailedToolResult(message, terminalReason);
+		resolveAbort?.(createFailedAfterPossibleDispatch(message, terminalReason));
+	};
+	const abortPromise = new Promise((resolve) => {
+		resolveAbort = resolve;
+	});
+	const timeoutPromise = new Promise((resolve) => {
+		const { timeoutMs } = params;
+		timeout = setTimeout(() => {
+			timedOut = true;
+			const timeoutDetails = formatDynamicToolTimeoutDetails({
+				call: params.call,
+				timeoutMs
+			});
+			params.onFallbackSelected?.();
+			controller.abort(new Error(timeoutDetails.responseMessage));
+			params.onTimeout?.();
+			embeddedAgentLog.warn("codex dynamic tool call timed out", {
+				...timeoutDetails.meta,
+				consoleMessage: timeoutDetails.consoleMessage
+			});
+			notifyFailedToolResult(timeoutDetails.responseMessage, "timed_out");
+			resolve(createFailedAfterPossibleDispatch(timeoutDetails.responseMessage, "timed_out"));
+		}, timeoutMs);
+		timeout.unref?.();
+	});
+	try {
+		params.signal.addEventListener("abort", abortFromRun, { once: true });
+		if (params.signal.aborted) abortFromRun();
+		const response = await Promise.race([
+			params.toolBridge.handleToolCall(params.call, {
+				signal: controller.signal,
+				onAgentToolResult: notifyAgentToolResult,
+				toolCallOrdinal: params.toolCallOrdinal,
+				retainExecutionSnapshot: true
+			}),
+			abortPromise,
+			timeoutPromise
+		]);
+		if (!response.success && !didNotifyAgentToolResult) notifyFailedToolResult(readDynamicToolResponseText(response), response.diagnosticTerminalReason ?? "failed");
+		return finalizeTerminal(response);
+	} catch (error) {
+		const terminalReason = params.signal.aborted ? resolveCodexToolAbortTerminalReason(params.signal) : resolveToolExecutionErrorKind(error);
+		const message = formatToolExecutionErrorMessage(error, "OpenClaw dynamic tool call failed.");
+		notifyFailedToolResult(message, terminalReason);
+		return finalizeTerminal(createFailedAfterPossibleDispatch(message, terminalReason));
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		params.signal.removeEventListener("abort", abortFromRun);
+		resolveAbort = void 0;
+		if (!timedOut && !controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("OpenClaw dynamic tool call finished."));
+	}
+}
+function readDynamicToolResponseText(response) {
+	return response.contentItems.flatMap((item) => item.type === "inputText" && typeof item.text === "string" ? [item.text] : []).join("\n").trim() || "OpenClaw dynamic tool call failed.";
+}
+/** Strips OpenClaw-only metadata before sending a dynamic tool response to Codex. */
+function toCodexDynamicToolProtocolResponse(response) {
+	return {
+		contentItems: response.contentItems,
+		success: response.success
+	};
+}
+/** Adds async-started progress details when a tool result continues out of band. */
+function toCodexDynamicToolProgressResponse(response, protocolResponse) {
+	const transcriptDetails = isJsonObject(response.transcriptDetails) ? response.transcriptDetails : void 0;
+	const mcpAppPreview = isJsonObject(transcriptDetails?.mcpAppPreview) ? transcriptDetails.mcpAppPreview : void 0;
+	const progressDetails = mcpAppPreview ? { mcpAppPreview } : void 0;
+	if (response.asyncStarted !== true && progressDetails === void 0) return protocolResponse;
+	return {
+		...protocolResponse,
+		...progressDetails ? { details: progressDetails } : {},
+		...response.asyncStarted === true ? { details: {
+			...progressDetails,
+			async: true,
+			status: "started"
+		} } : {}
+	};
+}
+/** Decides whether a terminal dynamic tool response can release the Codex turn. */
+function shouldReleaseTurnAfterTerminalDynamicTool(state) {
+	return !state.completed && !state.aborted && state.responseSuccess && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && state.activeTurnItemIdsCount === 0 && state.pendingOpenClawDynamicToolCompletionIdsCount === 0;
+}
+/** Returns true when a non-async result should block terminal-release shortcuts. */
+function shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response) {
+	return response.asyncStarted !== true;
+}
+/** Resolves whether terminal diagnostic state should release, wait, or stay idle. */
+function resolveTerminalDynamicToolBatchAction(state) {
+	if (state.activeAppServerTurnRequests > 0 || state.activeTurnItemIdsCount > 0 || state.pendingOpenClawDynamicToolCompletionIdsCount > 0) return "wait";
+	if (state.currentTurnHadNonTerminalDynamicToolResult) return "clear-nonterminal-batch";
+	if (state.hasPendingTerminalDynamicToolRelease) return "release-pending-terminal";
+	return "idle";
+}
+/** Returns true for diagnostic events that terminate a dynamic tool call. */
+function isDynamicToolTerminalDiagnosticEvent(event) {
+	return event.type === "tool.execution.completed" || event.type === "tool.execution.error" || event.type === "tool.execution.blocked";
+}
+/** Matches terminal diagnostics to a specific dynamic tool call id/name. */
+function isMatchingDynamicToolTerminalDiagnostic(params) {
+	if (params.event.toolCallId !== params.call.callId || params.event.toolName !== params.call.tool) return false;
+	if (params.runId !== void 0) return params.event.runId === params.runId;
+	if (params.sessionId !== void 0) return params.event.sessionId === params.sessionId;
+	if (params.sessionKey !== void 0) return params.event.sessionKey === params.sessionKey;
+	return params.event.runId === void 0 && params.event.sessionId === void 0 && params.event.sessionKey === void 0;
+}
+/** Checks pending diagnostics for a terminal event matching a tool call. */
+function hasPendingDynamicToolTerminalDiagnostic(params) {
+	return hasPendingInternalDiagnosticEvent((event) => {
+		if (!isDynamicToolTerminalDiagnosticEvent(event)) return false;
+		return isMatchingDynamicToolTerminalDiagnostic({
+			event,
+			call: params.call,
+			runId: params.runId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey
+		});
+	});
+}
+/** Resolves per-tool timeout, applying media/message defaults and hard caps. */
+function resolveDynamicToolCallTimeoutMs(params) {
+	const args = isJsonObject(params.call.arguments) ? params.call.arguments : void 0;
+	if (params.call.tool === "ask_user" || params.call.tool === "secrets" && args?.action === "request") try {
+		return normalizeQuestionTimeoutSeconds(args?.timeoutSeconds) * 1e3 + CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS;
+	} catch {
+		return CODEX_DYNAMIC_TOOL_TIMEOUT_MS;
+	}
+	if (params.call.tool === "computer") return clampDynamicToolTimeoutMs(readComputerToolTimeoutMs(params.call.arguments));
+	if (params.call.tool === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
+	if (params.call.tool === "agents_wait") {
+		const requestedMs = readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS;
+		return Math.max(1, Math.min(63e4, Math.floor(requestedMs)));
+	}
+	return clampDynamicToolTimeoutMs(readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? CODEX_DYNAMIC_TOOL_TIMEOUT_MS);
+}
+/** Transport guard stays outside the handler's bounded tool wait and completion grace. */
+function resolveDynamicToolServerRequestTimeoutMs(call) {
+	return Math.max(63e4, call ? resolveDynamicToolCallTimeoutMs({
+		call,
+		config: void 0
+	}) : 0) + CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS;
+}
+function readComputerToolTimeoutMs(value) {
+	const args = isJsonObject(value) ? value : void 0;
+	const action = typeof args?.action === "string" ? args.action : void 0;
+	const gatewayTimeoutMs = readPositiveFiniteTimeoutMs(args?.timeoutMs) ?? CODEX_DYNAMIC_COMPUTER_GATEWAY_TIMEOUT_MS;
+	const gatewayCallCount = action === "screenshot" || action === "wait" ? 3 : 4;
+	return (action === "wait" || action === "hold_key" ? Math.max(0, Number(args?.duration) || 0) * 1e3 : 0) + gatewayCallCount * gatewayTimeoutMs + CODEX_DYNAMIC_COMPUTER_COMPLETION_GRACE_MS;
+}
+function readDynamicToolCallTimeoutMs(value) {
+	if (!isJsonObject(value)) return;
+	const timeoutMs = readPositiveFiniteTimeoutMs(value.timeoutMs);
+	if (timeoutMs !== void 0) return timeoutMs;
+	const timeoutSecondsMs = readDynamicToolTimeoutSecondsAsMs(value.timeoutSeconds);
+	return timeoutSecondsMs === void 0 ? void 0 : addTimerTimeoutGraceMs(timeoutSecondsMs, CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS);
+}
+function readConfiguredDynamicToolTimeoutMs(toolName, config) {
+	if (toolName === "image_generate") {
+		const imageModel = config?.agents?.defaults?.mediaModels?.image;
+		if (!imageModel || typeof imageModel !== "object") return CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+		return readPositiveFiniteTimeoutMs(imageModel.timeoutMs) ?? CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+	}
+	if (toolName === "view_image") {
+		const candidates = (config?.tools?.media?.models ?? []).filter((entry) => !entry.capabilities || entry.capabilities.includes("image"));
+		const capabilityTimeoutMs = readTimeoutSecondsAsMs(config?.tools?.media?.image?.timeoutSeconds);
+		return Math.max(capabilityTimeoutMs ?? CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS, ...candidates.map((entry) => readTimeoutSecondsAsMs(entry.timeoutSeconds) ?? capabilityTimeoutMs ?? CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS));
+	}
+	if (toolName === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
+}
+function readTimeoutSecondsAsMs(value) {
+	const seconds = readPositiveFiniteTimeoutMs(value);
+	return seconds === void 0 ? void 0 : seconds * 1e3;
+}
+function readDynamicToolTimeoutSecondsAsMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) return;
+	return value * 1e3;
+}
+function readPositiveFiniteTimeoutMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function clampDynamicToolTimeoutMs(timeoutMs) {
+	return Math.max(1, Math.min(CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS, Math.floor(timeoutMs)));
+}
+//#endregion
+//#region extensions/codex/src/app-server/elicitation-response.ts
+function createCodexElicitationResponse(action, content = null, meta = null) {
+	return {
+		action,
+		content,
+		_meta: meta
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/DynamicToolCallParams.json
+var DynamicToolCallParams_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"arguments": true,
+		"callId": { "type": "string" },
+		"namespace": { "type": ["string", "null"] },
+		"threadId": { "type": "string" },
+		"tool": { "type": "string" },
+		"turnId": { "type": "string" }
+	},
+	required: [
+		"arguments",
+		"callId",
+		"threadId",
+		"tool",
+		"turnId"
+	],
+	title: "DynamicToolCallParams",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/CodexAppServerProtocolDefinitions.json
+var definitions = {
+	"AbsolutePathBuf": {
+		"description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
+		"type": "string"
+	},
+	"Account": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["apiKey"],
+				"title": "ApiKeyAccountType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "ApiKeyAccount",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"email": { "type": ["string", "null"] },
+				"planType": { "$ref": "#/definitions/PlanType" },
+				"type": {
+					"enum": ["chatgpt"],
+					"title": "ChatgptAccountType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"email",
+				"planType",
+				"type"
+			],
+			"title": "ChatgptAccount",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"type": {
+					"enum": ["amazonBedrock"],
+					"title": "AmazonBedrockAccountType",
+					"type": "string"
+				},
+				"usesCodexManagedCredentials": {
+					"default": false,
+					"type": "boolean"
+				}
+			},
+			"required": ["type"],
+			"title": "AmazonBedrockAccount",
+			"type": "object"
+		}
+	] },
+	"ActivePermissionProfile": {
+		"properties": {
+			"extends": {
+				"default": null,
+				"description": "Parent profile identifier from the selected permissions profile's `extends` setting, when present.",
+				"type": ["string", "null"]
+			},
+			"id": {
+				"description": "Identifier from `default_permissions` or the implicit built-in default, such as `:workspace` or a user-defined `[permissions.<id>]` profile.",
+				"type": "string"
+			}
+		},
+		"required": ["id"],
+		"type": "object"
+	},
+	"AgentMessageDelivery": {
+		"enum": ["async"],
+		"type": "string"
+	},
+	"AgentPath": { "type": "string" },
+	"ApprovalsReviewer": {
+		"description": "Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `auto_review` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request. The legacy value `guardian_subagent` is accepted for compatibility.",
+		"enum": [
+			"user",
+			"auto_review",
+			"guardian_subagent"
+		],
+		"type": "string"
+	},
+	"AskForApproval": { "oneOf": [{
+		"additionalProperties": false,
+		"properties": { "granular": {
+			"properties": {
+				"mcp_elicitations": { "type": "boolean" },
+				"request_permissions": {
+					"default": false,
+					"type": "boolean"
+				},
+				"rules": { "type": "boolean" },
+				"sandbox_approval": { "type": "boolean" },
+				"skill_approval": {
+					"default": false,
+					"type": "boolean"
+				}
+			},
+			"required": [
+				"mcp_elicitations",
+				"rules",
+				"sandbox_approval"
+			],
+			"type": "object"
+		} },
+		"required": ["granular"],
+		"title": "GranularAskForApproval",
+		"type": "object"
+	}, {
+		"enum": [
+			"untrusted",
+			"on-request",
+			"never"
+		],
+		"type": "string"
+	}] },
+	"ByteRange": {
+		"properties": {
+			"end": {
+				"format": "uint",
+				"minimum": 0,
+				"type": "integer"
+			},
+			"start": {
+				"format": "uint",
+				"minimum": 0,
+				"type": "integer"
+			}
+		},
+		"required": ["end", "start"],
+		"type": "object"
+	},
+	"CodexErrorInfo": {
+		"description": "This translation layer make sure that we expose codex error code in camel case.\n\nWhen an upstream HTTP status is available (for example, from the Responses API or a provider), it is forwarded in `httpStatusCode` on the relevant `codexErrorInfo` variant.",
+		"oneOf": [
+			{
+				"additionalProperties": false,
+				"properties": { "httpConnectionFailed": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["httpConnectionFailed"],
+				"title": "HttpConnectionFailedCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "Failed to connect to the response SSE stream.",
+				"properties": { "responseStreamConnectionFailed": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["responseStreamConnectionFailed"],
+				"title": "ResponseStreamConnectionFailedCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "The response SSE stream disconnected in the middle of a turn before completion.",
+				"properties": { "responseStreamDisconnected": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["responseStreamDisconnected"],
+				"title": "ResponseStreamDisconnectedCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "Reached the retry limit for responses.",
+				"properties": { "responseTooManyFailedAttempts": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["responseTooManyFailedAttempts"],
+				"title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+				"properties": { "activeTurnNotSteerable": {
+					"properties": { "turnKind": { "$ref": "#/definitions/NonSteerableTurnKind" } },
+					"required": ["turnKind"],
+					"type": "object"
+				} },
+				"required": ["activeTurnNotSteerable"],
+				"title": "ActiveTurnNotSteerableCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"enum": [
+					"contextWindowExceeded",
+					"sessionBudgetExceeded",
+					"usageLimitExceeded",
+					"rateLimitExceeded",
+					"serverOverloaded",
+					"cyberPolicy",
+					"misalignmentPolicyViolation",
+					"internalServerError",
+					"unauthorized",
+					"badRequest",
+					"threadRollbackFailed",
+					"sandboxError",
+					"other"
+				],
+				"type": "string"
+			}
+		]
+	},
+	"CollabAgentState": {
+		"properties": {
+			"message": { "type": ["string", "null"] },
+			"status": { "$ref": "#/definitions/CollabAgentStatus" }
+		},
+		"required": ["status"],
+		"type": "object"
+	},
+	"CollabAgentStatus": {
+		"enum": [
+			"pendingInit",
+			"running",
+			"interrupted",
+			"completed",
+			"errored",
+			"shutdown",
+			"notFound"
+		],
+		"type": "string"
+	},
+	"CollabAgentTool": {
+		"enum": [
+			"spawnAgent",
+			"sendInput",
+			"resumeAgent",
+			"wait",
+			"closeAgent",
+			"sendMessage",
+			"followupTask",
+			"interruptAgent",
+			"listAgents"
+		],
+		"type": "string"
+	},
+	"CollabAgentToolCallStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed",
+			"interrupted"
+		],
+		"type": "string"
+	},
+	"CommandAction": { "oneOf": [
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"name": { "type": "string" },
+				"path": { "$ref": "#/definitions/LegacyAppPathString" },
+				"type": {
+					"enum": ["read"],
+					"title": "ReadCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"command",
+				"name",
+				"path",
+				"type"
+			],
+			"title": "ReadCommandAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"path": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["listFiles"],
+					"title": "ListFilesCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": ["command", "type"],
+			"title": "ListFilesCommandAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"path": { "type": ["string", "null"] },
+				"query": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["search"],
+					"title": "SearchCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": ["command", "type"],
+			"title": "SearchCommandAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"type": {
+					"enum": ["unknown"],
+					"title": "UnknownCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": ["command", "type"],
+			"title": "UnknownCommandAction",
+			"type": "object"
+		}
+	] },
+	"CommandExecutionSource": {
+		"enum": [
+			"agent",
+			"userShell",
+			"unifiedExecStartup",
+			"unifiedExecInteraction"
+		],
+		"type": "string"
+	},
+	"CommandExecutionStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed",
+			"declined"
+		],
+		"type": "string"
+	},
+	"DynamicToolCallOutputContentItem": { "oneOf": [
+		{
+			"properties": {
+				"text": { "type": "string" },
+				"type": {
+					"enum": ["inputText"],
+					"title": "InputTextDynamicToolCallOutputContentItemType",
+					"type": "string"
+				}
+			},
+			"required": ["text", "type"],
+			"title": "InputTextDynamicToolCallOutputContentItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"imageUrl": { "type": "string" },
+				"type": {
+					"enum": ["inputImage"],
+					"title": "InputImageDynamicToolCallOutputContentItemType",
+					"type": "string"
+				}
+			},
+			"required": ["imageUrl", "type"],
+			"title": "InputImageDynamicToolCallOutputContentItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"audioUrl": { "type": "string" },
+				"type": {
+					"enum": ["inputAudio"],
+					"title": "InputAudioDynamicToolCallOutputContentItemType",
+					"type": "string"
+				}
+			},
+			"required": ["audioUrl", "type"],
+			"title": "InputAudioDynamicToolCallOutputContentItem",
+			"type": "object"
+		}
+	] },
+	"DynamicToolCallStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed"
+		],
+		"type": "string"
+	},
+	"FileUpdateChange": {
+		"properties": {
+			"diff": { "type": "string" },
+			"kind": { "$ref": "#/definitions/PatchChangeKind" },
+			"path": { "type": "string" }
+		},
+		"required": [
+			"diff",
+			"kind",
+			"path"
+		],
+		"type": "object"
+	},
+	"FunctionCallOutputBody": { "anyOf": [{
+		"items": { "$ref": "#/definitions/FunctionCallOutputContentItem" },
+		"type": "array"
+	}, { "type": "string" }] },
+	"FunctionCallOutputContentItem": {
+		"description": "Responses API compatible content items that can be returned by a tool call. This is a subset of ContentItem with the types we support as function call outputs.",
+		"oneOf": [
+			{
+				"properties": {
+					"text": { "type": "string" },
+					"type": {
+						"enum": ["input_text"],
+						"title": "InputTextFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["text", "type"],
+				"title": "InputTextFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"detail": { "anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }] },
+					"image_url": { "type": "string" },
+					"type": {
+						"enum": ["input_image"],
+						"title": "InputImageFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["image_url", "type"],
+				"title": "InputImageFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"audio_url": { "type": "string" },
+					"type": {
+						"enum": ["input_audio"],
+						"title": "InputAudioFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["audio_url", "type"],
+				"title": "InputAudioFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"encrypted_content": { "type": "string" },
+					"type": {
+						"enum": ["encrypted_content"],
+						"title": "EncryptedContentFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["encrypted_content", "type"],
+				"title": "EncryptedContentFunctionCallOutputContentItem",
+				"type": "object"
+			}
+		]
+	},
+	"GitInfo": {
+		"properties": {
+			"branch": { "type": ["string", "null"] },
+			"originUrl": { "type": ["string", "null"] },
+			"sha": { "type": ["string", "null"] }
+		},
+		"type": "object"
+	},
+	"HookPromptFragment": {
+		"properties": {
+			"hookRunId": { "type": "string" },
+			"text": { "type": "string" }
+		},
+		"required": ["hookRunId", "text"],
+		"type": "object"
+	},
+	"ImageDetail": {
+		"enum": [
+			"auto",
+			"low",
+			"high",
+			"original"
+		],
+		"type": "string"
+	},
+	"ImageGenerationFailure": { "oneOf": [{
+		"properties": {
+			"limitId": { "type": "string" },
+			"resetsAt": {
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"type": {
+				"enum": ["usageLimitExceeded"],
+				"title": "UsageLimitExceededImageGenerationFailureType",
+				"type": "string"
+			}
+		},
+		"required": ["limitId", "type"],
+		"title": "UsageLimitExceededImageGenerationFailure",
+		"type": "object"
+	}] },
+	"InputModality": {
+		"description": "Canonical user-input modality tags advertised by a model.",
+		"oneOf": [
+			{
+				"description": "Plain text turns and tool payloads.",
+				"enum": ["text"],
+				"type": "string"
+			},
+			{
+				"description": "Image attachments included in user turns.",
+				"enum": ["image"],
+				"type": "string"
+			},
+			{
+				"description": "Audio attachments included in user turns.",
+				"enum": ["audio"],
+				"type": "string"
+			}
+		]
+	},
+	"LegacyAppPathString": { "type": "string" },
+	"McpToolCallAppContext": {
+		"properties": {
+			"actionName": { "type": ["string", "null"] },
+			"appName": { "type": ["string", "null"] },
+			"connectorId": { "type": "string" },
+			"linkId": { "type": ["string", "null"] },
+			"resourceUri": { "type": ["string", "null"] }
+		},
+		"required": ["connectorId"],
+		"type": "object"
+	},
+	"McpToolCallError": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
+	"McpToolCallResult": {
+		"properties": {
+			"_meta": true,
+			"content": {
+				"items": true,
+				"type": "array"
+			},
+			"structuredContent": true
+		},
+		"required": ["content"],
+		"type": "object"
+	},
+	"McpToolCallStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed"
+		],
+		"type": "string"
+	},
+	"MemoryCitation": {
+		"properties": {
+			"entries": {
+				"items": { "$ref": "#/definitions/MemoryCitationEntry" },
+				"type": "array"
+			},
+			"threadIds": {
+				"items": { "type": "string" },
+				"type": "array"
+			}
+		},
+		"required": ["entries", "threadIds"],
+		"type": "object"
+	},
+	"MemoryCitationEntry": {
+		"properties": {
+			"lineEnd": {
+				"format": "uint32",
+				"minimum": 0,
+				"type": "integer"
+			},
+			"lineStart": {
+				"format": "uint32",
+				"minimum": 0,
+				"type": "integer"
+			},
+			"note": { "type": "string" },
+			"path": { "type": "string" }
+		},
+		"required": [
+			"lineEnd",
+			"lineStart",
+			"note",
+			"path"
+		],
+		"type": "object"
+	},
+	"MessagePhase": {
+		"description": "Classifies an assistant message as interim commentary or final answer text.\n\nProviders do not emit this consistently, so callers must treat `None` as \"phase unknown\" and keep compatibility behavior for legacy models.",
+		"oneOf": [{
+			"description": "Mid-turn assistant text (for example preamble/progress narration).\n\nAdditional tool calls or assistant output may follow before turn completion.",
+			"enum": ["commentary"],
+			"type": "string"
+		}, {
+			"description": "The assistant's terminal answer text for the current turn.",
+			"enum": ["final_answer"],
+			"type": "string"
+		}]
+	},
+	"MisalignmentErrorDetails": {
+		"properties": {
+			"detailedExplanation": {
+				"description": "A substantive localized explanation is required before offering continuation.",
+				"type": ["string", "null"]
+			},
+			"errorType": {
+				"description": "Open-ended classification; clients must accept categories added by Responses.",
+				"type": ["string", "null"]
+			},
+			"steer": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentSteer" }, { "type": "null" }],
+				"description": "Instruction to submit as the next turn's user input if continuation is confirmed."
+			}
+		},
+		"type": "object"
+	},
+	"MisalignmentSteer": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
+	"Model": {
+		"properties": {
+			"additionalSpeedTiers": {
+				"default": [],
+				"description": "Deprecated: use `serviceTiers` instead.",
+				"items": { "type": "string" },
+				"type": "array"
+			},
+			"availabilityNux": { "anyOf": [{ "$ref": "#/definitions/ModelAvailabilityNux" }, { "type": "null" }] },
+			"defaultReasoningEffort": { "$ref": "#/definitions/ReasoningEffort" },
+			"defaultServiceTier": {
+				"default": null,
+				"description": "Catalog default service tier id for this model, when one is configured.",
+				"type": ["string", "null"]
+			},
+			"description": { "type": "string" },
+			"displayName": { "type": "string" },
+			"hidden": { "type": "boolean" },
+			"id": { "type": "string" },
+			"inputModalities": {
+				"default": ["text", "image"],
+				"items": { "$ref": "#/definitions/InputModality" },
+				"type": "array"
+			},
+			"isDefault": { "type": "boolean" },
+			"model": { "type": "string" },
+			"modelSpecialty": {
+				"default": null,
+				"type": ["string", "null"]
+			},
+			"multiAgentVersion": {
+				"anyOf": [{ "$ref": "#/definitions/MultiAgentVersion" }, { "type": "null" }],
+				"description": "Multi-agent runtime declared by this model, when available."
+			},
+			"serviceTiers": {
+				"default": [],
+				"items": { "$ref": "#/definitions/ModelServiceTier" },
+				"type": "array"
+			},
+			"supportedReasoningEfforts": {
+				"items": { "$ref": "#/definitions/ReasoningEffortOption" },
+				"type": "array"
+			},
+			"supportsPersonality": {
+				"default": false,
+				"type": "boolean"
+			},
+			"upgrade": { "type": ["string", "null"] },
+			"upgradeInfo": { "anyOf": [{ "$ref": "#/definitions/ModelUpgradeInfo" }, { "type": "null" }] }
+		},
+		"required": [
+			"defaultReasoningEffort",
+			"description",
+			"displayName",
+			"hidden",
+			"id",
+			"isDefault",
+			"model",
+			"supportedReasoningEfforts"
+		],
+		"type": "object"
+	},
+	"ModelAvailabilityNux": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
+	"ModelServiceTier": {
+		"properties": {
+			"description": { "type": "string" },
+			"id": { "type": "string" },
+			"name": { "type": "string" }
+		},
+		"required": [
+			"description",
+			"id",
+			"name"
+		],
+		"type": "object"
+	},
+	"ModelUpgradeInfo": {
+		"properties": {
+			"migrationMarkdown": { "type": ["string", "null"] },
+			"model": { "type": "string" },
+			"modelLink": { "type": ["string", "null"] },
+			"retirementAt": {
+				"description": "Informational Unix timestamp for this upgrade's scheduled retirement, if known.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"upgradeCopy": { "type": ["string", "null"] }
+		},
+		"required": ["model"],
+		"type": "object"
+	},
+	"MultiAgentMode": {
+		"description": "Controls the effective multi-agent delegation instructions for a turn. `custom` means the configured mode hint defines the policy instead of a built-in policy.",
+		"oneOf": [{
+			"additionalProperties": false,
+			"properties": { "custom": { "type": "string" } },
+			"required": ["custom"],
+			"title": "CustomMultiAgentMode",
+			"type": "object"
+		}, {
+			"enum": ["explicitRequestOnly", "proactive"],
+			"type": "string"
+		}]
+	},
+	"MultiAgentVersion": {
+		"description": "Multi-agent runtime supported by a model.",
+		"enum": [
+			"disabled",
+			"v1",
+			"v2"
+		],
+		"type": "string"
+	},
+	"NetworkAccess": {
+		"enum": ["restricted", "enabled"],
+		"type": "string"
+	},
+	"NonSteerableTurnKind": {
+		"enum": ["review", "compact"],
+		"type": "string"
+	},
+	"PatchApplyStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed",
+			"declined"
+		],
+		"type": "string"
+	},
+	"PatchChangeKind": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["add"],
+				"title": "AddPatchChangeKindType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "AddPatchChangeKind",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["delete"],
+				"title": "DeletePatchChangeKindType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "DeletePatchChangeKind",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"move_path": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["update"],
+					"title": "UpdatePatchChangeKindType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "UpdatePatchChangeKind",
+			"type": "object"
+		}
+	] },
+	"PlanType": {
+		"enum": [
+			"free",
+			"go",
+			"plus",
+			"pro",
+			"prolite",
+			"team",
+			"self_serve_business_prolite",
+			"self_serve_business_usage_based",
+			"business",
+			"ent26",
+			"enterprise_cbp_automation",
+			"enterprise_cbp_usage_based",
+			"enterprise",
+			"edu",
+			"edu_plus",
+			"edu_pro",
+			"unknown"
+		],
+		"type": "string"
+	},
+	"ReasoningEffort": {
+		"description": "A non-empty reasoning effort value advertised by the model.",
+		"minLength": 1,
+		"type": "string"
+	},
+	"ReasoningEffortOption": {
+		"properties": {
+			"description": { "type": "string" },
+			"reasoningEffort": { "$ref": "#/definitions/ReasoningEffort" }
+		},
+		"required": ["description", "reasoningEffort"],
+		"type": "object"
+	},
+	"SandboxPolicy": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["dangerFullAccess"],
+				"title": "DangerFullAccessSandboxPolicyType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "DangerFullAccessSandboxPolicy",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"networkAccess": {
+					"default": false,
+					"type": "boolean"
+				},
+				"type": {
+					"enum": ["readOnly"],
+					"title": "ReadOnlySandboxPolicyType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "ReadOnlySandboxPolicy",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"networkAccess": {
+					"allOf": [{ "$ref": "#/definitions/NetworkAccess" }],
+					"default": "restricted"
+				},
+				"type": {
+					"enum": ["externalSandbox"],
+					"title": "ExternalSandboxSandboxPolicyType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "ExternalSandboxSandboxPolicy",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"excludeSlashTmp": {
+					"default": false,
+					"type": "boolean"
+				},
+				"excludeTmpdirEnvVar": {
+					"default": false,
+					"type": "boolean"
+				},
+				"networkAccess": {
+					"default": false,
+					"type": "boolean"
+				},
+				"type": {
+					"enum": ["workspaceWrite"],
+					"title": "WorkspaceWriteSandboxPolicyType",
+					"type": "string"
+				},
+				"writableRoots": {
+					"default": [],
+					"items": { "$ref": "#/definitions/AbsolutePathBuf" },
+					"type": "array"
+				}
+			},
+			"required": ["type"],
+			"title": "WorkspaceWriteSandboxPolicy",
+			"type": "object"
+		}
+	] },
+	"SessionSource": { "oneOf": [
+		{
+			"additionalProperties": false,
+			"properties": { "custom": { "type": "string" } },
+			"required": ["custom"],
+			"title": "CustomSessionSource",
+			"type": "object"
+		},
+		{
+			"additionalProperties": false,
+			"properties": { "subAgent": { "$ref": "#/definitions/SubAgentSource" } },
+			"required": ["subAgent"],
+			"title": "SubAgentSessionSource",
+			"type": "object"
+		},
+		{
+			"enum": [
+				"cli",
+				"vscode",
+				"exec",
+				"appServer",
+				"unknown"
+			],
+			"type": "string"
+		}
+	] },
+	"SubAgentActivityKind": {
+		"enum": [
+			"started",
+			"interacted",
+			"interrupted",
+			"completed"
+		],
+		"type": "string"
+	},
+	"SubAgentSource": { "oneOf": [
+		{
+			"additionalProperties": false,
+			"properties": { "thread_spawn": {
+				"properties": {
+					"agent_nickname": {
+						"default": null,
+						"type": ["string", "null"]
+					},
+					"agent_path": {
+						"anyOf": [{ "$ref": "#/definitions/AgentPath" }, { "type": "null" }],
+						"default": null
+					},
+					"agent_role": {
+						"default": null,
+						"type": ["string", "null"]
+					},
+					"depth": {
+						"format": "int32",
+						"type": "integer"
+					},
+					"parent_thread_id": { "$ref": "#/definitions/ThreadId" }
+				},
+				"required": ["depth", "parent_thread_id"],
+				"type": "object"
+			} },
+			"required": ["thread_spawn"],
+			"title": "ThreadSpawnSubAgentSource",
+			"type": "object"
+		},
+		{
+			"additionalProperties": false,
+			"properties": { "other": { "type": "string" } },
+			"required": ["other"],
+			"title": "OtherSubAgentSource",
+			"type": "object"
+		},
+		{
+			"enum": [
+				"review",
+				"compact",
+				"memory_consolidation"
+			],
+			"type": "string"
+		}
+	] },
+	"TextElement": {
+		"properties": {
+			"byteRange": {
+				"allOf": [{ "$ref": "#/definitions/ByteRange" }],
+				"description": "Byte range in the parent `text` buffer that this element occupies."
+			},
+			"placeholder": {
+				"description": "Optional human-readable placeholder for the element, displayed in the UI.",
+				"type": ["string", "null"]
+			}
+		},
+		"required": ["byteRange"],
+		"type": "object"
+	},
+	"Thread": {
+		"properties": {
+			"agentNickname": {
+				"description": "Optional random unique nickname assigned to an AgentControl-spawned sub-agent.",
+				"type": ["string", "null"]
+			},
+			"agentRole": {
+				"description": "Optional role (agent_role) assigned to an AgentControl-spawned sub-agent.",
+				"type": ["string", "null"]
+			},
+			"canAcceptDirectInput": {
+				"description": "Whether the app server accepts direct turn input for this loaded thread. `None` means the capability is unavailable, such as for an unloaded stored thread.",
+				"type": ["boolean", "null"]
+			},
+			"cliVersion": {
+				"description": "Version of the CLI that created the thread.",
+				"type": "string"
+			},
+			"createdAt": {
+				"description": "Unix timestamp (in seconds) when the thread was created.",
+				"format": "int64",
+				"type": "integer"
+			},
+			"cwd": {
+				"allOf": [{ "$ref": "#/definitions/AbsolutePathBuf" }],
+				"description": "Working directory captured for the thread."
+			},
+			"ephemeral": {
+				"description": "Whether the thread is ephemeral and should not be materialized on disk.",
+				"type": "boolean"
+			},
+			"extra": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadExtra" }, { "type": "null" }],
+				"description": "Optional implementation-specific thread data."
+			},
+			"forkedFromId": {
+				"description": "Source thread id when this thread was created by forking another thread.",
+				"type": ["string", "null"]
+			},
+			"gitInfo": {
+				"anyOf": [{ "$ref": "#/definitions/GitInfo" }, { "type": "null" }],
+				"description": "Optional Git metadata captured when the thread was created."
+			},
+			"historyMode": {
+				"allOf": [{ "$ref": "#/definitions/ThreadHistoryMode" }],
+				"default": "legacy",
+				"description": "Persisted thread history contract selected when this thread was created."
+			},
+			"id": {
+				"description": "Identifier for this thread. Codex-generated thread IDs are UUIDv7.",
+				"type": "string"
+			},
+			"modelProvider": {
+				"description": "Model provider used for this thread (for example, 'openai').",
+				"type": "string"
+			},
+			"name": {
+				"description": "Optional user-facing thread title.",
+				"type": ["string", "null"]
+			},
+			"parentThreadId": {
+				"description": "The ID of the parent thread. This will only be set if this thread is a subagent.",
+				"type": ["string", "null"]
+			},
+			"path": {
+				"description": "[UNSTABLE] Path to the thread on disk.",
+				"type": ["string", "null"]
+			},
+			"preview": {
+				"description": "Usually the first user message in the thread, if available.",
+				"type": "string"
+			},
+			"projectId": {
+				"description": "Canonical project assignment owned by app-server, if any.",
+				"type": ["string", "null"]
+			},
+			"recencyAt": {
+				"description": "Unix timestamp (in seconds) used for thread recency ordering.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"section": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadSection" }, { "type": "null" }],
+				"default": null,
+				"description": "The independently persisted section selected for this thread, if any."
+			},
+			"sectionEnteredAt": {
+				"default": null,
+				"description": "Unix timestamp in seconds when the thread entered its current section.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"sessionId": {
+				"description": "Session id shared by threads that belong to the same session tree.",
+				"type": "string"
+			},
+			"source": {
+				"allOf": [{ "$ref": "#/definitions/SessionSource" }],
+				"description": "Origin of the thread (CLI, VSCode, codex exec, codex app-server, etc.)."
+			},
+			"status": {
+				"allOf": [{ "$ref": "#/definitions/ThreadStatus" }],
+				"description": "Current runtime status for the thread."
+			},
+			"threadSource": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadSource" }, { "type": "null" }],
+				"description": "Optional analytics source classification for this thread."
+			},
+			"turns": {
+				"description": "Only populated on `thread/resume`, `thread/rollback`, `thread/fork`, and `thread/read` (when `includeTurns` is true) responses. For all other responses and notifications returning a Thread, the turns field will be an empty list.",
+				"items": { "$ref": "#/definitions/Turn" },
+				"type": "array"
+			},
+			"updatedAt": {
+				"description": "Unix timestamp (in seconds) when the thread was last updated.",
+				"format": "int64",
+				"type": "integer"
+			}
+		},
+		"required": [
+			"cliVersion",
+			"createdAt",
+			"cwd",
+			"ephemeral",
+			"id",
+			"modelProvider",
+			"preview",
+			"projectId",
+			"sessionId",
+			"source",
+			"status",
+			"turns",
+			"updatedAt"
+		],
+		"type": "object"
+	},
+	"ThreadActiveFlag": {
+		"enum": ["waitingOnApproval", "waitingOnUserInput"],
+		"type": "string"
+	},
+	"ThreadExtra": {
+		"description": "Extra app-server data for a thread.",
+		"type": "object"
+	},
+	"ThreadHistoryMode": {
+		"enum": ["legacy", "paginated"],
+		"type": "string"
+	},
+	"ThreadId": { "type": "string" },
+	"ThreadItem": { "oneOf": [
+		{
+			"properties": {
+				"clientId": { "type": ["string", "null"] },
+				"content": {
+					"items": { "$ref": "#/definitions/UserInput" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["userMessage"],
+					"title": "UserMessageThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"content",
+				"id",
+				"type"
+			],
+			"title": "UserMessageThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"fragments": {
+					"items": { "$ref": "#/definitions/HookPromptFragment" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["hookPrompt"],
+					"title": "HookPromptThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"fragments",
+				"id",
+				"type"
+			],
+			"title": "HookPromptThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"delivery": {
+					"anyOf": [{ "$ref": "#/definitions/AgentMessageDelivery" }, { "type": "null" }],
+					"default": null
+				},
+				"id": { "type": "string" },
+				"memoryCitation": {
+					"anyOf": [{ "$ref": "#/definitions/MemoryCitation" }, { "type": "null" }],
+					"default": null
+				},
+				"phase": {
+					"anyOf": [{ "$ref": "#/definitions/MessagePhase" }, { "type": "null" }],
+					"default": null
+				},
+				"text": { "type": "string" },
+				"type": {
+					"enum": ["agentMessage"],
+					"title": "AgentMessageThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"text",
+				"type"
+			],
+			"title": "AgentMessageThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"name": { "type": "string" },
+				"namespace": { "type": ["string", "null"] },
+				"output": { "$ref": "#/definitions/FunctionCallOutputBody" },
+				"type": {
+					"enum": ["functionCallOutput"],
+					"title": "FunctionCallOutputThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"name",
+				"output",
+				"type"
+			],
+			"title": "FunctionCallOutputThreadItem",
+			"type": "object"
+		},
+		{
+			"description": "EXPERIMENTAL - proposed plan item content. The completed plan item is authoritative and may not match the concatenation of `PlanDelta` text.",
+			"properties": {
+				"id": { "type": "string" },
+				"text": { "type": "string" },
+				"type": {
+					"enum": ["plan"],
+					"title": "PlanThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"text",
+				"type"
+			],
+			"title": "PlanThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"content": {
+					"default": [],
+					"items": { "type": "string" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"summary": {
+					"default": [],
+					"items": { "type": "string" },
+					"type": "array"
+				},
+				"type": {
+					"enum": ["reasoning"],
+					"title": "ReasoningThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": ["id", "type"],
+			"title": "ReasoningThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"aggregatedOutput": {
+					"description": "The command's output, aggregated from stdout and stderr.",
+					"type": ["string", "null"]
+				},
+				"command": {
+					"description": "The command to be executed.",
+					"type": "string"
+				},
+				"commandActions": {
+					"description": "A best-effort parsing of the command to understand the action(s) it will perform. This returns a list of CommandAction objects because a single shell command may be composed of many commands piped together.",
+					"items": { "$ref": "#/definitions/CommandAction" },
+					"type": "array"
+				},
+				"cwd": {
+					"allOf": [{ "$ref": "#/definitions/LegacyAppPathString" }],
+					"description": "The command's working directory."
+				},
+				"durationMs": {
+					"description": "The duration of the command execution in milliseconds.",
+					"format": "int64",
+					"type": ["integer", "null"]
+				},
+				"exitCode": {
+					"description": "The command's exit code.",
+					"format": "int32",
+					"type": ["integer", "null"]
+				},
+				"id": { "type": "string" },
+				"pluginId": {
+					"default": null,
+					"description": "Trusted first-party plugin id when this command resolves to one plugin script.",
+					"type": ["string", "null"]
+				},
+				"processId": {
+					"description": "Identifier for the underlying PTY process (when available).",
+					"type": ["string", "null"]
+				},
+				"scriptPath": {
+					"default": null,
+					"description": "Safe plugin-relative path when this command resolves to one plugin script.",
+					"type": ["string", "null"]
+				},
+				"source": {
+					"allOf": [{ "$ref": "#/definitions/CommandExecutionSource" }],
+					"default": "agent"
+				},
+				"status": { "$ref": "#/definitions/CommandExecutionStatus" },
+				"type": {
+					"enum": ["commandExecution"],
+					"title": "CommandExecutionThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"command",
+				"commandActions",
+				"cwd",
+				"id",
+				"status",
+				"type"
+			],
+			"title": "CommandExecutionThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"changes": {
+					"items": { "$ref": "#/definitions/FileUpdateChange" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"status": { "$ref": "#/definitions/PatchApplyStatus" },
+				"type": {
+					"enum": ["fileChange"],
+					"title": "FileChangeThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"changes",
+				"id",
+				"status",
+				"type"
+			],
+			"title": "FileChangeThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"appContext": { "anyOf": [{ "$ref": "#/definitions/McpToolCallAppContext" }, { "type": "null" }] },
+				"arguments": true,
+				"durationMs": {
+					"description": "The duration of the MCP tool call in milliseconds.",
+					"format": "int64",
+					"type": ["integer", "null"]
+				},
+				"error": { "anyOf": [{ "$ref": "#/definitions/McpToolCallError" }, { "type": "null" }] },
+				"id": { "type": "string" },
+				"mcpAppResourceUri": {
+					"description": "Deprecated: use `appContext.resourceUri` instead.",
+					"type": ["string", "null"]
+				},
+				"pluginId": { "type": ["string", "null"] },
+				"readOnlyHint": { "type": ["boolean", "null"] },
+				"result": { "anyOf": [{ "$ref": "#/definitions/McpToolCallResult" }, { "type": "null" }] },
+				"server": { "type": "string" },
+				"status": { "$ref": "#/definitions/McpToolCallStatus" },
+				"tool": { "type": "string" },
+				"type": {
+					"enum": ["mcpToolCall"],
+					"title": "McpToolCallThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"arguments",
+				"id",
+				"server",
+				"status",
+				"tool",
+				"type"
+			],
+			"title": "McpToolCallThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"arguments": true,
+				"contentItems": {
+					"items": { "$ref": "#/definitions/DynamicToolCallOutputContentItem" },
+					"type": ["array", "null"]
+				},
+				"durationMs": {
+					"description": "The duration of the dynamic tool call in milliseconds.",
+					"format": "int64",
+					"type": ["integer", "null"]
+				},
+				"id": { "type": "string" },
+				"namespace": { "type": ["string", "null"] },
+				"status": { "$ref": "#/definitions/DynamicToolCallStatus" },
+				"success": { "type": ["boolean", "null"] },
+				"tool": { "type": "string" },
+				"type": {
+					"enum": ["dynamicToolCall"],
+					"title": "DynamicToolCallThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"arguments",
+				"id",
+				"status",
+				"tool",
+				"type"
+			],
+			"title": "DynamicToolCallThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"agentsStates": {
+					"additionalProperties": { "$ref": "#/definitions/CollabAgentState" },
+					"description": "Last known status of the target agents, when available.",
+					"type": "object"
+				},
+				"id": {
+					"description": "Unique identifier for this collab tool call.",
+					"type": "string"
+				},
+				"model": {
+					"description": "Model requested for the spawned agent, when applicable.",
+					"type": ["string", "null"]
+				},
+				"prompt": {
+					"description": "Prompt text sent as part of the collab tool call, when available.",
+					"type": ["string", "null"]
+				},
+				"reasoningEffort": {
+					"anyOf": [{ "$ref": "#/definitions/ReasoningEffort" }, { "type": "null" }],
+					"description": "Reasoning effort requested for the spawned agent, when applicable."
+				},
+				"receiverThreadIds": {
+					"description": "Thread ID of the receiving agent, when applicable. In case of spawn operation, this corresponds to the newly spawned agent.",
+					"items": { "type": "string" },
+					"type": "array"
+				},
+				"senderThreadId": {
+					"description": "Thread ID of the agent issuing the collab request.",
+					"type": "string"
+				},
+				"status": {
+					"allOf": [{ "$ref": "#/definitions/CollabAgentToolCallStatus" }],
+					"description": "Current status of the collab tool call."
+				},
+				"tool": {
+					"allOf": [{ "$ref": "#/definitions/CollabAgentTool" }],
+					"description": "Name of the collab tool that was invoked."
+				},
+				"type": {
+					"enum": ["collabAgentToolCall"],
+					"title": "CollabAgentToolCallThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"agentsStates",
+				"id",
+				"receiverThreadIds",
+				"senderThreadId",
+				"status",
+				"tool",
+				"type"
+			],
+			"title": "CollabAgentToolCallThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"agentPath": { "type": "string" },
+				"agentThreadId": { "type": "string" },
+				"id": { "type": "string" },
+				"kind": { "$ref": "#/definitions/SubAgentActivityKind" },
+				"type": {
+					"enum": ["subAgentActivity"],
+					"title": "SubAgentActivityThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"agentPath",
+				"agentThreadId",
+				"id",
+				"kind",
+				"type"
+			],
+			"title": "SubAgentActivityThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"action": { "anyOf": [{ "$ref": "#/definitions/WebSearchAction" }, { "type": "null" }] },
+				"id": { "type": "string" },
+				"query": { "type": "string" },
+				"results": {
+					"default": null,
+					"description": "Structured search results returned out-of-band by standalone web search.\n\nThese stay as opaque JSON at the extension/app-server boundary so new result fields and result types can pass through without a Codex release.",
+					"items": true,
+					"type": ["array", "null"]
+				},
+				"type": {
+					"enum": ["webSearch"],
+					"title": "WebSearchThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"query",
+				"type"
+			],
+			"title": "WebSearchThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"path": { "$ref": "#/definitions/LegacyAppPathString" },
+				"type": {
+					"enum": ["imageView"],
+					"title": "ImageViewThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"path",
+				"type"
+			],
+			"title": "ImageViewThreadItem",
+			"type": "object"
+		},
+		{
+			"description": "Display item emitted by the interruptible `clock.sleep` tool.",
+			"properties": {
+				"durationMs": {
+					"format": "uint64",
+					"minimum": 0,
+					"type": "integer"
+				},
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["sleep"],
+					"title": "SleepThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"durationMs",
+				"id",
+				"type"
+			],
+			"title": "SleepThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"failure": {
+					"anyOf": [{ "$ref": "#/definitions/ImageGenerationFailure" }, { "type": "null" }],
+					"default": null
+				},
+				"id": { "type": "string" },
+				"result": { "type": "string" },
+				"revisedPrompt": { "type": ["string", "null"] },
+				"savedPath": { "anyOf": [{ "$ref": "#/definitions/AbsolutePathBuf" }, { "type": "null" }] },
+				"status": { "type": "string" },
+				"transparentBackground": {
+					"default": null,
+					"type": ["boolean", "null"]
+				},
+				"type": {
+					"enum": ["imageGeneration"],
+					"title": "ImageGenerationThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"result",
+				"status",
+				"type"
+			],
+			"title": "ImageGenerationThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"review": { "type": "string" },
+				"type": {
+					"enum": ["enteredReviewMode"],
+					"title": "EnteredReviewModeThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"review",
+				"type"
+			],
+			"title": "EnteredReviewModeThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"review": { "type": "string" },
+				"type": {
+					"enum": ["exitedReviewMode"],
+					"title": "ExitedReviewModeThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"review",
+				"type"
+			],
+			"title": "ExitedReviewModeThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["contextCompaction"],
+					"title": "ContextCompactionThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": ["id", "type"],
+			"title": "ContextCompactionThreadItem",
+			"type": "object"
+		}
+	] },
+	"ThreadSection": {
+		"description": "An independently persisted, user-visible thread section.",
+		"properties": {
+			"appearance": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadSectionAppearance" }, { "type": "null" }],
+				"default": null,
+				"description": "Optional appearance synchronized across clients."
+			},
+			"id": {
+				"description": "Opaque UUIDv7 identity that remains stable when the section is renamed.",
+				"type": "string"
+			},
+			"name": {
+				"description": "The current user-visible section name.",
+				"type": "string"
+			}
+		},
+		"required": ["id", "name"],
+		"type": "object"
+	},
+	"ThreadSectionAppearance": {
+		"description": "Extensible visual presentation for a custom thread section.",
+		"properties": {
+			"color": { "type": ["string", "null"] },
+			"icon": { "type": ["string", "null"] }
+		},
+		"type": "object"
+	},
+	"ThreadSource": { "type": "string" },
+	"ThreadStatus": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["notLoaded"],
+				"title": "NotLoadedThreadStatusType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "NotLoadedThreadStatus",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["idle"],
+				"title": "IdleThreadStatusType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "IdleThreadStatus",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["systemError"],
+				"title": "SystemErrorThreadStatusType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "SystemErrorThreadStatus",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"activeFlags": {
+					"items": { "$ref": "#/definitions/ThreadActiveFlag" },
+					"type": "array"
+				},
+				"type": {
+					"enum": ["active"],
+					"title": "ActiveThreadStatusType",
+					"type": "string"
+				}
+			},
+			"required": ["activeFlags", "type"],
+			"title": "ActiveThreadStatus",
+			"type": "object"
+		}
+	] },
+	"Turn": {
+		"properties": {
+			"completedAt": {
+				"description": "Unix timestamp (in seconds) when the turn completed.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"durationMs": {
+				"description": "Duration between turn start and completion in milliseconds, if known.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"error": {
+				"anyOf": [{ "$ref": "#/definitions/TurnError" }, { "type": "null" }],
+				"description": "Only populated when the Turn's status is failed."
+			},
+			"id": {
+				"description": "Identifier for this turn. Codex-generated turn IDs are UUIDv7.",
+				"type": "string"
+			},
+			"items": {
+				"description": "Thread items currently included in this turn payload.",
+				"items": { "$ref": "#/definitions/ThreadItem" },
+				"type": "array"
+			},
+			"itemsView": {
+				"allOf": [{ "$ref": "#/definitions/TurnItemsView" }],
+				"default": "full",
+				"description": "Describes how much of `items` has been loaded for this turn."
+			},
+			"startedAt": {
+				"description": "Unix timestamp (in seconds) when the turn started.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"status": { "$ref": "#/definitions/TurnStatus" }
+		},
+		"required": [
+			"id",
+			"items",
+			"status"
+		],
+		"type": "object"
+	},
+	"TurnError": {
+		"properties": {
+			"additionalDetails": {
+				"default": null,
+				"type": ["string", "null"]
+			},
+			"codexErrorInfo": { "anyOf": [{ "$ref": "#/definitions/CodexErrorInfo" }, { "type": "null" }] },
+			"message": { "type": "string" },
+			"misalignment": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentErrorDetails" }, { "type": "null" }],
+				"default": null,
+				"description": "Optional public explanation and continuation instruction for a misalignment block."
+			}
+		},
+		"required": ["message"],
+		"type": "object"
+	},
+	"TurnItemsView": { "oneOf": [
+		{
+			"description": "`items` was not loaded for this turn. The field is intentionally empty.",
+			"enum": ["notLoaded"],
+			"type": "string"
+		},
+		{
+			"description": "`items` contains only a display summary for this turn.",
+			"enum": ["summary"],
+			"type": "string"
+		},
+		{
+			"description": "`items` contains every ThreadItem available from persisted app-server history for this turn.",
+			"enum": ["full"],
+			"type": "string"
+		}
+	] },
+	"TurnStatus": {
+		"enum": [
+			"completed",
+			"interrupted",
+			"failed",
+			"inProgress"
+		],
+		"type": "string"
+	},
+	"TurnsPage": {
+		"properties": {
+			"backwardsCursor": { "type": ["string", "null"] },
+			"data": {
+				"items": { "$ref": "#/definitions/Turn" },
+				"type": "array"
+			},
+			"nextCursor": { "type": ["string", "null"] }
+		},
+		"required": ["data"],
+		"type": "object"
+	},
+	"UserInput": { "oneOf": [
+		{
+			"properties": {
+				"text": { "type": "string" },
+				"text_elements": {
+					"default": [],
+					"description": "UI-defined spans within `text` used to render or persist special elements.",
+					"items": { "$ref": "#/definitions/TextElement" },
+					"type": "array"
+				},
+				"type": {
+					"enum": ["text"],
+					"title": "TextUserInputType",
+					"type": "string"
+				}
+			},
+			"required": ["text", "type"],
+			"title": "TextUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"detail": {
+					"anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }],
+					"default": null
+				},
+				"type": {
+					"enum": ["image"],
+					"title": "ImageUserInputType",
+					"type": "string"
+				},
+				"url": { "type": "string" }
+			},
+			"required": ["type", "url"],
+			"title": "ImageUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"detail": {
+					"anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }],
+					"default": null
+				},
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["localImage"],
+					"title": "LocalImageUserInputType",
+					"type": "string"
+				}
+			},
+			"required": ["path", "type"],
+			"title": "LocalImageUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"type": {
+					"enum": ["audio"],
+					"title": "AudioUserInputType",
+					"type": "string"
+				},
+				"url": { "type": "string" }
+			},
+			"required": ["type", "url"],
+			"title": "AudioUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["localAudio"],
+					"title": "LocalAudioUserInputType",
+					"type": "string"
+				}
+			},
+			"required": ["path", "type"],
+			"title": "LocalAudioUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"name": { "type": "string" },
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["skill"],
+					"title": "SkillUserInputType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"name",
+				"path",
+				"type"
+			],
+			"title": "SkillUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"name": { "type": "string" },
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["mention"],
+					"title": "MentionUserInputType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"name",
+				"path",
+				"type"
+			],
+			"title": "MentionUserInput",
+			"type": "object"
+		}
+	] },
+	"WebSearchAction": { "oneOf": [
+		{
+			"properties": {
+				"queries": {
+					"items": { "type": "string" },
+					"type": ["array", "null"]
+				},
+				"query": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["search"],
+					"title": "SearchWebSearchActionType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "SearchWebSearchAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"type": {
+					"enum": ["openPage"],
+					"title": "OpenPageWebSearchActionType",
+					"type": "string"
+				},
+				"url": { "type": ["string", "null"] }
+			},
+			"required": ["type"],
+			"title": "OpenPageWebSearchAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"pattern": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["findInPage"],
+					"title": "FindInPageWebSearchActionType",
+					"type": "string"
+				},
+				"url": { "type": ["string", "null"] }
+			},
+			"required": ["type"],
+			"title": "FindInPageWebSearchAction",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["other"],
+				"title": "OtherWebSearchActionType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "OtherWebSearchAction",
+			"type": "object"
+		}
+	] }
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ErrorNotification.json
+var ErrorNotification_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"error": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/TurnError" },
+		"threadId": { "type": "string" },
+		"turnId": { "type": "string" },
+		"willRetry": { "type": "boolean" }
+	},
+	required: [
+		"error",
+		"threadId",
+		"turnId",
+		"willRetry"
+	],
+	title: "ErrorNotification",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ModelListResponse.json
+var ModelListResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"data": {
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Model" },
+			"type": "array"
+		},
+		"nextCursor": {
+			"description": "Opaque cursor to pass to the next call to continue after the last item. If None, there are no more items to return.",
+			"type": ["string", "null"]
+		}
+	},
+	required: ["data"],
+	title: "ModelListResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ThreadResumeResponse.json
+var ThreadResumeResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"activePermissionProfile": {
+			"anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ActivePermissionProfile" }, { "type": "null" }],
+			"default": null,
+			"description": "Named or implicit built-in profile that produced the active permissions, when known."
+		},
+		"approvalPolicy": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AskForApproval" },
+		"approvalsReviewer": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ApprovalsReviewer" }],
+			"description": "Reviewer currently used for approval requests on this thread."
+		},
+		"cwd": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+		"initialTurnsPage": {
+			"anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/TurnsPage" }, { "type": "null" }],
+			"default": null,
+			"description": "`thread/turns/list` page returned when requested by `initialTurnsPage`."
+		},
+		"instructionSources": {
+			"default": [],
+			"description": "Environment-native paths to instruction source files currently loaded for this thread.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/LegacyAppPathString" },
+			"type": "array"
+		},
+		"itemsBackwardsCursor": {
+			"default": null,
+			"description": "Opaque cursor for hydrating paginated items backwards.\n\nPass this as `cursor` to `thread/items/list` with `sortDirection: \"desc\"`. The first page includes the item identified by the cursor.",
+			"type": ["string", "null"]
+		},
+		"model": { "type": "string" },
+		"modelProvider": { "type": "string" },
+		"multiAgentMode": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/MultiAgentMode" }],
+			"default": "explicitRequestOnly",
+			"description": "@deprecated Always `explicitRequestOnly`. Use `reasoningEffort` for Ultra behavior."
+		},
+		"reasoningEffort": { "anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ReasoningEffort" }, { "type": "null" }] },
+		"runtimeWorkspaceRoots": {
+			"default": [],
+			"description": "Thread-scoped runtime workspace roots used to materialize `:workspace_roots`.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+			"type": "array"
+		},
+		"sandbox": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/SandboxPolicy" }],
+			"description": "Legacy sandbox policy retained for compatibility. Experimental clients should prefer `activePermissionProfile` for profile provenance."
+		},
+		"serviceTier": { "type": ["string", "null"] },
+		"thread": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Thread" },
+		"turnsBackwardsCursor": {
+			"default": null,
+			"description": "Opaque cursor for hydrating paginated turns backwards.\n\nPass this as `cursor` to `thread/turns/list` with `sortDirection: \"desc\"`. The first page includes the turn identified by the cursor.",
+			"type": ["string", "null"]
+		}
+	},
+	required: [
+		"approvalPolicy",
+		"approvalsReviewer",
+		"cwd",
+		"model",
+		"modelProvider",
+		"sandbox",
+		"thread"
+	],
+	title: "ThreadResumeResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ThreadStartResponse.json
+var ThreadStartResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"activePermissionProfile": {
+			"anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ActivePermissionProfile" }, { "type": "null" }],
+			"default": null,
+			"description": "Named or implicit built-in profile that produced the active permissions, when known."
+		},
+		"approvalPolicy": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AskForApproval" },
+		"approvalsReviewer": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ApprovalsReviewer" }],
+			"description": "Reviewer currently used for approval requests on this thread."
+		},
+		"cwd": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+		"instructionSources": {
+			"default": [],
+			"description": "Environment-native paths to instruction source files currently loaded for this thread.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/LegacyAppPathString" },
+			"type": "array"
+		},
+		"model": { "type": "string" },
+		"modelProvider": { "type": "string" },
+		"multiAgentMode": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/MultiAgentMode" }],
+			"default": "explicitRequestOnly",
+			"description": "@deprecated Always `explicitRequestOnly`. Use `reasoningEffort` for Ultra behavior."
+		},
+		"reasoningEffort": { "anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ReasoningEffort" }, { "type": "null" }] },
+		"runtimeWorkspaceRoots": {
+			"default": [],
+			"description": "Thread-scoped runtime workspace roots used to materialize `:workspace_roots`.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+			"type": "array"
+		},
+		"sandbox": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/SandboxPolicy" }],
+			"description": "Legacy sandbox policy retained for compatibility. Experimental clients should prefer `activePermissionProfile` for profile provenance."
+		},
+		"serviceTier": { "type": ["string", "null"] },
+		"thread": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Thread" }
+	},
+	required: [
+		"approvalPolicy",
+		"approvalsReviewer",
+		"cwd",
+		"model",
+		"modelProvider",
+		"sandbox",
+		"thread"
+	],
+	title: "ThreadStartResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/TurnCompletedNotification.json
+var TurnCompletedNotification_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"threadId": { "type": "string" },
+		"turn": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Turn" }
+	},
+	required: ["threadId", "turn"],
+	title: "TurnCompletedNotification",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/TurnStartResponse.json
+var TurnStartResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: { "turn": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Turn" } },
+	required: ["turn"],
+	title: "TurnStartResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-validators.ts
+/**
+* Runtime validators for Codex app-server protocol payloads, including schema
+* normalization for generated JSON Schema before TypeBox compilation.
+*/
+const externalDefinitionRefPrefix = "./CodexAppServerProtocolDefinitions.json#/definitions/";
+const rootExternalDefinitionRefPrefix = "./v2/CodexAppServerProtocolDefinitions.json#/definitions/";
+const localDefinitionRefPrefix = "#/definitions/";
+function materializeCodexSchema(schema, externalRefPrefix = externalDefinitionRefPrefix) {
+	const sharedDefinitions = definitions;
+	if (!isRecord(schema) || !isRecord(sharedDefinitions)) return schema;
+	const reachable = collectDefinitionRefs(schema, externalRefPrefix);
+	const pending = [...reachable];
+	while (pending.length > 0) {
+		const name = pending.pop();
+		if (name === void 0) continue;
+		const definition = sharedDefinitions[name];
+		if (definition === void 0) throw new Error(`Missing generated Codex schema definition: ${name}`);
+		for (const dependency of collectDefinitionRefs(definition, localDefinitionRefPrefix)) if (!reachable.has(dependency)) {
+			reachable.add(dependency);
+			pending.push(dependency);
+		}
+	}
+	if (reachable.size === 0) return schema;
+	const definitions$1 = Object.fromEntries(Object.entries(sharedDefinitions).filter(([name]) => reachable.has(name)));
+	return rewriteDefinitionRefs({
+		...schema,
+		definitions: definitions$1
+	}, externalRefPrefix);
+}
+function collectDefinitionRefs(value, prefix, names = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(value)) for (const entry of value) collectDefinitionRefs(entry, prefix, names);
+	else if (isRecord(value)) {
+		if (typeof value.$ref === "string" && value.$ref.startsWith(prefix)) {
+			const name = value.$ref.slice(prefix.length).split("/", 1)[0];
+			if (name) names.add(name.replaceAll("~1", "/").replaceAll("~0", "~"));
+		}
+		for (const entry of Object.values(value)) collectDefinitionRefs(entry, prefix, names);
+	}
+	return names;
+}
+function rewriteDefinitionRefs(value, externalRefPrefix) {
+	if (Array.isArray(value)) return value.map((entry) => rewriteDefinitionRefs(entry, externalRefPrefix));
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, key === "$ref" && typeof entry === "string" && entry.startsWith(externalRefPrefix) ? `${localDefinitionRefPrefix}${entry.slice(externalRefPrefix.length)}` : rewriteDefinitionRefs(entry, externalRefPrefix)]));
+}
+const dynamicToolCallParamsSchema = materializeCodexSchema(DynamicToolCallParams_default, rootExternalDefinitionRefPrefix);
+const errorNotificationSchema = materializeCodexSchema(ErrorNotification_default);
+const modelListResponseSchema = materializeCodexSchema(ModelListResponse_default);
+const threadResumeResponseSchema = materializeCodexSchema(ThreadResumeResponse_default);
+const threadStartResponseSchema = materializeCodexSchema(ThreadStartResponse_default);
+const turnCompletedNotificationSchema = materializeCodexSchema(TurnCompletedNotification_default);
+const turnStartResponseSchema = materializeCodexSchema(TurnStartResponse_default);
+function compileCodexSchema(schema) {
+	const validator = Compile(normalizeJsonSchemaNode(schema));
 	return {
-		configFingerprint: retained.configFingerprint,
-		serviceTier: retained.serviceTier,
-		release
+		check: (value) => validator.Check(value),
+		errors: (value) => [...validator.Errors(value)]
 	};
 }
-/** Distinguish active claimed ownership from an already-evicted idle subscription. */
-function isCodexAppServerLiveThreadClaimed(client, threadId) {
-	const runtime = configuredClients.get(client);
-	return runtime !== void 0 && !runtime.closed && runtime.claimedThreads.has(threadId);
+const schemaMapKeywords = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const schemaValueKeywords = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+const schemaArrayKeywords = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+function schemaTypeIncludes(schema, type) {
+	return schema.type === type || Array.isArray(schema.type) && schema.type.includes(type);
+}
+function normalizeSchemaMap(value) {
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeJsonSchemaNode(entry)]));
+}
+function expandJsonSchemaTypeArray(schema) {
+	const { type, ...rest } = schema;
+	if (!Array.isArray(type)) return schema;
+	return { anyOf: type.map((entry) => Object.assign({}, rest, { type: entry })) };
+}
+function normalizeJsonSchemaNode(schema) {
+	if (Array.isArray(schema)) return schema.map((entry) => normalizeJsonSchemaNode(entry));
+	if (!isRecord(schema)) return schema;
+	const normalizedSchema = expandJsonSchemaTypeArray(schema);
+	return Object.fromEntries(Object.entries(normalizedSchema).map(([key, value]) => {
+		if (schemaMapKeywords.has(key)) return [key, normalizeSchemaMap(value)];
+		if (schemaValueKeywords.has(key) || schemaArrayKeywords.has(key)) return [key, normalizeJsonSchemaNode(value)];
+		return [key, value];
+	}));
 }
-/** Release the exact physical subscription and finish only its observed claim generation. */
-async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs) {
-	const runtime = configuredClients.get(client);
-	const claimed = runtime?.claimedThreads.get(threadId);
-	let transition = runtime?.releasingThreads.get(threadId);
-	if (transition?.physicalRelease) {
-		await transition.physicalRelease;
-		return;
+function readDefault(schema) {
+	if (!isRecord(schema) || !Object.hasOwn(schema, "default")) return;
+	return structuredClone(schema.default);
+}
+function decodePointerSegment(segment) {
+	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveLocalRef(root, ref) {
+	if (ref === "#") return root;
+	if (!ref.startsWith("#/")) return;
+	let current = root;
+	for (const segment of ref.slice(2).split("/").map(decodePointerSegment)) {
+		if (!isRecord(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function applySchemaDefaults(schema, value, root = schema, resolvingRefs = /* @__PURE__ */ new Set()) {
+	if (value === void 0) {
+		const defaultValue = readDefault(schema);
+		if (defaultValue !== void 0) return defaultValue;
+	}
+	if (!isRecord(schema)) return value;
+	let nextValue = value;
+	if (typeof schema.$ref === "string" && !resolvingRefs.has(schema.$ref)) {
+		const target = resolveLocalRef(root, schema.$ref);
+		if (target !== void 0) {
+			resolvingRefs.add(schema.$ref);
+			nextValue = applySchemaDefaults(target, nextValue, root, resolvingRefs);
+			resolvingRefs.delete(schema.$ref);
+		}
 	}
-	const physicalRelease = Promise.resolve().then(async () => {
-		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) !== claimed) return;
-		await client.request("thread/unsubscribe", { threadId }, { timeoutMs });
-	});
-	const ownsTransition = runtime !== void 0 && transition === void 0;
-	if (transition) transition.physicalRelease = physicalRelease;
-	else if (runtime) {
-		transition = {
-			completion: physicalRelease,
-			physicalRelease
-		};
-		runtime.releasingThreads.set(threadId, transition);
+	for (const key of ["allOf"]) {
+		const branches = schema[key];
+		if (Array.isArray(branches)) for (const branch of branches) nextValue = applySchemaDefaults(branch, nextValue, root, resolvingRefs);
 	}
-	try {
-		await physicalRelease;
-		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) === claimed) runtime.claimedThreads.delete(threadId);
-	} finally {
-		if (ownsTransition && runtime.releasingThreads.get(threadId) === transition) runtime.releasingThreads.delete(threadId);
+	if (schemaTypeIncludes(schema, "object") && isRecord(nextValue) && isRecord(schema.properties)) {
+		for (const [key, propertySchema] of Object.entries(schema.properties)) {
+			const currentValue = nextValue[key];
+			const defaultedValue = applySchemaDefaults(propertySchema, currentValue, root, resolvingRefs);
+			if (defaultedValue !== void 0 && defaultedValue !== currentValue) nextValue[key] = defaultedValue;
+		}
+		if (isRecord(schema.additionalProperties)) for (const key of Object.keys(nextValue)) {
+			if (Object.hasOwn(schema.properties, key)) continue;
+			nextValue[key] = applySchemaDefaults(schema.additionalProperties, nextValue[key], root, resolvingRefs);
+		}
 	}
+	if (schemaTypeIncludes(schema, "array") && Array.isArray(nextValue) && isRecord(schema.items)) return nextValue.map((entry) => applySchemaDefaults(schema.items, entry, root, resolvingRefs));
+	return nextValue;
+}
+function normalizeWithDefaults(schema, value) {
+	if (value === void 0 || value === null) return value;
+	return applySchemaDefaults(schema, structuredClone(value));
+}
+const validateDynamicToolCallParams = compileCodexSchema(dynamicToolCallParamsSchema);
+const validateErrorNotification = compileCodexSchema(errorNotificationSchema);
+const validateModelListResponse = compileCodexSchema(modelListResponseSchema);
+const validateThreadResumeResponse = compileCodexSchema(threadResumeResponseSchema);
+const validateThreadStartResponse = compileCodexSchema(threadStartResponseSchema);
+const validateTurnCompletedNotification = compileCodexSchema(turnCompletedNotificationSchema);
+const validateTurnStartResponse = compileCodexSchema(turnStartResponseSchema);
+/** Asserts and normalizes a Codex thread/start response. */
+function assertCodexThreadStartResponse(value) {
+	const normalized = normalizeWithDefaults(threadStartResponseSchema, value);
+	return assertCodexShape(validateThreadStartResponse, normalized, "thread/start response");
+}
+/** Asserts and normalizes a Codex thread/fork response. */
+function assertCodexThreadForkResponse(value) {
+	const normalized = normalizeWithDefaults(threadStartResponseSchema, value);
+	return assertCodexShape(validateThreadStartResponse, normalized, "thread/fork response");
+}
+/** Asserts the experimental beforeTurnId request field before it crosses the app-server boundary. */
+function assertCodexThreadForkParams(value) {
+	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.beforeTurnId !== void 0 && value.beforeTurnId !== null && typeof value.beforeTurnId !== "string") throw new Error("Invalid Codex app-server thread/fork params");
+	return value;
 }
-/** Reset/end owns the exact thread; failed generation retirement must never release its successor. */
-async function releaseCodexAppServerLiveThread(client, threadId) {
-	const runtime = configuredClients.get(client);
-	return runtime ? await releaseRetainedThread(client, runtime, threadId) : false;
+/** Asserts and normalizes a Codex thread/resume response. */
+function assertCodexThreadResumeResponse(value) {
+	const normalized = normalizeWithDefaults(threadResumeResponseSchema, value);
+	return assertCodexShape(validateThreadResumeResponse, normalized, "thread/resume response");
 }
-/** Native child work pins its parent's subscription even after the foreground parent turn ends. */
-function protectCodexAppServerLiveThread(client, threadId) {
-	const runtime = configuredClients.get(client);
-	if (!runtime || runtime.closed) return () => void 0;
-	runtime.protectedThreads.set(threadId, (runtime.protectedThreads.get(threadId) ?? 0) + 1);
-	scheduleRetainedThreadEviction(client, runtime);
-	let protectedThread = true;
-	return () => {
-		if (!protectedThread) return;
-		protectedThread = false;
-		if (runtime.closed) return;
-		const count = runtime.protectedThreads.get(threadId) ?? 0;
-		if (count <= 1) {
-			runtime.protectedThreads.delete(threadId);
-			const retained = runtime.retainedThreads.get(threadId);
-			if (retained) {
-				runtime.retainedThreads.delete(threadId);
-				runtime.retainedThreads.set(threadId, {
-					...retained,
-					expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS
-				});
-			}
-		} else runtime.protectedThreads.set(threadId, count - 1);
-		scheduleRetainedThreadEviction(client, runtime);
-		evictExcessIdleThreads(client, runtime).catch((error) => {
-			embeddedAgentLog.warn("codex retained thread unpin eviction failed", {
-				threadId,
-				reason: formatErrorMessage(error)
-			});
-		});
+var CodexThreadDirectInputError = class extends Error {
+	constructor(threadId) {
+		super(`Codex thread ${threadId} is controlled by its parent and cannot accept direct input. Continue its parent thread, or use /new for a separate OpenClaw session.`);
+		this.name = "CodexThreadDirectInputError";
+	}
+};
+/** Native V2 children allow observation, but only their parent may supply turn input. */
+function assertCodexThreadAcceptsDirectInput(thread) {
+	if (thread.canAcceptDirectInput === false) throw new CodexThreadDirectInputError(thread.id);
+}
+/** Asserts and normalizes a Codex turn/start response. */
+function assertCodexTurnStartResponse(value) {
+	const normalized = normalizeWithDefaults(turnStartResponseSchema, normalizeTurnStartResponse(value));
+	return assertCodexShape(validateTurnStartResponse, normalized, "turn/start response");
+}
+/** Reads Codex dynamic-tool call params, returning undefined for invalid payloads. */
+function readCodexDynamicToolCallParams(value) {
+	return readCodexShape(validateDynamicToolCallParams, normalizeWithDefaults(dynamicToolCallParamsSchema, value));
+}
+/** Reads a Codex error notification payload if it matches the protocol schema. */
+function readCodexErrorNotification(value) {
+	return readCodexShape(validateErrorNotification, normalizeWithDefaults(errorNotificationSchema, value));
+}
+/** Asserts and normalizes a Codex model/list response. */
+function assertCodexModelListResponse(value) {
+	return assertCodexShape(validateModelListResponse, normalizeWithDefaults(modelListResponseSchema, value), "model/list response");
+}
+/** Reads and normalizes a Codex turn object. */
+function readCodexTurn(value) {
+	return readCodexShape(validateTurnStartResponse, normalizeWithDefaults(turnStartResponseSchema, { turn: normalizeTurn(value) }))?.turn;
+}
+/** Reads a Codex turn/completed notification payload if it matches the protocol schema. */
+function readCodexTurnCompletedNotification(value) {
+	return readCodexShape(validateTurnCompletedNotification, normalizeWithDefaults(turnCompletedNotificationSchema, normalizeTurnCompletedNotification(value)));
+}
+function assertCodexShape(validate, value, label) {
+	if (validate.check(value)) return value;
+	throw new Error(`Invalid Codex app-server ${label}: ${formatValidationErrors(validate, value)}`);
+}
+function readCodexShape(validate, value) {
+	return validate.check(value) ? value : void 0;
+}
+function normalizeTurn(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	return {
+		error: null,
+		startedAt: null,
+		completedAt: null,
+		durationMs: null,
+		...value,
+		items: Array.isArray(value.items) ? value.items.map(normalizeThreadItem) : []
 	};
 }
-//#endregion
-//#region extensions/codex/src/app-server/elicitation-response.ts
-function createCodexElicitationResponse(action, content = null, meta = null) {
+function normalizeThreadItem(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	switch (value.type) {
+		case "agentMessage": return {
+			phase: null,
+			delivery: null,
+			memoryCitation: null,
+			...value
+		};
+		case "plan": return {
+			text: "",
+			...value
+		};
+		case "reasoning": return {
+			summary: [],
+			content: [],
+			...value
+		};
+		case "dynamicToolCall": return {
+			namespace: null,
+			arguments: null,
+			status: "completed",
+			contentItems: null,
+			success: null,
+			durationMs: null,
+			...value
+		};
+		default: return value;
+	}
+}
+function normalizeTurnStartResponse(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) return value;
 	return {
-		action,
-		content,
-		_meta: meta
+		...value,
+		turn: normalizeTurn(value.turn)
+	};
+}
+function normalizeTurnCompletedNotification(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) return value;
+	return {
+		...value,
+		turn: normalizeTurn(value.turn)
 	};
 }
+function formatValidationErrors(validate, value) {
+	const errors = validate.errors(value);
+	if (!errors || errors.length === 0) return "schema validation failed";
+	return errors.map((error) => {
+		const message = error.message?.trim() || "schema validation failed";
+		return error.instancePath ? `${error.instancePath} ${message}` : message;
+	}).join("; ");
+}
 //#endregion
 //#region extensions/codex/src/app-server/rpc-error.ts
 /** RPC error wrapper that preserves app-server error code and data. */
@@ -2248,339 +5361,14 @@ function websocketFrameToText(data) {
 	return Buffer.from(data).toString("utf8");
 }
 //#endregion
-//#region extensions/codex/src/app-server/transport-process-containment.ts
-const PROCESS_COLUMNS = "pid=,ppid=,pgid=,stat=,lstart=";
-const MAX_CONTAINED_PROCESSES = 512;
-const MAX_PROCESS_CONTAINMENT_MS = 2e3;
-const MAX_PROCESS_QUIESCE_PASSES = 16;
-const PROCESS_INSPECTION_MAX_BYTES = 8 * 1024 * 1024;
-async function terminateCodexAppServerDescendants(child) {
-	const rootPid = child.pid;
-	if (process.platform === "win32" || !rootPid || !child.kill || hasExited(child)) return;
-	const deadline = Date.now() + MAX_PROCESS_CONTAINMENT_MS;
-	const snapshot = await readProcessSnapshot(deadline);
-	if (!snapshot || Date.now() >= deadline) return;
-	const root = snapshot.find((row) => row.pid === rootPid);
-	if (!root || !isSameLiveRoot(root, root)) return;
-	const initialDescendants = collectDescendants(snapshot, [rootPid]);
-	if (initialDescendants.length > MAX_CONTAINED_PROCESSES) return;
-	const stoppedDescendants = /* @__PURE__ */ new Map();
-	if (!await signalSameRoot(root, "SIGSTOP", deadline)) return;
-	let resumeRootOnUnwind = true;
-	try {
-		const descendants = await quiesceDescendants(root, initialDescendants, stoppedDescendants, deadline);
-		if (!descendants) return;
-		for (const descendant of descendants.toReversed()) {
-			if (Date.now() >= deadline) return;
-			if (!descendant.state.startsWith("Z")) {
-				if (!await signalSameProcess(descendant, "SIGKILL", deadline) || Date.now() >= deadline) return;
-			}
-		}
-		resumeRootOnUnwind = false;
-		let resumed = false;
-		return () => {
-			if (resumed) return;
-			resumed = true;
-			resumeTransportRoot(child, root, false);
-		};
-	} finally {
-		if (resumeRootOnUnwind) {
-			for (const descendant of stoppedDescendants.values()) signalProcess(descendant.pid, "SIGCONT");
-			resumeTransportRoot(child, root, true);
-		}
-	}
-}
-async function quiesceDescendants(root, initialDescendants, stopped, deadline) {
-	const provenByPid = new Map(initialDescendants.map((descendant) => [descendant.pid, descendant]));
-	const stopFailures = /* @__PURE__ */ new Map();
-	for (let pass = 0; pass < MAX_PROCESS_QUIESCE_PASSES; pass += 1) {
-		if (Date.now() >= deadline) return;
-		const snapshot = await readProcessSnapshot(deadline);
-		if (!snapshot || Date.now() >= deadline) return;
-		const currentRoot = snapshot.find((row) => row.pid === root.pid);
-		if (!currentRoot || !isSameLiveRoot(currentRoot, root)) return;
-		if (!isSameLiveRoot(currentRoot, root, true)) {
-			if (!await signalSameRoot(root, "SIGSTOP", deadline) || Date.now() >= deadline) return;
-			continue;
-		}
-		const snapshotByPid = new Map(snapshot.map((process) => [process.pid, process]));
-		const liveProven = [];
-		for (const proven of provenByPid.values()) {
-			const current = snapshotByPid.get(proven.pid);
-			if (!current) {
-				provenByPid.delete(proven.pid);
-				stopped.delete(identityKey(proven));
-				continue;
-			}
-			if (!hasSameIdentity(proven, current)) return;
-			provenByPid.set(current.pid, current);
-			const key = identityKey(current);
-			if (stopped.has(key)) stopped.set(key, current);
-			liveProven.push(current);
-		}
-		const descendants = collectDescendants(snapshot, [root.pid, ...liveProven.map(({ pid }) => pid)]);
-		for (const descendant of descendants) {
-			const proven = provenByPid.get(descendant.pid);
-			if (proven && !hasSameIdentity(proven, descendant)) return;
-			provenByPid.set(descendant.pid, descendant);
-		}
-		if (provenByPid.size > MAX_CONTAINED_PROCESSES) return;
-		const quiescenceTargets = new Map(liveProven.map((process) => [process.pid, process]));
-		for (const descendant of descendants) quiescenceTargets.set(descendant.pid, descendant);
-		let allStopped = true;
-		for (const descendant of quiescenceTargets.values()) {
-			if (Date.now() >= deadline) return;
-			if (isStoppedState(descendant.state)) continue;
-			const stopQueued = await signalSameProcess(descendant, "SIGSTOP", deadline);
-			if (Date.now() >= deadline) return;
-			if (stopQueued) {
-				stopFailures.delete(identityKey(descendant));
-				stopped.set(identityKey(descendant), descendant);
-			} else {
-				const key = identityKey(descendant);
-				const failures = (stopFailures.get(key) ?? 0) + 1;
-				if (failures >= 2) return;
-				stopFailures.set(key, failures);
-			}
-			if (!isUninterruptibleState(descendant.state) || !stopQueued) allStopped = false;
-		}
-		if (allStopped) return [...provenByPid.values()];
-	}
-}
-async function readProcessSnapshot(deadline) {
-	return await readProcesses(["-axo", PROCESS_COLUMNS], deadline);
-}
-async function readProcess(pid, deadline) {
-	return (await readProcesses([
-		"-o",
-		PROCESS_COLUMNS,
-		"-p",
-		String(pid)
-	], deadline))?.find((row) => row.pid === pid);
-}
-async function readProcesses(args, deadline) {
-	const remainingMs = deadline - Date.now();
-	if (remainingMs <= 0) return;
-	return await new Promise((resolve) => {
-		let settled = false;
-		const settle = (processes) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			resolve(processes);
-		};
-		const inspector = execFile("ps", args, {
-			encoding: "utf8",
-			maxBuffer: PROCESS_INSPECTION_MAX_BYTES
-		}, (error, stdout) => {
-			settle(error ? void 0 : parseProcesses(stdout));
-		});
-		const timer = setTimeout(() => {
-			settle(void 0);
-			inspector.stdout?.destroy();
-			inspector.stderr?.destroy();
-			inspector.kill("SIGKILL");
-			inspector.unref();
-		}, Math.max(1, remainingMs));
-		timer.unref?.();
-	});
-}
-function parseProcesses(output) {
-	const rows = [];
-	for (const line of output.split("\n")) {
-		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line);
-		if (!match) continue;
-		const pid = Number(match[1] ?? "");
-		const ppid = Number(match[2] ?? "");
-		const pgid = Number(match[3] ?? "");
-		const startedAt = (match[5] ?? "").trim().replace(/\s+/g, " ");
-		if (![
-			pid,
-			ppid,
-			pgid
-		].every(Number.isSafeInteger) || pid <= 0 || ppid < 0 || pgid <= 0 || !startedAt) continue;
-		rows.push({
-			pid,
-			ppid,
-			pgid,
-			state: match[4] ?? "",
-			startedAt
-		});
-	}
-	return rows;
-}
-function collectDescendants(snapshot, rootPids) {
-	const childrenByParent = /* @__PURE__ */ new Map();
-	for (const row of snapshot) {
-		const children = childrenByParent.get(row.ppid) ?? [];
-		children.push(row);
-		childrenByParent.set(row.ppid, children);
-	}
-	const descendants = [];
-	const pending = [...new Set(rootPids)];
-	const seen = new Set(pending);
-	for (const parentPid of pending) for (const child of childrenByParent.get(parentPid) ?? []) {
-		if (seen.has(child.pid)) continue;
-		seen.add(child.pid);
-		descendants.push(child);
-		pending.push(child.pid);
-	}
-	return descendants;
-}
-function isStoppedState(state) {
-	return state.startsWith("T") || state.startsWith("t") || state.startsWith("Z");
-}
-function isQuiescedState(state) {
-	return isStoppedState(state) || isUninterruptibleState(state);
-}
-function isUninterruptibleState(state) {
-	return state.startsWith("D") || state.startsWith("U");
-}
-function isSameLiveProcess(current, expected) {
-	return current.pgid === expected.pgid && !current.state.startsWith("Z") && hasSameIdentity(current, expected);
-}
-function isSameLiveRoot(current, expected, requireStopped = false) {
-	return current.ppid === process.pid && (!requireStopped || isQuiescedState(current.state)) && isSameLiveProcess(current, expected);
-}
-async function signalSameRoot(root, signal, deadline) {
-	const current = await readProcess(root.pid, deadline);
-	return Boolean(current && isSameLiveRoot(current, root) && signalProcess(current.pid, signal));
-}
-function resumeTransportRoot(child, root, allowSynchronousPidFallback) {
-	try {
-		if (child.kill) {
-			child.kill("SIGCONT");
-			return;
-		}
-	} catch {
-		if (!allowSynchronousPidFallback) return;
-	}
-	if (allowSynchronousPidFallback) signalProcess(root.pid, "SIGCONT");
-}
-async function signalSameProcess(expected, signal, deadline) {
-	const current = await readProcess(expected.pid, deadline);
-	return Boolean(current && isSameLiveProcess(current, expected) && signalProcess(current.pid, signal));
-}
-function hasSameIdentity(left, right) {
-	return identityKey(left) === identityKey(right);
-}
-function identityKey(row) {
-	return `${row.pid}\0${row.startedAt}`;
-}
-function hasExited(child) {
-	return child.exitCode != null || child.signalCode != null;
-}
-function signalProcess(pid, signal) {
-	try {
-		process.kill(pid, signal);
-		return true;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region extensions/codex/src/app-server/transport.ts
-/**
-* Shared transport lifecycle helpers for stdio and WebSocket Codex app-server
-* connections.
-*/
-const CODEX_APP_SERVER_TRANSPORT_CLOSES = /* @__PURE__ */ new WeakMap();
-/** Starts graceful transport shutdown and schedules a force kill fallback. */
-function closeCodexAppServerTransport(child, options = {}) {
-	beginCodexAppServerTransportClose(child, options);
-}
-function beginCodexAppServerTransportClose(child, options) {
-	const current = CODEX_APP_SERVER_TRANSPORT_CLOSES.get(child);
-	if (current) return current;
-	if (process.platform === "win32" || !child.pid || !child.kill || hasCodexAppServerTransportExited(child)) {
-		finishCodexAppServerTransportClose(child, options);
-		const completed = Promise.resolve();
-		CODEX_APP_SERVER_TRANSPORT_CLOSES.set(child, completed);
-		return completed;
-	}
-	const closing = (async () => {
-		let resumeRoot;
-		try {
-			resumeRoot = await terminateCodexAppServerDescendants(child);
-		} catch {
-			resumeRoot = void 0;
-		}
-		try {
-			finishCodexAppServerTransportClose(child, options, resumeRoot);
-		} catch {
-			signalCodexAppServerTransport(child, "SIGKILL");
-		}
-	})();
-	CODEX_APP_SERVER_TRANSPORT_CLOSES.set(child, closing);
-	return closing;
-}
-function finishCodexAppServerTransportClose(child, options, resumeRoot) {
-	const forceKillDelayMs = options.forceKillDelayMs ?? 1e3;
-	const forceKill = setTimeout(() => {
-		if (hasCodexAppServerTransportExited(child)) return;
-		signalCodexAppServerTransport(child, "SIGKILL");
-	}, Math.max(1, forceKillDelayMs));
-	forceKill.unref?.();
-	child.once("exit", () => {
-		clearTimeout(forceKill);
-		child.stdout.destroy?.();
-		child.stderr.destroy?.();
-	});
-	try {
-		child.stdin.end?.();
-		child.stdin.destroy?.();
-	} finally {
-		resumeRoot?.();
-	}
-	child.unref?.();
-	child.stdout.unref?.();
-	child.stderr.unref?.();
-	child.stdin.unref?.();
-}
-/** Closes a transport and waits briefly for an exit event. */
-async function closeCodexAppServerTransportAndWait(child, options = {}) {
-	if (!hasCodexAppServerTransportExited(child)) await beginCodexAppServerTransportClose(child, options);
-	return await waitForCodexAppServerTransportExit(child, options.exitTimeoutMs ?? 2e3);
-}
-function hasCodexAppServerTransportExited(child) {
-	return child.exitCode !== null && child.exitCode !== void 0 ? true : child.signalCode !== null && child.signalCode !== void 0;
-}
-async function waitForCodexAppServerTransportExit(child, timeoutMs) {
-	if (hasCodexAppServerTransportExited(child)) return true;
-	return await new Promise((resolve) => {
-		let settled = false;
-		const onExit = () => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeout);
-			resolve(true);
-		};
-		const timeout = setTimeout(() => {
-			if (settled) return;
-			settled = true;
-			child.off?.("exit", onExit);
-			resolve(false);
-		}, Math.max(1, timeoutMs));
-		child.once("exit", onExit);
-	});
-}
-function signalCodexAppServerTransport(child, signal) {
-	if (child.pid && process.platform !== "win32") try {
-		process.kill(-child.pid, signal);
-		return;
-	} catch {}
-	child.kill?.(signal);
-}
-//#endregion
 //#region extensions/codex/src/app-server/client.ts
 /**
 * JSON-RPC client for Codex app-server transports, including request/response
 * routing, notification fanout, server request handlers, and version checks.
 */
 const CODEX_APP_SERVER_PARSE_LOG_MAX = 500;
-const CODEX_APP_SERVER_PARSE_BUFFER_MAX = 8 * 1024 * 1024;
+const CODEX_APP_SERVER_PARSE_BUFFER_MAX = 8388608;
 const CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES = 1e3;
-const CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS = 66e4;
 const CODEX_APP_SERVER_STDERR_TAIL_MAX = 2e3;
 const CODEX_APP_SERVER_OVERLOADED_ERROR_CODE = -32001;
 const CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES = 3;
@@ -2599,6 +5387,10 @@ function getCodexAppServerClientInstanceId(client) {
 function resolveCodexAppServerClientInstanceId(client) {
 	return client.getInstanceId?.call(client) ?? getCodexAppServerClientInstanceId(client);
 }
+/** Codex rejects this exact code before enqueueing, including mutating requests. */
+function isCodexAppServerOverloadError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === CODEX_APP_SERVER_OVERLOADED_ERROR_CODE;
+}
 var CodexAppServerLocalRequestCancellationError = class extends Error {
 	constructor(method, reason, mayHaveWritten) {
 		super(`${method} ${reason}`);
@@ -2658,6 +5450,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.closeHandlers = /* @__PURE__ */ new Set();
 		this.nextId = 1;
 		this.initialized = false;
+		this.modelCatalogRevision = 0;
 		this.closed = false;
 		this.transportExited = false;
 		this.stderrTail = "";
@@ -2683,7 +5476,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		child.stdin.on?.("error", (error) => this.closeWithError(toStringifiedError(error)));
 	}
 	/** Starts a new app-server client using resolved runtime start options. */
-	static start(options) {
+	static async start(options, assertCurrent) {
 		const defaults = resolveCodexAppServerRuntimeOptions().start;
 		const startOptions = {
 			...defaults,
@@ -2692,7 +5485,18 @@ var CodexAppServerClient = class CodexAppServerClient {
 		};
 		if (startOptions.transport === "stdio" && startOptions.commandSource === "managed") throw new Error("Managed Codex app-server start options must be resolved before spawn.");
 		if (startOptions.transport === "websocket" || startOptions.transport === "unix") return new CodexAppServerClient(createWebSocketTransport(startOptions));
-		return new CodexAppServerClient(createStdioTransport(startOptions));
+		let client;
+		try {
+			await createStdioTransport(startOptions, process.env, assertCurrent, (child) => {
+				client = new CodexAppServerClient(child);
+			});
+			return client;
+		} catch (error) {
+			assertCurrent?.();
+			if (client?.transportExited && hasCodexAppServerNaturalExit(client.child)) throw buildCodexAppServerExitError(client.child.exitCode, client.child.signalCode, client.stderrTail);
+			const stderr = client?.getStderrDiagnostic();
+			throw stderr ? new Error(`${coerceErrorMessage(error)}; stderr=${JSON.stringify(stderr)}`, { cause: error }) : error;
+		}
 	}
 	/** Builds a client around a fake transport for tests. */
 	static fromTransportForTests(child) {
@@ -2741,6 +5545,10 @@ var CodexAppServerClient = class CodexAppServerClient {
 	getInstanceId() {
 		return this.instanceId;
 	}
+	/** Account/config observations become stale before a mutation can enter the wire. */
+	getModelCatalogRevision() {
+		return this.modelCatalogRevision;
+	}
 	/** Installs the spawn-owner check run before config-loading thread requests. */
 	setThreadSessionRequestGuard(guard) {
 		this.threadSessionRequestGuard = guard;
@@ -2750,8 +5558,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		return this.child.pid;
 	}
 	request(method, params, optionsInput) {
-		let options = optionsInput;
-		options ??= {};
+		const options = optionsInput ?? {};
 		if (this.closed) return Promise.reject(this.closeError ?? /* @__PURE__ */ new Error("codex app-server client is closed"));
 		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false));
 		const guard = method === "thread/start" || method === "thread/resume" || method === "thread/fork" ? this.threadSessionRequestGuard : void 0;
@@ -2786,11 +5593,11 @@ var CodexAppServerClient = class CodexAppServerClient {
 					const elapsedMs = Date.now() - guardStartedAt;
 					const remainingTimeoutMs = options.timeoutMs === void 0 ? void 0 : options.timeoutMs - elapsedMs;
 					if (remainingTimeoutMs !== void 0 && remainingTimeoutMs <= 0) throw new CodexAppServerLocalRequestCancellationError(method, "timed out", false);
-					return await this.requestWithoutThreadSessionGuard(method, params, {
+					return await this.requestWithOverloadRetry(method, params, {
 						...options,
 						...remainingTimeoutMs !== void 0 ? { timeoutMs: remainingTimeoutMs } : {}
-					}, () => {
-						requestMayHaveWritten = true;
+					}, (mayHaveWritten) => {
+						requestMayHaveWritten = mayHaveWritten;
 					});
 				} catch (error) {
 					if (requestMayHaveWritten && !(error instanceof CodexAppServerRpcError)) {
@@ -2803,12 +5610,9 @@ var CodexAppServerClient = class CodexAppServerClient {
 				}
 			})();
 		}
-		return this.requestWithoutThreadSessionGuard(method, params, options);
+		return this.requestWithOverloadRetry(method, params, options);
 	}
-	requestWithoutThreadSessionGuard(method, params, options, onWriteAttempt) {
-		return this.requestWithOverloadRetry(method, params, options, onWriteAttempt);
-	}
-	async requestWithOverloadRetry(method, params, options, onWriteAttempt) {
+	async requestWithOverloadRetry(method, params, options, onWriteStateChange) {
 		const deadline = options.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) ? Date.now() + options.timeoutMs : void 0;
 		for (let retry = 0;; retry += 1) {
 			if (options.signal?.aborted) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false);
@@ -2818,9 +5622,10 @@ var CodexAppServerClient = class CodexAppServerClient {
 				return await this.requestOnce(method, params, {
 					...options,
 					...remainingTimeoutMs !== void 0 ? { timeoutMs: remainingTimeoutMs } : {}
-				}, onWriteAttempt);
+				}, onWriteStateChange);
 			} catch (error) {
-				if (!(error instanceof CodexAppServerRpcError) || error.code !== CODEX_APP_SERVER_OVERLOADED_ERROR_CODE || retry >= CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES) throw error;
+				if (!isCodexAppServerOverloadError(error) || retry >= CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES) throw error;
+				onWriteStateChange?.(false);
 				const backoffMs = Math.round(CODEX_APP_SERVER_OVERLOAD_RETRY_BASE_MS * 2 ** retry * (.75 + Math.random() * .5));
 				await this.waitForOverloadRetry(method, backoffMs, deadline, options.signal);
 			}
@@ -2849,10 +5654,11 @@ var CodexAppServerClient = class CodexAppServerClient {
 			if (signal?.aborted) abortListener();
 		});
 	}
-	requestOnce(method, params, options, onWriteAttempt) {
+	requestOnce(method, params, options, onWriteStateChange) {
 		if (this.closed) return Promise.reject(this.closeError ?? /* @__PURE__ */ new Error("codex app-server client is closed"));
 		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false));
 		const id = this.nextId++;
+		if (method === "account/login/start" || method === "account/logout" || method === "config/value/write" || method === "config/batchWrite") this.modelCatalogRevision += 1;
 		const message = {
 			id,
 			method,
@@ -2902,8 +5708,9 @@ var CodexAppServerClient = class CodexAppServerClient {
 				return;
 			}
 			try {
+				options.assertCurrent?.();
 				mayHaveWritten = true;
-				onWriteAttempt?.();
+				onWriteStateChange?.(true);
 				this.writeMessage(message, (error) => rejectPending(error));
 			} catch (error) {
 				rejectPending(toStringifiedError(error));
@@ -3105,8 +5912,9 @@ var CodexAppServerClient = class CodexAppServerClient {
 	}
 	async runServerRequestHandlers(request) {
 		const controller = new AbortController();
-		const timeoutResponse = timeoutServerRequestResponse(request);
-		if (!timeoutResponse) return await this.runServerRequestHandlersWithoutTimeout(request, controller.signal);
+		if (request.method !== "item/tool/call") return await this.runServerRequestHandlersWithoutTimeout(request, controller.signal);
+		const timeoutMs = resolveDynamicToolServerRequestTimeoutMs(readCodexDynamicToolCallParams(request.params));
+		const timeoutResponse = timeoutServerRequestResponse(timeoutMs);
 		let timeout;
 		try {
 			return await Promise.race([this.runServerRequestHandlersWithoutTimeout(request, controller.signal), new Promise((resolve) => {
@@ -3114,11 +5922,11 @@ var CodexAppServerClient = class CodexAppServerClient {
 					embeddedAgentLog.warn("codex app-server server request timed out", {
 						id: request.id,
 						method: request.method,
-						timeoutMs: CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS
+						timeoutMs
 					});
 					controller.abort(/* @__PURE__ */ new Error("codex app-server server request timed out"));
 					resolve(timeoutResponse);
-				}, CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS);
+				}, timeoutMs);
 				timeout.unref?.();
 			})]);
 		} finally {
@@ -3133,6 +5941,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		}
 	}
 	handleNotification(notification) {
+		if (notification.method === "account/updated") this.modelCatalogRevision += 1;
 		if (this.notificationHandlers.size === 0 && notification.method === "configWarning") {
 			if (this.pendingStartupWarnings.length === CODEX_APP_SERVER_PENDING_STARTUP_WARNINGS_MAX) this.pendingStartupWarnings.shift();
 			this.pendingStartupWarnings.push(notification);
@@ -3186,12 +5995,11 @@ function defaultServerRequestResponse(request) {
 function stringifyCodexAppServerMessage(message) {
 	return JSON.stringify(message, (_key, value) => typeof value === "string" ? value.replace(UNPAIRED_SURROGATE_RE, "") : value) ?? "null";
 }
-function timeoutServerRequestResponse(request) {
-	if (request.method !== "item/tool/call") return;
+function timeoutServerRequestResponse(timeoutMs) {
 	return {
 		contentItems: [{
 			type: "inputText",
-			text: `OpenClaw dynamic tool call timed out after ${CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS}ms before sending a response to Codex.`
+			text: `OpenClaw dynamic tool call timed out after ${timeoutMs}ms before sending a response to Codex.`
 		}],
 		success: false
 	};
@@ -3210,7 +6018,7 @@ function assertSupportedCodexAppServerVersion(response) {
 	if (!detectedVersion) throw new CodexAppServerVersionError(detectedVersion);
 	const detected = parse(detectedVersion);
 	if (!detected || detected.compare("0.149.0") < 0) throw new CodexAppServerVersionError(detectedVersion);
-	if (detected.compare("0.150.1") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
+	if (detected.compare("0.152.1") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
 		detectedVersion,
 		validatedVersion: CODEX_APP_SERVER_VERSION
 	});
@@ -3287,15 +6095,8 @@ function formatExitValue(value) {
 */
 /** Minimum startup timeout accepted by the Codex app-server harness. */
 const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;
-/** Default idle timeout while waiting for app-server turn completion. */
-const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
-/** Short guard after apparent assistant completion. */
-const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
-const CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 5 * 6e4;
-/** Guard after reasoning/commentary progress when no tool handoff occurred. */
-const CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS = 5 * 6e4;
-/** Long terminal idle watch for app-server turns that never send completion. */
-const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
+const TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS = 12e4;
+const TURN_FINALIZE_DRAIN_ABORT_GRACE_MS = 5e3;
 var CodexAppServerStartupError = class extends Error {
 	constructor(reason, message = reason === "timed_out" ? "codex app-server startup timed out" : "codex app-server startup aborted") {
 		super(message);
@@ -3308,7 +6109,8 @@ 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) {
-	return resolveTimerTimeoutMs(value, resolveTimerTimeoutMs(fallbackMs, 1));
+	const fallback = resolveTimerTimeoutMs(fallbackMs, 1);
+	return resolveTimerTimeoutMs(value, fallback);
 }
 /** Runs startup work with abort and timeout handling plus optional cleanup. */
 async function withCodexStartupTimeout(params) {
@@ -3354,27 +6156,11 @@ function resolveCodexStartupTimeoutMs(params) {
 	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
 	return Math.max(timeoutFloorMs, timeoutMs);
 }
-/** Resolves the completion-idle timeout for an active turn. */
-function resolveCodexTurnCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the short assistant-completion release timeout. */
-function resolveCodexTurnAssistantCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the conservative post-tool raw assistant guard timeout. */
-function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallbackMs) {
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(resolvePositiveIntegerTimeoutMs(void 0, fallbackMs), CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS));
-}
-/** Resolves the long terminal turn idle timeout. */
-function resolveCodexTurnTerminalIdleTimeoutMs(value, runTimeoutOverrideMs) {
-	const explicitRunBudgetMs = resolvePositiveIntegerTimeoutMs(runTimeoutOverrideMs, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS, explicitRunBudgetMs));
-}
 /** Adds gateway grace time to a caller timeout without overflowing invalid values. */
 function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
 	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
-	return addTimerTimeoutGraceMs(timeout, resolveTimerTimeoutMs(graceMs, 0, 0)) ?? timeout;
+	const grace = resolveTimerTimeoutMs(graceMs, 0, 0);
+	return addTimerTimeoutGraceMs(timeout, grace) ?? timeout;
 }
 //#endregion
 //#region extensions/codex/src/app-server/desktop-generation-fingerprint.ts
@@ -3459,8 +6245,8 @@ async function statFingerprint(filePath) {
 	}
 }
 async function readFileFingerprint(filePath, expected, followsSymlink) {
-	const noFollow = followsSymlink ? 0 : constants.O_NOFOLLOW ?? 0;
-	const handle = await fs.open(filePath, constants.O_RDONLY | noFollow);
+	const noFollow = followsSymlink ? 0 : constants$1.O_NOFOLLOW ?? 0;
+	const handle = await fs.open(filePath, constants$1.O_RDONLY | noFollow);
 	try {
 		const before = await handle.stat({ bigint: true });
 		if (!sameStat(before, expected)) throw new Error(`Codex desktop artifact changed while fingerprinting: ${filePath}`);
@@ -3757,6 +6543,26 @@ async function waitForPreviousFence(previous, options) {
 	});
 }
 //#endregion
+//#region extensions/codex/src/app-server/thread-lifecycle-errors.ts
+var CodexThreadStartRequestError = class extends Error {
+	constructor(cause) {
+		super(`thread/start: ${formatErrorMessage(cause)}`, { cause });
+		this.name = "CodexThreadStartRequestError";
+	}
+};
+var CodexThreadBindingConflictError = class extends Error {
+	constructor(threadId, operation) {
+		super(`Codex thread binding changed while ${operation}: ${threadId}`);
+		this.name = "CodexThreadBindingConflictError";
+	}
+};
+var CodexAdoptedThreadActiveError = class extends AgentHarnessPreflightError {
+	constructor(message = "Codex session became active in another runner; wait for it to finish before continuing") {
+		super(message);
+		this.name = "CodexAdoptedThreadActiveError";
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/shared-client.ts
 /**
 * Owns shared and isolated Codex app-server client startup, auth application,
@@ -3764,6 +6570,8 @@ async function waitForPreviousFence(previous, options) {
 */
 var shared_client_exports = /* @__PURE__ */ __exportAll({
 	assertCodexAppServerClientStartSelectionCurrent: () => assertCodexAppServerClientStartSelectionCurrent,
+	captureCodexAppServerClientLifetime: () => captureCodexAppServerClientLifetime,
+	captureSharedCodexAppServerCatalogLifetime: () => captureSharedCodexAppServerCatalogLifetime,
 	clearSharedCodexAppServerClientAndWait: () => clearSharedCodexAppServerClientAndWait,
 	clearSharedCodexAppServerClientIfCurrent: () => clearSharedCodexAppServerClientIfCurrent,
 	clearSharedCodexAppServerClientIfCurrentAndUnclaimed: () => clearSharedCodexAppServerClientIfCurrentAndUnclaimed,
@@ -3902,7 +6710,7 @@ 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.`);
+	if (preparedAuth?.kind === "profile" && !preparedAuth.store.profiles[preparedAuth.profileId]) throw new Error(`Prepared Codex auth profile "${preparedAuth.profileId}" was not found. Select an existing OpenAI profile or sign in again with OpenClaw, then retry.`);
 	if (preparedAuth?.kind === "api-key" && !preparedApiKey) throw new Error("Prepared Codex API-key auth is missing its resolved key.");
 	if (preparedAuth && requestedStartOptions.homeScope === "user") throw new Error("Prepared Codex auth requires an isolated app-server home.");
 	const preparedAuthRequirement = inferAuthRequirement(preparedAuth);
@@ -3910,11 +6718,11 @@ async function resolveCodexAppServerClientStartContext(options) {
 	const authRequirement = options?.authRequirement ?? preparedAuthRequirement;
 	const usesNativeAuth = !preparedAuth && (options?.authProfileId === null || requestedStartOptions.homeScope === "user");
 	const requestedAuthProfileId = preparedAuth?.kind === "profile" ? preparedAuth.profileId : options?.authProfileId ?? void 0;
-	const authProfileStore = preparedAuth?.kind === "profile" ? preparedAuth.store : !usesNativeAuth && options?.authProfileStore ? resolveCodexAppServerAuthProfileStore({
+	const authProfileStore = preparedAuth?.kind === "profile" ? preparedAuth.store : !usesNativeAuth && preparedAuth?.kind !== "api-key" ? resolveCodexAppServerAuthProfileStore({
 		agentDir,
 		authProfileId: requestedAuthProfileId,
-		authProfileStore: options.authProfileStore,
-		config: options.config
+		authProfileStore: options?.authProfileStore,
+		config: options?.config
 	}) : options?.authProfileStore;
 	const authProfileId = preparedAuth?.kind === "profile" ? preparedAuth.profileId : usesNativeAuth || preparedAuth?.kind === "api-key" ? void 0 : resolveCodexAppServerAuthProfileIdForAgent({
 		authProfileId: requestedAuthProfileId,
@@ -3922,20 +6730,26 @@ async function resolveCodexAppServerClientStartContext(options) {
 		config: options?.config,
 		...authProfileStore ? { authProfileStore } : {}
 	});
-	const preparedAuthProfileSnapshot = preparedAuth?.kind === "profile" ? preparedAuth.snapshot ?? await resolveCodexAppServerPreparedAuthProfileSnapshot({
+	const preparedAuthProfileSnapshot = !usesNativeAuth && authProfileId ? (preparedAuth?.kind === "profile" ? preparedAuth.snapshot : void 0) ?? await resolveCodexAppServerPreparedAuthProfileSnapshot({
 		authProfileId,
 		authProfileStore,
 		agentDir,
 		config: options?.config
 	}) : void 0;
-	if (preparedAuth?.kind === "profile" && !preparedAuthProfileSnapshot) throw new Error(`Prepared Codex auth profile "${preparedAuth.profileId}" is unusable.`);
+	if (preparedAuth?.kind === "profile" && !preparedAuthProfileSnapshot) throw new Error(`Prepared Codex auth profile "${preparedAuth.profileId}" is unusable. Repair or replace the selected OpenAI profile, then retry.`);
 	const resolvedPreparedAuth = preparedAuth?.kind === "api-key" ? {
 		kind: "api-key",
 		apiKey: preparedApiKey
-	} : preparedAuth?.kind === "profile" ? {
-		...preparedAuth,
+	} : preparedAuthProfileSnapshot && authProfileId && authProfileStore ? {
+		kind: "profile",
+		profileId: authProfileId,
+		store: authProfileStore,
 		snapshot: preparedAuthProfileSnapshot
 	} : void 0;
+	const agentStartOptions = resolveCodexAppServerStartOptionsForAgent({
+		startOptions: requestedStartOptions,
+		agentDir
+	});
 	return {
 		agentDir,
 		usesNativeAuth,
@@ -3945,14 +6759,11 @@ async function resolveCodexAppServerClientStartContext(options) {
 		preparedAuth: resolvedPreparedAuth,
 		authRequirement,
 		startOptions: await bridgeCodexAppServerStartOptions({
-			startOptions: await resolveManagedCodexAppServerStartOptions(resolveCodexAppServerStartOptionsForAgent({
-				startOptions: requestedStartOptions,
-				agentDir
-			})),
+			startOptions: await resolveManagedCodexAppServerStartOptions(agentStartOptions),
 			agentId: options?.agentId,
 			agentDir,
 			authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
-			...resolvedPreparedAuth ? { preparedAuth: resolvedPreparedAuth } : {},
+			...preparedAuth && resolvedPreparedAuth ? { preparedAuth: resolvedPreparedAuth } : {},
 			authRequirement,
 			config: options?.config,
 			pluginConfig: options?.pluginConfig,
@@ -3967,44 +6778,6 @@ function shouldTrackDesktopGeneration(startOptions, pluginConfig) {
 	if (resolveCodexComputerUseConfig({ pluginConfig }).enabled && (startOptions.commandSource === "managed" || startOptions.commandSource === "resolved-managed")) return true;
 	return startOptions.commandSource === "managed" && (startOptions.managedCommandOrder ?? "package-first") === "desktop-first";
 }
-function resolveWarmSharedCodexAppServerClientIdentity(options) {
-	if (!options?.config || typeof options.config !== "object" || !options.startOptions || options.pluginConfig !== void 0 || options.authProfileStore !== void 0 || options.preparedAuth !== void 0 || options.runtimeArtifactMode !== void 0 || options.expectedRuntimeArtifact !== void 0) return;
-	const authProfileSelector = options.authProfileId === null ? ["native"] : options.authProfileId === void 0 ? ["implicit"] : ["profile", options.authProfileId];
-	return {
-		config: options.config,
-		startOptions: options.startOptions,
-		selectorKey: JSON.stringify([
-			options.agentDir ?? resolveDefaultAgentDir(options.config),
-			authProfileSelector,
-			options.authBindingFingerprint ?? null,
-			options.authRequirement ?? null
-		])
-	};
-}
-function readWarmSharedCodexAppServerClient(state, identity) {
-	const aliases = state.warmClientsByConfig?.get(identity.config)?.get(identity.startOptions);
-	const warm = aliases?.get(identity.selectorKey);
-	if (!warm) return;
-	if (state.clients.get(warm.key) !== warm.entry || warm.entry.client !== warm.client || warm.entry.closeWhenIdle || warm.entry.closeError) {
-		aliases?.delete(identity.selectorKey);
-		return;
-	}
-	return warm;
-}
-function rememberWarmSharedCodexAppServerClient(state, identity, warm) {
-	state.warmClientsByConfig ??= /* @__PURE__ */ new WeakMap();
-	let byStartOptions = state.warmClientsByConfig.get(identity.config);
-	if (!byStartOptions) {
-		byStartOptions = /* @__PURE__ */ new WeakMap();
-		state.warmClientsByConfig.set(identity.config, byStartOptions);
-	}
-	let aliases = byStartOptions.get(identity.startOptions);
-	if (!aliases) {
-		aliases = /* @__PURE__ */ new Map();
-		byStartOptions.set(identity.startOptions, aliases);
-	}
-	aliases.set(identity.selectorKey, warm);
-}
 /** Gets or starts a shared Codex app-server client without retaining a lease. */
 async function getSharedCodexAppServerClient(options) {
 	return (await acquireSharedCodexAppServerClient(options)).client;
@@ -4035,7 +6808,7 @@ function releaseCodexAppServerClientLease(lease) {
 	lease.client = void 0;
 	return client ? releaseLeasedSharedCodexAppServerClient(client) : false;
 }
-/** Retries one config-loading request after moving its lease to the current owner. */
+/** Retries one config-loading operation with a shared deadline and current client lease. */
 async function withLeasedCodexAppServerClientStartSelectionRetry(params) {
 	let client = params.lease.client;
 	if (!client) throw new Error("Codex app-server selection retry requires an active client lease");
@@ -4051,24 +6824,40 @@ async function withLeasedCodexAppServerClientStartSelectionRetry(params) {
 			...signal ? { signal } : {}
 		};
 	};
-	for (let attempt = 0; attempt < 2; attempt += 1) try {
-		return await params.run(client, requestOptions());
-	} catch (error) {
-		if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
-		retireSharedCodexAppServerClientIfCurrent(client);
-		params.lease.client = void 0;
-		if (!releaseLeasedSharedCodexAppServerClient(client)) {
-			client.close();
-			throw new Error("Codex app-server selection retry requires a leased shared client", { cause: error });
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		const attemptClient = client;
+		let scopeActive = true;
+		const assertCurrent = () => {
+			if (!scopeActive || params.lease.client !== attemptClient) throw new CodexAppServerStartupError("aborted", "Codex app-server request scope is closed");
+		};
+		try {
+			requestOptions();
+			return await params.run(client, () => {
+				assertCurrent();
+				return {
+					...requestOptions(),
+					assertCurrent
+				};
+			});
+		} catch (error) {
+			if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
+			retireSharedCodexAppServerClientIfCurrent(client);
+			params.lease.client = void 0;
+			if (!releaseLeasedSharedCodexAppServerClient(client)) {
+				client.close();
+				throw new Error("Codex app-server selection retry requires a leased shared client", { cause: error });
+			}
+			const replacementOptions = requestOptions();
+			client = await getLeasedSharedCodexAppServerClient({
+				...params.options,
+				timeoutMs: replacementOptions.timeoutMs,
+				...signal ? { abandonSignal: signal } : {}
+			});
+			params.lease.client = client;
+			params.onClientChange?.(client);
+		} finally {
+			scopeActive = false;
 		}
-		const replacementOptions = requestOptions();
-		client = await getLeasedSharedCodexAppServerClient({
-			...params.options,
-			timeoutMs: replacementOptions.timeoutMs,
-			...signal ? { abandonSignal: signal } : {}
-		});
-		params.lease.client = client;
-		params.onClientChange(client);
 	}
 	throw new Error("Codex app-server selection retry loop exited unexpectedly");
 }
@@ -4077,24 +6866,6 @@ async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 	const acquireStartedAt = Date.now();
 	const timeoutMs = options?.timeoutMs ?? 0;
 	const state = getSharedCodexAppServerClientState();
-	const warmIdentity = resolveWarmSharedCodexAppServerClientIdentity(options);
-	let warmClient = warmIdentity ? readWarmSharedCodexAppServerClient(state, warmIdentity) : void 0;
-	const warmGeneration = warmClient ? getCodexAppServerClientStartMetadata().get(warmClient.client)?.desktopGeneration : void 0;
-	if (warmClient && warmGeneration && !isCodexDesktopGenerationCurrent(warmGeneration)) {
-		await withCodexAppServerAcquireDeadline(resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt), waitForCodexDesktopGeneration(), options?.abandonSignal);
-		if (!isCodexDesktopGenerationCurrent(warmGeneration)) {
-			retireSharedCodexAppServerClientIfCurrent(warmClient.client);
-			warmClient = void 0;
-		}
-	}
-	if (warmClient) {
-		options?.onStartedClient?.(warmClient.client);
-		const release = leaseOptions?.leased ? retainSharedClientEntry(warmClient.entry) : void 0;
-		return release ? {
-			client: warmClient.client,
-			release
-		} : { client: warmClient.client };
-	}
 	const { agentDir, usesNativeAuth, authProfileId, authProfileStore, preparedAuth, authRequirement, requestedStartOptions, startOptions, desktopGeneration, pluginConfig } = await withCodexAppServerAcquireDeadline(timeoutMs, resolveCodexAppServerClientStartContext(options), options?.abandonSignal);
 	const remainingTimeoutMs = resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt);
 	const authIdentityCacheKey = preparedAuth?.kind === "api-key" ? resolveCodexAppServerPreparedApiKeyCacheKey(preparedAuth.apiKey) : preparedAuth?.snapshot.secretFreeCacheKey ?? (authRequirement === "api-key" && !authProfileId ? resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions }) : void 0);
@@ -4166,11 +6937,6 @@ async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 			config: options?.config
 		});
 		const release = leaseOptions?.leased ? retainSharedClientEntry(entry) : void 0;
-		if (warmIdentity) rememberWarmSharedCodexAppServerClient(state, warmIdentity, {
-			key,
-			entry,
-			client
-		});
 		return release ? {
 			client,
 			release
@@ -4328,11 +7094,10 @@ async function startInitializedCodexAppServerClient(params) {
 		} finally {
 			artifactDrain?.cancel();
 		}
-		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-BvyT1uyd.js") : void 0;
-		const nativeCommandBeforeStart = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
+		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-C3jVimFn.js") : void 0;
 		const runtimeArtifactBeforeStart = runtimeArtifactModule ? await runtimeArtifactModule.captureCodexAppServerRuntimeArtifactBeforeStart({
 			startOptions,
-			spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions, nativeCommandBeforeStart),
+			spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions),
 			signal: params.runtimeArtifactSignal
 		}) : void 0;
 		if (runtimeArtifactModule && runtimeArtifactBeforeStart && params.expectedRuntimeArtifact && !runtimeArtifactModule.validateCodexAppServerRuntimeArtifactCapture(params.expectedRuntimeArtifact, runtimeArtifactBeforeStart)) {
@@ -4340,7 +7105,17 @@ async function startInitializedCodexAppServerClient(params) {
 			throw new Error("Codex app-server runtime artifact does not match verified inference");
 		}
 		assertDesktopGenerationCurrent();
-		const client = CodexAppServerClient.start(startOptions);
+		let starting;
+		let client;
+		try {
+			client = await withCodexAppServerAcquireDeadline(resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt), starting = CodexAppServerClient.start(startOptions, () => {
+				assertDesktopGenerationCurrent();
+				resolveRemainingAcquireTimeout(timeoutMs, acquireStartedAt);
+			}), params.abandonSignal);
+		} catch (error) {
+			starting?.then((lateClient) => lateClient.close(), () => {});
+			throw error;
+		}
 		const nativeCommandAtStart = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
 		getCodexAppServerClientStartMetadata().set(client, {
 			requestedStartOptions: params.requestedStartOptions,
@@ -4369,11 +7144,10 @@ async function startInitializedCodexAppServerClient(params) {
 		let runtimeArtifact;
 		try {
 			if (runtimeArtifactModule && runtimeArtifactBeforeStart) {
-				const nativeCommand = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
 				runtimeArtifact = await runtimeArtifactModule.finalizeCodexAppServerRuntimeArtifact({
 					before: runtimeArtifactBeforeStart,
 					startOptions,
-					spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions, nativeCommand),
+					spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions),
 					runtimeIdentity: client.getRuntimeIdentity(),
 					signal: params.runtimeArtifactSignal
 				});
@@ -4388,7 +7162,8 @@ async function startInitializedCodexAppServerClient(params) {
 			authProfileId: params.authProfileId ?? void 0,
 			authMode: params.preparedAuth?.kind === "api-key" ? "prepared-api-key" : "profile",
 			...params.authProfileStore ? { authProfileStore: params.authProfileStore } : {},
-			config: params.config
+			config: params.config,
+			onAuthRefreshFailure: () => retireSharedCodexAppServerClientIfCurrent(client)
 		});
 		try {
 			assertDesktopGenerationCurrent();
@@ -4455,6 +7230,20 @@ function clearSharedCodexAppServerClientIfCurrent(client) {
 	}
 	return false;
 }
+/** Captures a revocable observation of the exact shared client and native account/config. */
+function captureSharedCodexAppServerCatalogLifetime(client) {
+	const isCurrent = captureSharedClientRegistration(client);
+	const revision = client.getModelCatalogRevision();
+	return () => isCurrent() && client.getModelCatalogRevision() === revision;
+}
+/** Registration ends on retirement even when sibling leases keep the process alive. */
+function captureSharedClientRegistration(client) {
+	const state = getSharedCodexAppServerClientState();
+	const entry = state.entriesByClient.get(client);
+	const key = [...state.clients].find(([, candidate]) => candidate === entry)?.[0];
+	const generation = readCodexAppServerClientDesktopGeneration(client);
+	return () => key !== void 0 && state.clients.get(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) {
 	if (!client) return;
@@ -4474,6 +7263,19 @@ function retainSharedCodexAppServerClientByInstanceId(clientId) {
 		};
 	}
 }
+/** Captures physical ownership, independently of unrelated thread and reader leases. */
+function captureCodexAppServerClientLifetime(client, requiredOwnership) {
+	const state = getSharedCodexAppServerClientState();
+	const start = getCodexAppServerClientStartMetadata().get(client)?.startOptions;
+	if (requiredOwnership === "native-process" && (start?.transport !== "stdio" || isCodexAppServerProxyLaunch(start.args))) throw new AgentHarnessPreflightError("Codex ordinary configuration refresh requires an OpenClaw-managed local stdio process, not an external socket or app-server proxy. No turn was sent; reconnect through managed local stdio before continuing.");
+	const isCurrent = requiredOwnership === "native-process" && state.isolatedClients.has(client) ? () => state.isolatedClients.has(client) && !client.getCloseError() : captureSharedClientRegistration(client);
+	const assertCurrent = () => {
+		if (!isCurrent()) throw new CodexAdoptedThreadActiveError("Codex app-server connection changed during thread preparation; reconnect before continuing");
+		assertCodexAppServerClientStartSelectionCurrent({ client });
+	};
+	assertCurrent();
+	return assertCurrent;
+}
 /**
 * Retires a matching shared client. Default is graceful: detach from the map
 * (future acquisitions get a fresh client) and close once leases drain.
@@ -4589,7 +7391,6 @@ async function clearSharedCodexAppServerClientAndWait(options) {
 	const state = getSharedCodexAppServerClientState();
 	const clients = collectSharedClients(state);
 	state.clients.clear();
-	state.warmClientsByConfig = /* @__PURE__ */ new WeakMap();
 	await Promise.all(clients.map((client) => client.closeAndWait(options)));
 }
 globalThis[SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER] = clearSharedCodexAppServerClientAndWait;
@@ -4690,4 +7491,4 @@ function collectSharedClients(state) {
 	return [...state.liveClients];
 }
 //#endregion
-export { releaseCodexAppServerLiveThread as $, resolveCodexTurnAssistantCompletionIdleTimeoutMs as A, isCodexAppServerPrewriteRequestCancellationError as B, createCodexDesktopGenerationService as C, resolveCodexGatewayTimeoutWithGraceMs as D, isCodexAppServerStartupError as E, isCodexAppServerApprovalRequest as F, CodexAppServerRpcError as G, isUnsupportedCodexAppServerVersionError as H, isCodexAppServerBrokenPipeError as I, consumeCodexAppServerLiveThread as J, createCodexElicitationResponse as K, isCodexAppServerConnectionClosedError as L, resolveCodexTurnTerminalIdleTimeoutMs as M, withCodexStartupTimeout as N, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as O, getCodexAppServerClientInstanceId as P, protectCodexAppServerLiveThread as Q, isCodexAppServerIndeterminateRequestCancellationError as R, acquireCodexNativeConfigFence as S, resolveCodexAppServerLocalHomeDir as St, CodexAppServerStartupError as T, resolveCodexAppServerClientInstanceId as U, isCodexAppServerRequestTimeoutError as V, closeCodexAppServerTransportAndWait as W, isCodexAppServerClientRuntimeLive as X, ensureCodexAppServerClientRuntime as Y, isCodexAppServerLiveThreadClaimed as Z, retireSharedCodexAppServerClientIfCurrent as _, flattenCodexDynamicToolFunctions as _t, createIsolatedCodexAppServerClient as a, readRecentCodexRateLimits as at, waitForCodexAppServerClientDesktopGenerationDrain as b, assertNotSymlink as bt, isCodexAppServerStartSelectionChangedError as c, resolveCodexAppServerAuthAccountCacheKey as ct, readCodexAppServerClientProcessIdentity as d, resolveCodexAppServerFallbackApiKeyCacheKey as dt, retainCodexAppServerLiveThread as et, releaseCodexAppServerClientLease as f, resolveCodexAppServerPreparedApiKeyCacheKey as ft, retainSharedCodexAppServerClientIfCurrent as g, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as gt, retainSharedCodexAppServerClientByInstanceId as h, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as ht, clearSharedCodexAppServerClientIfCurrentAndWait as i, readCodexRateLimitsRevision as it, resolveCodexTurnCompletionIdleTimeoutMs as j, resolveCodexStartupTimeoutMs as k, readCodexAppServerClientDesktopGeneration as l, resolveCodexAppServerAuthProfileId as lt, resolveCodexNativeConfigFenceKey as m, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as mt, clearSharedCodexAppServerClientIfCurrent as n, withAbortableTimeout as nt, getLeasedSharedCodexAppServerClient as o, rememberCodexRateLimitsRead as ot, releaseLeasedSharedCodexAppServerClient as p, resolveCodexAppServerPreparedAuthHandoff as pt, claimCodexAppServerLiveThread as q, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as r, withTimeout$1 as rt, getSharedCodexAppServerClient as s, reconcileCodexComputerUseStartArtifacts as st, assertCodexAppServerClientStartSelectionCurrent as t, unsubscribeCodexAppServerLiveThread as tt, readCodexAppServerClientDesktopGenerationFingerprint as u, resolveCodexAppServerAuthProfileIdForAgent as ut, retireSharedCodexAppServerClientsBeforeDesktopGeneration as v, isJsonObject as vt, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as w, withLeasedCodexAppServerClientStartSelectionRetry as x, resolveCodexAppServerHomeDir as xt, shared_client_exports as y, resolveCodexManagedBundledMarketplacePath as yt, isCodexAppServerIndeterminateTransportError as z };
+export { assertCodexThreadResumeResponse as $, isJsonObject as $t, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS as A, retainCodexAppServerLiveThread as At, isCodexAppServerIndeterminateRequestCancellationError as B, resolveCodexAppServerAuthProfileIdForAgent as Bt, withLeasedCodexAppServerClientStartSelectionRetry as C, ensureCodexAppServerClientRuntime as Ct, acquireCodexNativeConfigFence as D, protectCodexAppServerLiveThread as Dt, CodexThreadStartRequestError as E, isCodexAppServerLiveThreadClaimed as Et, withCodexStartupTimeout as F, readRecentCodexRateLimits as Ft, isUnsupportedCodexAppServerVersionError as G, resolveCodexManagedBundledMarketplacePath as Gt, isCodexAppServerOverloadError as H, resolveCodexAppServerFallbackApiKeyCacheKey as Ht, getCodexAppServerClientInstanceId as I, rememberCodexRateLimitsRead as It, CodexThreadDirectInputError as J, readCodexSessionMeta as Jt, resolveCodexAppServerClientInstanceId as K, assertNotSymlink as Kt, isCodexAppServerApprovalRequest as L, reconcileCodexComputerUseStartArtifacts as Lt, isCodexAppServerStartupError as M, withAbortableTimeout as Mt, resolveCodexGatewayTimeoutWithGraceMs as N, withTimeout$1 as Nt, createCodexDesktopGenerationService as O, readCodexClientSessionMeta as Ot, resolveCodexStartupTimeoutMs as P, readCodexRateLimitsRevision as Pt, assertCodexThreadForkResponse as Q, flattenCodexDynamicToolFunctions as Qt, isCodexAppServerBrokenPipeError as R, resolveCodexAppServerAuthAccountCacheKey as Rt, waitForCodexAppServerClientDesktopGenerationDrain as S, consumeCodexAppServerLiveThread as St, CodexThreadBindingConflictError as T, isCodexAppServerClientRuntimeLive as Tt, isCodexAppServerPrewriteRequestCancellationError as U, resolveCodexAppServerPreparedApiKeyCacheKey as Ut, isCodexAppServerIndeterminateTransportError as V, resolveCodexAppServerAuthProfileStore as Vt, isCodexAppServerRequestTimeoutError as W, resolveCodexAppServerPreparedAuthHandoff as Wt, assertCodexThreadAcceptsDirectInput as X, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as Xt, assertCodexModelListResponse as Y, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as Yt, assertCodexThreadForkParams as Z, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as Zt, retainSharedCodexAppServerClientByInstanceId as _, resolveCodexToolAbortTerminalReason as _t, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as a, readCodexTurnCompletedNotification as at, retireSharedCodexAppServerClientsBeforeDesktopGeneration as b, withDynamicToolTranscriptDetails as bt, getLeasedSharedCodexAppServerClient as c, hasPendingDynamicToolTerminalDiagnostic as ct, readCodexAppServerClientDesktopGeneration as d, resolveDynamicToolCallTimeoutMs as dt, assertCodexThreadStartResponse as et, readCodexAppServerClientDesktopGenerationFingerprint as f, resolveTerminalDynamicToolBatchAction as ft, resolveCodexNativeConfigFenceKey as g, toCodexDynamicToolProtocolResponse as gt, releaseLeasedSharedCodexAppServerClient as h, toCodexDynamicToolProgressResponse as ht, clearSharedCodexAppServerClientIfCurrent as i, readCodexTurn as it, TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS as j, unsubscribeCodexAppServerLiveThread as jt, CodexAppServerStartupError as k, releaseCodexAppServerLiveThread as kt, getSharedCodexAppServerClient as l, isDynamicToolTerminalDiagnosticEvent as lt, releaseCodexAppServerClientLease as m, shouldReleaseTurnAfterTerminalDynamicTool as mt, captureCodexAppServerClientLifetime as n, readCodexDynamicToolCallParams as nt, clearSharedCodexAppServerClientIfCurrentAndWait as o, createCodexElicitationResponse as ot, readCodexAppServerClientProcessIdentity as p, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as pt, CodexAppServerRpcError as q, isOpenClawManagedCodexThread as qt, captureSharedCodexAppServerCatalogLifetime as r, readCodexErrorNotification as rt, createIsolatedCodexAppServerClient as s, handleDynamicToolCallWithTimeout as st, assertCodexAppServerClientStartSelectionCurrent as t, assertCodexTurnStartResponse as tt, isCodexAppServerStartSelectionChangedError as u, isMatchingDynamicToolTerminalDiagnostic as ut, retainSharedCodexAppServerClientIfCurrent as v, createFailedDynamicToolResponse as vt, CodexAdoptedThreadActiveError as w, hasCodexAppServerLiveThread as wt, shared_client_exports as x, claimCodexAppServerLiveThread as xt, retireSharedCodexAppServerClientIfCurrent as y, withDynamicToolExecutionState as yt, isCodexAppServerConnectionClosedError as z, resolveCodexAppServerAuthProfileId as zt };