@openclaw/codex 2026.9.5 → 2026.9.6

package/dist/.setup/{run-attempt-rlA07pUv.mjs → run-attempt-BHu11r7h.mjs}

@@ -1,72 +1,78 @@
-import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-DUle8DLz.mjs";
-import { b as createCodexNativeSubagentHistoryOwner, i as matchesCodexNativeSubagentSubmissionBinding, n as assertCodexBindingMayBeReplaced, p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
-import { n as defineCodexBuildState } from "./build-state-Xx9ybZqa.mjs";
-import { E as readCodexRequirementsToml, h as resolveCodexAppServerHomeDir, l as shouldAutoApproveCodexAppServerApprovals, m as isJsonObject, n as hasCodexMcpToolApprovalOverrides, p as flattenCodexDynamicToolFunctions, u as withMcpElicitationsApprovalPolicy } from "./config-security-BRQ2mgW9.mjs";
+import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-BoRei8Z4.mjs";
+import { i as matchesCodexNativeSubagentSubmissionBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, x as createCodexNativeSubagentHistoryOwner } from "./session-binding-record-BGoz8wOK.mjs";
+import { n as defineCodexBuildState } from "./build-state-C7EnDVgr.mjs";
+import { d as resolveCodexAppServerHomeDir, l as shouldAutoApproveCodexAppServerApprovals, n as hasCodexMcpToolApprovalOverrides, u as withMcpElicitationsApprovalPolicy, y as readCodexRequirementsToml } from "./config-security-BEReZ6go.mjs";
 import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-CcB9iPoq.mjs";
-import { A as isMatchingDynamicToolTerminalDiagnostic, D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, F as toCodexDynamicToolProgressResponse, I as toCodexDynamicToolProtocolResponse, L as resolveCodexToolAbortTerminalReason, M as resolveTerminalDynamicToolBatchAction, N as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, O as hasPendingDynamicToolTerminalDiagnostic, P as shouldReleaseTurnAfterTerminalDynamicTool, S as readCodexDynamicToolCallParams, T as readCodexTurnCompletedNotification, c as isCodexAppServerIndeterminateTransportError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError, w as readCodexTurn, x as assertCodexTurnStartResponse } from "./client-vXs2929Q.mjs";
-import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-BsanJ8QG.mjs";
-import { c as resolveCodexAppServerPreparedApiKeyCacheKey, m as retireSharedCodexAppServerClientIfCurrent, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-QirmgiCo.mjs";
+import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
+import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-BvaRs51b.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-B2mpaI9D.mjs";
+import { h as retireSharedCodexAppServerClientIfCurrent } from "./session-catalog-events-Bj6j94E_.mjs";
 import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.mjs";
-import { o as formatCodexDisplayText } from "./command-formatters-CGEkdawF.mjs";
-import { i as CodexAppServerRpcError, t as withAbortableTimeout } from "./timeout-DZF05XrR.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-Bmqvr9tO.mjs";
+import { n as waitForPromiseOrAbort, o as CodexAppServerRpcError, r as withAbortableTimeout } from "./timeout-C910MdAB.mjs";
 import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.mjs";
-import { D as splitPlanText, E as readNullableString, S as readItemString, T as readNonNegativeInteger, d as matchesCodexSnapshotTurn, f as shouldClearTerminalPresentationForNativeItem, g as extractRawAssistantText, v as readCodexErrorNotificationMessage, x as readItem, y as readCodexProviderRefusal } from "./event-projector-items-DyTQ_XqL.mjs";
+import { C as readItemString, D as readNullableString, E as readNonNegativeInteger, O as splitPlanText, S as readItem, _ as extractRawAssistantText, b as readCodexProviderRefusal, d as matchesCodexSnapshotTurn, f as shouldClearTerminalPresentationForNativeItem, y as readCodexErrorNotificationMessage } from "./event-projector-items-C6L_5ZiT.mjs";
 import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
-import { a as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BOxKP7db.mjs";
-import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-Bm38niE8.mjs";
-import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-CedDWjM-.mjs";
+import { a as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-B2CsSdnV.mjs";
+import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-ThoatDcb.mjs";
+import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-BoTP_mrL.mjs";
 import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-CzM-94NC.mjs";
+import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BrqhSCf9.mjs";
 import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-WqZtZfXN.mjs";
+import { A as getCodexInferenceThread, B as prepareCodexWorkspaceReferences, K as readCodexRateLimitsRevision, P as ensureCodexAppServerClientRuntime, V as protectCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, Z as resolveCodexAppServerPreparedAuthHandoff, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as resolveCodexStartupTimeoutMs, c as getLeasedSharedCodexAppServerClient, et as CodexAppServerStartupError, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, l as getSharedCodexAppServerClient, nt as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, ot as withCodexStartupTimeout, q as readRecentCodexRateLimits, s as createIsolatedCodexAppServerClient, tt as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent, w as CodexThreadClientReplacementError } from "./shared-client-DA4VR4Eb.mjs";
+import { A as isMatchingDynamicToolTerminalDiagnostic, B as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS, C as readCodexDynamicToolCallParams, D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, F as toCodexDynamicToolProgressResponse, I as toCodexDynamicToolProtocolResponse, L as resolveCodexToolAbortTerminalReason, M as resolveTerminalDynamicToolBatchAction, N as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, O as hasPendingDynamicToolTerminalDiagnostic, P as shouldReleaseTurnAfterTerminalDynamicTool, S as assertCodexTurnStartResponse, T as readCodexTurnCompletedNotification, c as isCodexAppServerIndeterminateTransportError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, m as CodexServerRequestResolvedError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-Cs08OXVQ.mjs";
+import { _ as CodexProjectionDiagnostics, d as shouldRetireCodexStartupClient, f as terminateCodexBackgroundTerminals, h as getCodexAppServerTurnRouter, m as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as retireUnsafeCodexTurnClientBestEffort, v as isCodexNotificationForTurn, y as readCodexNotificationThreadId } from "./attempt-client-cleanup-CEv1cKwF.mjs";
 import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-DhLWa_7K.mjs";
-import { A as getCodexInferenceThread, B as prepareCodexWorkspaceReferences, K as readCodexRateLimitsRevision, P as ensureCodexAppServerClientRuntime, V as protectCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, Z as resolveCodexAppServerPreparedAuthHandoff, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as resolveCodexStartupTimeoutMs, c as getLeasedSharedCodexAppServerClient, et as CodexAppServerStartupError, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, l as getSharedCodexAppServerClient, nt as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, ot as withCodexStartupTimeout, q as readRecentCodexRateLimits, s as createIsolatedCodexAppServerClient, tt as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent, w as CodexThreadClientReplacementError } from "./shared-client-BpTtuLQ5.mjs";
-import { _ as CodexProjectionDiagnostics, a as closeCodexStartupClientBestEffort, d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, g as waitForPromiseOrAbort, l as retireUnsafeCodexTurnClientBestEffort, m as getCodexAppServerTurnRouter, o as interruptCodexTurnAndWaitBestEffort, p as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError, u as shouldRetireCodexStartupClient, v as isCodexNotificationForTurn, y as readCodexNotificationThreadId } from "./attempt-client-cleanup-BpYKdTA0.mjs";
-import { a as isPendingOpenClawDynamicToolCompletionNotification, c as readCodexNotificationItem, d as updateActiveTurnItemIds, i as isCodexTurnAbortMarkerNotification, l as readNotificationItemId, o as isRawFunctionToolOutputCompletionNotification, r as codexExecutionToolName, s as isTerminalTurnStatus, t as CodexUsageProjection, u as readRawResponseToolCallId } from "./event-projector-usage-C7Ntzs-f.mjs";
-import { At as shouldBuildCodexPluginThreadConfig, Ct as resolveCodexContinuityProjectionMaxChars, Et as buildCodexPluginThreadConfigTimeoutFallback, G as scheduleCodexNativeHookRelayUnregister, H as emitCodexNativePreToolUseFailureDiagnostic, I as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, J as hasCodexNativeToolCatalog, M as readCodexMcpToolUiVisibility, Ot as mergeCodexThreadConfigs, P as isCodexAppServerProfilerEnabled, R as buildCodexNativeHookRelayConfig, St as resolveCodexContextEngineProjectionReserveTokens, T as buildDeveloperInstructions, Tt as buildCodexPluginThreadConfigInputFingerprint, U as resolveCodexNativeHookRelayEvents, V as createCodexNativeHookRelay, W as resolveCodexNativeHookRelayTtlMs, Y as loadCodexNativeToolCatalog, _ as resolveScheduledCodexAppCreatorCaptureDecision, _t as fitCodexProjectedContextForTurnStart, a as buildTurnStartParams, bt as projectContextEngineAssemblyForCodex, ct as isSystemAgentOnlyCodexDynamicToolAllowlist, d as buildLegacyScheduledCodexAppRecoveryPrompt, dt as resolveCodexDynamicToolsLoadingForRuntime, et as codexDynamicToolsFingerprint, f as buildScheduledCodexAppAuthorityInputFingerprint, ft as buildContextEngineBinding, g as readCurrentCodexScheduledAppPolicy$1, gt as buildCodexContinuityCalibration, h as intersectCodexPluginThreadConfigWithScheduledAuthority, ht as CodexContextAttachmentError, i as buildTurnCollaborationMode, it as filterCodexDynamicTools, j as readCodexMcpToolConnectorId, k as resolveCodexAppServerThreadModelSelection, l as startOrResumeThread, m as captureScheduledCodexAppAuthority, mt as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, p as buildScheduledCodexAppServerConnectionIdentity, t as buildCodexHistoryProvenancePrefix, tt as codexLegacyDynamicToolsFingerprint, u as assertScheduledCodexAppAuthorityRuntime, vt as isCodexDurableCustomMessage, w as resolveCodexWebSearchPlan, wt as buildCodexPluginThreadConfig, xt as resolveCodexContextEngineProjectionMaxChars, yt as neutralizeCodexExplicitMentionSigils, z as buildCodexNativeHookRelayDisabledConfig } from "./thread-lifecycle-Cik28qWn.mjs";
-import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding, s as scopeCodexRunBindingStore } from "./session-binding-_0W_fHRr.mjs";
-import { n as CodexThreadPolicyHandoffError } from "./thread-policy-Cjs4B8xf.mjs";
-import { r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-skomxnIt.mjs";
-import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-D4qp_leP.mjs";
-import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-C0ow7DOc.mjs";
+import { a as isPendingOpenClawDynamicToolCompletionNotification, c as readCodexNotificationItem, d as updateActiveTurnItemIds, i as isCodexTurnAbortMarkerNotification, l as readNotificationItemId, o as isRawFunctionToolOutputCompletionNotification, r as codexExecutionToolName, s as isTerminalTurnStatus, t as CodexUsageProjection, u as readRawResponseToolCallId } from "./event-projector-usage-CnBS8Wa3.mjs";
+import { A as emitCodexNativePreToolUseFailureDiagnostic, C as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, Ct as shouldBuildCodexPluginThreadConfig, D as buildCodexNativeHookRelayDisabledConfig, E as buildCodexNativeHookRelayConfig, K as codexDynamicToolsFingerprint, M as resolveCodexNativeHookRelayTtlMs, N as scheduleCodexNativeHookRelayUnregister, R as hasCodexNativeToolCatalog, T as assertCodexNativeHookRelayAllowed, U as areCodexDynamicToolFingerprintsCompatible, X as fingerprintJsonObject, at as filterCodexDynamicTools, ft as resolveCodexDynamicToolsLoadingForRuntime, gt as buildCodexPluginThreadConfigTimeoutFallback, ht as buildCodexPluginThreadConfigInputFingerprint, j as resolveCodexNativeHookRelayEvents, k as createCodexNativeHookRelay, lt as isSystemAgentOnlyCodexDynamicToolAllowlist, m as buildDeveloperInstructions, mt as buildCodexPluginThreadConfig, p as resolveCodexWebSearchPlan, q as codexLegacyDynamicToolsFingerprint, v as resolveCodexAppServerThreadModelSelection, w as CodexManagedHooksOnlyError, xt as mergeCodexThreadConfigs, z as loadCodexNativeToolCatalog } from "./thread-requests-BLvGkP2R.mjs";
+import { A as resolveCodexContinuityProjectionMaxChars, C as buildCodexContinuityCalibration, D as projectContextEngineAssemblyForCodex, E as neutralizeCodexExplicitMentionSigils, O as resolveCodexContextEngineProjectionMaxChars, S as CodexContextAttachmentError, T as isCodexDurableCustomMessage, _ as readCodexMcpToolUiVisibility, a as buildTurnStartParams, b as isContextEngineBindingCompatible, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, g as readCodexMcpToolConnectorId, h as resolveScheduledCodexAppCreatorCaptureDecision, i as buildTurnCollaborationMode, k as resolveCodexContextEngineProjectionReserveTokens, l as buildLegacyScheduledCodexAppRecoveryPrompt, m as readCurrentCodexScheduledAppPolicy$1, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, p as intersectCodexPluginThreadConfigWithScheduledAuthority, s as startOrResumeThread, t as buildCodexHistoryProvenancePrefix, u as buildScheduledCodexAppAuthorityInputFingerprint, v as isCodexAppServerProfilerEnabled, w as fitCodexProjectedContextForTurnStart, x as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, y as buildContextEngineBinding } from "./thread-lifecycle-B3mfz1TG.mjs";
+import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding } from "./session-binding-Cm0apEbd.mjs";
+import { n as CodexThreadPolicyHandoffError } from "./thread-policy-DGuQsuFC.mjs";
+import { r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DcTtAcXj.mjs";
+import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BtHDBp1G.mjs";
+import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-DUMbefVY.mjs";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.mjs";
 import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
 import { a as shouldKeepCodexSharedAbortOpen, i as runCodexAgentEndHook, n as ensureCodexWorkspaceDirOnce, o as withCodexAppServerFastModeServiceTier, r as estimateCodexAppServerProjectedTurnTokens, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-B7JbY4-F.mjs";
-import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-context-fulhZuz8.mjs";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-DNUR1s0A.mjs";
-import { _ as inferCodexDynamicToolMeta, b as sanitizeCodexToolArguments, v as isCodexCommandBearingToolCall, x as sanitizeCodexToolResponse, y as resolveCodexToolProgressDetailMode } from "./native-subagent-task-ids-DsuOonKv.mjs";
-import { C as shouldRequireCodexSandboxExecServerEnvironment, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeToolLifecycleProjector, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as readBoundedCodexRemoteWorkspaceFile, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-D16lOp67.mjs";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-B8J4Dy-O.mjs";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-CjfzafAZ.mjs";
-import { a as CodexToolProgressProjection, i as CodexToolTranscriptProjection, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-B1hxzIOy.mjs";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-DhurXY0l.mjs";
-import { a as getCodexWorkspaceMemoryToolNames, c as readContextEngineThreadBootstrapProjection, d as resolveCodexDeliveryHintPreservedInputRange, f as resolveContextEngineBootstrapProjectionDecision, i as buildCodexWorkspaceBootstrapContext, l as readMirroredSessionHistoryMessages, n as buildCodexSystemPromptReport, r as buildCodexWatchedSessionsContext, s as prependCodexOpenClawPromptContext, t as buildCodexOpenClawPromptContext, u as renderCodexSkillsCollaborationInstructions } from "./attempt-context-VXVwTCfS.mjs";
+import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-context-D96l9-ew.mjs";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BsruvNrH.mjs";
+import { C as sanitizeCodexToolArguments, S as resolveCodexToolProgressDetailMode, b as inferCodexDynamicToolMeta, w as sanitizeCodexToolResponse, x as isCodexCommandBearingToolCall } from "./native-subagent-task-ids-wb8CKZGN.mjs";
+import { C as shouldEnableCodexAppServerNativeToolSurface, E as mapCodexAppServerRemoteWorkspacePath, S as resolveCodexSandboxEnvironmentSelection, T as shouldWarnCodexDynamicToolBuildStageSummary, _ as formatCodexDynamicToolBuildStageSummary, a as emitDynamicToolStartedDiagnostic, b as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as ensureCodexSandboxExecServerEnvironment, d as hasCodexNativeBackgroundProcesses, f as readBoundedCodexRemoteWorkspaceFile, g as disableCodexPluginThreadConfig, h as createCodexDynamicToolBuildStageTracker, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as buildDynamicTools, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as CodexNativeToolLifecycleProjector, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as CodexNativeProcessAuthority, v as resolveCodexAppServerExecutionCwd, w as shouldRequireCodexSandboxExecServerEnvironment, x as resolveCodexMessageToolProvider, y as resolveCodexAppServerHookChannelId } from "./dynamic-tools-BDXl-8Cw.mjs";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-BfE88FZ5.mjs";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-C0MZzCuP.mjs";
+import { a as CodexToolProgressProjection, i as CodexToolTranscriptProjection, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-D3filLY2.mjs";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BI1QK_98.mjs";
+import { a as getCodexContextFileDisplayBasename, c as normalizeCodexContextFilePath, d as shouldInjectCodexOpenClawPromptContext, i as getCodexContextFileBasename, l as normalizeCodexDynamicToolName, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as getCodexWorkspaceMemoryToolNames, r as buildCodexWorkspaceBootstrapContext, s as isNonEmptyString$1 } from "./attempt-workspace-context-DUVEn_CS.mjs";
 import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-fmwouT5I.mjs";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DsS5buNa.mjs";
-import { asOptionalRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-Ctmo83k_.mjs";
+import { asOptionalRecord, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { resolveAgentConfig, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { isPathStrictlyInside, readFileWindowFully, root } from "openclaw/plugin-sdk/file-access-runtime";
 import { addAbortListener } from "node:events";
 import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { Buffer as Buffer$1 } from "node:buffer";
-import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
 import { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
-import { getSessionEntry, parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
+import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { acknowledgeInternalToolResult } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
 import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { appendSessionYieldContext, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { prepareAgentWorkspaceAttachments } from "openclaw/plugin-sdk/agent-workspace-runtime";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
-import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+import { normalizeMediaReferenceForComparison, saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
+import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 //#region extensions/codex/src/app-server/attempt-preparation-timing.ts
 /** Records startup before the native turn owns inference and tool execution. */
@@ -216,7 +222,10 @@ function createCodexSteeringQueue(params) {
 			for (const item of pendingItems) {
 				if (!isCurrent(item)) continue;
 				try {
-					prepared.push(Object.assign(item, { prepared: await params.prepareMessage(item.text, item) }));
+					prepared.push(Object.assign(item, { prepared: await params.prepareMessage(item.text, item, () => {
+						assertActive();
+						item.assertCurrent();
+					}) }));
 				} catch (error) {
 					if (isCurrent(item)) throw error;
 				}
@@ -447,7 +456,7 @@ var CodexAssistantProjection = class {
 		if (item?.type === "agentMessage" && typeof item.text === "string") {
 			this.rememberAssistantItem(item.id);
 			this.assistantTextByItem.set(item.id, item.text);
-			if (item.text && this.isCommentaryAssistantItem(item.id)) {
+			if (this.isCommentaryAssistantItem(item.id)) {
 				this.emitCommentaryProgress({
 					itemId: item.id,
 					text: item.text,
@@ -481,15 +490,11 @@ var CodexAssistantProjection = class {
 			this.pendingRawCommentaryEchoes -= 1;
 			return;
 		}
-		const text = extractRawAssistantText(item);
 		if (isPendingTerminalAssistantEcho) {
-			const typedItemId = pendingTerminalAssistantEchoItemId;
 			this.pendingRawTerminalAssistantEchoItemId = void 0;
-			if (this.assistantTextByItem.get(typedItemId)?.trim() || !text) return;
-			this.rememberAssistantItem(typedItemId);
-			this.assistantTextByItem.set(typedItemId, text);
 			return;
 		}
+		const text = extractRawAssistantText(item);
 		if (text === void 0 || !text && (phase === "commentary" || activeItemIds.size > 0 || readStringField(item, "type") !== "message")) return;
 		const itemId = rawItemId ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
 		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && activeItemIds.size === 0;
@@ -816,7 +821,7 @@ var CodexGeneratedMediaProjection = class {
 		this.config = config;
 		this.remote = remote;
 		this.itemIds = /* @__PURE__ */ new Set();
-		this.urlsByItemId = /* @__PURE__ */ new Map();
+		this.mediaByItemId = /* @__PURE__ */ new Map();
 		this.gatewayMaterializedItemIds = /* @__PURE__ */ new Set();
 		this.pendingMaterializationsByItemId = /* @__PURE__ */ new Map();
 	}
@@ -826,6 +831,11 @@ var CodexGeneratedMediaProjection = class {
 	async recordNative(item) {
 		if (item?.type !== "imageGeneration") return;
 		this.itemIds.add(item.id);
+		const savedPath = readItemString(item, "savedPath")?.trim();
+		if (savedPath) this.mediaByItemId.set(item.id, {
+			...this.mediaByItemId.get(item.id),
+			savedPath
+		});
 		const result = readItemString(item, "result");
 		if (result) {
 			await this.recordImage({
@@ -836,7 +846,6 @@ var CodexGeneratedMediaProjection = class {
 			});
 			return;
 		}
-		const savedPath = readItemString(item, "savedPath")?.trim();
 		if (savedPath) {
 			if (this.remote?.remoteWorkspaceRoot) {
 				if (!this.remote.readFile) {
@@ -937,22 +946,53 @@ var CodexGeneratedMediaProjection = class {
 			});
 		}
 	}
-	buildToolMediaUrls(params) {
+	projectDelivery(params) {
+		const generatedUrls = /* @__PURE__ */ new Set();
+		const generatedUrlBySource = /* @__PURE__ */ new Map();
+		for (const { mediaUrl, savedPath } of this.mediaByItemId.values()) {
+			if (!mediaUrl) continue;
+			generatedUrls.add(mediaUrl);
+			generatedUrlBySource.set(normalizeMediaReferenceForComparison(mediaUrl), mediaUrl);
+			if (savedPath) generatedUrlBySource.set(normalizeMediaReferenceForComparison(savedPath), mediaUrl);
+		}
+		const sentMediaUrls = new Set(params.messagingToolSentMediaUrls);
+		const generatedUrlsByTarget = /* @__PURE__ */ new Map();
+		for (const delivery of params.confirmedMediaDeliveries ?? []) for (const sourceUrl of delivery.sourceUrls) {
+			const generatedUrl = generatedUrlBySource.get(normalizeMediaReferenceForComparison(sourceUrl));
+			if (!generatedUrl) continue;
+			if (delivery.kind === "sourceReply") generatedUrls.delete(generatedUrl);
+			else {
+				const targetUrls = generatedUrlsByTarget.get(delivery.target) ?? /* @__PURE__ */ new Set();
+				targetUrls.add(generatedUrl);
+				generatedUrlsByTarget.set(delivery.target, targetUrls);
+				sentMediaUrls.add(generatedUrl);
+			}
+		}
 		const mediaUrls = new Set(params.toolMediaUrls?.map((url) => url.trim()).filter(Boolean) ?? []);
-		if ((params.messagingToolSentMediaUrls?.length ?? 0) === 0) for (const mediaUrl of this.urlsByItemId.values()) mediaUrls.add(mediaUrl);
-		return mediaUrls.size > 0 ? [...mediaUrls] : params.toolMediaUrls;
-	}
-	buildHostOwnedMediaUrls(params) {
-		if ((params.messagingToolSentMediaUrls?.length ?? 0) > 0) return;
-		const mediaUrls = [...this.urlsByItemId.values()];
-		return mediaUrls.length > 0 ? mediaUrls : void 0;
+		for (const mediaUrl of generatedUrls) mediaUrls.add(mediaUrl);
+		return {
+			toolMediaUrls: mediaUrls.size > 0 ? [...mediaUrls] : params.toolMediaUrls,
+			hostOwnedToolMediaUrls: generatedUrls.size > 0 ? [...generatedUrls] : void 0,
+			messagingToolSentMediaUrls: [...sentMediaUrls],
+			messagingToolSentTargets: params.messagingToolSentTargets.map((target) => {
+				const aliases = generatedUrlsByTarget.get(target);
+				return aliases ? {
+					...target,
+					mediaUrls: [.../* @__PURE__ */ new Set([...target.mediaUrls ?? [], ...aliases])]
+				} : target;
+			})
+		};
 	}
 	recordUrl(params) {
-		if (this.urlsByItemId.has(params.itemId) && params.replaceExisting !== true) {
+		const existing = this.mediaByItemId.get(params.itemId);
+		if (existing?.mediaUrl && params.replaceExisting !== true) {
 			this.itemIds.add(params.itemId);
 			return;
 		}
-		this.urlsByItemId.set(params.itemId, params.mediaUrl);
+		this.mediaByItemId.set(params.itemId, {
+			...existing,
+			mediaUrl: params.mediaUrl
+		});
 		this.itemIds.add(params.itemId);
 	}
 };
@@ -1220,7 +1260,8 @@ var CodexTerminalFailureProjection = class {
 		this.promptErrorSource = null;
 	}
 	record(params) {
-		this.providerRefusal ??= readCodexProviderRefusal(params.message, params.codexErrorInfo);
+		const refusal = readCodexProviderRefusal(params.message, params.codexErrorInfo, params);
+		if (!this.providerRefusal || refusal?.category === "misalignment" && this.providerRefusal.category === "misalignment" && params.misalignment != null) this.providerRefusal = refusal;
 		if (this.providerRefusal) return;
 		this.promptError = resolveCodexPromptError({
 			message: params.message,
@@ -1422,7 +1463,8 @@ var CodexTurnProjection = class {
 		});
 		const toolMetas = this.toolProgressProjection.toolMetas;
 		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || Boolean(toolTelemetry.successfulCronAdds || toolTelemetry.acceptedSessionSpawns?.length) || this.generatedMediaProjection.hasGeneratedMedia() || this.toolProgressProjection.hasPotentialSideEffects;
-		const sentMediaUrls = new Set(toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
+		const mediaDelivery = this.generatedMediaProjection.projectDelivery(toolTelemetry);
+		const sentMediaUrls = new Set(mediaDelivery.messagingToolSentMediaUrls.map((url) => url.trim()));
 		const toolAutoDeliveryMediaUrls = toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
 		const result = {
 			terminal: attemptTerminal.normalize({
@@ -1446,12 +1488,9 @@ var CodexTurnProjection = class {
 			didDeliverSourceReplyViaMessageTool: toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
 			sourceReplyDelivered: toolTelemetry.sourceReplyDelivered,
 			messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,
-			messagingToolSentMediaUrls: toolTelemetry.messagingToolSentMediaUrls,
-			messagingToolSentTargets: toolTelemetry.messagingToolSentTargets,
+			...mediaDelivery,
 			messagingToolSourceReplyPayloads: toolTelemetry.messagingToolSourceReplyPayloads ?? [],
 			heartbeatToolResponse: toolTelemetry.heartbeatToolResponse,
-			toolMediaUrls: this.generatedMediaProjection.buildToolMediaUrls(toolTelemetry),
-			hostOwnedToolMediaUrls: this.generatedMediaProjection.buildHostOwnedMediaUrls(toolTelemetry),
 			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
 			successfulCronAdds: toolTelemetry.successfulCronAdds,
 			acceptedSessionSpawns: toolTelemetry.acceptedSessionSpawns,
@@ -1482,6 +1521,7 @@ var CodexTurnProjection = class {
 };
 //#endregion
 //#region extensions/codex/src/app-server/event-projector.ts
+const optedOutNotificationMethods = new Set(CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS);
 var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
@@ -1634,23 +1674,23 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 				this.terminalFailure.record({
 					message: readCodexErrorNotificationMessage(params),
 					codexErrorInfo,
+					misalignment: isJsonObject(params.error) ? params.error.misalignment : void 0,
+					nativeThreadId: this.threadId,
+					nativeTurnId: this.turnId,
 					rateLimits: this.options.readRecentRateLimits?.(),
 					fallbackMessage: "codex app-server error",
 					promptErrorSource: compactionFailure ? "compaction" : "prompt"
 				});
 				break;
 			}
-			case "thread/compacted":
 			case "turn/started":
-			case "turn/diff/updated":
 			case "item/reasoning/summaryPartAdded":
 			case "item/commandExecution/terminalInteraction":
-			case "item/fileChange/outputDelta":
 			case "item/fileChange/patchUpdated":
 			case "item/mcpToolCall/progress":
 			case "model/verification":
 			case "turn/moderationMetadata": break;
-			default: this.diagnostics.warnUnknownEvent(notification, params);
+			default: if (!optedOutNotificationMethods.has(notification.method)) this.diagnostics.warnUnknownEvent(notification, params);
 		}
 		if (!this.projectionClosed && [
 			"item/started",
@@ -1834,7 +1874,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		});
 	}
 	async handleTurnCompleted(params) {
-		const turn = readCodexTurn(params.turn);
+		const turn = readCodexTurnCompletedNotification(params)?.turn;
 		if (!turn || turn.id !== this.turnId) return;
 		this.completedTurn = turn;
 		this.eventProjection.endSafetyBuffering();
@@ -1847,6 +1887,9 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 			this.terminalFailure.record({
 				message: turn.error?.message,
 				codexErrorInfo,
+				misalignment: turn.error?.misalignment,
+				nativeThreadId: this.threadId,
+				nativeTurnId: this.turnId,
 				rateLimits: this.options.readRecentRateLimits?.(),
 				fallbackMessage: "codex app-server turn failed",
 				promptErrorSource: compactionFailure ? "compaction" : "prompt"
@@ -1860,7 +1903,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 				this.eventProjection.emitCompactionEnd(itemId, false);
 			}
 		}
-		const turnItems = turn.items ?? [];
+		const turnItems = turn.items;
 		const unsettledAsyncDeliveries = this.asyncDeliveryProjection.pending();
 		const lastToolItem = turnItems.findLast((item) => matchesCodexSnapshotTurn(item, this.turnId) && (item.type === "dynamicToolCall" || shouldClearTerminalPresentationForNativeItem(item)));
 		if (lastToolItem?.type !== "dynamicToolCall") this.nativeToolLifecycleProjector.clearTerminalPresentationForNativeItem(lastToolItem);
@@ -2175,52 +2218,31 @@ const MAX_USER_INPUT_HEADER = 64;
 const MAX_USER_INPUT_TEXT = 4096;
 /** Creates the single per-turn owner for Codex operator input. */
 function createCodexUserInputBridge(params) {
-	const jobs = [];
-	let activeCompletion;
+	const cleanup = new AbortController();
+	const bridgeSignal = params.signal ? AbortSignal.any([params.signal, cleanup.signal]) : cleanup.signal;
+	let completion = Promise.resolve();
 	const inputSessionKey = params.paramsForRun.sessionKey ?? params.paramsForRun.sessionId;
-	const pump = () => {
-		const job = jobs[0];
-		if (activeCompletion || !job) return;
-		activeCompletion = job.run(job.abort.signal).catch((error) => {
-			embeddedAgentLog.warn("failed to bridge codex operator input", { error });
-			return job.abort.signal.aborted ? job.cancelValue : job.failureValue;
-		}).then((value) => {
-			const response = job.abort.signal.aborted ? job.cancelValue : value ?? job.failureValue;
-			job.onResponse?.(response);
-			job.resolve(response);
-		}).finally(() => {
-			if (jobs[0] === job) jobs.shift();
-			activeCompletion = void 0;
-			pump();
-		});
-	};
-	const enqueue = (definition) => {
-		if (params.signal?.aborted) return Promise.resolve(definition.cancelValue);
-		return new Promise((resolve) => {
-			jobs.push({
-				...definition,
-				resolve
-			});
-			pump();
+	const enqueue = (job, requestSignal) => {
+		const signal = requestSignal ? AbortSignal.any([bridgeSignal, requestSignal]) : bridgeSignal;
+		if (signal.aborted) return Promise.resolve(job.cancelValue);
+		return new Promise((resolve, reject) => {
+			const onAbort = () => resolve(job.cancelValue);
+			signal.addEventListener("abort", onAbort, { once: true });
+			completion = completion.then(async () => {
+				signal.removeEventListener("abort", onAbort);
+				if (signal.aborted) return;
+				let value;
+				try {
+					value = await job.run(signal);
+				} catch (error) {
+					if (!signal.aborted) embeddedAgentLog.warn("failed to bridge codex operator input", { error });
+				}
+				const response = signal.aborted ? job.cancelValue : value ?? job.failureValue;
+				if (!(signal.reason instanceof CodexServerRequestResolvedError)) job.onResponse?.(response);
+				resolve(response);
+			}).catch(reject);
 		});
 	};
-	const cancelJob = (job) => {
-		const index = jobs.indexOf(job);
-		if (index < 0) return;
-		if (index === 0) {
-			job.abort.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
-			return;
-		}
-		jobs.splice(index, 1);
-		job.resolve(job.cancelValue);
-	};
-	const cancelPending = async () => {
-		const pendingCompletion = activeCompletion;
-		const queuedJobs = jobs.splice(1);
-		for (const job of queuedJobs) job.resolve(job.cancelValue);
-		jobs[0]?.abort.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
-		await pendingCompletion;
-	};
 	const execute = (input, timeoutMs, signal) => agentHarnessStructuredInput.run({
 		input,
 		sessionKey: inputSessionKey,
@@ -2236,9 +2258,8 @@ function createCodexUserInputBridge(params) {
 			urlIntro: "Codex needs confirmation:"
 		}
 	});
-	params.signal?.addEventListener("abort", () => void cancelPending(), { once: true });
 	return {
-		async handleRequest(request) {
+		async handleRequest(request, requestSignal) {
 			const requestParams = readUserInputParams(request.params);
 			if (!requestParams || requestParams.threadId !== params.threadId || requestParams.turnId !== params.turnId) return;
 			if (requestParams.questions.length === 0) return emptyUserInputResponse();
@@ -2246,8 +2267,6 @@ function createCodexUserInputBridge(params) {
 			const input = compileUserInputQuestions(requestParams.questions);
 			const cancelValue = emptyUserInputResponse();
 			return await enqueue({
-				requestId: request.id,
-				abort: new AbortController(),
 				cancelValue,
 				failureValue: cancelValue,
 				onResponse: requestParams.questions.some((question) => question.isSecret) ? void 0 : (response) => params.onOrdinaryResponse?.({
@@ -2259,39 +2278,27 @@ function createCodexUserInputBridge(params) {
 					const result = await execute(input, timeoutMs, signal);
 					return result.status === "answered" ? gatewayAnswersToCodexResponse(result.answers) : cancelValue;
 				}
-			});
+			}, requestSignal);
 		},
-		async handleElicitationRequest(request) {
+		async handleElicitationRequest(request, requestSignal) {
 			if (readOwnDataString(request.params, "threadId") !== params.threadId) return;
 			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params);
-			if (!agentHarnessStructuredInput.isRecord(requestSnapshot)) {
-				const cancelValue = createCodexElicitationResponse("cancel");
-				return await enqueue({
-					requestId: request.id,
-					abort: new AbortController(),
-					cancelValue,
-					failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
-					run: async (signal) => {
-						const result = await execute({
-							kind: "unsupported",
-							message: "OpenClaw declined a malformed or over-limit MCP elicitation request."
-						}, params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS, signal);
-						return result.status === "unsupported" ? declineElicitation(result.message) : cancelValue;
-					}
-				});
-			}
-			if (readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
+			if (agentHarnessStructuredInput.isRecord(requestSnapshot) && readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
 			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.mjs");
-			const compiled = compileCodexOrdinaryElicitation({
+			const compiled = agentHarnessStructuredInput.isRecord(requestSnapshot) ? compileCodexOrdinaryElicitation({
 				snapshot: requestSnapshot,
 				turnId: params.turnId
-			});
+			}) : {
+				kind: "compiled",
+				input: {
+					kind: "unsupported",
+					message: "OpenClaw declined a malformed or over-limit MCP elicitation request."
+				}
+			};
 			if (compiled.kind === "ignored") return;
 			const cancelValue = createCodexElicitationResponse("cancel");
 			const timeoutMs = params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS;
 			return await enqueue({
-				requestId: request.id,
-				abort: new AbortController(),
 				cancelValue,
 				failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
 				run: async (signal) => {
@@ -2300,20 +2307,15 @@ function createCodexUserInputBridge(params) {
 						const content = compiled.input.kind === "ready" && compiled.input.plan.kind === "url" ? null : result.content;
 						return createCodexElicitationResponse("accept", content);
 					}
-					if (result.status === "declined") return declineElicitation(result.message);
-					if (result.status === "unsupported") return declineElicitation(result.message);
+					if (result.status === "declined" || result.status === "unsupported") return declineElicitation(result.message);
 					return cancelValue;
 				}
-			});
-		},
-		handleNotification(notification) {
-			if (notification.method !== "serverRequest/resolved" || !isJsonObject(notification.params)) return;
-			const requestId = readRequestId(notification.params);
-			if (requestId === void 0 || readOwnDataString(notification.params, "threadId") !== params.threadId) return;
-			const job = jobs.find((candidate) => typeof candidate.requestId === typeof requestId && candidate.requestId === requestId);
-			if (job) cancelJob(job);
+			}, requestSignal);
 		},
-		cancelPending
+		async cancelPending() {
+			cleanup.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
+			await completion;
+		}
 	};
 }
 function compileUserInputQuestions(questions) {
@@ -2394,11 +2396,6 @@ function readOwnDataString(value, key) {
 	const descriptor = Object.getOwnPropertyDescriptor(value, key);
 	return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
 }
-function readRequestId(record) {
-	const descriptor = Object.getOwnPropertyDescriptor(record, "requestId");
-	const value = descriptor && "value" in descriptor ? descriptor.value : void 0;
-	return typeof value === "string" || typeof value === "number" ? value : void 0;
-}
 function gatewayAnswersToCodexResponse(answers) {
 	return { answers: Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [questionId, { answers: values }])) };
 }
@@ -2410,7 +2407,7 @@ function declineElicitation(message) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-active-turn.ts
-function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turn) {
+function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, { turn, upstreamUserText }) {
 	const { prompt, state: resourceState, projectorRef, trajectoryRecorder, pendingNativePreToolUseFailures } = resources;
 	const { context, turnState } = prompt;
 	const { runtime, attemptTools, hookContext } = context;
@@ -2437,6 +2434,31 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			provider: runtimeModelSelection.provider
 		}
 	} : dynamicToolParams;
+	const hostPrepareReplyMedia = params.hostCapabilities.prepareReplyMedia;
+	const remoteWorkspaceRoot = connection.appServer.remoteWorkspaceRoot;
+	const replyMediaClient = resourceState.client;
+	const prepareReplyMedia = hostPrepareReplyMedia && remoteWorkspaceRoot ? async (content, transferSignal) => hostPrepareReplyMedia({
+		...content,
+		workspaceRoot: remoteWorkspaceRoot,
+		signal: runAbortController.signal,
+		readWorkspaceFile: async (relativePath, { maxBytes, signal }) => {
+			connection.assertCurrent();
+			const file = await readBoundedCodexRemoteWorkspaceFile({
+				client: replyMediaClient,
+				path: mapCodexAppServerRemoteWorkspacePath({
+					value: path.resolve(params.workspaceDir, relativePath),
+					localWorkspaceRoot: params.workspaceDir,
+					remoteWorkspaceRoot
+				}),
+				workspaceRoot: remoteWorkspaceRoot,
+				maxBytes,
+				signal: transferSignal ? AbortSignal.any([signal, transferSignal]) : signal,
+				timeoutMs: connection.appServer.requestTimeoutMs
+			});
+			connection.assertCurrent();
+			return Buffer.from(file.dataBase64, "base64");
+		}
+	}) : void 0;
 	const progressCardTool = toolBridge.availableTools.find((tool) => tool.name === "progress_card");
 	let nativePlanUpdateOrdinal = 0;
 	const prepareNativeMcpAppResultDetails = createCodexNativeMcpAppResultDetailsPreparer({
@@ -2448,20 +2470,6 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		eventEmitted: false,
 		needsTerminalSnapshot: false
 	};
-	emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
-	userInputBridgeRef.current = createCodexUserInputBridge({
-		paramsForRun: params,
-		onOrdinaryResponse: (response) => projectorRef.current?.recordUserInputResponse(response),
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		signal: runAbortController.signal
-	});
-	trajectoryRecorder?.recordEvent("prompt.submitted", {
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		prompt: turnState.codexTurnPromptText,
-		imagesCount: params.images?.length ?? 0
-	});
 	projectorRef.current = new CodexAppServerEventProjector({
 		...projectionParams,
 		onAgentEvent: (event) => {
@@ -2478,7 +2486,17 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		asyncUserMessageAllowed: params.disableTools !== true && (params.toolsAllow === void 0 || toolBridge.availableTools.some((tool) => tool.name === "message")),
 		onAsyncDelivery: async (delivery) => {
 			return await codexTranscriptMirrorRuntime.deliverAsyncMessageBestEffort({
-				params: projectionParams,
+				params: prepareReplyMedia && projectionParams.onBlockReply ? {
+					...projectionParams,
+					onBlockReply: async (payload, options) => {
+						const prepared = await prepareReplyMedia({
+							kind: "payload",
+							payload
+						});
+						if (prepared.kind !== "payload") throw new Error("Reply media preparation returned the wrong result kind");
+						await projectionParams.onBlockReply?.(prepared.payload, options);
+					}
+				} : projectionParams,
 				cwd: effectiveCwd,
 				threadId: resourceState.thread.threadId,
 				turnId: activeTurnId,
@@ -2489,9 +2507,9 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		runAbortSignal: runAbortController.signal,
 		remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
 		remoteWorkspaceRequestTimeoutMs: connection.appServer.requestTimeoutMs,
-		readRemoteWorkspaceFile: ({ path, maxBytes, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
+		readRemoteWorkspaceFile: ({ path: remotePath, maxBytes, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
 			client: resourceState.client,
-			path,
+			path: remotePath,
 			maxBytes,
 			signal,
 			timeoutMs
@@ -2513,7 +2531,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			}
 		} } : {},
 		...prepareNativeMcpAppResultDetails ? { prepareNativeMcpAppResultDetails } : {},
-		upstreamUserText: turnState.codexTurnPromptText,
+		upstreamUserText,
 		onContextCompacted: async () => {
 			computerContextEpoch.value += 1;
 			delete computerContextEpoch.frameToolCallId;
@@ -2534,22 +2552,14 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			}
 		}
 	});
-	if (isTerminalTurnStatus(turn.turn.status)) {
-		projectorRef.current.settlement.terminalReceipt = turn.turn;
-		state.terminalTurnNotificationQueued = true;
-		deadlines.beginSettlement(Date.now());
-	}
-	emitLifecycleStart({
-		provider: projectionParams.provider,
-		model: projectionParams.modelId
-	});
 	const activeProjector = projectorRef.current;
-	noteProgress("turn:start");
+	let activationFailed = false;
 	const abortListener = () => {
 		state.abortCleanup = interruptTurn(activeTurnId).then(async (confirmed) => {
-			if (!terminalState.explicitCancellationObserved && !state.permissionChangeRestart && !state.timeout) return;
+			if (!activationFailed && !terminalState.explicitCancellationObserved && !state.permissionChangeRestart && !state.timeout) return;
 			if (!confirmed) throw new Error(state.permissionChangeRestart ? "Permission change could not confirm the previous Codex turn stopped." : "Codex cancellation could not confirm the turn stopped; background terminals may still be running.");
-			await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
+			if (resources.nativeProcessAuthority) await resources.nativeProcessAuthority.cancelTurn(resourceState.client, resourceState.thread.threadId, activeTurnId);
+			else await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
 			if (state.permissionChangeRestart) state.permissionChangeRestart = "confirmed";
 		});
 		state.abortCleanup.then(completeTurn, (error) => {
@@ -2557,32 +2567,18 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			completeTurn();
 		});
 	};
-	runAbortController.signal.addEventListener("abort", abortListener, { once: true });
-	if (runAbortController.signal.aborted) abortListener();
-	for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
 	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
-	const promptMirrorPromise = mirrorPromptAtTurnStartBestEffort({
-		params,
-		agentId: sessionAgentId,
-		notifyUserMessagePersisted,
-		sessionKey: contextSessionKey,
-		cwd: effectiveCwd,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		upstreamUserText: turnState.codexTurnPromptText
-	});
-	const bindProjection = async () => {
+	const bindProjection = async (promptMirrorPromise) => {
 		state.activeLocalProjections += 1;
 		try {
-			await Promise.race([promptMirrorPromise, completion]);
-			if (state.completed) return;
 			if (resourceState.turnRoute) try {
-				await Promise.race([resourceState.turnRoute.bindTurn(activeTurnId), completion]);
+				await Promise.race([resourceState.turnRoute.bindTurn(activeTurnId, { beforeNotifications: promptMirrorPromise }), completion]);
 			} catch (error) {
 				if (!state.terminalTurnNotificationQueued && !runAbortController.signal.aborted) throw error;
 				await Promise.race([resourceState.turnRoute.drain(), completion]);
 				if (!state.completed) throw error;
 			}
+			else await Promise.race([promptMirrorPromise, completion]);
 			if (!state.completed && isTerminalTurnStatus(turn.turn.status)) {
 				if (!isJsonObject(turn.turn)) throw new Error("Codex turn completion payload is not a JSON object");
 				await enqueueNotification({
@@ -2612,6 +2608,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	});
 	const imageContext = {
 		workspaceDir: connection.effectiveWorkspace,
+		agentWorkspaceDir: params.workspaceDir,
 		model: params.model,
 		config: params.config,
 		workspaceOnly,
@@ -2628,7 +2625,18 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		requestTimeoutMs: connection.appServer.requestTimeoutMs,
 		signal: runAbortController.signal,
 		assertActive: assertSteeringActive,
-		prepareMessage: async (text, options) => {
+		prepareMessage: async (text, options, assertMessageCurrent) => {
+			const attachmentNote = await prepareAgentWorkspaceAttachments({
+				workspaceDir: params.workspaceDir,
+				turn: {
+					config: params.config,
+					media: options.media,
+					timeoutMs: params.timeoutMs,
+					abortSignal: runAbortController.signal,
+					userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
+				},
+				assertCurrent: assertMessageCurrent
+			});
 			const result = await detectAndLoadAgentHarnessPromptImages({
 				...imageContext,
 				prompt: text,
@@ -2645,7 +2653,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 				userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
 			});
 			return {
-				input: buildCodexUserInput(text, result.images),
+				input: buildCodexUserInput(attachmentNote ? `${text}\n\n${attachmentNote}` : text, result.images),
 				message: {
 					...source,
 					role: "user",
@@ -2788,27 +2796,72 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		cancel: () => abortExplicitly("cancelled"),
 		abort: () => abortExplicitly("aborted")
 	};
-	if (thread.preserveNativeModel !== true && thread.connectionScope !== "supervision" && !params.expectedSessionRuntimeOwnership) {
-		const route = resourceState.turnRoute;
-		params.registerPluginRuntimeRefreshConsumer?.(() => resourceState.turnRoute === route && route?.signal.aborted === false && turnRuntime.turnIdRef.current === activeTurnId && !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted);
-	}
-	const projectionReady = bindProjection();
-	params.replyOperation?.attachBackend(handle);
-	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
 	const freezeRunTerminalOutcome = () => {
 		if (terminalState.terminalOutcomeFrozen) return;
 		terminalState.terminalOutcomeFrozen = true;
 		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 	};
-	if (!runAbortController.signal.aborted && params.permissionChange && !params.permissionChange.applied()) {
-		state.permissionChangeRestart = "requested";
-		runAbortController.abort("permission-change");
-	}
+	const projectionReady = Promise.resolve().then(async () => {
+		runAbortController.signal.addEventListener("abort", abortListener, { once: true });
+		if (runAbortController.signal.aborted) abortListener();
+		try {
+			emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
+			userInputBridgeRef.current = createCodexUserInputBridge({
+				paramsForRun: params,
+				onOrdinaryResponse: (response) => activeProjector.recordUserInputResponse(response),
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				signal: runAbortController.signal
+			});
+			trajectoryRecorder?.recordEvent("prompt.submitted", {
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				prompt: turnState.codexTurnPromptText,
+				imagesCount: params.images?.length ?? 0
+			});
+			if (isTerminalTurnStatus(turn.turn.status)) {
+				activeProjector.settlement.terminalReceipt = turn.turn;
+				state.terminalTurnNotificationQueued = true;
+				deadlines.beginSettlement(Date.now());
+			}
+			emitLifecycleStart({
+				provider: projectionParams.provider,
+				model: projectionParams.modelId
+			});
+			noteProgress("turn:start");
+			for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
+			if (thread.preserveNativeModel !== true && thread.connectionScope !== "supervision" && !params.expectedSessionRuntimeOwnership) {
+				const route = resourceState.turnRoute;
+				params.registerPluginRuntimeRefreshConsumer?.(() => resourceState.turnRoute === route && route?.signal.aborted === false && turnRuntime.turnIdRef.current === activeTurnId && !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted);
+			}
+			params.replyOperation?.attachBackend(handle);
+			setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
+			if (!runAbortController.signal.aborted && params.permissionChange && !params.permissionChange.applied()) {
+				state.permissionChangeRestart = "requested";
+				runAbortController.abort("permission-change");
+			}
+			await bindProjection(mirrorPromptAtTurnStartBestEffort({
+				params,
+				agentId: sessionAgentId,
+				notifyUserMessagePersisted,
+				sessionKey: contextSessionKey,
+				cwd: effectiveCwd,
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				upstreamUserText
+			}));
+		} catch (error) {
+			activationFailed = true;
+			runAbortController.abort(error);
+			throw error;
+		}
+	});
 	return {
 		activeTurnId,
 		activeProjector,
 		runtimeModelSelection,
 		streamState,
+		prepareReplyMedia,
 		handle,
 		freezeRunTerminalOutcome,
 		notifyUserMessagePersisted,
@@ -2819,7 +2872,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-cleanup.ts
 async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRuntime, activeTurn) {
-	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, releaseSharedClientLeaseAndRetireOneShotClient, releaseSandboxExecEnvironment, runCleanupStep } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, releaseSharedClientLeaseAndRetireOneShotClient, releaseSandboxExecEnvironment, releaseNativeProcessAuthority, retainThreadSubscription, releaseThreadSubscription, runCleanupStep } = resources;
 	const { connection } = prompt.context.runtime;
 	const { params, options, runAbortController, terminalState, bindingStore, bindingIdentity } = connection;
 	const { state, steeringQueueRef, userInputBridgeRef, deadlines } = turnRuntime;
@@ -2859,29 +2912,14 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		await runCleanupStep("codex-trajectory-flush", () => trajectoryRecorder?.flush());
 		const pluginRuntimeRefreshing = state.pluginRuntimeRefreshStop !== void 0 && !runAbortController.signal.aborted && terminalState.settledTurnStatus === "completed";
 		const retainLiveIncognitoThread = !pluginRuntimeRefreshing && (terminalState.settledTurnStatus === "completed" || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
-		const retainLiveThread = (!pluginRuntimeRefreshing && (retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.settledTurnStatus !== void 0 && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint) && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) ? bindingStore.read(bindingIdentity)?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
-			if (bindingStore.read(bindingIdentity)?.threadId !== resourceState.thread.threadId) return false;
-			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
-				release: resourceState.thread.liveThreadOwnership?.release,
-				configFingerprint: resourceState.thread.liveThreadConfigFingerprint,
-				serviceTier: connection.mutable.pluginAppServer.serviceTier,
-				ephemeralPolicy: resourceState.thread.liveThreadEphemeralPolicy
-			});
-		}) : false) || retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy === void 0;
+		const retainLiveThread = !pluginRuntimeRefreshing && (retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.settledTurnStatus !== void 0 && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && !resourceState.thread.ringZeroConfigFingerprint) && await retainThreadSubscription() || retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy === void 0;
 		if (pluginRuntimeRefreshing) await withExclusiveCodexAppServerThread({
 			bindingStore,
 			identity: bindingIdentity,
 			threadId: resourceState.thread.threadId,
 			run: () => bindingStore.withLease(bindingIdentity, async () => {
 				if (!isSameCodexAppServerThreadOwner(bindingStore.read(bindingIdentity), resourceState.thread)) throw new Error("Codex plugin refresh lost its managed thread binding.");
-				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-					threadId: resourceState.thread.threadId,
-					timeoutMs: 5e3,
-					assertCurrent: connection.assertCurrent
-				})) {
-					await closeCodexStartupClientBestEffort(resourceState.client);
-					throw new Error("Plugin reload could not release the previous Codex thread.");
-				}
+				if (!await releaseThreadSubscription(connection.assertCurrent)) throw new Error("Plugin reload could not release the previous Codex thread.");
 				if (!await bindingStore.mutate(bindingIdentity, {
 					kind: "clear",
 					threadId: resourceState.thread.threadId
@@ -2895,11 +2933,7 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			}) : true;
 			if (!retainLiveThread) {
 				if (bindingReleased) {
-					if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-						threadId: resourceState.thread.threadId,
-						timeoutMs: 5e3
-					})) {
-						await closeCodexStartupClientBestEffort(resourceState.client);
+					if (!await releaseThreadSubscription()) {
 						if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-unsubscribe", async () => {
 							throw new Error("Codex one-shot thread unsubscribe was not confirmed");
 						});
@@ -2908,14 +2942,12 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			}
 		}
 	} finally {
+		if (resourceState.thread.liveThreadOwnership) await runCleanupStep("codex-unsettled-subscription", async () => {
+			await releaseThreadSubscription();
+		});
 		await runCleanupStep("codex-user-input-cancel", () => userInputBridgeRef.current?.cancelPending());
 		await runCleanupStep("codex-turn-deadline-clear", () => deadlines.dispose());
-		await runCleanupStep("codex-dynamic-tool-cleanup", async () => {
-			const cleanupReason = terminalState.settledTurnStatus === "completed" ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
-			const cleanups = prompt.context.attemptTools.runCleanups.splice(0);
-			const errors = (await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)))).filter((result) => result.status === "rejected");
-			if (params.oneShotCliRun && errors.length) throw new AggregateError(errors.map((result) => result.reason), "Codex tool cleanup failed");
-		});
+		await prompt.context.attemptTools.disposeTools(terminalState.settledTurnStatus === "completed" ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error");
 		await runCleanupStep("codex-route-release", releaseCurrentRoute);
 		await checkpointCleanup;
 		await runCleanupStep("codex-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
@@ -2931,6 +2963,7 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			await nativeHookRelay.drain();
 		});
 		await runCleanupStep("codex-sandbox-release", releaseSandboxExecEnvironment);
+		await runCleanupStep("codex-native-process-source-release", releaseNativeProcessAuthority);
 		await runCleanupStep("codex-abort-listener-remove", () => {
 			runAbortController.signal.removeEventListener("abort", abortListener);
 		});
@@ -2943,6 +2976,39 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	await state.abortCleanup;
 }
 //#endregion
+//#region extensions/codex/src/app-server/session-binding-scope.ts
+/** Carries one prepared run identity through callers that rederive it from public params. */
+function scopeCodexRunBindingStore(params) {
+	const mapSessionIdentity = (identity) => identity.agentId === params.logicalIdentity.agentId && identity.sessionId === params.logicalIdentity.sessionId && identity.sessionKey?.trim() === params.logicalIdentity.sessionKey?.trim() ? params.physicalIdentity : identity;
+	const mapIdentity = (identity) => identity.kind === "session" ? mapSessionIdentity(identity) : identity;
+	const mapHistoryOwner = (identity, owner) => {
+		const mapped = mapIdentity(identity);
+		return identity.kind === "session" && mapped.kind === "session" && owner.sessionId === identity.sessionId ? {
+			...owner,
+			sessionId: mapped.sessionId
+		} : owner;
+	};
+	const readMany = params.bindingStore.readMany?.bind(params.bindingStore);
+	return {
+		...params.bindingStore,
+		read: (identity) => params.bindingStore.read(mapIdentity(identity)),
+		...readMany ? { readMany: (identities) => readMany(identities.map(mapIdentity)) } : {},
+		readNativeSubagentSubmissions: (identity, owner) => params.bindingStore.readNativeSubagentSubmissions(mapIdentity(identity), mapHistoryOwner(identity, owner)),
+		hasOtherThreadOwner: (threadId, identity) => params.bindingStore.hasOtherThreadOwner(threadId, identity ? mapIdentity(identity) : void 0),
+		mutate: (identity, mutation, assertCurrent) => params.bindingStore.mutate(mapIdentity(identity), mutation.kind === "record-native-subagent-submission" || mutation.kind === "consume-native-subagent-submission" ? {
+			...mutation,
+			owner: mapHistoryOwner(identity, mutation.owner)
+		} : mutation, assertCurrent),
+		prepareSessionGenerationReclaim: (identity) => params.bindingStore.prepareSessionGenerationReclaim(mapSessionIdentity(identity)),
+		adoptSessionGeneration: (identity, expectedPreviousSessionId, assertCurrent) => params.bindingStore.adoptSessionGeneration(mapSessionIdentity(identity), expectedPreviousSessionId, assertCurrent),
+		resetSessionGeneration: (identity) => params.bindingStore.resetSessionGeneration(mapSessionIdentity(identity)),
+		retireSessionGeneration: (identity) => params.bindingStore.retireSessionGeneration(mapSessionIdentity(identity)),
+		withSessionDeletion: (identity, assertCurrent, run) => params.bindingStore.withSessionDeletion(mapSessionIdentity(identity), assertCurrent, run),
+		withThreadArchiveFence: (run) => params.bindingStore.withThreadArchiveFence(run),
+		withLease: (identity, run) => params.bindingStore.withLease(mapIdentity(identity), run)
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/startup-binding.ts
 const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
 const CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS = 2e4;
@@ -2964,7 +3030,6 @@ const CODEX_APP_SERVER_BYTE_UNITS = {
 	tb: 1099511627776,
 	tib: 1099511627776
 };
-const codexSessionRecordCache = /* @__PURE__ */ new Map();
 function parseCodexAppServerByteLimit(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
 	if (typeof value !== "string") return;
@@ -3032,51 +3097,6 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 	}
 	return files;
 }
-async function readCodexSessionRecordForSessionFile(sessionFile) {
-	if (isSqliteSessionFileMarker(sessionFile)) return;
-	const sessionsFile = path.join(path.dirname(sessionFile), "sessions.json");
-	const resolvedSessionFile = path.resolve(sessionFile);
-	let stat;
-	try {
-		stat = await fs.stat(sessionsFile);
-	} catch {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	const cached = codexSessionRecordCache.get(resolvedSessionFile);
-	if (cached?.sessionsFile === sessionsFile && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.record;
-	let store;
-	try {
-		store = JSON.parse(await fs.readFile(sessionsFile, "utf8"));
-	} catch {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	if (!isJsonObject(store)) {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	let found;
-	for (const [sessionKey, record] of Object.entries(store)) {
-		if (!isJsonObject(record) || typeof record.sessionFile !== "string") continue;
-		if (path.resolve(record.sessionFile) !== resolvedSessionFile) continue;
-		found = {
-			sessionKey,
-			...record
-		};
-		break;
-	}
-	codexSessionRecordCache.set(resolvedSessionFile, {
-		sessionsFile,
-		mtimeMs: stat.mtimeMs,
-		size: stat.size,
-		record: found
-	});
-	return found;
-}
-function isSqliteSessionFileMarker(sessionFile) {
-	return parseSqliteSessionFileMarker(sessionFile) !== void 0;
-}
 async function readCodexAppServerRolloutTokenSnapshot(file, openedHandle) {
 	let handle = openedHandle;
 	if (!handle) try {
@@ -3100,12 +3120,8 @@ async function readCodexAppServerRolloutTokenSnapshot(file, openedHandle) {
 			const bytesToRead = Math.min(position, CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES);
 			const nextPosition = position - bytesToRead;
 			const chunk = Buffer.allocUnsafe(bytesToRead);
-			let bytesRead = 0;
-			while (bytesRead < bytesToRead) {
-				const result = await handle.read(chunk, bytesRead, bytesToRead - bytesRead, nextPosition + bytesRead);
-				if (result.bytesRead === 0) return snapshot;
-				bytesRead += result.bytesRead;
-			}
+			const bytesRead = await readFileWindowFully(handle, chunk, nextPosition);
+			if (bytesRead < bytesToRead) return snapshot;
 			let lineEnd = bytesRead;
 			while (lineEnd > 0) {
 				const index = chunk.lastIndexOf(10, lineEnd - 1);
@@ -3148,9 +3164,6 @@ function readCodexAppServerRolloutTokenSnapshotLine(line) {
 function readCompactionConfig(config) {
 	return isJsonObject(config?.agents?.defaults?.compaction) ? config.agents.defaults.compaction : void 0;
 }
-function resolveCodexAppServerNativeThreadReserveTokens(_config) {
-	return CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
-}
 function resolveCodexAppServerNativeThreadTokenFuse(params) {
 	const projectedTurnTokens = typeof params.projectedTurnTokens === "number" && Number.isFinite(params.projectedTurnTokens) && params.projectedTurnTokens > 0 ? Math.floor(params.projectedTurnTokens) : 0;
 	const contextWindow = params.modelContextWindow ?? CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS;
@@ -3163,11 +3176,6 @@ function maxFiniteNumber(values) {
 	if (nums.length === 0) return;
 	return Math.max(...nums);
 }
-function minFiniteNumber(values) {
-	const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value));
-	if (nums.length === 0) return;
-	return Math.min(...nums);
-}
 function hasContextEngineThreadBootstrapProjection(binding) {
 	return binding.contextEngine?.projection?.mode === "thread_bootstrap";
 }
@@ -3176,7 +3184,6 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const binding = params.binding;
 	if (!binding?.threadId) return { binding };
 	if (binding.connectionScope === "supervision") return { binding };
-	const sessionRecord = await readCodexSessionRecordForSessionFile(params.sessionFile);
 	const rolloutFiles = await listCodexAppServerRolloutFilesForThread(params.agentDir, binding.threadId, params.codexHome, binding.rolloutPath);
 	const maxBytes = parseCodexAppServerByteLimit(readCompactionConfig(params.config)?.maxActiveTranscriptBytes);
 	if (maxBytes !== void 0 && params.contextEngineActive === true && hasContextEngineThreadBootstrapProjection(binding)) embeddedAgentLog.debug("codex app-server deferring native transcript byte guard for context-engine thread bootstrap", {
@@ -3210,25 +3217,19 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const nativeTokenSnapshots = await Promise.all(rolloutFiles.map(async (file) => readCodexAppServerRolloutTokenSnapshot(file.path, file.handle)));
 	const nativeTokens = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.totalTokens));
 	const nativeModelContextWindow = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.modelContextWindow));
-	const sessionModelContextWindow = typeof sessionRecord?.contextTokens === "number" && Number.isFinite(sessionRecord.contextTokens) && sessionRecord.contextTokens > 0 ? Math.floor(sessionRecord.contextTokens) : void 0;
-	const reserveTokens = resolveCodexAppServerNativeThreadReserveTokens(params.config);
+	const reserveTokens = CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
 	const maxTokens = resolveCodexAppServerNativeThreadTokenFuse({
-		modelContextWindow: minFiniteNumber([nativeModelContextWindow, sessionModelContextWindow]),
+		modelContextWindow: nativeModelContextWindow,
 		reserveTokens,
 		projectedTurnTokens: params.projectedTurnTokens
 	});
-	const sessionTokens = sessionRecord?.totalTokensFresh === true && sessionRecord.totalTokensVersion === 1 && typeof sessionRecord?.totalTokens === "number" && Number.isFinite(sessionRecord.totalTokens) ? sessionRecord.totalTokens : void 0;
-	const tokenCount = maxFiniteNumber([sessionTokens, nativeTokens]);
-	if (tokenCount !== void 0 && tokenCount >= maxTokens) {
+	if (nativeTokens !== void 0 && nativeTokens >= maxTokens) {
 		assertCodexBindingMayBeReplaced(binding, "rotating a full native context", params.expectedSessionRuntimeOwnership);
 		embeddedAgentLog.warn("codex app-server native transcript exceeded active token limit; starting a fresh thread", {
 			threadId: binding.threadId,
 			maxTokens,
-			sessionKey: sessionRecord?.sessionKey,
-			sessionTokens,
 			nativeTokens,
 			nativeModelContextWindow,
-			sessionModelContextWindow,
 			reserveTokens,
 			projectedTurnTokens: params.projectedTurnTokens
 		});
@@ -3238,10 +3239,9 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 		}, params.assertCurrent);
 		return { binding: void 0 };
 	}
-	const startupContextTokens = nativeModelContextWindow ?? sessionModelContextWindow;
 	return {
 		binding,
-		...startupContextTokens ? { startupContextTokens } : {}
+		...nativeModelContextWindow ? { startupContextTokens: nativeModelContextWindow } : {}
 	};
 }
 //#endregion
@@ -3517,9 +3517,8 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			binding: startupBinding,
 			bindingStore,
 			identity: bindingIdentity,
-			sessionFile: params.sessionFile,
 			agentDir,
-			codexHome: appServer.start.env?.CODEX_HOME,
+			codexHome: appServer.start.codexHome ?? appServer.start.env?.CODEX_HOME,
 			config: params.config,
 			contextEngineActive: Boolean(activeContextEngine),
 			expectedSessionRuntimeOwnership: params.expectedSessionRuntimeOwnership
@@ -3614,6 +3613,314 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/attempt-context.ts
+/**
+* Builds Codex app-server prompt context,
+* system-prompt reports, and context-engine projection decisions.
+*/
+/** Reads mirrored Codex session history for harness hooks. */
+async function readMirroredSessionHistoryMessages(params) {
+	const { admission, signal, contextTokenBudget, ...target } = params;
+	const messages = await readCodexMirroredSessionHistoryMessages(target, admission, signal, contextTokenBudget);
+	if (!messages) embeddedAgentLog.warn("failed to read mirrored session history for codex harness hooks", { sessionFile: params.sessionFile });
+	return messages;
+}
+/** Reads a valid thread-bootstrap projection request from context-engine output. */
+function readContextEngineThreadBootstrapProjection(projection) {
+	if (projection?.mode !== "thread_bootstrap") return;
+	const epoch = projection.epoch?.trim();
+	if (!epoch) {
+		embeddedAgentLog.warn("context engine requested Codex thread-bootstrap projection without an epoch; using per-turn projection");
+		return;
+	}
+	const fingerprint = projection.fingerprint?.trim();
+	return {
+		mode: "thread_bootstrap",
+		epoch,
+		...fingerprint ? { fingerprint } : {}
+	};
+}
+/**
+* Decides whether an existing Codex thread can reuse its context-engine
+* bootstrap projection or must be reprojected.
+*/
+function resolveContextEngineBootstrapProjectionDecision(params) {
+	const bindingProjection = params.startupBinding?.contextEngine?.projection;
+	if (!params.startupBinding?.threadId || !bindingProjection) return {
+		project: true,
+		reason: !params.startupBinding?.threadId ? "missing-thread-binding" : "missing-projection-binding"
+	};
+	if (!params.expectedBinding || !isContextEngineBindingCompatible(params.startupBinding.contextEngine, params.expectedBinding)) return {
+		project: true,
+		reason: "context-engine-binding-mismatch"
+	};
+	if (!areCodexDynamicToolFingerprintsCompatible({
+		previous: params.startupBinding.dynamicToolsFingerprint,
+		next: params.dynamicToolsFingerprint,
+		nextLegacy: params.legacyDynamicToolsFingerprint
+	})) return {
+		project: true,
+		reason: "dynamic-tools-mismatch"
+	};
+	return bindingProjection.mode !== "thread_bootstrap" || bindingProjection.epoch !== params.projection.epoch || bindingProjection.fingerprint !== params.projection.fingerprint ? {
+		project: true,
+		reason: "projection-mismatch"
+	} : {
+		project: false,
+		reason: "matching-thread-bootstrap-binding"
+	};
+}
+/**
+* Builds the prompt-size, bootstrap-file, skill, and tool-schema accounting
+* report for a Codex run.
+*/
+function buildCodexSystemPromptReport(params) {
+	const toolEntries = flattenCodexDynamicToolFunctions(params.tools).map(buildCodexToolReportEntry);
+	const schemaChars = toolEntries.reduce((sum, tool) => sum + tool.schemaChars, 0);
+	const skillsPrompt = params.skillsPrompt.trim();
+	const bootstrapMaxChars = readPositiveNumber(params.attempt.config?.agents?.defaults?.bootstrapMaxChars);
+	const bootstrapTotalMaxChars = readPositiveNumber(params.attempt.config?.agents?.defaults?.bootstrapTotalMaxChars);
+	return {
+		source: "run",
+		generatedAt: Date.now(),
+		sessionId: params.attempt.sessionId,
+		sessionKey: params.sessionKey,
+		provider: params.attempt.provider,
+		model: params.attempt.modelId,
+		workspaceDir: params.workspaceDir,
+		...bootstrapMaxChars ? { bootstrapMaxChars } : {},
+		...bootstrapTotalMaxChars ? { bootstrapTotalMaxChars } : {},
+		systemPrompt: {
+			chars: params.developerInstructions.length,
+			projectContextChars: 0,
+			nonProjectContextChars: params.developerInstructions.length,
+			hash: sha256Text(params.developerInstructions)
+		},
+		injectedWorkspaceFiles: buildCodexBootstrapInjectionStats({
+			bootstrapFiles: params.workspaceBootstrapContext.bootstrapFiles,
+			injectedFiles: params.workspaceBootstrapContext.promptContextFiles ?? [],
+			omitReferenceFiles: params.omitWorkspaceReferences,
+			developerInstructionFiles: [...params.workspaceBootstrapContext.threadDeveloperInstructionFiles ?? [], ...params.workspaceBootstrapContext.turnScopedDeveloperInstructionFiles ?? []],
+			memoryToolRoutedBootstrapFiles: params.workspaceBootstrapContext.memoryToolRoutedBootstrapFiles ?? [],
+			memoryToolRouted: params.workspaceBootstrapContext.memoryToolRouted === true
+		}),
+		skills: {
+			promptChars: skillsPrompt.length,
+			hash: sha256Text(skillsPrompt),
+			entries: buildCodexSkillReportEntries(skillsPrompt)
+		},
+		tools: {
+			listChars: 0,
+			schemaChars,
+			entries: toolEntries
+		}
+	};
+}
+function buildCodexSkillReportEntries(skillsPrompt) {
+	if (!skillsPrompt) return [];
+	return Array.from(skillsPrompt.matchAll(/<skill>[\s\S]*?<\/skill>/gi)).map((match) => match[0] ?? "").map((block) => ({
+		name: block.match(/<name>\s*([^<]+?)\s*<\/name>/i)?.[1]?.trim() || "(unknown)",
+		blockChars: block.length
+	})).filter((entry) => entry.blockChars > 0);
+}
+function buildCodexToolReportEntry(tool) {
+	const summary = tool.description.trim();
+	if (tool.deferLoading === true) return {
+		name: tool.name,
+		summaryChars: summary.length,
+		summaryHash: sha256Text(summary),
+		schemaChars: 0,
+		schemaHash: stableJsonHash(null),
+		propertiesCount: null
+	};
+	return {
+		name: tool.name,
+		summaryChars: summary.length,
+		summaryHash: sha256Text(summary),
+		...buildCodexToolSchemaStats(tool.inputSchema)
+	};
+}
+function buildCodexToolSchemaStats(schema) {
+	const schemaChars = (() => {
+		try {
+			return JSON.stringify(schema).length;
+		} catch {
+			return 0;
+		}
+	})();
+	const properties = isJsonObject(schema) && isJsonObject(schema.properties) ? schema.properties : null;
+	return {
+		schemaChars,
+		schemaHash: stableJsonHash(schema),
+		propertiesCount: properties ? Object.keys(properties).length : null
+	};
+}
+function sha256Text(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function normalizeForStableHash(value) {
+	if (Array.isArray(value)) return value.map((entry) => normalizeForStableHash(entry));
+	if (value && typeof value === "object") {
+		const record = value;
+		return Object.fromEntries(Object.keys(record).toSorted((left, right) => left.localeCompare(right)).map((key) => [key, normalizeForStableHash(record[key])]));
+	}
+	return value;
+}
+function stableJsonHash(value) {
+	return sha256Text(JSON.stringify(normalizeForStableHash(value)) ?? "null");
+}
+function buildCodexBootstrapInjectionStats(params) {
+	const injectedIndex = indexCodexContextFileContent(params.injectedFiles);
+	const developerInstructionIndex = indexCodexContextFileContent(params.developerInstructionFiles ?? []);
+	const memoryToolRoutedPaths = new Set((params.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonBlankString(file.path)).filter(isNonEmptyString$1).map(normalizeCodexContextFilePath));
+	return params.bootstrapFiles.map((file) => {
+		const fileName = readNonBlankString(file.name);
+		const pathValue = readNonBlankString(file.path) ?? fileName ?? "";
+		const displayName = (fileName ?? getCodexContextFileDisplayBasename(pathValue)) || pathValue;
+		const baseName = getCodexContextFileBasename(pathValue || fileName || "");
+		const rawChars = file.missing ? 0 : (file.content ?? "").trimEnd().length;
+		const memoryToolRoutedFile = baseName === "memory.md" && params.memoryToolRouted === true && memoryToolRoutedPaths.has(normalizeCodexContextFilePath(pathValue));
+		const injected = memoryToolRoutedFile ? void 0 : readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) ?? readCodexIndexedContextFileContent(developerInstructionIndex, pathValue, fileName);
+		if (!file.missing && injected === void 0 && CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName)) return {
+			name: displayName,
+			path: pathValue,
+			missing: false,
+			rawChars,
+			injectionStatus: "native_unverified",
+			injectedChars: null,
+			truncated: null
+		};
+		const omitted = memoryToolRoutedFile || params.omitReferenceFiles && readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) !== void 0;
+		const injectedChars = omitted ? 0 : injected?.length ?? 0;
+		const truncated = omitted ? false : !file.missing && injectedChars < rawChars;
+		return {
+			name: displayName,
+			path: pathValue,
+			missing: file.missing,
+			rawChars,
+			injectedChars,
+			truncated
+		};
+	});
+}
+function indexCodexContextFileContent(files) {
+	const byPath = /* @__PURE__ */ new Map();
+	const byBaseName = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const pathValue = readNonBlankString(file.path);
+		if (!pathValue) continue;
+		if (!byPath.has(pathValue)) byPath.set(pathValue, file.content);
+		const baseName = getCodexContextFileBasename(pathValue);
+		if (baseName && !byBaseName.has(baseName)) byBaseName.set(baseName, file.content);
+	}
+	return {
+		byPath,
+		byBaseName
+	};
+}
+function readCodexIndexedContextFileContent(index, pathValue, fileName) {
+	const pathContent = index.byPath.get(pathValue);
+	if (pathContent !== void 0) return pathContent;
+	if (fileName) {
+		const nameContent = index.byPath.get(fileName);
+		if (nameContent !== void 0) return nameContent;
+	}
+	const baseName = getCodexContextFileBasename(fileName ?? pathValue);
+	return baseName ? index.byBaseName.get(baseName) : void 0;
+}
+function readPositiveNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+/**
+* Builds OpenClaw-provided workspace prompt context for the current Codex turn.
+*/
+function buildCodexOpenClawPromptContext(params) {
+	if (!shouldInjectCodexOpenClawPromptContext(params.params)) return;
+	const sections = [params.workspacePromptContext?.trim() ? [
+		"## OpenClaw Workspace Context",
+		"",
+		params.workspacePromptContext.trim()
+	].join("\n") : void 0, params.watchedSessionsContext?.trim() || void 0].filter(isNonEmptyString$1);
+	if (sections.length === 0) return;
+	return [
+		"OpenClaw runtime context for this turn:",
+		"Treat this OpenClaw-provided context as supporting project/user reference for the current request.",
+		"",
+		...sections
+	].join("\n");
+}
+/**
+* Renders the watched-sessions block for the Codex per-turn runtime context.
+* Codex builds its own instruction layers, so the embedded prompt's Watched
+* Sessions section must be re-surfaced here or Codex-backed main sessions
+* keep refusing cross-session questions (openclaw#114797).
+*/
+function buildCodexWatchedSessionsContext(params) {
+	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
+	return buildWatchedSessionsHarnessContext({
+		config: params.attempt.config,
+		sessionKey: params.sessionKey,
+		sandboxed: params.sandboxed,
+		toolNames: flattenCodexDynamicToolFunctions(params.dynamicTools).map((tool) => normalizeCodexDynamicToolName(tool.name))
+	});
+}
+/** Renders loaded OpenClaw skill prompts as Codex collaboration instructions. */
+function renderCodexSkillsCollaborationInstructions(params) {
+	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
+	return params.skillsPrompt?.trim() ? [
+		"## OpenClaw Skills",
+		"",
+		params.skillsPrompt.trim()
+	].join("\n") : void 0;
+}
+/**
+* Prepends OpenClaw context while preserving leading delivery metadata as
+* routing guidance instead of user request text.
+*/
+function prependCodexOpenClawPromptContext(prompt, context, options = {}) {
+	const { deliveryHint, prompt: promptWithoutDeliveryHint } = splitLeadingCodexDeliveryHint(prompt);
+	if (!context?.trim() && (!deliveryHint || options.preservePromptWithoutContext)) return prompt;
+	const promptSection = promptWithoutDeliveryHint.startsWith("OpenClaw assembled context for this turn:") ? promptWithoutDeliveryHint : ["Current user request:", promptWithoutDeliveryHint].join("\n");
+	const deliverySection = deliveryHint ? [
+		"OpenClaw delivery metadata:",
+		"This delivery metadata is runtime routing guidance, not the user's request.",
+		deliveryHint
+	].join("\n") : void 0;
+	return [
+		context?.trim(),
+		deliverySection,
+		promptSection
+	].filter(Boolean).join("\n\n");
+}
+/**
+* Maps the surviving user-request portion of an input range after delivery
+* metadata has been relocated before the request.
+*/
+function resolveCodexDeliveryHintPreservedInputRange(params) {
+	const { prompt, promptInputRange, decoratedPrompt } = params;
+	const { deliveryHint, prompt: promptWithoutDeliveryHint } = splitLeadingCodexDeliveryHint(prompt);
+	if (!deliveryHint || !promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !decoratedPrompt.endsWith(promptWithoutDeliveryHint)) return;
+	const promptWithoutDeliveryHintStart = prompt.length - promptWithoutDeliveryHint.length;
+	const inputStart = Math.max(promptInputRange.start, promptWithoutDeliveryHintStart);
+	const inputEnd = Math.max(inputStart, Math.min(promptInputRange.end, promptWithoutDeliveryHint.length + promptWithoutDeliveryHintStart));
+	const decoratedPromptSuffixStart = decoratedPrompt.length - promptWithoutDeliveryHint.length;
+	const requestHeader = "Current user request:\n";
+	const requestHeaderStart = decoratedPromptSuffixStart - 22;
+	return {
+		start: inputStart === promptWithoutDeliveryHintStart && decoratedPrompt.slice(requestHeaderStart, decoratedPromptSuffixStart) === requestHeader ? requestHeaderStart : decoratedPromptSuffixStart + inputStart - promptWithoutDeliveryHintStart,
+		end: decoratedPromptSuffixStart + inputEnd - promptWithoutDeliveryHintStart
+	};
+}
+function splitLeadingCodexDeliveryHint(prompt) {
+	const trimmedStart = prompt.trimStart();
+	const matchedHint = MESSAGE_TOOL_DELIVERY_HINTS.find((hint) => trimmedStart.startsWith(hint));
+	if (!matchedHint) return { prompt };
+	return {
+		deliveryHint: matchedHint,
+		prompt: trimmedStart.slice(matchedHint.length).replace(/^\s*\n/, "").trimStart()
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-state.ts
 async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields, expected) {
 	const currentBinding = bindingStore.read(identity);
@@ -3749,6 +4056,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	const memoryToolNames = getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs);
 	const workspaceBootstrapContext = await buildCodexWorkspaceBootstrapContext({
 		params: runtimeParams,
+		agentWorkspaceDeveloperInstructions: connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions,
 		resolvedWorkspace: runtimeParams.bootstrapWorkspaceDir ?? resolvedWorkspace,
 		executionWorkspace: resolvedWorkspace,
 		effectiveWorkspace,
@@ -3758,7 +4066,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		ringZeroActive: isHostScopedAgentToolActive("openclaw") && isSystemAgentOnlyCodexDynamicToolAllowlist(runtimeParams.toolsAllow),
 		sandboxed: sandbox?.enabled === true
 	});
-	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions ? connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions ?? workspaceBootstrapContext.threadDeveloperInstructions : void 0;
+	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions;
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
 	const watchedSessionsContext = buildCodexWatchedSessionsContext({
 		attempt: runtimeParams,
@@ -3995,6 +4303,28 @@ function isInvalidCodexImagePayloadError(message) {
 	return /\b(?:invalid|malformed)\b[\s\S]{0,120}\b(?:image|image url|base64)\b/iu.test(normalizedMessage) || /\b(?:image|image url|base64)\b[\s\S]{0,120}\b(?:invalid|malformed)\b/iu.test(normalizedMessage);
 }
 //#endregion
+//#region extensions/codex/src/app-server/run-attempt-reply-media.ts
+async function settleReplyMedia(activeTurn, result, { state, settlementExpired }, signal) {
+	if (activeTurn.prepareReplyMedia && !signal.aborted) {
+		state.pendingSettlementStage = "reply/media";
+		const transferAbort = new AbortController();
+		settlementExpired.then(() => transferAbort.abort(/* @__PURE__ */ new Error("Reply media settlement expired")));
+		try {
+			const prepared = await activeTurn.prepareReplyMedia({
+				kind: "attempt",
+				attempt: result
+			}, transferAbort.signal);
+			if (prepared.kind !== "attempt") throw new Error("Reply media preparation returned the wrong result kind");
+			result.preparedReplyMedia = prepared.preparedMedia;
+		} catch (error) {
+			if (!signal.aborted) throw error;
+		} finally {
+			transferAbort.abort();
+		}
+	}
+	if (signal.aborted) await state.abortCleanup;
+}
+//#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
 /** Creates a trajectory recorder when the host exposes its capture capability. */
 function createCodexTrajectoryRecorder(params) {
@@ -4296,7 +4626,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 					degradedSettlement
 				]);
 			}
-			if (runAbortController.signal.aborted) await state.abortCleanup;
+			await settleReplyMedia(activeTurn, result, turnRuntime, runAbortController.signal);
 		} finally {
 			closeSettlement();
 		}
@@ -4696,7 +5026,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const { attemptTools, runtime } = context;
 	const { appServer, runAbortController } = runtime.connection;
 	const { allocateCodexToolOutcomeOrdinal } = attemptTools;
-	const { state, turnIdRef, userInputBridgeRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, openClawDynamicToolExecutions, completeTurn, noteProgress, deadlines } = turnRuntime;
+	const { state, turnIdRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, openClawDynamicToolExecutions, completeTurn, noteProgress, deadlines } = turnRuntime;
 	const { scheduleTerminalDynamicToolReleaseCheck, reportExecutionNotification, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const pendingNativeCommandItems = /* @__PURE__ */ new Set();
 	const nativeItemObservers = /* @__PURE__ */ new Set();
@@ -4723,7 +5053,6 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		if (state.projectionClosed) return;
 		const projector = projectorRef.current;
 		const turnId = turnIdRef.current;
-		userInputBridgeRef.current?.handleNotification(notification);
 		if (!projector || !turnId) {
 			if (notification.method === "error") state.latestStartupErrorNotification = notification;
 			return;
@@ -5102,7 +5431,7 @@ async function prepareCodexAttemptPrompt(context) {
 		return projected;
 	};
 	const applyNoContextEngineContinuityProjection = async (action, binding) => {
-		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
+		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary" || message.role === "assistant" && message.content.some((part) => part.type === "text" && part.text.trim())));
 		if (activeContextEngine || !hasContinuity && !params.pluginRuntimeRefreshMessages?.length) return false;
 		if (action === "resumed" && promptState.precomputedStaleBindingContinuityProjectionApplied) return true;
 		if (action === "started" && promptState.staleBindingContinuityForcedFreshStart) return true;
@@ -5125,9 +5454,8 @@ async function prepareCodexAttemptPrompt(context) {
 			binding,
 			bindingStore,
 			identity: bindingIdentity,
-			sessionFile: params.sessionFile,
 			agentDir,
-			codexHome: appServer.start.env?.CODEX_HOME,
+			codexHome: appServer.start.codexHome ?? appServer.start.env?.CODEX_HOME,
 			config: params.config,
 			contextEngineActive: Boolean(activeContextEngine),
 			expectedSessionRuntimeOwnership: params.expectedSessionRuntimeOwnership,
@@ -5221,6 +5549,13 @@ function prepareCodexAttemptResources(prompt) {
 	const { connection, hookChannelId } = runtime;
 	const { appServer, params, effectiveCwd, sessionAgentId, contextSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
 	const { toolBridge } = attemptTools;
+	let nativeProcessAuthorityReleased = false;
+	const releaseNativeProcessAuthority = () => {
+		if (!nativeProcessAuthorityReleased) {
+			nativeProcessAuthorityReleased = true;
+			nativeProcessAuthority?.release();
+		}
+	};
 	const trajectoryRecorder = createCodexTrajectoryRecorder({
 		attempt: params,
 		cwd: effectiveCwd,
@@ -5245,6 +5580,7 @@ function prepareCodexAttemptResources(prompt) {
 		nativePreToolUseFailureFallbackTerminalReason: void 0,
 		releaseSharedClientLease: void 0,
 		startupClientUnsafe: false,
+		turnStartAttempted: false,
 		sharedCodexClientRetiredForOneShotCleanup: false,
 		sandboxExecEnvironment: void 0,
 		executionDisconnectError: void 0,
@@ -5414,6 +5750,88 @@ function prepareCodexAttemptResources(prompt) {
 		state.routeActivated = false;
 		await unregisterNativeSubagentMonitor();
 	};
+	let subscriptionSettlement;
+	const retainThreadSubscription = async () => {
+		const { client, thread } = state;
+		if (subscriptionSettlement?.thread === thread) return subscriptionSettlement.retained;
+		if (!thread || thread.clientId !== resolveCodexAppServerClientInstanceId(client)) return false;
+		const { bindingStore, bindingIdentity } = connection;
+		const retained = await bindingStore.withLease(bindingIdentity, async () => {
+			if (!isSameCodexAppServerThreadOwner(bindingStore.read(bindingIdentity), thread)) return false;
+			try {
+				if (!state.turnStartAttempted) runAbortController.signal.throwIfAborted();
+				if (!hasCodexNativeBackgroundProcesses(client, thread.threadId)) {
+					params.hostCapabilities.assertActive();
+					connection.assertCurrent();
+				}
+				thread.liveThreadOwnership?.assertCurrent();
+			} catch {
+				return false;
+			}
+			return await retainCodexAppServerBindingSubscription(client, thread.threadId, {
+				release: thread.liveThreadOwnership?.release,
+				configFingerprint: thread.liveThreadConfigFingerprint,
+				serviceTier: state.turnStartAttempted ? connection.mutable.pluginAppServer.serviceTier : thread.liveThreadOwnership?.serviceTier,
+				ephemeralPolicy: thread.liveThreadEphemeralPolicy
+			});
+		});
+		if (retained) subscriptionSettlement = {
+			thread,
+			retained: true
+		};
+		return retained;
+	};
+	const releaseThreadSubscription = async (assertCurrent) => {
+		const { client, thread } = state;
+		if (!thread || subscriptionSettlement?.thread === thread) return true;
+		subscriptionSettlement = {
+			thread,
+			retained: false
+		};
+		if (thread.liveThreadOwnership) try {
+			await thread.liveThreadOwnership.release(thread.threadId, assertCurrent);
+			return true;
+		} catch (error) {
+			await closeCodexStartupClientBestEffort(client);
+			throw error;
+		}
+		const released = await unsubscribeCodexThreadBestEffort(client, {
+			threadId: thread.threadId,
+			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
+			assertCurrent
+		});
+		if (!released) await closeCodexStartupClientBestEffort(client);
+		return released;
+	};
+	const cleanupBeforeActiveTurn = async () => {
+		await runCleanupStep("codex-pre-turn-hook-fallback", activateNativePreToolUseFailureFallback);
+		await runCleanupStep("codex-pre-turn-subscription", async () => {
+			const { thread } = state;
+			if (!thread || subscriptionSettlement?.thread === thread || state.startupClientUnsafe) return;
+			let retained = false;
+			try {
+				retained = Boolean(!state.turnStartAttempted && !runAbortController.signal.aborted && params.cleanupBundleMcpOnRunEnd !== true && thread.liveThreadOwnership && await retainThreadSubscription());
+			} finally {
+				if (!retained) {
+					if (!isIncognitoSessionKey(params.sessionKey) || await connection.bindingStore.mutate(connection.bindingIdentity, {
+						kind: "clear",
+						threadId: thread.threadId
+					})) await releaseThreadSubscription();
+				}
+			}
+		});
+		await runCleanupStep("codex-pre-turn-route-release", releaseCurrentRoute);
+		const relay = state.nativeHookRelay;
+		state.nativeHookRelay = void 0;
+		await runCleanupStep("codex-pre-turn-native-hook-relay", async () => {
+			relay?.unregister();
+			await relay?.drain();
+		});
+		await runCleanupStep("codex-pre-turn-sandbox-release", releaseSandboxExecEnvironment);
+		await runCleanupStep("codex-pre-turn-source-release", releaseNativeProcessAuthority);
+		await runCleanupStep("codex-pre-turn-trajectory-flush", () => trajectoryRecorder?.flush());
+		await runCleanupStep("codex-pre-turn-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
+	};
 	const startupTimeoutMs = resolveCodexStartupTimeoutMs({
 		timeoutMs: params.timeoutMs,
 		timeoutFloorMs: options.startupTimeoutFloorMs
@@ -5425,6 +5843,8 @@ function prepareCodexAttemptResources(prompt) {
 		previousRelay?.unregister();
 		await previousRelay?.drain();
 		connection.assertCurrent();
+		const requiresProcessAdmission = nativeProcessAuthority && runtime.nativeToolSurfaceEnabled;
+		const relayEvents = requiresProcessAdmission && !nativeHookRelayEvents.includes("pre_tool_use") ? [...nativeHookRelayEvents, "pre_tool_use"] : nativeHookRelayEvents;
 		if (params.pluginHarnessToolPolicyRestricted === true) {
 			state.nativeHookRelay = void 0;
 			return {
@@ -5433,10 +5853,13 @@ function prepareCodexAttemptResources(prompt) {
 			};
 		}
 		state.nativeHookRelay = createCodexNativeHookRelay({
-			options: options.nativeHookRelay,
+			options: requiresProcessAdmission ? {
+				...options.nativeHookRelay,
+				enabled: true
+			} : options.nativeHookRelay,
 			generation: decision.action === "resume" ? decision.binding.nativeHookRelayGeneration : void 0,
 			generationMismatchGraceMs: decision.action === "resume" && !decision.binding.nativeHookRelayGeneration ? CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS : void 0,
-			events: nativeHookRelayEvents,
+			events: relayEvents,
 			agentId: sessionAgentId,
 			sessionId: params.sessionId,
 			sessionKey: contextSessionKey,
@@ -5460,6 +5883,10 @@ function prepareCodexAttemptResources(prompt) {
 			loopDetectionPreToolUseRelay: appServer.loopDetectionPreToolUseRelay,
 			signal: runAbortController.signal,
 			hostCapabilities: params.hostCapabilities,
+			nativeProcessAuthority: requiresProcessAdmission ? {
+				owner: nativeProcessAuthority,
+				client: () => state.client
+			} : void 0,
 			assertCurrent: connection.assertCurrent,
 			onPreToolUseFailure: (failure) => {
 				const projector = projectorRef.current;
@@ -5473,18 +5900,35 @@ function prepareCodexAttemptResources(prompt) {
 		return {
 			configPatch: state.nativeHookRelay ? buildCodexNativeHookRelayConfig({
 				relay: state.nativeHookRelay,
-				events: nativeHookRelayEvents,
+				events: relayEvents,
 				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
 			}) : options.nativeHookRelay?.enabled === false ? buildCodexNativeHookRelayDisabledConfig() : void 0,
 			nativeHookRelayGeneration: state.nativeHookRelay?.generation
 		};
 	};
+	const nativeProcessAuthority = sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority ? new CodexNativeProcessAuthority(params.hostCapabilities, (error) => {
+		const message = formatErrorMessage(error);
+		embeddedAgentLog.warn("codex native background work remains unsettled", {
+			runId: params.runId,
+			sessionId: params.sessionId,
+			error: message
+		});
+		emitCodexAppServerEvent(params, {
+			stream: "codex_app_server.lifecycle",
+			data: {
+				phase: "background_cleanup_failed",
+				error: message
+			}
+		});
+	}) : void 0;
 	return {
 		prompt,
 		trajectoryRecorder,
 		state,
 		projectorRef,
 		pendingNativePreToolUseFailures,
+		nativeProcessAuthority,
+		releaseNativeProcessAuthority,
 		markTrajectoryEndRecorded: () => {
 			state.trajectoryEndRecorded = true;
 		},
@@ -5495,6 +5939,9 @@ function prepareCodexAttemptResources(prompt) {
 		runCleanupStep,
 		registerNativeSubagentMonitor,
 		releaseCurrentRoute,
+		retainThreadSubscription,
+		releaseThreadSubscription,
+		cleanupBeforeActiveTurn,
 		startupTimeoutMs,
 		buildNativeHookRelayFinalConfigPatch
 	};
@@ -5502,7 +5949,7 @@ function prepareCodexAttemptResources(prompt) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-route.ts
 async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, handleServerRequest) {
-	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, registerNativeSubagentMonitor, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseOnce, runCleanupStep } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, registerNativeSubagentMonitor } = resources;
 	const { connection } = prompt.context.runtime;
 	const { runAbortController } = connection;
 	const { state, turnIdRef, completeTurn } = turnRuntime;
@@ -5551,26 +5998,7 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 		}
 		return resourceState.turnRoute;
 	};
-	try {
-		await ensureCurrentThreadRoute();
-	} catch (error) {
-		activateNativePreToolUseFailureFallback();
-		await runCleanupStep("codex-route-failure-route-release", releaseCurrentRoute);
-		const relay = resourceState.nativeHookRelay;
-		relay?.unregister();
-		await runAgentCleanupStep({
-			runId: connection.params.runId,
-			sessionId: connection.params.sessionId,
-			step: "codex-route-failure-native-hook-relay",
-			log: embeddedAgentLog,
-			cleanup: async () => {
-				await relay?.drain();
-			}
-		});
-		await releaseSandboxExecEnvironment();
-		releaseSharedClientLeaseOnce();
-		throw error;
-	}
+	await ensureCurrentThreadRoute();
 	return { ensureCurrentThreadRoute };
 }
 //#endregion
@@ -5713,25 +6141,64 @@ async function prepareCodexAttemptRuntime(connection) {
 	});
 	preDynamicStartupStages.mark("bundle-mcp");
 	const sandboxExecServerEnabled = isCodexSandboxExecServerEnabled(pluginConfig, sandbox);
-	const nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
+	let nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
 		agentId: policyAgentId,
 		runtimeSessionKey: sandboxSessionKey,
 		sandboxExecServerEnabled
 	});
+	if (nativeToolSurfaceEnabled && sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority) {
+		const client = await attemptClientFactory({
+			assertCurrent: connection.assertCurrent,
+			startOptions: appServer.start,
+			pluginConfig,
+			...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
+			authRequirement: connection.startupAuthRequirement,
+			authProfileStore: attemptAuthProfileStore,
+			authBindingFingerprint: preparedAuthBinding?.fingerprint,
+			...connection.runtimeArtifactRequest ? {
+				runtimeArtifactMode: "capture",
+				...connection.runtimeArtifactRequest.expected ? { expectedRuntimeArtifact: connection.runtimeArtifactRequest.expected } : {}
+			} : {},
+			agentId: sessionAgentId,
+			agentDir,
+			config: params.config,
+			abandonSignal: runAbortController.signal,
+			timeoutMs: appServer.requestTimeoutMs
+		});
+		try {
+			connection.assertCurrent();
+			await assertCodexNativeHookRelayAllowed(client, runAbortController.signal, appServer.requestTimeoutMs);
+			connection.assertCurrent();
+		} catch (error) {
+			if (!(error instanceof CodexManagedHooksOnlyError)) throw error;
+			connection.assertCurrent();
+			nativeToolSurfaceEnabled = false;
+			embeddedAgentLog.info("Codex managed-only hooks require sandbox-backed OpenClaw tools");
+		} finally {
+			if (attemptClientFactory === createIsolatedCodexAppServerClient) await client.closeAndWait();
+			else releaseLeasedSharedCodexAppServerClient(client);
+		}
+	}
 	const configuredMcpSurface = scheduledConfiguredMcpSurface ? "scheduled" : !nativeToolSurfaceEnabled && bundleMcpThreadConfig.staticServerNames.length > 0 ? "transient" : void 0;
 	preDynamicStartupStages.mark("native-tool-surface");
-	const nativeProviderWebSearchSupport = resolveCodexWebSearchPlan({
+	const webSearchPlan = resolveCodexWebSearchPlan({
 		config: params.config,
 		disableTools: params.disableTools,
 		nativeToolSurfaceEnabled
-	}).kind === "native-hosted" ? await resolveCodexProviderWebSearchSupport({
+	});
+	const supervisedSearchFingerprint = usesSupervisionConnection && !mutable.startupBinding?.pendingSupervisionBranch ? mutable.startupBinding?.webSearchThreadConfigFingerprint : void 0;
+	let nativeProviderWebSearchSupport;
+	if (webSearchPlan.kind !== "native-hosted" || supervisedSearchFingerprint === fingerprintJsonObject(resolveCodexWebSearchPlan({ disableTools: true }).threadConfig)) nativeProviderWebSearchSupport = "unsupported";
+	else if (supervisedSearchFingerprint === fingerprintJsonObject(webSearchPlan.threadConfig)) nativeProviderWebSearchSupport = "supported";
+	else nativeProviderWebSearchSupport = await resolveCodexProviderWebSearchSupport({
 		clientFactory: attemptClientFactory,
 		appServer,
 		authProfileId: startupClientAuthProfileId,
 		preparedAuth: startupPreparedAuth,
 		agentDir,
 		config: params.config,
-		modelProviderOverride: usesSupervisionConnection ? mutable.startupBinding?.modelProvider : resolveCodexAppServerThreadModelSelection({
+		expectedNativeModelProvider: usesSupervisionConnection ? mutable.startupBinding?.modelProvider : void 0,
+		modelProviderOverride: usesSupervisionConnection ? void 0 : resolveCodexAppServerThreadModelSelection({
 			provider: params.provider,
 			model: params.modelId,
 			binding: mutable.startupBinding,
@@ -5741,7 +6208,7 @@ async function prepareCodexAttemptRuntime(connection) {
 			config: params.config
 		}).modelProvider,
 		signal: runAbortController.signal
-	}) : "unsupported";
+	});
 	preDynamicStartupStages.mark("provider-capabilities");
 	for (const diagnostic of bundleMcpThreadConfig.diagnostics) embeddedAgentLog.warn(`bundle-mcp: ${diagnostic.pluginId}: ${diagnostic.message}`);
 	if (activeContextEngine) assertContextEngineHostSupport({
@@ -5925,17 +6392,11 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					signal
 				});
 				if (approvalResult.kind === "handled") return approvalResult.response;
-				return await userInputBridgeRef.current?.handleElicitationRequest({
-					id: request.id,
-					params: request.params
-				});
+				return await userInputBridgeRef.current?.handleElicitationRequest(request, signal);
 			}
 			if (request.method === "item/tool/requestUserInput") {
 				if (scope.turnId === turnId) markCurrentTurnRequestProgress();
-				return await userInputBridgeRef.current?.handleRequest({
-					id: request.id,
-					params: request.params
-				});
+				return await userInputBridgeRef.current?.handleRequest(request, signal);
 			}
 			if (request.method !== "item/tool/call") {
 				if (isCodexAppServerApprovalRequest(request.method)) {
@@ -5986,19 +6447,32 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			const toolMeta = inferCodexDynamicToolMeta(call, resolveCodexToolProgressDetailMode(params.toolProgressDetail));
 			const toolArgs = sanitizeCodexToolArguments(call.arguments);
 			const commandBearing = isCodexCommandBearingToolCall(call.tool, toolArgs);
-			const shouldEmitDynamicToolProgress = shouldEmitTranscriptToolProgress(call.tool, toolArgs);
-			if (shouldEmitDynamicToolProgress) emitCodexAppServerEvent(params, {
-				stream: "tool",
-				data: {
-					phase: "start",
-					name: call.tool,
-					itemId: call.callId,
+			const shouldEmitDynamicToolProgress = shouldEmitTranscriptToolProgress(call.tool);
+			if (shouldEmitDynamicToolProgress) {
+				const activity = projectAgentToolActivity({
 					toolCallId: call.callId,
-					...toolMeta ? { meta: toolMeta } : {},
-					...toolArgs ? { args: toolArgs } : {},
-					...commandBearing ? { commandBearing: true } : {}
-				}
-			});
+					name: call.tool,
+					phase: "start",
+					args: toolArgs,
+					meta: toolMeta
+				});
+				emitCodexAppServerEvent(params, {
+					stream: "item",
+					data: activity
+				});
+				emitCodexAppServerEvent(params, {
+					stream: "tool",
+					data: {
+						phase: "start",
+						name: call.tool,
+						itemId: call.callId,
+						toolCallId: call.callId,
+						...toolMeta ? { meta: toolMeta } : {},
+						...toolArgs ? { args: toolArgs } : {},
+						...commandBearing ? { commandBearing: true } : {}
+					}
+				});
+			}
 			const dynamicToolTimeoutMs = resolveDynamicToolCallTimeoutMs({
 				call,
 				config: params.config,
@@ -6081,6 +6555,14 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				}
 				if (shouldEmitDynamicToolProgress) {
 					const progressResponse = toCodexDynamicToolProgressResponse(response, protocolResponse);
+					const activity = projectAgentToolActivity({
+						toolCallId: call.callId,
+						name: call.tool,
+						phase: "result",
+						args: response.executedArguments ?? call.arguments,
+						result: toTranscriptToolResult(progressResponse),
+						isError: !protocolResponse.success
+					});
 					emitCodexAppServerEvent(params, {
 						stream: "tool",
 						data: {
@@ -6094,6 +6576,10 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 							result: toTranscriptToolResult(progressResponse)
 						}
 					});
+					emitCodexAppServerEvent(params, {
+						stream: "item",
+						data: activity
+					});
 				}
 				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic({
 					call,
@@ -6157,7 +6643,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 //#region extensions/codex/src/app-server/attempt-runtime-artifact.ts
 async function verifyStartupArtifact(params) {
 	if (!params.request) return;
-	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Dy38Z5iU.mjs");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CLZ8udh-.mjs");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6223,9 +6709,13 @@ async function runCodexComputerUseHealthProbe(client, config, monitor, tools) {
 	monitor.running = true;
 	try {
 		const { liveTest, repair } = await runCodexComputerUseLiveTest({
+			client,
 			config,
 			tools,
-			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, { timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs })
+			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, {
+				timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs,
+				...requestOptions?.signal ? { signal: requestOptions.signal } : {}
+			})
 		});
 		if (!liveTest.ok) {
 			embeddedAgentLog.warn("codex computer-use periodic health failed", {
@@ -6547,7 +7037,8 @@ async function startCodexAttemptThread(params) {
 								appServerStartOptions: params.appServer.start,
 								timeoutMs: params.appServer.requestTimeoutMs,
 								signal: AbortSignal.any([params.signal, startupAbandonController.signal]),
-								onExecutionDisconnect: params.onExecutionDisconnect
+								onExecutionDisconnect: params.onExecutionDisconnect,
+								requireProcessAuthority: Boolean(attemptParams.hostCapabilities.retainSourceAuthority)
 							}) : void 0;
 							startupSandboxEnvironmentAcquired = Boolean(startupSandboxEnvironment);
 							if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
@@ -6752,7 +7243,7 @@ async function startCodexAttemptThread(params) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-start.ts
 async function startCodexAttemptRuntime(resources) {
-	const { prompt, state, trajectoryRecorder, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseAndRetireOneShotClient, releaseCurrentRoute, runCleanupStep, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
+	const { prompt, state, trajectoryRecorder, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
 	const { context, turnState, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
 	const { runtime, attemptTools, promptState } = context;
 	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
@@ -6796,7 +7287,7 @@ async function startCodexAttemptRuntime(resources) {
 			developerInstructions,
 			agentWorkspaceDeveloperInstructions: context.agentWorkspaceDeveloperInstructions,
 			buildFinalConfigPatch: buildNativeHookRelayFinalConfigPatch,
-			nativeHookRelayRequired: connection.options.nativeHookRelay?.enabled !== false && params.pluginHarnessToolPolicyRestricted !== true && connection.nativeHookRelayEvents.includes("pre_tool_use") && (hasBeforeToolCallPolicy() || appServer.loopDetectionPreToolUseRelay && Boolean(connection.sandboxSessionKey) && loopDetectionEnabled),
+			nativeHookRelayRequired: Boolean(resources.nativeProcessAuthority && nativeToolSurfaceEnabled) || connection.options.nativeHookRelay?.enabled !== false && params.pluginHarnessToolPolicyRestricted !== true && connection.nativeHookRelayEvents.includes("pre_tool_use") && (hasBeforeToolCallPolicy() || appServer.loopDetectionPreToolUseRelay && Boolean(connection.sandboxSessionKey) && loopDetectionEnabled),
 			bundleMcpThreadConfig,
 			configuredMcpDynamicSurface: attemptTools.configuredMcp !== void 0,
 			configuredMcpOwnershipVersion: attemptTools.configuredMcpOwnershipVersion,
@@ -6883,16 +7374,6 @@ async function startCodexAttemptRuntime(resources) {
 		connection.mutable.pluginAppServer = pluginAppServer;
 		await resources.registerNativeSubagentMonitor(state.thread.threadId);
 	} catch (error) {
-		await runCleanupStep("codex-start-failure-hook-fallback", activateNativePreToolUseFailureFallback);
-		await runCleanupStep("codex-start-failure-route-release", releaseCurrentRoute);
-		const nativeHookRelay = state.nativeHookRelay;
-		state.nativeHookRelay = void 0;
-		await runCleanupStep("codex-start-failure-native-hook-relay", async () => {
-			nativeHookRelay?.unregister();
-			await nativeHookRelay?.drain();
-		});
-		await runCleanupStep("codex-start-failure-sandbox-release", releaseSandboxExecEnvironment);
-		await runCleanupStep("codex-start-failure-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		throw error instanceof CodexThreadPolicyHandoffError ? error : state.executionDisconnectError ?? error;
 	}
 }
@@ -7043,137 +7524,20 @@ async function prepareCodexAttemptTools(runtime) {
 		}
 	}
 	let requireExplicitMessageTarget;
-	const tools = await buildDynamicTools({
-		...commonToolParams,
-		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
-		onMessageToolTargetResolved: (required) => {
-			requireExplicitMessageTarget = required;
-		},
-		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
-		cronCreatorToolAllowlistCaptureRef,
-		onPersistentWebSearchPolicyResolved: (allowed) => {
-			toolState.persistentWebSearchAllowed = allowed;
-		},
-		onWebSearchPolicyResolved: (allowed) => {
-			toolState.webSearchAllowed = allowed;
-		}
-	});
-	const registeredTools = nativeSpecs ? [] : await buildDynamicTools({
-		...commonToolParams,
-		forceHeartbeatTool: true,
-		ignoreDisableMessageTool: true,
-		ignoreRuntimePlan: true
-	});
-	const policyContext = {
-		config: params.config,
-		sessionKey: sandboxSessionKey,
-		runSessionKey: params.sessionKey && params.sessionKey !== sandboxSessionKey ? params.sessionKey : void 0,
-		sessionId: params.sessionId,
-		runId: params.runId,
-		agentId: policyAgentId,
-		agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
-		agentAccountId: params.agentAccountId,
-		messageProvider: params.messageProvider ?? params.messageChannel,
-		messageChannel: params.messageChannel,
-		chatType: params.chatType,
-		messageTo: params.messageTo,
-		messageThreadId: params.messageThreadId,
-		currentChannelId: params.currentChannelId,
-		currentMessagingTarget: params.currentMessagingTarget,
-		currentThreadTs: params.currentThreadTs,
-		currentMessageId: params.currentMessageId,
-		groupId: params.groupId,
-		groupChannel: params.groupChannel,
-		groupSpace: params.groupSpace,
-		memberRoleIds: params.memberRoleIds,
-		spawnedBy: params.spawnedBy,
-		senderId: params.senderId,
-		senderName: params.senderName,
-		senderUsername: params.senderUsername,
-		senderE164: params.senderE164,
-		senderIsOwner: params.senderIsOwner,
-		modelProvider: params.provider,
-		modelId: params.modelId,
-		modelApi: params.model.api,
-		modelContextWindowTokens: params.model.contextWindow,
-		modelHasVision: params.model.input?.includes("image") ?? false,
-		workspaceDir: effectiveWorkspace,
-		cwd: effectiveCwd ?? effectiveWorkspace,
-		sandboxToolPolicy: sandbox?.tools,
-		conversationToolPolicy: params.conversationToolPolicy,
-		inputProvenance: params.inputProvenance,
-		trustedInternalHandoff: params.trustedInternalHandoff,
-		scheduledToolPolicy: params.scheduledToolPolicy
-	};
-	const reservedToolNames = [...tools.map((tool) => tool.name), ...registeredTools.map((tool) => tool.name)];
-	const turnSourceChannel = params.messageChannel ?? params.messageProvider;
-	const turnSourceTo = params.currentMessagingTarget ?? params.currentChannelId;
-	const requester = {
-		...turnSourceChannel ? { channel: turnSourceChannel } : {},
-		...params.agentAccountId ? { accountId: params.agentAccountId } : {},
-		...params.senderId ? { senderId: params.senderId } : {},
-		...params.senderIsOwner !== void 0 ? { senderIsOwner: params.senderIsOwner } : {},
-		...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
-	};
-	const hasRequester = Object.keys(requester).length > 0;
-	const requestInteractiveMcpApproval = async (approval) => {
-		const allowedDecisions = approval.mode === "prompt" ? ["allow-once", "deny"] : [
-			"allow-once",
-			"allow-always",
-			"deny"
-		];
-		const outcome = await requestPluginApprovalOutcome({
-			hostCapabilities: params.hostCapabilities,
-			signal: approval.signal,
-			title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
-			description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
-			allowedDecisions,
-			toolName: approval.safeToolName,
-			toolCallId: approval.toolCallId,
-			mcpTool: {
-				server: approval.serverName,
-				tool: approval.toolName
-			},
-			isMcpToolApprovalActive: approval.isActive
-		});
-		if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
-	};
-	const requestRequesterMcpApproval = async (approval) => {
-		const outcome = await requestPluginApprovalOutcome({
-			hostCapabilities: params.hostCapabilities,
-			signal: approval.signal,
-			title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
-			description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
-			allowedDecisions: ["allow-once", "deny"],
-			toolName: approval.safeToolName,
-			toolCallId: approval.toolCallId,
-			mcpTool: {
-				server: approval.serverName,
-				tool: approval.toolName
-			},
-			isMcpToolApprovalActive: approval.isActive
+	let configuredMcp;
+	let scopedMcpTools;
+	let toolDisposal;
+	const disposeTools = (reason) => toolDisposal ??= (async () => {
+		await runAgentCleanupStep({
+			runId: params.runId,
+			sessionId: params.sessionId,
+			step: "codex-dynamic-tool-cleanup",
+			log: embeddedAgentLog,
+			cleanup: async () => {
+				const errors = (await Promise.allSettled(runCleanups.splice(0).map(async (cleanup) => await cleanup(reason)))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+				if (params.oneShotCliRun && errors.length) throw new AggregateError(errors, "Codex tool cleanup failed");
+			}
 		});
-		if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
-	};
-	const configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
-		sessionId: params.sessionId,
-		sessionKey: params.sessionKey,
-		agentId: sessionAgentId,
-		workspaceDir: effectiveWorkspace,
-		agentDir: policyContext.agentDir,
-		cfg: params.config,
-		manifestRegistry: bundleManifestRegistry,
-		reservedToolNames,
-		toolsAllow: params.toolsAllow,
-		toolOverrides: codexMcpToolOverrides,
-		autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
-		projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
-		...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: requestInteractiveMcpApproval } : {},
-		policyContext,
-		warn: (message) => embeddedAgentLog.warn(message)
-	}) : void 0;
-	let scopedMcpTools = void 0;
-	const disposeMcpTools = async () => {
 		for (const [step, materialized] of [["codex-scoped-mcp-dispose", scopedMcpTools], ["codex-configured-mcp-dispose", configuredMcp]]) await runAgentCleanupStep({
 			runId: params.runId,
 			sessionId: params.sessionId,
@@ -7181,8 +7545,137 @@ async function prepareCodexAttemptTools(runtime) {
 			log: embeddedAgentLog,
 			cleanup: async () => materialized?.dispose()
 		});
-	};
+	})();
 	try {
+		const tools = await buildDynamicTools({
+			...commonToolParams,
+			registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
+			onMessageToolTargetResolved: (required) => {
+				requireExplicitMessageTarget = required;
+			},
+			cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
+			cronCreatorToolAllowlistCaptureRef,
+			onPersistentWebSearchPolicyResolved: (allowed) => {
+				toolState.persistentWebSearchAllowed = allowed;
+			},
+			onWebSearchPolicyResolved: (allowed) => {
+				toolState.webSearchAllowed = allowed;
+			}
+		});
+		const registeredTools = nativeSpecs ? [] : await buildDynamicTools({
+			...commonToolParams,
+			forceHeartbeatTool: true,
+			ignoreDisableMessageTool: true,
+			ignoreRuntimePlan: true
+		});
+		const policyContext = {
+			config: params.config,
+			sessionKey: sandboxSessionKey,
+			runSessionKey: params.sessionKey && params.sessionKey !== sandboxSessionKey ? params.sessionKey : void 0,
+			sessionId: params.sessionId,
+			runId: params.runId,
+			agentId: policyAgentId,
+			agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
+			agentAccountId: params.agentAccountId,
+			messageProvider: params.messageProvider ?? params.messageChannel,
+			messageChannel: params.messageChannel,
+			chatType: params.chatType,
+			messageTo: params.messageTo,
+			messageThreadId: params.messageThreadId,
+			currentChannelId: params.currentChannelId,
+			currentMessagingTarget: params.currentMessagingTarget,
+			currentThreadTs: params.currentThreadTs,
+			currentMessageId: params.currentMessageId,
+			groupId: params.groupId,
+			groupChannel: params.groupChannel,
+			groupSpace: params.groupSpace,
+			memberRoleIds: params.memberRoleIds,
+			spawnedBy: params.spawnedBy,
+			senderId: params.senderId,
+			senderName: params.senderName,
+			senderUsername: params.senderUsername,
+			senderE164: params.senderE164,
+			senderIsOwner: params.senderIsOwner,
+			modelProvider: params.provider,
+			modelId: params.modelId,
+			modelApi: params.model.api,
+			modelContextWindowTokens: params.model.contextWindow,
+			modelHasVision: params.model.input?.includes("image") ?? false,
+			workspaceDir: effectiveWorkspace,
+			cwd: effectiveCwd ?? effectiveWorkspace,
+			sandboxToolPolicy: sandbox?.tools,
+			conversationToolPolicy: params.conversationToolPolicy,
+			inputProvenance: params.inputProvenance,
+			trustedInternalHandoff: params.trustedInternalHandoff,
+			scheduledToolPolicy: params.scheduledToolPolicy
+		};
+		const reservedToolNames = [...tools.map((tool) => tool.name), ...registeredTools.map((tool) => tool.name)];
+		const turnSourceChannel = params.messageChannel ?? params.messageProvider;
+		const turnSourceTo = params.currentMessagingTarget ?? params.currentChannelId;
+		const requester = {
+			...turnSourceChannel ? { channel: turnSourceChannel } : {},
+			...params.agentAccountId ? { accountId: params.agentAccountId } : {},
+			...params.senderId ? { senderId: params.senderId } : {},
+			...params.senderIsOwner !== void 0 ? { senderIsOwner: params.senderIsOwner } : {},
+			...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
+		};
+		const hasRequester = Object.keys(requester).length > 0;
+		const requestInteractiveMcpApproval = async (approval) => {
+			const allowedDecisions = approval.mode === "prompt" ? ["allow-once", "deny"] : [
+				"allow-once",
+				"allow-always",
+				"deny"
+			];
+			const outcome = await requestPluginApprovalOutcome({
+				hostCapabilities: params.hostCapabilities,
+				signal: approval.signal,
+				title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
+				description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
+				allowedDecisions,
+				toolName: approval.safeToolName,
+				toolCallId: approval.toolCallId,
+				mcpTool: {
+					server: approval.serverName,
+					tool: approval.toolName
+				},
+				isMcpToolApprovalActive: approval.isActive
+			});
+			if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
+		};
+		const requestRequesterMcpApproval = async (approval) => {
+			const outcome = await requestPluginApprovalOutcome({
+				hostCapabilities: params.hostCapabilities,
+				signal: approval.signal,
+				title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
+				description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
+				allowedDecisions: ["allow-once", "deny"],
+				toolName: approval.safeToolName,
+				toolCallId: approval.toolCallId,
+				mcpTool: {
+					server: approval.serverName,
+					tool: approval.toolName
+				},
+				isMcpToolApprovalActive: approval.isActive
+			});
+			if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
+		};
+		configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			agentId: sessionAgentId,
+			workspaceDir: effectiveWorkspace,
+			agentDir: policyContext.agentDir,
+			cfg: params.config,
+			manifestRegistry: bundleManifestRegistry,
+			reservedToolNames,
+			toolsAllow: params.toolsAllow,
+			toolOverrides: codexMcpToolOverrides,
+			autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
+			projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
+			...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: requestInteractiveMcpApproval } : {},
+			policyContext,
+			warn: (message) => embeddedAgentLog.warn(message)
+		}) : void 0;
 		scopedMcpTools = authenticatedScheduledMode ? void 0 : await materializeRequesterScopedMcpToolsForHarnessRun({
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -7270,7 +7763,7 @@ async function prepareCodexAttemptTools(runtime) {
 						agentDir: policyContext.agentDir,
 						cfg: params.config,
 						manifestRegistry: bundleManifestRegistry,
-						reservedToolNames: toolBridge.availableTools.map((tool) => tool.name),
+						reservedToolNames: configuredMcp ? reservedToolNames : toolBridge.availableTools.map((tool) => tool.name),
 						toolsAllow: params.toolsAllow,
 						toolOverrides: codexMcpToolOverrides,
 						autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
@@ -7309,14 +7802,13 @@ async function prepareCodexAttemptTools(runtime) {
 			requireExplicitMessageTarget,
 			scopedMcpTools,
 			configuredMcp,
-			disposeMcpTools,
+			disposeTools,
 			configuredMcpOwnershipVersion: configuredMcpSurface === "scheduled" ? 1 : void 0,
 			captureCronCreatorToolAllowlist,
 			scheduledAppAuthoritySourceRef,
 			dynamicToolParams,
 			compactionPlanState,
 			computerContextEpoch,
-			runCleanups,
 			toolBridge,
 			toolState,
 			toolOutcomeOrdinals,
@@ -7326,7 +7818,7 @@ async function prepareCodexAttemptTools(runtime) {
 			runtimeYieldCompletionClaim
 		};
 	} catch (error) {
-		await disposeMcpTools();
+		await disposeTools("error");
 		throw error;
 	}
 }
@@ -7360,6 +7852,98 @@ async function resolveCodexExplicitSkillInputs(params) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/provider-review-continuation.ts
+/** Reconcile the acknowledged failure with the native thread immediately before turn/start. */
+async function prepareCodexProviderReviewContinuation(params) {
+	const acknowledgment = params.acknowledgment;
+	if (!acknowledgment) return;
+	let nativeChanged = false;
+	let dispatched = false;
+	let dispose = () => {};
+	const assertCurrent = () => {
+		params.signal.throwIfAborted();
+		params.assertCurrent();
+		acknowledgment.read();
+		if (nativeChanged) throw new Error("The native provider review changed before dispatch");
+	};
+	assertCurrent();
+	const snapshot = acknowledgment.read();
+	if (snapshot.phase === "accepted") throw new Error("Provider review continuation cannot start another native turn");
+	const assertWorkStart = () => acknowledgment.assertRuntime({
+		provider: params.provider,
+		model: params.model,
+		runtimeId: "codex",
+		api: params.api,
+		assertCurrent
+	});
+	await assertWorkStart();
+	assertCurrent();
+	const { review } = snapshot;
+	if (review.nativeThreadId !== params.turnStartParams.threadId || !review.review?.continuation) throw new Error("Provider review no longer matches the native thread");
+	dispose = params.client.addNotificationHandler((notification) => {
+		const event = notification.params;
+		if (!isJsonObject(event) || event.threadId !== review.nativeThreadId) return;
+		if (notification.method === "turn/started") nativeChanged = true;
+		else if (notification.method === "turn/completed" || notification.method === "error" && event.willRetry !== true) {
+			const turn = isJsonObject(event.turn) ? event.turn : void 0;
+			const turnId = turn?.id ?? event.turnId;
+			const error = isJsonObject(turn?.error) ? turn.error : isJsonObject(event.error) ? event.error : void 0;
+			const failure = readCodexProviderRefusal(typeof error?.message === "string" ? error.message : void 0, error?.codexErrorInfo, { misalignment: error?.misalignment });
+			if (turnId !== review.nativeTurnId || turn && turn.status !== "failed" || failure?.category !== "misalignment" || error?.misalignment != null && !isDeepStrictEqual(failure.review, review.review)) nativeChanged = true;
+		}
+	});
+	try {
+		const page = await params.client.request("thread/turns/list", {
+			threadId: params.turnStartParams.threadId,
+			limit: 1,
+			sortDirection: "desc",
+			itemsView: "notLoaded"
+		}, {
+			signal: params.signal,
+			timeoutMs: params.timeoutMs,
+			assertCurrent
+		});
+		assertCurrent();
+		const latest = page.data[0];
+		const refusal = latest && readCodexProviderRefusal(latest.error?.message, latest.error?.codexErrorInfo, { misalignment: latest.error?.misalignment });
+		if (page.data.length !== 1 || !latest || latest.id !== review.nativeTurnId || latest.threadId !== void 0 && latest.threadId !== params.turnStartParams.threadId || latest.status !== "failed" || refusal?.category !== "misalignment" || latest.error?.misalignment != null && !isDeepStrictEqual(refusal.review, review.review)) throw new Error("The native provider review changed; refresh the findings before continuing");
+		await assertWorkStart();
+		assertCurrent();
+		const message = review.review.continuation.message;
+		params.turnStartParams.input = [{
+			type: "text",
+			text: message,
+			text_elements: []
+		}];
+		params.turnStartParams.responsesapiClientMetadata = {
+			...params.turnStartParams.responsesapiClientMetadata,
+			misalignment_override: JSON.stringify({ timestamp: Date.now() })
+		};
+		return {
+			dispose,
+			dispatch: () => {
+				assertCurrent();
+				if (dispatched) throw new Error("Provider review continuation already dispatched");
+				dispatched = true;
+				dispose();
+			},
+			accept: async (turnId) => {
+				assertCurrent();
+				if (!dispatched) throw new Error("Provider review continuation has not dispatched");
+				await acknowledgment.acceptNativeTurn({
+					nativeThreadId: params.turnStartParams.threadId,
+					nativeTurnId: turnId,
+					assertCurrent
+				});
+				assertCurrent();
+			}
+		};
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-request.ts
 async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, waitForActiveNativeTurnCompletion) {
 	const { prompt, state: resourceState, releaseCurrentRoute } = resources;
@@ -7417,10 +8001,17 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 	const startCodexTurn = async () => {
 		const activeTurnRoute = await ensureCurrentThreadRoute();
 		assertCodexSessionRuntimeOwnership(resourceState.thread, params.expectedSessionRuntimeOwnership);
+		const selectedThread = resourceState.thread;
+		const { threadId, liveThreadOwnership, model, modelProvider } = selectedThread;
+		const turnClient = resourceState.client;
+		const assertTurnCurrent = () => {
+			connection.assertCurrent();
+			liveThreadOwnership?.assertCurrent();
+			if (resourceState.thread !== selectedThread || selectedThread.threadId !== threadId || selectedThread.liveThreadOwnership !== liveThreadOwnership || selectedThread.model !== model || selectedThread.modelProvider !== modelProvider) throw new Error("Codex native model or thread ownership changed during turn start.");
+		};
 		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, runtimeParams);
 		connection.mutable.pluginAppServer = turnAppServer;
 		const references = prepareWorkspaceReferences();
-		const referencesRetained = turnState.codexTurnPromptText.includes(workspaceBootstrapContext.promptContext ?? "");
 		const inferenceRoute = usesSupervisionConnection ? void 0 : getCodexInferenceThread(resourceState.client, resourceState.thread.threadId);
 		const turnStartParams = buildTurnStartParams(runtimeParams, {
 			threadId: resourceState.thread.threadId,
@@ -7484,6 +8075,17 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 				truncated: null
 			} : file);
 		}
+		const continuation = await prepareCodexProviderReviewContinuation({
+			acknowledgment: params.providerReviewAcknowledgment,
+			client: resourceState.client,
+			turnStartParams,
+			provider: params.provider,
+			model: params.modelId,
+			api: runtimeParams.model.api,
+			signal: runAbortController.signal,
+			timeoutMs: params.timeoutMs,
+			assertCurrent: assertTurnCurrent
+		});
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
 		recordCodexTrajectoryContext(resources.trajectoryRecorder, {
 			attempt: params,
@@ -7507,29 +8109,41 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			}
 		});
 		let acceptedTurnId;
+		const upstreamUserText = turnStartParams.input.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
 		try {
-			const startedTurn = assertCodexTurnStartResponse(await resourceState.client.request("turn/start", turnStartParams, {
+			const startedTurn = assertCodexTurnStartResponse(await turnClient.request("turn/start", turnStartParams, {
 				timeoutMs: params.timeoutMs,
 				signal: runAbortController.signal,
-				assertCurrent: connection.assertCurrent
+				assertCurrent: () => {
+					assertTurnCurrent();
+					continuation?.dispatch();
+				}
 			}));
 			acceptedTurnId = startedTurn.turn.id;
-			connection.assertCurrent();
-			if (referencesRetained) references.accepted();
+			resources.nativeProcessAuthority?.bindTurn(turnClient, threadId, acceptedTurnId);
+			assertTurnCurrent();
+			if (upstreamUserText.includes(workspaceBootstrapContext.promptContext ?? "")) references.accepted();
 			throwIfTurnStartAcceptedAfterAbort();
-			return startedTurn;
+			await continuation?.accept(acceptedTurnId);
+			return {
+				turn: startedTurn,
+				upstreamUserText
+			};
 		} catch (error) {
 			if (acceptedTurnId || isCodexAppServerIndeterminateRequestCancellationError(error)) try {
-				resourceState.startupClientUnsafe = !await interruptCodexTurnAndWaitBestEffort(resourceState.client, {
-					threadId: resourceState.thread.threadId,
+				resourceState.startupClientUnsafe = !await interruptCodexTurnAndWaitBestEffort(turnClient, {
+					threadId,
 					turnId: acceptedTurnId ?? ""
 				});
-				if (resourceState.startupClientUnsafe) await retireUnsafeCodexTurnClientBestEffort(resourceState.client, "startup interrupt");
+				if (resourceState.startupClientUnsafe) await retireUnsafeCodexTurnClientBestEffort(turnClient, "startup interrupt");
 			} finally {
 				await releaseCurrentRoute();
 			}
 			else await activeTurnRoute.cancelTurn();
+			if (params.providerReviewAcknowledgment) throw new Error("Could not continue this chat. Review its latest status before trying again.");
 			throw error;
+		} finally {
+			continuation?.dispose();
 		}
 	};
 	if (resourceState.thread.lifecycle.action === "resumed" && (resourceState.thread.lifecycle.activeTurnIds?.length ?? 0) > 0) {
@@ -7565,7 +8179,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-start.ts
 async function startCodexAttemptTurn(resources, turnRuntime, notifications, requestRuntime) {
-	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded, activateNativePreToolUseFailureFallback, releaseCurrentRoute, releaseSandboxExecEnvironment, releaseSharedClientLeaseAndRetireOneShotClient } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded } = resources;
 	const { context, turnState, systemPromptReport } = prompt;
 	const { runtime, historyState, hookContext, hookContextWindowFields, hookRunner } = context;
 	const { connection, runtimeParams, effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
@@ -7573,7 +8187,8 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 	const { state, turnIdRef } = turnRuntime;
 	const { waitForActiveNativeTurnCompletion } = notifications;
 	const { codexModelCallDiagnostics, startCodexTurn, buildLlmInputEvent } = requestRuntime;
-	let turn;
+	let started;
+	resourceState.turnStartAttempted = true;
 	try {
 		codexModelCallDiagnostics.emitStarted();
 		runAgentHarnessLlmInputHook({
@@ -7581,10 +8196,10 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			ctx: hookContext,
 			hookRunner
 		});
-		turn = await startCodexTurn();
+		started = await startCodexTurn();
 	} catch (error) {
 		let turnStartError = error;
-		if (isCodexActiveCompactTurnError(turnStartError)) {
+		if (!params.providerReviewAcknowledgment && isCodexActiveCompactTurnError(turnStartError)) {
 			embeddedAgentLog.info("codex app-server turn/start blocked by active compact turn; waiting to retry", { threadId: resourceState.thread.threadId });
 			if (await waitForActiveNativeTurnCompletion() && !runAbortController.signal.aborted) {
 				emitCodexAppServerEvent(params, {
@@ -7595,13 +8210,13 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 					}
 				});
 				try {
-					turn = await startCodexTurn();
+					started = await startCodexTurn();
 				} catch (retryError) {
 					turnStartError = retryError;
 				}
 			}
 		}
-		if (turn === void 0 && resourceState.thread.connectionScope !== "supervision" && shouldUseFreshCodexThreadAfterContextEngineOverflow({
+		if (started === void 0 && !params.providerReviewAcknowledgment && resourceState.thread.connectionScope !== "supervision" && shouldUseFreshCodexThreadAfterContextEngineOverflow({
 			error: turnStartError,
 			contextEngineActive: Boolean(activeContextEngine),
 			thread: resourceState.thread
@@ -7643,7 +8258,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 					}
 				});
 				try {
-					turn = await startCodexTurn();
+					started = await startCodexTurn();
 				} catch (retryError) {
 					turnStartError = retryError;
 				}
@@ -7651,7 +8266,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 		} catch (retrySetupError) {
 			turnStartError = retrySetupError;
 		}
-		if (turn === void 0) {
+		if (started === void 0) {
 			const usageLimitError = await formatCodexTurnStartUsageLimitError({
 				client: resourceState.client,
 				error: turnStartError,
@@ -7661,7 +8276,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				signal: runAbortController.signal
 			});
 			const message = usageLimitError?.message ?? formatErrorMessage(turnStartError);
-			if (isInvalidCodexImagePayloadError(message)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
+			if (!params.providerReviewAcknowledgment && isInvalidCodexImagePayloadError(message)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 				phase: "turn_start",
 				threadId: resourceState.thread.threadId,
 				error: message
@@ -7718,43 +8333,6 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				ctx: hookContext,
 				hookRunner
 			});
-			if ((isIncognitoSessionKey(params.sessionKey) ? await bindingStore.mutate(bindingIdentity, {
-				kind: "clear",
-				threadId: resourceState.thread.threadId
-			}) : true) && !resourceState.startupClientUnsafe) {
-				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-					threadId: resourceState.thread.threadId,
-					timeoutMs: 5e3
-				})) await runAgentCleanupStep({
-					runId: params.runId,
-					sessionId: params.sessionId,
-					step: "codex-retire-unsafe-startup-client",
-					log: embeddedAgentLog,
-					cleanup: async () => closeCodexStartupClientBestEffort(resourceState.client)
-				});
-			}
-			await releaseCurrentRoute();
-			activateNativePreToolUseFailureFallback();
-			const relay = resourceState.nativeHookRelay;
-			relay?.unregister();
-			await runAgentCleanupStep({
-				runId: params.runId,
-				sessionId: params.sessionId,
-				step: "codex-turn-start-failure-native-hook-relay",
-				log: embeddedAgentLog,
-				cleanup: async () => {
-					await relay?.drain();
-				}
-			});
-			await releaseSandboxExecEnvironment();
-			await runAgentCleanupStep({
-				runId: params.runId,
-				sessionId: params.sessionId,
-				step: "codex-trajectory-flush-startup-failure",
-				log: embeddedAgentLog,
-				cleanup: async () => trajectoryRecorder?.flush()
-			});
-			await releaseSharedClientLeaseAndRetireOneShotClient();
 			if (usageLimitError) {
 				await markCodexAuthProfileBlockedFromRateLimits({
 					params,
@@ -7786,11 +8364,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			throw turnStartError;
 		}
 	}
-	if (!turn) {
-		activateNativePreToolUseFailureFallback();
-		await releaseSharedClientLeaseAndRetireOneShotClient();
-		throw new Error("codex app-server turn/start failed without an error");
-	}
+	if (!started) throw new Error("codex app-server turn/start failed without an error");
 	const authoritySourceRef = context.attemptTools.scheduledAppAuthoritySourceRef;
 	if (resourceState.thread.pluginAppPolicyContext) authoritySourceRef.current = {
 		client: resourceState.client,
@@ -7798,9 +8372,9 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 		policyContext: resourceState.thread.pluginAppPolicyContext,
 		configCwd: connection.effectiveCwd
 	};
-	turnIdRef.current = turn.turn.id;
-	resourceState.nativeSubagentMonitor?.bindTurn(turn.turn.id);
-	return { turn };
+	turnIdRef.current = started.turn.turn.id;
+	resourceState.nativeSubagentMonitor?.bindTurn(started.turn.turn.id);
+	return started;
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-deadlines.ts
@@ -8018,44 +8592,50 @@ async function runCodexAppServerAttempt(params, options) {
 			const attemptContext = await preparation.measure("context", () => prepareCodexAttemptContext(runtime, attemptTools));
 			const resources = prepareCodexAttemptResources(await preparation.measure("prompt", () => prepareCodexAttemptPrompt(attemptContext)));
 			attemptTools.runtimeYieldCompletionClaim.current = () => resources.state.nativeHookRelay?.hasClaimedDirectChild() ?? false;
-			await preparation.measure("runtime-start", () => startCodexAttemptRuntime(resources));
-			const turnRuntime = createCodexAttemptTurnState(resources);
+			let activeTurnOwnsCleanup = false;
 			try {
-				const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
-				const notifications = createCodexAttemptNotificationController(resources, turnRuntime, lifecycle);
-				const serverRequests = createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle, notifications.waitForNativeTerminalItems);
-				const { ensureCurrentThreadRoute } = await preparation.measure("thread-route", () => prepareCodexAttemptRoute(resources, turnRuntime, notifications, serverRequests.handleServerRequest));
-				const turnRequest = await preparation.measure("turn-request", () => prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, notifications.waitForActiveNativeTurnCompletion));
-				preparation.ready();
-				const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
-				if ("result" in turnStart) return turnStart.result;
-				const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart.turn);
-				let finalizedResult;
+				await preparation.measure("runtime-start", () => startCodexAttemptRuntime(resources));
+				const turnRuntime = createCodexAttemptTurnState(resources);
 				try {
+					const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
+					const notifications = createCodexAttemptNotificationController(resources, turnRuntime, lifecycle);
+					const serverRequests = createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle, notifications.waitForNativeTerminalItems);
+					const { ensureCurrentThreadRoute } = await preparation.measure("thread-route", () => prepareCodexAttemptRoute(resources, turnRuntime, notifications, serverRequests.handleServerRequest));
+					const turnRequest = await preparation.measure("turn-request", () => prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, notifications.waitForActiveNativeTurnCompletion));
+					preparation.ready();
+					const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
+					if ("result" in turnStart) return turnStart.result;
+					const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart);
+					activeTurnOwnsCleanup = true;
+					let finalizedResult;
 					try {
-						await activeTurn.ready;
-						finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
-					} finally {
-						await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
+						try {
+							await activeTurn.ready;
+							finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
+						} finally {
+							await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
+						}
+					} catch (error) {
+						if (!finalizedResult || !turnRuntime.state.pluginRuntimeRefreshStop) throw error;
+						const original = attemptTerminal.project(finalizedResult.terminal).promptError;
+						finalizedResult.terminal = attemptTerminal.merge(finalizedResult.terminal, {
+							kind: "failed",
+							source: "prompt",
+							error: new AggregateError(original ? [original, error] : [error], "Plugin runtime changed, but native continuation failed. Inspect the existing thread before continuing; do not repeat completed actions.")
+						});
+						delete finalizedResult.pluginRuntimeRefreshMessages;
+						delete finalizedResult.settledTurnFinalizationContext;
 					}
-				} catch (error) {
-					if (!finalizedResult || !turnRuntime.state.pluginRuntimeRefreshStop) throw error;
-					const original = attemptTerminal.project(finalizedResult.terminal).promptError;
-					finalizedResult.terminal = attemptTerminal.merge(finalizedResult.terminal, {
-						kind: "failed",
-						source: "prompt",
-						error: new AggregateError(original ? [original, error] : [error], "Plugin runtime changed, but native continuation failed. Inspect the existing thread before continuing; do not repeat completed actions.")
-					});
-					delete finalizedResult.pluginRuntimeRefreshMessages;
-					delete finalizedResult.settledTurnFinalizationContext;
+					if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
+					return finalizedResult;
+				} finally {
+					turnRuntime.deadlines.dispose();
 				}
-				if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
-				return finalizedResult;
 			} finally {
-				turnRuntime.deadlines.dispose();
+				if (!activeTurnOwnsCleanup) await resources.cleanupBeforeActiveTurn();
 			}
 		} finally {
-			await attemptTools.disposeMcpTools();
+			await attemptTools.disposeTools(connection.runAbortController.signal.aborted ? "cancel" : "error");
 		}
 	} finally {
 		params.abortSignal?.removeEventListener("abort", connection.abortFromUpstream);