@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/{side-question-BTZAII4l.js → side-question-DLbr2vUU.js}

@@ -1,21 +1,26 @@
-import { $t as isJsonObject, B as isCodexAppServerIndeterminateRequestCancellationError, C as withLeasedCodexAppServerClientStartSelectionRetry, Ct as ensureCodexAppServerClientRuntime, Ft as readRecentCodexRateLimits, L as isCodexAppServerApprovalRequest, Q as assertCodexThreadForkResponse, Wt as resolveCodexAppServerPreparedAuthHandoff, _t as resolveCodexToolAbortTerminalReason, c as getLeasedSharedCodexAppServerClient, dt as resolveDynamicToolCallTimeoutMs, it as readCodexTurn, m as releaseCodexAppServerClientLease, nt as readCodexDynamicToolCallParams, ot as createCodexElicitationResponse, st as handleDynamicToolCallWithTimeout, tt as assertCodexTurnStartResponse } from "./shared-client-DxcfF9KX.js";
-import { C as isCodexPairedNodeRemoteExecPlacementSandbox, E as readCodexPluginConfig, O as resolveOpenClawExecPolicyForCodexAppServer, T as isCodexSandboxExecServerEnabled, d as shouldAutoApproveCodexAppServerApprovals, f as withMcpElicitationsApprovalPolicy, h as resolveCodexModelBackedReviewerPolicyContext, l as hasCodexMcpToolApprovalOverrides, m as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveCodexAppServerHomeScope, w as isCodexRemoteExecPlacementSandbox, y as readCodexRequirementsToml } from "./config-BhmfC1s6.js";
-import { d as sessionBindingIdentity } from "./session-binding-BHuTCRZQ.js";
-import { d as unsubscribeCodexThreadBestEffort, h as isCodexNotificationForTurn, l as retireUnsafeCodexTurnClientBestEffort, s as isCodexAlreadyTerminalInterruptError } from "./attempt-client-cleanup-DYHcRQAa.js";
-import { B as emitCodexNativePreToolUseFailureDiagnostic, Dt as mergeCodexThreadConfigs, E as resolveCodexAppServerRequestModelSelection, I as buildCodexNativeHookRelayConfig, L as buildCodexNativeHookRelayDisabledConfig, N as CODEX_NATIVE_HOOK_RELAY_EVENTS, O as resolveCodexBindingModelProviderFallback, S as resolveCodexWebSearchPlan, St as buildCodexPluginAppsConfigPatchFromPolicyContext, T as resolveCodexAppServerModelProvider, a as readCodexSupportedReasoningEfforts, at as filterCodexDynamicTools, dt as resolveCodexDynamicToolsLoading, o as resolveCodexAppServerReasoningEffort, t as buildCodexTemporalAdditionalContext, v as buildCodexRuntimeThreadConfig, w as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-lifecycle-DAcEJ_Om.js";
-import { s as resolveCodexNativeExecutionBlock } from "./request-DYAI5FQE.js";
-import { i as refreshCodexThreadPolicy, n as CodexThreadPolicyHandoffError, r as assertCodexSupervisionThreadLineage } from "./thread-policy-g4KbJPzp.js";
-import { n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CawQJfUS.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy, t as CODEX_SESSION_PERMISSION_EXEC_MODES } from "./session-permission-policy-DeWVTCMj.js";
-import { n as resolveCodexBindingAppServerConnection, t as requireCodexSupervisionModelSelection } from "./binding-connection-E6uDsPlx.js";
-import { C as filterCodexVisionTools, T as CodexNativeToolLifecycleProjector, _ as resolveCodexMessageToolProvider, a as emitDynamicToolStartedDiagnostic, b as shouldEnableCodexAppServerNativeToolSurface, c as ensureCodexSandboxExecServerEnvironment, g as resolveCodexExternalSandboxPolicyForOpenClawSandbox, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, o as emitDynamicToolTerminalDiagnostic, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, v as resolveCodexNodePlacementToolConstructionPlan, x as shouldRequireCodexSandboxExecServerEnvironment, y as resolveCodexSandboxEnvironmentSelection } from "./dynamic-tools-BU9tmlYm.js";
-import { n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-DW5p4k9w.js";
+import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
+import { b as readCodexRequirementsToml, c as hasCodexMcpToolApprovalOverrides, d as withMcpElicitationsApprovalPolicy, i as resolveCodexAppServerHomeScope, m as resolveCodexModelBackedReviewerPolicyContext, u as shouldAutoApproveCodexAppServerApprovals } from "./config-options-jnIFvwxD.js";
+import { b as isCodexSandboxExecServerEnabled, o as isJsonObject, v as isCodexPairedNodeRemoteExecPlacementSandbox, x as readCodexPluginConfig, y as isCodexRemoteExecPlacementSandbox } from "./protocol-CAAcVIKF.js";
+import { D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, L as resolveCodexToolAbortTerminalReason, S as readCodexDynamicToolCallParams, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, s as isCodexAppServerIndeterminateRequestCancellationError, v as assertCodexThreadForkResponse, x as assertCodexTurnStartResponse } from "./client-BEKu4yDx.js";
+import { n as formatCodexUsageLimitErrorMessage } from "./rate-limits-Bqnx1N4z.js";
+import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-JDfTI4VI.js";
+import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection } from "./binding-connection-QqgcPCgk.js";
+import { F as ensureCodexAppServerClientRuntime, Z as resolveCodexAppServerPreparedAuthHandoff, c as getLeasedSharedCodexAppServerClient, m as releaseCodexAppServerClientLease, q as readRecentCodexRateLimits, x as withLeasedCodexAppServerClientStartSelectionRetry } from "./shared-client-CVhez2Uo.js";
+import { d as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, o as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-D6cR54TV.js";
+import { t as CodexEphemeralTurn } from "./ephemeral-turn-DSwzP8YY.js";
+import { B as emitCodexNativePreToolUseFailureDiagnostic, E as resolveCodexAppServerRequestModelSelection, Et as refreshCodexPluginAppApprovalPolicy, I as buildCodexNativeHookRelayConfig, L as buildCodexNativeHookRelayDisabledConfig, N as CODEX_NATIVE_HOOK_RELAY_EVENTS, O as resolveCodexBindingModelProviderFallback, S as resolveCodexWebSearchPlan, T as resolveCodexAppServerModelProvider, Tt as mergeCodexThreadConfigs, a as readCodexSupportedReasoningEfforts, ct as resolveCodexDynamicToolsLoading, nt as filterCodexDynamicTools, o as resolveCodexAppServerReasoningEffort, t as buildCodexTemporalAdditionalContext, v as buildCodexRuntimeThreadConfig, w as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-lifecycle-D1pzRwHB.js";
+import { o as resolveCodexSessionBinding } from "./session-binding-CKSepwIC.js";
+import { i as refreshCodexThreadPolicy, n as CodexThreadPolicyHandoffError, r as assertCodexSupervisionThreadLineage } from "./thread-policy-D8kI7yAO.js";
+import { t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-BcT66fWy.js";
+import { C as shouldRequireCodexSandboxExecServerEnvironment, S as shouldEnableCodexAppServerNativeToolSurface, T as filterCodexVisionTools, a as emitDynamicToolStartedDiagnostic, b as resolveCodexNodePlacementToolConstructionPlan, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeToolLifecycleProjector, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, o as emitDynamicToolTerminalDiagnostic, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-D-JBoaLt.js";
+import { n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-W4tfK5Y5.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy, t as CODEX_SESSION_PERMISSION_EXEC_MODES } from "./session-permission-policy-B22InTp_.js";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { buildAgentHookContextChannelFields, embeddedAgentLog, formatErrorMessage, registerNativeHookRelay, resolveAgentDir, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveSandboxContext, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { randomUUID } from "node:crypto";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { isDeepStrictEqual } from "node:util";
 import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
-import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { buildAgentHookContextChannelFields, embeddedAgentLog, formatErrorMessage, registerNativeHookRelay, resolveAgentDir as resolveAgentDir$2, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveSandboxContext, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { loadCodexBundleMcpApprovalConfig, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
 //#region extensions/codex/src/app-server/side-question.ts
@@ -50,7 +55,15 @@ async function runCodexAppServerSideQuestion(params, options) {
 		agentId: params.agentId,
 		config: params.cfg
 	});
-	const binding = await options.bindingStore.read(bindingIdentity);
+	const hostCapabilities = params.hostCapabilities;
+	const { binding, assertCurrent } = await resolveCodexSessionBinding({
+		bindingStore: options.bindingStore,
+		identity: bindingIdentity,
+		config: params.cfg,
+		storePath: params.storePath,
+		assertCurrent: hostCapabilities.assertActive,
+		signal: params.opts?.abortSignal
+	});
 	if (!binding?.threadId) throw new Error("Codex /btw needs an active Codex thread. Send a normal message first, then try /btw again.");
 	if (isCodexPairedNodeRemoteExecPlacementSandbox(params.sandbox)) throw new Error("Normal Codex turns are supported on nodes, but /btw is not yet bound to the active placement.");
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
@@ -219,10 +232,9 @@ async function runCodexAppServerSideQuestion(params, options) {
 	};
 	let client = await getLeasedSharedCodexAppServerClient(clientOptions);
 	const clientLease = { client };
-	const collector = new CodexSideQuestionCollector(params, () => readRecentCodexRateLimits(client));
+	let collector;
 	const runAbortController = new AbortController();
 	let nativeToolLifecycleProjector;
-	const pendingNativeToolNotifications = [];
 	const pendingNativePreToolUseFailures = [];
 	let nativePreToolUseFailureFallbackActive = false;
 	let nativeToolRunWasAbortedBeforeCleanup;
@@ -248,26 +260,17 @@ async function runCodexAppServerSideQuestion(params, options) {
 		}
 		flushPendingNativePreToolUseFailures();
 	};
-	const handleNotification = (notification) => {
-		collector.handleNotification(notification);
-		if (notification.method !== "item/started" && notification.method !== "item/completed" && notification.method !== "rawResponseItem/completed" && notification.method !== "turn/completed") return;
-		if (!nativeToolLifecycleProjector) {
-			pendingNativeToolNotifications.push(notification);
-			return;
-		}
-		nativeToolLifecycleProjector.handleNotification(notification);
-	};
-	let removeNotificationHandler = client.addNotificationHandler(handleNotification);
 	const abortFromUpstream = () => runAbortController.abort(params.opts?.abortSignal?.reason ?? "codex_side_question_abort");
 	if (params.opts?.abortSignal?.aborted) abortFromUpstream();
 	else params.opts?.abortSignal?.addEventListener("abort", abortFromUpstream, { once: true });
 	let childThreadId;
+	let pluginAppPolicyContext = binding.pluginAppPolicyContext;
 	let childClient;
 	let policyWriteUncertain = false;
 	let turnId;
 	let sandboxEnvironment;
+	let sandboxDisconnectError;
 	let sandboxEnvironmentClient;
-	let removeRequestHandler;
 	let nativeHookRelay;
 	const activeDynamicToolCalls = /* @__PURE__ */ new Set();
 	const releaseSandboxEnvironment = async () => {
@@ -280,6 +283,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 	const ensureSandboxEnvironment = async (targetClient) => {
 		if (!sandboxEnvironmentRequired || sandboxEnvironmentClient === targetClient) return;
 		await releaseSandboxEnvironment();
+		assertCurrent();
 		const environment = await ensureCodexSandboxExecServerEnvironment({
 			client: targetClient,
 			sandbox: params.sandbox ?? null,
@@ -288,7 +292,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 			timeoutMs: appServer.requestTimeoutMs,
 			signal: runAbortController.signal,
 			onExecutionDisconnect: (error) => {
-				collector.reject(error);
+				sandboxDisconnectError = error;
 				embeddedAgentLog.warn(error.message);
 				runAbortController.abort("client_closed");
 			}
@@ -298,6 +302,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 		sandboxEnvironmentClient = targetClient;
 	};
 	try {
+		assertCurrent();
 		const autoApproveMcpTools = shouldAutoApproveCodexAppServerApprovals(appServer);
 		const projectedMcpServers = loadCodexBundleMcpApprovalConfig({
 			workspaceDir: agentWorkspaceDir,
@@ -337,7 +342,9 @@ async function runCodexAppServerSideQuestion(params, options) {
 			} : {},
 			config: params.cfg
 		});
-		const registerRequestHandler = (targetClient) => targetClient.addRequestHandler(async (request) => {
+		const handleServerRequest = async (request, _scope, requestSignal) => {
+			const signal = AbortSignal.any([requestSignal, runAbortController.signal]);
+			if (signal.aborted) return;
 			if (!childThreadId || !turnId) return;
 			if (request.method === "mcpServer/elicitation/request") {
 				const approvalResult = await routeCodexAppServerElicitationRequest({
@@ -348,8 +355,8 @@ async function runCodexAppServerSideQuestion(params, options) {
 					autoApproveMcpTools,
 					projectedMcpServers,
 					getActiveMcpToolCall: (serverName) => nativeToolLifecycleProjector?.getActiveMcpToolCall(serverName),
-					pluginAppPolicyContext: binding.pluginAppPolicyContext,
-					signal: runAbortController.signal
+					pluginAppPolicyContext,
+					signal
 				});
 				return approvalResult.kind === "handled" ? approvalResult.response : createCodexElicitationResponse("decline", null, { message: "OpenClaw Codex side questions do not support interactive MCP input." });
 			}
@@ -362,7 +369,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 				turnId,
 				nativeHookRelay,
 				autoApprove: autoApproveMcpTools,
-				signal: runAbortController.signal,
+				signal,
 				onNativeToolFailureDisposition: (itemId, disposition) => nativeToolLifecycleProjector?.recordApprovalFailureDisposition(itemId, disposition)
 			});
 			if (request.method !== "item/tool/call") return;
@@ -384,7 +391,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 			const toolCall = handleDynamicToolCallWithTimeout({
 				call,
 				toolBridge,
-				signal: runAbortController.signal,
+				signal,
 				timeoutMs,
 				observeToolTerminal: sideRunParams.observeToolTerminal
 			});
@@ -404,25 +411,20 @@ async function runCodexAppServerSideQuestion(params, options) {
 				emitDynamicToolErrorDiagnostic({
 					...diagnosticContext,
 					durationMs: Math.max(0, Date.now() - toolStartedAt),
-					terminalReason: runAbortController.signal.aborted ? resolveCodexToolAbortTerminalReason(runAbortController.signal) : "failed"
+					terminalReason: signal.aborted ? resolveCodexToolAbortTerminalReason(signal) : "failed"
 				});
 				throw error;
 			} finally {
 				activeDynamicToolCalls.delete(toolCall);
 			}
-		});
-		removeRequestHandler = registerRequestHandler(client);
-		const rebindClientHandlers = (nextClient) => {
-			removeRequestHandler?.();
-			removeNotificationHandler();
+		};
+		const selectClient = (nextClient) => {
 			client = nextClient;
 			ensureCodexAppServerClientRuntime(client, {
 				agentDir: params.agentDir,
 				authProfileId: connection.requestAuthProfileId,
 				config: params.cfg
 			});
-			removeNotificationHandler = client.addNotificationHandler(handleNotification);
-			removeRequestHandler = registerRequestHandler(client);
 		};
 		const serviceTier = binding.serviceTier ?? appServer.serviceTier;
 		const nativeHookRelayEvents = resolveCodexSideNativeHookRelayEvents({
@@ -450,6 +452,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 			loopDetectionPreToolUseRelay: appServer.loopDetectionPreToolUseRelay,
 			signal: runAbortController.signal,
 			hostCapabilities: sideRunParams.hostCapabilities,
+			assertCurrent,
 			onPreToolUseFailure: (failure) => {
 				if (nativePreToolUseFailureFallbackActive) emitNativePreToolUseFailure(failure);
 				else if (nativeToolLifecycleProjector) nativeToolLifecycleProjector.recordPreToolUseFailure(failure, nativeToolRunWasAbortedBeforeCleanup);
@@ -466,27 +469,54 @@ async function runCodexAppServerSideQuestion(params, options) {
 			nativeCodeModeEnabled: nativeToolSurfaceEnabled,
 			nativeCodeModeOnlyEnabled: appServer.codeModeOnly
 		});
-		const pluginAppsConfigPatch = binding.pluginAppPolicyContext ? buildCodexPluginAppsConfigPatchFromPolicyContext(binding.pluginAppPolicyContext) : void 0;
-		const threadConfig = mergeCodexThreadConfigs(nativeHookRelayConfig, runtimeThreadConfig, pluginAppsConfigPatch, appServer.networkProxy?.configPatch) ?? runtimeThreadConfig;
 		const sideThreadId = await withLeasedCodexAppServerClientStartSelectionRetry({
 			lease: clientLease,
 			options: clientOptions,
 			signal: runAbortController.signal,
 			run: async (forkClient, requestOptions) => options.bindingStore.withLease(bindingIdentity, async () => {
+				const assertCurrentBinding = () => {
+					assertCurrent();
+					runAbortController.signal.throwIfAborted();
+					if (!isDeepStrictEqual(options.bindingStore.read(bindingIdentity), binding)) throw new Error("Codex side-question binding changed before fork");
+				};
+				const currentRequestOptions = () => {
+					const scoped = requestOptions();
+					return {
+						...scoped,
+						assertCurrent: () => {
+							scoped.assertCurrent();
+							assertCurrentBinding();
+						}
+					};
+				};
+				assertCurrentBinding();
 				if (binding.connectionScope === "supervision") {
-					params.hostCapabilities.assertActive();
 					const { thread } = await forkClient.request("thread/read", {
 						threadId: binding.threadId,
 						includeTurns: false
-					}, requestOptions());
-					params.hostCapabilities.assertActive();
-					if (!isDeepStrictEqual(await options.bindingStore.read(bindingIdentity), binding)) throw new Error("Codex side-question binding changed before fork");
-					params.hostCapabilities.assertActive();
+					}, currentRequestOptions());
+					assertCurrentBinding();
 					assertCodexSupervisionThreadLineage(binding, thread);
 				}
 				await ensureSandboxEnvironment(forkClient);
-				params.hostCapabilities.assertActive();
+				assertCurrentBinding();
 				const executionCwd = sandboxEnvironment?.cwd ?? cwd;
+				let pluginAppsConfigPatch;
+				if (binding.pluginAppPolicyContext) {
+					const refreshed = await refreshCodexPluginAppApprovalPolicy({
+						policyContext: binding.pluginAppPolicyContext,
+						configCwd: executionCwd,
+						request: (method, requestParams) => {
+							assertCurrentBinding();
+							return forkClient.request(method, requestParams, currentRequestOptions());
+						}
+					}).finally(assertCurrentBinding);
+					pluginAppPolicyContext = refreshed.policyContext;
+					pluginAppsConfigPatch = refreshed.configPatch;
+					for (const diagnostic of refreshed.diagnostics) embeddedAgentLog.warn(diagnostic.message);
+				}
+				assertCurrentBinding();
+				const threadConfig = mergeCodexThreadConfigs(nativeHookRelayConfig, runtimeThreadConfig, pluginAppsConfigPatch, appServer.networkProxy?.configPatch) ?? runtimeThreadConfig;
 				const response = assertCodexThreadForkResponse(await forkCodexSideThread(forkClient, {
 					threadId: binding.threadId,
 					model: modelSelection.model,
@@ -502,14 +532,24 @@ async function runCodexAppServerSideQuestion(params, options) {
 					ephemeral: true,
 					excludeTurns: true,
 					threadSource: "user"
-				}, requestOptions()));
+				}, currentRequestOptions()));
 				if (!response.thread.id.trim() || response.thread.id === binding.threadId) {
 					await retireUnsafeCodexTurnClientBestEffort(forkClient, "unsafe side child identity");
 					throw new Error("Codex side fork returned an unsafe child identity");
 				}
 				childThreadId = response.thread.id;
 				childClient = forkClient;
+				collector = new CodexEphemeralTurn(forkClient, childThreadId, {
+					textMode: "last",
+					onRequest: handleServerRequest,
+					onAssistantMessageStart: async () => {
+						await params.opts?.onAssistantMessageStart?.();
+					},
+					onNotification: (notification) => nativeToolLifecycleProjector?.handleNotification(notification)
+				});
+				if (nativeHookRelay) collector.route.signal.addEventListener("abort", nativeHookRelay.unregister, { once: true });
 				try {
+					assertCurrentBinding();
 					if (supervisionModelSelection && (response.model !== supervisionModelSelection.model || response.modelProvider !== supervisionModelSelection.modelProvider)) throw new Error("Codex supervised side thread did not preserve its native model and provider");
 					const scoped = requestOptions();
 					await refreshCodexThreadPolicy({
@@ -519,7 +559,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 						...scoped,
 						signal: runAbortController.signal,
 						assertCurrent: () => {
-							params.hostCapabilities.assertActive();
+							assertCurrent();
 							runAbortController.signal.throwIfAborted();
 							scoped.assertCurrent();
 						}
@@ -530,14 +570,14 @@ async function runCodexAppServerSideQuestion(params, options) {
 				}
 				return response.thread.id;
 			}),
-			onClientChange: rebindClientHandlers
+			onClientChange: selectClient
 		});
 		const effort = usesSupervisionConnection ? void 0 : resolveCodexAppServerReasoningEffort({
 			thinkLevel: params.resolvedThinkLevel ?? "off",
 			modelId: modelSelection.model,
 			supportedReasoningEfforts: readCodexSupportedReasoningEfforts(params.runtimeModel?.compat)
 		});
-		turnId = assertCodexTurnStartResponse(await client.request("turn/start", {
+		const turnResponse = assertCodexTurnStartResponse(await client.request("turn/start", {
 			threadId: sideThreadId,
 			input: [{
 				type: "text",
@@ -566,51 +606,64 @@ async function runCodexAppServerSideQuestion(params, options) {
 			}
 		}, {
 			timeoutMs: appServer.requestTimeoutMs,
-			signal: runAbortController.signal
+			signal: runAbortController.signal,
+			assertCurrent
 		}).catch((error) => {
 			if (isCodexAppServerIndeterminateRequestCancellationError(error)) turnId = "";
 			throw error;
-		})).turn.id;
-		collector.setTurn(sideThreadId, turnId);
+		}));
+		turnId = turnResponse.turn.id;
+		assertCurrent();
 		nativeToolLifecycleProjector = new CodexNativeToolLifecycleProjector({
 			...sideRunParams,
 			agentId: sessionAgentId
 		}, sideThreadId, turnId, { runAbortSignal: runAbortController.signal });
 		for (const failure of pendingNativePreToolUseFailures) nativeToolLifecycleProjector.recordPreToolUseFailure(failure);
 		pendingNativePreToolUseFailures.length = 0;
-		for (const notification of pendingNativeToolNotifications) nativeToolLifecycleProjector.handleNotification(notification);
-		pendingNativeToolNotifications.length = 0;
-		let text;
+		if (!collector) throw new Error("Codex side thread route was not reserved");
+		let result;
 		try {
-			text = await collector.wait({
+			result = await collector.wait(turnResponse.turn, {
 				signal: runAbortController.signal,
-				timeoutMs: SIDE_QUESTION_COMPLETION_TIMEOUT_MS
+				abortError: () => sandboxDisconnectError ?? /* @__PURE__ */ new Error("Codex /btw was aborted."),
+				timeout: {
+					ms: SIDE_QUESTION_COMPLETION_TIMEOUT_MS,
+					error: new CodexSideQuestionTimeoutError("Codex /btw timed out waiting for the side thread to finish.")
+				}
 			});
 		} catch (error) {
 			if (error instanceof CodexSideQuestionTimeoutError && !runAbortController.signal.aborted) runAbortController.abort(error);
 			throw error;
 		}
-		const trimmed = text.trim();
+		if (result.error || result.turn?.status === "failed") throw formatCodexErrorMessage(result.error ?? { error: {
+			message: result.turn?.error?.message ?? null,
+			codexErrorInfo: result.turn?.error?.codexErrorInfo ?? null
+		} }, readRecentCodexRateLimits(client));
+		if (result.turn?.status === "interrupted") throw new Error("Codex /btw side thread was interrupted.");
+		const trimmed = result.text;
+		assertCurrent();
 		if (!trimmed) throw new Error("Codex /btw completed without an answer.");
-		return { text: trimmed };
+		return {
+			text: trimmed,
+			usage: result.usage
+		};
 	} finally {
 		try {
 			const runWasAbortedBeforeCleanup = runAbortController.signal.aborted;
 			nativeToolRunWasAbortedBeforeCleanup = runWasAbortedBeforeCleanup;
 			params.opts?.abortSignal?.removeEventListener("abort", abortFromUpstream);
-			removeRequestHandler?.();
 			if (!runAbortController.signal.aborted) runAbortController.abort("codex_side_question_finished");
 			await Promise.allSettled(activeDynamicToolCalls);
 			try {
 				await cleanupCodexSideThread(childClient ?? client, {
 					threadId: childThreadId,
 					turnId,
-					interrupt: !collector.completed,
+					interrupt: !collector?.completed,
 					timeoutMs: appServer.requestTimeoutMs
 				});
 			} finally {
 				if (policyWriteUncertain && childClient) await retireUnsafeCodexTurnClientBestEffort(childClient, "side policy handoff");
-				removeNotificationHandler();
+				collector?.route.release();
 				try {
 					nativeToolLifecycleProjector?.finalizeActive(runWasAbortedBeforeCleanup);
 				} finally {
@@ -653,7 +706,7 @@ function registerCodexSideNativeHookRelay(params) {
 		}),
 		signal: params.signal,
 		runBeforeToolCall: params.hostCapabilities.runBeforeToolCall,
-		assertActive: params.hostCapabilities.assertActive,
+		assertActive: params.assertCurrent,
 		onPreToolUseFailure: params.onPreToolUseFailure,
 		command: { timeoutMs: params.options.gatewayTimeoutMs }
 	});
@@ -739,6 +792,13 @@ async function createCodexSideToolBridge(input) {
 			workspaceDir: input.cwd
 		});
 		const toolConstructionPlan = resolveCodexNodePlacementToolConstructionPlan(sandbox, input.nativeToolSurfaceEnabled);
+		const publishSideToolResult = input.params.opts?.onToolResult;
+		const questionPrompt = publishSideToolResult ? {
+			send: async (payload) => {
+				await publishSideToolResult(payload);
+			},
+			...input.params.messageChannel ? { messageChannel: input.params.messageChannel } : {}
+		} : void 0;
 		const allTools = createOpenClawCodingTools({
 			agentId: input.sessionAgentId,
 			requesterThinkingLevel: input.params.resolvedThinkLevel ?? "off",
@@ -748,7 +808,7 @@ async function createCodexSideToolBridge(input) {
 			exec: input.sessionPermissionPolicy && { mode: input.sessionPermissionPolicy.execMode },
 			sessionPermissionPolicy: input.sessionPermissionPolicy,
 			runId: input.runId,
-			agentDir: input.params.agentDir ?? resolveAgentDir(input.params.cfg ?? {}, input.sessionAgentId),
+			agentDir: input.params.agentDir ?? resolveAgentDir$2(input.params.cfg ?? {}, input.sessionAgentId),
 			workspaceDir: input.cwd,
 			spawnWorkspaceDir: resolveAttemptSpawnWorkspaceDir({
 				sandbox,
@@ -794,6 +854,7 @@ async function createCodexSideToolBridge(input) {
 			}).channelId,
 			sandbox,
 			...toolConstructionPlan ? { toolConstructionPlan } : {},
+			...questionPrompt ? { questionPrompt } : {},
 			emitBeforeToolCallDiagnostics: false,
 			modelHasVision: runtimeModel.input?.includes("image") ?? false,
 			requireExplicitMessageTarget: true
@@ -861,14 +922,12 @@ function isMissingCodexParentThreadError(error) {
 }
 async function cleanupCodexSideThread(client, params) {
 	if (!params.threadId) return;
-	if (params.interrupt && params.turnId !== void 0) try {
-		await client.request("turn/interrupt", {
+	if (params.interrupt && params.turnId !== void 0) {
+		if (!await interruptCodexTurnAndWaitBestEffort(client, {
 			threadId: params.threadId,
-			turnId: params.turnId
-		}, { timeoutMs: params.timeoutMs });
-	} catch (error) {
-		if (!isCodexAlreadyTerminalInterruptError(error)) {
-			embeddedAgentLog.debug("codex /btw side thread interrupt cleanup failed", { error });
+			turnId: params.turnId,
+			timeoutMs: params.timeoutMs
+		})) {
 			await retireUnsafeCodexTurnClientBestEffort(client, "side turn interrupt");
 			return;
 		}
@@ -878,121 +937,6 @@ async function cleanupCodexSideThread(client, params) {
 		timeoutMs: params.timeoutMs
 	})) await retireUnsafeCodexTurnClientBestEffort(client, "side thread unsubscribe");
 }
-var CodexSideQuestionCollector = class {
-	constructor(params, readRecentRateLimits) {
-		this.params = params;
-		this.readRecentRateLimits = readRecentRateLimits;
-		this.pendingNotifications = [];
-		this.assistantStarted = false;
-		this.assistantText = "";
-		this.completed = false;
-	}
-	setTurn(threadId, turnId) {
-		this.threadId = threadId;
-		this.turnId = turnId;
-		const pending = this.pendingNotifications;
-		this.pendingNotifications = [];
-		for (const notification of pending) this.handleNotification(notification);
-	}
-	handleNotification(notification) {
-		const params = isJsonObject(notification.params) ? notification.params : void 0;
-		if (!params) return;
-		if (!this.threadId || !this.turnId) {
-			this.pendingNotifications.push(notification);
-			return;
-		}
-		if (!isCodexNotificationForTurn(params, this.threadId, this.turnId)) return;
-		if (notification.method === "item/agentMessage/delta") {
-			this.appendAssistantDelta(params);
-			return;
-		}
-		if (notification.method === "turn/completed") {
-			this.completeFromTurn(params);
-			return;
-		}
-		if (notification.method === "error" && params.willRetry !== true) this.reject(formatCodexErrorMessage(params, this.readRecentRateLimits()));
-	}
-	wait(options) {
-		if (this.terminalError) return Promise.reject(this.terminalError);
-		if (this.completed) return Promise.resolve(this.finalText ?? this.assistantText);
-		if (options.signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Codex /btw was aborted."));
-		return new Promise((resolve, reject) => {
-			let timeout;
-			const cleanup = () => {
-				if (timeout) {
-					clearTimeout(timeout);
-					timeout = void 0;
-				}
-				options.signal?.removeEventListener("abort", abort);
-			};
-			const abort = () => {
-				cleanup();
-				this.settle = void 0;
-				reject(/* @__PURE__ */ new Error("Codex /btw was aborted."));
-			};
-			timeout = setTimeout(() => {
-				cleanup();
-				this.settle = void 0;
-				reject(new CodexSideQuestionTimeoutError("Codex /btw timed out waiting for the side thread to finish."));
-			}, Math.max(100, options.timeoutMs));
-			timeout.unref?.();
-			options.signal?.addEventListener("abort", abort, { once: true });
-			this.settle = {
-				resolve: (text) => {
-					cleanup();
-					resolve(text);
-				},
-				reject: (error) => {
-					cleanup();
-					reject(error);
-				}
-			};
-		});
-	}
-	async appendAssistantDelta(params) {
-		const delta = readStringField(params, "delta") ?? "";
-		if (!delta) return;
-		if (!this.assistantStarted) {
-			this.assistantStarted = true;
-			await this.params.opts?.onAssistantMessageStart?.();
-		}
-		this.assistantText += delta;
-	}
-	completeFromTurn(params) {
-		const turn = readCodexTurn(params.turn);
-		if (!turn || turn.id !== this.turnId) return;
-		this.completed = true;
-		if (turn.status === "failed") {
-			this.reject(formatCodexUsageLimitErrorMessage({
-				message: turn.error?.message,
-				codexErrorInfo: turn.error?.codexErrorInfo,
-				rateLimits: this.readRecentRateLimits()
-			}) ?? turn.error?.message ?? "Codex /btw side thread failed.");
-			return;
-		}
-		if (turn.status === "interrupted") {
-			this.reject("Codex /btw side thread was interrupted.");
-			return;
-		}
-		const finalText = collectAssistantText(turn) || this.assistantText;
-		this.resolve(finalText);
-	}
-	resolve(text) {
-		this.finalText = text;
-		const settle = this.settle;
-		this.settle = void 0;
-		settle?.resolve(text);
-	}
-	reject(error) {
-		this.terminalError = error instanceof Error ? error : new Error(error);
-		const settle = this.settle;
-		this.settle = void 0;
-		settle?.reject(this.terminalError);
-	}
-};
-function collectAssistantText(turn) {
-	return (turn.items ?? []).filter((item) => item.type === "agentMessage" && typeof item.text === "string").map((item) => item.text.trim()).filter(Boolean).at(-1) ?? "";
-}
 function formatCodexErrorMessage(params, rateLimits) {
 	const error = isJsonObject(params.error) ? params.error : void 0;
 	const message = formatCodexUsageLimitErrorMessage({