@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/index.js

@@ -1,54 +1,52 @@
 import { registerCodexCliMetadata } from "./cli-metadata.js";
-import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./harness-Csz0F-DK.js";
-import { D as readCodexRequirementsToml, _ as CODEX_PLUGINS_MARKETPLACE_NAME, c as assertCodexAppServerConnectionSecurity, h as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions, j as resolveOpenClawExecPolicyForCodexAppServer, n as codexSandboxPolicyForTurn, s as resolveCodexSupervisionAppServerRuntimeOptions, t as codexAppServerStartOptionsKey, x as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-giW8X0QA.js";
-import { $ as releaseCodexAppServerLiveThread, C as createCodexDesktopGenerationService, H as isUnsupportedCodexAppServerVersionError, J as consumeCodexAppServerLiveThread, R as isCodexAppServerIndeterminateRequestCancellationError, X as isCodexAppServerClientRuntimeLive, Z as isCodexAppServerLiveThreadClaimed, ct as resolveCodexAppServerAuthAccountCacheKey, dt as resolveCodexAppServerFallbackApiKeyCacheKey, f as releaseCodexAppServerClientLease, h as retainSharedCodexAppServerClientByInstanceId, ht as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, i as clearSharedCodexAppServerClientIfCurrentAndWait, o as getLeasedSharedCodexAppServerClient, p as releaseLeasedSharedCodexAppServerClient, ut as resolveCodexAppServerAuthProfileIdForAgent, v as retireSharedCodexAppServerClientsBeforeDesktopGeneration, vt as isJsonObject, x as withLeasedCodexAppServerClientStartSelectionRetry } from "./shared-client-DKz23hHY.js";
-import { i as setManagedCodexPluginRoot } from "./managed-binary-DFYK4DWq.js";
+import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./harness-Czh2Sdoc.js";
+import { m as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-utils-C57JiJrU.js";
+import { l as sessionBindingIdentity, s as readCurrentCodexAppServerBinding } from "./session-binding-record-CyaXZvTe.js";
+import { A as resolveOpenClawExecPolicyForCodexAppServer, B as isJsonObject, L as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, O as readCodexPluginConfig, c as assertCodexAppServerConnectionSecurity, i as resolveCodexAppServerRuntimeOptions, m as canUseCodexModelBackedApprovalsReviewerForModel, n as codexSandboxPolicyForTurn, s as resolveCodexSupervisionAppServerRuntimeOptions, t as codexAppServerStartOptionsKey, y as readCodexRequirementsToml } from "./config-CyapYSji.js";
+import { B as isCodexAppServerIndeterminateRequestCancellationError, Bt as resolveCodexAppServerAuthAccountCacheKey, C as withLeasedCodexAppServerClientStartSelectionRetry, Dt as isCodexAppServerClientRuntimeLive, Et as hasCodexAppServerLiveThread, G as isUnsupportedCodexAppServerVersionError, H as isCodexAppServerOverloadError, Ht as resolveCodexAppServerAuthProfileIdForAgent, O as createCodexDesktopGenerationService, Ot as isCodexAppServerLiveThreadClaimed, Q as assertCodexThreadAcceptsDirectInput, Wt as resolveCodexAppServerFallbackApiKeyCacheKey, Y as CodexThreadDirectInputError, _ as retainSharedCodexAppServerClientByInstanceId, b as retireSharedCodexAppServerClientsBeforeDesktopGeneration, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, jt as releaseCodexAppServerLiveThread, m as releaseCodexAppServerClientLease, nt as assertCodexThreadStartResponse, o as clearSharedCodexAppServerClientIfCurrentAndWait, wt as consumeCodexAppServerLiveThread } from "./shared-client-CKhX2kFt.js";
+import { a as setManagedCodexPluginRoot } from "./managed-binary-DcpnJF9x.js";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
-import { d as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, o as isCodexAppServerNativeAuthProfile, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-Bcynfd-_.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, h as isCodexNotificationForTurn, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-bfsmcQ6m.js";
-import { s as isAssistantCommentaryCompletionNotification } from "./event-projector-usage-Bk1I90Bg.js";
-import { a as assertCodexThreadStartResponse } from "./protocol-validators-VeJxxJ0U.js";
-import { o as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-C1CAdfcP.js";
-import { B as resolveCodexAppServerRequestModelSelection, Et as pluginReadParams, G as CODEX_MANAGED_THREAD_MAX_ENTRIES, K as CODEX_MANAGED_THREAD_NAMESPACE, L as buildCodexProjectDocThreadConfig, R as CODEX_NATIVE_PERSONALITY_NONE, St as ensureCodexPluginActivation, bt as mergeCodexThreadConfigs, q as createCodexManagedThreadStore, vt as buildDisabledAppsConfigPatch, wt as isOpenAiCuratedMarketplace } from "./thread-lifecycle-L7oEkTlq.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
-import { t as resumeCodexAppServerThread } from "./thread-resume-BE9qNEW0.js";
-import { d as projectBoundedCodexVisibleSessionHistory } from "./transcript-mirror-DsCMWBca.js";
+import { a as isCodexAppServerNativeAuthProfile, n as assertCodexBindingMayBeReplaced, o as normalizeCodexAppServerBindingModelProvider } from "./session-binding-4Ki04sW-.js";
+import { o as createCodexAppServerProcessReaperService } from "./transport-stdio-CzTngV0j.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, h as isCodexNotificationForTurn, l as retireUnsafeCodexTurnClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, s as isCodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-Bp1ZOnk2.js";
+import { i as isAssistantCommentaryCompletionNotification } from "./event-projector-usage-ZqEVbAEY.js";
+import { c as defaultCodexAppInventoryCache, i as buildCodexPluginAppCacheKey, t as resumeCodexAppServerThread } from "./thread-resume-BLgqkUc1.js";
+import { E as resolveCodexAppServerRequestModelSelection, Et as mergeCodexThreadConfigs, J as createCodexManagedThreadStore, K as CODEX_MANAGED_THREAD_MAX_ENTRIES, Nt as pluginReadParams, Tt as buildDisabledAppsConfigPatch, jt as isOpenAiCuratedMarketplace, k as buildCodexProjectDocThreadConfig, kt as ensureCodexPluginActivation, q as CODEX_MANAGED_THREAD_NAMESPACE, w as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-lifecycle-DPK30jad.js";
+import { a as rollbackCodexAppServerBindingSubscription, c as withExclusiveCodexAppServerThread, i as retireCodexConversationThreadBinding, l as isIncognitoSessionKey, n as releaseCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, s as withCodexConversationThreadActivity, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-CbucAmmp.js";
+import { s as resolveCodexBindingAppServerConnection } from "./thread-policy-CTalhWFy.js";
+import { c as projectBoundedCodexVisibleSessionHistory } from "./transcript-mirror-_njEB84z.js";
+import { c as resolveCodexNativeSandboxBlock, i as requestCodexAppServerJson, o as withCodexAppServerJsonClient, s as resolveCodexNativeExecutionBlock } from "./request-C8H22rPi.js";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-BRMh0aIq.js";
-import { r as formatCodexDisplayText } from "./command-formatters-DEsIufkt.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, t as CODEX_SESSION_PERMISSION_EXEC_MODES } from "./session-permission-policy-BrNH1bjy.js";
-import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-kuWTn9C5.js";
-import { a as rollbackCodexAppServerBindingSubscription, i as retireCodexConversationThreadBinding, n as releaseCodexAppServerBindingSubscription, o as withCodexConversationThreadActivity, r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DZeuKH1j.js";
-import { f as trackCodexConversationActiveTurn, g as canMutateCodexHost, h as CODEX_NATIVE_EXECUTION_AUTH_ERROR, t as discoverCodexMarketplacePlugins } from "./plugin-marketplace-discovery-B9DvaAG-.js";
-import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-CW2GuupV.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-BMvPX73o.js";
-import { c as createCodexCliSessionNodeInvokePolicies, d as resolveCodexCliSessionForBindingOnNode, f as resumeCodexCliSessionOnNode, i as createCodexSessionCatalogNodeHostCommands, n as createCodexSessionCatalogNodeInvokePolicies, o as assertCodexArchiveDescendantsUnowned, r as createCodexSessionCatalogControl, s as createCodexCliSessionNodeHostCommands, t as codexSessionCatalogRuntime, u as listCodexCliSessionsOnNode } from "./session-catalog-DaLKVtpH.js";
-import { i as withCodexAppServerJsonClient, r as requestCodexAppServerJson } from "./request-DXXGHko0.js";
-import { t as codexControlRequest } from "./command-rpc-CCeCkf_v.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-B1mgvpP8.js";
+import { a as formatCodexDisplayText } from "./command-formatters-DSbGMXA0.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, t as CODEX_SESSION_PERMISSION_EXEC_MODES } from "./session-permission-policy-BaueHmSj.js";
+import { f as trackCodexConversationActiveTurn, g as canMutateCodexHost, h as CODEX_NATIVE_EXECUTION_AUTH_ERROR, t as discoverCodexMarketplacePlugins } from "./plugin-marketplace-discovery-B7gHXJ3d.js";
+import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-BiodpIzq.js";
+import { d as createCodexCliSessionNodeHostCommands, f as createCodexCliSessionNodeInvokePolicies, g as resumeCodexCliSessionOnNode, h as resolveCodexCliSessionForBindingOnNode, i as createCodexSessionCatalogNodeHostCommands, m as listCodexCliSessionsOnNode, n as createCodexSessionCatalogNodeInvokePolicies, o as assertCodexArchiveDescendantsUnowned, r as createCodexSessionCatalogControl, s as codexControlRequest, t as codexSessionCatalogRuntime } from "./session-catalog-B47uwekb.js";
 import { t as createCodexWebSearchProviderBase } from "./web-search-provider.shared-BrZmlqyR.js";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
 import { normalizePluginsConfig, resolveEffectiveEnableState, resolveLivePluginConfigObject, resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { asBoolean, asOptionalRecord, asSafeIntegerInRange, isRecord, normalizeOptionalString, normalizeSingleOrTrimmedStringList, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { getSessionEntry, resolveStorePath, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
+import { parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { embeddedAgentLog, formatErrorMessage, resolveActiveEmbeddedRunSessionId, resolveSandboxContext } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { canonicalPathFromExistingAncestor, isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 import os from "node:os";
-import { loadAuthProfileStoreWithoutExternalProfiles, resolveAgentConfig, resolveAgentWorkspaceDir, resolveDefaultAgentDir, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+import { loadAuthProfileStoreWithoutExternalProfiles, resolveAgentConfig as resolveAgentConfig$1, resolveAgentWorkspaceDir, resolveDefaultAgentDir, resolveDefaultAgentId as resolveDefaultAgentId$1 } from "openclaw/plugin-sdk/agent-runtime";
 import { applyAuthProfileConfig, buildApiKeyCredential, buildOauthProviderAuthResult, buildOpenAICodexCredentialExtra, readCodexCliCredentialsCached, resolveOpenAICodexAuthIdentity, resolveOpenAICodexImportProfileName, updateAuthProfileStoreWithLock } from "openclaw/plugin-sdk/provider-auth";
-import { resolveSessionAgentIds as resolveSessionAgentIds$2 } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { extractErrorCode, pathExists } from "openclaw/plugin-sdk/security-runtime";
-import { getSessionEntry, resolveStorePath, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
+import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { fileURLToPath } from "node:url";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { canonicalPathFromExistingAncestor, isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { readVisibleSessionTranscriptMessageEntries } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { getSessionBindingService } from "openclaw/plugin-sdk/conversation-binding-runtime";
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { ModelSelectionLockedError, isModelSelectionLocked } from "openclaw/plugin-sdk/model-session-runtime";
+import { fileURLToPath } from "node:url";
 import { MIGRATION_REASON_TARGET_EXISTS, applyMigrationManualItem, createMigrationItem, createMigrationManualItem, hasMigrationConfigPatchConflict, markMigrationItemConflict, markMigrationItemError, markMigrationItemSkipped, mergeMigrationConfigValue, readMigrationConfigPath, resolveMigrationConfigRuntime, summarizeMigrationItems, writeMigrationConfigPath } from "openclaw/plugin-sdk/migration";
 import { archiveMigrationItem, copyMemoryMigrationFileItem, copyMigrationFileItem, withCachedMigrationConfigRuntime, writeMigrationReport } from "openclaw/plugin-sdk/migration-runtime";
 import { sleep } from "openclaw/plugin-sdk/runtime-env";
@@ -181,20 +179,21 @@ function waitForReconnect(delayMs, signal) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/session-binding-store.ts
-/** Defers schema compilation and auth loading until the first binding operation. */
+/** Keeps lifecycle/auth loading behind mutations while sharing the canonical read codec. */
 function createLazyCodexAppServerBindingStore(state, managedThreadState) {
 	let resolved;
-	const store = () => resolved ??= import("./session-binding-Bcynfd-_.js").then((n) => n.f).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
+	const store = () => resolved ??= import("./session-binding-4Ki04sW-.js").then((n) => n.d).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
 	const managedThreads = managedThreadState ? createCodexManagedThreadStore(managedThreadState) : void 0;
 	return {
 		...managedThreads ? { managedThreads } : {},
-		read: async (identity) => (await store()).read(identity),
+		read: (identity) => readCurrentCodexAppServerBinding(state, identity),
 		hasOtherThreadOwner: async (threadId, currentIdentity) => (await store()).hasOtherThreadOwner(threadId, currentIdentity),
-		mutate: async (identity, mutation) => (await store()).mutate(identity, mutation),
+		mutate: async (identity, mutation, assertCurrent) => (await store()).mutate(identity, mutation, assertCurrent),
 		prepareSessionGenerationReclaim: async (identity) => (await store()).prepareSessionGenerationReclaim(identity),
-		adoptSessionGeneration: async (identity, previousSessionId) => (await store()).adoptSessionGeneration(identity, previousSessionId),
+		adoptSessionGeneration: async (identity, previousSessionId, assertCurrent) => (await store()).adoptSessionGeneration(identity, previousSessionId, assertCurrent),
 		resetSessionGeneration: async (identity) => (await store()).resetSessionGeneration(identity),
 		retireSessionGeneration: async (identity) => (await store()).retireSessionGeneration(identity),
+		withSessionDeletion: async (identity, assertCurrent, run) => (await store()).withSessionDeletion(identity, assertCurrent, run),
 		withThreadArchiveFence: async (run) => (await store()).withThreadArchiveFence(run),
 		withLease: async (identity, run) => (await store()).withLease(identity, run)
 	};
@@ -214,7 +213,7 @@ async function handleCodexCommand(ctx, options) {
 	}
 }
 async function loadDefaultCodexSubcommandHandler() {
-	const { handleCodexSubcommand } = await import("./command-handlers-D_-1_qRp.js");
+	const { handleCodexSubcommand } = await import("./command-handlers-DOJvGv6-.js");
 	return handleCodexSubcommand;
 }
 //#endregion
@@ -396,7 +395,7 @@ function isImageMedia(media) {
 	return IMAGE_EXTENSIONS.has(path.extname(candidate.split(/[?#]/, 1)[0] ?? "").toLowerCase());
 }
 function normalizeFileUrl(value) {
-	if (!value.startsWith("file://")) return value;
+	if (!/^file:\/\//iu.test(value)) return value;
 	try {
 		return fileURLToPath(value);
 	} catch {
@@ -405,18 +404,18 @@ function normalizeFileUrl(value) {
 }
 function readLocalMediaPath(value) {
 	if (!value) return;
-	if (value.startsWith("file://")) return value;
+	if (/^file:\/\//iu.test(value)) return value;
 	if (value.startsWith("//")) return;
 	if (path.isAbsolute(value) || path.win32.isAbsolute(value)) return value;
 	return /^[a-z][a-z0-9+.-]*:/i.test(value) ? void 0 : value;
 }
 //#endregion
 //#region extensions/codex/src/conversation-binding.ts
-const DEFAULT_BOUND_TURN_TIMEOUT_MS = 20 * 6e4;
+const DEFAULT_BOUND_TURN_TIMEOUT_MS = 12e5;
 const NATIVE_CONVERSATION_INTERACTIVE_APPROVALS_UNAVAILABLE = "OpenClaw native Codex conversation binding cannot route interactive approvals yet; use the Codex harness or explicit /acp spawn codex for that workflow.";
 async function resolveConversationAppServerRuntime(params) {
 	const source = params.source;
-	const agentId = source?.agentId ?? params.agentId ?? (params.config ? resolveSessionAgentIds$2({
+	const agentId = source?.agentId ?? params.agentId ?? (params.config ? resolveSessionAgentIdsStrict({
 		sessionKey: params.sessionKey,
 		config: params.config
 	}).sessionAgentId : void 0);
@@ -505,18 +504,16 @@ async function startCodexConversationThread(params) {
 		sessionKey: params.sessionKey,
 		config: params.config
 	});
-	const existingBinding = await params.bindingStore.read(identity);
+	const existingBinding = params.bindingStore.read(identity);
 	assertCodexBindingMayBeReplaced(existingBinding, "starting a conversation-bound Codex thread");
 	const authProfileId = resolveCodexAppServerAuthProfileIdForAgent({
 		authProfileId: params.authProfileId ?? existingBinding?.authProfileId,
 		...agentLookup
 	});
-	const incognito = isIncognitoSessionKey(params.sessionKey);
-	if (params.threadId?.trim()) await attachExistingThread({
+	const bindingParams = {
 		pluginConfig: params.pluginConfig,
 		bindingStore: params.bindingStore,
 		identity,
-		threadId: params.threadId.trim(),
 		workspaceDir,
 		...agentDir ? { agentDir } : {},
 		model: params.model,
@@ -525,25 +522,20 @@ async function startCodexConversationThread(params) {
 		serviceTier: params.serviceTier,
 		config: params.config,
 		sessionKey: params.sessionKey,
-		incognito,
+		incognito: isIncognitoSessionKey(params.sessionKey),
 		agentId: params.agentId
-	});
-	else await createThread({
-		pluginConfig: params.pluginConfig,
+	};
+	const threadId = params.threadId?.trim();
+	const bind = () => params.bindingStore.withLease(identity, () => bindThread(bindingParams, threadId));
+	const ownedThreadId = threadId ?? existingBinding?.threadId;
+	if (ownedThreadId) await withExclusiveCodexAppServerThread({
 		bindingStore: params.bindingStore,
 		identity,
-		workspaceDir,
-		...agentDir ? { agentDir } : {},
-		model: params.model,
-		modelProvider: params.modelProvider,
-		authProfileId,
-		serviceTier: params.serviceTier,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		incognito,
-		agentId: params.agentId
+		threadId: ownedThreadId,
+		run: bind
 	});
-	const storedBinding = await params.bindingStore.read(identity);
+	else await bind();
+	const storedBinding = params.bindingStore.read(identity);
 	if (!storedBinding) throw new Error("Codex session binding disappeared while starting its conversation thread.");
 	return createCodexConversationBindingData({
 		source: {
@@ -612,7 +604,7 @@ async function handleCodexConversationInboundClaim(event, ctx, options) {
 		const identity = conversationBindingIdentity(data);
 		const sessionKey = event.sessionKey ?? ctx.sessionKey;
 		const incognito = isIncognitoSessionKey(data.source?.sessionKey ?? (data.legacyBinding ? sessionKey : void 0));
-		const queuedOwner = options.bindingStore.read(identity);
+		const expected = options.bindingStore.read(identity);
 		return {
 			handled: true,
 			reply: (await withCodexConversationThreadActivity(data.bindingId, async () => {
@@ -622,8 +614,7 @@ async function handleCodexConversationInboundClaim(event, ctx, options) {
 					conversationId: publicBinding.conversationId,
 					...publicBinding.parentConversationId ? { parentConversationId: publicBinding.parentConversationId } : {}
 				});
-				const expected = await queuedOwner;
-				const current = await options.bindingStore.read(identity);
+				const current = options.bindingStore.read(identity);
 				if (currentPublicBinding?.bindingId !== publicBinding.bindingId || expected && (!current || current.threadId !== expected.threadId || current.conversationStartId !== expected.conversationStartId) || !expected && current && data.start?.id && current.conversationStartId !== data.start.id) return { reply: { text: "This Codex conversation was detached or changed before its message could run." } };
 				return await runBoundTurnWithMissingThreadRecovery({
 					bindingStore: options.bindingStore,
@@ -650,7 +641,7 @@ async function handleCodexConversationBindingResolved(event, options) {
 	const data = readCodexConversationBindingDataRecord(event.request.data ?? {});
 	if (!data || data.kind !== "codex-app-server-session") return;
 	const identity = conversationBindingIdentity(data);
-	const binding = await options.bindingStore.read(identity);
+	const binding = options.bindingStore.read(identity);
 	assertCodexBindingMayBeReplaced(binding, "clearing a denied conversation binding");
 	if (binding && (!data.start?.id || binding.conversationStartId === data.start.id)) await withCodexConversationThreadActivity(identity.bindingId, () => retireCodexConversationThreadBinding({
 		bindingStore: options.bindingStore,
@@ -707,21 +698,21 @@ async function resolveThreadBindingRuntime(params) {
 		authProfileId: params.authProfileId,
 		...agentLookup
 	};
-	const client = await getLeasedSharedCodexAppServerClient(clientOptions);
 	return {
 		runtime: modelScopedRuntime,
 		workspaceDir,
 		agentLookup,
 		model: modelSelection?.model,
 		modelProvider: modelSelection?.modelProvider ?? modelProvider,
-		client,
-		clientLease: { client },
 		clientOptions
 	};
 }
-function buildThreadRequestRuntimeOptions(params, resolved) {
-	const serviceTier = params.serviceTier ?? resolved.runtime.serviceTier;
+function buildConversationThreadRequest(resolved, serviceTier) {
 	return {
+		cwd: resolved.workspaceDir,
+		...resolved.model ? { model: resolved.model } : {},
+		...resolved.modelProvider ? { modelProvider: resolved.modelProvider } : {},
+		personality: CODEX_NATIVE_PERSONALITY_NONE,
 		approvalPolicy: resolved.runtime.approvalPolicy,
 		approvalsReviewer: resolved.runtime.approvalsReviewer,
 		...resolved.runtime.sessionRoot ? { runtimeWorkspaceRoots: [resolved.runtime.sessionRoot] } : {},
@@ -731,52 +722,39 @@ function buildThreadRequestRuntimeOptions(params, resolved) {
 }
 function codexConversationSandboxOrPermissions(runtime, sandbox) {
 	const networkProxy = runtime.networkProxy;
-	const disabledApps = mergeCodexThreadConfigs(buildDisabledAppsConfigPatch(), { "features.apps": false });
-	const config = buildCodexProjectDocThreadConfig(mergeCodexThreadConfigs(networkProxy?.configPatch, disabledApps));
+	const config = buildCodexProjectDocThreadConfig(mergeCodexThreadConfigs(networkProxy?.configPatch, buildDisabledAppsConfigPatch()));
 	return networkProxy ? { config } : {
 		sandbox,
 		config
 	};
 }
-async function requestNewConversationBindingThread(params, resolved) {
-	return await withLeasedCodexAppServerClientStartSelectionRetry({
-		lease: resolved.clientLease,
-		options: resolved.clientOptions,
-		run: async (client, requestOptions) => await client.request("thread/start", {
-			cwd: resolved.workspaceDir,
-			...resolved.model ? { model: resolved.model } : {},
-			...resolved.modelProvider ? { modelProvider: resolved.modelProvider } : {},
-			personality: CODEX_NATIVE_PERSONALITY_NONE,
-			...buildThreadRequestRuntimeOptions(params, resolved),
-			developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
-			experimentalRawEvents: true,
-			...params.incognito ? { ephemeral: true } : {}
-		}, requestOptions),
-		onClientChange: (client) => {
-			resolved.client = client;
-		}
-	});
-}
-async function writeThreadBindingFromResponse(params, resolved, response) {
-	const current = await params.bindingStore.read(params.identity);
-	assertCodexBindingMayBeReplaced(current, "storing a conversation-bound Codex thread");
-	const trackSubscription = !params.incognito && isCodexAppServerClientRuntimeLive(resolved.client);
-	const sameOwner = isSameCodexAppServerThreadOwner(current, {
-		threadId: response.thread.id,
-		clientId: resolved.client.getInstanceId()
-	});
+async function writeThreadBindingFromResponse(params, resolved, client, response, requestOptions) {
 	let retained = false;
+	let sameOwner = false;
 	try {
+		const current = params.bindingStore.read(params.identity);
+		assertCodexBindingMayBeReplaced(current, "storing a conversation-bound Codex thread");
+		const trackSubscription = !params.incognito && isCodexAppServerClientRuntimeLive(client);
+		sameOwner = isSameCodexAppServerThreadOwner(current, {
+			threadId: response.thread.id,
+			clientId: client.getInstanceId()
+		});
+		requestOptions();
+		assertCodexThreadAcceptsDirectInput(response.thread);
 		if (trackSubscription) {
-			retained = await retainCodexAppServerBindingSubscription(resolved.client, response.thread.id);
+			retained = await retainCodexAppServerBindingSubscription(client, response.thread.id);
 			if (!retained) throw new Error("Codex conversation thread lost its native subscription owner.");
 		}
-		if (current && !sameOwner) await releaseCodexAppServerBindingSubscription(current);
+		if (current && !sameOwner) {
+			const { assertCurrent } = requestOptions();
+			await releaseCodexAppServerBindingSubscription(current, { assertCurrent });
+		}
+		requestOptions();
 		if (!await params.bindingStore.mutate(params.identity, {
 			kind: "set",
 			binding: {
 				threadId: response.thread.id,
-				clientId: resolved.client.getInstanceId(),
+				clientId: client.getInstanceId(),
 				cwd: resolved.workspaceDir,
 				authProfileId: params.authProfileId,
 				model: response.model ?? resolved.model ?? params.model,
@@ -789,56 +767,54 @@ async function writeThreadBindingFromResponse(params, resolved, response) {
 				networkProxyProfileName: resolved.runtime.networkProxy?.profileName,
 				networkProxyConfigFingerprint: resolved.runtime.networkProxy?.configFingerprint
 			}
-		})) throw new Error("Codex conversation binding changed while storing its thread.");
+		}, requestOptions)) throw new Error("Codex conversation binding changed while storing its thread.");
 	} catch (error) {
-		if (trackSubscription && !sameOwner) await rollbackCodexAppServerBindingSubscription(resolved.client, response.thread.id, retained);
+		if (retained && !sameOwner || !hasCodexAppServerLiveThread(client, response.thread.id)) await rollbackCodexAppServerBindingSubscription(client, response.thread.id, retained);
 		throw error;
 	}
 }
-async function attachExistingThread(params) {
-	await withExclusiveCodexAppServerThread({
-		bindingStore: params.bindingStore,
-		identity: params.identity,
-		threadId: params.threadId,
-		run: async () => {
-			assertCodexBindingMayBeReplaced(await params.bindingStore.read(params.identity), "attaching a conversation-bound Codex thread");
-			const resolved = await resolveThreadBindingRuntime(params);
-			try {
-				const response = resolved.runtime.networkProxy ? await requestNewConversationBindingThread(params, resolved) : await withLeasedCodexAppServerClientStartSelectionRetry({
-					lease: resolved.clientLease,
-					options: resolved.clientOptions,
-					run: async (client, requestOptions) => {
-						if (isCodexAppServerLiveThreadClaimed(client, params.threadId)) throw new Error(`Codex thread ${params.threadId} has an active run; stop it before binding its conversation.`);
-						await releaseCodexAppServerLiveThread(client, params.threadId);
-						if (isCodexAppServerLiveThreadClaimed(client, params.threadId)) throw new Error(`Codex thread ${params.threadId} has an active run; stop it before binding its conversation.`);
-						return await client.request(CODEX_CONTROL_METHODS.resumeThread, {
-							threadId: params.threadId,
-							cwd: resolved.workspaceDir,
-							...resolved.model ? { model: resolved.model } : {},
-							...resolved.modelProvider ? { modelProvider: resolved.modelProvider } : {},
-							personality: CODEX_NATIVE_PERSONALITY_NONE,
-							...buildThreadRequestRuntimeOptions(params, resolved)
-						}, requestOptions);
-					},
-					onClientChange: (client) => {
-						resolved.client = client;
-					}
-				});
-				if (!resolved.runtime.networkProxy && response.thread.id !== params.threadId) throw new Error(`Codex conversation resume returned ${response.thread.id} for ${params.threadId}.`);
-				await writeThreadBindingFromResponse(params, resolved, response);
-			} finally {
-				releaseCodexAppServerClientLease(resolved.clientLease);
-			}
-		}
-	});
-}
-async function createThread(params) {
-	assertCodexBindingMayBeReplaced(await params.bindingStore.read(params.identity), "creating a conversation-bound Codex thread");
+async function bindThread(params, threadId) {
+	const current = params.bindingStore.read(params.identity);
+	assertCodexBindingMayBeReplaced(current, "binding a conversation-bound Codex thread");
 	const resolved = await resolveThreadBindingRuntime(params);
+	const clientLease = { client: await getLeasedSharedCodexAppServerClient(resolved.clientOptions) };
 	try {
-		await writeThreadBindingFromResponse(params, resolved, await requestNewConversationBindingThread(params, resolved));
+		await withLeasedCodexAppServerClientStartSelectionRetry({
+			lease: clientLease,
+			options: resolved.clientOptions,
+			run: async (client, requestOptions) => {
+				const request = buildConversationThreadRequest(resolved, params.serviceTier ?? resolved.runtime.serviceTier);
+				let response;
+				if (threadId && !resolved.runtime.networkProxy) {
+					if (isCodexAppServerLiveThreadClaimed(client, threadId)) throw new Error(`Codex thread ${threadId} has an active run; stop it before binding its conversation.`);
+					const { thread } = await client.request("thread/read", {
+						threadId,
+						includeTurns: false
+					}, requestOptions());
+					assertCodexThreadAcceptsDirectInput(thread);
+					const { assertCurrent } = requestOptions();
+					await releaseCodexAppServerLiveThread(client, threadId, assertCurrent);
+					if (isCodexAppServerLiveThreadClaimed(client, threadId)) throw new Error(`Codex thread ${threadId} has an active run; stop it before binding its conversation.`);
+					response = await resumeCodexAppServerThread({
+						client,
+						abandonClient: () => closeCodexStartupClientBestEffort(client),
+						request: {
+							...request,
+							threadId
+						},
+						requestResume: (resumeRequest) => client.request("thread/resume", resumeRequest, requestOptions())
+					});
+				} else response = await client.request("thread/start", {
+					...request,
+					developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
+					experimentalRawEvents: true,
+					...params.incognito ? { ephemeral: true } : {}
+				}, requestOptions());
+				await writeThreadBindingFromResponse(params, resolved, client, response, requestOptions);
+			}
+		});
 	} finally {
-		releaseCodexAppServerClientLease(resolved.clientLease);
+		releaseCodexAppServerClientLease(clientLease);
 	}
 }
 async function runBoundTurn(params) {
@@ -847,266 +823,288 @@ async function runBoundTurn(params) {
 		config: params.config
 	});
 	const identity = conversationBindingIdentity(params.data);
-	const binding = await params.bindingStore.read(identity);
+	const binding = params.bindingStore.read(identity);
 	if (!binding?.threadId) throw new Error("bound Codex conversation has no thread binding");
-	assertCodexBindingMayBeReplaced(binding, "running a conversation-bound Codex thread");
-	let threadId = binding.threadId;
-	const requestedWorkspaceDir = binding.cwd || params.data.workspaceDir;
-	const reviewerModelProvider = resolveModelBackedReviewerPolicyProvider({
-		authProfileId: binding.authProfileId,
-		modelProvider: binding.modelProvider,
-		...agentLookup
-	});
-	const { runtime, workspaceDir } = await resolveConversationAppServerRuntime({
-		pluginConfig: params.pluginConfig,
-		config: params.config,
-		agentId: params.data.source?.agentId ?? params.data.agentId,
-		sessionKey: params.data.legacyBinding ? params.sessionKey : params.data.source?.sessionKey,
-		source: params.data.source,
-		workspaceDir: requestedWorkspaceDir,
-		modelProvider: reviewerModelProvider,
-		model: binding.model,
-		agentDir: params.data.agentDir
-	});
-	const modelScopedRuntime = resolveCodexAppServerForModelProvider({
-		appServer: runtime,
-		provider: reviewerModelProvider,
-		model: binding.model,
-		config: params.config,
-		env: process.env,
-		agentDir: params.data.agentDir
-	});
-	const sessionRoot = modelScopedRuntime.sessionRoot;
-	const approvalPolicy = modelScopedRuntime.approvalPolicy;
-	const sandbox = modelScopedRuntime.sandbox;
-	const permissionProfile = modelScopedRuntime.networkProxy?.profileName;
-	const networkProxyConfigFingerprint = modelScopedRuntime.networkProxy?.configFingerprint;
-	const networkProxyBindingChanged = binding.networkProxyProfileName !== permissionProfile || binding.networkProxyConfigFingerprint !== networkProxyConfigFingerprint;
-	const serviceTier = binding.serviceTier ?? runtime.serviceTier;
-	let useStickyNetworkProfile = permissionProfile !== void 0 && binding.networkProxyProfileName === permissionProfile && binding.networkProxyConfigFingerprint === networkProxyConfigFingerprint;
-	assertNativeConversationApprovalPolicySupported(modelScopedRuntime);
-	const modelSelection = binding.model ? resolveCodexAppServerRequestModelSelection({
-		model: binding.model,
-		modelProvider: binding.modelProvider,
-		authProfileId: binding.authProfileId,
-		...agentLookup
-	}) : void 0;
-	const clientOptions = {
-		startOptions: runtime.start,
-		timeoutMs: runtime.requestTimeoutMs,
-		authProfileId: binding.authProfileId,
-		...agentLookup
-	};
-	let client = await getLeasedSharedCodexAppServerClient(clientOptions);
-	const clientLease = { client };
-	let activeTurnId;
-	let activeTurnCleanup = () => void 0;
-	let retiredUnsafeClient;
-	let turnRoute;
-	let liveThreadOwnership;
-	let ownsNativeSubscription = false;
-	let turnSucceeded = false;
-	try {
-		if (!params.incognito && isCodexAppServerClientRuntimeLive(client)) {
-			const ownership = await consumeCodexAppServerLiveThread(client, threadId);
-			if (ownership) {
-				liveThreadOwnership = {
-					client,
+	return await withExclusiveCodexAppServerThread({
+		bindingStore: params.bindingStore,
+		identity,
+		threadId: binding.threadId,
+		run: async () => {
+			const current = params.bindingStore.read(identity);
+			if (!isSameCodexAppServerThreadOwner(current, binding)) throw new Error("Codex conversation binding changed before its turn.");
+			assertCodexBindingMayBeReplaced(binding, "running a conversation-bound Codex thread");
+			let threadId = binding.threadId;
+			const requestedWorkspaceDir = binding.cwd || params.data.workspaceDir;
+			const reviewerModelProvider = resolveModelBackedReviewerPolicyProvider({
+				authProfileId: binding.authProfileId,
+				modelProvider: binding.modelProvider,
+				...agentLookup
+			});
+			const { runtime, workspaceDir } = await resolveConversationAppServerRuntime({
+				pluginConfig: params.pluginConfig,
+				config: params.config,
+				agentId: params.data.source?.agentId ?? params.data.agentId,
+				sessionKey: params.data.legacyBinding ? params.sessionKey : params.data.source?.sessionKey,
+				source: params.data.source,
+				workspaceDir: requestedWorkspaceDir,
+				modelProvider: reviewerModelProvider,
+				model: binding.model,
+				agentDir: params.data.agentDir
+			});
+			const modelScopedRuntime = resolveCodexAppServerForModelProvider({
+				appServer: runtime,
+				provider: reviewerModelProvider,
+				model: binding.model,
+				config: params.config,
+				env: process.env,
+				agentDir: params.data.agentDir
+			});
+			const sessionRoot = modelScopedRuntime.sessionRoot;
+			const approvalPolicy = modelScopedRuntime.approvalPolicy;
+			const sandbox = modelScopedRuntime.sandbox;
+			const permissionProfile = modelScopedRuntime.networkProxy?.profileName;
+			const networkProxyConfigFingerprint = modelScopedRuntime.networkProxy?.configFingerprint;
+			const networkProxyBindingChanged = binding.networkProxyProfileName !== permissionProfile || binding.networkProxyConfigFingerprint !== networkProxyConfigFingerprint;
+			const serviceTier = binding.serviceTier ?? runtime.serviceTier;
+			let useStickyNetworkProfile = permissionProfile !== void 0 && binding.networkProxyProfileName === permissionProfile && binding.networkProxyConfigFingerprint === networkProxyConfigFingerprint;
+			assertNativeConversationApprovalPolicySupported(modelScopedRuntime);
+			const modelSelection = binding.model ? resolveCodexAppServerRequestModelSelection({
+				model: binding.model,
+				modelProvider: binding.modelProvider,
+				authProfileId: binding.authProfileId,
+				...agentLookup
+			}) : void 0;
+			const threadRequestRuntime = {
+				runtime: modelScopedRuntime,
+				workspaceDir,
+				...modelSelection
+			};
+			const clientOptions = {
+				startOptions: runtime.start,
+				timeoutMs: runtime.requestTimeoutMs,
+				authProfileId: binding.authProfileId,
+				...agentLookup
+			};
+			let client = await getLeasedSharedCodexAppServerClient(clientOptions);
+			const clientLease = { client };
+			let activeTurnId;
+			let activeTurnCleanup = () => void 0;
+			let isolatedSubscriptionClient;
+			let turnRoute;
+			let liveThreadOwnership;
+			let ownsNativeSubscription = false;
+			let turnSucceeded = false;
+			const assertResumeInputAllowed = async () => {
+				const { thread } = await client.request("thread/read", {
 					threadId,
-					ownership
-				};
-				ownsNativeSubscription = true;
-			}
-		}
-		if (networkProxyBindingChanged) {
-			const response = assertCodexThreadStartResponse(await withLeasedCodexAppServerClientStartSelectionRetry({
-				lease: clientLease,
-				options: clientOptions,
-				run: async (requestClient, requestOptions) => await requestClient.request("thread/start", {
+					includeTurns: false
+				}, { timeoutMs: runtime.requestTimeoutMs });
+				assertCodexThreadAcceptsDirectInput(thread);
+			};
+			try {
+				if (!networkProxyBindingChanged && binding.clientId !== client.getInstanceId()) await assertResumeInputAllowed();
+				if (!params.incognito && isCodexAppServerClientRuntimeLive(client)) {
+					const ownership = await consumeCodexAppServerLiveThread(client, threadId);
+					if (ownership) {
+						liveThreadOwnership = {
+							client,
+							threadId,
+							ownership
+						};
+						ownsNativeSubscription = true;
+					}
+				}
+				if (networkProxyBindingChanged) {
+					const response = assertCodexThreadStartResponse(await withLeasedCodexAppServerClientStartSelectionRetry({
+						lease: clientLease,
+						options: clientOptions,
+						run: async (requestClient, requestOptions) => await requestClient.request("thread/start", {
+							...buildConversationThreadRequest(threadRequestRuntime, serviceTier),
+							developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
+							experimentalRawEvents: true,
+							...params.incognito ? { ephemeral: true } : {}
+						}, requestOptions()),
+						onClientChange: (nextClient) => {
+							client = nextClient;
+						}
+					}));
+					threadId = response.thread.id;
+					ownsNativeSubscription = true;
+					assertCodexThreadAcceptsDirectInput(response.thread);
+					if (liveThreadOwnership && (liveThreadOwnership.threadId !== threadId || liveThreadOwnership.client !== client)) {
+						const previousOwnership = liveThreadOwnership;
+						try {
+							await previousOwnership.ownership.release(previousOwnership.threadId);
+						} catch (error) {
+							if (!(isCodexAppServerClientRuntimeLive(previousOwnership.client) && await retainCodexAppServerBindingSubscription(previousOwnership.client, previousOwnership.threadId, previousOwnership.ownership).catch(() => false))) await closeCodexStartupClientBestEffort(previousOwnership.client);
+							liveThreadOwnership = void 0;
+							throw error;
+						}
+						liveThreadOwnership = void 0;
+					} else if (binding.threadId !== threadId) await releaseCodexAppServerBindingSubscription(binding);
+					if (!await params.bindingStore.mutate(identity, {
+						kind: "set",
+						binding: {
+							threadId,
+							clientId: client.getInstanceId(),
+							cwd: response.thread.cwd ?? workspaceDir,
+							authProfileId: binding.authProfileId,
+							model: response.model ?? modelSelection?.model ?? binding.model,
+							modelProvider: normalizeCodexAppServerBindingModelProvider({
+								authProfileId: binding.authProfileId,
+								modelProvider: response.modelProvider ?? modelSelection?.modelProvider ?? binding.modelProvider,
+								...agentLookup
+							}),
+							serviceTier: serviceTier ?? void 0,
+							networkProxyProfileName: modelScopedRuntime.networkProxy?.profileName,
+							networkProxyConfigFingerprint: modelScopedRuntime.networkProxy?.configFingerprint,
+							conversationStartId: binding.conversationStartId,
+							conversationSourceTransferComplete: binding.conversationSourceTransferComplete,
+							historyCoveredThrough: binding.historyCoveredThrough
+						}
+					})) throw new Error("Codex conversation binding changed while rotating its thread.");
+					useStickyNetworkProfile = modelScopedRuntime.networkProxy !== void 0;
+				} else if (binding.clientId !== client.getInstanceId() || isCodexAppServerClientRuntimeLive(client) && !params.incognito && !liveThreadOwnership) {
+					if (binding.clientId === client.getInstanceId()) await assertResumeInputAllowed();
+					const response = await withLeasedCodexAppServerClientStartSelectionRetry({
+						lease: clientLease,
+						options: clientOptions,
+						run: async (requestClient, requestOptions) => await resumeCodexAppServerThread({
+							client: requestClient,
+							onSubscriptionReleased: () => {
+								isolatedSubscriptionClient = requestClient;
+							},
+							abandonClient: async () => {
+								await closeCodexStartupClientBestEffort(requestClient);
+								isolatedSubscriptionClient = requestClient;
+							},
+							request: {
+								threadId,
+								...buildConversationThreadRequest(threadRequestRuntime, serviceTier)
+							},
+							requestResume: (request) => requestClient.request("thread/resume", request, requestOptions())
+						}),
+						onClientChange: (nextClient) => {
+							client = nextClient;
+						}
+					});
+					threadId = response.thread.id;
+					ownsNativeSubscription = true;
+					assertCodexThreadAcceptsDirectInput(response.thread);
+					if (!isSameCodexAppServerThreadOwner(binding, {
+						threadId,
+						clientId: client.getInstanceId()
+					})) await releaseCodexAppServerBindingSubscription(binding);
+					if (!await params.bindingStore.mutate(identity, {
+						kind: "patch",
+						threadId: binding.threadId,
+						patch: {
+							clientId: client.getInstanceId(),
+							cwd: response.thread.cwd ?? binding.cwd,
+							model: response.model ?? modelSelection?.model ?? binding.model,
+							modelProvider: normalizeCodexAppServerBindingModelProvider({
+								authProfileId: binding.authProfileId,
+								modelProvider: response.modelProvider ?? modelSelection?.modelProvider ?? binding.modelProvider,
+								...agentLookup
+							})
+						}
+					})) throw new Error("Codex conversation binding changed while resuming on a new client.");
+				}
+				const turnCollector = createCodexConversationTurnCollector(threadId);
+				turnRoute = getCodexAppServerTurnRouter(client).reserveThread({
+					threadId,
+					onNotification: turnCollector.handleNotification
+				});
+				turnRoute.armTurn();
+				activeTurnId = (await client.request("turn/start", {
+					threadId,
+					input: buildCodexConversationTurnInput({
+						prompt: params.prompt,
+						event: params.event
+					}),
 					cwd: workspaceDir,
 					...sessionRoot ? { runtimeWorkspaceRoots: [sessionRoot] } : {},
-					...modelSelection?.model ? { model: modelSelection.model } : {},
-					...modelSelection?.modelProvider ? { modelProvider: modelSelection.modelProvider } : {},
-					personality: CODEX_NATIVE_PERSONALITY_NONE,
 					approvalPolicy,
 					approvalsReviewer: modelScopedRuntime.approvalsReviewer,
-					...codexConversationSandboxOrPermissions(modelScopedRuntime, sandbox),
-					...serviceTier ? { serviceTier } : {},
-					developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
-					experimentalRawEvents: true,
-					...params.incognito ? { ephemeral: true } : {}
-				}, requestOptions),
-				onClientChange: (nextClient) => {
-					client = nextClient;
-				}
-			}));
-			threadId = response.thread.id;
-			ownsNativeSubscription = true;
-			if (liveThreadOwnership && (liveThreadOwnership.threadId !== threadId || liveThreadOwnership.client !== client)) {
-				const previousOwnership = liveThreadOwnership;
-				try {
-					await previousOwnership.ownership.release(previousOwnership.threadId);
-				} catch (error) {
-					if (!(isCodexAppServerClientRuntimeLive(previousOwnership.client) && await retainCodexAppServerBindingSubscription(previousOwnership.client, previousOwnership.threadId, previousOwnership.ownership).catch(() => false))) await closeCodexStartupClientBestEffort(previousOwnership.client);
-					liveThreadOwnership = void 0;
-					throw error;
-				}
-				liveThreadOwnership = void 0;
-			} else if (binding.threadId !== threadId) await releaseCodexAppServerBindingSubscription(binding);
-			if (!await params.bindingStore.mutate(identity, {
-				kind: "set",
-				binding: {
+					...useStickyNetworkProfile ? {} : { sandboxPolicy: codexSandboxPolicyForTurn(sandbox, sessionRoot ?? workspaceDir) },
+					...modelSelection?.model ? { model: modelSelection.model } : {},
+					personality: CODEX_NATIVE_PERSONALITY_NONE,
+					...serviceTier ? { serviceTier } : {}
+				}, { timeoutMs: runtime.requestTimeoutMs })).turn.id;
+				activeTurnCleanup = trackCodexConversationActiveTurn({
+					identity,
+					client,
 					threadId,
-					clientId: client.getInstanceId(),
-					cwd: response.thread.cwd ?? workspaceDir,
-					authProfileId: binding.authProfileId,
-					model: response.model ?? modelSelection?.model ?? binding.model,
-					modelProvider: normalizeCodexAppServerBindingModelProvider({
-						authProfileId: binding.authProfileId,
-						modelProvider: response.modelProvider ?? modelSelection?.modelProvider ?? binding.modelProvider,
-						...agentLookup
-					}),
-					serviceTier: serviceTier ?? void 0,
-					networkProxyProfileName: modelScopedRuntime.networkProxy?.profileName,
-					networkProxyConfigFingerprint: modelScopedRuntime.networkProxy?.configFingerprint,
-					conversationStartId: binding.conversationStartId,
-					conversationSourceTransferComplete: binding.conversationSourceTransferComplete,
-					historyCoveredThrough: binding.historyCoveredThrough
+					turnId: activeTurnId
+				});
+				turnCollector.setTurnId(activeTurnId);
+				await turnRoute.bindTurn(activeTurnId);
+				const replyText = (await turnCollector.wait({ timeoutMs: params.timeoutMs ?? DEFAULT_BOUND_TURN_TIMEOUT_MS })).replyText.trim();
+				turnSucceeded = true;
+				return { reply: { text: replyText || "Codex completed without a text reply." } };
+			} catch (error) {
+				if (isCodexAppServerOverloadError(error) && error.method === "thread/resume") throw error;
+				if (error instanceof CodexThreadDirectInputError) {
+					if (params.incognito && ownsNativeSubscription) {
+						if (!await unsubscribeCodexThreadBestEffort(client, {
+							threadId,
+							timeoutMs: 5e3
+						})) await retireUnsafeCodexTurnClientBestEffort(client, "parent-owned thread unsubscribe");
+					}
+					throw error;
 				}
-			})) throw new Error("Codex conversation binding changed while rotating its thread.");
-			useStickyNetworkProfile = modelScopedRuntime.networkProxy !== void 0;
-		} else if (binding.clientId !== client.getInstanceId() || isCodexAppServerClientRuntimeLive(client) && !params.incognito && !liveThreadOwnership) {
-			const response = await withLeasedCodexAppServerClientStartSelectionRetry({
-				lease: clientLease,
-				options: clientOptions,
-				run: async (requestClient, requestOptions) => await resumeCodexAppServerThread({
-					client: requestClient,
-					abandonClient: async () => {
-						retiredUnsafeClient = requestClient;
-						await closeCodexStartupClientBestEffort(requestClient);
-					},
-					request: {
+				if (error instanceof CodexConversationTurnTimeoutError && activeTurnId || turnRoute && isCodexAppServerIndeterminateRequestCancellationError(error)) {
+					if (!await interruptCodexTurnAndWaitBestEffort(client, {
 						threadId,
-						cwd: workspaceDir,
-						...sessionRoot ? { runtimeWorkspaceRoots: [sessionRoot] } : {},
-						...modelSelection?.model ? { model: modelSelection.model } : {},
-						...modelSelection?.modelProvider ? { modelProvider: modelSelection.modelProvider } : {},
-						personality: CODEX_NATIVE_PERSONALITY_NONE,
-						approvalPolicy,
-						approvalsReviewer: modelScopedRuntime.approvalsReviewer,
-						...codexConversationSandboxOrPermissions(modelScopedRuntime, sandbox),
-						...serviceTier ? { serviceTier } : {}
-					},
-					...requestOptions
-				}),
-				onClientChange: (nextClient) => {
-					client = nextClient;
+						turnId: activeTurnId ?? ""
+					})) {
+						await retireUnsafeCodexTurnClientBestEffort(client, "turn interrupt");
+						isolatedSubscriptionClient = client;
+					}
 				}
-			});
-			threadId = response.thread.id;
-			ownsNativeSubscription = true;
-			if (!isSameCodexAppServerThreadOwner(binding, {
-				threadId,
-				clientId: client.getInstanceId()
-			})) await releaseCodexAppServerBindingSubscription(binding);
-			if (!await params.bindingStore.mutate(identity, {
-				kind: "patch",
-				threadId: binding.threadId,
-				patch: {
-					clientId: client.getInstanceId(),
-					cwd: response.thread.cwd ?? binding.cwd,
-					model: response.model ?? modelSelection?.model ?? binding.model,
-					modelProvider: normalizeCodexAppServerBindingModelProvider({
-						authProfileId: binding.authProfileId,
-						modelProvider: response.modelProvider ?? modelSelection?.modelProvider ?? binding.modelProvider,
-						...agentLookup
-					})
+				if (params.incognito) {
+					if (await params.bindingStore.mutate(identity, {
+						kind: "clear",
+						threadId
+					}) && isolatedSubscriptionClient !== client) {
+						if (!await unsubscribeCodexThreadBestEffort(client, {
+							threadId,
+							timeoutMs: 5e3
+						})) await retireUnsafeCodexTurnClientBestEffort(client, "thread unsubscribe");
+					}
 				}
-			})) throw new Error("Codex conversation binding changed while resuming on a new client.");
-		}
-		const turnCollector = createCodexConversationTurnCollector(threadId);
-		turnRoute = getCodexAppServerTurnRouter(client).reserveThread({
-			threadId,
-			onNotification: turnCollector.handleNotification
-		});
-		turnRoute.armTurn();
-		activeTurnId = (await client.request("turn/start", {
-			threadId,
-			input: buildCodexConversationTurnInput({
-				prompt: params.prompt,
-				event: params.event
-			}),
-			cwd: workspaceDir,
-			...sessionRoot ? { runtimeWorkspaceRoots: [sessionRoot] } : {},
-			approvalPolicy,
-			approvalsReviewer: modelScopedRuntime.approvalsReviewer,
-			...useStickyNetworkProfile ? {} : { sandboxPolicy: codexSandboxPolicyForTurn(sandbox, sessionRoot ?? workspaceDir) },
-			...modelSelection?.model ? { model: modelSelection.model } : {},
-			personality: CODEX_NATIVE_PERSONALITY_NONE,
-			...serviceTier ? { serviceTier } : {}
-		}, { timeoutMs: runtime.requestTimeoutMs })).turn.id;
-		activeTurnCleanup = trackCodexConversationActiveTurn({
-			identity,
-			client,
-			threadId,
-			turnId: activeTurnId
-		});
-		turnCollector.setTurnId(activeTurnId);
-		await turnRoute.bindTurn(activeTurnId);
-		const replyText = (await turnCollector.wait({ timeoutMs: params.timeoutMs ?? DEFAULT_BOUND_TURN_TIMEOUT_MS })).replyText.trim();
-		turnSucceeded = true;
-		return { reply: { text: replyText || "Codex completed without a text reply." } };
-	} catch (error) {
-		if (error instanceof CodexConversationTurnTimeoutError && activeTurnId || turnRoute && isCodexAppServerIndeterminateRequestCancellationError(error)) {
-			if (!await interruptCodexTurnAndWaitBestEffort(client, {
-				threadId,
-				turnId: activeTurnId ?? ""
-			})) {
-				retiredUnsafeClient = client;
-				await retireUnsafeCodexTurnClientBestEffort(client, "turn interrupt");
-			}
-		}
-		if (params.incognito) {
-			if (await params.bindingStore.mutate(identity, {
-				kind: "clear",
-				threadId
-			}) && retiredUnsafeClient !== client) {
-				if (!await unsubscribeCodexThreadBestEffort(client, {
-					threadId,
-					timeoutMs: 5e3
-				})) await retireUnsafeCodexTurnClientBestEffort(client, "thread unsubscribe");
-			}
-		}
-		throw error;
-	} finally {
-		activeTurnCleanup();
-		turnRoute?.release();
-		try {
-			if (ownsNativeSubscription && retiredUnsafeClient !== client && !params.incognito && isCodexAppServerClientRuntimeLive(client)) {
-				const currentLiveThreadOwnership = liveThreadOwnership?.client === client && liveThreadOwnership.threadId === threadId ? liveThreadOwnership.ownership : void 0;
-				let retained = false;
-				if (turnSucceeded) retained = await params.bindingStore.withLease(identity, async () => {
-					const current = await params.bindingStore.read(identity);
-					if (current?.threadId !== threadId || current.clientId !== client.getInstanceId()) return false;
-					return await retainCodexAppServerBindingSubscription(client, threadId, currentLiveThreadOwnership);
-				});
-				if (!retained) {
-					if (!(currentLiveThreadOwnership ? await currentLiveThreadOwnership.release(threadId).then(() => true) : await unsubscribeCodexThreadBestEffort(client, {
+				throw error;
+			} finally {
+				activeTurnCleanup();
+				turnRoute?.release();
+				try {
+					if (ownsNativeSubscription && isolatedSubscriptionClient !== client && !params.incognito && isCodexAppServerClientRuntimeLive(client)) {
+						const currentLiveThreadOwnership = liveThreadOwnership?.client === client && liveThreadOwnership.threadId === threadId ? liveThreadOwnership.ownership : void 0;
+						let retained = false;
+						if (turnSucceeded) retained = await params.bindingStore.withLease(identity, async () => {
+							const latest = params.bindingStore.read(identity);
+							if (latest?.threadId !== threadId || latest.clientId !== client.getInstanceId()) return false;
+							return await retainCodexAppServerBindingSubscription(client, threadId, currentLiveThreadOwnership);
+						});
+						if (!retained) {
+							if (!(currentLiveThreadOwnership ? await currentLiveThreadOwnership.release(threadId).then(() => true) : await unsubscribeCodexThreadBestEffort(client, {
+								threadId,
+								timeoutMs: 5e3
+							}))) await closeCodexStartupClientBestEffort(client);
+						}
+					}
+				} catch (error) {
+					embeddedAgentLog.warn("codex conversation subscription cleanup failed", {
 						threadId,
-						timeoutMs: 5e3
-					}))) await closeCodexStartupClientBestEffort(client);
+						reason: formatErrorMessage(error)
+					});
+					await closeCodexStartupClientBestEffort(client);
+				} finally {
+					releaseCodexAppServerClientLease(clientLease);
 				}
 			}
-		} catch (error) {
-			embeddedAgentLog.warn("codex conversation subscription cleanup failed", {
-				threadId,
-				reason: formatErrorMessage(error)
-			});
-			await closeCodexStartupClientBestEffort(client);
-		} finally {
-			releaseCodexAppServerClientLease(clientLease);
 		}
-	}
+	});
 }
 function assertNativeConversationApprovalPolicySupported(runtime) {
 	if (runtime.approvalPolicy !== "never" && runtime.approvalsReviewer === "user") throw new Error(NATIVE_CONVERSATION_INTERACTIVE_APPROVALS_UNAVAILABLE);
@@ -1123,8 +1121,10 @@ async function runBoundTurnWithMissingThreadRecovery(params) {
 }
 async function prepareConversationBinding(params, options = {}) {
 	const identity = conversationBindingIdentity(params.data);
-	await params.bindingStore.withLease(identity, async () => {
-		const current = await params.bindingStore.read(identity);
+	const snapshot = params.bindingStore.read(identity);
+	const run = () => params.bindingStore.withLease(identity, async () => {
+		const current = params.bindingStore.read(identity);
+		if (current?.threadId !== snapshot?.threadId || current?.clientId !== snapshot?.clientId) throw new Error("Codex conversation binding changed before preparation.");
 		const requested = params.data.start && current?.conversationStartId !== params.data.start.id ? params.data.start : void 0;
 		if (current && !requested && !options.forceNew) return;
 		const sourceIdentity = params.data.source ? sessionBindingIdentity({
@@ -1133,7 +1133,7 @@ async function prepareConversationBinding(params, options = {}) {
 			sessionKey: params.data.source.sessionKey,
 			config: params.config
 		}) : void 0;
-		const sourceBinding = sourceIdentity ? await params.bindingStore.read(sourceIdentity) : void 0;
+		const sourceBinding = sourceIdentity ? params.bindingStore.read(sourceIdentity) : void 0;
 		assertCodexBindingMayBeReplaced(current, "initializing a conversation-bound Codex thread");
 		assertCodexBindingMayBeReplaced(sourceBinding, "transferring a session into a conversation-bound Codex thread");
 		const inherited = current ?? sourceBinding;
@@ -1158,15 +1158,11 @@ async function prepareConversationBinding(params, options = {}) {
 			agentId: params.data.source?.agentId ?? params.data.agentId
 		};
 		const threadId = requested?.threadId;
-		if (threadId && !options.forceNew) await attachExistingThread({
-			...bindingParams,
-			threadId
-		});
-		else await createThread(bindingParams);
-		const stored = await params.bindingStore.read(identity);
+		await bindThread(bindingParams, options.forceNew ? void 0 : threadId);
+		const stored = params.bindingStore.read(identity);
 		if (!stored) throw new Error("Codex conversation binding disappeared while initializing its thread.");
 		if (sourceIdentity && params.data.source && !current?.conversationSourceTransferComplete) await params.bindingStore.withLease(sourceIdentity, async () => {
-			const source = await params.bindingStore.read(sourceIdentity);
+			const source = params.bindingStore.read(sourceIdentity);
 			if (source && source.threadId === params.data.source?.threadId) {
 				const sourceSessionKey = sourceIdentity.sessionKey ?? resolveTranscriptSessionKeyBySessionId({
 					agentId: sourceIdentity.agentId,
@@ -1193,6 +1189,14 @@ async function prepareConversationBinding(params, options = {}) {
 			}
 		})) throw new Error("Codex conversation binding changed while initializing its thread.");
 	});
+	const threadId = params.data.start?.threadId ?? snapshot?.threadId;
+	if (threadId) await withExclusiveCodexAppServerThread({
+		bindingStore: params.bindingStore,
+		identity,
+		threadId,
+		run
+	});
+	else await run();
 }
 async function projectConversationSourceHistory(source, target, config) {
 	const storePath = resolveStorePath(config?.session?.store, { agentId: source.agentId });
@@ -1202,12 +1206,13 @@ async function projectConversationSourceHistory(source, target, config) {
 		storePath
 	});
 	if (!sessionKey) return;
-	const history = projectBoundedCodexVisibleSessionHistory(await readVisibleSessionTranscriptMessageEntries({
+	const entries = await readVisibleSessionTranscriptMessageEntries({
 		agentId: source.agentId,
 		sessionId: source.sessionId,
 		sessionKey,
 		storePath
-	}));
+	});
+	const history = projectBoundedCodexVisibleSessionHistory(entries);
 	if (history.length === 0) return;
 	const clientLease = retainSharedCodexAppServerClientByInstanceId(target.clientId);
 	if (!clientLease) throw new Error("Codex conversation source history lost its bound client owner.");
@@ -1221,6 +1226,7 @@ async function projectConversationSourceHistory(source, target, config) {
 	}
 }
 function isCodexThreadNotFoundError(error) {
+	if (isCodexAppServerOverloadError(error) || isCodexAppServerUnsafeSubscriptionError(error)) return false;
 	const message = formatErrorMessage(error);
 	return /\bthread not found:/iu.test(message) || /\bbound Codex conversation has no thread binding\b/u.test(message);
 }
@@ -1391,7 +1397,8 @@ async function buildCodexOAuthCredential(source) {
 	} : null;
 }
 async function buildCodexApiKeyCredential(source) {
-	const key = normalizeOptionalString((await readJsonObject(source.authPath)).OPENAI_API_KEY);
+	const raw = await readJsonObject(source.authPath);
+	const key = normalizeOptionalString(raw.OPENAI_API_KEY);
 	if (!key) return null;
 	return {
 		kind: "api_key",
@@ -2123,9 +2130,9 @@ function sanitizePluginName(value) {
 //#region extensions/codex/src/migration/targets.ts
 function resolveCodexMigrationTargets(ctx) {
 	const cfg = ctx.config;
-	const agentId = ctx.targetAgentId ?? resolveDefaultAgentId(cfg);
+	const agentId = ctx.targetAgentId ?? resolveDefaultAgentId$1(cfg);
 	const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
-	const configuredAgentDir = resolveAgentConfig(cfg, agentId)?.agentDir?.trim();
+	const configuredAgentDir = resolveAgentConfig$1(cfg, agentId)?.agentDir?.trim();
 	return {
 		workspaceDir,
 		agentDir: ctx.runtime?.agent?.resolveAgentDir(cfg, agentId) ?? (configuredAgentDir ? resolveHomePath(configuredAgentDir) : void 0) ?? path.join(ctx.stateDir, "agents", agentId, "agent")
@@ -2699,7 +2706,8 @@ async function requestTargetCodexAppServerJson(params) {
 		});
 		if (hasOpenAiCuratedMarketplace(lastResponse)) return lastResponse;
 		if (Date.now() >= discoveryDeadline) return lastResponse;
-		await sleep(Math.min(TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS, discoveryDeadline - Date.now()));
+		const waitMs = Math.min(TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS, discoveryDeadline - Date.now());
+		await sleep(waitMs);
 	} while (Date.now() < discoveryDeadline);
 	return lastResponse;
 }
@@ -2866,7 +2874,7 @@ function createCodexPluginsTool(options) {
 			const marketplace = typeof params.marketplace === "string" ? params.marketplace.trim() : void 0;
 			const limit = typeof params.limit === "number" && Number.isInteger(params.limit) ? Math.max(1, Math.min(params.limit, 20)) : 12;
 			const pluginConfig = options.getPluginConfig();
-			const binding = options.context.sessionId ? await options.bindingStore.read(sessionBindingIdentity({
+			const binding = options.context.sessionId ? options.bindingStore.read(sessionBindingIdentity({
 				sessionId: options.context.sessionId,
 				sessionKey: options.context.sessionKey,
 				agentId: options.context.agentId,
@@ -3041,11 +3049,11 @@ function createCodexThreadsTool(options) {
 		agentId: options.context.agentId,
 		config: runtimeConfig()
 	});
-	const currentBinding = async (session) => session ? await options.bindingStore.read(currentIdentity(session.sessionId)) : void 0;
-	const requestOptions = async (pluginConfig) => {
+	const currentBinding = (session) => session ? options.bindingStore.read(currentIdentity(session.sessionId)) : void 0;
+	const requestOptions = (pluginConfig) => {
 		const plugin = readCodexPluginConfig(pluginConfig);
 		const session = currentSession();
-		const binding = await currentBinding(session);
+		const binding = currentBinding(session);
 		if (binding?.connectionScope === "supervision") {
 			const connection = resolveCodexBindingAppServerConnection({
 				binding,
@@ -3106,7 +3114,7 @@ function createCodexThreadsTool(options) {
 					sourceKinds: [...CODEX_INTERACTIVE_THREAD_SOURCE_KINDS],
 					...cursor ? { cursor } : {},
 					...searchTerm ? { searchTerm } : {}
-				}, await requestOptions(pluginConfig));
+				}, requestOptions(pluginConfig));
 				return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
 			}
 			const threadId = readThreadId(params);
@@ -3116,7 +3124,7 @@ function createCodexThreadsTool(options) {
 				const response = await request(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
 					threadId,
 					includeTurns
-				}, await requestOptions(pluginConfig));
+				}, requestOptions(pluginConfig));
 				return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
 			}
 			if ((action === "fork" || action === "rename" || action === "archive" || action === "unarchive") && supervision?.enabled === true && supervision.allowWriteControls !== true) throw new Error("Codex native thread mutations are disabled for this codex plugin supervision config.");
@@ -3128,7 +3136,7 @@ function createCodexThreadsTool(options) {
 				await request(pluginConfig, CODEX_CONTROL_METHODS.renameThread, {
 					threadId,
 					name
-				}, await requestOptions(pluginConfig));
+				}, requestOptions(pluginConfig));
 				return jsonResult({
 					action,
 					threadId,
@@ -3136,17 +3144,17 @@ function createCodexThreadsTool(options) {
 				});
 			}
 			if (action === "unarchive") {
-				const response = await request(pluginConfig, CODEX_CONTROL_METHODS.unarchiveThread, { threadId }, await requestOptions(pluginConfig));
+				const response = await request(pluginConfig, CODEX_CONTROL_METHODS.unarchiveThread, { threadId }, requestOptions(pluginConfig));
 				return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
 			}
 			const session = currentSession();
-			const binding = await currentBinding(session);
+			const binding = currentBinding(session);
 			if (action === "archive") {
 				if (params.confirm !== true) throw new Error("confirm=true is required to archive a native Codex thread");
 				if (!session) throw new Error("cannot safely archive a native Codex thread without a session identity");
 				const identity = currentIdentity(session.sessionId);
 				await options.bindingStore.withThreadArchiveFence(async () => {
-					const archivedBinding = await currentBinding(session);
+					const archivedBinding = currentBinding(session);
 					if (archivedBinding?.threadId === threadId) {
 						if (session.modelSelectionLocked) throw new ModelSelectionLockedError();
 						assertCodexBindingMayBeReplaced(archivedBinding, "archiving its bound native thread");
@@ -3154,20 +3162,20 @@ function createCodexThreadsTool(options) {
 					assertThreadMayBeArchived(await request(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
 						threadId,
 						includeTurns: false
-					}, await requestOptions(pluginConfig)), threadId);
+					}, requestOptions(pluginConfig)), threadId);
 					if (await options.bindingStore.hasOtherThreadOwner(threadId, identity)) throw new Error("cannot archive a native Codex thread owned by another OpenClaw session");
 					await assertCodexArchiveDescendantsUnowned({
 						bindingStore: options.bindingStore,
 						threadId,
-						listPage: async (listParams) => await request(pluginConfig, CODEX_CONTROL_METHODS.listThreads, listParams, await requestOptions(pluginConfig)),
+						listPage: async (listParams) => await request(pluginConfig, CODEX_CONTROL_METHODS.listThreads, listParams, requestOptions(pluginConfig)),
 						assertDescendantIdle: async (descendantThreadId) => {
 							assertThreadMayBeArchived(await request(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
 								threadId: descendantThreadId,
 								includeTurns: false
-							}, await requestOptions(pluginConfig)), descendantThreadId);
+							}, requestOptions(pluginConfig)), descendantThreadId);
 						}
 					});
-					await request(pluginConfig, CODEX_CONTROL_METHODS.archiveThread, { threadId }, await requestOptions(pluginConfig));
+					await request(pluginConfig, CODEX_CONTROL_METHODS.archiveThread, { threadId }, requestOptions(pluginConfig));
 					if (archivedBinding?.threadId === threadId) await options.bindingStore.mutate(identity, {
 						kind: "clear",
 						threadId
@@ -3189,13 +3197,13 @@ function createCodexThreadsTool(options) {
 				assertThreadMayBeForked(await request(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
 					threadId,
 					includeTurns: false
-				}, await requestOptions(pluginConfig)), threadId);
+				}, requestOptions(pluginConfig)), threadId);
 			}
 			const response = await request(pluginConfig, CODEX_CONTROL_METHODS.forkThread, {
 				threadId,
 				threadSource: "user",
 				excludeTurns: true
-			}, await requestOptions(pluginConfig));
+			}, requestOptions(pluginConfig));
 			if (!isJsonObject(response) || !isJsonObject(response.thread)) throw new Error("Codex app-server returned an invalid thread/fork response");
 			const forkThreadId = typeof response.thread.id === "string" && response.thread.id.trim() ? response.thread.id : void 0;
 			if (!forkThreadId) throw new Error("Codex app-server thread/fork response did not include a thread id");
@@ -3254,7 +3262,8 @@ function createCodexNodeExecServerCommand() {
 			} catch {
 				throw new Error("Codex node exec-server requires a valid workspace request.");
 			}
-			const placement = parseCodexNodePlacementWorkspace(request);
+			if (!isRecord(request) || Object.keys(request).length !== 2 || request.authorization !== "human-approved" && request.authorization !== "session-full") throw new Error("Codex node exec-server requires an authorized managed placement workspace launch.");
+			const placement = parseCodexNodePlacementWorkspace(request.placement);
 			if (!context?.acquireManagedWorkspace || context.sessionKey !== placement.sessionKey || io.signal.aborted) throw new Error("Codex node exec-server requires active managed placement authority.");
 			const workspace = context.acquireManagedWorkspace({
 				workspaceDir: placement.cwd,
@@ -3266,11 +3275,14 @@ function createCodexNodeExecServerCommand() {
 			const frames = io.frames;
 			let unsubscribe;
 			try {
-				const { runCodexNodeExecServer } = await import("./node-exec-server.runtime-BpWqJO1V.js");
+				if (!context.prepareExecAuthorization) throw new Error("Codex node execution requires node-local exec policy support; update the node.");
+				const assertExecAuthorized = context.prepareExecAuthorization(request.authorization);
+				const { runCodexNodeExecServer } = await import("./node-exec-server.runtime-nfbUOtUB.js");
 				return await runCodexNodeExecServer({
 					workspaceDir: workspace.workspaceDir,
 					io,
 					activeProcesses,
+					assertExecAuthorized,
 					onFrameReceiver: (receiver) => {
 						unsubscribe = frames.onMessage(receiver);
 					}
@@ -3285,17 +3297,21 @@ function createCodexNodeExecServerCommand() {
 		}
 	};
 }
-/** Keeps node exec-server launch behind explicit arming and one-time approval. */
+/** Keeps node launch behind command opt-in and a live Full owner or human decision. */
 function createCodexNodeExecServerInvokePolicy() {
 	return {
 		commands: [CODEX_NODE_EXEC_SERVER_COMMAND],
 		dangerous: true,
+		standingApproval: {
+			kind: "placement",
+			scope: CODEX_NODE_EXEC_SERVER_CAPABILITY
+		},
 		classifyRisk: () => ({
 			level: "high",
 			family: CODEX_NODE_EXEC_SERVER_CAPABILITY
 		}),
 		handle: async (context) => {
-			if (!context.approvals || context.risk?.level !== "high") return {
+			if (context.risk?.level !== "high") return {
 				ok: false,
 				code: "CODEX_NODE_EXEC_APPROVAL_REQUIRED",
 				message: "Codex node execution requires an available approval reviewer."
@@ -3310,18 +3326,52 @@ function createCodexNodeExecServerInvokePolicy() {
 					message: "Codex node execution requires an exact managed placement workspace."
 				};
 			}
-			const nodeName = context.node?.displayName ?? context.nodeId;
-			if ((await context.approvals.request({
-				title: "Run Codex execution on node",
-				description: `${nodeName}: ${placement.cwd}; allows arbitrary processes and filesystem access across the node account, not only this workspace.`,
-				severity: "critical",
-				allowedDecisions: ["allow-once"]
-			})).decision !== "allow-once") return {
+			const workspace = {
+				workspaceDir: placement.cwd,
+				environmentId: placement.environmentId,
+				sessionId: placement.sessionId,
+				ownerEpoch: placement.ownerEpoch,
+				sessionKey: placement.sessionKey
+			};
+			const fullLaunch = await context.invokeNodeWithSessionFull?.({
+				workspace,
+				createParams: () => ({
+					placement,
+					authorization: "session-full"
+				})
+			});
+			if (fullLaunch) return fullLaunch;
+			if (!context.approvals) return {
 				ok: false,
-				code: "CODEX_NODE_EXEC_APPROVAL_DENIED",
-				message: "Codex node execution requires one-time approval."
+				code: "CODEX_NODE_EXEC_APPROVAL_REQUIRED",
+				message: "Codex node execution requires an available approval reviewer."
 			};
-			return await context.invokeNode({ params: placement });
+			const nodeName = context.node?.displayName ?? context.nodeId;
+			const approval = await context.approvals.request({
+				title: "Run Codex on this node placement",
+				description: `Allows arbitrary processes and filesystem access across the node account, not only this workspace. Allow always applies only while this exact placement remains active. ${nodeName}: ${placement.cwd}`,
+				severity: "critical",
+				allowedDecisions: ["allow-once", "allow-always"]
+			});
+			if (approval.decision !== "allow-once" && approval.decision !== "allow-always") {
+				if (approval.decision === "deny") return {
+					ok: false,
+					code: "CODEX_NODE_EXEC_APPROVAL_DENIED",
+					message: "Codex node execution was denied. Retry the action and choose Allow once or Allow always to continue."
+				};
+				return {
+					ok: false,
+					code: "CODEX_NODE_EXEC_APPROVAL_EXPIRED",
+					message: "Codex node execution approval expired before a decision. Retry the action and approve the new request."
+				};
+			}
+			return await context.invokeNode({
+				workspace,
+				params: {
+					placement,
+					authorization: "human-approved"
+				}
+			});
 		}
 	};
 }
@@ -4107,7 +4157,7 @@ function createCodexSupervisionTools(options) {
 }
 //#endregion
 //#region extensions/codex/src/web-search-provider.ts
-const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./web-search-provider.runtime-ClaNPV7N.js"));
+const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./web-search-provider.runtime-DKQn67A7.js"));
 const CodexWebSearchSchema = {
 	type: "object",
 	properties: { query: {
@@ -4143,13 +4193,13 @@ const ENDED_SESSION_REASONS = /* @__PURE__ */ new Set([
 	"new",
 	"reset",
 	"idle",
-	"daily",
-	"deleted"
+	"daily"
 ]);
 var codex_default = definePluginEntry({
 	id: "codex",
 	name: "Codex",
 	description: "Codex app-server harness and native session supervision.",
+	reload: { noopPrefixes: ["plugins.entries.codex.config.codexPlugins"] },
 	register(api) {
 		setManagedCodexPluginRoot(api.rootDir);
 		const resolveCurrentConfig = () => api.runtime.config?.current ? api.runtime.config.current() : void 0;
@@ -4169,6 +4219,7 @@ var codex_default = definePluginEntry({
 		const resolveCurrentPluginConfig = () => resolvePluginConfig(resolveCurrentConfig);
 		const appServerConfig = readCodexPluginConfig(resolveCurrentPluginConfig()).appServer;
 		api.registerService(createCodexDesktopGenerationService({ onGenerationChange: retireSharedCodexAppServerClientsBeforeDesktopGeneration }));
+		api.registerService(createCodexAppServerProcessReaperService());
 		if (appServerConfig?.transport === "websocket") api.registerService(createCodexAppServerConnectionHealthService({
 			getPluginConfig: resolveCurrentPluginConfig,
 			getRuntimeConfig: resolveCurrentConfig
@@ -4181,9 +4232,10 @@ var codex_default = definePluginEntry({
 			overflowPolicy: "reject-new"
 		});
 		const lazyBindingStateStore = {
-			delete: (key) => openBindingStateStore().delete(key),
+			deleteIf: (key, predicate) => openBindingStateStore().deleteIf(key, predicate),
 			entries: () => openBindingStateStore().entries(),
 			lookup: (key) => openBindingStateStore().lookup(key),
+			registerIfAbsent: (key, value, options) => openBindingStateStore().registerIfAbsent(key, value, options),
 			get update() {
 				const store = openBindingStateStore();
 				return store.update?.bind(store);
@@ -4196,10 +4248,12 @@ var codex_default = definePluginEntry({
 		});
 		const bindingStore = createLazyCodexAppServerBindingStore(lazyBindingStateStore, {
 			entries: () => openManagedThreadStateStore().entries(),
+			lookup: (key) => openManagedThreadStateStore().lookup(key),
 			registerIfAbsent: (key, value) => openManagedThreadStateStore().registerIfAbsent(key, value)
 		});
 		registerCodexCliMetadata(api);
 		const sessionCatalogControlFactory = createCodexSessionCatalogControl({
+			managedThreads: bindingStore.managedThreads,
 			config: api.config,
 			getPluginConfig: resolveCurrentPluginConfig,
 			getRuntimeConfig: resolveCurrentConfig
@@ -4333,22 +4387,6 @@ var codex_default = definePluginEntry({
 			})
 		}));
 		api.onConversationBindingResolved?.((event) => codexConversationBindingRuntime.handleBindingResolved(event, { bindingStore }));
-		api.on("after_compaction", async (event, ctx) => {
-			const previousSessionId = event.previousSessionId?.trim();
-			const sessionId = ctx.sessionId?.trim();
-			if (!previousSessionId || !sessionId || previousSessionId === sessionId) return;
-			const config = resolveCurrentConfig();
-			const sessionKey = ctx.sessionKey?.trim();
-			const { sessionBindingIdentity } = await import("./session-binding-Bcynfd-_.js").then((n) => n.f);
-			const identity = sessionBindingIdentity({
-				sessionId,
-				...sessionKey ? { sessionKey } : {},
-				...ctx.agentId ? { agentId: ctx.agentId } : {},
-				...config ? { config } : {}
-			});
-			const adopted = await bindingStore.adoptSessionGeneration(identity, previousSessionId);
-			if (adopted === "conflict") api.logger.warn?.(`codex: could not adopt compacted session generation ${sessionId} (${adopted}); secondary native compaction will skip`);
-		});
 		api.on("session_end", async (event, ctx) => {
 			if (!event.reason || !ENDED_SESSION_REASONS.has(event.reason)) return;
 			const sessionKey = event.sessionKey ?? ctx.sessionKey;
@@ -4357,7 +4395,7 @@ var codex_default = definePluginEntry({
 			if (endedSessionKey && nextSessionKey && nextSessionKey !== endedSessionKey) return;
 			if (event.nextSessionId?.trim() === event.sessionId.trim()) return;
 			const config = resolveCurrentConfig();
-			const [{ sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-Bcynfd-_.js").then((n) => n.f), import("./session-retirement-CcNC3YSY.js")]);
+			const [{ sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-4Ki04sW-.js").then((n) => n.d), import("./session-retirement-DNdmYdFc.js")]);
 			await retireCodexAppServerSessionGeneration({
 				bindingStore,
 				identity: sessionBindingIdentity({