@openclaw/codex 2026.10.5-beta.4 → 2026.10.10-beta.1

package/dist/.setup/{conversation-binding-BieJZRRV.mjs → conversation-binding-C7MZy-Cx.mjs}

@@ -1,60 +1,125 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-DU_0biMD.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
+import { g as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-C_THntMe.mjs";
 import { d as readCodexRequirementsToml } from "./config-security-clxAZYWX.mjs";
 import { d as readCodexPluginConfig } from "./config-parsing-DsWSCPHO.mjs";
-import { d as readCodexEffectiveConfig, n as codexSandboxPolicyForTurn } from "./config-options-DDzeNQ8m.mjs";
-import { S as retainSharedCodexAppServerClientByInstanceId } from "./auth-cache-key-f8ODJ_OX.mjs";
-import { o as resolveCodexDefaultWorkspaceDir } from "./conversation-binding-data-UgLuTSQT.mjs";
-import { o as isCodexAppServerOverloadError } from "./rpc-error-C98SHchT.mjs";
-import { n as projectBoundedCodexVisibleSessionHistory } from "./transcript-history-projection-DfKcoZCB.mjs";
-import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-C1YVVLEA.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-DWzK-k0n.mjs";
-import { n as normalizeCodexAppServerBindingModelProvider, t as isCodexAppServerNativeAuthProfile } from "./auth-profile-CgHQ8Vot.mjs";
-import { B as isCodexAppServerClientRuntimeLive, F as consumeCodexAppServerLiveThread, K as releaseCodexAppServerLiveThread, R as hasCodexAppServerLiveThread, V as isCodexAppServerLiveThreadClaimed, b as withLeasedCodexAppServerClientStartSelectionRetry, c as getLeasedSharedCodexAppServerClient, m as releaseCodexAppServerClientLease } from "./shared-client-BCx1wbyA.mjs";
-import { a as isCodexAppServerIndeterminateRequestCancellationError, g as assertCodexThreadStartResponse, p as assertCodexThreadAcceptsDirectInput, u as CodexThreadDirectInputError } from "./client-D93nbdB8.mjs";
-import { a as isCodexNotificationForTurn, n as getCodexAppServerTurnRouter } from "./turn-router-DBVMToGo.mjs";
-import { f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-zNuNTKVr.mjs";
-import { d as mergeCodexThreadConfigs, s as buildDisabledAppsConfigPatch, t as buildCodexProjectDocThreadConfig } from "./project-doc-thread-config-BVcvnps8.mjs";
-import "./session-binding-JEHNMPsr.mjs";
-import { r as resolveCodexAppServerRequestModelSelection, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-model-selection-DcVebr8N.mjs";
-import { a as rollbackCodexAppServerBindingSubscription, c as withExclusiveCodexAppServerThread, n as releaseCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-BoUd0i6L.mjs";
-import { t as resumeCodexAppServerThread } from "./thread-resume-D-3bsr1j.mjs";
+import { d as readCodexEffectiveConfig, n as codexSandboxPolicyForTurn } from "./config-options-DMFZkd3X.mjs";
+import { T as retainSharedCodexAppServerClientByInstanceId } from "./auth-cache-key-CVcYw8HD.mjs";
+import { o as resolveCodexDefaultWorkspaceDir } from "./conversation-binding-data-khgW0n-o.mjs";
+import { o as isCodexAppServerOverloadError } from "./rpc-error-DemqqaxE.mjs";
+import { n as projectBoundedCodexVisibleSessionHistory } from "./transcript-history-projection-i-FVpyha.mjs";
+import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-BfrAlTMT.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BZRizyuG.mjs";
+import { n as normalizeCodexAppServerBindingModelProvider, o as resolveModelBackedReviewerPolicyProvider } from "./auth-profile-auwzSwwy.mjs";
+import { A as hasCodexAppServerLiveThread, D as consumeCodexAppServerLiveThread, M as isCodexAppServerClientRuntimeLive, N as isCodexAppServerLiveThreadClaimed, d as releaseCodexAppServerClientLease, h as withCodexAppServerClientRequestScope, o as getLeasedSharedCodexAppServerClient, z as releaseCodexAppServerLiveThread } from "./shared-client-CE_uY0A1.mjs";
+import { f as assertCodexThreadAcceptsDirectInput, h as assertCodexThreadStartResponse, i as isCodexAppServerIndeterminateRequestCancellationError, l as CodexThreadDirectInputError } from "./client-BS8X7HmG.mjs";
+import { a as isCodexNotificationForTurn, n as getCodexAppServerTurnRouter } from "./turn-router-Dbw17k3K.mjs";
+import { f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-6OcbMH46.mjs";
+import { d as mergeCodexThreadConfigs, s as buildDisabledAppsConfigPatch, t as buildCodexProjectDocThreadConfig } from "./project-doc-thread-config-B0UI3f1D.mjs";
+import "./session-binding-BgsWcbdY.mjs";
+import { r as resolveCodexAppServerRequestModelSelection, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-model-selection-DxposL4X.mjs";
+import { a as rollbackCodexAppServerBindingSubscription, c as withExclusiveCodexAppServerThread, n as releaseCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-t6Y9fLQS.mjs";
+import { i as resolveCodexNativeExecutionPolicy } from "./native-execution-policy-D09tLP-u.mjs";
+import { i as resolveCodexNativeExecutionBlock, t as assertNativeConversationApprovalPolicySupported } from "./sandbox-guard-DneAfNye.mjs";
+import { t as resumeCodexAppServerThread } from "./thread-resume-BUbsUfgF.mjs";
 import { i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, t as CODEX_SESSION_PERMISSION_EXEC_MODES } from "./session-permission-policy-CD2MAWU8.mjs";
-import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-D_zv8J7V.mjs";
-import { f as trackCodexConversationActiveTurn, o as resolveThreadRequestModelProvider, t as buildCodexConversationAgentLookup } from "./conversation-control-GXM3unE4.mjs";
+import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-Cog6mm2i.mjs";
+import { f as trackCodexConversationActiveTurn, o as resolveThreadRequestModelProvider, t as buildCodexConversationAgentLookup } from "./conversation-control-B2EpVZEb.mjs";
 import { asOptionalRecord, normalizeOptionalString, readNonEmptyStringPreservingWhitespace } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import path from "node:path";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
+import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { fileURLToPath } from "node:url";
 import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
 import { embeddedAgentLog, formatErrorMessage, resolveActiveEmbeddedRunSessionId, resolveSandboxContext } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
-import { getSessionEntry, resolveStorePath, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
+import { loadExecApprovalsReadOnlyAsync } from "openclaw/plugin-sdk/exec-approvals-runtime";
+import { getSessionEntryByIdAsync, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { readVisibleSessionTranscriptMessageEntries } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { captureSessionEntryCurrentCheckAsync, composeSessionEntryCommitGuards } from "openclaw/plugin-sdk/session-binding-runtime";
+//#region extensions/codex/src/conversation-binding-history.ts
+async function projectConversationSourceHistory(source, target, config, assertCurrent) {
+	const storePath = source.storePath ?? resolveStorePath(config?.session?.store, { agentId: source.agentId });
+	const sessionKey = source.sessionKey ?? (await getSessionEntryByIdAsync({
+		agentId: source.agentId,
+		sessionId: source.sessionId,
+		storePath
+	}))?.sessionKey;
+	if (!sessionKey) return;
+	const entries = await readVisibleSessionTranscriptMessageEntries({
+		agentId: source.agentId,
+		sessionId: source.sessionId,
+		sessionKey,
+		storePath
+	});
+	const history = projectBoundedCodexVisibleSessionHistory(entries);
+	if (history.length === 0) return;
+	const clientLease = await retainSharedCodexAppServerClientByInstanceId(target.clientId);
+	if (!clientLease) throw new Error("Codex conversation source history lost its bound client owner.");
+	try {
+		await clientLease.client.request("thread/inject_items", {
+			threadId: target.threadId,
+			items: history
+		}, { withCurrent: async (write) => {
+			await assertCurrent();
+			write();
+		} });
+	} finally {
+		await clientLease.release();
+	}
+}
+//#endregion
 //#region extensions/codex/src/conversation-binding-preparation.ts
 /** Canonical conversation thread preparation, policy, and binding ownership. */
-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 ? resolveSessionAgentIdsStrict({
 		sessionKey: params.sessionKey,
 		config: params.config
 	}).sessionAgentId : void 0);
-	const storePath = agentId && (source || params.sessionKey) ? resolveStorePath(params.config?.session?.store, { agentId }) : void 0;
-	const sessionKey = source ? source.sessionKey ?? (storePath ? resolveTranscriptSessionKeyBySessionId({
+	const storePath = agentId && (source || params.sessionKey) ? source?.storePath ?? params.storePath ?? resolveStorePath(params.config?.session?.store, { agentId }) : void 0;
+	const selectedById = source && !source.sessionKey && storePath ? await getSessionEntryByIdAsync({
 		agentId: source.agentId,
 		sessionId: source.sessionId,
 		storePath
-	}) : void 0) : params.sessionKey;
-	const storedEntry = sessionKey && storePath ? getSessionEntry({
+	}) : void 0;
+	const sessionKey = source ? source.sessionKey ?? selectedById?.sessionKey : params.sessionKey;
+	const ownsSession = source || (parseAgentSessionKey(sessionKey)?.agentId ?? agentId) === agentId;
+	const current = sessionKey && storePath && agentId && ownsSession ? await captureSessionEntryCurrentCheckAsync({
 		agentId,
 		storePath,
 		sessionKey,
-		readConsistency: "latest"
+		fields: [
+			"permissionMode",
+			"sessionRoot",
+			"execHost",
+			"execNode",
+			"sandbox",
+			"sandboxMode",
+			"incognito"
+		],
+		...selectedById ? { expected: selectedById.entry } : {}
 	}) : void 0;
+	let transferred = false;
+	using currentCleanup = { [Symbol.dispose]: () => !transferred && current?.release() };
+	const storedEntry = current?.entry;
 	const entry = !source || storedEntry?.sessionId === source.sessionId ? storedEntry : void 0;
 	if (source && !entry) throw new Error("Codex conversation source session is missing or no longer current; rebind this conversation before retrying.");
+	const block = resolveCodexNativeExecutionBlock({
+		config: params.config,
+		agentId,
+		sessionKey,
+		storePath,
+		executionPolicy: resolveCodexNativeExecutionPolicy({
+			config: params.config,
+			agentId,
+			sessionKey,
+			sessionEntry: entry ?? null,
+			readRuntimeSessionEntry: false
+		}),
+		surface: "conversation binding"
+	});
+	if (block) throw new Error(block);
 	const permissionMode = entry?.permissionMode;
 	const sessionRoot = permissionMode ? entry?.sessionRoot : void 0;
 	const agentWorkspaceDir = params.config && agentId ? resolveAgentWorkspaceDir(params.config, agentId) : resolveCodexDefaultWorkspaceDir(params.pluginConfig);
@@ -63,13 +128,14 @@ async function resolveConversationAppServerRuntime(params) {
 		agentId,
 		permissionMode,
 		execOverrides: permissionMode ? { mode: CODEX_SESSION_PERMISSION_EXEC_MODES[permissionMode] } : void 0,
-		approvals: permissionMode === "full" ? void 0 : loadExecApprovals()
+		approvals: permissionMode === "full" ? void 0 : await loadExecApprovalsReadOnlyAsync()
 	});
 	const sandboxForPolicy = execPolicy.touched && execPolicy.security === "full" && execPolicy.ask !== "off" ? await resolveSandboxContext({
 		config: params.config,
 		sessionKey,
 		workspaceDir: agentWorkspaceDir
 	}) : void 0;
+	using _ = { [Symbol.dispose]: () => sandboxForPolicy?.[Symbol.dispose]?.() };
 	const configuredRuntime = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.pluginConfig,
 		execPolicy,
@@ -96,7 +162,12 @@ async function resolveConversationAppServerRuntime(params) {
 		requirementsToml: readCodexRequirementsToml({}),
 		execMode: execPolicy.mode
 	});
-	return {
+	await current?.assertCurrent();
+	const resolved = {
+		release: current?.release ?? (() => {}),
+		assertCurrent: current?.assertCurrent ?? (async () => {}),
+		source: current?.source,
+		incognito: source || sessionKey ? entry?.incognito === true || isIncognitoSessionKey(sessionKey) : void 0,
 		runtime: resolveCodexAppServerForModelProvider({
 			appServer: runtime,
 			provider: params.modelProvider,
@@ -113,38 +184,48 @@ async function resolveConversationAppServerRuntime(params) {
 			fallbackCwd: params.workspaceDir
 		})
 	};
+	transferred = true;
+	return resolved;
 }
 const CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS = "This Codex thread is bound to an OpenClaw conversation. Answer normally; OpenClaw will deliver your final response back to the conversation.";
 async function resolveThreadBindingRuntime(params) {
 	const agentLookup = buildCodexConversationAgentLookup(params);
-	const modelProvider = resolveThreadRequestModelProvider({
+	const modelProvider = await resolveThreadRequestModelProvider({
 		authProfileId: params.authProfileId,
 		modelProvider: params.modelProvider,
 		...agentLookup
 	});
-	const modelSelection = params.model?.trim() ? resolveCodexAppServerRequestModelSelection({
+	const modelSelection = params.model?.trim() ? await resolveCodexAppServerRequestModelSelection({
 		model: params.model,
 		modelProvider,
 		authProfileId: params.authProfileId,
 		...agentLookup
 	}) : void 0;
-	const reviewerModelProvider = resolveModelBackedReviewerPolicyProvider({
+	const reviewerModelProvider = await resolveModelBackedReviewerPolicyProvider({
 		authProfileId: params.authProfileId,
 		modelProvider: params.modelProvider,
 		...agentLookup
 	});
-	const { runtime, workspaceDir } = await resolveConversationAppServerRuntime({
+	const { runtime, workspaceDir, assertCurrent, source, incognito, release } = await resolveConversationAppServerRuntime({
 		...params,
 		modelProvider: reviewerModelProvider
 	});
+	let transferred = false;
+	using _ = { [Symbol.dispose]: () => !transferred && release() };
 	assertNativeConversationApprovalPolicySupported(runtime);
 	const clientOptions = {
+		assertCurrentAsync: assertCurrent,
 		startOptions: runtime.start,
 		timeoutMs: runtime.requestTimeoutMs,
 		authProfileId: params.authProfileId,
 		...agentLookup
 	};
+	transferred = true;
 	return {
+		release,
+		assertCurrent,
+		source,
+		incognito: incognito ?? params.incognito,
 		runtime,
 		workspaceDir,
 		agentLookup,
@@ -154,8 +235,10 @@ async function resolveThreadBindingRuntime(params) {
 	};
 }
 async function buildConversationThreadRequestForClient(client, resolved, serviceTier, requestOptions) {
+	await resolved.assertCurrent();
 	const effectiveConfig = await readCodexEffectiveConfig(client, resolved.workspaceDir, requestOptions());
 	requestOptions();
+	await resolved.assertCurrent();
 	const { runtime } = resolved;
 	const config = buildCodexProjectDocThreadConfig(mergeCodexThreadConfigs(runtime.networkProxy?.configPatch, buildDisabledAppsConfigPatch()), effectiveConfig);
 	return {
@@ -177,9 +260,9 @@ async function writeThreadBindingFromResponse(params, resolved, client, response
 	let retained = false;
 	let sameOwner = false;
 	try {
-		const current = params.bindingStore.read(params.identity);
+		const current = await params.bindingStore.readAsync(params.identity);
 		assertCodexBindingMayBeReplaced(current, "storing a conversation-bound Codex thread");
-		const trackSubscription = !params.incognito && isCodexAppServerClientRuntimeLive(client);
+		const trackSubscription = !resolved.incognito && isCodexAppServerClientRuntimeLive(client);
 		sameOwner = isSameCodexAppServerThreadOwner(current, {
 			threadId: response.thread.id,
 			clientId: client.getInstanceId()
@@ -191,9 +274,10 @@ async function writeThreadBindingFromResponse(params, resolved, client, response
 			if (!retained) throw new Error("Codex conversation thread lost its native subscription owner.");
 		}
 		if (current && !sameOwner) {
-			const { assertCurrent } = requestOptions();
+			const { assertCurrent, withCurrent } = requestOptions();
 			await releaseCodexAppServerBindingSubscription(current, {
 				assertCurrent,
+				withCurrent,
 				retainedClientId: client.getInstanceId()
 			});
 		}
@@ -204,9 +288,10 @@ async function writeThreadBindingFromResponse(params, resolved, client, response
 				threadId: response.thread.id,
 				clientId: client.getInstanceId(),
 				cwd: resolved.workspaceDir,
+				...resolved.incognito ? { conversationIncognito: true } : {},
 				authProfileId: params.authProfileId,
 				model: response.model ?? resolved.model ?? params.model,
-				modelProvider: normalizeCodexAppServerBindingModelProvider({
+				modelProvider: await normalizeCodexAppServerBindingModelProvider({
 					authProfileId: params.authProfileId,
 					modelProvider: response.modelProvider ?? resolved.modelProvider ?? params.modelProvider,
 					...resolved.agentLookup
@@ -215,22 +300,37 @@ async function writeThreadBindingFromResponse(params, resolved, client, response
 				networkProxyProfileName: resolved.runtime.networkProxy?.profileName,
 				networkProxyConfigFingerprint: resolved.runtime.networkProxy?.configFingerprint
 			}
-		}, requestOptions)) throw new Error("Codex conversation binding changed while storing its thread.");
+		}, composeSessionEntryCommitGuards([() => {
+			requestOptions();
+		}, resolved.source]))) throw new Error("Codex conversation binding changed while storing its thread.");
 	} catch (error) {
 		if (retained && !sameOwner || !hasCodexAppServerLiveThread(client, response.thread.id)) await rollbackCodexAppServerBindingSubscription(client, response.thread.id, retained);
 		throw error;
 	}
 }
 async function bindThread(params, threadId) {
-	const current = params.bindingStore.read(params.identity);
+	const current = await params.bindingStore.readAsync(params.identity);
 	assertCodexBindingMayBeReplaced(current, "binding a conversation-bound Codex thread");
 	const resolved = await resolveThreadBindingRuntime(params);
+	let transferred = false;
+	using _ = { [Symbol.dispose]: () => !transferred && resolved.release() };
 	const clientLease = { client: await getLeasedSharedCodexAppServerClient(resolved.clientOptions) };
 	try {
-		await withLeasedCodexAppServerClientStartSelectionRetry({
+		await withCodexAppServerClientRequestScope({
 			lease: clientLease,
 			options: resolved.clientOptions,
-			run: async (client, requestOptions) => {
+			run: async (client, connectionRequestOptions) => {
+				const requestOptions = () => {
+					const options = connectionRequestOptions();
+					return {
+						...options,
+						withCurrent: async (write) => {
+							await resolved.assertCurrent();
+							options.assertCurrent();
+							write();
+						}
+					};
+				};
 				const request = await buildConversationThreadRequestForClient(client, resolved, params.serviceTier ?? resolved.runtime.serviceTier, requestOptions);
 				let response;
 				if (threadId && !resolved.runtime.networkProxy) {
@@ -240,8 +340,8 @@ async function bindThread(params, threadId) {
 						includeTurns: false
 					}, requestOptions());
 					assertCodexThreadAcceptsDirectInput(thread);
-					const { assertCurrent } = requestOptions();
-					await releaseCodexAppServerLiveThread(client, threadId, assertCurrent);
+					const { assertCurrent, withCurrent } = requestOptions();
+					await releaseCodexAppServerLiveThread(client, threadId, assertCurrent, withCurrent);
 					if (isCodexAppServerLiveThreadClaimed(client, threadId)) throw new Error(`Codex thread ${threadId} has an active run; stop it before binding its conversation.`);
 					response = await resumeCodexAppServerThread({
 						client,
@@ -256,7 +356,7 @@ async function bindThread(params, threadId) {
 					...request,
 					developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
 					experimentalRawEvents: true,
-					...params.incognito ? { ephemeral: true } : {}
+					...resolved.incognito ? { ephemeral: true } : {}
 				}, requestOptions());
 				await writeThreadBindingFromResponse(params, resolved, client, response, requestOptions);
 			}
@@ -264,18 +364,21 @@ async function bindThread(params, threadId) {
 	} finally {
 		releaseCodexAppServerClientLease(clientLease);
 	}
-}
-function assertNativeConversationApprovalPolicySupported(runtime) {
-	if (runtime.approvalPolicy !== "never" && runtime.approvalsReviewer === "user") throw new Error(NATIVE_CONVERSATION_INTERACTIVE_APPROVALS_UNAVAILABLE);
+	transferred = true;
+	return {
+		assertCurrent: resolved.assertCurrent,
+		source: resolved.source,
+		release: resolved.release
+	};
 }
 async function prepareCodexConversationBinding(params, options = {}) {
 	const identity = {
 		kind: "conversation",
 		bindingId: params.data.bindingId
 	};
-	const snapshot = params.bindingStore.read(identity);
+	const snapshot = await params.bindingStore.readAsync(identity);
 	const run = () => params.bindingStore.withLease(identity, async () => {
-		const current = params.bindingStore.read(identity);
+		const current = await params.bindingStore.readAsync(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;
@@ -285,7 +388,7 @@ async function prepareCodexConversationBinding(params, options = {}) {
 			sessionKey: params.data.source.sessionKey,
 			config: params.config
 		}) : void 0;
-		const sourceBinding = sourceIdentity ? params.bindingStore.read(sourceIdentity) : void 0;
+		const sourceBinding = sourceIdentity ? await params.bindingStore.readAsync(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;
@@ -310,26 +413,33 @@ async function prepareCodexConversationBinding(params, options = {}) {
 			agentId: params.data.source?.agentId ?? params.data.agentId
 		};
 		const threadId = requested?.threadId;
-		await bindThread(bindingParams, options.forceNew ? void 0 : threadId);
-		const stored = params.bindingStore.read(identity);
+		const sourceAuthority = await bindThread(bindingParams, options.forceNew ? void 0 : threadId);
+		using _ = { [Symbol.dispose]: sourceAuthority.release };
+		await sourceAuthority.assertCurrent();
+		const sourceGuard = sourceAuthority.source;
+		const stored = await params.bindingStore.readAsync(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 = params.bindingStore.read(sourceIdentity);
+			await sourceAuthority.assertCurrent();
+			const source = await params.bindingStore.readAsync(sourceIdentity);
 			if (source && source.threadId === params.data.source?.threadId) {
-				const sourceSessionKey = sourceIdentity.sessionKey ?? resolveTranscriptSessionKeyBySessionId({
+				const sourceSessionKey = sourceIdentity.sessionKey ?? (await getSessionEntryByIdAsync({
 					agentId: sourceIdentity.agentId,
 					sessionId: sourceIdentity.sessionId,
-					storePath: resolveStorePath(params.config?.session?.store, { agentId: sourceIdentity.agentId })
-				});
+					storePath: params.data.source.storePath ?? resolveStorePath(params.config?.session?.store, { agentId: sourceIdentity.agentId })
+				}))?.sessionKey;
 				if (sourceSessionKey && resolveActiveEmbeddedRunSessionId(sourceSessionKey) === sourceIdentity.sessionId) throw new Error("Codex source session has an active run; stop it before binding this conversation.");
 				if (source.threadId !== stored.threadId) {
-					await releaseCodexAppServerBindingSubscription(source);
-					await projectConversationSourceHistory(params.data.source, stored, params.config);
+					await releaseCodexAppServerBindingSubscription(source, { withCurrent: async (write) => {
+						await sourceAuthority.assertCurrent();
+						write();
+					} });
+					await projectConversationSourceHistory(params.data.source, stored, params.config, sourceAuthority.assertCurrent);
 				}
 				await params.bindingStore.mutate(sourceIdentity, {
 					kind: "clear",
 					threadId: source.threadId
-				});
+				}, sourceAuthority.source);
 			}
 		});
 		if (!await params.bindingStore.mutate(identity, {
@@ -339,7 +449,7 @@ async function prepareCodexConversationBinding(params, options = {}) {
 				...params.data.start ? { conversationStartId: params.data.start.id } : {},
 				...sourceIdentity ? { conversationSourceTransferComplete: true } : {}
 			}
-		})) throw new Error("Codex conversation binding changed while initializing its thread.");
+		}, sourceGuard)) throw new Error("Codex conversation binding changed while initializing its thread.");
 	});
 	const threadId = params.data.start?.threadId ?? snapshot?.threadId;
 	if (threadId) await withExclusiveCodexAppServerThread({
@@ -350,38 +460,6 @@ async function prepareCodexConversationBinding(params, options = {}) {
 	});
 	else await run();
 }
-async function projectConversationSourceHistory(source, target, config) {
-	const storePath = resolveStorePath(config?.session?.store, { agentId: source.agentId });
-	const sessionKey = source.sessionKey ?? resolveTranscriptSessionKeyBySessionId({
-		agentId: source.agentId,
-		sessionId: source.sessionId,
-		storePath
-	});
-	if (!sessionKey) return;
-	const entries = await readVisibleSessionTranscriptMessageEntries({
-		agentId: source.agentId,
-		sessionId: source.sessionId,
-		sessionKey,
-		storePath
-	});
-	const history = projectBoundedCodexVisibleSessionHistory(entries);
-	if (history.length === 0) return;
-	const clientLease = await retainSharedCodexAppServerClientByInstanceId(target.clientId);
-	if (!clientLease) throw new Error("Codex conversation source history lost its bound client owner.");
-	try {
-		await clientLease.client.request("thread/inject_items", {
-			threadId: target.threadId,
-			items: history
-		});
-	} finally {
-		await clientLease.release();
-	}
-}
-function resolveModelBackedReviewerPolicyProvider(params) {
-	const modelProvider = params.modelProvider?.trim();
-	if (modelProvider && modelProvider.toLowerCase() !== "codex") return modelProvider.toLowerCase() === "openai" ? "openai" : modelProvider;
-	return isCodexAppServerNativeAuthProfile(params) ? "openai" : void 0;
-}
 //#endregion
 //#region extensions/codex/src/conversation-turn-collector.ts
 /** Identifies a timer that expired in the bound-turn collector itself. */
@@ -544,24 +622,24 @@ async function runBoundTurn(params) {
 		kind: "conversation",
 		bindingId: params.data.bindingId
 	};
-	const binding = params.bindingStore.read(identity);
+	const binding = await params.bindingStore.readAsync(identity);
 	if (!binding?.threadId) throw new Error("bound Codex conversation has no thread binding");
 	return await withExclusiveCodexAppServerThread({
 		bindingStore: params.bindingStore,
 		identity,
 		threadId: binding.threadId,
 		run: async () => {
-			const current = params.bindingStore.read(identity);
+			const current = await params.bindingStore.readAsync(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({
+			const reviewerModelProvider = await resolveModelBackedReviewerPolicyProvider({
 				authProfileId: binding.authProfileId,
 				modelProvider: binding.modelProvider,
 				...agentLookup
 			});
-			const { runtime, workspaceDir } = await resolveConversationAppServerRuntime({
+			const { runtime, workspaceDir, assertCurrent, release, source, incognito: sourceIncognito } = await resolveConversationAppServerRuntime({
 				pluginConfig: params.pluginConfig,
 				config: params.config,
 				agentId: params.data.source?.agentId ?? params.data.agentId,
@@ -572,6 +650,8 @@ async function runBoundTurn(params) {
 				model: binding.model,
 				agentDir: params.data.agentDir
 			});
+			using _ = { [Symbol.dispose]: release };
+			const incognito = sourceIncognito ?? params.incognito;
 			const { sessionRoot, approvalPolicy, sandbox } = runtime;
 			const permissionProfile = runtime.networkProxy?.profileName;
 			const networkProxyConfigFingerprint = runtime.networkProxy?.configFingerprint;
@@ -579,7 +659,7 @@ async function runBoundTurn(params) {
 			const serviceTier = binding.serviceTier ?? runtime.serviceTier;
 			let useStickyNetworkProfile = permissionProfile !== void 0 && !networkProxyBindingChanged;
 			assertNativeConversationApprovalPolicySupported(runtime);
-			const modelSelection = binding.model ? resolveCodexAppServerRequestModelSelection({
+			const modelSelection = binding.model ? await resolveCodexAppServerRequestModelSelection({
 				model: binding.model,
 				modelProvider: binding.modelProvider,
 				authProfileId: binding.authProfileId,
@@ -588,15 +668,19 @@ async function runBoundTurn(params) {
 			const threadRequestRuntime = {
 				runtime,
 				workspaceDir,
+				assertCurrent,
+				source,
+				incognito,
 				...modelSelection
 			};
 			const clientOptions = {
+				assertCurrentAsync: assertCurrent,
 				startOptions: runtime.start,
 				timeoutMs: runtime.requestTimeoutMs,
 				authProfileId: binding.authProfileId,
 				...agentLookup
 			};
-			let client = await getLeasedSharedCodexAppServerClient(clientOptions);
+			const client = await getLeasedSharedCodexAppServerClient(clientOptions);
 			const clientLease = { client };
 			let activeTurnId;
 			let activeTurnCleanup = () => void 0;
@@ -605,16 +689,23 @@ async function runBoundTurn(params) {
 			let liveThreadOwnership;
 			let ownsNativeSubscription = false;
 			let turnSucceeded = false;
+			const withCurrent = async (write) => {
+				await assertCurrent();
+				write();
+			};
 			const assertResumeInputAllowed = async () => {
 				const { thread } = await client.request("thread/read", {
 					threadId,
 					includeTurns: false
-				}, { timeoutMs: runtime.requestTimeoutMs });
+				}, {
+					timeoutMs: runtime.requestTimeoutMs,
+					withCurrent
+				});
 				assertCodexThreadAcceptsDirectInput(thread);
 			};
 			try {
 				if (!networkProxyBindingChanged && binding.clientId !== client.getInstanceId()) await assertResumeInputAllowed();
-				if (!params.incognito && isCodexAppServerClientRuntimeLive(client)) {
+				if (!incognito && isCodexAppServerClientRuntimeLive(client)) {
 					const ownership = await consumeCodexAppServerLiveThread(client, threadId);
 					if (ownership) {
 						liveThreadOwnership = {
@@ -625,18 +716,29 @@ async function runBoundTurn(params) {
 						ownsNativeSubscription = true;
 					}
 				}
-				if (networkProxyBindingChanged || binding.clientId !== client.getInstanceId() || isCodexAppServerClientRuntimeLive(client) && !params.incognito && !liveThreadOwnership) {
+				if (networkProxyBindingChanged || binding.clientId !== client.getInstanceId() || isCodexAppServerClientRuntimeLive(client) && !incognito && !liveThreadOwnership) {
 					if (!networkProxyBindingChanged && binding.clientId === client.getInstanceId()) await assertResumeInputAllowed();
-					const result = await withLeasedCodexAppServerClientStartSelectionRetry({
+					const result = await withCodexAppServerClientRequestScope({
 						lease: clientLease,
 						options: clientOptions,
-						run: async (requestClient, requestOptions) => {
+						run: async (requestClient, connectionRequestOptions) => {
+							const requestOptions = () => {
+								const options = connectionRequestOptions();
+								return {
+									...options,
+									withCurrent: async (write) => {
+										await assertCurrent();
+										options.assertCurrent();
+										write();
+									}
+								};
+							};
 							const threadRequest = await buildConversationThreadRequestForClient(requestClient, threadRequestRuntime, serviceTier, requestOptions);
 							if (networkProxyBindingChanged) return await requestClient.request("thread/start", {
 								...threadRequest,
 								developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
 								experimentalRawEvents: true,
-								...params.incognito ? { ephemeral: true } : {}
+								...incognito ? { ephemeral: true } : {}
 							}, requestOptions());
 							return await resumeCodexAppServerThread({
 								client: requestClient,
@@ -653,9 +755,6 @@ async function runBoundTurn(params) {
 								},
 								requestResume: (request) => requestClient.request("thread/resume", request, requestOptions())
 							});
-						},
-						onClientChange: (nextClient) => {
-							client = nextClient;
 						}
 					});
 					const response = networkProxyBindingChanged ? assertCodexThreadStartResponse(result) : result;
@@ -675,12 +774,16 @@ async function runBoundTurn(params) {
 					} else if (networkProxyBindingChanged ? binding.threadId !== threadId : !isSameCodexAppServerThreadOwner(binding, {
 						threadId,
 						clientId: client.getInstanceId()
-					})) await releaseCodexAppServerBindingSubscription(binding, { retainedClientId: client.getInstanceId() });
+					})) await releaseCodexAppServerBindingSubscription(binding, {
+						withCurrent,
+						retainedClientId: client.getInstanceId()
+					});
 					const patch = {
+						...incognito ? { conversationIncognito: true } : {},
 						clientId: client.getInstanceId(),
 						cwd: response.thread.cwd ?? (networkProxyBindingChanged ? workspaceDir : binding.cwd),
 						model: response.model ?? modelSelection?.model ?? binding.model,
-						modelProvider: normalizeCodexAppServerBindingModelProvider({
+						modelProvider: await normalizeCodexAppServerBindingModelProvider({
 							authProfileId: binding.authProfileId,
 							modelProvider: response.modelProvider ?? modelSelection?.modelProvider ?? binding.modelProvider,
 							...agentLookup
@@ -703,8 +806,14 @@ async function runBoundTurn(params) {
 						kind: "patch",
 						threadId: binding.threadId,
 						patch
-					})) throw new Error(networkProxyBindingChanged ? "Codex conversation binding changed while rotating its thread." : "Codex conversation binding changed while resuming on a new client.");
+					}, source)) throw new Error(networkProxyBindingChanged ? "Codex conversation binding changed while rotating its thread." : "Codex conversation binding changed while resuming on a new client.");
 					if (networkProxyBindingChanged) useStickyNetworkProfile = runtime.networkProxy !== void 0;
+				} else if (incognito && !binding.conversationIncognito) {
+					if (!await params.bindingStore.mutate(identity, {
+						kind: "patch",
+						threadId,
+						patch: { conversationIncognito: true }
+					}, source)) throw new Error("Codex conversation binding changed while recording its source lifecycle.");
 				}
 				const turnCollector = createCodexConversationTurnCollector(threadId);
 				turnRoute = getCodexAppServerTurnRouter(client).reserveThread({
@@ -726,7 +835,10 @@ async function runBoundTurn(params) {
 					...modelSelection?.model ? { model: modelSelection.model } : {},
 					personality: CODEX_NATIVE_PERSONALITY_NONE,
 					...serviceTier ? { serviceTier } : {}
-				}, { timeoutMs: runtime.requestTimeoutMs })).turn.id;
+				}, {
+					timeoutMs: runtime.requestTimeoutMs,
+					withCurrent
+				})).turn.id;
 				activeTurnCleanup = trackCodexConversationActiveTurn({
 					identity,
 					client,
@@ -742,7 +854,7 @@ async function runBoundTurn(params) {
 			} catch (error) {
 				if (isCodexAppServerOverloadError(error) && error.method === "thread/resume") throw error;
 				if (error instanceof CodexThreadDirectInputError) {
-					if (params.incognito && ownsNativeSubscription) {
+					if (incognito && ownsNativeSubscription) {
 						if (!await unsubscribeCodexThreadBestEffort(client, {
 							threadId,
 							timeoutMs: 5e3
@@ -759,7 +871,7 @@ async function runBoundTurn(params) {
 						isolatedSubscriptionClient = client;
 					}
 				}
-				if (params.incognito) {
+				if (incognito) {
 					if (await params.bindingStore.mutate(identity, {
 						kind: "clear",
 						threadId
@@ -775,7 +887,7 @@ async function runBoundTurn(params) {
 				activeTurnCleanup();
 				turnRoute?.release();
 				try {
-					if (ownsNativeSubscription && isolatedSubscriptionClient !== client && !params.incognito && isCodexAppServerClientRuntimeLive(client)) {
+					if (ownsNativeSubscription && isolatedSubscriptionClient !== client && !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 () => {