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

package/dist/.setup/{run-attempt-ClU8MxhZ.mjs → run-attempt-BcWArowv.mjs}

@@ -1,66 +1,65 @@
 import { n as readCodexRuntimeModelId } from "./model-runtime-BdqzOMkU.mjs";
-import { g as createCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-DmVhedNs.mjs";
-import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
-import { i as matchesCodexNativeSubagentSubmissionBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-DU_0biMD.mjs";
-import { n as defineCodexBuildState } from "./build-state-Ds14X10-.mjs";
+import { g as createCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-CTinVtjo.mjs";
+import { n as flattenCodexDynamicToolFunctions, r as isJsonObject, t as CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE } from "./protocol-CaPAVwe9.mjs";
+import { g as sessionBindingIdentity, i as matchesCodexNativeSubagentSubmissionBinding, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-C_THntMe.mjs";
+import { n as defineCodexBuildState } from "./build-state-VcujMRqP.mjs";
 import { c as withMcpElicitationsApprovalPolicy, d as readCodexRequirementsToml, n as hasCodexMcpToolApprovalOverrides, s as shouldAutoApproveCodexAppServerApprovals } from "./config-security-clxAZYWX.mjs";
 import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-DsWSCPHO.mjs";
 import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
 import { t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
-import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-DDzeNQ8m.mjs";
-import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey, w as retireSharedCodexAppServerClientIfCurrent } from "./auth-cache-key-f8ODJ_OX.mjs";
-import { i as withCodexAppServerGitConfig } from "./transport-stdio-CRWTkKOn.mjs";
-import { o as formatCodexDisplayText } from "./command-formatters-xW9KpoSZ.mjs";
-import { a as codexPrewriteRejectionCause, i as CodexAppServerScopedRequestRejectedError, r as CodexAppServerRpcError } from "./rpc-error-C98SHchT.mjs";
+import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-DMFZkd3X.mjs";
+import { D as retireSharedCodexAppServerClientIfCurrent, _ as observeAcquire, c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-CVcYw8HD.mjs";
+import { i as withCodexAppServerGitConfig } from "./transport-stdio-Bq160Dhv.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-B_7-QZ1c.mjs";
+import { a as codexPrewriteRejectionCause, r as CodexAppServerRpcError } from "./rpc-error-DemqqaxE.mjs";
 import { n as waitForPromiseOrAbort } from "./timeout-D0mEWSGG.mjs";
 import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.mjs";
-import { i as readCodexProviderRefusal, n as extractRawResponseItemText, o as readItem, r as readCodexErrorNotificationMessage, s as readNullableString } from "./event-projector-values-CLvG1Hil.mjs";
+import { i as readCodexProviderRefusal, n as extractRawResponseItemText, o as readItem, r as readCodexErrorNotificationMessage, s as readNullableString } from "./event-projector-values-yf4us9Pf.mjs";
 import { i as readMirrorIdentity, n as attachCodexMirrorIdentity, t as attachCodexAssistantItemIds } from "./upstream-prompt-provenance-Ccd9MFRJ.mjs";
-import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-Bg9DbDI6.mjs";
-import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-B7HAAZSI.mjs";
-import { n as requestCodexAppServerClientJson } from "./request-Bo0kKABI.mjs";
-import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-C1YVVLEA.mjs";
-import { a as isCodexDurableCustomMessage, c as resolveCodexContextEngineProjectionMaxChars, i as fitCodexProjectedContextForTurnStart, l as resolveCodexContinuityProjectionMaxChars, n as CodexContextAttachmentError, o as neutralizeCodexExplicitMentionSigils, r as buildCodexContinuityCalibration, s as projectContextEngineAssemblyForCodex, t as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, u as resolveProjectionPromptBudgetTokens } from "./context-engine-projection-ps-yn_ci.mjs";
+import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-DRb-niJc.mjs";
+import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-GTgUj9pi.mjs";
+import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-BfrAlTMT.mjs";
+import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-7W0cgTXF.mjs";
+import { a as isCodexDurableCustomMessage, c as resolveCodexContextEngineProjectionMaxChars, i as fitCodexProjectedContextForTurnStart, l as resolveCodexContinuityProjectionMaxChars, n as CodexContextAttachmentError, o as neutralizeCodexExplicitMentionSigils, r as buildCodexContinuityCalibration, s as projectContextEngineAssemblyForCodex, t as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, u as resolveProjectionPromptBudgetTokens } from "./context-engine-projection-PIeLSnR-.mjs";
 import { a as buildCodexMirrorIdempotencyKey, i as buildCodexMirrorDedupeIdentity, s as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-BzUXnrvv.mjs";
-import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BO6i_pfk.mjs";
-import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CgHQ8Vot.mjs";
-import { E as isCodexContextRestartSelectionChangedError, I as ensureCodexAppServerClientRuntime, M as getCodexInferenceThreadQualification, U as prepareCodexWorkspaceReferences, W as protectCodexAppServerLiveThread, X as readCodexRateLimitsRevision, Z as readRecentCodexRateLimits, _ as retainSharedCodexAppServerClientIfCurrent, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, dt as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, f as readCodexAppServerClientDesktopGenerationFingerprint, ft as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, gt as withCodexStartupTimeout, h as releaseLeasedSharedCodexAppServerClient, ht as resolveCodexStartupTimeoutMs, i as clearSharedCodexAppServerClientIfCurrent, j as getCodexInferenceThread, l as getSharedCodexAppServerClient, nt as resolveCodexAppServerPreparedAuthHandoff, s as createIsolatedCodexAppServerClient, tt as resolveCodexAppServerAuthAccountCacheKey, u as isCodexAppServerStartSelectionChangedError, ut as CodexAppServerStartupError, w as CodexThreadClientReplacementError, x as CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED } from "./shared-client-BCx1wbyA.mjs";
-import { a as isCodexResponsesOAuthRun, r as isCodexResponsesOAuth } from "./responses-oauth-twnuTaAa.mjs";
-import { D as toCodexDynamicToolProgressResponse, E as resolveDynamicToolCallTimeoutMs, L as resolveCodexAppServerClientInstanceId, M as readCodexAppServerWarningMessage, O as toCodexDynamicToolProtocolResponse, P as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS, T as handleDynamicToolCallWithTimeout, _ as assertCodexTurnStartResponse, a as isCodexAppServerIndeterminateRequestCancellationError, i as isCodexAppServerConnectionClosedError, l as CodexServerRequestResolvedError, o as isCodexAppServerIndeterminateTransportError, r as isCodexAppServerApprovalRequest, w as createCodexElicitationResponse, x as readCodexTurnCompletedNotification, y as readCodexDynamicToolCallParams } from "./client-D93nbdB8.mjs";
-import { n as isCodexWebSocketOpenFailure } from "./transport-websocket-DIyPfkHo.mjs";
-import { S as shouldClearTerminalPresentationForNativeItem, _ as itemName, a as isCodexNotificationForTurn, b as matchesCodexSnapshotTurn, i as CodexProjectionDiagnostics, n as getCodexAppServerTurnRouter, o as readCodexNotificationScope, s as readCodexNotificationThreadId, t as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, x as shouldAdvancePersistableAssistantBarrier } from "./turn-router-DBVMToGo.mjs";
-import { d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as shouldRetireCodexStartupClient } from "./attempt-client-cleanup-zNuNTKVr.mjs";
-import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BaxlhaNx.mjs";
-import { a as isRawFunctionToolOutputCompletionNotification, c as readRawResponseToolCallId, i as isCodexTurnAbortMarkerNotification, l as updateActiveTurnItemIds, o as isTerminalTurnStatus, r as completePendingOpenClawDynamicToolNotification, s as readCodexNotificationItem, t as CodexUsageProjection } from "./event-projector-usage-BpKfdoTm.mjs";
-import { n as listAllCodexAppServerModels } from "./models-BHpbAuz8.mjs";
-import { d as mergeCodexThreadConfigs } from "./project-doc-thread-config-BVcvnps8.mjs";
-import { B as resolveCodexDynamicToolsLoadingForRuntime, L as isSystemAgentOnlyCodexDynamicToolAllowlist, P as filterCodexDynamicTools, V as joinPresentSections, _ as buildDeveloperInstructions, b as codexDynamicToolsFingerprint, h as resolveCodexWebSearchPlan, k as stabilizeJsonValue, l as isCodexNativeDelegationDisabledForRun, v as areCodexDynamicToolFingerprintsCompatible, w as fingerprintJsonObject, x as codexLegacyDynamicToolsFingerprint } from "./thread-requests-BgzJwJtS.mjs";
-import { i as resolveCodexSessionBinding, n as createCodexSessionGenerationSupersededError, t as clearCodexBindingForClient } from "./session-binding-JEHNMPsr.mjs";
-import { i as resolveCodexAppServerThreadModelSelection } from "./thread-model-selection-DcVebr8N.mjs";
-import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-BQX8RHAd.mjs";
-import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-BoUd0i6L.mjs";
+import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-auwzSwwy.mjs";
+import { C as getCodexInferenceThread, F as prepareCodexWorkspaceReferences, I as protectCodexAppServerLiveThread, J as recordCodexTurnForkSettings, O as ensureCodexAppServerClientRuntime, Q as resolveCodexAppServerPreparedAuthHandoff, U as readCodexRateLimitsRevision, W as readRecentCodexRateLimits, Z as resolveCodexAppServerAuthAccountCacheKey, a as createIsolatedCodexAppServerClient, ct as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, dt as resolveCodexStartupTimeoutMs, f as releaseLeasedSharedCodexAppServerClient, ft as withCodexStartupTimeout, l as readCodexAppServerClientDesktopGenerationFingerprint, o as getLeasedSharedCodexAppServerClient, ot as CodexAppServerStartupError, p as retainSharedCodexAppServerClientIfCurrent, r as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, s as getSharedCodexAppServerClient, st as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, v as CodexThreadClientReplacementError, w as getCodexInferenceThreadQualification } from "./shared-client-CE_uY0A1.mjs";
+import { a as isCodexResponsesOAuthRun, r as isCodexResponsesOAuth } from "./responses-oauth-CCV7aVYF.mjs";
+import { C as createCodexElicitationResponse, D as toCodexDynamicToolProtocolResponse, E as toCodexDynamicToolProgressResponse, P as resolveCodexAppServerClientInstanceId, T as resolveDynamicToolCallTimeoutMs, a as isCodexAppServerIndeterminateTransportError, b as readCodexTurnCompletedNotification, c as CodexServerRequestResolvedError, g as assertCodexTurnStartResponse, i as isCodexAppServerIndeterminateRequestCancellationError, j as readCodexAppServerWarningMessage, r as isCodexAppServerApprovalRequest, v as readCodexDynamicToolCallParams, w as handleDynamicToolCallWithTimeout } from "./client-BS8X7HmG.mjs";
+import { s as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS } from "./client-initialize-CjgZcX61.mjs";
+import { S as shouldClearTerminalPresentationForNativeItem, _ as itemName, a as isCodexNotificationForTurn, b as matchesCodexSnapshotTurn, i as CodexProjectionDiagnostics, n as getCodexAppServerTurnRouter, o as readCodexNotificationScope, s as readCodexNotificationThreadId, t as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, x as shouldAdvancePersistableAssistantBarrier } from "./turn-router-Dbw17k3K.mjs";
+import { d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as shouldRetireCodexStartupClient } from "./attempt-client-cleanup-6OcbMH46.mjs";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-830RLAJW.mjs";
+import { a as isRawFunctionToolOutputCompletionNotification, c as readRawResponseToolCallId, i as isCodexTurnAbortMarkerNotification, l as updateActiveTurnItemIds, o as isTerminalTurnStatus, r as completePendingOpenClawDynamicToolNotification, s as readCodexNotificationItem, t as CodexUsageProjection } from "./event-projector-usage-CBY0Hkga.mjs";
+import { d as mergeCodexThreadConfigs } from "./project-doc-thread-config-B0UI3f1D.mjs";
+import { B as resolveCodexDynamicToolsLoadingForRuntime, L as isSystemAgentOnlyCodexDynamicToolAllowlist, P as filterCodexDynamicTools, V as joinPresentSections, _ as buildDeveloperInstructions, b as codexDynamicToolsFingerprint, h as resolveCodexWebSearchPlan, k as stabilizeJsonValue, l as isCodexNativeDelegationDisabledForRun, v as areCodexDynamicToolFingerprintsCompatible, w as fingerprintJsonObject, x as codexLegacyDynamicToolsFingerprint } from "./thread-requests-BjawdIVV.mjs";
+import { i as resolveCodexSessionBinding, n as createCodexSessionGenerationSupersededError, t as clearCodexBindingForClient } from "./session-binding-BgsWcbdY.mjs";
+import { i as resolveCodexAppServerThreadModelSelection } from "./thread-model-selection-DxposL4X.mjs";
+import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-DcOSH3J4.mjs";
+import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-t6Y9fLQS.mjs";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.mjs";
-import { a as CodexToolTranscriptProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolArguments, i as emitCodexAgentEvent, l as resolveCodexToolProgressDetailMode, o as CodexToolProgressProjection, r as CodexEventProjection, s as shouldEmitTranscriptToolProgress, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexAgentEventRecord } from "./native-subagent-monitor-DOLEIf9r.mjs";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-CD88q3yx.mjs";
-import { n as CodexThreadPolicyHandoffError, s as restoreCodexThreadInstructionsAfterCompaction } from "./thread-policy-B3wBRNph.mjs";
-import { t as attemptTerminal } from "./attempt-terminal-jO5IMj9K.mjs";
-import { a as runCodexAgentEndHook, c as withCodexAppServerFastModeServiceTier, i as reportCodexBackgroundCleanupFailure, n as ensureCodexWorkspaceDirOnce, o as runCodexCleanupStep, r as estimateCodexAppServerProjectedTurnTokens, s as shouldKeepCodexSharedAbortOpen, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-KN4oh-7O.mjs";
-import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-metadata-DCvcG_N_.mjs";
-import "./inference-context-DNlGwzwy.mjs";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-CLMKN4x-.mjs";
-import { a as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as shouldEnableCodexAppServerNativeToolSurface, i as resolveCodexAppServerHookChannelId, l as shouldRequireCodexSandboxExecServerEnvironment, o as resolveCodexMessageToolProvider, p as mapCodexAppServerRemoteWorkspacePath, r as resolveCodexAppServerExecutionCwd, s as resolveCodexSandboxEnvironmentSelection, t as buildDynamicTools, u as shouldWarnCodexDynamicToolBuildStageSummary } from "./dynamic-tool-build-DcaPmBlE.mjs";
-import { a as buildCodexNativeHookRelayDisabledConfig, d as scheduleCodexNativeHookRelayUnregister, i as buildCodexNativeHookRelayConfig, l as resolveCodexNativeHookRelayEvents, n as CodexManagedHooksOnlyError, r as assertCodexNativeHookRelayAllowed, s as createCodexNativeHookRelay, t as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, u as resolveCodexNativeHookRelayTtlMs } from "./native-hook-relay-wq7jrNLk.mjs";
-import { a as prepareCodexPluginThreadConfigStartupProvider, c as buildLegacyScheduledCodexAppRecoveryPrompt, d as resolveScheduledCodexAppCreatorCaptureDecision, i as isContextEngineBindingCompatible, l as buildScheduledCodexAppServerConnectionIdentity, n as isCodexAppServerProfilerEnabled, o as resolveCodexPluginThreadConfigStartupPolicy, r as buildContextEngineBinding, s as assertScheduledCodexAppAuthorityRuntime, t as startOrResumeThread, u as captureScheduledCodexAppAuthority } from "./thread-lifecycle-run-C_aYiYqk.mjs";
+import { a as CodexToolTranscriptProjection, c as asCodexToolArguments, i as emitCodexAgentEvent, l as isCodexCommandBearingToolCall, o as CodexToolProgressProjection, r as CodexEventProjection, s as shouldEmitTranscriptToolProgress, t as codexNativeSubagentMonitorRuntime, u as resolveCodexToolProgressDetailMode } from "./native-subagent-monitor-CFE7b4oC.mjs";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-DIZHLbAM.mjs";
+import { r as prepareCodexNativeExecutionPolicyForRun } from "./native-execution-policy-D09tLP-u.mjs";
+import { n as CodexThreadPolicyHandoffError, s as restoreCodexThreadInstructionsAfterCompaction } from "./thread-policy-Cy301Or8.mjs";
+import { t as attemptTerminal } from "./attempt-terminal-sZutF0WY.mjs";
+import { a as runCodexAgentEndHook, c as withCodexAppServerFastModeServiceTier, i as reportCodexBackgroundCleanupFailure, n as ensureCodexWorkspaceDirOnce, o as runCodexCleanupStep, r as estimateCodexAppServerProjectedTurnTokens, s as shouldKeepCodexSharedAbortOpen, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-DN-ATDp9.mjs";
+import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-metadata-CYFWLHVk.mjs";
+import "./inference-context-mv_dBpAL.mjs";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncDelivery } from "./event-projector-assistant-message-ChOAY7rW.mjs";
+import { a as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as shouldEnableCodexAppServerNativeToolSurface, i as resolveCodexAppServerHookChannelId, l as shouldRequireCodexSandboxExecServerEnvironment, o as resolveCodexMessageToolProvider, p as mapCodexAppServerRemoteWorkspacePath, r as resolveCodexAppServerExecutionCwd, s as resolveCodexSandboxEnvironmentSelection, t as buildDynamicTools, u as shouldWarnCodexDynamicToolBuildStageSummary } from "./dynamic-tool-build-BjFAIG-f.mjs";
+import { a as buildCodexNativeHookRelayDisabledConfig, d as scheduleCodexNativeHookRelayUnregister, i as buildCodexNativeHookRelayConfig, l as resolveCodexNativeHookRelayEvents, n as CodexManagedHooksOnlyError, r as assertCodexNativeHookRelayAllowed, s as createCodexNativeHookRelay, t as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, u as resolveCodexNativeHookRelayTtlMs } from "./native-hook-relay-C7aaLJaP.mjs";
+import { a as prepareCodexPluginThreadConfigStartupProvider, c as buildLegacyScheduledCodexAppRecoveryPrompt, d as resolveScheduledCodexAppCreatorCaptureDecision, i as isContextEngineBindingCompatible, l as buildScheduledCodexAppServerConnectionIdentity, n as isCodexAppServerProfilerEnabled, o as resolveCodexPluginThreadConfigStartupPolicy, r as buildContextEngineBinding, s as assertScheduledCodexAppAuthorityRuntime, t as startOrResumeThread, u as captureScheduledCodexAppAuthority } from "./thread-lifecycle-run-mLueY6pH.mjs";
 import { i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-CD2MAWU8.mjs";
-import { o as hasCodexNativeToolCatalog, s as loadCodexNativeToolCatalog } from "./native-skill-isolation-DSBeF-Yy.mjs";
-import { r as prepareCodexNativeMcpFormResourceContext, t as createCodexNativeMcpAppResultDetailsPreparer } from "./native-mcp-app-DX3nyTtc.mjs";
-import { _ as invalidateCodexComputerFrame, a as handleCodexAppServerApprovalRequest, c as createCodexNativePreToolUseFailureBuffer, f as buildTurnCollaborationMode, g as buildCodexUserInput, h as readCodexRetainedBackgroundCommands, i as createCodexDynamicToolDiagnostics, l as buildCodexHistoryProvenancePrefix, m as CodexNativeProcessAuthority, n as projectCodexExecutableDynamicTools, o as ensureCodexSandboxExecServerEnvironment, p as buildTurnStartParams, r as routeCodexAppServerElicitationRequest, s as releaseCodexSandboxExecServerEnvironment, t as createCodexDynamicToolBridge, u as buildCodexParentLocalInstructions, v as createCodexRemoteWorkspaceFileReader, y as CodexNativeToolLifecycleProjector } from "./dynamic-tools-CnQFnNKH.mjs";
-import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-Bee2o6jj.mjs";
-import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-D_zv8J7V.mjs";
-import { a as getCodexContextFileDisplayBasename, i as getCodexContextFileBasename, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as isNonEmptyString, r as buildCodexWorkspaceBootstrapContext, s as normalizeCodexContextFilePath } from "./attempt-workspace-context-CcwP3DA3.mjs";
+import { o as hasCodexNativeToolCatalog, s as loadCodexNativeToolCatalog } from "./native-skill-isolation-CMimsKYy.mjs";
+import { r as prepareCodexNativeMcpFormResourceContext, t as createCodexNativeMcpAppResultDetailsPreparer } from "./native-mcp-app-CsWj-v_x.mjs";
+import { _ as invalidateCodexComputerFrame, a as handleCodexAppServerApprovalRequest, c as createCodexNativePreToolUseFailureBuffer, f as buildTurnCollaborationMode, g as buildCodexUserInput, h as readCodexRetainedBackgroundCommands, i as createCodexDynamicToolDiagnostics, l as buildCodexHistoryProvenancePrefix, m as CodexNativeProcessAuthority, n as projectCodexExecutableDynamicTools, o as ensureCodexSandboxExecServerEnvironment, p as buildTurnStartParams, r as routeCodexAppServerElicitationRequest, s as releaseCodexSandboxExecServerEnvironment, t as createCodexDynamicToolBridge, u as buildCodexParentLocalInstructions, v as createCodexRemoteWorkspaceFileReader, y as CodexNativeToolLifecycleProjector } from "./dynamic-tools-XqWsVjcC.mjs";
+import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-CEQJZlF3.mjs";
+import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-Cog6mm2i.mjs";
+import { a as getCodexContextFileDisplayBasename, i as getCodexContextFileBasename, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as isNonEmptyString, r as buildCodexWorkspaceBootstrapContext, s as normalizeCodexContextFilePath } from "./attempt-workspace-context-GYPLawX6.mjs";
 import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-BPL6D3RO.mjs";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-Dn2WwH4P.mjs";
-import { a as runCodexComputerUseLiveTest, i as createComputerUseRequest, t as ensureCodexComputerUse } from "./computer-use-DL2v3Kxq.mjs";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-DjcKunHS.mjs";
+import { a as runCodexComputerUseLiveTest, i as createComputerUseRequest, t as ensureCodexComputerUse } from "./computer-use-FqQ-Flbl.mjs";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
@@ -70,23 +69,23 @@ import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-
 import path from "node:path";
 import fs from "node:fs/promises";
 import { isPathStrictlyInside, readFileWindowFully, root } from "openclaw/plugin-sdk/file-access-runtime";
+import { createStageTimingTracker, formatStageTimings } from "openclaw/plugin-sdk/time-runtime";
 import { addAbortListener } from "node:events";
 import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 import { Type } from "typebox";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { createStageTimingTracker, formatStageTimings } from "openclaw/plugin-sdk/time-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
 import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, HEARTBEAT_RESPONSE_TOOL_NAME, agentHarnessStructuredInput, applyEmbeddedAttemptToolsAllow, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, normalizeHeartbeatToolResponse, prepareWatchedSessionsHarnessContext, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
+import { loadExecApprovalsReadOnlyAsync } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { AgentHarnessProjectionSettlement, createAgentHarnessAttemptCancellation, createAgentHarnessAttemptDeadlineController, createAgentHarnessAttemptLifecycle, shouldIncludeAgentHarnessRuntimeContext } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
-import { getSessionEntry, patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { getSessionEntryAsync, prepareSessionEntryPatch, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { appendSessionYieldContext, composeSessionTranscriptWriteAssertion, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { acknowledgeInternalToolResult, createAgentHarnessToolExecutionRegistry } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
-import { createNativeSessionBindingAuthority, prepareNativeSessionGenerationAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
-import { appendSessionYieldContext, composeSessionTranscriptWriteAssertion, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { createNativeSessionBindingScope, createPreparedNativeSessionBindingAuthority, retainNativeSessionGenerationAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
+import { captureSessionEntryCurrentCheckAsync } from "openclaw/plugin-sdk/session-binding-runtime";
 import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
@@ -156,10 +155,7 @@ function createCodexQuestionInputHandlers(sessionKey, assertActive) {
 			sessionKey,
 			text,
 			authority: questionAuthority(authorityKind, assertCurrent, toolAuthorityPreparation),
-			sourceRecorder: optionsLocal.userTurnTranscriptRecorder,
-			persist: optionsLocal.userTurnTranscriptRecorder ? async () => {
-				await optionsLocal.userTurnTranscriptRecorder?.persistApproved();
-			} : void 0
+			sourceRecorder: optionsLocal.userTurnTranscriptRecorder
 		});
 	};
 	const cancelPendingUserInput = (resolvedBy, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run", toolAuthorityPreparation) => cancelPendingAgentQuestionForSession({
@@ -536,12 +532,13 @@ var CodexSteeringAssistantSegments = class {
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
-	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
+	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary, hasDeliveredFinalSourceReply) {
 		this.params = params;
 		this.emitAgentEvent = emitAgentEvent;
 		this.matchesToolProgressEcho = matchesToolProgressEcho;
 		this.nextTranscriptTimestamp = nextTranscriptTimestamp;
 		this.checkpointCommentary = checkpointCommentary;
+		this.hasDeliveredFinalSourceReply = hasDeliveredFinalSourceReply;
 		this.assistantTextByItem = /* @__PURE__ */ new Map();
 		this.assistantItemOrder = [];
 		this.assistantTimestampByItem = /* @__PURE__ */ new Map();
@@ -565,7 +562,7 @@ var CodexAssistantProjection = class {
 	async handleAssistantDelta(params) {
 		const itemId = readStringField(params, "itemId") ?? "assistant";
 		const delta = readStringField(params, "delta") ?? "";
-		if (!delta) return;
+		if (!delta || this.hasDeliveredFinalSourceReply?.()) return;
 		if (itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		const isCommentary = this.isCommentaryAssistantItem(itemId);
 		const isAsync = this.isAsyncAssistantItem(itemId);
@@ -574,6 +571,7 @@ var CodexAssistantProjection = class {
 			this.assistantStarted = true;
 			await this.params.onAssistantMessageStart?.();
 		}
+		if (this.hasDeliveredFinalSourceReply?.()) return;
 		this.rememberAssistantItem(itemId);
 		const text = `${this.assistantTextByItem.get(itemId) ?? ""}${delta}`;
 		this.assistantTextByItem.set(itemId, text);
@@ -606,6 +604,7 @@ var CodexAssistantProjection = class {
 		if (knownFinalAnswer && !replaceable) await this.params.onPartialReply?.(streamPayload);
 	}
 	async recordItemStarted(item, itemId) {
+		if (item?.type === "agentMessage" && this.hasDeliveredFinalSourceReply?.()) return;
 		this.noteNativeWorkBarrier(item);
 		this.rememberAssistantPhase(item);
 		if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
@@ -620,6 +619,7 @@ var CodexAssistantProjection = class {
 		});
 	}
 	recordItemCompleted(item, notification) {
+		if (item?.type === "agentMessage" && this.hasDeliveredFinalSourceReply?.()) return;
 		this.adoptSteeringPrefixForCompletion(item);
 		if (item?.type === "agentMessage" && (!notification || notification.itemId)) this.steeringSegments.recordCompletion(notification?.itemId ?? item.id);
 		if (notification) this.noteNativeWorkBarrier(item);
@@ -660,7 +660,7 @@ var CodexAssistantProjection = class {
 		const isPendingTerminalAssistantEcho = role === "assistant" && phase !== "commentary" && pendingTerminalAssistantEchoItemId !== void 0 && (rawItemId === void 0 || rawItemId === pendingTerminalAssistantEchoItemId);
 		if (pendingTerminalAssistantEchoItemId !== void 0 && !isPendingTerminalAssistantEcho) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		if (!isPendingTerminalAssistantEcho) this.markTerminalAssistantCandidateSupersededBy(rawItemId);
-		if (role !== "assistant") return;
+		if (role !== "assistant" || this.hasDeliveredFinalSourceReply?.()) return;
 		if (phase === "commentary" && this.pendingRawCommentaryEchoes > 0) {
 			this.pendingRawCommentaryEchoes -= 1;
 			return;
@@ -756,7 +756,7 @@ var CodexAssistantProjection = class {
 		this.persistedAssistantBoundary = true;
 	}
 	finalizeAnswerCandidate(turn) {
-		if (turn.status !== "completed") {
+		if (turn.status !== "completed" || this.hasDeliveredFinalSourceReply?.()) {
 			this.supersedeVisibleAnswerCandidate();
 			return;
 		}
@@ -957,15 +957,7 @@ var CodexAssistantProjection = class {
 		});
 	}
 	createAsyncDelivery(itemId) {
-		if (!this.isAsyncAssistantItem(itemId)) return;
-		const text = this.assistantTextByItem.get(itemId);
-		const timestamp = this.assistantTimestampByItem.get(itemId);
-		if (!text?.trim() || timestamp === void 0) return;
-		return {
-			itemId,
-			message: createAssistantAsyncMessage(this.params, text, itemId, timestamp, this.assistantQuestionsByItem.get(itemId)),
-			text
-		};
+		return this.isAsyncAssistantItem(itemId) ? createAssistantAsyncDelivery(this.params, this.assistantTextByItem.get(itemId), itemId, this.assistantTimestampByItem.get(itemId), this.assistantQuestionsByItem.get(itemId)) : void 0;
 	}
 	isToolProgressEchoText(itemId, text) {
 		return this.rawPromotedAssistantItemIds.has(itemId) && this.matchesToolProgressEcho(text);
@@ -997,7 +989,7 @@ var CodexAsyncDeliveryProjection = class {
 		return [...this.pendingDeliveries.values()];
 	}
 	async deliver(delivery) {
-		if (this.settledItemIds.has(delivery.itemId)) return;
+		if (this.options.hasDeliveredFinalSourceReply?.() || this.settledItemIds.has(delivery.itemId)) return;
 		const settlement = await this.options.onAsyncDelivery?.(delivery);
 		if (settlement === "settled") {
 			this.settledItemIds.add(delivery.itemId);
@@ -1516,7 +1508,7 @@ var CodexTranscriptCheckpoint = class {
 			});
 			try {
 				await codexTranscriptMirrorRuntime.mirror({
-					assertWriteCurrent: createNativeSessionBindingAuthority([], () => {
+					assertWriteCurrent: createNativeSessionBindingScope(() => {
 						if (this.state === "abandoned") throw new Error("Codex transcript checkpoint was retired before write");
 					}).assertLegacyCurrent,
 					...this.params.sessionTarget,
@@ -1597,7 +1589,9 @@ var CodexTurnProjection = class {
 		});
 		this.toolSearchEvidenceProjection = options.trajectoryRecorder && process.env.OPENCLAW_BUILD_PRIVATE_QA === "1" ? new CodexToolSearchEvidenceProjection(options.trajectoryRecorder, threadId, turnId) : void 0;
 		this.eventProjection = new CodexEventProjection(params.provider, threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
-		this.assistantProjection = new CodexAssistantProjection(this.settlement.params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
+		this.assistantProjection = new CodexAssistantProjection(this.settlement.params, (event) => {
+			if (!options.hasDeliveredFinalSourceReply?.()) this.emitAgentEvent(event);
+		}, (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary, options.hasDeliveredFinalSourceReply);
 		this.reasoningProjection = new CodexReasoningProjection(this.settlement.params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
 	}
 	get projectionClosed() {
@@ -1619,7 +1613,7 @@ var CodexTurnProjection = class {
 			for (const [id, processId] of options?.readRetainedNativeCommands?.() ?? []) if (pending.has(id) && (pending.get(id) === null || pending.get(id) === processId)) retainedCommands.set(id, processId);
 		}
 		this.nativeToolLifecycleProjector.finalizeActive(void 0, retainedCommands);
-		const assistantTexts = this.assistantProjection.collectAssistantTexts();
+		const assistantTexts = toolTelemetry.finalSourceReplyDelivered ? [] : this.assistantProjection.collectAssistantTexts();
 		const asyncMessages = this.assistantProjection.collectAsyncMessages();
 		const commentaryMessages = this.assistantProjection.collectCommentaryMessages();
 		const reasoningText = this.reasoningProjection.reasoningText();
@@ -1650,7 +1644,15 @@ var CodexTurnProjection = class {
 			providerRefusal
 		};
 		const lastAssistant = providerRefusal ? this.assistantProjection.createAssistantMessage("", assistantMessageOptions) : assistantTexts.length ? this.assistantProjection.createAssistantMessage(assistantTexts.join("\n\n"), assistantMessageOptions) : void 0;
-		const currentAttemptAssistant = providerRefusal ? lastAssistant : this.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
+		let currentAttemptAssistant = toolTelemetry.finalSourceReplyDelivered ? void 0 : providerRefusal ? lastAssistant : this.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
+		if (toolTelemetry.messagingToolSourceReplyPayloads?.some((reply) => reply.toolAuthoredForTurnId === turnId)) {
+			currentAttemptAssistant ??= this.assistantProjection.createAssistantMessage("", assistantMessageOptions);
+			currentAttemptAssistant = {
+				...currentAttemptAssistant,
+				turnId
+			};
+			if (lastAssistant) lastAssistant.turnId = turnId;
+		}
 		const messagesSnapshot = buildCodexMessagesSnapshot({
 			runParams,
 			turnId,
@@ -1744,6 +1746,15 @@ var CodexTurnProjection = class {
 //#endregion
 //#region extensions/codex/src/app-server/event-projector.ts
 const optedOutNotificationMethods = new Set(CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS);
+const RAW_TOOL_ITEM_PHASE = {
+	function_call: "started",
+	custom_tool_call: "started",
+	local_shell_call: "started",
+	tool_search_call: "started",
+	function_call_output: "completed",
+	custom_tool_call_output: "completed",
+	tool_search_output: "completed"
+};
 var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	constructor(..._args) {
 		super(..._args);
@@ -2192,6 +2203,17 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
+		const type = readStringField(item, "type");
+		const phase = type && Object.hasOwn(RAW_TOOL_ITEM_PHASE, type) ? RAW_TOOL_ITEM_PHASE[type] : void 0;
+		const itemId = readStringField(item, "call_id");
+		if (phase && itemId) this.emitAgentEvent({
+			stream: "codex_app_server.item",
+			data: {
+				phase,
+				itemId,
+				type
+			}
+		});
 		if (item.role === "assistant" && extractRawResponseItemText(item)) this.eventProjection.markSafetyBufferingAssistantStarted();
 		this.toolSearchEvidenceProjection?.recordRawResponseItem(item);
 		this.toolTranscriptProjection.recordRawNativeToolItem(item);
@@ -2626,20 +2648,24 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		}
 	}, resourceState.thread.threadId, activeTurnId, {
 		agentHookContext: hookContext,
+		hasDeliveredFinalSourceReply: () => toolBridge.telemetry.finalSourceReplyDelivered === true,
 		initialContextTokens: connection.mutable.startupContextTokens,
 		nativePostToolUseRelayEnabled: resourceState.nativeHookRelay?.allowedEvents.includes("post_tool_use") === true && resourceState.nativeHookRelay.shouldRelayEvent("post_tool_use"),
 		asyncUserMessageAllowed: params.disableTools !== true && (params.toolsAllow === void 0 || toolBridge.availableTools.some((tool) => tool.name === "message")),
 		onAsyncDelivery: async (delivery) => {
 			return await codexTranscriptMirrorRuntime.deliverAsyncMessageBestEffort({
-				params: prepareReplyMedia && projectionParams.onBlockReply ? {
+				params: projectionParams.onBlockReply ? {
 					...projectionParams,
 					onBlockReply: async (payload, options) => {
-						const prepared = await prepareReplyMedia({
+						const prepared = prepareReplyMedia ? await prepareReplyMedia({
 							kind: "payload",
 							payload
-						});
+						}) : {
+							kind: "payload",
+							payload
+						};
 						if (prepared.kind !== "payload") throw new Error("Reply media preparation returned the wrong result kind");
-						await projectionParams.onBlockReply?.(prepared.payload, options);
+						if (!toolBridge.telemetry.finalSourceReplyDelivered) await projectionParams.onBlockReply?.(prepared.payload, options);
 					}
 				} : projectionParams,
 				cwd: effectiveCwd,
@@ -2799,7 +2825,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
 			if (params.sessionTarget && messages.length > 0) {
 				await codexTranscriptMirrorRuntime.mirror({
-					assertCurrent: composeSessionTranscriptWriteAssertion([connection.assertLegacyCurrent, createNativeSessionBindingAuthority([], assertSteeringActive).assertLegacyCurrent]),
+					assertCurrent: composeSessionTranscriptWriteAssertion([connection.assertLegacyCurrent, createNativeSessionBindingScope(assertSteeringActive).assertLegacyCurrent]),
 					agentId: sessionAgentId,
 					sessionKey: contextSessionKey,
 					sessionId: params.sessionId,
@@ -3089,8 +3115,9 @@ function scopeCodexRunBindingStore(params) {
 	return {
 		...params.bindingStore,
 		read: (identity) => params.bindingStore.read(mapIdentity(identity)),
+		readAsync: (identity) => params.bindingStore.readAsync(mapIdentity(identity)),
 		readMany: (identities) => params.bindingStore.readMany(identities.map(mapIdentity)),
-		readNativeSubagentAssignments: (identity, owner) => (params.bindingStore.readNativeSubagentAssignments?.(mapIdentity(identity), mapHistoryOwner(identity, owner)) ?? []).map((assignment) => Object.assign({}, assignment, { owner: {
+		readNativeSubagentAssignments: async (identity, owner) => (await params.bindingStore.readNativeSubagentAssignments?.(mapIdentity(identity), mapHistoryOwner(identity, owner)) ?? []).map((assignment) => Object.assign({}, assignment, { owner: {
 			...assignment.owner,
 			sessionId: owner.sessionId
 		} })),
@@ -3339,6 +3366,7 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 //#region extensions/codex/src/app-server/run-attempt-connection.ts
 async function prepareCodexAttemptConnection({ params, options }) {
 	const attemptStartedAt = Date.now();
+	const attemptStartedAtMonotonicMs = performance.now();
 	const profilerEnabled = isCodexAppServerProfilerEnabled(params.config);
 	const codexModelCallTrace = freezeDiagnosticTraceContext(createDiagnosticTraceContextFromActiveScope());
 	const codexModelContentCapture = resolveDiagnosticModelContentCapturePolicy(params.config);
@@ -3371,12 +3399,17 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		sessionKey: sandboxSessionKey,
 		workspaceDir: resolvedWorkspace
 	});
+	const ownedSandbox = params.sandbox === void 0 ? sandbox : void 0;
+	let sandboxTransferred = false;
+	using _ = { [Symbol.dispose]: () => {
+		if (!sandboxTransferred) ownedSandbox?.[Symbol.dispose]?.();
+	} };
 	const attemptClientFactory = options.clientFactory ?? (isCodexPairedNodeRemoteExecPlacementSandbox(sandbox) ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient);
 	preDynamicStartupStages.mark("sandbox");
 	const execPolicy = resolveOpenClawExecPolicyForCodexAppServer({
 		permissionMode: params.permissionMode,
 		execOverrides: params.execOverrides,
-		approvals: params.permissionMode === "full" ? void 0 : loadExecApprovals(),
+		approvals: params.permissionMode === "full" ? void 0 : await loadExecApprovalsReadOnlyAsync(),
 		config: params.config,
 		agentId: policyAgentId
 	});
@@ -3433,15 +3466,23 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	preDynamicStartupStages.mark("session-agent");
 	let activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
 	const isInactiveThreadBootstrapBinding = (binding) => !activeContextEngine && binding?.contextEngine?.projection?.mode === "thread_bootstrap";
+	let generationAuthority;
+	let generationAuthorityTransferred = false;
+	using captures = new DisposableStack();
+	captures.defer(() => {
+		if (!generationAuthorityTransferred) generationAuthority?.release();
+	});
 	if (bindingIdentity.kind === "session" && bindingIdentity.sessionKey) {
-		const { state: authority } = await prepareNativeSessionGenerationAuthority({
+		generationAuthority = await retainNativeSessionGenerationAuthority({
 			config: params.config,
 			storePath: params.sessionTarget?.storePath,
 			target: bindingIdentity,
 			createSupersededError: createCodexSessionGenerationSupersededError
 		});
-		if (authority === "superseded") throw createCodexSessionGenerationSupersededError(bindingIdentity.sessionId);
-		if (authority === "ephemeral") {
+		if (generationAuthority.state === "superseded") throw createCodexSessionGenerationSupersededError(bindingIdentity.sessionId);
+		if (generationAuthority.state === "ephemeral") {
+			generationAuthority.release();
+			generationAuthority = void 0;
 			const logicalIdentity = bindingIdentity;
 			const physicalIdentity = {
 				kind: "session",
@@ -3458,8 +3499,10 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	}
 	let modelExecution;
 	const assertModelExecutionCurrent = () => modelExecution?.assertCurrent();
-	const { binding: admittedBinding, authority: bindingAuthority } = await resolveCodexSessionBinding({
+	generationAuthorityTransferred = true;
+	const { binding: admittedBinding, authority: bindingAuthority, release: releaseBindingAuthority } = await resolveCodexSessionBinding({
 		reclaimStale: true,
+		generationAuthority,
 		bindingStore,
 		identity: bindingIdentity,
 		config: params.config,
@@ -3468,11 +3511,15 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		signal: params.abortSignal,
 		assertBinding: params.expectedSessionRuntimeOwnership ? (binding) => assertCodexSessionRuntimeOwnership(binding, params.expectedSessionRuntimeOwnership) : void 0
 	});
+	let bindingAuthorityTransferred = false;
+	captures.defer(() => {
+		if (!bindingAuthorityTransferred) releaseBindingAuthority();
+	});
 	const assertCurrent = () => {
 		bindingAuthority.assertCurrent();
 		assertModelExecutionCurrent();
 	};
-	const authority = createNativeSessionBindingAuthority(bindingAuthority.lineage, assertCurrent);
+	const authority = bindingAuthority.withLiveness(assertCurrent);
 	let startupBinding = admittedBinding;
 	preDynamicStartupStages.mark("read-binding");
 	const usesSupervisionConnection = startupBinding?.connectionScope === "supervision";
@@ -3500,7 +3547,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		authProfileId: startupAuthProfileCandidate,
 		store: params.authProfileStore,
 		config: params.config
-	}) : resolveCodexAppServerAuthProfileIdForAgent({
+	}) : await resolveCodexAppServerAuthProfileIdForAgent({
 		authProfileId: startupAuthProfileCandidate,
 		agentDir,
 		config: params.config
@@ -3667,6 +3714,8 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		};
 		const resolveRuntimeOptionsForCurrentBinding = async (selection) => resolveFinalAppServer(await resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection);
 		assertCurrent();
+		sandboxTransferred = true;
+		bindingAuthorityTransferred = true;
 		return {
 			params,
 			prepareInputAttachments: async (request) => {
@@ -3701,6 +3750,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			},
 			assertCurrent,
 			authority,
+			releaseBindingAuthority,
 			withCurrent: authority.withCurrent,
 			assertLegacyCurrent: authority.assertLegacyCurrent,
 			assertModelExecutionCurrent,
@@ -3708,6 +3758,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			releaseModelExecution,
 			options,
 			attemptStartedAt,
+			attemptStartedAtMonotonicMs,
 			profilerEnabled,
 			codexModelCallTrace,
 			codexModelContentCapture,
@@ -3725,6 +3776,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			sandboxSessionKey,
 			contextSessionKey,
 			sandbox,
+			releaseSandboxContext: () => ownedSandbox?.[Symbol.dispose]?.(),
 			agentDir,
 			shellEnvironment,
 			shellPathPrepend,
@@ -4057,6 +4109,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	};
 	const hookContext = {
 		runId: params.runId,
+		config: params.config,
 		agentId: sessionAgentId,
 		sessionKey: contextSessionKey,
 		sessionId: params.sessionId,
@@ -4633,7 +4686,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			const completedTurnStatus = activeProjector.getCompletedTurnStatus();
 			const locallyCompletedTurn = state.completed && state.localCompletionRequested && !state.timeout && clientClosedPromptErrorForFinal === void 0;
 			const turnSucceeded = !finalAborted && !effectiveTimedOut && (finalPromptError === null || finalPromptError === void 0) && (completedTurnStatus === "completed" || locallyCompletedTurn);
-			if (toolBridge.telemetry.messagingToolSentTargets.some((target) => target.sourceReplyFinal === true)) result.agentHarnessResultClassification = void 0;
+			if (toolBridge.telemetry.finalSourceReplyDelivered || toolBridge.telemetry.messagingToolSentTargets.some((target) => target.sourceReplyFinal === true)) result.agentHarnessResultClassification = void 0;
 			const attemptSucceeded = turnSucceeded && result.agentHarnessResultClassification === void 0;
 			result.terminal = attemptTerminal.normalize({
 				settlementWarning: state.settlementWarning,
@@ -4674,7 +4727,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			const mirrorTerminal = projectTerminalOutcome();
 			state.pendingSettlementStage = "transcript/mirror";
 			return codexTranscriptMirrorRuntime.mirrorBestEffort({
-				assertWriteCurrent: createNativeSessionBindingAuthority([], () => {
+				assertWriteCurrent: createNativeSessionBindingScope(() => {
 					if (!isSettlementActive() || state.settlementWarning !== warning) throw new Error("Codex transcript settlement is no longer active");
 					const current = projectTerminalOutcome();
 					if (current.finalAborted !== mirrorTerminal.finalAborted || current.effectiveTimedOut !== mirrorTerminal.effectiveTimedOut || current.finalPromptError !== mirrorTerminal.finalPromptError) throw new Error("Codex transcript terminal outcome changed before write");
@@ -4912,24 +4965,42 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 	const { connection } = prompt.context.runtime;
 	const { params, attemptStartedAt, runAbortController, fastModeAutoStartedAtMs, fastModeAutoProgressState } = connection;
 	const { state, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds } = turnRuntime;
-	const batchHadNonTerminalResult = () => state.currentTurnHadNonTerminalDynamicToolResult && !state.currentTurnHadToolAuthoredFinalReply;
+	let modelResponse;
+	let lastClosedResponseId;
+	const resolveAuthoredResponse = () => {
+		if (!modelResponse?.closed || modelResponse.calls.size === 0) return;
+		const results = [];
+		for (const { result } of modelResponse.calls.values()) {
+			if (!result?.response.success || result.response.terminate !== true) return;
+			results.push(result);
+		}
+		const payloads = results.flatMap((result) => result.response.toolAuthoredSourceReply ? [result.response.toolAuthoredSourceReply] : []);
+		const value = results[0];
+		return value && payloads.length > 0 ? {
+			value,
+			payloads
+		} : void 0;
+	};
 	const scheduleTerminalDynamicToolReleaseCheck = () => {
-		if (state.terminalDynamicToolReleaseCheckScheduled || !state.pendingTerminalDynamicToolRelease && !state.currentTurnHadNonTerminalDynamicToolResult) return;
+		if (state.terminalDynamicToolReleaseCheckScheduled || !state.pendingTerminalDynamicToolRelease && !state.currentTurnHadNonTerminalDynamicToolResult && !resolveAuthoredResponse()) return;
 		state.terminalDynamicToolReleaseCheckScheduled = true;
 		setImmediate(() => {
 			state.terminalDynamicToolReleaseCheckScheduled = false;
-			if (state.pendingTerminalDynamicToolRelease?.response.success === true && !batchHadNonTerminalResult() && state.activeAppServerTurnRequests === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0) turnRuntime.steeringQueueRef.current?.cancel();
+			if (modelResponse && (!modelResponse.closed || [...modelResponse.calls.values()].some((call) => call.direct && !call.result))) return;
+			const deliveredFinal = state.pendingTerminalDynamicToolRelease?.response.finalSourceReplyDelivered === true;
+			const authored = deliveredFinal ? void 0 : resolveAuthoredResponse();
+			if (!authored && (deliveredFinal || state.pendingTerminalDynamicToolRelease?.response.success === true) && (deliveredFinal || !state.currentTurnHadNonTerminalDynamicToolResult) && state.activeAppServerTurnRequests === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0) turnRuntime.steeringQueueRef.current?.cancel();
 			if (state.activeAppServerTurnRequests > 0 || activeTurnItemIds.size > 0 || pendingOpenClawDynamicToolCompletionIds.size > 0) return;
-			if (batchHadNonTerminalResult()) {
+			if (!authored && !deliveredFinal && state.currentTurnHadNonTerminalDynamicToolResult) {
 				state.pendingTerminalDynamicToolRelease = void 0;
 				state.currentTurnHadNonTerminalDynamicToolResult = false;
-				state.currentTurnHadToolAuthoredFinalReply = false;
 				return;
 			}
-			const value = state.pendingTerminalDynamicToolRelease;
-			if (!value || state.completed || runAbortController.signal.aborted || !value.response.success || state.activeAppServerTurnRequests !== 0 || activeTurnItemIds.size !== 0 || pendingOpenClawDynamicToolCompletionIds.size !== 0) return;
+			const value = authored?.value ?? state.pendingTerminalDynamicToolRelease;
+			if (!value || state.completed || runAbortController.signal.aborted || !value.response.success && !deliveredFinal) return;
 			state.pendingTerminalDynamicToolRelease = void 0;
-			state.currentTurnHadToolAuthoredFinalReply = false;
+			modelResponse = void 0;
+			if (authored) prompt.context.attemptTools.toolBridge.telemetry.messagingToolSourceReplyPayloads.push(...authored.payloads);
 			trajectoryRecorder?.recordEvent("turn.dynamic_tool_terminal_release", {
 				threadId: value.call.threadId,
 				turnId: value.call.turnId,
@@ -4950,16 +5021,47 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		}).unref?.();
 	};
 	const recordDynamicToolResult = (value) => {
-		if (value.response.success && value.response.toolAuthoredFinalReply === true) state.currentTurnHadToolAuthoredFinalReply = true;
-		if (value.response.terminate === true && value.response.success) {
-			state.pendingTerminalDynamicToolRelease = value;
+		const modelCall = modelResponse?.calls.get(value.call.callId);
+		if (modelCall) modelCall.result = value;
+		if (value.response.toolAuthoredSourceReply) {
+			if (modelCall && !state.pendingTerminalDynamicToolRelease?.response.finalSourceReplyDelivered) state.pendingTerminalDynamicToolRelease = void 0;
 			scheduleTerminalDynamicToolReleaseCheck();
-		} else if (value.response.asyncStarted === true) scheduleTerminalDynamicToolReleaseCheck();
+			return;
+		}
+		if (value.response.terminate === true && (value.response.success || value.response.finalSourceReplyDelivered)) {
+			if (value.response.finalSourceReplyDelivered || !state.pendingTerminalDynamicToolRelease?.response.finalSourceReplyDelivered && ![...modelResponse?.calls.values() ?? []].some((call) => call.result?.response.toolAuthoredSourceReply)) state.pendingTerminalDynamicToolRelease = value;
+			scheduleTerminalDynamicToolReleaseCheck();
+		} else if (value.response.success && value.response.asyncStarted === true) scheduleTerminalDynamicToolReleaseCheck();
 		else {
 			state.currentTurnHadNonTerminalDynamicToolResult = true;
-			if (!state.currentTurnHadToolAuthoredFinalReply) state.pendingTerminalDynamicToolRelease = void 0;
+			if (!state.pendingTerminalDynamicToolRelease?.response.finalSourceReplyDelivered) state.pendingTerminalDynamicToolRelease = void 0;
 		}
 	};
+	const recordModelResponseNotification = (notification) => {
+		const notificationParams = notification.params;
+		if (!isJsonObject(notificationParams)) return;
+		if (notification.method === "rawResponse/completed") {
+			const responseId = notificationParams.responseId;
+			if (typeof responseId !== "string" || !responseId || responseId === lastClosedResponseId) return;
+			lastClosedResponseId = responseId;
+			if (!modelResponse || modelResponse.closed) modelResponse = {
+				closed: false,
+				calls: /* @__PURE__ */ new Map()
+			};
+			modelResponse.closed = true;
+			scheduleTerminalDynamicToolReleaseCheck();
+			return;
+		}
+		if (notification.method !== "rawResponseItem/completed" || !isJsonObject(notificationParams.item)) return;
+		const callId = readRawResponseToolCallId(notification);
+		const item = notificationParams.item;
+		if (!(callId !== void 0 || item.type === "reasoning" || item.type === "message" && item.role === "assistant")) return;
+		if (!modelResponse || modelResponse.closed) modelResponse = {
+			closed: false,
+			calls: /* @__PURE__ */ new Map()
+		};
+		if (callId && !modelResponse.calls.has(callId)) modelResponse.calls.set(callId, { direct: item.namespace === CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE });
+	};
 	const { emitLifecycleStart, emitLifecycleTerminal, emitExecutionPhaseOnce } = createAgentHarnessAttemptLifecycle({
 		attempt: params,
 		backend: "codex-app-server",
@@ -5038,6 +5140,7 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		}
 	};
 	return {
+		recordModelResponseNotification,
 		recordDynamicToolResult,
 		scheduleTerminalDynamicToolReleaseCheck,
 		emitLifecycleStart,
@@ -5082,14 +5185,14 @@ async function projectCodexSessionWarning(params) {
 		return await params.project();
 	};
 	try {
-		await patchSessionEntry({
+		await prepareSessionEntryPatch({
 			agentId: session.agentId,
 			sessionKey: session.sessionKey,
 			storePath: session.storePath,
 			preserveActivity: true,
 			requireWriteSuccess: true,
 			skipMaintenance: true,
-			update: async (entry) => {
+			prepare: async (entry) => {
 				foundSession = true;
 				params.assertCurrent();
 				if (entry.sessionId !== session.sessionId || session.expectedLifecycleRevision !== void 0 && entry.lifecycleRevision !== session.expectedLifecycleRevision) return null;
@@ -5130,7 +5233,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const { appServer, runAbortController } = runtime.connection;
 	const { allocateCodexToolOutcomeOrdinal } = attemptTools;
 	const { state, turnIdRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, openClawDynamicToolExecutions, completeTurn, noteProgress, deadlines } = turnRuntime;
-	const { scheduleTerminalDynamicToolReleaseCheck, reportExecutionNotification, maybeAnnounceFastModeAutoOff } = lifecycle;
+	const { recordModelResponseNotification, scheduleTerminalDynamicToolReleaseCheck, reportExecutionNotification, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const pendingNativeCommandItems = /* @__PURE__ */ new Set();
 	let nativeItemsCompletion;
 	const waitForNativeTerminalItems = async (signal) => {
@@ -5246,6 +5349,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			deadlines.beginSettlement(receivedAtMs);
 		}
 		if (scope.turnId === turnId) {
+			recordModelResponseNotification(notification);
 			const modelToolCallId = readRawResponseToolCallId(notification);
 			if (modelToolCallId) allocateCodexToolOutcomeOrdinal?.(modelToolCallId);
 			const nativeItem = readCodexNotificationItem(notification.params);
@@ -5283,12 +5387,13 @@ async function prepareCodexAttemptPrompt(context) {
 	const { toolBridge } = attemptTools;
 	const availableToolNames = () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString);
 	const nativeHistoryProvenancePrefix = params.trigger === "user" ? buildCodexHistoryProvenancePrefix(params) : void 0;
-	const forkedSession = !mutable.startupBinding?.threadId && params.sessionTarget ? getSessionEntry({
+	const forkedSession = !mutable.startupBinding?.threadId && params.sessionTarget ? await getSessionEntryAsync({
 		...params.sessionTarget,
 		sessionKey: contextSessionKey,
 		hydrateSkillPromptRefs: false,
 		readConsistency: "latest"
 	}) : void 0;
+	connection.assertCurrent();
 	const preserveForkedToolResults = Boolean(forkedSession?.sessionId === params.sessionId && forkedSession.createdVia === "spawn" && forkedSession.parentSessionKey && forkedSession.parentSessionKey !== contextSessionKey && forkedSession.forkSource?.sessionKey === forkedSession.parentSessionKey && forkedSession.forkSource.sessionId !== params.sessionId);
 	let contextImageGroups = [];
 	let turnContextImageGroups = [];
@@ -5332,7 +5437,8 @@ async function prepareCodexAttemptPrompt(context) {
 			maxRenderedContextChars: codexContinuityProjectionMaxChars,
 			toolPayloadMode: params.continuation || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
 			prepareFileContext,
-			currentUserTurnIdempotencyKey
+			currentUserTurnIdempotencyKey,
+			currentUserMessage: admittedMessage
 		});
 		assertProjectionCurrent();
 		contextImageGroups = projection.imageGroups ?? [];
@@ -5381,7 +5487,8 @@ async function prepareCodexAttemptPrompt(context) {
 				maxRenderedContextChars: codexContextProjectionMaxChars,
 				toolPayloadMode: contextEngineProjection || params.continuation || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
 				...projectionDecision.project ? { prepareFileContext } : {},
-				currentUserTurnIdempotencyKey
+				currentUserTurnIdempotencyKey,
+				currentUserMessage: admittedMessage
 			});
 			assertProjectionCurrent();
 			contextImageGroups = projectionDecision.project ? projection.imageGroups ?? [] : [];
@@ -5639,6 +5746,16 @@ function buildCodexHookRequester(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-subagent-assignment-store.ts
+/** Accepted child writes retain the captured parent lifecycle beyond foreground settlement. */
+function createNativeSubagentSessionAuthority(parent) {
+	if (!parent) return;
+	return createPreparedNativeSessionBindingAuthority({
+		lineage: [],
+		source: parent.source,
+		entryChecks: parent.entryCurrent ? [parent.entryCurrent] : [],
+		assertCurrent: () => parent.source.assertScopeCurrent()
+	});
+}
 function createNativeSubagentAssignmentStore(params) {
 	const { bindingStore, identity, owner } = params;
 	const assertCurrent = () => {
@@ -5646,6 +5763,10 @@ function createNativeSubagentAssignmentStore(params) {
 		const binding = bindingStore.read(identity);
 		if (!binding || !matchesCodexNativeSubagentSubmissionBinding(binding, owner)) throw new Error("Native assignment binding is no longer current.");
 	};
+	const assertCurrentAsync = async () => {
+		await params.assertLifecycleCurrentAsync?.();
+		assertCurrent();
+	};
 	const mutate = (kind) => (assignment, assertSourceCurrent) => bindingStore.mutate(identity, {
 		kind,
 		owner,
@@ -5653,17 +5774,44 @@ function createNativeSubagentAssignmentStore(params) {
 	}, () => {
 		assertCurrent();
 		assertSourceCurrent();
-	});
+	}, params.authority);
 	return {
 		assertCurrent,
-		read: () => {
-			assertCurrent();
-			return bindingStore.readNativeSubagentAssignments?.(identity, owner) ?? [];
+		assertCurrentAsync,
+		read: async () => {
+			const assignments = await bindingStore.readNativeSubagentAssignments?.(identity, owner) ?? [];
+			await assertCurrentAsync();
+			return assignments;
 		},
 		record: mutate("record-native-subagent-assignment"),
 		consume: mutate("consume-native-subagent-assignment")
 	};
 }
+function createNativeSubagentSubmissionStore(params) {
+	const { bindingStore, identity, owner } = params;
+	const assertCurrent = () => {
+		const current = bindingStore.read(identity);
+		if (!current || !matchesCodexNativeSubagentSubmissionBinding(current, owner)) throw new Error("Native submission binding is no longer current.");
+	};
+	return {
+		assertCurrent,
+		assertCurrentAsync: async () => {
+			await params.assertLifecycleCurrentAsync();
+			assertCurrent();
+		},
+		read: () => bindingStore.readNativeSubagentSubmissions(identity, owner),
+		record: (receipt, assertSourceCurrent) => bindingStore.mutate(identity, {
+			kind: "record-native-subagent-submission",
+			owner,
+			receipt
+		}, assertSourceCurrent, params.authority),
+		consume: (receipt, assertSourceCurrent) => bindingStore.mutate(identity, {
+			kind: "consume-native-subagent-submission",
+			owner,
+			receipt
+		}, assertSourceCurrent, params.authority)
+	};
+}
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-resources.ts
 function prepareCodexAttemptResources(prompt) {
@@ -5679,7 +5827,7 @@ function prepareCodexAttemptResources(prompt) {
 		modelAdmissionSource?.release();
 	}
 	let nativeProcessAuthorityReleased = false;
-	const cleanupAuthority = createNativeSessionBindingAuthority(connection.authority.lineage, () => {
+	const cleanupAuthority = connection.authority.withLiveness(() => {
 		params.hostCapabilities.assertActive();
 		if (nativeProcessAuthorityReleased) throw new Error("Codex attempt cleanup authority has ended");
 	});
@@ -5787,103 +5935,110 @@ function prepareCodexAttemptResources(prompt) {
 		await nativeSubagentMonitorSettlement;
 	};
 	const registerNativeSubagentMonitor = async (parentThreadId) => {
+		const requestCustody = params.hostCapabilities.captureRequestCustody?.();
 		const { client, thread, nativeHookRelay, turnRoute } = state;
-		await unregisterNativeSubagentMonitor();
-		connection.assertCurrent();
-		const generation = ++nativeSubagentMonitorGeneration;
-		const sessionKey = params.sessionKey;
+		const sessionKey = params.sessionTarget?.sessionKey ?? params.sessionKey;
 		const storePath = params.sessionTarget?.storePath;
-		const readParentSession = () => sessionKey && storePath ? getSessionEntry({
-			agentId: sessionAgentId,
+		const parent = sessionKey && storePath ? await captureSessionEntryCurrentCheckAsync({
+			agentId: params.sessionTarget?.agentId ?? sessionAgentId,
 			sessionKey,
 			storePath,
-			readConsistency: "latest",
-			hydrateSkillPromptRefs: false
-		}) : void 0;
-		const parentSession = readParentSession();
-		const historyOwner = createCodexNativeSubagentHistoryOwner({
-			parentThreadId,
-			sessionId: params.sessionId,
-			...parentSession?.sessionId === params.sessionId ? { lifecycleRevision: parentSession.lifecycleRevision } : {},
-			binding: thread
-		});
-		const { bindingStore, bindingIdentity } = connection;
-		const assertParentSessionCurrent = () => {
-			if (historyOwner?.lifecycleRevision && sessionKey && storePath) {
-				if (readParentSession()?.lifecycleRevision !== historyOwner.lifecycleRevision) throw new Error("Native submission session lifecycle is no longer current.");
-			}
-		};
-		const submissionStore = historyOwner && thread.lifecycle.preserveExistingBinding !== true ? {
-			assertCurrent: () => {
-				const current = bindingStore.read(bindingIdentity);
-				if (!current || !matchesCodexNativeSubagentSubmissionBinding(current, historyOwner)) throw new Error("Native submission binding is no longer current.");
-				assertParentSessionCurrent();
-			},
-			read: () => bindingStore.readNativeSubagentSubmissions(bindingIdentity, historyOwner),
-			record: (receipt, assertCurrent) => bindingStore.mutate(bindingIdentity, {
-				kind: "record-native-subagent-submission",
-				owner: historyOwner,
-				receipt
-			}, assertCurrent),
-			consume: (receipt, assertCurrent) => bindingStore.mutate(bindingIdentity, {
-				kind: "consume-native-subagent-submission",
-				owner: historyOwner,
-				receipt
-			}, assertCurrent)
-		} : void 0;
-		const assignmentStore = historyOwner && submissionStore ? createNativeSubagentAssignmentStore({
-			bindingStore,
-			identity: bindingIdentity,
-			owner: historyOwner,
-			assertLifecycleCurrent: () => submissionStore.assertCurrent()
+			errorMessage: "Native submission session lifecycle is no longer current."
 		}) : void 0;
-		const assertRegistrationCurrent = () => {
-			runAbortController.signal.throwIfAborted();
-			params.hostCapabilities.assertActive();
-			connection.assertCurrent();
-			if (submissionStore) submissionStore.assertCurrent();
-			else assertParentSessionCurrent();
-			thread.liveThreadOwnership?.assertCurrent();
-			if (generation !== nativeSubagentMonitorGeneration || state.client !== client || state.thread !== thread || state.nativeHookRelay !== nativeHookRelay || state.turnRoute !== turnRoute) throw new Error("Codex native subagent registration was superseded during setup");
-		};
-		const retainModelSource = params.hostCapabilities.retainSourceAuthority;
-		const modelSource = retainModelSource?.();
+		let parentTransferred = false;
 		try {
-			const configurationQualification = getCodexInferenceThreadQualification(client, parentThreadId);
-			const registration = await codexNativeSubagentMonitorRuntime.register({
-				client,
+			await unregisterNativeSubagentMonitor();
+			connection.assertCurrent();
+			const generation = ++nativeSubagentMonitorGeneration;
+			const parentSession = parent?.entry;
+			const historyOwner = createCodexNativeSubagentHistoryOwner({
 				parentThreadId,
-				...retainModelSource ? { modelSource } : {},
-				configurationQualification,
-				unqualifiedModelExecution: modelSource && !configurationQualification ? true : void 0,
-				onUnqualifiedModelCancelled: connection.abortExplicitly,
-				requesterSessionKey: params.sessionKey,
-				completionScope: params.agentHarnessCompletionScope,
-				historyOwner,
-				submissionStore,
-				assignmentStore,
-				agentId: sessionAgentId,
-				assertCurrent: assertRegistrationCurrent,
-				isTurnYielded: () => attemptTools.toolState.yieldDetected,
-				retainClient: () => retainSharedCodexAppServerClientIfCurrent(client),
-				retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(client, protectedThreadId),
-				claimDirectChild: (childThreadId) => nativeHookRelay?.claimDirectChild(childThreadId),
-				rejectPendingDirectChild: (childThreadId, reason) => nativeHookRelay?.rejectPendingDirectChild(childThreadId, reason),
-				...params.sessionKey && params.agentHarnessCompletionScope ? { onDirectChildAccepted: () => {
-					state.runtimeContinuationStarted = true;
-				} } : {}
+				sessionId: params.sessionId,
+				...parentSession?.sessionId === params.sessionId ? { lifecycleRevision: parentSession.lifecycleRevision } : {},
+				binding: thread
 			});
+			const { bindingStore, bindingIdentity } = connection;
+			const assertParentSessionCurrent = async () => {
+				await parent?.assertCurrent();
+			};
+			const parentWriteAuthority = createNativeSubagentSessionAuthority(parent);
+			const submissionStore = historyOwner && thread.lifecycle.preserveExistingBinding !== true ? {
+				...createNativeSubagentSubmissionStore({
+					bindingStore,
+					identity: bindingIdentity,
+					owner: historyOwner,
+					assertLifecycleCurrentAsync: assertParentSessionCurrent,
+					authority: parentWriteAuthority
+				}),
+				release: () => parent?.release()
+			} : void 0;
+			const assignmentStore = historyOwner && submissionStore ? createNativeSubagentAssignmentStore({
+				bindingStore,
+				identity: bindingIdentity,
+				owner: historyOwner,
+				assertLifecycleCurrent: () => submissionStore.assertCurrent(),
+				assertLifecycleCurrentAsync: () => assertParentSessionCurrent(),
+				authority: parentWriteAuthority
+			}) : void 0;
+			const assertRegistrationCurrent = () => {
+				runAbortController.signal.throwIfAborted();
+				params.hostCapabilities.assertActive();
+				connection.assertCurrent();
+				if (submissionStore) submissionStore.assertCurrent();
+				thread.liveThreadOwnership?.assertCurrent();
+				if (generation !== nativeSubagentMonitorGeneration || state.client !== client || state.thread !== thread || state.nativeHookRelay !== nativeHookRelay || state.turnRoute !== turnRoute) throw new Error("Codex native subagent registration was superseded during setup");
+			};
+			const retainModelSource = params.hostCapabilities.retainSourceAuthority;
+			const modelSource = retainModelSource?.();
 			try {
-				await registration.ready;
-				assertRegistrationCurrent();
-				state.nativeSubagentMonitor = registration;
+				const configurationQualification = getCodexInferenceThreadQualification(client, parentThreadId);
+				const registration = await codexNativeSubagentMonitorRuntime.register({
+					client,
+					parentThreadId,
+					...retainModelSource ? { modelSource } : {},
+					configurationQualification,
+					unqualifiedModelExecution: modelSource && !configurationQualification ? true : void 0,
+					onUnqualifiedModelCancelled: connection.abortExplicitly,
+					requesterSessionKey: params.sessionKey,
+					requesterTurnRunId: params.runId,
+					requestCustody,
+					completionScope: params.agentHarnessCompletionScope,
+					historyOwner,
+					submissionStore,
+					assignmentStore,
+					agentId: sessionAgentId,
+					assertCurrent: assertRegistrationCurrent,
+					assertCurrentAsync: assertParentSessionCurrent,
+					isTurnYielded: () => attemptTools.toolState.yieldDetected,
+					retainClient: () => retainSharedCodexAppServerClientIfCurrent(client),
+					retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(client, protectedThreadId),
+					claimDirectChild: (childThreadId) => nativeHookRelay?.claimDirectChild(childThreadId),
+					rejectPendingDirectChild: (childThreadId, reason) => nativeHookRelay?.rejectPendingDirectChild(childThreadId, reason),
+					...params.sessionKey && params.agentHarnessCompletionScope ? { onDirectChildAccepted: () => {
+						state.runtimeContinuationStarted = true;
+					} } : {}
+				});
+				parentTransferred = submissionStore !== void 0;
+				try {
+					await registration.ready;
+					await assertParentSessionCurrent();
+					assertRegistrationCurrent();
+					if (!submissionStore) {
+						const unregister = registration.unregister;
+						registration.unregister = () => unregister().finally(parent?.release);
+					}
+					state.nativeSubagentMonitor = registration;
+					parentTransferred = true;
+				} catch (error) {
+					await registration.unregister();
+					throw error;
+				}
 			} catch (error) {
-				await registration.unregister();
+				modelSource?.release();
 				throw error;
 			}
-		} catch (error) {
-			modelSource?.release();
-			throw error;
+		} finally {
+			if (!parentTransferred) parent?.release();
 		}
 	};
 	const releaseCurrentRoute = async () => {
@@ -6011,8 +6166,14 @@ function prepareCodexAttemptResources(prompt) {
 		connection.assertCurrent();
 		const requiresProcessAdmission = nativeProcessAuthority?.requiresProcessAdmission && runtime.nativeToolSurfaceEnabled;
 		const requiresModelAdmission = nativeModelAdmission !== void 0 && decision.nativeModelInputTools !== void 0;
-		const requiresExecutionAdmission = requiresProcessAdmission || requiresModelAdmission;
-		const relayEvents = requiresExecutionAdmission && !nativeHookRelayEvents.includes("pre_tool_use") ? [...nativeHookRelayEvents, "pre_tool_use"] : nativeHookRelayEvents;
+		const workspaceReadiness = runtime.nativeToolSurfaceEnabled ? params.hostCapabilities.workspaceReadiness : void 0;
+		const requiresWorkspaceAdmission = workspaceReadiness !== void 0 && decision.nativeModelInputTools !== void 0;
+		if (workspaceReadiness && !requiresWorkspaceAdmission) {
+			await workspaceReadiness.waitUntilReady();
+			connection.assertCurrent();
+		}
+		const requiresExecutionAdmission = requiresProcessAdmission || requiresModelAdmission || requiresWorkspaceAdmission;
+		const relayEvents = requiresExecutionAdmission && !nativeHookRelayEvents.includes("pre_tool_use") ? [...nativeHookRelayEvents, "pre_tool_use"] : [...nativeHookRelayEvents];
 		if (params.pluginHarnessToolPolicyRestricted === true) {
 			state.nativeHookRelay = void 0;
 			return {
@@ -6067,7 +6228,11 @@ function prepareCodexAttemptResources(prompt) {
 				timeoutMs: appServer.requestTimeoutMs,
 				onCleanupFailure: (error) => reportCodexBackgroundCleanupFailure(params, error)
 			},
-			assertCurrent: connection.assertLegacyCurrent,
+			assertCurrent: () => {
+				connection.assertLegacyCurrent();
+			},
+			assertCurrentAsync: runtime.nativeExecutionPolicy.assertCurrent,
+			retainExecutionPolicy: runtime.nativeExecutionPolicy.retain,
 			onPreToolUseFailure: (failure) => {
 				const projector = projectorRef.current;
 				if (projector) projector.recordNativeToolPreToolUseFailure(failure);
@@ -6087,7 +6252,7 @@ function prepareCodexAttemptResources(prompt) {
 			configPatch: state.nativeHookRelay ? buildCodexNativeHookRelayConfig({
 				relay: state.nativeHookRelay,
 				events: relayEvents,
-				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
+				hookTimeoutSec: requiresWorkspaceAdmission ? Math.max(options.nativeHookRelay?.hookTimeoutSec ?? 0, params.timeoutMs / 1e3) : options.nativeHookRelay?.hookTimeoutSec
 			}) : options.nativeHookRelay?.enabled === false ? buildCodexNativeHookRelayDisabledConfig() : void 0,
 			nativeHookRelayGeneration: state.nativeHookRelay?.generation
 		};
@@ -6291,94 +6456,108 @@ async function prepareCodexAttemptRuntime(connection) {
 	});
 	preDynamicStartupStages.mark("bundle-mcp");
 	const sandboxExecServerEnabled = isCodexSandboxExecServerEnabled(pluginConfig, sandbox);
-	let nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
+	const nativeExecutionPolicy = await prepareCodexNativeExecutionPolicyForRun(runtimeParams, {
 		agentId: policyAgentId,
 		runtimeSessionKey: sandboxSessionKey,
-		sandboxExecServerEnabled
+		sandbox
 	});
-	if (nativeToolSurfaceEnabled && sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority) {
-		const client = await attemptClientFactory({
-			...clientOptions,
-			assertCurrent: connection.assertCurrent,
-			agentId: sessionAgentId
+	let handedOff = false;
+	try {
+		connection.assertCurrent();
+		let nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
+			agentId: policyAgentId,
+			runtimeSessionKey: sandboxSessionKey,
+			sandboxExecServerEnabled,
+			nativeExecutionPolicy
 		});
-		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);
+		if (nativeToolSurfaceEnabled && sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority) {
+			const client = await attemptClientFactory({
+				...clientOptions,
+				assertCurrent: connection.assertCurrent,
+				agentId: sessionAgentId
+			});
+			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 = params.requireWorkspaceOnly === true ? void 0 : scheduledConfiguredMcpSurface ? "scheduled" : !nativeToolSurfaceEnabled && bundleMcpThreadConfig.staticServerNames.length > 0 ? "transient" : void 0;
-	preDynamicStartupStages.mark("native-tool-surface");
-	const webSearchPlan = resolveCodexWebSearchPlan({
-		config: params.config,
-		disableTools: params.disableTools,
-		nativeToolSurfaceEnabled
-	});
-	const supervisedSearchFingerprint = usesSupervisionConnection && !mutable.startupBinding?.pendingSupervisionBranch ? mutable.startupBinding?.webSearchThreadConfigFingerprint : void 0;
-	let nativeProviderWebSearchSupport;
-	if (isCodexResponsesOAuth(startupPreparedAuth)) nativeProviderWebSearchSupport = "supported";
-	else 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,
-		expectedNativeModelProvider: usesSupervisionConnection ? mutable.startupBinding?.modelProvider : void 0,
-		modelProviderOverride: usesSupervisionConnection ? void 0 : resolveCodexAppServerThreadModelSelection({
-			homeScope: appServer.start.homeScope,
-			provider: params.provider,
-			model: params.modelId,
-			binding: mutable.startupBinding,
-			authProfileId: startupAuthProfileId,
-			authProfileStore: attemptAuthProfileStore,
+		const configuredMcpSurface = params.requireWorkspaceOnly === true ? void 0 : scheduledConfiguredMcpSurface ? "scheduled" : !nativeToolSurfaceEnabled && bundleMcpThreadConfig.staticServerNames.length > 0 ? "transient" : void 0;
+		preDynamicStartupStages.mark("native-tool-surface");
+		const webSearchPlan = resolveCodexWebSearchPlan({
+			config: params.config,
+			disableTools: params.disableTools,
+			nativeToolSurfaceEnabled
+		});
+		const supervisedSearchFingerprint = usesSupervisionConnection && !mutable.startupBinding?.pendingSupervisionBranch ? mutable.startupBinding?.webSearchThreadConfigFingerprint : void 0;
+		let nativeProviderWebSearchSupport;
+		if (isCodexResponsesOAuth(startupPreparedAuth)) nativeProviderWebSearchSupport = "supported";
+		else 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
-		}).modelProvider,
-		signal: runAbortController.signal
-	});
-	preDynamicStartupStages.mark("provider-capabilities");
-	for (const diagnostic of bundleMcpThreadConfig.diagnostics) embeddedAgentLog.warn(`bundle-mcp: ${diagnostic.pluginId}: ${diagnostic.message}`);
-	if (activeContextEngine) assertContextEngineHostSupport({
-		contextEngine: activeContextEngine,
-		operation: "agent-run",
-		host: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST
-	});
-	const hookChannelId = resolveCodexAppServerHookChannelId(params, sandboxSessionKey);
-	preDynamicStartupStages.mark("context-engine-support");
-	return {
-		connection,
-		clientOptions,
-		preparedAuthBinding,
-		runtimeParams,
-		effectiveContextWindowInfo,
-		effectiveContextTokenBudget,
-		effectiveRuntimeProviderId,
-		effectiveRuntimeModelId,
-		startupAuthAccountCacheKey,
-		startupEnvApiKeyCacheKey,
-		bundleMcpThreadConfig,
-		bundleManifestRegistry,
-		authenticatedScheduledMode,
-		configuredMcpSurface,
-		canResolveScheduledConfiguredMcpCreatorAuthority: mayResolveScheduledConfiguredMcpCreatorAuthority,
-		codexMcpToolOverrides,
-		sandboxExecServerEnabled,
-		nativeToolSurfaceEnabled,
-		nativeProviderWebSearchSupport,
-		hookChannelId
-	};
+			config: params.config,
+			expectedNativeModelProvider: usesSupervisionConnection ? mutable.startupBinding?.modelProvider : void 0,
+			modelProviderOverride: usesSupervisionConnection ? void 0 : (await resolveCodexAppServerThreadModelSelection({
+				homeScope: appServer.start.homeScope,
+				provider: params.provider,
+				model: params.modelId,
+				binding: mutable.startupBinding,
+				authProfileId: startupAuthProfileId,
+				authProfileStore: attemptAuthProfileStore,
+				agentDir,
+				config: params.config
+			})).modelProvider,
+			signal: runAbortController.signal
+		});
+		preDynamicStartupStages.mark("provider-capabilities");
+		for (const diagnostic of bundleMcpThreadConfig.diagnostics) embeddedAgentLog.warn(`bundle-mcp: ${diagnostic.pluginId}: ${diagnostic.message}`);
+		if (activeContextEngine) assertContextEngineHostSupport({
+			contextEngine: activeContextEngine,
+			operation: "agent-run",
+			host: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST
+		});
+		const hookChannelId = resolveCodexAppServerHookChannelId(params, sandboxSessionKey);
+		preDynamicStartupStages.mark("context-engine-support");
+		handedOff = true;
+		return {
+			connection,
+			clientOptions,
+			preparedAuthBinding,
+			runtimeParams,
+			effectiveContextWindowInfo,
+			effectiveContextTokenBudget,
+			effectiveRuntimeProviderId,
+			effectiveRuntimeModelId,
+			startupAuthAccountCacheKey,
+			startupEnvApiKeyCacheKey,
+			bundleMcpThreadConfig,
+			bundleManifestRegistry,
+			authenticatedScheduledMode,
+			configuredMcpSurface,
+			canResolveScheduledConfiguredMcpCreatorAuthority: mayResolveScheduledConfiguredMcpCreatorAuthority,
+			codexMcpToolOverrides,
+			sandboxExecServerEnabled,
+			nativeToolSurfaceEnabled,
+			nativeExecutionPolicy,
+			nativeProviderWebSearchSupport,
+			hookChannelId
+		};
+	} finally {
+		if (!handedOff) nativeExecutionPolicy.release();
+	}
 }
 //#endregion
 //#region extensions/codex/src/app-server/dynamic-tool-result-projection.ts
@@ -6399,10 +6578,9 @@ function recordCodexDynamicToolResult(projector, call, response, protocolRespons
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-tools.ts
 function toTranscriptToolResult(response) {
-	const sanitized = sanitizeCodexAgentEventRecord({ ...response });
-	const contentItems = Array.isArray(sanitized.contentItems) ? sanitized.contentItems : [];
+	const contentItems = Array.isArray(response.contentItems) ? response.contentItems : [];
 	const result = {
-		...sanitized,
+		...response,
 		content: contentItems.map(toTranscriptToolResultContentItem)
 	};
 	delete result.contentItems;
@@ -6547,7 +6725,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				toolCallId: call.callId
 			});
 			const toolMeta = inferToolMetaFromArgs(call.tool, call.arguments, { detailMode: resolveCodexToolProgressDetailMode(params.toolProgressDetail) });
-			const toolArgs = sanitizeCodexToolArguments(call.arguments);
+			const toolArgs = asCodexToolArguments(call.arguments);
 			const commandBearing = isCodexCommandBearingToolCall(call.tool, toolArgs);
 			const shouldEmitDynamicToolProgress = shouldEmitTranscriptToolProgress(call.tool);
 			if (shouldEmitDynamicToolProgress) {
@@ -6689,6 +6867,14 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				return protocolResponse;
 			} catch (error) {
 				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
+				recordDynamicToolResult({
+					call,
+					response: {
+						contentItems: [],
+						success: false
+					},
+					durationMs: Math.max(0, Date.now() - toolStartedAt)
+				});
 				if (!terminalDiagnosticObserved && !diagnostics.hasPendingTerminal()) diagnostics.error(Math.max(0, Date.now() - toolStartedAt));
 				await settlePluginRuntimeRefresh(turnId);
 				throw error;
@@ -6710,7 +6896,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-C13pR7tD.mjs");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CmLWeyJB.mjs");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6807,7 +6993,6 @@ function clearComputerUseHealthMonitor(client, monitor) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-startup.ts
-const CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS = 3;
 /**
 * Starts or resumes the Codex app-server thread and returns the resources the
 * run loop must later release.
@@ -6819,6 +7004,17 @@ async function startCodexAttemptThread(params) {
 	let releaseSharedClientLease;
 	let startupClientForAbandonedRequestCleanup;
 	let releaseStartupResourcesOnTimeout;
+	const startupStartedAt = performance.now();
+	let stage = "configuration";
+	let stageStartedAt = startupStartedAt;
+	let acquireBoundary;
+	let startupIdentity;
+	let startupAttemptNumber = 0;
+	const enterStartupStage = (nextStage) => {
+		stage = nextStage;
+		stageStartedAt = performance.now();
+		acquireBoundary = void 0;
+	};
 	const startupAbandonController = new AbortController();
 	const abandonStartupAcquire = () => startupAbandonController.abort();
 	params.signal.addEventListener("abort", abandonStartupAcquire, { once: true });
@@ -6827,6 +7023,21 @@ async function startCodexAttemptThread(params) {
 			timeoutMs: params.startupTimeoutMs,
 			signal: params.signal,
 			onTimeout: async () => {
+				try {
+					const client = startupClientForAbandonedRequestCleanup;
+					const now = performance.now();
+					embeddedAgentLog.warn("codex app-server startup timed out", {
+						...startupIdentity,
+						attempt: startupAttemptNumber,
+						stage,
+						stageElapsedMs: Math.max(0, Math.round(now - stageStartedAt)),
+						elapsedMs: Math.max(0, Math.round(now - startupStartedAt)),
+						timeoutMs: params.startupTimeoutMs,
+						acquireBoundary,
+						clientInstanceId: client?.getInstanceId(),
+						clientPendingRequestMethods: client?.getPendingRequestMethods() ?? []
+					});
+				} catch {}
 				startupAbandonController.abort();
 				await params.onStartupTimeout();
 				await releaseStartupResourcesOnTimeout?.();
@@ -6848,18 +7059,27 @@ async function startCodexAttemptThread(params) {
 					...params.appServer,
 					approvalPolicy: withMcpElicitationsApprovalPolicy(params.appServer.approvalPolicy)
 				} : params.appServer;
-				let attemptedClient;
 				const startupAttempt = async () => {
+					startupAttemptNumber += 1;
 					let startupClientLease;
 					let startupClient;
 					let startupAttemptError;
 					let startupAttemptSucceeded = false;
 					try {
 						const attemptParams = params.buildAttemptParams();
+						startupIdentity = {
+							runId: attemptParams.runId,
+							sessionId: attemptParams.sessionId
+						};
 						params.assertCurrent?.();
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
+						enterStartupStage("client-acquire");
 						startupClient = await params.attemptClientFactory({
 							...params.clientOptions,
+							onAcquireObservation: (observation) => {
+								if (stage === "client-acquire") acquireBoundary = observation.boundary;
+								observeAcquire(params.clientOptions, observation);
+							},
 							assertCurrent: () => {
 								params.assertCurrent?.();
 								params.authority?.assertLegacyCurrent();
@@ -6886,9 +7106,9 @@ async function startCodexAttemptThread(params) {
 							else releaseLeasedSharedCodexAppServerClient(activeStartupClient);
 						};
 						releaseSharedClientLease = startupClientLease;
-						attemptedClient = activeStartupClient;
 						startupClientForAbandonedRequestCleanup = activeStartupClient;
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
+						enterStartupStage("runtime-artifact");
 						const runtimeArtifact = await verifyStartupArtifact({
 							client: activeStartupClient,
 							startOptions: params.appServer.start,
@@ -6907,6 +7127,7 @@ async function startCodexAttemptThread(params) {
 						let computerUseTools = [];
 						let computerUseConfig = params.computerUseConfig;
 						try {
+							enterStartupStage("computer-use");
 							const computerUseStatus = await ensureCodexComputerUse({
 								client: activeStartupClient,
 								pluginConfig: params.pluginConfig,
@@ -6922,7 +7143,7 @@ async function startCodexAttemptThread(params) {
 								mcpServerName: computerUseStatus.mcpServerName
 							};
 						} catch (error) {
-							if (startupAbandonController.signal.aborted || isCodexAppServerStartSelectionChangedError(error)) throw error;
+							if (startupAbandonController.signal.aborted) throw error;
 							throw new AgentHarnessPreflightError(`Codex Computer Use readiness failed: ${formatErrorMessage(error)}`, {
 								cause: error,
 								scope: "harness"
@@ -6975,6 +7196,7 @@ async function startCodexAttemptThread(params) {
 								nativeToolSurfaceEnabled: params.nativeToolSurfaceEnabled,
 								sandboxExecServerEnabled: params.sandboxExecServerEnabled
 							});
+							enterStartupStage("sandbox-environment");
 							startupSandboxEnvironment = sandboxEnvironmentRequired ? await ensureCodexSandboxExecServerEnvironment({
 								client: activeStartupClient,
 								sandbox: params.sandbox ?? null,
@@ -7015,6 +7237,7 @@ async function startCodexAttemptThread(params) {
 							return { release: releaseStartupReservation };
 						};
 						const releaseStartupResources = async () => {
+							enterStartupStage("resource-cleanup");
 							releaseStartupReservation();
 							await releaseStartupSandboxEnvironment();
 						};
@@ -7065,10 +7288,12 @@ async function startCodexAttemptThread(params) {
 							})
 						});
 						try {
+							enterStartupStage("thread-lifecycle");
 							const startupThread = await startOrResumeThread(buildThreadLifecycleParams(startupAbandonController.signal, reserveStartupThread));
 							try {
 								reserveStartupThread(startupThread.threadId);
 							} catch (error) {
+								enterStartupStage("subscription-cleanup");
 								if (!await unsubscribeCodexThreadBestEffort(activeStartupClient, {
 									threadId: startupThread.threadId,
 									timeoutMs: 5e3
@@ -7096,16 +7321,10 @@ async function startCodexAttemptThread(params) {
 								sandboxPolicy: startupSandboxPolicy,
 								...runtimeArtifact ? { runtimeArtifact } : {},
 								restartContextEngineCodexThread: async () => {
-									try {
-										return await startOrResumeThread({
-											...buildThreadLifecycleParams(params.signal),
-											contextEngineProjection: void 0
-										});
-									} catch (error) {
-										if (!isCodexAppServerStartSelectionChangedError(error)) throw error;
-										retireSharedCodexAppServerClientIfCurrent(activeStartupClient);
-										throw Object.assign(new Error("codex app-server client is closed", { cause: error }), { code: CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED });
-									}
+									return await startOrResumeThread({
+										...buildThreadLifecycleParams(params.signal),
+										contextEngineProjection: void 0
+									});
 								}
 							};
 						} catch (error) {
@@ -7126,45 +7345,23 @@ async function startCodexAttemptThread(params) {
 							startupClientLease?.();
 							if (shouldRetireCodexStartupClient(startupAttemptError, params.spawnedBy, startupAbandonController.signal)) {
 								if (startupClientForAbandonedRequestCleanup === startupClient) startupClientForAbandonedRequestCleanup = void 0;
+								enterStartupStage("client-retirement");
 								await closeCodexStartupClientBestEffort(startupClient);
 							}
 						}
 					}
 					if (startupAttemptError instanceof CodexThreadClientReplacementError && startupClient) {
+						enterStartupStage("client-retirement");
 						if (!(await startupClient.closeAndWait()).exited) throw new AgentHarnessPreflightError("The previous conversation process did not confirm shutdown; the conversation was preserved.");
 					}
 					throw startupAttemptError;
 				};
-				let replacedSettledFailureClient = false;
-				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS; attempt += 1) try {
+				try {
 					return await startupAttempt();
 				} catch (error) {
-					const selectionChanged = isCodexAppServerStartSelectionChangedError(error);
-					const clientRetired = error instanceof CodexThreadClientReplacementError;
-					if (startupAbandonController.signal.aborted || isCodexWebSocketOpenFailure(error) || clientRetired && replacedSettledFailureClient || !clientRetired && !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
-					replacedSettledFailureClient ||= clientRetired;
-					const refreshedSharedClient = clientRetired ? void 0 : selectionChanged ? retireSharedCodexAppServerClientIfCurrent(attemptedClient) : clearSharedCodexAppServerClientIfCurrent(attemptedClient);
-					if (startupClientForAbandonedRequestCleanup === attemptedClient) startupClientForAbandonedRequestCleanup = void 0;
-					if (attempt >= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS) {
-						embeddedAgentLog.warn(selectionChanged ? "codex app-server executable selection kept changing during startup; retries exhausted" : "codex app-server connection closed during startup; retries exhausted", {
-							attempt,
-							maxAttempts: CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS,
-							refreshedSharedClient,
-							error: formatErrorMessage(error)
-						});
-						throw error;
-					}
-					const retryDelayMs = selectionChanged || clientRetired ? 0 : 1e3 * 2 ** (attempt - 1);
-					embeddedAgentLog.warn(clientRetired ? "codex app-server retired a settled failed client; resuming on a fresh client" : selectionChanged ? "codex app-server executable selection changed during startup; restarting app-server and retrying" : "codex app-server connection closed during startup; restarting app-server and retrying", {
-						attempt,
-						nextAttempt: attempt + 1,
-						maxAttempts: CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS,
-						refreshedSharedClient,
-						error: formatErrorMessage(error)
-					});
-					await sleepWithAbort(retryDelayMs, startupAbandonController.signal);
+					if (startupAbandonController.signal.aborted || !(error instanceof CodexThreadClientReplacementError)) throw error;
+					return await startupAttempt();
 				}
-				throw new Error("codex app-server startup retry loop exited unexpectedly");
 			}
 		});
 		startupClientForAbandonedRequestCleanup = void 0;
@@ -7431,6 +7628,7 @@ async function prepareCodexAttemptTools(runtime) {
 	let resolveCreatorAuthorityImpl;
 	const runtimeYieldCompletionClaim = {};
 	const commonToolParams = {
+		nativeExecutionPolicy: runtime.nativeExecutionPolicy,
 		nodeExecAvailability: {},
 		params: dynamicToolParams,
 		resolvedWorkspace,
@@ -7671,6 +7869,7 @@ async function prepareCodexAttemptTools(runtime) {
 		}) : void 0;
 		const registeredFallbackTools = params.trigger === "heartbeat" || params.enableHeartbeatTool === true || params.forceHeartbeatTool === true || !heartbeatFallbackTool ? void 0 : params.hostCapabilities.bindToolSurface([heartbeatFallbackTool], { cwd: effectiveCwd ?? effectiveWorkspace });
 		const toolBridge = createCodexDynamicToolBridge({
+			assertCurrentAsync: runtime.nativeExecutionPolicy.assertCurrent,
 			tools: toolsWithScopedMcp,
 			registeredTools: registeredWithScopedMcp,
 			registeredFallbackTools,
@@ -7876,40 +8075,6 @@ async function prepareCodexProviderReviewContinuation(params) {
 	}
 }
 //#endregion
-//#region extensions/codex/src/app-server/service-tier.ts
-/** Validate an explicit Ultrafast selection against this turn's native model and client. */
-async function resolveCodexUltrafastServiceTier(params) {
-	if (!params.enabled || params.modelProvider !== "openai" && params.modelProvider !== "openclaw_token_sharing" || !params.model) return params.serviceTier;
-	params.signal.throwIfAborted();
-	params.assertCurrent();
-	const deadline = Date.now() + params.timeoutMs;
-	try {
-		const catalog = await listAllCodexAppServerModels({
-			includeHidden: true,
-			request: (request) => {
-				const timeoutMs = deadline - Date.now();
-				if (timeoutMs <= 0) throw new Error("Codex Ultrafast catalog deadline exceeded");
-				return requestCodexAppServerClientJson({
-					...request,
-					client: params.client,
-					signal: params.signal,
-					assertCurrent: params.assertCurrent,
-					timeoutMs,
-					config: params.config
-				});
-			}
-		});
-		params.signal.throwIfAborted();
-		params.assertCurrent();
-		return catalog.models.find((entry) => entry.model === params.model)?.serviceTiers?.includes("ultrafast") ? "ultrafast" : params.serviceTier;
-	} catch (error) {
-		params.signal.throwIfAborted();
-		params.assertCurrent();
-		if (error instanceof CodexAppServerScopedRequestRejectedError) throw error;
-		return params.serviceTier;
-	}
-}
-//#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;
@@ -7976,7 +8141,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, { fastMode }, connection.appServer);
 		const references = prepareWorkspaceReferences();
 		const inferenceRoute = getCodexInferenceThread(resourceState.client, resourceState.thread.threadId);
-		const turnStartParams = buildTurnStartParams(runtimeParams, {
+		const turnStartParams = await buildTurnStartParams(runtimeParams, {
 			threadId: resourceState.thread.threadId,
 			cwd: resourceState.codexExecutionCwd,
 			appServer: turnAppServer,
@@ -7997,17 +8162,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			requireExplicitMessageTarget: attemptTools.requireExplicitMessageTarget,
 			sessionStatusAvailable: toolBridge.availableTools.some((tool) => tool.name === "session_status")
 		});
-		const serviceTier = await resolveCodexUltrafastServiceTier({
-			enabled: fastMode === "ultrafast" && turnAppServer.enableUltrafast !== false,
-			serviceTier: turnStartParams.serviceTier,
-			model: turnStartParams.model ?? model,
-			modelProvider: modelProvider ?? effectiveRuntimeProviderId,
-			client: turnClient,
-			timeoutMs: Math.min(params.timeoutMs, 2500),
-			signal: runAbortController.signal,
-			assertCurrent: assertTurnCurrent,
-			config: params.config
-		});
+		const serviceTier = fastMode === "ultrafast" ? selectedThread.preparedServiceTier : turnStartParams.serviceTier;
 		assertTurnCurrent();
 		turnStartParams.serviceTier = serviceTier;
 		connection.mutable.pluginAppServer = {
@@ -8103,6 +8258,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 				}
 			}));
 			acceptedTurnId = startedTurn.turn.id;
+			recordCodexTurnForkSettings(turnClient, turnStartParams);
 			resources.nativeProcessAuthority?.bindTurn(turnClient, threadId, acceptedTurnId);
 			assertTurnCurrent();
 			resourceState.nativeSubagentMonitor?.bindTurn(acceptedTurnId, modelMapping);
@@ -8305,7 +8461,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				authProfileId: startupAuthProfileId,
 				rateLimits: usageLimitError.rateLimitsForProfile
 			});
-			else if (!isCodexContextRestartSelectionChangedError(turnStartError)) throw turnStartError;
+			else throw turnStartError;
 			const result = buildCodexTurnStartFailureResult({
 				params,
 				message,
@@ -8353,7 +8509,6 @@ var CodexAttemptState = class {
 		this.projectionClosed = false;
 		this.terminalDynamicToolReleaseCheckScheduled = false;
 		this.currentTurnHadNonTerminalDynamicToolResult = false;
-		this.currentTurnHadToolAuthoredFinalReply = false;
 	}
 };
 function createCodexAttemptTurnState(resources) {
@@ -8432,6 +8587,7 @@ function createCodexAttemptTurnState(resources) {
 	};
 	const deadlines = createAgentHarnessAttemptDeadlineController({
 		startedAtMs: connection.attemptStartedAt,
+		startedAtMonotonicMs: connection.attemptStartedAtMonotonicMs,
 		timeoutMs: params.timeoutMs,
 		settlementTimeoutMs: TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS,
 		signal: runAbortController.signal,
@@ -8500,66 +8656,79 @@ async function runCodexAppServerAttempt(params, options) {
 	}));
 	try {
 		const runtime = await preparation.measure("runtime", () => prepareCodexAttemptRuntime(connection));
-		const attemptTools = await preparation.measure("tools", () => prepareCodexAttemptTools(runtime));
 		try {
-			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;
-			let activeTurnOwnsCleanup = false;
+			const attemptTools = await preparation.measure("tools", () => prepareCodexAttemptTools(runtime));
 			try {
-				await preparation.measure("runtime-start", () => startCodexAttemptRuntime(resources));
-				const turnRuntime = createCodexAttemptTurnState(resources);
+				const attemptContext = await preparation.measure("context", () => prepareCodexAttemptContext(runtime, attemptTools));
+				const resources = prepareCodexAttemptResources(await preparation.measure("prompt", () => prepareCodexAttemptPrompt(attemptContext)));
+				attemptTools.runtimeYieldCompletionClaim.current = () => {
+					if (resources.state.nativeHookRelay?.hasClaimedDirectChild()) return true;
+					const pendingChildren = resources.state.nativeSubagentMonitor?.listPendingChildren() ?? [];
+					return pendingChildren.length > 0 ? { pendingChildren } : false;
+				};
+				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) {
-						connection.assertModelExecutionCurrent();
-						return turnStart.result;
-					}
-					const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart);
-					activeTurnOwnsCleanup = true;
-					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) {
+							connection.assertModelExecutionCurrent();
+							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) {
+							connection.assertModelExecutionCurrent();
+							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 (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
 						connection.assertModelExecutionCurrent();
-						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;
+						return finalizedResult;
+					} finally {
+						turnRuntime.deadlines.dispose();
 					}
-					if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
-					connection.assertModelExecutionCurrent();
-					return finalizedResult;
 				} finally {
-					turnRuntime.deadlines.dispose();
+					if (!activeTurnOwnsCleanup) await resources.cleanupBeforeActiveTurn();
 				}
 			} finally {
-				if (!activeTurnOwnsCleanup) await resources.cleanupBeforeActiveTurn();
+				await attemptTools.disposeTools(connection.runAbortController.signal.aborted ? "cancel" : "error");
 			}
 		} finally {
-			await attemptTools.disposeTools(connection.runAbortController.signal.aborted ? "cancel" : "error");
+			runtime.nativeExecutionPolicy.release();
 		}
 	} catch (error) {
 		throw codexPrewriteRejectionCause(error);
 	} finally {
-		connection.cancellation.dispose();
-		connection.releaseModelExecution();
+		try {
+			connection.cancellation.dispose();
+			connection.releaseModelExecution();
+			connection.releaseSandboxContext();
+		} finally {
+			connection.releaseBindingAuthority();
+		}
 	}
 }
 //#endregion