@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/{run-attempt-D1hJO4fX.js → run-attempt-DwKds3DN.js}

@@ -1,54 +1,110 @@
-import { $t as isJsonObject, A as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, B as isCodexAppServerIndeterminateRequestCancellationError, Bt as resolveCodexAppServerAuthProfileIdForAgent, Ct as ensureCodexAppServerClientRuntime, Dt as protectCodexAppServerLiveThread, F as withCodexStartupTimeout, Ft as readRecentCodexRateLimits, H as isCodexAppServerOverloadError, Ht as resolveCodexAppServerFallbackApiKeyCacheKey, I as getCodexAppServerClientInstanceId, It as rememberCodexRateLimitsRead, K as resolveCodexAppServerClientInstanceId, L as isCodexAppServerApprovalRequest, M as isCodexAppServerStartupError, Mt as withAbortableTimeout, P as resolveCodexStartupTimeoutMs, Pt as readCodexRateLimitsRevision, Qt as flattenCodexDynamicToolFunctions, R as isCodexAppServerBrokenPipeError, Rt as resolveCodexAppServerAuthAccountCacheKey, Ut as resolveCodexAppServerPreparedApiKeyCacheKey, V as isCodexAppServerIndeterminateTransportError, W as isCodexAppServerRequestTimeoutError, Wt as resolveCodexAppServerPreparedAuthHandoff, _t as resolveCodexToolAbortTerminalReason, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as readCodexTurnCompletedNotification, c as getLeasedSharedCodexAppServerClient, ct as hasPendingDynamicToolTerminalDiagnostic, dt as resolveDynamicToolCallTimeoutMs, f as readCodexAppServerClientDesktopGenerationFingerprint, ft as resolveTerminalDynamicToolBatchAction, gt as toCodexDynamicToolProtocolResponse, h as releaseLeasedSharedCodexAppServerClient, ht as toCodexDynamicToolProgressResponse, i as clearSharedCodexAppServerClientIfCurrent, it as readCodexTurn, j as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, k as CodexAppServerStartupError, l as getSharedCodexAppServerClient, lt as isDynamicToolTerminalDiagnosticEvent, mt as shouldReleaseTurnAfterTerminalDynamicTool, nt as readCodexDynamicToolCallParams, ot as createCodexElicitationResponse, pt as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, q as CodexAppServerRpcError, s as createIsolatedCodexAppServerClient, st as handleDynamicToolCallWithTimeout, tt as assertCodexTurnStartResponse, u as isCodexAppServerStartSelectionChangedError, ut as isMatchingDynamicToolTerminalDiagnostic, v as retainSharedCodexAppServerClientIfCurrent, y as retireSharedCodexAppServerClientIfCurrent, z as isCodexAppServerConnectionClosedError, zt as resolveCodexAppServerAuthProfileId } from "./shared-client-DxcfF9KX.js";
-import { C as isCodexPairedNodeRemoteExecPlacementSandbox, D as resolveCodexPluginsPolicy, E as readCodexPluginConfig, F as resolveCodexAppServerHomeDir, O as resolveOpenClawExecPolicyForCodexAppServer, T as isCodexSandboxExecServerEnabled, d as shouldAutoApproveCodexAppServerApprovals, f as withMcpElicitationsApprovalPolicy, h as resolveCodexModelBackedReviewerPolicyContext, l as hasCodexMcpToolApprovalOverrides, m as canUseCodexModelBackedApprovalsReviewerForModel, o as resolveCodexComputerUseConfig, r as resolveCodexAppServerHomeScope, w as isCodexRemoteExecPlacementSandbox, y as readCodexRequirementsToml } from "./config-BhmfC1s6.js";
-import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, i as createCodexSessionGenerationSupersededError, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore } from "./session-binding-BHuTCRZQ.js";
-import { B as readNonNegativeInteger, E as itemStatus, H as splitPlanText, I as readItem, L as readItemString, M as extractRawAssistantText, O as matchesCodexSnapshotTurn, P as readCodexErrorNotificationMessage, T as itemName, V as readNullableString, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, j as shouldSynthesizeToolProgressForItem, k as shouldClearTerminalPresentationForNativeItem, l as retireUnsafeCodexTurnClientBestEffort, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, u as terminateCodexBackgroundTerminals } from "./attempt-client-cleanup-DYHcRQAa.js";
-import { a as codexExecutionToolName, c as isPendingOpenClawDynamicToolCompletionNotification, d as isTerminalTurnStatus, f as readCodexNotificationItem, h as updateActiveTurnItemIds, l as isRawFunctionToolOutputCompletionNotification, m as readRawResponseToolCallId, p as readNotificationItemId, r as projectCodexThreadUsageUpdate, s as isCodexTurnAbortMarkerNotification, t as CodexResponseCompletionProjection } from "./event-projector-usage-C5mcrGjp.js";
-import { i as buildCodexPluginAppCacheKey, r as buildCodexAppServerRuntimeFingerprint, s as defaultCodexAppInventoryCache } from "./thread-resume-C7pyVKeW.js";
-import { A as readCodexMcpToolConnectorId, B as emitCodexNativePreToolUseFailureDiagnostic, C as buildDeveloperInstructions, Ct as buildCodexPluginThreadConfig, D as resolveCodexAppServerThreadModelSelection, Dt as mergeCodexThreadConfigs, H as resolveCodexNativeHookRelayTtlMs, I as buildCodexNativeHookRelayConfig, L as buildCodexNativeHookRelayDisabledConfig, M as isCodexAppServerProfilerEnabled, Ot as shouldBuildCodexPluginThreadConfig, P as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, Pt as resolveRecoverableCodexPluginConfigKeys, S as resolveCodexWebSearchPlan, Tt as buildCodexPluginThreadConfigTimeoutFallback, U as scheduleCodexNativeHookRelayUnregister, V as resolveCodexNativeHookRelayEvents, X as loadCodexNativeToolCatalog, Y as hasCodexNativeToolCatalog, _t as neutralizeCodexExplicitMentionSigils, at as filterCodexDynamicTools, bt as resolveCodexContextEngineProjectionReserveTokens, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, ft as resolveCodexDynamicToolsLoadingForRuntime, gt as fitCodexProjectedContextForTurnStart, h as resolveScheduledCodexAppCreatorCaptureDecision, ht as buildCodexContinuityCalibration, i as buildCodexUserInput, j as readCodexMcpToolUiVisibility, l as buildLegacyScheduledCodexAppRecoveryPrompt, lt as isSystemAgentOnlyCodexDynamicToolAllowlist, m as readCurrentCodexScheduledAppPolicy$1, n as buildTurnCollaborationMode, nt as codexLegacyDynamicToolsFingerprint, p as intersectCodexPluginThreadConfigWithScheduledAuthority, pt as buildContextEngineBinding, r as buildTurnStartParams, s as startOrResumeThread, tt as codexDynamicToolsFingerprint, u as buildScheduledCodexAppAuthorityInputFingerprint, vt as projectContextEngineAssemblyForCodex, wt as buildCodexPluginThreadConfigInputFingerprint, xt as resolveCodexContinuityProjectionMaxChars, yt as resolveCodexContextEngineProjectionMaxChars, z as createCodexNativeHookRelay } from "./thread-lifecycle-DAcEJ_Om.js";
-import { l as isIncognitoSessionKey, r as retainCodexAppServerBindingSubscription } from "./thread-ownership-zGokd8i1.js";
-import { a as buildCodexUserPromptMessage, i as mirrorPromptAtTurnStartBestEffort, l as hasCodexMirrorOrigin, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, s as applyCodexTranscriptTaint, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-DTUxFWa_.js";
-import { n as CodexThreadPolicyHandoffError } from "./thread-policy-g4KbJPzp.js";
+import { l as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-CaZjYwNS.js";
+import { n as defineCodexBuildState } from "./build-state-6RL6qohz.js";
+import { b as readCodexRequirementsToml, c as hasCodexMcpToolApprovalOverrides, d as withMcpElicitationsApprovalPolicy, i as resolveCodexAppServerHomeScope, m as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig, u as shouldAutoApproveCodexAppServerApprovals } from "./config-options-jnIFvwxD.js";
+import { S as resolveCodexPluginsPolicy, a as flattenCodexDynamicToolFunctions, b as isCodexSandboxExecServerEnabled, o as isJsonObject, s as resolveCodexAppServerHomeDir, v as isCodexPairedNodeRemoteExecPlacementSandbox, x as readCodexPluginConfig, y as isCodexRemoteExecPlacementSandbox } from "./protocol-CAAcVIKF.js";
+import { A as isMatchingDynamicToolTerminalDiagnostic, D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, F as toCodexDynamicToolProgressResponse, I as toCodexDynamicToolProtocolResponse, L as resolveCodexToolAbortTerminalReason, M as resolveTerminalDynamicToolBatchAction, N as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, O as hasPendingDynamicToolTerminalDiagnostic, P as shouldReleaseTurnAfterTerminalDynamicTool, S as readCodexDynamicToolCallParams, T as readCodexTurnCompletedNotification, a as isCodexAppServerBrokenPipeError, c as isCodexAppServerIndeterminateTransportError, d as isCodexAppServerRequestTimeoutError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, l as isCodexAppServerOverloadError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError, w as readCodexTurn, x as assertCodexTurnStartResponse } from "./client-BEKu4yDx.js";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, m as retireSharedCodexAppServerClientIfCurrent, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-Kq6oerr6.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-Bqnx1N4z.js";
+import { a as formatCodexDisplayText } from "./command-formatters-DeTfrapr.js";
+import { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-BeqLPbtM.js";
 import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-dIjNVCYH.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CawQJfUS.js";
-import { a as formatCodexDisplayText } from "./command-formatters-CLHhEB1Q.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-DeWVTCMj.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-E6uDsPlx.js";
-import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Ds_QVm-X.js";
+import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey, s as defaultCodexAppInventoryCache } from "./plugin-app-cache-key-CdSQzWyX.js";
+import { t as withAbortableTimeout } from "./timeout-BVw8aaM1.js";
+import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-JDfTI4VI.js";
+import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-DibE0krH.js";
+import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Co2Vfcf_.js";
+import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-QqgcPCgk.js";
+import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CwzO4_RG.js";
+import { B as prepareCodexWorkspaceReferences, D as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, E as CodexAppServerStartupError, F as ensureCodexAppServerClientRuntime, J as rememberCodexRateLimitsRead, K as readCodexRateLimitsRevision, M as withCodexStartupTimeout, O as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, V as protectCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, Z as resolveCodexAppServerPreparedAuthHandoff, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, j as resolveCodexStartupTimeoutMs, k as isCodexAppServerStartupError, l as getSharedCodexAppServerClient, q as readRecentCodexRateLimits, s as createIsolatedCodexAppServerClient, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent } from "./shared-client-CVhez2Uo.js";
+import { F as readCodexProviderRefusal, H as readNullableString, L as readItem, M as extractRawAssistantText, O as matchesCodexSnapshotTurn, P as readCodexErrorNotificationMessage, R as readItemString, U as splitPlanText, V as readNonNegativeInteger, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, k as shouldClearTerminalPresentationForNativeItem, l as retireUnsafeCodexTurnClientBestEffort, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, u as terminateCodexBackgroundTerminals } from "./attempt-client-cleanup-D6cR54TV.js";
+import { a as isRawFunctionToolOutputCompletionNotification, c as readNotificationItemId, i as isPendingOpenClawDynamicToolCompletionNotification, l as readRawResponseToolCallId, o as isTerminalTurnStatus, r as isCodexTurnAbortMarkerNotification, s as readCodexNotificationItem, t as codexExecutionToolName, u as updateActiveTurnItemIds } from "./attempt-notifications--H8zXR5-.js";
+import { t as CodexUsageProjection } from "./event-projector-usage-CIyrYYid.js";
+import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-CoRCzWW4.js";
+import { $ as codexLegacyDynamicToolsFingerprint, A as readCodexMcpToolConnectorId, B as emitCodexNativePreToolUseFailureDiagnostic, C as buildDeveloperInstructions, Ct as buildCodexPluginThreadConfigTimeoutFallback, D as resolveCodexAppServerThreadModelSelection, Dt as shouldBuildCodexPluginThreadConfig, H as resolveCodexNativeHookRelayTtlMs, I as buildCodexNativeHookRelayConfig, K as hasCodexNativeToolCatalog, L as buildCodexNativeHookRelayDisabledConfig, M as isCodexAppServerProfilerEnabled, P as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, Q as codexDynamicToolsFingerprint, S as resolveCodexWebSearchPlan, St as buildCodexPluginThreadConfigInputFingerprint, Tt as mergeCodexThreadConfigs, U as scheduleCodexNativeHookRelayUnregister, V as resolveCodexNativeHookRelayEvents, _t as projectContextEngineAssemblyForCodex, bt as resolveCodexContinuityProjectionMaxChars, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, ft as CodexContextAttachmentError, gt as neutralizeCodexExplicitMentionSigils, h as resolveScheduledCodexAppCreatorCaptureDecision, ht as isCodexDurableCustomMessage, i as buildCodexUserInput, j as readCodexMcpToolUiVisibility, l as buildLegacyScheduledCodexAppRecoveryPrompt, lt as resolveCodexDynamicToolsLoadingForRuntime, m as readCurrentCodexScheduledAppPolicy$1, mt as fitCodexProjectedContextForTurnStart, n as buildTurnCollaborationMode, nt as filterCodexDynamicTools, ot as isSystemAgentOnlyCodexDynamicToolAllowlist, p as intersectCodexPluginThreadConfigWithScheduledAuthority, pt as buildCodexContinuityCalibration, q as loadCodexNativeToolCatalog, r as buildTurnStartParams, s as startOrResumeThread, u as buildScheduledCodexAppAuthorityInputFingerprint, ut as buildContextEngineBinding, vt as resolveCodexContextEngineProjectionMaxChars, xt as buildCodexPluginThreadConfig, yt as resolveCodexContextEngineProjectionReserveTokens, z as createCodexNativeHookRelay } from "./thread-lifecycle-D1pzRwHB.js";
+import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding, s as scopeCodexRunBindingStore } from "./session-binding-CKSepwIC.js";
+import { n as CodexThreadPolicyHandoffError } from "./thread-policy-D8kI7yAO.js";
+import { r as retainCodexAppServerBindingSubscription } from "./thread-ownership-D6oASVRu.js";
+import { i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-t5TOccct.js";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.js";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-DHRFXKbS.js";
-import { a as CodexToolProgressProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as resolveCodexToolProgressDetailMode, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, s as inferCodexDynamicToolMeta, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexToolArguments } from "./native-subagent-monitor-CnH147jH.js";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-CNe-Xrjx.js";
-import { S as shouldWarnCodexDynamicToolBuildStageSummary, T as CodexNativeToolLifecycleProjector, _ as resolveCodexMessageToolProvider, a as emitDynamicToolStartedDiagnostic, b as shouldEnableCodexAppServerNativeToolSurface, c as ensureCodexSandboxExecServerEnvironment, d as createCodexDynamicToolBuildStageTracker, f as disableCodexPluginThreadConfig, g as resolveCodexExternalSandboxPolicyForOpenClawSandbox, h as resolveCodexAppServerHookChannelId, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as resolveCodexAppServerExecutionCwd, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as formatCodexDynamicToolBuildStageSummary, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as buildDynamicTools, w as readBoundedCodexRemoteWorkspaceFile, x as shouldRequireCodexSandboxExecServerEnvironment, y as resolveCodexSandboxEnvironmentSelection } from "./dynamic-tools-BU9tmlYm.js";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-DW5p4k9w.js";
-import { a as getCodexWorkspaceMemoryToolNames, c as readContextEngineThreadBootstrapProjection, d as resolveCodexDeliveryHintPreservedInputRange, f as resolveContextEngineBootstrapProjectionDecision, i as buildCodexWorkspaceBootstrapContext, l as readMirroredSessionHistoryMessages, n as buildCodexSystemPromptReport, r as buildCodexWatchedSessionsContext, s as prependCodexOpenClawPromptContext, t as buildCodexOpenClawPromptContext, u as renderCodexSkillsCollaborationInstructions } from "./attempt-context-DmQUNWwT.js";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-D3SNWtUn.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-BFrPhb2c.js";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BmBM4qBV.js";
+import { C as shouldRequireCodexSandboxExecServerEnvironment, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeToolLifecycleProjector, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as readBoundedCodexRemoteWorkspaceFile, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-D-JBoaLt.js";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-W4tfK5Y5.js";
+import { a as CodexToolProgressProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as resolveCodexToolProgressDetailMode, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, s as inferCodexDynamicToolMeta, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexToolArguments } from "./native-subagent-monitor-BbCUKRwC.js";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-DeW95wB5.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-B22InTp_.js";
+import { a as getCodexWorkspaceMemoryToolNames, c as readContextEngineThreadBootstrapProjection, d as resolveCodexDeliveryHintPreservedInputRange, f as resolveContextEngineBootstrapProjectionDecision, i as buildCodexWorkspaceBootstrapContext, l as readMirroredSessionHistoryMessages, n as buildCodexSystemPromptReport, r as buildCodexWatchedSessionsContext, s as prependCodexOpenClawPromptContext, t as buildCodexOpenClawPromptContext, u as renderCodexSkillsCollaborationInstructions } from "./attempt-context-AO4DSjE0.js";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-Du6gdUDd.js";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DgNfRAGA.js";
 import { asOptionalRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
-import fs from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { resolveAgentConfig, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import path from "node:path";
+import fs from "node:fs/promises";
+import { addAbortListener } from "node:events";
+import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
+import { Buffer as Buffer$1 } from "node:buffer";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
-import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
-import { resolveAgentConfig as resolveAgentConfig$1, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
-import { addAbortListener } from "node:events";
-import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
-import { hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
-import { Buffer as Buffer$1 } from "node:buffer";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { appendSessionYieldContext, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
+import { acknowledgeInternalToolResult } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+//#region extensions/codex/src/app-server/attempt-preparation-timing.ts
+/** Records startup before the native turn owns inference and tool execution. */
+function createCodexAttemptPreparationTiming(params) {
+	const tracker = createCodexDynamicToolBuildStageTracker();
+	const profilerEnabled = isCodexAppServerProfilerEnabled(params.config);
+	const totalWarnMs = profilerEnabled ? 1e3 : 1e4;
+	const stageWarnMs = profilerEnabled ? 500 : 5e3;
+	const log = (stage, outcome) => {
+		const summary = tracker.snapshot();
+		const lastStage = summary.stages.at(-1);
+		const slowTotal = outcome !== "completed" && summary.totalMs >= totalWarnMs;
+		const slowStage = outcome !== "ready" && (lastStage?.durationMs ?? 0) >= stageWarnMs;
+		if (!slowTotal && !slowStage) return;
+		embeddedAgentLog.warn(`codex app-server preparation timings runId=${params.runId} sessionId=${params.sessionId} stage=${stage} outcome=${outcome} totalMs=${summary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(summary)}`, {
+			runId: params.runId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			stage,
+			outcome,
+			totalMs: summary.totalMs,
+			stages: summary.stages
+		});
+	};
+	return {
+		async measure(stage, run) {
+			let outcome = "error";
+			try {
+				const result = await run();
+				outcome = "completed";
+				return result;
+			} finally {
+				tracker.mark(stage);
+				log(stage, outcome);
+			}
+		},
+		ready() {
+			log("native-turn-handoff", "ready");
+		}
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/attempt-steering.ts
 /**
 * Debounced steering queue for forwarding user messages to an active Codex
@@ -130,30 +186,67 @@ function createCodexSteeringQueue(params) {
 		closeQueue(/* @__PURE__ */ new Error("codex app-server steering queue cancelled"));
 	};
 	const sendBatch = async (items) => {
-		const liveItems = items.filter((item) => !item.settled);
+		let liveItems = items.filter((item) => !item.settled);
 		if (liveItems.length === 0) return;
 		let clientUserMessageId;
+		let skippedRevokedBatch = false;
 		try {
 			assertActive();
-			const input = [];
+			const prepared = /* @__PURE__ */ new Map();
+			const isCurrent = (item) => {
+				if (item.settled) return false;
+				try {
+					item.assertCurrent();
+					return true;
+				} catch (error) {
+					rejectItem(item, error);
+					return false;
+				}
+			};
 			for (const item of liveItems) {
-				input.push(...await params.prepareMessage(item.text, item));
+				if (!isCurrent(item)) continue;
+				try {
+					prepared.set(item, await params.prepareMessage(item.text, item));
+				} catch (error) {
+					if (isCurrent(item)) throw error;
+				}
+				assertActive();
+				isCurrent(item);
+			}
+			liveItems = liveItems.filter(isCurrent);
+			if (liveItems.length === 0) return;
+			if (params.beforeSubmit) {
+				await params.beforeSubmit(liveItems);
 				assertActive();
+				liveItems = liveItems.filter(isCurrent);
+				if (liveItems.length === 0) return;
 			}
 			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
 			dispatchedBatches.set(clientUserMessageId, { items: liveItems });
-			await params.client.request("turn/steer", {
+			const request = {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
-				input,
+				input: liveItems.flatMap((item) => prepared.get(item) ?? []),
 				clientUserMessageId
-			}, {
+			};
+			await params.client.request("turn/steer", request, {
 				timeoutMs: params.requestTimeoutMs,
-				signal: params.signal
+				signal: params.signal,
+				assertCurrent: () => {
+					assertActive();
+					liveItems = liveItems.filter(isCurrent);
+					request.input = liveItems.flatMap((item) => prepared.get(item) ?? []);
+					dispatchedBatches.set(request.clientUserMessageId, { items: liveItems });
+					if (liveItems.length === 0) {
+						skippedRevokedBatch = true;
+						throw new Error("Codex steering batch has no authorized inputs");
+					}
+				}
 			});
 			for (const item of liveItems) reportItemAcceptance(item, true);
 		} catch (error) {
 			if (clientUserMessageId) dispatchedBatches.delete(clientUserMessageId);
+			if (skippedRevokedBatch) return;
 			const acceptedUnconfirmed = clientUserMessageId !== void 0 && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error));
 			for (const item of liveItems) {
 				if (acceptedUnconfirmed) reportItemAcceptance(item, true);
@@ -180,7 +273,7 @@ function createCodexSteeringQueue(params) {
 		send.catch(() => void 0);
 		return send;
 	};
-	const createPendingMessage = (text, options) => {
+	const createPendingMessage = (text, options, assertCurrent = () => {}) => {
 		let resolveDelivery;
 		let rejectDelivery;
 		const delivery = new Promise((resolve, reject) => {
@@ -189,6 +282,7 @@ function createCodexSteeringQueue(params) {
 		});
 		const item = {
 			...options,
+			assertCurrent,
 			acceptance: "open",
 			text,
 			resolve: resolveDelivery,
@@ -204,14 +298,15 @@ function createCodexSteeringQueue(params) {
 	params.signal.addEventListener("abort", abortQueue, { once: true });
 	if (params.signal.aborted) abortQueue();
 	return {
-		async queue(text, options) {
+		async queue(text, options, assertCurrent = () => {}) {
 			try {
 				assertActive();
+				assertCurrent();
 			} catch (error) {
 				options?.onQueueAccepted?.(false);
 				throw error;
 			}
-			const { item, delivery } = createPendingMessage(text, options);
+			const { item, delivery } = createPendingMessage(text, options, assertCurrent);
 			batchedMessages.push(item);
 			clearBatchTimer();
 			const debounceMs = normalizeCodexSteerDebounceMs(options?.debounceMs);
@@ -226,21 +321,8 @@ function createCodexSteeringQueue(params) {
 			const batch = dispatchedBatches.get(clientUserMessageId);
 			if (!batch) return false;
 			dispatchedBatches.delete(clientUserMessageId);
-			for (const item of batch.items) reportItemAcceptance(item, true);
-			const resolveBatch = () => {
-				for (const item of batch.items) resolveItem(item);
-				return true;
-			};
-			const rejectBatch = (error) => {
-				for (const item of batch.items) rejectItem(item, error);
-				return true;
-			};
-			if (!params.beforeConfirmConsumed) return resolveBatch();
-			try {
-				return params.beforeConfirmConsumed(batch.items).then(resolveBatch, rejectBatch);
-			} catch (error) {
-				return rejectBatch(error);
-			}
+			for (const item of batch.items) resolveItem(item);
+			return true;
 		},
 		sealAdmission: sealQueueAdmission,
 		cancel: cancelQueue
@@ -251,6 +333,9 @@ function normalizeCodexSteerDebounceMs(value) {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : CODEX_STEER_ALL_DEBOUNCE_MS;
 }
 //#endregion
+//#region extensions/codex/src/app-server/attempt-terminal.ts
+const attemptTerminal = agentHarnessAttemptTerminal;
+//#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
 	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
@@ -320,6 +405,7 @@ var CodexAssistantProjection = class {
 		this.emitAgentEvent({
 			stream: "assistant",
 			data: {
+				itemId,
 				...streamPayload,
 				...replaceable ? { replaceable: true } : {}
 			}
@@ -1000,8 +1086,61 @@ function reasoningMethodOrder(method) {
 	return method === "item/reasoning/summaryTextDelta" ? 0 : 1;
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-terminal.ts
-const attemptTerminal = agentHarnessAttemptTerminal;
+//#region extensions/codex/src/app-server/event-projector-settlement.ts
+var CodexProjectionSettlement = class {
+	constructor(params, isActive) {
+		this.turnTainted = false;
+		this.pending = /* @__PURE__ */ new Map();
+		const detach = (stage, callback) => callback ? (...args) => {
+			if (!isActive()) return;
+			const completion = createDeferred();
+			this.pending.set(completion.promise, stage);
+			const settled = () => {
+				this.pending.delete(completion.promise);
+				completion.resolve();
+			};
+			const failed = (error) => {
+				embeddedAgentLog.warn(`codex app-server ${stage} callback failed: ${String(error)}`);
+				settled();
+			};
+			try {
+				Promise.resolve(callback(...args)).then(settled, failed);
+			} catch (error) {
+				failed(error);
+			}
+		} : void 0;
+		this.params = {
+			...params,
+			onAssistantMessageStart: detach("onAssistantMessageStart", params.onAssistantMessageStart),
+			onPartialReply: detach("onPartialReply", params.onPartialReply),
+			onReasoningStream: detach("onReasoningStream", params.onReasoningStream),
+			onReasoningEnd: detach("onReasoningEnd", params.onReasoningEnd)
+		};
+	}
+	get pendingStage() {
+		return this.stage ?? this.pending.values().next().value;
+	}
+	get completedAnswer() {
+		const turn = this.terminalReceipt;
+		const answer = turn?.items?.findLast((item) => item.type === "agentMessage" && item.phase !== "commentary" && item.delivery !== "async" && typeof item.text === "string" && item.text.trim().length > 0);
+		return turn?.status === "completed" && answer ? {
+			turn,
+			answer
+		} : void 0;
+	}
+	async project(stage, project) {
+		const previous = this.stage;
+		this.stage = stage;
+		try {
+			return await project();
+		} finally {
+			this.stage = previous;
+		}
+	}
+	async drain() {
+		while (this.pending.size > 0) await Promise.all(this.pending.keys());
+	}
+};
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
 function buildCodexMessagesSnapshot(params) {
@@ -1016,7 +1155,10 @@ function buildCodexMessagesSnapshot(params) {
 		...params.toolMessages
 	].toSorted((left, right) => (asDateTimestampMs(left.timestamp) ?? 0) - (asDateTimestampMs(right.timestamp) ?? 0));
 	messages.push(...visibleWorkMessages);
-	if (params.lastAssistant) messages.push(attachCodexMirrorIdentity(params.lastAssistant, `${params.turnId}:assistant`));
+	if (params.lastAssistant) {
+		const assistant = applyCodexTranscriptTaint(params.lastAssistant, { tainted: params.turnTainted === true });
+		messages.push(attachCodexMirrorIdentity(assistant, `${params.turnId}:assistant`));
+	}
 	const taint = { tainted: false };
 	return messages.map((message) => projectAgentHarnessTranscriptMessageForDisplay({
 		hidden: params.runParams.trigger === "memory",
@@ -1047,202 +1189,39 @@ function buildCodexSteeringMessagesSnapshot(params) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/app-server/event-projector-result.ts
-function buildCodexAttemptResult(input) {
-	input.nativeToolLifecycleProjection.finalizeActive();
-	const assistantTexts = input.assistantProjection.collectAssistantTexts();
-	const asyncMessages = input.assistantProjection.collectAsyncMessages();
-	const commentaryMessages = input.assistantProjection.collectCommentaryMessages();
-	const reasoningText = input.reasoningProjection.reasoningText();
-	const planText = input.reasoningProjection.planText();
-	const unavailableThreadUsage = input.tokenUsage ? {
-		...input.tokenUsage,
-		contextUsage: { state: "unavailable" }
-	} : void 0;
-	const completedUsage = input.responseCompletions.usage ?? (input.responseCompletions.modelIterations > 0 ? unavailableThreadUsage : input.tokenUsage);
-	const projectedUsage = input.aborted ? unavailableThreadUsage : completedUsage;
-	const hasAssistantItemText = input.assistantProjection.hasAssistantItemTextForSynthesis();
-	const legacyFailClosed = !input.completedTurn || input.completedTurn.status !== "completed" || hasAssistantItemText;
-	const hasDeliverableAssistantOnCompletedTurn = input.completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
-	const synthesizedMissingToolResultError = input.toolTranscriptProjection.synthesizeMissingToolResults({
-		synthesize: legacyFailClosed,
-		terminalDisposition: input.aborted ? "tool_error" : hasDeliverableAssistantOnCompletedTurn ? "diagnostic_only" : "prompt_error"
-	});
-	const storedMissingToolResultError = synthesizedMissingToolResultError ?? input.synthesizedMissingToolResultError;
-	let promptErrorSource = input.promptErrorSource;
-	if (synthesizedMissingToolResultError) {
-		input.recordSynthesizedMissingToolResultError(synthesizedMissingToolResultError);
-		promptErrorSource = promptErrorSource ?? "prompt";
-	}
-	const assistantMessageOptions = {
-		tokenUsage: projectedUsage,
-		aborted: input.aborted,
-		promptError: input.promptError
-	};
-	const lastAssistant = assistantTexts.length ? input.assistantProjection.createAssistantMessage(assistantTexts.join("\n\n"), assistantMessageOptions) : void 0;
-	const currentAttemptAssistant = input.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
-	const messagesSnapshot = buildCodexMessagesSnapshot({
-		runParams: input.runParams,
-		turnId: input.turnId,
-		upstreamUserText: input.upstreamUserText,
-		reasoningText,
-		asyncMessages,
-		commentaryMessages,
-		toolMessages: input.toolTranscriptProjection.transcriptMessages,
-		lastAssistant
-	});
-	const turnFailed = input.completedTurn?.status === "failed";
-	const promptError = input.promptError ?? storedMissingToolResultError ?? (turnFailed ? input.completedTurn?.error?.message ?? "codex app-server turn failed" : null);
-	const agentHarnessResultClassification = classifyAgentHarnessTerminalOutcome({
-		assistantTexts,
-		reasoningText,
-		planText,
-		promptError,
-		turnCompleted: Boolean(input.completedTurn)
-	});
-	const toolMetas = input.toolProgressProjection.toolMetas;
-	const hadPotentialSideEffects = input.toolTelemetry.didSendViaMessagingTool || Boolean(input.toolTelemetry.successfulCronAdds || input.toolTelemetry.acceptedSessionSpawns?.length) || input.generatedMediaProjection.hasGeneratedMedia() || input.toolProgressProjection.hasPotentialSideEffects;
-	const sentMediaUrls = new Set(input.toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
-	const toolAutoDeliveryMediaUrls = input.toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
-	const result = {
-		terminal: attemptTerminal.normalize({
-			aborted: input.aborted,
-			promptError,
-			promptErrorSource: promptError ? promptErrorSource || "prompt" : null
-		}),
-		sessionIdUsed: input.runParams.sessionId,
-		terminalTurnId: input.turnId,
-		...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
-		bootstrapPromptWarningSignaturesSeen: input.runParams.bootstrapPromptWarningSignaturesSeen,
-		bootstrapPromptWarningSignature: input.runParams.bootstrapPromptWarningSignature,
-		...input.responseCompletions.modelIterations > 0 ? { modelIterations: input.responseCompletions.modelIterations } : {},
-		messagesSnapshot,
-		assistantTexts,
-		toolMetas,
-		lastAssistant,
-		currentAttemptAssistant,
-		...input.toolProgressProjection.lastToolError ? { lastToolError: input.toolProgressProjection.lastToolError } : {},
-		didSendViaMessagingTool: input.toolTelemetry.didSendViaMessagingTool,
-		didDeliverSourceReplyViaMessageTool: input.toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
-		messagingToolSentTexts: input.toolTelemetry.messagingToolSentTexts,
-		messagingToolSentMediaUrls: input.toolTelemetry.messagingToolSentMediaUrls,
-		messagingToolSentTargets: input.toolTelemetry.messagingToolSentTargets,
-		messagingToolSourceReplyPayloads: input.toolTelemetry.messagingToolSourceReplyPayloads ?? [],
-		heartbeatToolResponse: input.toolTelemetry.heartbeatToolResponse,
-		toolMediaUrls: input.generatedMediaProjection.buildToolMediaUrls(input.toolTelemetry),
-		hostOwnedToolMediaUrls: input.generatedMediaProjection.buildHostOwnedMediaUrls(input.toolTelemetry),
-		toolAudioAsVoice: input.toolTelemetry.toolAudioAsVoice,
-		successfulCronAdds: input.toolTelemetry.successfulCronAdds,
-		acceptedSessionSpawns: input.toolTelemetry.acceptedSessionSpawns,
-		cloudCodeAssistFormatError: false,
-		contextTokens: input.contextTokens,
-		contextTokensSource: input.contextTokensSource,
-		attemptUsage: projectedUsage,
-		...input.completedCompactionCount > 0 ? { compactionCount: input.completedCompactionCount } : {},
-		replayMetadata: {
-			hadPotentialSideEffects,
-			replaySafe: !hadPotentialSideEffects
-		},
-		itemLifecycle: {
-			startedCount: input.activeItemCount + input.completedItemCount,
-			completedCount: input.completedItemCount,
-			activeCount: input.activeItemCount
-		},
-		yieldDetected: input.yieldDetected || false,
-		didSendDeterministicApprovalPrompt: input.guardianReviewCount > 0 ? false : void 0
-	};
-	const transferTtsProvenance = resolveCodexTtsProvenanceTransfer(input.runParams.hostCapabilities);
-	for (const toolResult of input.toolTelemetry.coreTtsToolResults ?? []) transferTtsProvenance?.(toolResult, result, toolAutoDeliveryMediaUrls ?? []);
-	return result;
-}
-//#endregion
-//#region extensions/codex/src/app-server/transcript-checkpoint.ts
-/** Commits completed work in receipt order without waiting for the enclosing turn. */
-var CodexTranscriptCheckpoint = class {
-	constructor(params, threadId, turnId) {
-		this.params = params;
-		this.threadId = threadId;
-		this.turnId = turnId;
-		this.pending = [];
-		this.commentaryItemIds = /* @__PURE__ */ new Set();
-		this.lastTimestamp = 0;
-		this.writing = Promise.resolve();
-		this.tainted = false;
-		this.closed = false;
-		this.nextTimestamp = () => {
-			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
-			return this.lastTimestamp;
-		};
-		this.enqueueCommentary = (itemId, entry) => {
-			if (this.params.config?.ui?.prefs?.chatPersistCommentary === false || this.commentaryItemIds.has(itemId)) return;
-			this.commentaryItemIds.add(itemId);
-			this.enqueue({
-				...entry,
-				read: () => {
-					const message = entry.read();
-					return message ? attachCodexMirrorIdentity(message, `${this.turnId}:commentary:${itemId}`) : void 0;
-				}
-			});
-		};
-		this.enqueue = (entry) => {
-			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
-		};
-	}
-	flush(close = false) {
-		if (this.closed) return this.writing;
-		this.closed = close;
-		this.writing = this.writing.then(async () => {
-			const blocked = close ? -1 : this.pending.findIndex((entry) => entry.ready?.() === false);
-			const count = blocked < 0 ? this.pending.length : blocked;
-			if (count === 0) return;
-			const taint = { tainted: this.tainted };
-			const messages = this.pending.slice(0, count).flatMap((entry) => {
-				const message = entry.read();
-				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
-					hidden: this.params.trigger === "memory",
-					message: applyCodexTranscriptTaint(message, taint)
-				})] : [];
-			});
-			try {
-				await codexTranscriptMirrorRuntime.mirror({
-					...this.params.sessionTarget,
-					sessionId: this.params.sessionId,
-					cwd: this.params.workspaceDir,
-					messages,
-					idempotencyScope: `codex-app-server:${this.threadId}`,
-					runId: this.params.runId,
-					runMirrorIdentityPrefix: `${this.turnId}:`,
-					config: this.params.config
-				});
-				this.pending.splice(0, count);
-				this.tainted = taint.tainted;
-			} catch (error) {
-				embeddedAgentLog.warn("failed to checkpoint codex app-server transcript", {
-					runId: this.params.runId,
-					sessionId: this.params.sessionId,
-					error: formatErrorMessage(error)
-				});
-			}
-		});
-		return this.writing;
-	}
-};
-//#endregion
 //#region extensions/codex/src/app-server/usage-limit-error.ts
 /**
 * Enriches Codex usage-limit failures with current rate-limit information and
 * marks blocked auth profiles when Codex exposes a reset time.
 */
 const CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS = 5e3;
-function createCodexUsageLimitPromptError(message) {
-	return Object.assign(new Error(message), { status: 429 });
-}
+var CodexUsageLimitPromptError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.status = 429;
+	}
+};
 function resolveCodexPromptError(source) {
 	const usageLimitMessage = formatCodexUsageLimitErrorMessage(source);
-	return usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : source.message ?? void 0;
-}
-function isCodexUsageLimitPromptError(error) {
-	return error instanceof Error && "status" in error && error.status === 429;
+	if (usageLimitMessage) return new CodexUsageLimitPromptError(usageLimitMessage);
+	const info = source.codexErrorInfo;
+	let status = info === "rateLimitExceeded" ? 429 : info === "serverOverloaded" ? 503 : info === "internalServerError" ? 500 : void 0;
+	if (isJsonObject(info)) for (const variant of [
+		"httpConnectionFailed",
+		"responseStreamConnectionFailed",
+		"responseStreamDisconnected",
+		"responseTooManyFailedAttempts"
+	]) {
+		const detail = info[variant];
+		if (isJsonObject(detail) && typeof detail.httpStatusCode === "number") {
+			status = detail.httpStatusCode;
+			break;
+		}
+	}
+	return status === void 0 ? source.message ?? void 0 : Object.assign(new Error(source.message ?? "codex app-server error"), {
+		status,
+		...info === "serverOverloaded" ? { code: "OVERLOADED" } : {}
+	});
 }
 /** Marks a Codex auth profile blocked until the reset time advertised by rate limits. */
 async function markCodexAuthProfileBlockedFromRateLimits(params) {
@@ -1368,8 +1347,106 @@ function readCodexErrorPayload(error) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/app-server/event-projector.ts
-var CodexAppServerEventProjector = class {
+//#region extensions/codex/src/app-server/event-projector-terminal-failure.ts
+var CodexTerminalFailureProjection = class {
+	constructor() {
+		this.promptErrorSource = null;
+	}
+	record(params) {
+		this.providerRefusal ??= readCodexProviderRefusal(params.message, params.codexErrorInfo);
+		if (this.providerRefusal) return;
+		this.promptError = resolveCodexPromptError({
+			message: params.message,
+			codexErrorInfo: params.codexErrorInfo,
+			rateLimits: params.rateLimits
+		}) ?? params.fallbackMessage;
+		this.promptErrorSource = params.promptErrorSource;
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/transcript-checkpoint.ts
+/** Commits completed work in receipt order without waiting for the enclosing turn. */
+var CodexTranscriptCheckpoint = class {
+	constructor(params, threadId, turnId) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.pending = [];
+		this.commentaryItemIds = /* @__PURE__ */ new Set();
+		this.lastTimestamp = 0;
+		this.writing = Promise.resolve();
+		this.tainted = false;
+		this.closed = false;
+		this.abandoned = false;
+		this.nextTimestamp = () => {
+			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
+			return this.lastTimestamp;
+		};
+		this.enqueueCommentary = (itemId, entry) => {
+			if (this.params.config?.ui?.prefs?.chatPersistCommentary === false || this.commentaryItemIds.has(itemId)) return;
+			this.commentaryItemIds.add(itemId);
+			this.enqueue({
+				...entry,
+				read: () => {
+					const message = entry.read();
+					return message ? attachCodexMirrorIdentity(message, `${this.turnId}:commentary:${itemId}`) : void 0;
+				}
+			});
+		};
+		this.enqueue = (entry) => {
+			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
+		};
+	}
+	abandon() {
+		this.closed = this.abandoned = true;
+		this.pending.length = 0;
+	}
+	flush(close = false) {
+		if (this.closed) return this.writing;
+		this.closed = close;
+		this.writing = this.writing.then(async () => {
+			const blocked = close ? -1 : this.pending.findIndex((entry) => entry.ready?.() === false);
+			const count = blocked < 0 ? this.pending.length : blocked;
+			if (count === 0) return;
+			const taint = { tainted: this.tainted };
+			const messages = this.pending.slice(0, count).flatMap((entry) => {
+				const message = entry.read();
+				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
+					hidden: this.params.trigger === "memory",
+					message: applyCodexTranscriptTaint(message, taint)
+				})] : [];
+			});
+			try {
+				await codexTranscriptMirrorRuntime.mirror({
+					assertWriteCurrent: () => {
+						if (this.abandoned) throw new Error("Codex transcript checkpoint was retired before write");
+					},
+					...this.params.sessionTarget,
+					sessionId: this.params.sessionId,
+					cwd: this.params.workspaceDir,
+					messages,
+					idempotencyScope: `codex-app-server:${this.threadId}`,
+					runId: this.params.runId,
+					runMirrorIdentityPrefix: `${this.turnId}:`,
+					config: this.params.config
+				});
+				this.pending.splice(0, count);
+				this.tainted = taint.tainted;
+			} catch (error) {
+				embeddedAgentLog.warn("failed to checkpoint codex app-server transcript", {
+					runId: this.params.runId,
+					sessionId: this.params.sessionId,
+					error: formatErrorMessage(error)
+				});
+			}
+		});
+		return this.writing;
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-result.ts
+/** Owns per-turn projection state and builds results from the same state. */
+var CodexTurnProjection = class {
 	constructor(params, threadId, turnId, options = {}) {
 		this.params = params;
 		this.threadId = threadId;
@@ -1378,15 +1455,14 @@ var CodexAppServerEventProjector = class {
 		this.activeItemIds = /* @__PURE__ */ new Set();
 		this.completedItemIds = /* @__PURE__ */ new Set();
 		this.activeCompactionItemIds = /* @__PURE__ */ new Set();
-		this.terminalPresentationClearedItemIds = /* @__PURE__ */ new Set();
-		this.nativeToolOutcomeOrdinals = /* @__PURE__ */ new Map();
-		this.projectionClosed = false;
+		this.projectionController = new AbortController();
 		this.settledTurnFailureFinalizationAllowed = false;
-		this.promptErrorSource = null;
+		this.terminalFailure = new CodexTerminalFailureProjection();
 		this.synthesizedMissingToolResultError = null;
 		this.aborted = false;
-		this.responseCompletions = new CodexResponseCompletionProjection();
+		this.usageProjection = new CodexUsageProjection();
 		this.completedCompactionCount = 0;
+		this.settlement = new CodexProjectionSettlement(params, () => !this.projectionClosed);
 		this.transcriptCheckpoint = new CodexTranscriptCheckpoint(params, threadId, turnId);
 		this.asyncDeliveryProjection = new CodexAsyncDeliveryProjection(params, threadId, turnId, options);
 		this.contextTokens = options.initialContextTokens;
@@ -1397,7 +1473,7 @@ var CodexAppServerEventProjector = class {
 			remoteWorkspaceRoot: options.remoteWorkspaceRoot,
 			readFile: options.readRemoteWorkspaceFile,
 			requestTimeoutMs: options.remoteWorkspaceRequestTimeoutMs,
-			signal: options.runAbortSignal
+			signal: options.runAbortSignal ? AbortSignal.any([options.runAbortSignal, this.projectionController.signal]) : this.projectionController.signal
 		});
 		this.toolProgressProjection = new CodexToolProgressProjection(params);
 		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, this.transcriptCheckpoint.nextTimestamp, {
@@ -1407,12 +1483,151 @@ var CodexAppServerEventProjector = class {
 			checkpointMessage: this.transcriptCheckpoint.enqueue
 		});
 		this.eventProjection = new CodexEventProjection(threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
-		this.assistantProjection = new CodexAssistantProjection(params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
-		this.reasoningProjection = new CodexReasoningProjection(params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
+		this.assistantProjection = new CodexAssistantProjection(this.settlement.params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
+		this.reasoningProjection = new CodexReasoningProjection(this.settlement.params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
 	}
+	get projectionClosed() {
+		return this.projectionController.signal.aborted;
+	}
+	buildResult(toolTelemetry, options) {
+		this.eventProjection.flushPendingGuardianWarning();
+		const { params: runParams, turnId, completedTurn, aborted, contextTokens, contextTokensSource, completedCompactionCount, synthesizedMissingToolResultError: previousMissingToolResultError } = this;
+		const { promptError: initialPromptError, promptErrorSource: initialPromptErrorSource, providerRefusal } = this.terminalFailure;
+		const upstreamUserText = this.options.upstreamUserText;
+		const turnTainted = this.settlement.turnTainted;
+		const activeItemCount = this.activeItemIds.size;
+		const completedItemCount = this.completedItemIds.size;
+		const guardianReviewCount = this.eventProjection.guardianReviewCount;
+		const yieldDetected = options?.yieldDetected;
+		this.nativeToolLifecycleProjector.finalizeActive();
+		const assistantTexts = this.assistantProjection.collectAssistantTexts();
+		const asyncMessages = this.assistantProjection.collectAsyncMessages();
+		const commentaryMessages = this.assistantProjection.collectCommentaryMessages();
+		const reasoningText = this.reasoningProjection.reasoningText();
+		const planText = this.reasoningProjection.planText();
+		const usage = this.usageProjection.usage;
+		const projectedUsage = aborted && usage ? {
+			...usage,
+			contextUsage: { state: "unavailable" }
+		} : usage;
+		const hasAssistantItemText = this.assistantProjection.hasAssistantItemTextForSynthesis();
+		const legacyFailClosed = !completedTurn || completedTurn.status !== "completed" || hasAssistantItemText;
+		const hasDeliverableAssistantOnCompletedTurn = completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
+		const synthesizedMissingToolResultError = this.toolTranscriptProjection.synthesizeMissingToolResults({
+			synthesize: legacyFailClosed,
+			terminalDisposition: aborted ? "tool_error" : hasDeliverableAssistantOnCompletedTurn ? "diagnostic_only" : "prompt_error"
+		});
+		const storedMissingToolResultError = synthesizedMissingToolResultError ?? previousMissingToolResultError;
+		let promptErrorSource = initialPromptErrorSource;
+		if (synthesizedMissingToolResultError) {
+			this.synthesizedMissingToolResultError = synthesizedMissingToolResultError;
+			promptErrorSource = promptErrorSource ?? "prompt";
+		}
+		const assistantMessageOptions = {
+			tokenUsage: projectedUsage,
+			aborted,
+			promptError: initialPromptError,
+			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);
+		const messagesSnapshot = buildCodexMessagesSnapshot({
+			runParams,
+			turnId,
+			upstreamUserText,
+			reasoningText,
+			asyncMessages,
+			commentaryMessages,
+			toolMessages: this.toolTranscriptProjection.transcriptMessages,
+			lastAssistant,
+			turnTainted
+		});
+		const turnFailed = completedTurn?.status === "failed";
+		const promptError = providerRefusal ? null : initialPromptError ?? storedMissingToolResultError ?? (turnFailed ? completedTurn?.error?.message ?? "codex app-server turn failed" : null);
+		const agentHarnessResultClassification = providerRefusal ? void 0 : classifyAgentHarnessTerminalOutcome({
+			assistantTexts,
+			reasoningText,
+			planText,
+			promptError,
+			turnCompleted: Boolean(completedTurn)
+		});
+		const toolMetas = this.toolProgressProjection.toolMetas;
+		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || Boolean(toolTelemetry.successfulCronAdds || toolTelemetry.acceptedSessionSpawns?.length) || this.generatedMediaProjection.hasGeneratedMedia() || this.toolProgressProjection.hasPotentialSideEffects;
+		const sentMediaUrls = new Set(toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
+		const toolAutoDeliveryMediaUrls = toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
+		const result = {
+			terminal: attemptTerminal.normalize({
+				aborted,
+				promptError,
+				promptErrorSource: promptError ? promptErrorSource || "prompt" : null
+			}),
+			sessionIdUsed: runParams.sessionId,
+			terminalTurnId: turnId,
+			...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
+			bootstrapPromptWarningSignaturesSeen: runParams.bootstrapPromptWarningSignaturesSeen,
+			bootstrapPromptWarningSignature: runParams.bootstrapPromptWarningSignature,
+			...this.usageProjection.modelIterations > 0 ? { modelIterations: this.usageProjection.modelIterations } : {},
+			messagesSnapshot,
+			assistantTexts,
+			toolMetas,
+			lastAssistant,
+			currentAttemptAssistant,
+			...this.toolProgressProjection.lastToolError ? { lastToolError: this.toolProgressProjection.lastToolError } : {},
+			didSendViaMessagingTool: toolTelemetry.didSendViaMessagingTool,
+			didDeliverSourceReplyViaMessageTool: toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
+			sourceReplyDelivered: toolTelemetry.sourceReplyDelivered,
+			messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,
+			messagingToolSentMediaUrls: toolTelemetry.messagingToolSentMediaUrls,
+			messagingToolSentTargets: toolTelemetry.messagingToolSentTargets,
+			messagingToolSourceReplyPayloads: toolTelemetry.messagingToolSourceReplyPayloads ?? [],
+			heartbeatToolResponse: toolTelemetry.heartbeatToolResponse,
+			toolMediaUrls: this.generatedMediaProjection.buildToolMediaUrls(toolTelemetry),
+			hostOwnedToolMediaUrls: this.generatedMediaProjection.buildHostOwnedMediaUrls(toolTelemetry),
+			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
+			successfulCronAdds: toolTelemetry.successfulCronAdds,
+			acceptedSessionSpawns: toolTelemetry.acceptedSessionSpawns,
+			cloudCodeAssistFormatError: false,
+			contextTokens,
+			contextTokensSource,
+			attemptUsage: projectedUsage,
+			...completedCompactionCount > 0 ? { compactionCount: completedCompactionCount } : {},
+			replayMetadata: {
+				hadPotentialSideEffects,
+				replaySafe: !hadPotentialSideEffects
+			},
+			itemLifecycle: {
+				startedCount: activeItemCount + completedItemCount,
+				completedCount: completedItemCount,
+				activeCount: activeItemCount
+			},
+			yieldDetected: yieldDetected || false,
+			didSendDeterministicApprovalPrompt: guardianReviewCount > 0 ? false : void 0
+		};
+		const transferTtsProvenance = resolveCodexTtsProvenanceTransfer(runParams.hostCapabilities);
+		for (const toolResult of toolTelemetry.coreTtsToolResults ?? []) transferTtsProvenance?.(toolResult, result, toolAutoDeliveryMediaUrls ?? []);
+		return result;
+	}
+	emitAgentEvent(event) {
+		if (!this.projectionClosed) emitCodexAgentEvent(this.params, event);
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/event-projector.ts
+var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
 	}
+	/** Native completion owns the answer independently of unfinished host projection. */
+	recoverCompletedAnswer() {
+		const completed = this.settlement.completedAnswer;
+		if (!completed || this.aborted || this.terminalFailure.promptError) return false;
+		this.projectionController.abort();
+		this.transcriptCheckpoint.abandon();
+		this.completedTurn = completed.turn;
+		this.assistantProjection.recordSnapshotItem(completed.answer);
+		this.assistantProjection.finalizeAnswerCandidate(completed.turn);
+		return true;
+	}
 	getActiveMcpToolCall(serverName) {
 		if (this.projectionClosed || this.aborted) return;
 		return this.nativeToolLifecycleProjector.getActiveMcpToolCall(serverName);
@@ -1441,14 +1656,12 @@ var CodexAppServerEventProjector = class {
 	}
 	/** Fence delayed projections before the turn's final snapshot leaves its owner. */
 	closeProjection() {
-		this.projectionClosed = true;
-		return this.transcriptCheckpoint.flush(true);
+		this.projectionController.abort();
+		return this.settlement.project("transcript/checkpoint", () => this.transcriptCheckpoint.flush(true));
 	}
 	/** Resolves the shared model-order position for a native tool item. */
 	recordNativeToolOutcome(item) {
-		if (!item || this.nativeToolOutcomeOrdinals.has(item.id) || !shouldClearTerminalPresentationForNativeItem(item)) return;
-		const ordinal = this.params.allocateToolOutcomeOrdinal?.(item.id);
-		if (ordinal !== void 0) this.nativeToolOutcomeOrdinals.set(item.id, ordinal);
+		this.nativeToolLifecycleProjector.recordNativeToolOutcome(item);
 	}
 	recordNativeToolApprovalFailure(toolCallId, disposition, approvalKind) {
 		this.nativeToolLifecycleProjector.recordApprovalFailureDisposition(toolCallId, disposition);
@@ -1486,11 +1699,9 @@ var CodexAppServerEventProjector = class {
 				break;
 			case "item/started":
 				await this.handleItemStarted(params);
-				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/completed":
 				await this.handleItemCompleted(params);
-				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/commandExecution/outputDelta":
 				this.toolProgressProjection.handleOutputDelta(params, "bash");
@@ -1513,43 +1724,46 @@ var CodexAppServerEventProjector = class {
 			case "hook/completed":
 				this.eventProjection.handleHook(notification.method, params);
 				break;
-			case "thread/tokenUsage/updated":
-				projectCodexThreadUsageUpdate(params, this.tokenUsage, (usage) => this.tokenUsage = usage, (data) => {
-					if (data.modelContextWindow !== void 0) {
-						this.contextTokens = data.modelContextWindow;
-						this.contextTokensSource = this.params.authoredContextTokenCap === void 0 ? "runtime" : "runtime-configured";
-					}
-					this.emitAgentEvent({
-						stream: "usage",
-						data
-					});
+			case "thread/tokenUsage/updated": {
+				const data = this.usageProjection.recordThread(params);
+				if (data.modelContextWindow !== void 0) {
+					this.contextTokens = data.modelContextWindow;
+					this.contextTokensSource = this.params.authoredContextTokenCap === void 0 ? "runtime" : "runtime-configured";
+				}
+				if (Object.keys(data).length > 0) this.emitAgentEvent({
+					stream: "usage",
+					data
 				});
 				break;
+			}
 			case "turn/completed":
 				await this.handleTurnCompleted(params);
 				break;
 			case "rawResponse/completed":
-				this.responseCompletions.record(params, this.params.hostCapabilities.reportOutputTokens);
+				this.usageProjection.record(params, this.params.hostCapabilities.reportOutputTokens);
 				break;
 			case "rawResponseItem/completed":
 				await this.handleRawResponseItemCompleted(params);
-				await this.transcriptCheckpoint.flush();
 				break;
 			case "model/rerouted":
 				this.eventProjection.handleModelRerouted(params);
 				break;
 			case "error": {
-				this.responseCompletions.clear();
-				if (params.willRetry === true) break;
+				this.usageProjection.invalidateContext();
+				if (params.willRetry === true) {
+					this.eventProjection.handleRetry(params);
+					break;
+				}
 				const codexErrorInfo = isJsonObject(params.error) ? params.error.codexErrorInfo : void 0;
 				const compactionFailure = codexErrorInfo === "other" && this.isCompacting();
 				this.settledTurnFailureFinalizationAllowed = codexErrorInfo === "serverOverloaded" || compactionFailure;
-				this.promptError = resolveCodexPromptError({
+				this.terminalFailure.record({
 					message: readCodexErrorNotificationMessage(params),
 					codexErrorInfo,
-					rateLimits: this.options.readRecentRateLimits?.()
-				}) ?? "codex app-server error";
-				this.promptErrorSource = compactionFailure ? "compaction" : "prompt";
+					rateLimits: this.options.readRecentRateLimits?.(),
+					fallbackMessage: "codex app-server error",
+					promptErrorSource: compactionFailure ? "compaction" : "prompt"
+				});
 				break;
 			}
 			case "thread/compacted":
@@ -1565,47 +1779,23 @@ var CodexAppServerEventProjector = class {
 			case "model/safetyBuffering/updated": break;
 			default: this.diagnostics.warnUnknownEvent(notification, params);
 		}
-	}
-	buildResult(toolTelemetry, options) {
-		this.eventProjection.flushPendingGuardianWarning();
-		return buildCodexAttemptResult({
-			runParams: this.params,
-			turnId: this.turnId,
-			upstreamUserText: this.options.upstreamUserText,
-			completedTurn: this.completedTurn,
-			promptError: this.promptError,
-			promptErrorSource: this.promptErrorSource,
-			synthesizedMissingToolResultError: this.synthesizedMissingToolResultError,
-			recordSynthesizedMissingToolResultError: (error) => {
-				this.synthesizedMissingToolResultError = error;
-				this.promptErrorSource = this.promptErrorSource ?? "prompt";
-			},
-			aborted: this.aborted,
-			tokenUsage: this.tokenUsage,
-			contextTokens: this.contextTokens,
-			contextTokensSource: this.contextTokensSource,
-			completedCompactionCount: this.completedCompactionCount,
-			activeItemCount: this.activeItemIds.size,
-			completedItemCount: this.completedItemIds.size,
-			guardianReviewCount: this.eventProjection.guardianReviewCount,
-			toolTelemetry,
-			yieldDetected: options?.yieldDetected,
-			nativeToolLifecycleProjection: this.nativeToolLifecycleProjector,
-			assistantProjection: this.assistantProjection,
-			reasoningProjection: this.reasoningProjection,
-			responseCompletions: this.responseCompletions,
-			toolTranscriptProjection: this.toolTranscriptProjection,
-			toolProgressProjection: this.toolProgressProjection,
-			generatedMediaProjection: this.generatedMediaProjection
-		});
+		if (!this.projectionClosed && [
+			"item/started",
+			"item/completed",
+			"rawResponseItem/completed"
+		].includes(notification.method)) await this.settlement.project("transcript/checkpoint", () => this.transcriptCheckpoint.flush());
 	}
 	recordDynamicToolCall(params) {
 		this.toolTranscriptProjection.recordDynamicToolCall(params);
 	}
 	/** Projects a successful OpenClaw progress_card call through the native plan stream. */
 	async recordDynamicProgressCardUpdate(params) {
-		if (isJsonObject(params)) {
-			const projected = { plan: Array.isArray(params.plan) ? params.plan : [] };
+		const update = projectProgressCardChannelUpdate(params);
+		if (update) {
+			const projected = {
+				plan: update.steps,
+				...update.explanation ? { explanation: update.explanation } : {}
+			};
 			await this.reasoningProjection.handleTurnPlanUpdated(projected, "openclaw");
 		}
 	}
@@ -1616,16 +1806,19 @@ var CodexAppServerEventProjector = class {
 	}
 	markTimedOut() {
 		this.aborted = true;
-		this.promptError = "codex app-server attempt timed out";
-		this.promptErrorSource = "prompt";
+		this.terminalFailure.promptError = "codex app-server attempt timed out";
+		this.terminalFailure.promptErrorSource = "prompt";
 	}
 	markAborted() {
 		this.aborted = true;
-		this.responseCompletions.clear();
+		this.usageProjection.invalidateContext();
 	}
 	isCompacting() {
 		return this.activeCompactionItemIds.size > 0;
 	}
+	isCompactionProjectionActive() {
+		return !this.projectionClosed && !this.aborted && !this.options.runAbortSignal?.aborted;
+	}
 	async handleItemStarted(params) {
 		const item = readItem(params.item);
 		const itemId = item?.id ?? readStringField(params, "itemId");
@@ -1633,12 +1826,16 @@ var CodexAppServerEventProjector = class {
 		if (itemId) this.activeItemIds.add(itemId);
 		this.recordNativeToolOutcome(item);
 		if (item?.type === "contextCompaction" && itemId) {
+			if (!this.isCompactionProjectionActive()) return;
 			this.activeCompactionItemIds.add(itemId);
+			const messages = await this.toolTranscriptProjection.readMirroredSessionMessages(this.options.runAbortSignal);
+			if (!this.isCompactionProjectionActive()) return;
 			await runAgentHarnessBeforeCompactionHook({
 				sessionFile: this.params.sessionFile,
-				messages: await this.toolTranscriptProjection.readMirroredSessionMessages(),
+				messages,
 				ctx: this.options.agentHookContext ?? {}
 			});
+			if (!this.isCompactionProjectionActive()) return;
 			this.emitAgentEvent({
 				stream: "compaction",
 				data: {
@@ -1675,7 +1872,7 @@ var CodexAppServerEventProjector = class {
 		const item = readItem(params.item);
 		this.diagnostics.warnUnknownItemStatus(item);
 		this.recordNativeToolOutcome(item);
-		this.clearTerminalPresentationForNativeItem(item);
+		this.nativeToolLifecycleProjector.clearTerminalPresentationForNativeItem(item);
 		const itemId = item?.id ?? readStringField(params, "itemId");
 		if (itemId) {
 			this.activeItemIds.delete(itemId);
@@ -1686,20 +1883,23 @@ var CodexAppServerEventProjector = class {
 		if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 		if (this.projectionClosed) return;
 		this.reasoningProjection.recordItem(item);
-		await this.generatedMediaProjection.recordNative(item);
+		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
 		if (this.projectionClosed) return;
 		if (item?.type === "contextCompaction" && itemId) {
+			if (!this.isCompactionProjectionActive()) return;
 			this.activeCompactionItemIds.delete(itemId);
 			this.completedCompactionCount += 1;
 			await this.options.onContextCompacted?.();
-			if (this.projectionClosed) return;
+			if (!this.isCompactionProjectionActive()) return;
+			const messages = await this.toolTranscriptProjection.readMirroredSessionMessages(this.options.runAbortSignal);
+			if (!this.isCompactionProjectionActive()) return;
 			await runAgentHarnessAfterCompactionHook({
 				sessionFile: this.params.sessionFile,
-				messages: await this.toolTranscriptProjection.readMirroredSessionMessages(),
+				messages,
 				compactedCount: -1,
 				ctx: this.options.agentHookContext ?? {}
 			});
-			if (this.projectionClosed) return;
+			if (!this.isCompactionProjectionActive()) return;
 			await persistCodexContextCompactionActivity({
 				sessionTarget: this.params.sessionTarget,
 				config: this.params.config,
@@ -1710,6 +1910,7 @@ var CodexAppServerEventProjector = class {
 				itemId,
 				timestamp: this.transcriptCheckpoint.nextTimestamp()
 			});
+			if (!this.isCompactionProjectionActive()) return;
 			this.eventProjection.emitCompactionEnd(itemId, true);
 		}
 		this.toolProgressProjection.recordToolMeta(item);
@@ -1724,8 +1925,9 @@ var CodexAppServerEventProjector = class {
 		});
 		if (this.projectionClosed) return;
 		this.toolTranscriptProjection.recordNativeToolCall(item);
-		await this.toolTranscriptProjection.recordNativeToolResultWithDetails(item);
+		const details = await this.toolTranscriptProjection.prepareNativeToolResultDetails(item);
 		if (this.projectionClosed) return;
+		this.toolTranscriptProjection.recordNativeToolResult(item, details);
 		this.toolProgressProjection.emitToolResultSummary(item);
 		this.toolProgressProjection.emitToolResultOutput(item);
 		this.emitAgentEvent({
@@ -1741,16 +1943,18 @@ var CodexAppServerEventProjector = class {
 		const turn = readCodexTurn(params.turn);
 		if (!turn || turn.id !== this.turnId) return;
 		this.completedTurn = turn;
-		const compactionFailure = turn.status === "failed" && (this.promptErrorSource === "compaction" || turn.error?.codexErrorInfo === "other" && this.isCompacting());
+		const compactionFailure = turn.status === "failed" && (this.terminalFailure.promptErrorSource === "compaction" || turn.error?.codexErrorInfo === "other" && this.isCompacting());
 		this.settledTurnFailureFinalizationAllowed = turn.status === "failed" && (turn.error?.codexErrorInfo === "serverOverloaded" || compactionFailure);
-		if (turn.status !== "completed") this.responseCompletions.clear();
+		if (turn.status !== "completed") this.usageProjection.invalidateContext();
 		if (turn.status === "failed") {
-			this.promptError = resolveCodexPromptError({
+			const codexErrorInfo = turn.error?.codexErrorInfo;
+			this.terminalFailure.record({
 				message: turn.error?.message,
-				codexErrorInfo: turn.error?.codexErrorInfo,
-				rateLimits: this.options.readRecentRateLimits?.()
-			}) ?? "codex app-server turn failed";
-			this.promptErrorSource = compactionFailure ? "compaction" : "prompt";
+				codexErrorInfo,
+				rateLimits: this.options.readRecentRateLimits?.(),
+				fallbackMessage: "codex app-server turn failed",
+				promptErrorSource: compactionFailure ? "compaction" : "prompt"
+			});
 		}
 		if (compactionFailure) {
 			const failedCompactionItemIds = [...this.activeCompactionItemIds];
@@ -1763,7 +1967,7 @@ var CodexAppServerEventProjector = class {
 		const turnItems = turn.items ?? [];
 		const unsettledAsyncDeliveries = this.asyncDeliveryProjection.pending();
 		const lastToolItem = turnItems.findLast((item) => matchesCodexSnapshotTurn(item, this.turnId) && (item.type === "dynamicToolCall" || shouldClearTerminalPresentationForNativeItem(item)));
-		if (lastToolItem?.type !== "dynamicToolCall") this.clearTerminalPresentationForNativeItem(lastToolItem);
+		if (lastToolItem?.type !== "dynamicToolCall") this.nativeToolLifecycleProjector.clearTerminalPresentationForNativeItem(lastToolItem);
 		for (const item of turnItems) {
 			if (!this.asyncDeliveryProjection.allows(item)) continue;
 			this.diagnostics.warnUnknownItemStatus(item);
@@ -1771,15 +1975,21 @@ var CodexAppServerEventProjector = class {
 			if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 			if (this.projectionClosed) return;
 			this.reasoningProjection.recordItem(item);
-			await this.generatedMediaProjection.recordNative(item);
+			await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
 			if (this.projectionClosed) return;
 			this.toolProgressProjection.recordToolMeta(item);
 			this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
-			await this.emitSnapshotOnlyNativeToolProgress(item);
+			await this.eventProjection.emitSnapshotOnlyNativeToolProgress({
+				item,
+				activeItemIds: this.activeItemIds,
+				completedItemIds: this.completedItemIds,
+				isActive: () => !this.projectionClosed
+			});
 			if (this.projectionClosed) return;
 			this.toolTranscriptProjection.recordNativeToolCall(item);
-			await this.toolTranscriptProjection.recordNativeToolResultWithDetails(item);
+			const details = await this.toolTranscriptProjection.prepareNativeToolResultDetails(item);
 			if (this.projectionClosed) return;
+			this.toolTranscriptProjection.recordNativeToolResult(item, details);
 			this.toolTranscriptProjection.emitAfterToolCallObservation(item);
 			this.toolProgressProjection.emitToolResultSummary(item);
 			this.toolProgressProjection.emitToolResultOutput(item);
@@ -1794,52 +2004,12 @@ var CodexAppServerEventProjector = class {
 		this.activeCompactionItemIds.clear();
 		await this.reasoningProjection.maybeEndReasoning();
 	}
-	async emitSnapshotOnlyNativeToolProgress(item) {
-		if (!shouldSynthesizeToolProgressForItem(item) || !matchesCodexSnapshotTurn(item, this.turnId) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
-		if (!this.activeItemIds.has(item.id)) {
-			this.eventProjection.emitStandardItemEvent({
-				phase: "start",
-				item
-			});
-			await this.eventProjection.emitNormalizedToolItemEvent({
-				phase: "start",
-				item
-			});
-		}
-		if (this.projectionClosed) return;
-		this.activeItemIds.delete(item.id);
-		this.eventProjection.emitStandardItemEvent({
-			phase: "end",
-			item
-		});
-		await this.eventProjection.emitNormalizedToolItemEvent({
-			phase: "result",
-			item
-		});
-		this.completedItemIds.add(item.id);
-	}
 	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
 		this.toolTranscriptProjection.recordRawNativeToolItem(item);
 		this.assistantProjection.handleRawResponseItemCompleted(item, this.activeItemIds);
-		await this.generatedMediaProjection.recordRaw(item);
-	}
-	clearTerminalPresentationForNativeItem(item) {
-		if (!item || this.terminalPresentationClearedItemIds.has(item.id) || !shouldClearTerminalPresentationForNativeItem(item)) return;
-		const toolCallOrdinal = this.nativeToolOutcomeOrdinals.get(item.id);
-		this.terminalPresentationClearedItemIds.add(item.id);
-		this.params.onToolOutcome?.({
-			toolName: itemName(item) ?? item.type,
-			argsHash: "",
-			resultHash: "",
-			...toolCallOrdinal !== void 0 ? { toolCallOrdinal } : {},
-			terminalPresentation: void 0,
-			presentationOnly: true
-		});
-	}
-	emitAgentEvent(event) {
-		if (!this.projectionClosed) emitCodexAgentEvent(this.params, event);
+		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordRaw(item));
 	}
 	isHookNotificationForCurrentThread(params) {
 		const threadId = readStringField(params, "threadId");
@@ -1950,6 +2120,7 @@ function createNativeMcpRuntime(params) {
 		listResourceTemplates: async (serverName) => {
 			return { resourceTemplates: (await loadStatuses()).find((entry) => entry.name === serverName)?.resourceTemplates ?? [] };
 		},
+		joinCleanup: async () => {},
 		dispose: async () => {}
 	};
 	return runtime;
@@ -2107,7 +2278,6 @@ const MAX_USER_INPUT_HEADER = 64;
 const MAX_USER_INPUT_TEXT = 4096;
 /** Creates the single per-turn owner for Codex operator input. */
 function createCodexUserInputBridge(params) {
-	const gatewayCall = params.gatewayCall ?? callGatewayTool;
 	const jobs = [];
 	let activeCompletion;
 	const inputSessionKey = params.paramsForRun.sessionKey ?? params.paramsForRun.sessionId;
@@ -2158,7 +2328,7 @@ function createCodexUserInputBridge(params) {
 		agentId: params.paramsForRun.agentId,
 		runId: params.paramsForRun.runId,
 		timeoutMs,
-		gatewayCall,
+		gatewayCall: params.gatewayCall,
 		delivery: params.paramsForRun,
 		signal,
 		promptOptions: {
@@ -2188,9 +2358,9 @@ function createCodexUserInputBridge(params) {
 			});
 		},
 		async handleElicitationRequest(request) {
-			if (readRawOwnString(request.params, "threadId") !== params.threadId) return;
+			if (readOwnDataString(request.params, "threadId") !== params.threadId) return;
 			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params);
-			if (requestSnapshot === void 0) {
+			if (!agentHarnessStructuredInput.isRecord(requestSnapshot)) {
 				const cancelValue = createCodexElicitationResponse("cancel");
 				return await enqueue({
 					requestId: request.id,
@@ -2206,10 +2376,10 @@ function createCodexUserInputBridge(params) {
 					}
 				});
 			}
-			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DMkeki8d.js");
+			if (readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
+			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.js");
 			const compiled = compileCodexOrdinaryElicitation({
-				value: requestSnapshot,
-				threadId: params.threadId,
+				snapshot: requestSnapshot,
 				turnId: params.turnId
 			});
 			if (compiled.kind === "ignored") return;
@@ -2235,7 +2405,7 @@ function createCodexUserInputBridge(params) {
 		handleNotification(notification) {
 			if (notification.method !== "serverRequest/resolved" || !isJsonObject(notification.params)) return;
 			const requestId = readRequestId(notification.params);
-			if (requestId === void 0 || readOwnString(notification.params, "threadId") !== params.threadId) return;
+			if (requestId === void 0 || readOwnDataString(notification.params, "threadId") !== params.threadId) return;
 			const job = jobs.find((candidate) => typeof candidate.requestId === typeof requestId && candidate.requestId === requestId);
 			if (job) cancelJob(job);
 		},
@@ -2314,11 +2484,7 @@ function readArray(record, key, maximum) {
 	const value = readValue(record, key);
 	return Array.isArray(value) && value.length <= maximum ? value : void 0;
 }
-function readOwnString(record, key) {
-	const descriptor = Object.getOwnPropertyDescriptor(record, key);
-	return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
-}
-function readRawOwnString(value, key) {
+function readOwnDataString(value, key) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	const descriptor = Object.getOwnPropertyDescriptor(value, key);
 	return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
@@ -2350,6 +2516,22 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	const { emitExecutionPhaseOnce, emitLifecycleStart, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const { enqueueNotification } = notifications;
 	const activeTurnId = turn.turn.id;
+	const { thread } = resourceState;
+	const runtimeModelSelection = thread.preserveNativeModel && thread.model && thread.modelProvider ? {
+		provider: thread.modelProvider,
+		model: thread.model
+	} : void 0;
+	const projectionParams = runtimeModelSelection ? {
+		...dynamicToolParams,
+		provider: runtimeModelSelection.provider,
+		modelId: runtimeModelSelection.model,
+		model: {
+			...dynamicToolParams.model,
+			id: runtimeModelSelection.model,
+			name: runtimeModelSelection.model,
+			provider: runtimeModelSelection.provider
+		}
+	} : dynamicToolParams;
 	const progressCardTool = toolBridge.availableTools.find((tool) => tool.name === "progress_card");
 	let nativePlanUpdateOrdinal = 0;
 	const prepareNativeMcpAppResultDetails = createCodexNativeMcpAppResultDetailsPreparer({
@@ -2375,7 +2557,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		imagesCount: params.images?.length ?? 0
 	});
 	projectorRef.current = new CodexAppServerEventProjector({
-		...dynamicToolParams,
+		...projectionParams,
 		onAgentEvent: (event) => {
 			if (event.stream === "assistant" && typeof event.data.delta === "string") {
 				streamState.eventEmitted = true;
@@ -2390,7 +2572,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		asyncUserMessageAllowed: params.disableTools !== true && (params.toolsAllow === void 0 || toolBridge.availableTools.some((tool) => tool.name === "message")),
 		onAsyncDelivery: async (delivery) => {
 			return await codexTranscriptMirrorRuntime.deliverAsyncMessageBestEffort({
-				params: dynamicToolParams,
+				params: projectionParams,
 				cwd: effectiveCwd,
 				threadId: resourceState.thread.threadId,
 				turnId: activeTurnId,
@@ -2447,6 +2629,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		}
 	});
 	if (isTerminalTurnStatus(turn.turn.status)) {
+		projectorRef.current.settlement.terminalReceipt = turn.turn;
 		state.terminalTurnNotificationQueued = true;
 		deadlines.beginSettlement(Date.now());
 	}
@@ -2510,7 +2693,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		}
 	};
 	const assertSteeringActive = () => {
-		params.hostCapabilities.assertActive();
+		connection.assertCurrent();
 		runAbortController.signal.throwIfAborted();
 		if (state.completed || state.terminalTurnNotificationQueued) throw new Error("codex app-server turn is no longer accepting steering");
 	};
@@ -2548,13 +2731,15 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			if (result.failedMediaCount) throw new Error(`failed to hydrate ${result.failedMediaCount} structured image attachment(s) for Codex steering`);
 			return buildCodexUserInput(text, result.images);
 		},
-		beforeConfirmConsumed: async (items) => {
+		beforeSubmit: async (items) => {
 			const transcriptItems = items.filter((item) => item.isInboundUserMessage === true || item.userTurnTranscriptRecorder !== void 0);
 			if (transcriptItems.length === 0) return;
 			await promptMirrorPromise;
+			assertSteeringActive();
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
 			if (params.sessionTarget && messages.length > 0) {
 				await codexTranscriptMirrorRuntime.mirror({
+					assertCurrent: assertSteeringActive,
 					agentId: sessionAgentId,
 					sessionKey: contextSessionKey,
 					sessionId: params.sessionId,
@@ -2566,47 +2751,66 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 					runMirrorIdentityPrefix: `${activeTurnId}:`,
 					config: params.config
 				});
+				assertSteeringActive();
 				activeProjector.markSteeringTranscriptPersisted();
 			}
 			for (const item of transcriptItems) {
 				const recorder = item.userTurnTranscriptRecorder;
 				if (!recorder) continue;
+				assertSteeringActive();
 				await recorder.persistApproved();
-				if (!recorder.hasPersisted()) throw new Error("Codex consumed steering before its user turn was persisted");
+				if (!recorder.hasPersisted()) throw new Error("Codex steering requires a persisted user turn before submission");
 			}
 		}
 	});
 	steeringQueueRef.current = activeSteeringQueue;
-	const claimPendingUserInputAnswer = async (text, optionsLocal) => {
+	const injectionGuard = (assertCurrent) => () => {
+		assertCurrent?.();
+		assertSteeringActive();
+		return true;
+	};
+	const claimPendingUserInputAnswer = async (text, optionsLocal, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run") => {
 		if (optionsLocal?.isInboundUserMessage !== true || hasPromptImageInput(optionsLocal)) return false;
 		assertSteeringActive();
 		return await claimPendingAgentQuestionAnswer({
 			sessionKey: params.sessionKey ?? params.sessionId,
 			text,
+			authority: {
+				kind: authorityKind,
+				assertCurrent: injectionGuard(assertCurrent)
+			},
+			sourceRecorder: optionsLocal.userTurnTranscriptRecorder,
 			persist: optionsLocal.userTurnTranscriptRecorder ? async () => {
 				await optionsLocal.userTurnTranscriptRecorder?.persistApproved();
 			} : void 0
 		});
 	};
-	const cancelPendingUserInput = (resolvedBy) => cancelPendingAgentQuestionForSession({
+	const cancelPendingUserInput = (resolvedBy, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run") => cancelPendingAgentQuestionForSession({
 		sessionKey: params.sessionKey ?? params.sessionId,
-		resolvedBy
+		resolvedBy,
+		authority: {
+			kind: authorityKind,
+			assertCurrent: injectionGuard(assertCurrent)
+		}
 	});
-	const queueMessage = async (text, optionsLocal) => {
-		if (await claimPendingUserInputAnswer(text, optionsLocal)) {
+	const queueMessage = async (text, optionsLocal, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run") => {
+		const canClaim = injectionGuard(assertCurrent);
+		if (await claimPendingUserInputAnswer(text, optionsLocal, assertCurrent, authorityKind)) {
 			optionsLocal?.onQueueAccepted?.(true);
 			return;
 		}
 		if (optionsLocal?.isInboundUserMessage === true && hasPromptImageInput(optionsLocal)) {
 			assertSteeringActive();
 			try {
-				await cancelPendingUserInput("image-reply");
+				await cancelPendingUserInput("image-reply", assertCurrent, authorityKind);
 			} catch (error) {
+				canClaim();
+				if (error instanceof Error && error.name === "QuestionDispatchRefusedError") throw error;
 				embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
 			}
 		}
 		try {
-			await activeSteeringQueue.queue(text, optionsLocal);
+			await activeSteeringQueue.queue(text, optionsLocal, injectionGuard(assertCurrent));
 		} catch (error) {
 			if (error instanceof CodexSteeringAcceptedUnconfirmedError) return {
 				transcriptCommit: "unconfirmed",
@@ -2615,6 +2819,13 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			throw error;
 		}
 	};
+	const messageInjection = {
+		version: 2,
+		isAvailable: () => !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted,
+		queueMessage,
+		claimPendingUserInputAnswer,
+		cancelPendingUserInput
+	};
 	const handle = {
 		kind: "embedded",
 		runId: params.runId,
@@ -2632,10 +2843,8 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		claimPendingUserInputAnswer,
 		cancelPendingUserInput,
 		queueMessage,
-		messageInjection: {
-			isAvailable: () => !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted,
-			queueMessage
-		},
+		messageInjection,
+		messageInjectionV2: messageInjection,
 		isStreaming: () => !state.completed && !runAbortController.signal.aborted,
 		isAborted: () => runAbortController.signal.aborted,
 		isStopped: () => state.completed || runAbortController.signal.aborted,
@@ -2650,7 +2859,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		abort: () => abortExplicitly("aborted")
 	};
 	params.replyOperation?.attachBackend(handle);
-	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile);
+	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
 	const freezeRunTerminalOutcome = () => {
 		if (terminalState.terminalOutcomeFrozen) return;
 		terminalState.terminalOutcomeFrozen = true;
@@ -2663,6 +2872,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	return {
 		activeTurnId,
 		activeProjector,
+		runtimeModelSelection,
 		streamState,
 		handle,
 		freezeRunTerminalOutcome,
@@ -2686,7 +2896,9 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	const projectionClose = state.projectionClosed ? void 0 : activeTurn.activeProjector.closeProjection();
 	state.projectionClosed = true;
 	const checkpointCleanup = projectionClose ? runCleanupStep("codex-transcript-checkpoint", () => projectionClose) : void 0;
-	await state.abortCleanup.catch(() => void 0);
+	if (params.oneShotCliRun) await runCleanupStep("codex-abort-cleanup", () => state.abortCleanup);
+	else await state.abortCleanup?.catch(() => {});
+	if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-terminals", () => terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId, true));
 	try {
 		steeringQueueRef.current?.cancel();
 		if (params.isFinalFallbackAttempt !== false) await maybeEmitFastModeAutoResetBestEffort();
@@ -2707,9 +2919,9 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			aborted: runAbortController.signal.aborted && !state.clientClosedAbort
 		});
 		await runCleanupStep("codex-trajectory-flush", () => trajectoryRecorder?.flush());
-		const retainLiveIncognitoThread = (terminalState.turnSucceeded || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
-		const retainLiveThread = ((retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.turnSucceeded && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint) && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) ? (await bindingStore.read(bindingIdentity))?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
-			if ((await bindingStore.read(bindingIdentity))?.threadId !== resourceState.thread.threadId) return false;
+		const retainLiveIncognitoThread = (terminalState.settledTurnStatus === "completed" || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
+		const retainLiveThread = ((retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.settledTurnStatus !== void 0 && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint) && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) ? bindingStore.read(bindingIdentity)?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
+			if (bindingStore.read(bindingIdentity)?.threadId !== resourceState.thread.threadId) return false;
 			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
 				release: resourceState.thread.liveThreadOwnership?.release,
 				configFingerprint: resourceState.thread.liveThreadConfigFingerprint,
@@ -2726,16 +2938,22 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
 					threadId: resourceState.thread.threadId,
 					timeoutMs: 5e3
-				})) await closeCodexStartupClientBestEffort(resourceState.client);
+				})) {
+					await closeCodexStartupClientBestEffort(resourceState.client);
+					if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-unsubscribe", async () => {
+						throw new Error("Codex one-shot thread unsubscribe was not confirmed");
+					});
+				}
 			}
 		}
 	} finally {
 		await runCleanupStep("codex-user-input-cancel", () => userInputBridgeRef.current?.cancelPending());
 		await runCleanupStep("codex-turn-deadline-clear", () => deadlines.dispose());
 		await runCleanupStep("codex-dynamic-tool-cleanup", async () => {
-			const cleanupReason = terminalState.turnSucceeded ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
+			const cleanupReason = terminalState.settledTurnStatus === "completed" ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
 			const cleanups = prompt.context.attemptTools.runCleanups.splice(0);
-			await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)));
+			const errors = (await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)))).filter((result) => result.status === "rejected");
+			if (params.oneShotCliRun && errors.length) throw new AggregateError(errors.map((result) => result.reason), "Codex tool cleanup failed");
 		});
 		await runCleanupStep("codex-route-release", releaseCurrentRoute);
 		await checkpointCleanup;
@@ -2744,15 +2962,13 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		resourceState.nativeHookRelay = void 0;
 		await runCleanupStep("codex-native-hook-relay-release", () => {
 			if (!nativeHookRelay) return;
-			if (state.shouldDelayNativeHookRelayUnregister) scheduleCodexNativeHookRelayUnregister({
+			if (state.shouldDelayNativeHookRelayUnregister && !params.oneShotCliRun) scheduleCodexNativeHookRelayUnregister({
 				relay: nativeHookRelay,
 				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
 			});
 			else nativeHookRelay.unregister();
 		});
 		await runCleanupStep("codex-sandbox-release", releaseSandboxExecEnvironment);
-		await runCleanupStep("codex-scoped-mcp-dispose", () => prompt.context.attemptTools.scopedMcpTools?.dispose());
-		await runCleanupStep("codex-configured-mcp-dispose", () => prompt.context.attemptTools.configuredMcp?.dispose());
 		await runCleanupStep("codex-abort-listener-remove", () => {
 			runAbortController.signal.removeEventListener("abort", abortListener);
 		});
@@ -2995,8 +3211,9 @@ async function readCodexAppServerRolloutTokenSnapshot(file, openedHandle) {
 				bytesRead += result.bytesRead;
 			}
 			let lineEnd = bytesRead;
-			for (let index = bytesRead - 1; index >= 0; index -= 1) {
-				if (chunk[index] !== 10) continue;
+			while (lineEnd > 0) {
+				const index = chunk.lastIndexOf(10, lineEnd - 1);
+				if (index < 0) break;
 				const lineFragment = chunk.subarray(index + 1, lineEnd);
 				const line = partialLineFragments.length === 0 ? lineFragment.toString("utf8") : Buffer.concat([lineFragment, ...partialLineFragments.toReversed()]).toString("utf8");
 				partialLineFragments.length = 0;
@@ -3078,6 +3295,7 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 			await Promise.all(rolloutFiles.map(async (file) => {
 				await file.handle?.close();
 			}));
+			assertCodexBindingMayBeReplaced(binding, "rotating an oversized native transcript", params.expectedSessionRuntimeOwnership);
 			embeddedAgentLog.warn("codex app-server native transcript exceeded active byte limit; starting a fresh thread", {
 				threadId: binding.threadId,
 				maxBytes,
@@ -3089,7 +3307,7 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 			await params.bindingStore.mutate(params.identity, {
 				kind: "clear",
 				threadId: binding.threadId
-			});
+			}, params.assertCurrent);
 			return { binding: void 0 };
 		}
 	}
@@ -3106,6 +3324,7 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const sessionTokens = sessionRecord?.totalTokensFresh === true && sessionRecord.totalTokensVersion === 1 && typeof sessionRecord?.totalTokens === "number" && Number.isFinite(sessionRecord.totalTokens) ? sessionRecord.totalTokens : void 0;
 	const tokenCount = maxFiniteNumber([sessionTokens, nativeTokens]);
 	if (tokenCount !== void 0 && tokenCount >= maxTokens) {
+		assertCodexBindingMayBeReplaced(binding, "rotating a full native context", params.expectedSessionRuntimeOwnership);
 		embeddedAgentLog.warn("codex app-server native transcript exceeded active token limit; starting a fresh thread", {
 			threadId: binding.threadId,
 			maxTokens,
@@ -3120,7 +3339,7 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 		await params.bindingStore.mutate(params.identity, {
 			kind: "clear",
 			threadId: binding.threadId
-		});
+		}, params.assertCurrent);
 		return { binding: void 0 };
 	}
 	const startupContextTokens = nativeModelContextWindow ?? sessionModelContextWindow;
@@ -3142,7 +3361,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		offAnnounced: false,
 		resetAnnounced: false
 	};
-	const preDynamicStartupStages = createCodexDynamicToolBuildStageTracker({ enabled: profilerEnabled });
+	const preDynamicStartupStages = createCodexDynamicToolBuildStageTracker();
 	const runtimeArtifactRequest = params.captureRuntimeArtifact || params.expectedRuntimeArtifact ? params.expectedRuntimeArtifact ? { expected: params.expectedRuntimeArtifact } : {} : void 0;
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const requirementsToml = readCodexRequirementsToml({});
@@ -3178,7 +3397,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
 	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
 	const assertLocalTargetSupported = (unsupported) => {
-		if (preparedEnvironment?.localProcessEnv && unsupported) throw new Error("This runtime cannot target the diagnosed local installation. Use the saved prompt with a suggested external or manual handoff on this machine.");
+		if (preparedEnvironment?.localProcessEnv && unsupported) throw new Error("This runtime cannot target the diagnosed local installation. Use an owned local Codex stdio process, or use the saved prompt with a suggested external or manual handoff on this machine.");
 	};
 	assertLocalTargetSupported(sandbox?.enabled === true || remoteExec);
 	const preparedShellEnvironment = preparedEnvironment ? {
@@ -3189,7 +3408,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const shellEnvironment = preparedShellEnvironment && Object.keys(preparedShellEnvironment).length > 0 ? preparedShellEnvironment : void 0;
 	const disableLoginShell = remoteExec || preparedEnvironment?.localProcessEnv !== void 0 || preparedEnvironment?.managedLocalIdentity === true || preparedEnvironment !== void 0 && Object.keys(preparedEnvironment.credentialScrubEnv).length > 0;
 	const withPreparedProcessEnv = (appServer) => {
-		assertLocalTargetSupported(appServer.start.transport === "websocket" || Boolean(appServer.remoteWorkspaceRoot));
+		assertLocalTargetSupported(appServer.start.transport !== "stdio" || Boolean(appServer.remoteWorkspaceRoot));
 		return shellEnvironment ? {
 			...appServer,
 			start: {
@@ -3233,16 +3452,17 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			bindingIdentity = physicalIdentity;
 		}
 	}
-	let startupBinding = await bindingStore.read(bindingIdentity);
-	if (!startupBinding && bindingIdentity.kind === "session" && bindingIdentity.sessionKey) {
-		if (!await reclaimCurrentCodexSessionGeneration({
-			bindingStore,
-			identity: bindingIdentity,
-			config: params.config,
-			storePath: params.sessionTarget?.storePath
-		})) throw createCodexSessionGenerationSupersededError(bindingIdentity.sessionId);
-		startupBinding = await bindingStore.read(bindingIdentity);
-	}
+	const { binding: admittedBinding, assertCurrent } = await resolveCodexSessionBinding({
+		reclaimStale: true,
+		bindingStore,
+		identity: bindingIdentity,
+		config: params.config,
+		storePath: params.sessionTarget?.storePath,
+		assertCurrent: params.hostCapabilities.assertActive,
+		signal: params.abortSignal,
+		assertBinding: params.expectedSessionRuntimeOwnership ? (binding) => assertCodexSessionRuntimeOwnership(binding, params.expectedSessionRuntimeOwnership) : void 0
+	});
+	let startupBinding = admittedBinding;
 	preDynamicStartupStages.mark("read-binding");
 	const usesSupervisionConnection = startupBinding?.connectionScope === "supervision";
 	if (usesSupervisionConnection) activeContextEngine = void 0;
@@ -3365,7 +3585,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	preDynamicStartupStages.mark("app-server-policy");
 	preDynamicStartupStages.mark("native-hook-relay");
 	const terminalState = {
-		turnSucceeded: false,
+		settledTurnStatus: void 0,
 		explicitCancellationObserved: false,
 		explicitCancellationReason: void 0,
 		terminalOutcomeFrozen: false,
@@ -3393,104 +3613,113 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	};
 	if (params.abortSignal?.aborted) abortFromUpstream();
 	else params.abortSignal?.addEventListener("abort", abortFromUpstream, { once: true });
-	const startupBindingBeforeRotation = startupBinding;
-	const startupBindingResolution = await rotateOversizedCodexAppServerStartupBinding({
-		binding: startupBinding,
-		bindingStore,
-		identity: bindingIdentity,
-		sessionFile: params.sessionFile,
-		agentDir,
-		codexHome: appServer.start.env?.CODEX_HOME,
-		config: params.config,
-		contextEngineActive: Boolean(activeContextEngine)
-	});
-	startupBinding = startupBindingResolution.binding;
-	const initialInactiveThreadBootstrapBindingForcedFreshStart = initialStartupBindingHadInactiveThreadBootstrap && !startupBinding?.threadId;
-	preDynamicStartupStages.mark("rotate-binding");
-	if (startupBinding !== startupBindingBeforeRotation) {
-		reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
-		configuredAppServer = resolveRuntimeOptionsForBinding(startupBinding, {
-			modelProvider: reviewerPolicyContext.modelProvider,
-			model: reviewerPolicyContext.model
+	try {
+		const startupBindingBeforeRotation = startupBinding;
+		const startupBindingResolution = await rotateOversizedCodexAppServerStartupBinding({
+			assertCurrent,
+			binding: startupBinding,
+			bindingStore,
+			identity: bindingIdentity,
+			sessionFile: params.sessionFile,
+			agentDir,
+			codexHome: appServer.start.env?.CODEX_HOME,
+			config: params.config,
+			contextEngineActive: Boolean(activeContextEngine),
+			expectedSessionRuntimeOwnership: params.expectedSessionRuntimeOwnership
 		});
-		resolvedAppServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
-		appServer = resolvedAppServer.appServer;
+		startupBinding = startupBindingResolution.binding;
+		const initialInactiveThreadBootstrapBindingForcedFreshStart = initialStartupBindingHadInactiveThreadBootstrap && !startupBinding?.threadId;
+		preDynamicStartupStages.mark("rotate-binding");
+		if (startupBinding !== startupBindingBeforeRotation) {
+			reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
+			configuredAppServer = resolveRuntimeOptionsForBinding(startupBinding, {
+				modelProvider: reviewerPolicyContext.modelProvider,
+				model: reviewerPolicyContext.model
+			});
+			resolvedAppServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
+			appServer = resolvedAppServer.appServer;
+		}
+		const sessionPermissionPolicy = resolveCodexEffectiveSessionPermissionPolicy({
+			appServer,
+			permissionMode: params.permissionMode,
+			sessionRoot: params.sessionRoot,
+			defaultRoot: effectiveWorkspace
+		});
+		if (sessionPermissionPolicy) {
+			params.permissionMode = sessionPermissionPolicy.mode;
+			params.sessionRoot = sessionPermissionPolicy.root;
+			(params.execOverrides ??= {}).mode = sessionPermissionPolicy.execMode;
+		}
+		const nativeHookRelayEvents = resolveCodexNativeHookRelayEvents({
+			configuredEvents: options.nativeHookRelay?.events,
+			appServer
+		});
+		const mutable = {
+			startupBinding,
+			startupContextTokens: startupBindingResolution.startupContextTokens,
+			pluginAppServer: appServer,
+			continuityCalibration: startupBindingBeforeRotation?.continuityCalibration
+		};
+		const resolveRuntimeOptionsForCurrentBinding = (selection) => resolveFinalAppServer(resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection).appServer;
+		assertCurrent();
+		return {
+			params,
+			assertCurrent,
+			options,
+			attemptStartedAt,
+			profilerEnabled,
+			codexModelCallTrace,
+			codexModelContentCapture,
+			codexModelCallId,
+			fastModeAutoStartedAtMs,
+			fastModeAutoProgressState,
+			preDynamicStartupStages,
+			attemptClientFactory,
+			runtimeArtifactRequest,
+			pluginConfig,
+			computerUseConfig,
+			sessionAgentId,
+			policyAgentId,
+			resolvedWorkspace,
+			sandboxSessionKey,
+			contextSessionKey,
+			sandbox,
+			agentDir,
+			shellEnvironment,
+			disableLoginShell,
+			bindingIdentity,
+			bindingStore,
+			activeContextEngine,
+			isInactiveThreadBootstrapBinding,
+			usesSupervisionConnection,
+			startupAuthProfileId,
+			startupAuthRequirement: preparedAuthRoute?.authRequirement,
+			startupPreparedAuth,
+			startupClientAuthProfileId,
+			effectiveWorkspace,
+			effectiveCwd,
+			appServer,
+			sessionPermissionPolicy,
+			nativeHookRelayEvents,
+			runAbortController,
+			terminalState,
+			abortExplicitly,
+			abortFromUpstream,
+			resolveReviewerPolicyContext,
+			resolveRuntimeOptionsForCurrentBinding,
+			mutable,
+			initialStartupBindingHadInactiveThreadBootstrap,
+			initialInactiveThreadBootstrapBindingForcedFreshStart
+		};
+	} catch (error) {
+		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
+		throw error;
 	}
-	const sessionPermissionPolicy = resolveCodexEffectiveSessionPermissionPolicy({
-		appServer,
-		permissionMode: params.permissionMode,
-		sessionRoot: params.sessionRoot,
-		defaultRoot: effectiveWorkspace
-	});
-	if (sessionPermissionPolicy) {
-		params.permissionMode = sessionPermissionPolicy.mode;
-		params.sessionRoot = sessionPermissionPolicy.root;
-		(params.execOverrides ??= {}).mode = sessionPermissionPolicy.execMode;
-	}
-	const nativeHookRelayEvents = resolveCodexNativeHookRelayEvents({
-		configuredEvents: options.nativeHookRelay?.events,
-		appServer
-	});
-	const mutable = {
-		startupBinding,
-		startupContextTokens: startupBindingResolution.startupContextTokens,
-		pluginAppServer: appServer,
-		continuityCalibration: startupBindingBeforeRotation?.continuityCalibration
-	};
-	const resolveRuntimeOptionsForCurrentBinding = (selection) => resolveFinalAppServer(resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection).appServer;
-	return {
-		params,
-		options,
-		attemptStartedAt,
-		profilerEnabled,
-		codexModelCallTrace,
-		codexModelContentCapture,
-		codexModelCallId,
-		fastModeAutoStartedAtMs,
-		fastModeAutoProgressState,
-		preDynamicStartupStages,
-		attemptClientFactory,
-		runtimeArtifactRequest,
-		pluginConfig,
-		computerUseConfig,
-		sessionAgentId,
-		policyAgentId,
-		resolvedWorkspace,
-		sandboxSessionKey,
-		contextSessionKey,
-		sandbox,
-		agentDir,
-		shellEnvironment,
-		disableLoginShell,
-		bindingIdentity,
-		bindingStore,
-		activeContextEngine,
-		isInactiveThreadBootstrapBinding,
-		usesSupervisionConnection,
-		startupAuthProfileId,
-		startupAuthRequirement: preparedAuthRoute?.authRequirement,
-		startupPreparedAuth,
-		startupClientAuthProfileId,
-		effectiveWorkspace,
-		effectiveCwd,
-		appServer,
-		sessionPermissionPolicy,
-		nativeHookRelayEvents,
-		runAbortController,
-		terminalState,
-		abortExplicitly,
-		abortFromUpstream,
-		resolveReviewerPolicyContext,
-		resolveRuntimeOptionsForCurrentBinding,
-		mutable,
-		initialStartupBindingHadInactiveThreadBootstrap,
-		initialInactiveThreadBootstrapBindingForcedFreshStart
-	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-state.ts
-async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields) {
-	const currentBinding = await bindingStore.read(identity);
+async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields, expected) {
+	const currentBinding = bindingStore.read(identity);
 	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
 	if (!expectedThreadId) return;
 	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
@@ -3500,8 +3729,8 @@ async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity,
 		});
 		return;
 	}
-	if (currentBinding?.connectionScope === "supervision") {
-		embeddedAgentLog.warn("codex app-server image payload error detected for supervised thread; preserving native binding", fields);
+	if (expected || currentBinding?.connectionScope === "supervision") {
+		embeddedAgentLog.warn("codex app-server image payload error detected for native-owned thread; preserving binding", fields);
 		return;
 	}
 	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
@@ -3510,16 +3739,6 @@ async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity,
 		threadId: expectedThreadId
 	});
 }
-async function markCodexAppServerBindingCoveredThroughTurn(params) {
-	await params.bindingStore.mutate(params.identity, {
-		kind: "patch",
-		threadId: params.threadId,
-		patch: {
-			historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
-			...params.continuityCalibration ? { continuityCalibration: params.continuityCalibration } : {}
-		}
-	});
-}
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
@@ -3556,10 +3775,14 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	};
 	const readFencedHistory = async () => {
 		const transcriptReadFence = params.userTurnTranscriptRecorder?.getAdmissionReceipt();
-		return await readMirroredSessionHistoryMessages({
+		const messages = await readMirroredSessionHistoryMessages({
 			...activeTranscriptTarget,
+			signal: connection.runAbortController.signal,
 			...transcriptReadFence ? { admission: transcriptReadFence } : {}
 		});
+		connection.runAbortController.signal.throwIfAborted();
+		connection.assertCurrent();
+		return messages;
 	};
 	const historyState = { messages: !activeContextEngine && initialStartupBindingHadInactiveThreadBootstrap ? [] : await readFencedHistory() ?? [] };
 	const hadSessionTranscriptState = historyState.messages.length > 0;
@@ -3574,6 +3797,10 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		sessionKey: contextSessionKey,
 		sessionId: params.sessionId,
 		workspaceDir: params.workspaceDir,
+		...!usesSupervisionConnection && connection.mutable.startupBinding?.preserveNativeModel !== true ? {
+			modelProviderId: params.provider,
+			modelId: params.modelId
+		} : {},
 		trigger: params.trigger,
 		...buildAgentHookContextChannelFields({
 			sessionKey: contextSessionKey,
@@ -3633,6 +3860,17 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	});
 	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions ? connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions ?? workspaceBootstrapContext.threadDeveloperInstructions : void 0;
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
+	const watchedSessionsContext = buildCodexWatchedSessionsContext({
+		attempt: runtimeParams,
+		dynamicTools: toolBridge.availableSpecs,
+		sessionKey: contextSessionKey,
+		sandboxed: sandbox?.enabled === true
+	});
+	const buildOpenClawPromptContext = (includeWorkspaceReferences) => buildCodexOpenClawPromptContext({
+		params: runtimeParams,
+		workspacePromptContext: includeWorkspaceReferences ? workspaceBootstrapContext.promptContext : void 0,
+		watchedSessionsContext
+	});
 	return {
 		runtime,
 		attemptTools,
@@ -3645,16 +3883,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		workspaceBootstrapContext,
 		agentWorkspaceDeveloperInstructions,
 		baseDeveloperInstructions,
-		openClawPromptContext: buildCodexOpenClawPromptContext({
-			params: runtimeParams,
-			workspacePromptContext: workspaceBootstrapContext.promptContext,
-			watchedSessionsContext: buildCodexWatchedSessionsContext({
-				attempt: runtimeParams,
-				dynamicTools: toolBridge.availableSpecs,
-				sessionKey: contextSessionKey,
-				sandboxed: sandbox?.enabled === true
-			})
-		}),
+		buildOpenClawPromptContext,
 		skillsCollaborationInstructions: renderCodexSkillsCollaborationInstructions({
 			attempt: runtimeParams,
 			skillsPrompt: params.skillsSnapshot?.prompt
@@ -3901,6 +4130,7 @@ function recordCodexTrajectoryCompletion(recorder, params) {
 		yieldDetected: params.yieldDetected ?? false,
 		aborted: terminal.aborted,
 		promptError: normalizeCodexTrajectoryError(terminal.promptError),
+		...terminal.settlementWarning ? { settlementWarning: terminal.settlementWarning } : {},
 		usage: params.result.attemptUsage,
 		assistantTexts: params.result.assistantTexts,
 		messagesSnapshot: params.result.messagesSnapshot
@@ -3940,265 +4170,395 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
 	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, agentDir, attemptStartedAt, startupAuthProfileId } = connection;
 	const { toolBridge, toolState } = attemptTools;
-	const { state, completion, deadlines } = turnRuntime;
+	const canClearBindingForRecovery = (operation) => {
+		if (params.expectedSessionRuntimeOwnership) {
+			embeddedAgentLog.warn("codex app-server preserved native binding instead of recovery rotation", {
+				threadId: resourceState.thread.threadId,
+				operation
+			});
+			return false;
+		}
+		assertCodexBindingMayBeReplaced(resourceState.thread, operation);
+		return true;
+	};
+	const { state, completion, deadlines, settlementExpired } = turnRuntime;
 	const { emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { drainNotificationQueue } = notifications;
 	const { codexModelCallDiagnostics } = requestRuntime;
-	const { activeTurnId, activeProjector, streamState, freezeRunTerminalOutcome, notifyUserMessagePersisted } = activeTurn;
+	const { activeTurnId, activeProjector, runtimeModelSelection, streamState, freezeRunTerminalOutcome, notifyUserMessagePersisted } = activeTurn;
 	await completion;
-	const abortGraceElapsed = createDeferred();
-	let settlementClosed = false;
-	let abortGraceTimer;
-	const beginAbortGrace = () => {
-		if (settlementClosed) return;
-		abortGraceTimer = setTimeout(() => abortGraceElapsed.resolve(), TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
-		abortGraceTimer.unref?.();
+	const drainGraceElapsed = createDeferred();
+	let settlementPhase = "active";
+	let drainGraceTimer;
+	const beginDrainGrace = () => {
+		if (settlementPhase !== "active" || drainGraceTimer) return;
+		drainGraceTimer = setTimeout(() => {
+			settlementPhase = "expired";
+			drainGraceElapsed.resolve();
+		}, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
+		drainGraceTimer.unref?.();
 	};
 	const abortListener = addAbortListener(runAbortController.signal, () => {
-		state.abortCleanup.then(beginAbortGrace, beginAbortGrace);
+		state.abortCleanup.then(beginDrainGrace, beginDrainGrace);
 	});
 	const closeProjection = () => {
 		state.projectionClosed = true;
 		return activeProjector.closeProjection();
 	};
-	const settlement = drainNotificationQueue().then(closeProjection);
-	try {
-		await Promise.race([settlement, abortGraceElapsed.promise]);
-		if (runAbortController.signal.aborted) await state.abortCleanup;
-	} finally {
-		settlementClosed = true;
+	const closeSettlement = () => {
+		if (settlementPhase === "closed") return;
+		settlementPhase = "closed";
 		abortListener[Symbol.dispose]();
-		clearTimeout(abortGraceTimer);
+		clearTimeout(drainGraceTimer);
 		deadlines.dispose();
-		if (!state.projectionClosed) await resources.runCleanupStep("codex-transcript-checkpoint", closeProjection);
-	}
-	const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected: toolState.yieldDetected });
-	const projectedTerminal = attemptTerminal.project(result.terminal);
-	const effectiveTimedOut = state.timeout !== void 0;
-	const isFinalAborted = () => terminalState.explicitCancellationObserved || !resourceState.executionDisconnectError && (projectedTerminal.aborted || runAbortController.signal.aborted && !state.clientClosedAbort);
-	const clientClosedPromptErrorForFinal = state.clientClosedPromptError;
-	let finalPromptError = resourceState.executionDisconnectError ?? clientClosedPromptErrorForFinal ?? (state.timeout?.kind === "settlement" ? "codex app-server terminal settlement timed out" : state.timeout?.kind === "execution" ? "codex app-server execution budget timed out" : projectedTerminal.promptError);
-	const finalPromptErrorMessage = typeof finalPromptError === "string" ? finalPromptError : finalPromptError instanceof Error ? finalPromptError.message : finalPromptError ? formatErrorMessage(finalPromptError) : void 0;
-	if (isInvalidCodexImagePayloadError(finalPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
-		phase: "turn_completed",
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		error: finalPromptErrorMessage
+	};
+	const settlement = drainNotificationQueue().then(async () => {
+		await closeProjection();
+		await activeProjector.settlement.drain();
+	});
+	const degradedSettlement = settlementExpired.then(() => {
+		beginDrainGrace();
 	});
-	if (resourceState.thread.connectionScope !== "supervision" && shouldUseFreshCodexThreadAfterContextEngineOverflow({
-		error: finalPromptError,
-		contextEngineActive: Boolean(activeContextEngine),
-		thread: resourceState.thread
-	})) {
-		embeddedAgentLog.warn("codex app-server context-engine turn overflowed after resume; clearing thread binding for recovery", {
+	let projectionDrained = false;
+	try {
+		try {
+			projectionDrained = await Promise.race([
+				settlement.then(() => true),
+				drainGraceElapsed.promise.then(() => false),
+				degradedSettlement.then(() => false)
+			]);
+			if (runAbortController.signal.aborted) await state.abortCleanup;
+		} finally {
+			if (!state.projectionClosed) await resources.runCleanupStep("codex-transcript-checkpoint", closeProjection);
+		}
+		const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected: toolState.yieldDetected });
+		const projectedTerminal = attemptTerminal.project(result.terminal);
+		const isFinalAborted = () => terminalState.explicitCancellationObserved || !resourceState.executionDisconnectError && (projectedTerminal.aborted || runAbortController.signal.aborted && !state.clientClosedAbort);
+		const currentPromptError = (fallback) => resourceState.executionDisconnectError ?? state.clientClosedPromptError ?? (state.timeout ? `codex app-server ${state.timeout.kind === "execution" ? "execution budget" : "terminal settlement"} timed out` : fallback);
+		let enrichedPromptError = currentPromptError(projectedTerminal.promptError);
+		const enrichedPromptErrorMessage = typeof enrichedPromptError === "string" ? enrichedPromptError : enrichedPromptError instanceof Error ? enrichedPromptError.message : enrichedPromptError ? formatErrorMessage(enrichedPromptError) : void 0;
+		if (isInvalidCodexImagePayloadError(enrichedPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
+			phase: "turn_completed",
+			threadId: resourceState.thread.threadId,
+			turnId: activeTurnId,
+			error: enrichedPromptErrorMessage
+		}, params.expectedSessionRuntimeOwnership);
+		if (resourceState.thread.connectionScope !== "supervision" && shouldUseFreshCodexThreadAfterContextEngineOverflow({
+			error: enrichedPromptError,
+			contextEngineActive: Boolean(activeContextEngine),
+			thread: resourceState.thread
+		}) && canClearBindingForRecovery("clearing a native context after overflow")) {
+			embeddedAgentLog.warn("codex app-server context-engine turn overflowed after resume; clearing thread binding for recovery", {
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				error: enrichedPromptErrorMessage
+			});
+			await bindingStore.mutate(bindingIdentity, {
+				kind: "clear",
+				threadId: resourceState.thread.threadId
+			});
+		}
+		const refreshedUsageLimitPromptError = await refreshCodexUsageLimitPromptError({
+			client: resourceState.client,
+			message: enrichedPromptErrorMessage,
+			timeoutMs: appServer.requestTimeoutMs,
+			signal: runAbortController.signal
+		});
+		if (refreshedUsageLimitPromptError) {
+			await markCodexAuthProfileBlockedFromRateLimits({
+				params,
+				authProfileId: startupAuthProfileId,
+				rateLimits: refreshedUsageLimitPromptError.rateLimitsForProfile
+			});
+			enrichedPromptError = new CodexUsageLimitPromptError(refreshedUsageLimitPromptError.message);
+		} else if (enrichedPromptError instanceof CodexUsageLimitPromptError && state.rateLimitsRevisionBeforeLastTurnStart !== void 0 && readCodexRateLimitsRevision(resourceState.client) > state.rateLimitsRevisionBeforeLastTurnStart) await markCodexAuthProfileBlockedFromRateLimits({
+			params,
+			authProfileId: startupAuthProfileId,
+			rateLimits: readRecentCodexRateLimits(resourceState.client)
+		});
+		const projectTerminalOutcome = () => {
+			const effectiveTimedOut = state.timeout !== void 0;
+			const clientClosedPromptErrorForFinal = state.clientClosedPromptError;
+			const finalPromptError = currentPromptError(enrichedPromptError);
+			const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : projectedTerminal.promptErrorSource;
+			const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : state.timeout?.kind === "settlement" ? "turn_settlement_timeout" : void 0;
+			const replayBlockedReason = codexAppServerFailureKind ? resolveCodexAppServerReplayBlockedReason(result) : void 0;
+			const promptTimeoutOutcome = buildCodexAppServerPromptTimeoutOutcome(state.timeout);
+			const failureDiagnostics = codexAppServerFailureKind === "client_closed_before_turn_completed" && state.clientClosedDiagnostic ? { transportError: state.clientClosedDiagnostic } : state.timeout?.kind === "settlement" ? { timeoutMs: state.timeout.timeoutMs } : void 0;
+			const codexAppServerFailure = codexAppServerFailureKind ? {
+				kind: codexAppServerFailureKind,
+				transport: appServer.start.transport,
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				replaySafe: codexAppServerFailureKind === "client_closed_before_turn_completed" && replayBlockedReason === void 0,
+				...replayBlockedReason ? { replayBlockedReason } : {},
+				...failureDiagnostics ? { diagnostics: failureDiagnostics } : {}
+			} : void 0;
+			const finalAborted = isFinalAborted();
+			if (finalAborted && result.attemptUsage) result.attemptUsage = {
+				...result.attemptUsage,
+				contextUsage: { state: "unavailable" }
+			};
+			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;
+			const attemptSucceeded = turnSucceeded && result.agentHarnessResultClassification === void 0;
+			result.terminal = attemptTerminal.normalize({
+				settlementWarning: state.settlementWarning,
+				timedOut: effectiveTimedOut,
+				aborted: finalAborted,
+				promptError: finalPromptError,
+				promptErrorSource: finalPromptErrorSource
+			});
+			for (const message of [
+				result.lastAssistant,
+				result.currentAttemptAssistant,
+				result.messagesSnapshot.find((candidate) => readMirrorIdentity(candidate) === `${activeTurnId}:assistant`)
+			]) if (message?.role === "assistant") {
+				if (!message.diagnostics?.some((diagnostic) => diagnostic.type === "provider_refusal") || finalAborted || finalPromptError) {
+					message.stopReason = finalAborted ? "aborted" : finalPromptError ? "error" : "stop";
+					message.errorMessage = finalPromptError ? formatErrorMessage(finalPromptError) : void 0;
+				}
+			}
+			return {
+				effectiveTimedOut,
+				finalPromptError,
+				codexAppServerFailure,
+				promptTimeoutOutcome,
+				finalAborted,
+				turnSucceeded,
+				attemptSucceeded,
+				completedTurnStatus
+			};
+		};
+		projectTerminalOutcome();
+		const unavailableMirror = {
+			assistantTranscriptOwned: false,
+			mirroredMessages: []
+		};
+		let mirrorOutcome = unavailableMirror;
+		const mirrorFinal = () => {
+			const warning = state.settlementWarning;
+			const mirrorTerminal = projectTerminalOutcome();
+			state.pendingSettlementStage = "transcript/mirror";
+			return codexTranscriptMirrorRuntime.mirrorBestEffort({
+				assertWriteCurrent: () => {
+					if (settlementPhase !== "active" || 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");
+				},
+				params,
+				settlementWarning: warning,
+				agentId: sessionAgentId,
+				notifyUserMessagePersisted,
+				result,
+				sessionKey: contextSessionKey,
+				cwd: effectiveCwd,
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId
+			});
+		};
+		try {
+			if (projectionDrained && settlementPhase === "active" && !state.settlementWarning) mirrorOutcome = await Promise.race([
+				mirrorFinal(),
+				drainGraceElapsed.promise.then(() => unavailableMirror),
+				degradedSettlement.then(() => unavailableMirror)
+			]);
+			if (state.settlementWarning && !runAbortController.signal.aborted) {
+				mirrorOutcome = await Promise.race([mirrorFinal(), drainGraceElapsed.promise.then(() => unavailableMirror)]);
+				if (mirrorOutcome === unavailableMirror) trajectoryRecorder?.recordEvent("turn.settlement_persistence_unavailable", {
+					pendingStage: "transcript/mirror",
+					threadId: resourceState.thread.threadId,
+					turnId: activeTurnId
+				});
+			}
+			if (toolState.yieldMessage && projectTerminalOutcome().turnSucceeded) {
+				state.pendingSettlementStage = "transcript/yield-context";
+				await Promise.race([
+					appendSessionYieldContext({
+						...activeTranscriptTarget.sessionTarget,
+						agentId: activeTranscriptTarget.agentId,
+						sessionId: activeTranscriptTarget.sessionId,
+						sessionKey: activeTranscriptTarget.sessionKey,
+						config: params.config,
+						message: toolState.yieldMessage,
+						assertCurrent: () => {
+							connection.assertCurrent();
+							if (settlementPhase !== "active" || !projectTerminalOutcome().turnSucceeded) throw new Error("Codex yield settlement is no longer active");
+						}
+					}),
+					drainGraceElapsed.promise,
+					degradedSettlement
+				]);
+			}
+			if (runAbortController.signal.aborted) await state.abortCleanup;
+		} finally {
+			closeSettlement();
+		}
+		const { effectiveTimedOut, finalPromptError, codexAppServerFailure, promptTimeoutOutcome, finalAborted, turnSucceeded, attemptSucceeded, completedTurnStatus } = projectTerminalOutcome();
+		terminalState.settledTurnStatus = turnSucceeded ? "completed" : completedTurnStatus === "failed" && !finalAborted && !effectiveTimedOut && !state.clientClosedPromptError && !resourceState.executionDisconnectError ? "failed" : void 0;
+		terminalState.sharedAbortAllowedAfterTerminalOutcome = shouldKeepCodexSharedAbortOpen({
+			trigger: params.trigger,
+			result,
+			attemptSucceeded,
+			explicitCancellationObserved: terminalState.explicitCancellationObserved
+		});
+		freezeRunTerminalOutcome();
+		const modelCallFailureKind = classifyCodexModelCallFailureKind({
+			error: finalPromptError,
+			timedOut: effectiveTimedOut,
+			runAborted: finalAborted,
+			abortReason: terminalState.explicitCancellationReason ?? runAbortController.signal.reason,
+			clientClosedAbort: state.clientClosedAbort,
+			formatError: formatErrorMessage
+		}) ?? (finalAborted ? "aborted" : void 0);
+		if (modelCallFailureKind) codexModelCallDiagnostics.emitError(finalPromptError ?? "codex app-server attempt interrupted", { failureKind: modelCallFailureKind });
+		else if (finalPromptError) codexModelCallDiagnostics.emitError(finalPromptError);
+		else codexModelCallDiagnostics.emitCompleted(result);
+		const { assistantTranscriptOwned, assistantTranscriptIdempotencyKey, terminalAnchor } = mirrorOutcome;
+		const settledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed) ? (!usesSupervisionConnection ? await captureCodexSettledTurnFinalizationContext({
+			...activeTranscriptTarget,
+			model: resourceState.thread.model,
+			modelProvider: resourceState.thread.modelProvider,
+			authProfileId: startupAuthProfileId,
+			mirroredMessages: mirrorOutcome.mirroredMessages,
+			settledMessages: result.messagesSnapshot,
+			turnId: activeTurnId,
+			signal: params.abortSignal,
+			assertActive: connection.assertCurrent
+		}) : void 0) ?? Object.freeze({ source: "unavailable" }) : void 0;
+		if (settledTurnFinalizationContext?.source === "unavailable") embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
+			runId: params.runId,
 			threadId: resourceState.thread.threadId,
 			turnId: activeTurnId,
-			error: finalPromptErrorMessage
+			reason: usesSupervisionConnection ? "native_auth_finalization_unsupported" : "context_unavailable"
 		});
-		await bindingStore.mutate(bindingIdentity, {
-			kind: "clear",
-			threadId: resourceState.thread.threadId
+		runAgentHarnessLlmOutputHook({
+			event: {
+				runId: params.runId,
+				sessionId: params.sessionId,
+				provider: usesSupervisionConnection ? resourceState.thread.modelProvider ?? effectiveRuntimeProviderId : params.provider,
+				model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId,
+				...hookContextWindowFields,
+				resolvedRef: usesSupervisionConnection ? `${resourceState.thread.modelProvider ?? effectiveRuntimeProviderId}/${resourceState.thread.model ?? effectiveRuntimeModelId}` : params.runtimePlan?.observability.resolvedRef ?? `${params.provider}/${params.modelId}`,
+				...!usesSupervisionConnection && params.runtimePlan?.observability.harnessId ? { harnessId: params.runtimePlan.observability.harnessId } : {},
+				assistantTexts: result.assistantTexts,
+				...result.lastAssistant ? { lastAssistant: result.lastAssistant } : {},
+				...result.attemptUsage ? { usage: result.attemptUsage } : {}
+			},
+			ctx: hookContext,
+			hookRunner
 		});
-	}
-	const refreshedUsageLimitPromptError = await refreshCodexUsageLimitPromptError({
-		client: resourceState.client,
-		message: finalPromptErrorMessage,
-		timeoutMs: appServer.requestTimeoutMs,
-		signal: runAbortController.signal
-	});
-	if (refreshedUsageLimitPromptError) {
-		await markCodexAuthProfileBlockedFromRateLimits({
-			params,
-			authProfileId: startupAuthProfileId,
-			rateLimits: refreshedUsageLimitPromptError.rateLimitsForProfile
+		const providerRefusal = result.currentAttemptAssistant?.diagnostics?.some((diagnostic) => diagnostic.type === "provider_refusal");
+		await runCodexAgentEndHook(params, {
+			skillExperienceReviewSource: providerRefusal ? void 0 : terminalAnchor,
+			event: {
+				messages: result.messagesSnapshot,
+				success: !finalAborted && !finalPromptError,
+				...finalPromptError ? { error: formatErrorMessage(finalPromptError) } : {},
+				durationMs: Date.now() - attemptStartedAt
+			},
+			ctx: {
+				...hookContext,
+				modelProviderId: resourceState.thread.modelProvider ?? effectiveRuntimeProviderId,
+				modelId: resourceState.thread.model ?? effectiveRuntimeModelId,
+				authProfileId: resourceState.thread.authProfileId ?? startupAuthProfileId,
+				modelIterations: result.modelIterations ?? 0,
+				skillWorkshopAvailable: flattenCodexDynamicToolFunctions(attemptTools.toolBridge.availableSpecs).some((tool) => tool.name === "skill_workshop"),
+				compacted: (result.compactionCount ?? 0) > 0,
+				senderId: params.senderId ?? void 0,
+				foregroundPromptContext: buildEmbeddedForegroundPromptContext({
+					...params,
+					agentId: sessionAgentId
+				}, agentDir)
+			},
+			hookRunner
 		});
-		finalPromptError = createCodexUsageLimitPromptError(refreshedUsageLimitPromptError.message);
-	} else if (isCodexUsageLimitPromptError(finalPromptError) && state.rateLimitsRevisionBeforeLastTurnStart !== void 0 && readCodexRateLimitsRevision(resourceState.client) > state.rateLimitsRevisionBeforeLastTurnStart) await markCodexAuthProfileBlockedFromRateLimits({
-		params,
-		authProfileId: startupAuthProfileId,
-		rateLimits: readRecentCodexRateLimits(resourceState.client)
-	});
-	finalPromptError = resourceState.executionDisconnectError ?? finalPromptError;
-	const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : projectedTerminal.promptErrorSource;
-	const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : state.timeout?.kind === "settlement" ? "turn_settlement_timeout" : void 0;
-	const replayBlockedReason = codexAppServerFailureKind ? resolveCodexAppServerReplayBlockedReason(result) : void 0;
-	const promptTimeoutOutcome = buildCodexAppServerPromptTimeoutOutcome(state.timeout);
-	const failureDiagnostics = codexAppServerFailureKind === "client_closed_before_turn_completed" && state.clientClosedDiagnostic ? { transportError: state.clientClosedDiagnostic } : state.timeout?.kind === "settlement" ? { timeoutMs: state.timeout.timeoutMs } : void 0;
-	const codexAppServerFailure = codexAppServerFailureKind ? {
-		kind: codexAppServerFailureKind,
-		transport: appServer.start.transport,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		replaySafe: codexAppServerFailureKind === "client_closed_before_turn_completed" && replayBlockedReason === void 0,
-		...replayBlockedReason ? { replayBlockedReason } : {},
-		...failureDiagnostics ? { diagnostics: failureDiagnostics } : {}
-	} : void 0;
-	const finalAborted = isFinalAborted();
-	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;
-	const attemptSucceeded = turnSucceeded && result.agentHarnessResultClassification === void 0;
-	terminalState.turnSucceeded = turnSucceeded;
-	terminalState.sharedAbortAllowedAfterTerminalOutcome = shouldKeepCodexSharedAbortOpen({
-		trigger: params.trigger,
-		result,
-		attemptSucceeded,
-		explicitCancellationObserved: terminalState.explicitCancellationObserved
-	});
-	freezeRunTerminalOutcome();
-	const modelCallFailureKind = classifyCodexModelCallFailureKind({
-		error: finalPromptError,
-		timedOut: effectiveTimedOut,
-		runAborted: finalAborted,
-		abortReason: terminalState.explicitCancellationReason ?? runAbortController.signal.reason,
-		clientClosedAbort: state.clientClosedAbort,
-		formatError: formatErrorMessage
-	}) ?? (finalAborted ? "aborted" : void 0);
-	if (modelCallFailureKind) codexModelCallDiagnostics.emitError(finalPromptError ?? "codex app-server attempt interrupted", { failureKind: modelCallFailureKind });
-	else if (finalPromptError) codexModelCallDiagnostics.emitError(finalPromptError);
-	else codexModelCallDiagnostics.emitCompleted(result);
-	const mirrorOutcome = await codexTranscriptMirrorRuntime.mirrorBestEffort({
-		params,
-		agentId: sessionAgentId,
-		notifyUserMessagePersisted,
-		result,
-		sessionKey: contextSessionKey,
-		cwd: effectiveCwd,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId
-	});
-	const { assistantTranscriptOwned, assistantTranscriptIdempotencyKey, terminalAnchor } = mirrorOutcome;
-	const settledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed) ? await captureCodexSettledTurnFinalizationContext({
-		...activeTranscriptTarget,
-		mirroredMessages: mirrorOutcome.mirroredMessages,
-		settledMessages: result.messagesSnapshot,
-		turnId: activeTurnId
-	}) ?? Object.freeze({ source: "unavailable" }) : void 0;
-	if (settledTurnFinalizationContext?.source === "unavailable") embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId
-	});
-	runAgentHarnessLlmOutputHook({
-		event: {
-			runId: params.runId,
-			sessionId: params.sessionId,
-			provider: usesSupervisionConnection ? resourceState.thread.modelProvider ?? effectiveRuntimeProviderId : params.provider,
-			model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId,
-			...hookContextWindowFields,
-			resolvedRef: usesSupervisionConnection ? `${resourceState.thread.modelProvider ?? effectiveRuntimeProviderId}/${resourceState.thread.model ?? effectiveRuntimeModelId}` : params.runtimePlan?.observability.resolvedRef ?? `${params.provider}/${params.modelId}`,
-			...!usesSupervisionConnection && params.runtimePlan?.observability.harnessId ? { harnessId: params.runtimePlan.observability.harnessId } : {},
-			assistantTexts: result.assistantTexts,
-			...result.lastAssistant ? { lastAssistant: result.lastAssistant } : {},
-			...result.attemptUsage ? { usage: result.attemptUsage } : {}
-		},
-		ctx: hookContext,
-		hookRunner
-	});
-	await runCodexAgentEndHook(params, {
-		event: {
-			messages: result.messagesSnapshot,
-			success: !finalAborted && !finalPromptError,
-			...finalPromptError ? { error: formatErrorMessage(finalPromptError) } : {},
-			durationMs: Date.now() - attemptStartedAt
-		},
-		ctx: {
-			...hookContext,
-			modelProviderId: resourceState.thread.modelProvider ?? effectiveRuntimeProviderId,
-			modelId: resourceState.thread.model ?? effectiveRuntimeModelId,
-			authProfileId: resourceState.thread.authProfileId ?? startupAuthProfileId,
-			modelIterations: result.modelIterations ?? 0,
-			skillWorkshopAvailable: flattenCodexDynamicToolFunctions(attemptTools.toolBridge.availableSpecs).some((tool) => tool.name === "skill_workshop"),
-			compacted: (result.compactionCount ?? 0) > 0,
-			senderId: params.senderId ?? void 0,
-			foregroundPromptContext: buildEmbeddedForegroundPromptContext({
-				...params,
-				agentId: sessionAgentId
-			}, agentDir)
-		},
-		hookRunner
-	});
-	state.shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
-	if (state.shouldDelayNativeHookRelayUnregister) try {
-		await markCodexAppServerBindingCoveredThroughTurn({
-			bindingStore,
-			identity: bindingIdentity,
-			threadId: resourceState.thread.threadId,
-			continuityCalibration: context.promptState.noEngineContinuityProjectionApplied ? buildCodexContinuityCalibration({
+		state.shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
+		if (state.shouldDelayNativeHookRelayUnregister) try {
+			const continuityCalibration = context.promptState.noEngineContinuityProjectionApplied ? buildCodexContinuityCalibration({
 				promptChars: prompt.turnState.codexTurnPromptText.length,
-				inputTokens: (result.attemptUsage?.input ?? 0) + (result.attemptUsage?.cacheRead ?? 0) + (result.attemptUsage?.cacheWrite ?? 0)
-			}) : void 0
+				inputTokens: result.attemptUsage?.contextUsage?.state === "available" ? result.attemptUsage.contextUsage.promptTokens ?? 0 : 0
+			}) : void 0;
+			await bindingStore.mutate(bindingIdentity, {
+				kind: "patch",
+				threadId: resourceState.thread.threadId,
+				patch: {
+					historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
+					...continuityCalibration ? { continuityCalibration } : {}
+				}
+			}, connection.assertCurrent);
+		} catch (error) {
+			if (resourceState.thread.connectionScope === "supervision") throw error;
+			if (canClearBindingForRecovery("clearing native coverage after a completed turn")) {
+				if (!await bindingStore.mutate(bindingIdentity, {
+					kind: "clear",
+					threadId: resourceState.thread.threadId
+				}, connection.assertCurrent)) throw error;
+				embeddedAgentLog.warn("codex app-server binding coverage update failed after completed turn; cleared stale binding", {
+					threadId: resourceState.thread.threadId,
+					turnId: activeTurnId,
+					error
+				});
+			}
+		}
+		recordCodexTrajectoryCompletion(trajectoryRecorder, {
+			attempt: params,
+			result,
+			threadId: resourceState.thread.threadId,
+			turnId: activeTurnId,
+			timedOut: effectiveTimedOut,
+			yieldDetected: toolState.yieldDetected
 		});
-	} catch (error) {
-		if (resourceState.thread.connectionScope === "supervision") throw error;
-		if (!await bindingStore.mutate(bindingIdentity, {
-			kind: "clear",
-			threadId: resourceState.thread.threadId
-		})) throw error;
-		embeddedAgentLog.warn("codex app-server binding coverage update failed after completed turn; cleared stale binding", {
+		trajectoryRecorder?.recordEvent("session.ended", {
+			status: finalPromptError ? "error" : finalAborted || effectiveTimedOut ? "interrupted" : "success",
 			threadId: resourceState.thread.threadId,
 			turnId: activeTurnId,
-			error
+			timedOut: effectiveTimedOut,
+			yieldDetected: toolState.yieldDetected,
+			promptError: normalizeCodexTrajectoryError(finalPromptError)
+		});
+		markTrajectoryEndRecorded();
+		const terminalAssistantText = collectTerminalAssistantText(result);
+		if (terminalAssistantText && (!streamState.eventEmitted || streamState.needsTerminalSnapshot) && !finalAborted && !finalPromptError) emitCodexAppServerEvent(params, {
+			stream: "assistant",
+			data: { text: terminalAssistantText }
+		});
+		emitLifecycleTerminal(finalPromptError ? {
+			phase: "error",
+			error: formatErrorMessage(finalPromptError),
+			...buildLifecycleTerminalMeta({
+				aborted: finalAborted,
+				timedOut: effectiveTimedOut
+			})
+		} : {
+			phase: "end",
+			...buildLifecycleTerminalMeta({
+				aborted: finalAborted,
+				timedOut: effectiveTimedOut,
+				yielded: toolState.yieldDetected
+			})
 		});
+		const finalizedResult = Object.assign(result, {
+			...runtimeModelSelection ? { runtimeModelSelection } : {},
+			...toolState.yieldAcknowledgment ? { yieldAcknowledgment: toolState.yieldAcknowledgment } : {},
+			...codexAppServerFailure ? { codexAppServerFailure } : {},
+			...promptTimeoutOutcome ? { promptTimeoutOutcome } : {},
+			...assistantTranscriptOwned ? { assistantTranscriptOwned: true } : {},
+			...assistantTranscriptIdempotencyKey ? { assistantTranscriptIdempotencyKey } : {},
+			...terminalAnchor ? { contextEngineTerminalAnchor: terminalAnchor } : {},
+			...settledTurnFinalizationContext ? { settledTurnFinalizationContext } : {},
+			...resourceState.runtimeArtifact ? { runtimeArtifact: resourceState.runtimeArtifact } : {},
+			...resourceState.runtimeContinuationStarted ? { runtimeContinuationStarted: true } : {},
+			...!finalAborted && !effectiveTimedOut && !finalPromptError && preparedAuthBinding ? { authBindingFingerprint: preparedAuthBinding.fingerprint } : {},
+			systemPromptReport
+		});
+		if (turnSucceeded && toolState.yieldDetected && !runAbortController.signal.aborted) resourceState.nativeHookRelay?.authorizeRetentionAfterSuccessfulYield();
+		return finalizedResult;
+	} finally {
+		closeSettlement();
 	}
-	recordCodexTrajectoryCompletion(trajectoryRecorder, {
-		attempt: params,
-		result,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		timedOut: effectiveTimedOut,
-		yieldDetected: toolState.yieldDetected
-	});
-	trajectoryRecorder?.recordEvent("session.ended", {
-		status: finalPromptError ? "error" : finalAborted || effectiveTimedOut ? "interrupted" : "success",
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		timedOut: effectiveTimedOut,
-		yieldDetected: toolState.yieldDetected,
-		promptError: normalizeCodexTrajectoryError(finalPromptError)
-	});
-	markTrajectoryEndRecorded();
-	const terminalAssistantText = collectTerminalAssistantText(result);
-	if (terminalAssistantText && (!streamState.eventEmitted || streamState.needsTerminalSnapshot) && !finalAborted && !finalPromptError) emitCodexAppServerEvent(params, {
-		stream: "assistant",
-		data: { text: terminalAssistantText }
-	});
-	emitLifecycleTerminal(finalPromptError ? {
-		phase: "error",
-		error: formatErrorMessage(finalPromptError),
-		...buildLifecycleTerminalMeta({
-			aborted: finalAborted,
-			timedOut: effectiveTimedOut
-		})
-	} : {
-		phase: "end",
-		...buildLifecycleTerminalMeta({
-			aborted: finalAborted,
-			timedOut: effectiveTimedOut,
-			yielded: toolState.yieldDetected
-		})
-	});
-	const finalizedResult = Object.assign(result, {
-		...toolState.yieldAcknowledgment ? { yieldAcknowledgment: toolState.yieldAcknowledgment } : {},
-		terminal: attemptTerminal.normalize({
-			timedOut: effectiveTimedOut,
-			aborted: finalAborted,
-			promptError: finalPromptError,
-			promptErrorSource: finalPromptErrorSource
-		}),
-		...codexAppServerFailure ? { codexAppServerFailure } : {},
-		...promptTimeoutOutcome ? { promptTimeoutOutcome } : {},
-		...assistantTranscriptOwned ? { assistantTranscriptOwned: true } : {},
-		...assistantTranscriptIdempotencyKey ? { assistantTranscriptIdempotencyKey } : {},
-		...terminalAnchor ? { contextEngineTerminalAnchor: terminalAnchor } : {},
-		...settledTurnFinalizationContext ? { settledTurnFinalizationContext } : {},
-		...resourceState.runtimeArtifact ? { runtimeArtifact: resourceState.runtimeArtifact } : {},
-		...resourceState.runtimeContinuationStarted ? { runtimeContinuationStarted: true } : {},
-		...!finalAborted && !effectiveTimedOut && !finalPromptError && preparedAuthBinding ? { authBindingFingerprint: preparedAuthBinding.fingerprint } : {},
-		systemPromptReport
-	});
-	if (turnSucceeded && toolState.yieldDetected && !runAbortController.signal.aborted) resourceState.nativeHookRelay?.authorizeRetentionAfterSuccessfulYield();
-	return finalizedResult;
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-notification-state.ts
@@ -4422,7 +4782,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const { attemptTools, runtime } = context;
 	const { appServer, runAbortController } = runtime.connection;
 	const { allocateCodexToolOutcomeOrdinal } = attemptTools;
-	const { state, turnIdRef, userInputBridgeRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, completeTurn, noteProgress, deadlines } = turnRuntime;
+	const { state, turnIdRef, userInputBridgeRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, openClawDynamicToolExecutions, completeTurn, noteProgress, deadlines } = turnRuntime;
 	const { scheduleTerminalDynamicToolReleaseCheck, reportExecutionNotification, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const isTerminalTurnNotificationForTurn = (notification, notificationTurnId) => isTerminalCodexTurnNotificationForTurn({
 		notification,
@@ -4457,7 +4817,15 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 				if (notification.method === "item/completed") {
 					if (activeTurnItemIds.size === 0) scheduleTerminalDynamicToolReleaseCheck();
 					const item = readCodexNotificationItem(notification.params);
-					if (item?.type === "userMessage" && typeof item.clientId === "string") await steeringQueueRef.current?.confirmConsumed(item.clientId);
+					if (item?.type === "dynamicToolCall" && typeof item.id === "string") {
+						const response = await openClawDynamicToolExecutions.get({
+							threadId: resourceState.thread.threadId,
+							turnId,
+							callId: item.id
+						});
+						if (response && !state.projectionClosed && !runAbortController.signal.aborted && turnIdRef.current === turnId && item.success === response.success && isDeepStrictEqual(item.contentItems, response.contentItems)) acknowledgeInternalToolResult(response);
+					}
+					if (item?.type === "userMessage" && typeof item.clientId === "string") steeringQueueRef.current?.confirmConsumed(item.clientId);
 				}
 				if (isCodexTurnAbortMarkerNotification(notification, { currentPromptTexts: [turnState.codexTurnPromptText] })) state.sawCodexInterruptMarker = true;
 			}
@@ -4498,6 +4866,8 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		if (!projector || !turnId || state.projectionClosed) return;
 		projector.recordMcpToolCallReceipt(notification);
 		if (isTerminalTurnNotificationForTurn(notification, turnId)) {
+			const completed = readCodexTurnCompletedNotification(notification.params);
+			if (completed) projector.settlement.terminalReceipt = completed.turn;
 			state.terminalTurnNotificationQueued = true;
 			steeringQueueRef.current?.sealAdmission();
 			deadlines.beginSettlement(receivedAtMs);
@@ -4506,7 +4876,10 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			const modelToolCallId = readRawResponseToolCallId(notification);
 			if (modelToolCallId) allocateCodexToolOutcomeOrdinal?.(modelToolCallId);
 			const nativeItem = readCodexNotificationItem(notification.params);
-			if (nativeItem?.type === "webSearch") projector.recordNativeToolOutcome(nativeItem);
+			if (nativeItem?.type === "webSearch") {
+				projector.settlement.turnTainted ||= notification.method === "item/completed";
+				projector.recordNativeToolOutcome(nativeItem);
+			}
 		}
 	};
 	const enqueueNotification = async (notification, scope) => {
@@ -4533,17 +4906,47 @@ function isRestrictivePromptToolsAllow(toolsAllow) {
 	return toolsAllow !== void 0 && !toolsAllow.some((name) => name.trim() === "*");
 }
 async function prepareCodexAttemptPrompt(context) {
-	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, openClawPromptContext, skillsCollaborationInstructions, promptState, codexContextProjectionMaxChars, codexContinuityProjectionMaxChars } = context;
+	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, buildOpenClawPromptContext, skillsCollaborationInstructions, promptState, codexContextProjectionMaxChars, codexContinuityProjectionMaxChars } = context;
 	const { connection, buildActiveRunAttemptParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
 	const { params, activeContextEngine, usesSupervisionConnection, mutable, isInactiveThreadBootstrapBinding, bindingStore, bindingIdentity, agentDir, appServer, contextSessionKey, effectiveWorkspace, sandbox } = connection;
 	const { toolBridge } = attemptTools;
-	const applyFreshThreadContinuityProjection = () => {
-		const projection = projectContextEngineAssemblyForCodex({
-			assembledMessages: historyState.messages,
+	let contextImages = [];
+	const currentUserTurnIdempotencyKey = params.userTurnTranscriptRecorder?.message?.idempotencyKey;
+	const assertProjectionCurrent = () => {
+		params.hostCapabilities.assertActive();
+		connection.assertCurrent();
+		connection.runAbortController.signal.throwIfAborted();
+	};
+	const prepareFileContext = async (message, maxChars) => {
+		const prepare = params.hostCapabilities.prepareContextMedia;
+		if (!prepare) {
+			const media = asOptionalRecord(Reflect.get(message, "__openclaw"))?.media;
+			if (Array.isArray(media) && media.length || message.role === "user" && Array.isArray(message.content) && message.content.some((part) => part.type === "image")) throw new CodexContextAttachmentError("Saved attachments require a newer OpenClaw host. Update the Gateway and Codex plugin together, then retry.");
+			return { images: [] };
+		}
+		try {
+			const files = await prepare({
+				message,
+				maxChars
+			});
+			assertProjectionCurrent();
+			return files;
+		} catch (error) {
+			assertProjectionCurrent();
+			throw new CodexContextAttachmentError("Saved attachment preparation failed. Retry the request after checking the attachment source.", { cause: error });
+		}
+	};
+	const applyContinuityProjection = async (messages) => {
+		const projection = await projectContextEngineAssemblyForCodex({
+			assembledMessages: messages,
 			originalHistoryMessages: historyState.messages,
 			prompt: params.prompt,
-			maxRenderedContextChars: codexContinuityProjectionMaxChars
+			maxRenderedContextChars: codexContinuityProjectionMaxChars,
+			prepareFileContext,
+			currentUserTurnIdempotencyKey
 		});
+		assertProjectionCurrent();
+		contextImages = projection.images ?? [];
 		promptState.promptText = projection.promptText;
 		promptState.promptContextRange = projection.promptContextRange;
 		promptState.prePromptMessageCount = projection.prePromptMessageCount;
@@ -4572,14 +4975,6 @@ async function prepareCodexAttemptPrompt(context) {
 		});
 		if (!assembled) throw new Error("context engine assemble returned no result");
 		const contextEngineProjection = readContextEngineThreadBootstrapProjection(assembled.contextProjection);
-		const projection = projectContextEngineAssemblyForCodex({
-			assembledMessages: assembled.messages,
-			originalHistoryMessages: historyState.messages,
-			prompt: params.prompt,
-			systemPromptAddition: assembled.systemPromptAddition,
-			maxRenderedContextChars: codexContextProjectionMaxChars,
-			toolPayloadMode: contextEngineProjection ? "preserve" : "elide"
-		});
 		const projectionDecision = contextEngineProjection ? resolveContextEngineBootstrapProjectionDecision({
 			startupBinding: decisionStartupBinding,
 			expectedBinding: buildContextEngineBinding(buildActiveRunAttemptParams(), contextEngineProjection),
@@ -4590,6 +4985,18 @@ async function prepareCodexAttemptPrompt(context) {
 			project: true,
 			reason: "per-turn-projection"
 		};
+		const projection = await projectContextEngineAssemblyForCodex({
+			assembledMessages: assembled.messages,
+			originalHistoryMessages: historyState.messages,
+			prompt: params.prompt,
+			systemPromptAddition: assembled.systemPromptAddition,
+			maxRenderedContextChars: codexContextProjectionMaxChars,
+			toolPayloadMode: contextEngineProjection ? "preserve" : "elide",
+			...projectionDecision.project ? { prepareFileContext } : {},
+			currentUserTurnIdempotencyKey
+		});
+		assertProjectionCurrent();
+		contextImages = projectionDecision.project ? projection.images ?? [] : [];
 		const decisionBinding = decisionStartupBinding;
 		embeddedAgentLog.info("codex app-server context-engine projection decision", {
 			sessionId: params.sessionId,
@@ -4617,6 +5024,8 @@ async function prepareCodexAttemptPrompt(context) {
 	if (activeContextEngine) try {
 		await applyActiveContextEngineProjection(runtime.nativeToolSurfaceEnabled ? mutable.startupBinding : void 0);
 	} catch (assembleErr) {
+		if (assembleErr instanceof CodexContextAttachmentError) throw assembleErr;
+		assertProjectionCurrent();
 		embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 	}
 	const codexModelInputHistoryMessages = [];
@@ -4633,7 +5042,7 @@ async function prepareCodexAttemptPrompt(context) {
 			toolAuthority: {
 				fingerprint: params.toolAuthorityFingerprint,
 				activeToolNames: () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString),
-				assertActive: params.hostCapabilities.assertActive
+				assertActive: connection.assertCurrent
 			}
 		});
 	};
@@ -4663,8 +5072,8 @@ async function prepareCodexAttemptPrompt(context) {
 			}
 		};
 	};
-	const decorateCodexTurnPromptText = (promptBuildResult) => {
-		const turnPromptText = prependCodexOpenClawPromptContext(promptBuildResult.prompt, openClawPromptContext, { preservePromptWithoutContext: params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron" });
+	const decorateCodexTurnPromptText = (promptBuildResult, includeWorkspaceReferences = true) => {
+		const turnPromptText = prependCodexOpenClawPromptContext(promptBuildResult.prompt, buildOpenClawPromptContext(includeWorkspaceReferences), { preservePromptWithoutContext: params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron" });
 		const projectedRanges = resolveShiftedPromptContextRange(promptBuildResult.prompt, promptBuildResult.promptInputRange, turnPromptText);
 		const preservedRange = resolveShiftedPromptInputRange(promptBuildResult.prompt, promptBuildResult.promptInputRange, turnPromptText) ?? resolveCodexDeliveryHintPreservedInputRange({
 			prompt: promptBuildResult.prompt,
@@ -4704,28 +5113,19 @@ async function prepareCodexAttemptPrompt(context) {
 	const selectNewerVisibleHistoryAfterBinding = (binding) => {
 		const cutoff = Date.parse(binding.historyCoveredThrough ?? "");
 		return historyState.messages.filter((message) => {
-			if (message.role !== "user" && message.role !== "assistant") return false;
+			if (message.role !== "user" && message.role !== "assistant" && !isCodexDurableCustomMessage(message)) return false;
 			const mirrorIdentity = readMirrorIdentity(message);
 			const timestamp = typeof message.timestamp === "number" ? message.timestamp : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
 			return !("idempotencyKey" in message && typeof message.idempotencyKey === "string" && message.idempotencyKey.startsWith("codex-app-server:")) && !hasCodexMirrorOrigin(message) && !mirrorIdentity?.startsWith("codex-app-server:") && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
 		});
 	};
-	const applyResumeStaleBindingContinuityProjection = (binding) => {
+	const applyResumeStaleBindingContinuityProjection = async (binding) => {
 		const newerVisibleMessages = selectNewerVisibleHistoryAfterBinding(binding);
 		if (newerVisibleMessages.length === 0) return false;
-		const projection = projectContextEngineAssemblyForCodex({
-			assembledMessages: newerVisibleMessages,
-			originalHistoryMessages: historyState.messages,
-			prompt: params.prompt,
-			maxRenderedContextChars: codexContinuityProjectionMaxChars
-		});
-		promptState.promptText = projection.promptText;
-		promptState.promptContextRange = projection.promptContextRange;
-		promptState.prePromptMessageCount = projection.prePromptMessageCount;
-		promptState.noEngineContinuityProjectionApplied = true;
+		await applyContinuityProjection(newerVisibleMessages);
 		return true;
 	};
-	const precomputeNoContextEngineStaleBindingProjection = () => {
+	const precomputeNoContextEngineStaleBindingProjection = async () => {
 		promptState.precomputedStaleBindingContinuityProjectionApplied = false;
 		promptState.staleBindingContinuityForcedFreshStart = false;
 		const binding = mutable.startupBinding;
@@ -4734,30 +5134,31 @@ async function prepareCodexAttemptPrompt(context) {
 			promptState.inactiveThreadBootstrapBindingForcedFreshStart = true;
 			return false;
 		}
-		const projected = applyResumeStaleBindingContinuityProjection(binding);
+		const projected = await applyResumeStaleBindingContinuityProjection(binding);
 		promptState.precomputedStaleBindingContinuityProjectionApplied = projected;
 		return projected;
 	};
-	const applyNoContextEngineContinuityProjection = (action, binding) => {
-		const hasContinuity = historyState.messages.some((message) => message.role === "user" || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
+	const applyNoContextEngineContinuityProjection = async (action, binding) => {
+		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
 		if (activeContextEngine || !hasContinuity) return false;
 		if (action === "resumed" && promptState.precomputedStaleBindingContinuityProjectionApplied) return true;
 		if (action === "started" && promptState.staleBindingContinuityForcedFreshStart) return true;
 		if (action === "started" && promptState.inactiveThreadBootstrapBindingForcedFreshStart) return false;
 		if (action === "resumed" && binding) return applyResumeStaleBindingContinuityProjection(binding);
 		if (action === "started") {
-			applyFreshThreadContinuityProjection();
+			await applyContinuityProjection(historyState.messages);
 			return true;
 		}
 		return false;
 	};
-	if (precomputeNoContextEngineStaleBindingProjection()) await rebuildCodexPromptBuildFromCurrentProjection();
+	if (await precomputeNoContextEngineStaleBindingProjection()) await rebuildCodexPromptBuildFromCurrentProjection();
 	const rotateStartupBindingForProjectedTurn = async () => {
 		const binding = mutable.startupBinding;
 		if (!binding?.threadId) return;
 		const previousThreadId = binding.threadId;
 		const hadInactiveThreadBootstrapBinding = isInactiveThreadBootstrapBinding(binding);
 		const startupBindingResolution = await rotateOversizedCodexAppServerStartupBinding({
+			assertCurrent: connection.assertCurrent,
 			binding,
 			bindingStore,
 			identity: bindingIdentity,
@@ -4766,6 +5167,7 @@ async function prepareCodexAttemptPrompt(context) {
 			codexHome: appServer.start.env?.CODEX_HOME,
 			config: params.config,
 			contextEngineActive: Boolean(activeContextEngine),
+			expectedSessionRuntimeOwnership: params.expectedSessionRuntimeOwnership,
 			projectedTurnTokens: estimateCodexAppServerProjectedTurnTokens({
 				prompt: turnState.codexTurnPromptText,
 				developerInstructions: buildRenderedCodexDeveloperInstructions()
@@ -4776,12 +5178,14 @@ async function prepareCodexAttemptPrompt(context) {
 		if (mutable.startupBinding?.threadId) return;
 		promptState.inactiveThreadBootstrapBindingForcedFreshStart = hadInactiveThreadBootstrapBinding;
 		promptState.staleBindingContinuityForcedFreshStart = promptState.precomputedStaleBindingContinuityProjectionApplied && !promptState.inactiveThreadBootstrapBindingForcedFreshStart;
-		if (promptState.staleBindingContinuityForcedFreshStart) applyFreshThreadContinuityProjection();
+		if (promptState.staleBindingContinuityForcedFreshStart) await applyContinuityProjection(historyState.messages);
 		if (activeContextEngine) {
 			promptState.contextEngineProjection = void 0;
 			try {
 				await applyActiveContextEngineProjection(void 0);
 			} catch (assembleErr) {
+				if (assembleErr instanceof CodexContextAttachmentError) throw assembleErr;
+				assertProjectionCurrent();
 				embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 			}
 		}
@@ -4795,22 +5199,36 @@ async function prepareCodexAttemptPrompt(context) {
 		});
 	};
 	await rotateStartupBindingForProjectedTurn();
+	const buildSystemPromptReport = (omitWorkspaceReferences = false) => buildCodexSystemPromptReport({
+		attempt: params,
+		sessionKey: contextSessionKey,
+		workspaceDir: effectiveWorkspace,
+		developerInstructions: buildRenderedCodexDeveloperInstructions(),
+		workspaceBootstrapContext,
+		omitWorkspaceReferences,
+		skillsPrompt: skillsCollaborationInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
+		tools: toolBridge.availableSpecs
+	});
+	const systemPromptReport = buildSystemPromptReport();
+	let workspaceReferencesIncluded = true;
 	return {
 		context,
+		get contextImages() {
+			return contextImages;
+		},
 		codexModelInputHistoryMessages,
 		turnState,
+		refreshWorkspaceReferences: (include) => {
+			turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild, include);
+			if (include !== workspaceReferencesIncluded) {
+				Object.assign(systemPromptReport, buildSystemPromptReport(!include));
+				workspaceReferencesIncluded = include;
+			}
+		},
 		buildRenderedCodexDeveloperInstructions,
 		rebuildCodexTurnPromptTextFromCurrentProjection,
 		applyNoContextEngineContinuityProjection,
-		systemPromptReport: buildCodexSystemPromptReport({
-			attempt: params,
-			sessionKey: contextSessionKey,
-			workspaceDir: effectiveWorkspace,
-			developerInstructions: buildRenderedCodexDeveloperInstructions(),
-			workspaceBootstrapContext,
-			skillsPrompt: skillsCollaborationInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
-			tools: toolBridge.availableSpecs
-		})
+		systemPromptReport
 	};
 }
 //#endregion
@@ -4909,10 +5327,11 @@ function prepareCodexAttemptResources(prompt) {
 			closed: retired.closed,
 			matchedSharedClient: retired.found
 		});
-		if (retired.closed) await state.client.closeAndWait({
+		const result = retired.closed ? await state.client.closeAndWait({
 			exitTimeoutMs: 2e3,
 			forceKillDelayMs: 250
-		});
+		}) : void 0;
+		if (params.oneShotCliRun && result?.cleanup !== "closed") throw new Error("Codex one-shot client cleanup could not be confirmed");
 	};
 	const releaseSandboxExecEnvironment = async () => {
 		if (state.sandboxExecEnvironment) {
@@ -4926,10 +5345,13 @@ function prepareCodexAttemptResources(prompt) {
 			await releaseSandboxExecEnvironment();
 			const ownedClient = state.releaseSharedClientLease ? state.client : void 0;
 			releaseSharedClientLeaseOnce();
-			await ownedClient?.closeAndWait({
-				exitTimeoutMs: 2e3,
-				forceKillDelayMs: 250
-			});
+			if (ownedClient) {
+				const result = await ownedClient.closeAndWait({
+					exitTimeoutMs: 2e3,
+					forceKillDelayMs: 250
+				});
+				if (params.oneShotCliRun && result.cleanup !== "closed") throw new Error("Codex isolated client cleanup could not be confirmed");
+			}
 			return;
 		}
 		releaseSharedClientLeaseOnce();
@@ -5016,6 +5438,7 @@ function prepareCodexAttemptResources(prompt) {
 			loopDetectionPreToolUseRelay: appServer.loopDetectionPreToolUseRelay,
 			signal: runAbortController.signal,
 			hostCapabilities: params.hostCapabilities,
+			assertCurrent: connection.assertCurrent,
 			onPreToolUseFailure: (failure) => {
 				const projector = projectorRef.current;
 				if (projector) projector.recordNativeToolPreToolUseFailure(failure);
@@ -5057,7 +5480,7 @@ function prepareCodexAttemptResources(prompt) {
 async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, handleServerRequest) {
 	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, registerNativeSubagentMonitor, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseOnce } = resources;
 	const { connection } = prompt.context.runtime;
-	const { params, runAbortController, abortFromUpstream } = connection;
+	const { runAbortController } = connection;
 	const { state, turnIdRef, completeTurn } = turnRuntime;
 	const { noteNotificationReceived, enqueueNotification } = notifications;
 	const attachRouteAbort = (route) => {
@@ -5112,7 +5535,6 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 		resourceState.nativeHookRelay?.unregister();
 		await releaseSandboxExecEnvironment();
 		releaseSharedClientLeaseOnce();
-		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 		throw error;
 	}
 	return { ensureCurrentThreadRoute };
@@ -5125,6 +5547,7 @@ function prewarmCodexAttemptClient(params) {
 	const { appServer, attemptClientFactory, options, pluginConfig, runtimeArtifactRequest, startupAuthRequirement, startupClientAuthProfileId, startupPreparedAuth, agentDir, params: runParams, runAbortController } = connection;
 	if (options.clientFactory || attemptClientFactory !== getLeasedSharedCodexAppServerClient || runtimeArtifactRequest) return;
 	getSharedCodexAppServerClient({
+		assertCurrent: connection.assertCurrent,
 		startOptions: appServer.start,
 		pluginConfig,
 		...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
@@ -5236,7 +5659,7 @@ async function prepareCodexAttemptRuntime(connection) {
 	const authenticatedScheduledMode = params.trigger === "cron" && params.scheduledToolPolicy !== void 0 && Array.isArray(params.toolsAllow);
 	const scheduledConfiguredMcpSurface = authenticatedScheduledMode && (bundleMcpThreadConfig.staticServerNames.length > 0 || mutable.startupBinding?.configuredMcpOwnershipVersion === 1);
 	const cronCreatorAuthorityCapability = params.cronCreatorAuthorityCapability;
-	const hasFreshCreatorAuthority = cronCreatorAuthorityCapability?.active === true && cronCreatorAuthorityCapability.runId === params.runId && !cronCreatorAuthorityCapability.signal.aborted;
+	const hasFreshCreatorAuthority = cronCreatorAuthorityCapability?.active === true && !(cronCreatorAuthorityCapability.controlUiAdmin && cronCreatorAuthorityCapability.callerOrigin.kind === "unknown") && cronCreatorAuthorityCapability.runId === params.runId && !cronCreatorAuthorityCapability.signal.aborted;
 	const mayResolveScheduledConfiguredMcpCreatorAuthority = !authenticatedScheduledMode && canResolveScheduledConfiguredMcpCreatorAuthority({
 		trigger: params.trigger,
 		connectionClass: appServer.connectionClass,
@@ -5401,10 +5824,10 @@ function createCodexDynamicToolExecutionRegistry() {
 		}
 	};
 }
-function resolveCodexDynamicToolDirectNames(params, hostSystemAgentActive = false) {
+function resolveCodexDynamicToolDirectNames(params, registeredTools, hostSystemAgentActive = false) {
 	const names = [];
 	if (hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow)) names.push("openclaw");
-	if (params.sourceReplyDeliveryMode === "message_tool_only") names.push("message");
+	if (registeredTools.some((tool) => tool.name === "message")) names.push("message");
 	return names;
 }
 //#endregion
@@ -5677,7 +6100,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-C3jVimFn.js");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-T-NwqeSH.js");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -5689,12 +6112,7 @@ async function verifyStartupArtifact(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/computer-use-health.ts
-const COMPUTER_USE_HEALTH_MONITOR_STATE = Symbol.for("openclaw.codexComputerUseHealthMonitorState");
-function getComputerUseHealthMonitorState() {
-	const globalState = globalThis;
-	globalState[COMPUTER_USE_HEALTH_MONITOR_STATE] ??= { monitors: /* @__PURE__ */ new WeakMap() };
-	return globalState[COMPUTER_USE_HEALTH_MONITOR_STATE];
-}
+const getComputerUseHealthMonitorState = defineCodexBuildState("openclaw.codexComputerUseHealthMonitorState", () => ({ monitors: /* @__PURE__ */ new WeakMap() }));
 function startCodexComputerUseHealthMonitor(params) {
 	const state = getComputerUseHealthMonitorState();
 	const existing = state.monitors.get(params.client);
@@ -5802,15 +6220,22 @@ function resolveCodexPluginThreadConfigStartupPolicy(params) {
 /** Builds plugin config without allowing sequential RPC timeouts to consume the turn. */
 async function buildCodexPluginThreadConfigWithinDeadline(params) {
 	const { requestTimeoutMs, signal, request, failClosedOnTimeout, transform, ...buildParams } = params;
+	signal.throwIfAborted();
 	const timeoutMs = resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs);
 	const deadlineMs = Date.now() + timeoutMs;
-	const boundedRequest = (method, requestParams) => {
+	let requestTimedOut = false;
+	const boundedRequest = async (method, requestParams) => {
 		const remainingTimeoutMs = deadlineMs - Date.now();
-		if (remainingTimeoutMs <= 0) throw new CodexPluginThreadConfigDeadlineError();
-		return request(method, requestParams, {
-			timeoutMs: remainingTimeoutMs,
-			signal
-		});
+		if (requestTimedOut || remainingTimeoutMs <= 0) throw new CodexPluginThreadConfigDeadlineError();
+		try {
+			return await request(method, requestParams, {
+				timeoutMs: remainingTimeoutMs,
+				signal
+			});
+		} catch (error) {
+			requestTimedOut ||= isCodexPluginThreadConfigTimeoutError(error);
+			throw error;
+		}
 	};
 	try {
 		return await withAbortableTimeout({
@@ -5821,14 +6246,16 @@ async function buildCodexPluginThreadConfigWithinDeadline(params) {
 					...buildParams,
 					request: boundedRequest
 				});
-				return transform ? await transform(config, boundedRequest) : config;
+				const result = transform ? await transform(config, boundedRequest) : config;
+				if (requestTimedOut || Date.now() >= deadlineMs) throw new CodexPluginThreadConfigDeadlineError();
+				return result;
 			})(),
 			timeoutMessage: "Codex plugin thread config deadline elapsed",
 			createTimeoutError: () => new CodexPluginThreadConfigDeadlineError()
 		});
 	} catch (error) {
-		if (signal.aborted || !isCodexPluginThreadConfigTimeoutError(error)) throw error;
-		if (failClosedOnTimeout) throw new AgentHarnessPreflightError(`Scheduled Codex app policy verification exceeded its ${timeoutMs} ms startup budget. No app tools were executed. Retry after Codex app inventory is responsive, or reauthorize the automation.`);
+		if (signal.aborted || !requestTimedOut && !isCodexPluginThreadConfigTimeoutError(error) && Date.now() < deadlineMs) throw error;
+		if (failClosedOnTimeout) throw new AgentHarnessPreflightError(`Codex app policy verification exceeded its ${timeoutMs} ms startup budget. No app tools were executed. Retry after Codex app inventory is responsive.`);
 		return buildCodexPluginThreadConfigTimeoutFallback({
 			pluginConfig: buildParams.pluginConfig,
 			appCacheKey: buildParams.appCacheKey,
@@ -5842,7 +6269,7 @@ function createCodexPluginThreadConfigStartupProvider(params) {
 	const metadataCache = configuredMetadataCache ?? defaultCodexPluginMetadataCache;
 	return {
 		enabled: true,
-		requiresCurrentPolicyCheck: Boolean(params.scheduledRuntimeAuthority),
+		requiresCurrentPolicyCheck: Boolean(policy?.enabled || params.scheduledRuntimeAuthority),
 		inputFingerprint,
 		enabledPluginConfigKeys,
 		accountAppRecoveryEnabled: policy?.allowAllPlugins,
@@ -5905,7 +6332,6 @@ async function startCodexAttemptThread(params) {
 	let releaseSharedClientLease;
 	let startupClientForAbandonedRequestCleanup;
 	let releaseStartupResourcesOnTimeout;
-	let startupAbandoned = false;
 	const startupAbandonController = new AbortController();
 	const abandonStartupAcquire = () => startupAbandonController.abort();
 	params.signal.addEventListener("abort", abandonStartupAcquire, { once: true });
@@ -5914,7 +6340,6 @@ async function startCodexAttemptThread(params) {
 			timeoutMs: params.startupTimeoutMs,
 			signal: params.signal,
 			onTimeout: async () => {
-				startupAbandoned = true;
 				startupAbandonController.abort();
 				await params.onStartupTimeout();
 				await releaseStartupResourcesOnTimeout?.();
@@ -5942,7 +6367,9 @@ async function startCodexAttemptThread(params) {
 					let startupAttemptSucceeded = false;
 					try {
 						const attemptParams = params.buildAttemptParams();
+						params.assertCurrent?.();
 						startupClient = await params.attemptClientFactory({
+							assertCurrent: params.assertCurrent,
 							startOptions: params.appServer.start,
 							pluginConfig: params.pluginConfig,
 							...params.startupPreparedAuth ? { preparedAuth: params.startupPreparedAuth } : { authProfileId: params.startupAuthProfileId },
@@ -5958,7 +6385,7 @@ async function startCodexAttemptThread(params) {
 							config: params.config,
 							onStartedClient: (client) => {
 								startupClientForAbandonedRequestCleanup = client;
-								if (startupAbandoned || startupAbandonController.signal.aborted) closeCodexStartupClientBestEffort(client);
+								if (startupAbandonController.signal.aborted) closeCodexStartupClientBestEffort(client);
 							},
 							abandonSignal: startupAbandonController.signal,
 							timeoutMs: params.appServer.requestTimeoutMs
@@ -5974,13 +6401,13 @@ async function startCodexAttemptThread(params) {
 						releaseSharedClientLease = startupClientLease;
 						attemptedClient = activeStartupClient;
 						startupClientForAbandonedRequestCleanup = activeStartupClient;
-						if (startupAbandoned) throw new CodexAppServerStartupError("timed_out");
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
 						const runtimeArtifact = await verifyStartupArtifact({
 							client: activeStartupClient,
 							request: params.runtimeArtifactRequest,
 							signal: startupAbandonController.signal
 						});
+						params.assertCurrent?.();
 						ensureCodexAppServerClientRuntime(activeStartupClient, {
 							agentDir: params.agentDir,
 							authProfileId: startupRuntimeAuthProfileId,
@@ -6046,6 +6473,7 @@ async function startCodexAttemptThread(params) {
 						};
 						releaseStartupResourcesOnTimeout = releaseStartupSandboxEnvironment;
 						try {
+							params.assertCurrent?.();
 							const sandboxEnvironmentRequired = shouldRequireCodexSandboxExecServerEnvironment({
 								sandbox: params.sandbox,
 								nativeToolSurfaceEnabled: params.nativeToolSurfaceEnabled,
@@ -6061,10 +6489,7 @@ async function startCodexAttemptThread(params) {
 								onExecutionDisconnect: params.onExecutionDisconnect
 							}) : void 0;
 							startupSandboxEnvironmentAcquired = Boolean(startupSandboxEnvironment);
-							if (startupAbandonController.signal.aborted) {
-								await releaseStartupSandboxEnvironment();
-								throw new CodexAppServerStartupError("aborted");
-							}
+							if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
 							if (sandboxEnvironmentRequired && !startupSandboxEnvironment) throw new Error("Codex app-server did not register an OpenClaw sandbox exec-server environment.");
 						} catch (error) {
 							await releaseStartupSandboxEnvironment();
@@ -6101,6 +6526,7 @@ async function startCodexAttemptThread(params) {
 							client: activeStartupClient,
 							reserveResumeThread,
 							bindingStore: params.bindingStore,
+							assertCurrent: params.assertCurrent,
 							params: params.buildAttemptParams(),
 							runtimeModelId: params.runtimeModelId,
 							agentId: params.sessionAgentId,
@@ -6191,7 +6617,7 @@ async function startCodexAttemptThread(params) {
 						}
 					} catch (error) {
 						startupAttemptError = error;
-						if (!startupAbandoned && !params.signal.aborted && !startupClient) {
+						if (!startupAbandonController.signal.aborted && !startupClient) {
 							const sharedClient = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(startupClientForAbandonedRequestCleanup);
 							if (sharedClient.found && !sharedClient.closed) startupClientForAbandonedRequestCleanup = void 0;
 						}
@@ -6200,10 +6626,7 @@ async function startCodexAttemptThread(params) {
 						if (!startupAttemptSucceeded) {
 							if (releaseSharedClientLease === startupClientLease) releaseSharedClientLease = void 0;
 							startupClientLease?.();
-							if (startupAbandoned || params.signal.aborted) {
-								if (startupClientForAbandonedRequestCleanup === startupClient) startupClientForAbandonedRequestCleanup = void 0;
-								await closeCodexStartupClientBestEffort(startupClient);
-							} else if (!isCodexAppServerStartSelectionChangedError(startupAttemptError) && (shouldClearSharedClientAfterStartupRace(startupAttemptError) || shouldClearSharedClientAfterStartupFailure(startupAttemptError, params.spawnedBy))) {
+							if (shouldRetireCodexStartupClient(startupAttemptError, params.spawnedBy, startupAbandonController.signal)) {
 								if (startupClientForAbandonedRequestCleanup === startupClient) startupClientForAbandonedRequestCleanup = void 0;
 								await closeCodexStartupClientBestEffort(startupClient);
 							}
@@ -6214,7 +6637,7 @@ async function startCodexAttemptThread(params) {
 					return await startupAttempt();
 				} catch (error) {
 					const selectionChanged = isCodexAppServerStartSelectionChangedError(error);
-					if (startupAbandoned || params.signal.aborted || !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
+					if (startupAbandonController.signal.aborted || !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
 					const refreshedSharedClient = selectionChanged ? retireSharedCodexAppServerClientIfCurrent(attemptedClient) : clearSharedCodexAppServerClientIfCurrent(attemptedClient);
 					if (startupClientForAbandonedRequestCleanup === attemptedClient) startupClientForAbandonedRequestCleanup = void 0;
 					if (attempt >= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS) {
@@ -6247,12 +6670,7 @@ async function startCodexAttemptThread(params) {
 			releaseSharedClientLease
 		};
 	} catch (error) {
-		if (params.signal.aborted || isCodexAppServerStartupError(error)) {
-			releaseSharedClientLease?.();
-			releaseSharedClientLease = void 0;
-			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
-			startupClientForAbandonedRequestCleanup = void 0;
-		} else if (!isCodexAppServerStartSelectionChangedError(error) && (shouldClearSharedClientAfterStartupRace(error) || shouldClearSharedClientAfterStartupFailure(error, params.spawnedBy))) {
+		if (shouldRetireCodexStartupClient(error, params.spawnedBy, startupAbandonController.signal)) {
 			releaseSharedClientLease?.();
 			releaseSharedClientLease = void 0;
 			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
@@ -6263,30 +6681,29 @@ async function startCodexAttemptThread(params) {
 		params.signal.removeEventListener("abort", abandonStartupAcquire);
 	}
 }
-function shouldClearSharedClientAfterStartupRace(error) {
-	return isCodexAppServerStartupError(error) || isCodexAppServerRequestTimeoutError(error);
-}
-function shouldClearSharedClientAfterStartupFailure(error, spawnedBy) {
-	return !isCodexAppServerOverloadError(error) && !(error instanceof AgentHarnessPreflightError && error.scope === void 0) && (isCodexAppServerBrokenPipeError(error) || !spawnedBy);
+function shouldRetireCodexStartupClient(error, spawnedBy, signal) {
+	if (signal.aborted || isCodexAppServerStartupError(error) || isCodexAppServerRequestTimeoutError(error)) return true;
+	return !isCodexAppServerStartSelectionChangedError(error) && !isCodexAppServerOverloadError(error) && !(error instanceof AgentHarnessPreflightError && error.scope === void 0) && (isCodexAppServerBrokenPipeError(error) || !spawnedBy);
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-start.ts
 async function startCodexAttemptRuntime(resources) {
 	const { prompt, state, trajectoryRecorder, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseAndRetireOneShotClient, releaseCurrentRoute, runCleanupStep, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
-	const { context, turnState, buildRenderedCodexDeveloperInstructions, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
+	const { context, turnState, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
 	const { runtime, attemptTools, promptState } = context;
 	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
 	const { toolBridge, toolState } = attemptTools;
 	const developerInstructions = joinPresentSections(turnState.promptBuild.developerInstructions, attemptTools.configuredMcp?.diagnosticNotice);
-	const { params, attemptClientFactory, bindingStore, appServer, pluginConfig, computerUseConfig, startupClientAuthProfileId, runtimeArtifactRequest, startupPreparedAuth, agentDir, sessionAgentId, effectiveWorkspace, effectiveCwd, sandbox, runAbortController, usesSupervisionConnection, resolveReviewerPolicyContext, resolveRuntimeOptionsForCurrentBinding, startupAuthProfileId, startupAuthRequirement, abortFromUpstream } = connection;
+	const { params, attemptClientFactory, bindingStore, appServer, pluginConfig, computerUseConfig, startupClientAuthProfileId, runtimeArtifactRequest, startupPreparedAuth, agentDir, sessionAgentId, effectiveWorkspace, effectiveCwd, sandbox, runAbortController, usesSupervisionConnection, resolveReviewerPolicyContext, resolveRuntimeOptionsForCurrentBinding, startupAuthProfileId, startupAuthRequirement } = connection;
 	let pluginAppServer = withCodexAppServerFastModeServiceTier(appServer, runtimeParams);
-	const loopDetectionEnabled = (sessionAgentId && params.config ? resolveAgentConfig$1(params.config, sessionAgentId)?.tools?.loopDetection?.enabled : void 0) ?? params.config?.tools?.loopDetection?.enabled ?? false;
+	const loopDetectionEnabled = (sessionAgentId && params.config ? resolveAgentConfig(params.config, sessionAgentId)?.tools?.loopDetection?.enabled : void 0) ?? params.config?.tools?.loopDetection?.enabled ?? false;
 	try {
 		emitCodexAppServerEvent(params, {
 			stream: "codex_app_server.lifecycle",
 			data: { phase: "startup" }
 		});
 		const startupResult = await startCodexAttemptThread({
+			assertCurrent: connection.assertCurrent,
 			attemptClientFactory,
 			bindingStore,
 			runtime: connection.options.runtime,
@@ -6342,6 +6759,7 @@ async function startCodexAttemptRuntime(resources) {
 		state.sandboxExecEnvironment = startupResult.sandboxEnvironment;
 		state.releaseSharedClientLease = startupResult.releaseSharedClientLease;
 		state.restartContextEngineCodexThread = startupResult.restartContextEngineCodexThread;
+		await attemptTools.captureCronCreatorToolAllowlist();
 		pluginAppServer = startupResult.pluginAppServer;
 		toolBridge.setRemoteWorkspaceFileReader?.(({ path, maxBytes, workspaceRoot, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
 			client: startupResult.client,
@@ -6389,7 +6807,7 @@ async function startCodexAttemptRuntime(resources) {
 				clientId: state.client.getInstanceId()
 			}
 		});
-		if (applyNoContextEngineContinuityProjection(state.thread.lifecycle.action, state.thread)) await rebuildCodexTurnPromptTextFromCurrentProjection();
+		if (await applyNoContextEngineContinuityProjection(state.thread.lifecycle.action, state.thread)) await rebuildCodexTurnPromptTextFromCurrentProjection();
 		trajectoryRecorder?.recordEvent("session.started", {
 			sessionFile: params.sessionFile,
 			threadId: state.thread.threadId,
@@ -6397,13 +6815,6 @@ async function startCodexAttemptRuntime(resources) {
 			workspaceDir: effectiveWorkspace,
 			toolCount: flattenCodexDynamicToolFunctions(toolBridge.specs).length
 		});
-		recordCodexTrajectoryContext(trajectoryRecorder, {
-			attempt: params,
-			cwd: effectiveCwd,
-			developerInstructions: joinPresentSections(buildRenderedCodexDeveloperInstructions(), attemptTools.configuredMcp?.diagnosticNotice),
-			prompt: turnState.codexTurnPromptText,
-			tools: toolBridge.availableSpecs
-		});
 		connection.mutable.pluginAppServer = pluginAppServer;
 	} catch (error) {
 		await runCleanupStep("codex-start-failure-hook-fallback", activateNativePreToolUseFailureFallback);
@@ -6413,7 +6824,6 @@ async function startCodexAttemptRuntime(resources) {
 		await runCleanupStep("codex-start-failure-native-hook-relay", () => nativeHookRelay?.unregister());
 		await runCleanupStep("codex-start-failure-sandbox-release", releaseSandboxExecEnvironment);
 		await runCleanupStep("codex-start-failure-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
-		await runCleanupStep("codex-start-failure-abort-listener", () => params.abortSignal?.removeEventListener("abort", abortFromUpstream));
 		throw error instanceof CodexThreadPolicyHandoffError ? error : state.executionDisconnectError ?? error;
 	}
 }
@@ -6424,15 +6834,14 @@ function isAuthorityResolutionOperationAbort(error, signal) {
 }
 async function prepareCodexAttemptTools(runtime) {
 	const { connection, bundleMcpThreadConfig, bundleManifestRegistry, runtimeParams, effectiveRuntimeModelId, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, hookChannelId, codexMcpToolOverrides, authenticatedScheduledMode, configuredMcpSurface, canResolveScheduledConfiguredMcpCreatorAuthority } = runtime;
-	const { params, preDynamicStartupStages, mutable, startupAuthProfileId, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, contextSessionKey, sandbox, sessionPermissionPolicy, runAbortController, sessionAgentId, policyAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
+	const { params, preDynamicStartupStages, mutable, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, contextSessionKey, sandbox, sessionPermissionPolicy, runAbortController, sessionAgentId, policyAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
 	const preDynamicSummary = preDynamicStartupStages.snapshot();
-	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(preDynamicSummary)}`, {
+	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary, profilerEnabled)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(preDynamicSummary)}`, {
 		runId: params.runId,
 		sessionId: params.sessionId,
 		totalMs: preDynamicSummary.totalMs,
 		stages: preDynamicSummary.stages,
 		hasStartupBinding: Boolean(mutable.startupBinding?.threadId),
-		startupAuthProfileId: startupAuthProfileId ?? null,
 		bundleMcpDiagnosticCount: bundleMcpThreadConfig.diagnostics.length,
 		nativeToolSurfaceEnabled
 	});
@@ -6495,7 +6904,6 @@ async function prepareCodexAttemptTools(runtime) {
 	const canResolveScheduledCodexAppAuthority = appCreatorCapture.supported;
 	const requiresScheduledCodexAppAuthority = appCreatorCapture.required;
 	const canResolveAnyScheduledCreatorAuthority = canResolveScheduledConfiguredMcpCreatorAuthority || requiresScheduledCodexAppAuthority;
-	let toolBridge;
 	let creatorAuthorityPromise;
 	let resolveCreatorAuthorityImpl;
 	const runtimeYieldCompletionClaim = {};
@@ -6516,8 +6924,9 @@ async function prepareCodexAttemptTools(runtime) {
 		pluginConfig,
 		profilerEnabled,
 		...params.cronCreatorAuthorityUnavailableReason === "queued-local-operator" && bundleMcpThreadConfig.staticServerNames.length > 0 ? { cronCreatorAuthorityUnavailableReason: "queued-local-operator-configured-mcp" } : {},
-		onYieldDetected: (acknowledgment) => {
+		onYieldDetected: (message, acknowledgment) => {
 			toolState.yieldDetected = true;
+			toolState.yieldMessage = message;
 			toolState.yieldAcknowledgment = acknowledgment;
 		},
 		claimYieldCompletion: () => runtimeYieldCompletionClaim.current?.() ?? false,
@@ -6540,8 +6949,9 @@ async function prepareCodexAttemptTools(runtime) {
 	let nativeSpecs;
 	if (hasCodexNativeToolCatalog(mutable.startupBinding)) {
 		runAbortController.signal.throwIfAborted();
-		params.hostCapabilities.assertActive();
+		connection.assertCurrent();
 		const client = await connection.attemptClientFactory({
+			assertCurrent: connection.assertCurrent,
 			startOptions: connection.appServer.start,
 			authProfileId: connection.startupClientAuthProfileId,
 			agentDir,
@@ -6556,16 +6966,20 @@ async function prepareCodexAttemptTools(runtime) {
 				agentDir,
 				assertCurrent: () => {
 					runAbortController.signal.throwIfAborted();
-					params.hostCapabilities.assertActive();
+					connection.assertCurrent();
 				}
 			});
 		} finally {
 			releaseLeasedSharedCodexAppServerClient(client);
 		}
 	}
+	let requireExplicitMessageTarget;
 	const tools = await buildDynamicTools({
 		...commonToolParams,
 		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
+		onMessageToolTargetResolved: (required) => {
+			requireExplicitMessageTarget = required;
+		},
 		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
 		cronCreatorToolAllowlistCaptureRef,
 		onPersistentWebSearchPolicyResolved: (allowed) => {
@@ -6588,7 +7002,7 @@ async function prepareCodexAttemptTools(runtime) {
 		sessionId: params.sessionId,
 		runId: params.runId,
 		agentId: policyAgentId,
-		agentDir: agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId),
+		agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
 		agentAccountId: params.agentAccountId,
 		messageProvider: params.messageProvider ?? params.messageChannel,
 		messageChannel: params.messageChannel,
@@ -6672,6 +7086,15 @@ async function prepareCodexAttemptTools(runtime) {
 		warn: (message) => embeddedAgentLog.warn(message)
 	}) : void 0;
 	let scopedMcpTools = void 0;
+	const disposeMcpTools = async () => {
+		for (const [step, materialized] of [["codex-scoped-mcp-dispose", scopedMcpTools], ["codex-configured-mcp-dispose", configuredMcp]]) await runAgentCleanupStep({
+			runId: params.runId,
+			sessionId: params.sessionId,
+			step,
+			log: embeddedAgentLog,
+			cleanup: async () => materialized?.dispose()
+		});
+	};
 	try {
 		scopedMcpTools = authenticatedScheduledMode ? void 0 : await materializeRequesterScopedMcpToolsForHarnessRun({
 			sessionId: params.sessionId,
@@ -6722,27 +7145,24 @@ async function prepareCodexAttemptTools(runtime) {
 			...params.agentAccountId ? { turnSourceAccountId: params.agentAccountId } : {},
 			...params.currentThreadTs !== void 0 ? { turnSourceThreadId: params.currentThreadTs } : {}
 		};
-		toolBridge = createCodexDynamicToolBridge({
+		const toolBridge = createCodexDynamicToolBridge({
 			tools: toolsWithScopedMcp,
 			registeredTools: registeredWithScopedMcp,
 			registeredSpecs: nativeSpecs,
 			signal: runAbortController.signal,
 			computerContextEpoch,
 			loading: resolveCodexDynamicToolsLoadingForRuntime(pluginConfig, effectiveRuntimeModelId, { connectionClass: connection.appServer.connectionClass }),
-			directToolNames: resolveCodexDynamicToolDirectNames(params, isHostScopedAgentToolActive("openclaw")),
+			directToolNames: resolveCodexDynamicToolDirectNames(params, registeredWithScopedMcp, isHostScopedAgentToolActive("openclaw")),
 			hookContext
 		});
-		await captureFinalCodexCronCreatorToolAllowlist(cronCreatorToolAllowlist, cronCreatorToolAllowlistCaptureRef, toolBridge.availableTools);
-		if (!authenticatedScheduledMode && bundleMcpThreadConfig.staticServerNames.length > 0 && !canResolveScheduledConfiguredMcpCreatorAuthority) delete cronCreatorToolAllowlistCaptureRef.value;
-		if (requiresScheduledCodexAppAuthority) delete cronCreatorToolAllowlistCaptureRef.value;
+		const captureCronCreatorToolAllowlist = async () => {
+			await captureFinalCodexCronCreatorToolAllowlist(cronCreatorToolAllowlist, cronCreatorToolAllowlistCaptureRef, toolBridge.availableTools, { nativeToolSurfaceEnabled });
+			if (!authenticatedScheduledMode && bundleMcpThreadConfig.staticServerNames.length > 0 && !canResolveScheduledConfiguredMcpCreatorAuthority) delete cronCreatorToolAllowlistCaptureRef.value;
+			if (requiresScheduledCodexAppAuthority) delete cronCreatorToolAllowlistCaptureRef.value;
+		};
 		if (canResolveAnyScheduledCreatorAuthority) resolveCreatorAuthorityImpl = async (options) => {
 			options?.signal?.throwIfAborted();
 			if (codexAppAuthorityUnavailableReason) throw new Error(codexAppAuthorityUnavailableReason);
-			if (!toolBridge) throw new Error("cron creator authority resolver lost the active tool bridge");
-			const authorityTools = [];
-			const captureRef = {};
-			await captureFinalCodexCronCreatorToolAllowlist(authorityTools, captureRef, toolBridge.availableTools);
-			if (!captureRef.value) throw new Error("cron creator authority snapshot did not produce provenance");
 			const appSource = scheduledAppAuthoritySourceRef.current;
 			const runtimeAuthority = canResolveScheduledCodexAppAuthority && scheduledCodexAppAuth ? appSource ? await captureScheduledCodexAppAuthority({
 				...appSource,
@@ -6751,46 +7171,39 @@ async function prepareCodexAttemptTools(runtime) {
 			}) : (() => {
 				throw new Error("Codex app authority is unavailable before the exact creator thread is active. Retry this automation mutation from the current owner turn.");
 			})() : void 0;
-			if (!canResolveScheduledConfiguredMcpCreatorAuthority) {
-				options?.signal?.throwIfAborted();
-				return Object.freeze({
-					tools: Object.freeze(authorityTools.map((entry) => Object.freeze(entry))),
-					provenance: Object.freeze(captureRef.value),
-					...runtimeAuthority ? { runtimeAuthority } : {}
-				});
-			}
-			const authorityRuntimeId = `cron-authority:${params.runId}`;
 			let materialized;
 			try {
-				materialized = await materializeStaticMcpToolsForHarnessRun({
-					sessionId: authorityRuntimeId,
-					agentId: sessionAgentId,
-					workspaceDir: effectiveWorkspace,
-					agentDir: policyContext.agentDir,
-					cfg: params.config,
-					manifestRegistry: bundleManifestRegistry,
-					reservedToolNames: toolBridge.availableTools.map((tool) => tool.name),
-					toolsAllow: params.toolsAllow,
-					toolOverrides: codexMcpToolOverrides,
-					autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
-					projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
-					policyContext,
-					warn: (message) => embeddedAgentLog.warn(message),
-					retireSessionRuntimeAfterDispose: true
-				});
-			} catch (error) {
-				const detail = error instanceof Error ? error.message : String(error);
-				throw new Error(`Configured MCP discovery failed while resolving inherited automation authority: ${detail}. Retry after the server is available, or provide an explicit finite toolsAllow list containing only currently visible tools; no automation changes were saved.`, { cause: error });
-			}
-			try {
+				if (canResolveScheduledConfiguredMcpCreatorAuthority) try {
+					materialized = await materializeStaticMcpToolsForHarnessRun({
+						sessionId: `cron-authority:${params.runId}`,
+						agentId: sessionAgentId,
+						workspaceDir: effectiveWorkspace,
+						agentDir: policyContext.agentDir,
+						cfg: params.config,
+						manifestRegistry: bundleManifestRegistry,
+						reservedToolNames: toolBridge.availableTools.map((tool) => tool.name),
+						toolsAllow: params.toolsAllow,
+						toolOverrides: codexMcpToolOverrides,
+						autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
+						projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
+						policyContext,
+						warn: (message) => embeddedAgentLog.warn(message),
+						retireSessionRuntimeAfterDispose: true
+					});
+				} catch (error) {
+					const detail = error instanceof Error ? error.message : String(error);
+					throw new Error(`Configured MCP discovery failed while resolving inherited automation authority: ${detail}. Retry after the server is available, or provide an explicit finite toolsAllow list containing only currently visible tools; no automation changes were saved.`, { cause: error });
+				}
 				options?.signal?.throwIfAborted();
-				if (materialized.diagnosticNotice) throw new Error(`${materialized.diagnosticNotice} Sign in to the affected MCP server and retry, or provide an explicit finite toolsAllow list containing only currently visible tools. No automation changes were saved.`);
-				const projectedConfiguredMcp = projectCodexExecutableDynamicTools({
+				if (materialized?.diagnosticNotice) throw new Error(`${materialized.diagnosticNotice} Sign in to the affected MCP server and retry, or provide an explicit finite toolsAllow list containing only currently visible tools. No automation changes were saved.`);
+				const configuredTools = materialized ? projectCodexExecutableDynamicTools({
 					tools: filterCodexDynamicTools(materialized.tools, pluginConfig),
 					hookContext
-				});
-				await captureFinalCodexCronCreatorToolAllowlist(authorityTools, captureRef, [...toolBridge.availableTools, ...projectedConfiguredMcp.availableTools]);
-				if (!captureRef.value) throw new Error("configured MCP authority snapshot did not produce provenance");
+				}).availableTools : [];
+				const authorityTools = [];
+				const captureRef = {};
+				await captureFinalCodexCronCreatorToolAllowlist(authorityTools, captureRef, [...toolBridge.availableTools, ...configuredTools], { nativeToolSurfaceEnabled });
+				if (!captureRef.value) throw new Error("cron creator authority snapshot did not produce provenance");
 				options?.signal?.throwIfAborted();
 				return Object.freeze({
 					tools: Object.freeze(authorityTools.map((entry) => Object.freeze(entry))),
@@ -6798,17 +7211,18 @@ async function prepareCodexAttemptTools(runtime) {
 					...runtimeAuthority ? { runtimeAuthority } : {}
 				});
 			} finally {
-				await materialized.dispose();
+				await materialized?.dispose();
 			}
 		};
 		return {
 			tools: toolsWithScopedMcp,
 			registeredTools: registeredWithScopedMcp,
+			requireExplicitMessageTarget,
 			scopedMcpTools,
 			configuredMcp,
+			disposeMcpTools,
 			configuredMcpOwnershipVersion: configuredMcpSurface === "scheduled" ? 1 : void 0,
-			cronCreatorToolAllowlist,
-			cronCreatorToolAllowlistCaptureRef,
+			captureCronCreatorToolAllowlist,
 			scheduledAppAuthoritySourceRef,
 			dynamicToolParams,
 			compactionPlanState,
@@ -6823,8 +7237,7 @@ async function prepareCodexAttemptTools(runtime) {
 			runtimeYieldCompletionClaim
 		};
 	} catch (error) {
-		await scopedMcpTools?.dispose();
-		await configuredMcp?.dispose();
+		await disposeMcpTools();
 		throw error;
 	}
 }
@@ -6907,11 +7320,22 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		error.name = "AbortError";
 		throw error;
 	};
+	const prepareWorkspaceReferences = () => {
+		const references = prepareCodexWorkspaceReferences(resourceState.client, resourceState.thread.threadId, workspaceBootstrapContext.promptContext);
+		prompt.refreshWorkspaceReferences(references.include);
+		return references;
+	};
 	const startCodexTurn = async () => {
 		const activeTurnRoute = await ensureCurrentThreadRoute();
+		assertCodexSessionRuntimeOwnership(resourceState.thread, params.expectedSessionRuntimeOwnership);
 		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, runtimeParams);
 		connection.mutable.pluginAppServer = turnAppServer;
-		const turnStartParams = buildTurnStartParams(runtimeParams, {
+		const references = prepareWorkspaceReferences();
+		const referencesRetained = turnState.codexTurnPromptText.includes(workspaceBootstrapContext.promptContext ?? "");
+		const turnStartParams = buildTurnStartParams({
+			...runtimeParams,
+			images: [...prompt.contextImages, ...runtimeParams.images ?? []]
+		}, {
 			threadId: resourceState.thread.threadId,
 			cwd: resourceState.codexExecutionCwd,
 			appServer: turnAppServer,
@@ -6928,9 +7352,18 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			skillsCollaborationInstructions: context.skillsCollaborationInstructions,
 			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
 			preserveNativeTurnSettings: usesSupervisionConnection,
+			messageToolAvailable: toolBridge.availableTools.some((tool) => tool.name === "message"),
+			requireExplicitMessageTarget: attemptTools.requireExplicitMessageTarget,
 			sessionStatusAvailable: toolBridge.availableTools.some((tool) => tool.name === "session_status")
 		});
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
+		recordCodexTrajectoryContext(resources.trajectoryRecorder, {
+			attempt: params,
+			cwd: connection.effectiveCwd,
+			developerInstructions: joinPresentSections(buildRenderedCodexDeveloperInstructions(), attemptTools.configuredMcp?.diagnosticNotice),
+			prompt: turnState.codexTurnPromptText,
+			tools: toolBridge.availableSpecs
+		});
 		state.latestStartupErrorNotification = void 0;
 		state.rateLimitsRevisionBeforeLastTurnStart = readCodexRateLimitsRevision(resourceState.client);
 		activeTurnRoute.armTurn();
@@ -6949,9 +7382,12 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		try {
 			const startedTurn = assertCodexTurnStartResponse(await resourceState.client.request("turn/start", turnStartParams, {
 				timeoutMs: params.timeoutMs,
-				signal: runAbortController.signal
+				signal: runAbortController.signal,
+				assertCurrent: connection.assertCurrent
 			}));
 			acceptedTurnId = startedTurn.turn.id;
+			connection.assertCurrent();
+			if (referencesRetained) references.accepted();
 			throwIfTurnStartAcceptedAfterAbort();
 			return startedTurn;
 		} catch (error) {
@@ -6980,6 +7416,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		if (await waitForActiveNativeTurnCompletion()) await resourceState.turnRoute?.drain();
 		else if (!runAbortController.signal.aborted) embeddedAgentLog.warn("codex app-server active native turn did not complete before turn/start wait timed out", { threadId: resourceState.thread.threadId });
 	}
+	prepareWorkspaceReferences();
 	const buildLlmInputEvent = () => ({
 		runId: params.runId,
 		sessionId: params.sessionId,
@@ -6988,7 +7425,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		systemPrompt: buildRenderedCodexDeveloperInstructions(),
 		prompt: turnState.codexTurnPromptText,
 		historyMessages: prompt.codexModelInputHistoryMessages,
-		imagesCount: params.images?.length ?? 0,
+		imagesCount: prompt.contextImages.length + (params.images?.length ?? 0),
 		tools
 	});
 	return {
@@ -7004,7 +7441,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 	const { context, turnState, systemPromptReport } = prompt;
 	const { runtime, historyState, hookContext, hookContextWindowFields, hookRunner } = context;
 	const { connection, runtimeParams, effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
-	const { params, usesSupervisionConnection, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, attemptStartedAt, startupAuthProfileId, abortFromUpstream } = connection;
+	const { params, usesSupervisionConnection, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, attemptStartedAt, startupAuthProfileId } = connection;
 	const { state, turnIdRef } = turnRuntime;
 	const { waitForActiveNativeTurnCompletion } = notifications;
 	const { codexModelCallDiagnostics, startCodexTurn, buildLlmInputEvent } = requestRuntime;
@@ -7040,52 +7477,51 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			error: turnStartError,
 			contextEngineActive: Boolean(activeContextEngine),
 			thread: resourceState.thread
-		}) && resourceState.restartContextEngineCodexThread) {
+		}) && resourceState.restartContextEngineCodexThread) try {
+			assertCodexBindingMayBeReplaced(resourceState.thread, "retrying an overflow on a fresh native thread", params.expectedSessionRuntimeOwnership);
 			embeddedAgentLog.warn("codex app-server context-engine turn overflowed on resume; retrying with fresh thread", {
 				threadId: resourceState.thread.threadId,
 				error: formatErrorMessage(turnStartError)
 			});
-			try {
-				if (!await bindingStore.mutate(bindingIdentity, {
-					kind: "clear",
-					threadId: resourceState.thread.threadId
-				})) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
-					threadId: resourceState.thread.threadId,
-					error: formatErrorMessage(turnStartError)
-				});
-				else {
-					resourceState.thread = await resourceState.restartContextEngineCodexThread();
-					const retryBinding = await bindingStore.read(bindingIdentity);
-					if (retryBinding && retryBinding.threadId === resourceState.thread.threadId && retryBinding.contextEngine?.projection) {
-						await bindingStore.mutate(bindingIdentity, {
-							kind: "patch",
-							threadId: retryBinding.threadId,
-							patch: { contextEngine: {
-								...retryBinding.contextEngine,
-								projection: void 0
-							} }
-						});
-						embeddedAgentLog.info("codex app-server cleared stale context-engine projection after overflow retry", {
-							threadId: resourceState.thread.threadId,
-							previousEpoch: retryBinding.contextEngine.projection.epoch
-						});
-					}
-					emitCodexAppServerEvent(params, {
-						stream: "codex_app_server.lifecycle",
-						data: {
-							phase: "thread_ready_retry",
-							threadId: resourceState.thread.threadId
-						}
+			if (!await bindingStore.mutate(bindingIdentity, {
+				kind: "clear",
+				threadId: resourceState.thread.threadId
+			})) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
+				threadId: resourceState.thread.threadId,
+				error: formatErrorMessage(turnStartError)
+			});
+			else {
+				resourceState.thread = await resourceState.restartContextEngineCodexThread();
+				const retryBinding = bindingStore.read(bindingIdentity);
+				if (retryBinding && retryBinding.threadId === resourceState.thread.threadId && retryBinding.contextEngine?.projection) {
+					await bindingStore.mutate(bindingIdentity, {
+						kind: "patch",
+						threadId: retryBinding.threadId,
+						patch: { contextEngine: {
+							...retryBinding.contextEngine,
+							projection: void 0
+						} }
 					});
-					try {
-						turn = await startCodexTurn();
-					} catch (retryError) {
-						turnStartError = retryError;
+					embeddedAgentLog.info("codex app-server cleared stale context-engine projection after overflow retry", {
+						threadId: resourceState.thread.threadId,
+						previousEpoch: retryBinding.contextEngine.projection.epoch
+					});
+				}
+				emitCodexAppServerEvent(params, {
+					stream: "codex_app_server.lifecycle",
+					data: {
+						phase: "thread_ready_retry",
+						threadId: resourceState.thread.threadId
 					}
+				});
+				try {
+					turn = await startCodexTurn();
+				} catch (retryError) {
+					turnStartError = retryError;
 				}
-			} catch (retrySetupError) {
-				turnStartError = retrySetupError;
 			}
+		} catch (retrySetupError) {
+			turnStartError = retrySetupError;
 		}
 		if (turn === void 0) {
 			const usageLimitError = await formatCodexTurnStartUsageLimitError({
@@ -7101,7 +7537,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				phase: "turn_start",
 				threadId: resourceState.thread.threadId,
 				error: message
-			});
+			}, params.expectedSessionRuntimeOwnership);
 			emitCodexAppServerEvent(params, {
 				stream: "codex_app_server.lifecycle",
 				data: {
@@ -7180,7 +7616,6 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				log: embeddedAgentLog,
 				cleanup: async () => trajectoryRecorder?.flush()
 			});
-			params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 			await releaseSharedClientLeaseAndRetireOneShotClient();
 			if (usageLimitError) {
 				await markCodexAuthProfileBlockedFromRateLimits({
@@ -7191,7 +7626,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				return { result: buildCodexTurnStartFailureResult({
 					params,
 					message: usageLimitError.message,
-					promptError: createCodexUsageLimitPromptError(usageLimitError.message),
+					promptError: new CodexUsageLimitPromptError(usageLimitError.message),
 					messagesSnapshot,
 					systemPromptReport
 				}) };
@@ -7299,6 +7734,8 @@ function createCodexAttemptTurnState(resources) {
 		terminalTurnNotificationQueued: false,
 		sawCodexInterruptMarker: false,
 		timeout: void 0,
+		settlementWarning: void 0,
+		pendingSettlementStage: void 0,
 		clientClosedPromptError: void 0,
 		clientClosedDiagnostic: void 0,
 		clientClosedAbort: false,
@@ -7314,6 +7751,7 @@ function createCodexAttemptTurnState(resources) {
 		currentTurnHadNonTerminalDynamicToolResult: false
 	};
 	const { promise: completion, resolve: resolveCompletion } = createDeferred();
+	const settlementExpired = createDeferred();
 	const pendingOpenClawDynamicToolCompletionIds = /* @__PURE__ */ new Set();
 	const openClawDynamicToolExecutions = createCodexDynamicToolExecutionRegistry();
 	const activeTurnItemIds = /* @__PURE__ */ new Set();
@@ -7374,13 +7812,32 @@ function createCodexAttemptTurnState(resources) {
 		signal: runAbortController.signal,
 		onDeadlineChanged: params.onAttemptDeadlineChanged,
 		onTimeout: (timeout) => {
+			const pendingStage = state.pendingSettlementStage ?? projectorRef.current?.settlement.pendingStage ?? "notification_queue";
+			if (timeout.kind === "settlement" && projectorRef.current?.recoverCompletedAnswer()) {
+				state.settlementWarning = {
+					pendingStage,
+					elapsedMs: timeout.elapsedMs,
+					timeoutMs: timeout.timeoutMs
+				};
+				state.projectionClosed = true;
+				trajectoryRecorder?.recordEvent("turn.settlement_warning", {
+					threadId: resourceState.thread.threadId,
+					turnId: turnIdRef.current,
+					...state.settlementWarning
+				});
+				embeddedAgentLog.warn("codex app-server retaining completed answer after settlement expiry", state.settlementWarning);
+				completeTurn();
+				settlementExpired.resolve();
+				return;
+			}
 			state.timeout = timeout;
 			projectorRef.current?.markTimedOut();
 			const error = /* @__PURE__ */ new Error(timeout.kind === "execution" ? "codex app-server execution budget timed out" : "codex app-server terminal settlement timed out");
 			const fields = {
 				threadId: resourceState.thread.threadId,
 				turnId: turnIdRef.current,
-				...timeout
+				...timeout,
+				pendingStage
 			};
 			trajectoryRecorder?.recordEvent(`turn.${timeout.kind}_timeout`, fields);
 			embeddedAgentLog.warn(error.message, fields);
@@ -7391,6 +7848,7 @@ function createCodexAttemptTurnState(resources) {
 	return {
 		state,
 		completion,
+		settlementExpired: settlementExpired.promise,
 		pendingOpenClawDynamicToolCompletionIds,
 		openClawDynamicToolExecutions,
 		activeTurnItemIds,
@@ -7407,35 +7865,47 @@ function createCodexAttemptTurnState(resources) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt.ts
 async function runCodexAppServerAttempt(params, options) {
-	const connection = await prepareCodexAttemptConnection({
+	const preparation = createCodexAttemptPreparationTiming(params);
+	const connection = await preparation.measure("connection", () => prepareCodexAttemptConnection({
 		params,
 		options
-	});
-	const runtime = await prepareCodexAttemptRuntime(connection);
-	const attemptTools = await prepareCodexAttemptTools(runtime);
-	const resources = prepareCodexAttemptResources(await prepareCodexAttemptPrompt(await prepareCodexAttemptContext(runtime, attemptTools)));
-	attemptTools.runtimeYieldCompletionClaim.current = () => resources.state.nativeHookRelay?.hasClaimedDirectChild() ?? false;
-	await startCodexAttemptRuntime(resources);
-	const turnRuntime = createCodexAttemptTurnState(resources);
+	}));
 	try {
-		const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
-		const notifications = createCodexAttemptNotificationController(resources, turnRuntime, lifecycle);
-		const { ensureCurrentThreadRoute } = await prepareCodexAttemptRoute(resources, turnRuntime, notifications, createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle).handleServerRequest);
-		const turnRequest = await prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, notifications.waitForActiveNativeTurnCompletion);
-		const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
-		if ("result" in turnStart) return turnStart.result;
-		const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart.turn);
-		let finalizedResult;
+		const runtime = await preparation.measure("runtime", () => prepareCodexAttemptRuntime(connection));
+		const attemptTools = await preparation.measure("tools", () => prepareCodexAttemptTools(runtime));
 		try {
-			await activeTurn.ready;
-			finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
+			const attemptContext = await preparation.measure("context", () => prepareCodexAttemptContext(runtime, attemptTools));
+			const resources = prepareCodexAttemptResources(await preparation.measure("prompt", () => prepareCodexAttemptPrompt(attemptContext)));
+			attemptTools.runtimeYieldCompletionClaim.current = () => resources.state.nativeHookRelay?.hasClaimedDirectChild() ?? false;
+			await preparation.measure("runtime-start", () => startCodexAttemptRuntime(resources));
+			const turnRuntime = createCodexAttemptTurnState(resources);
+			try {
+				const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
+				const notifications = createCodexAttemptNotificationController(resources, turnRuntime, lifecycle);
+				const serverRequests = createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle);
+				const { ensureCurrentThreadRoute } = await preparation.measure("thread-route", () => prepareCodexAttemptRoute(resources, turnRuntime, notifications, serverRequests.handleServerRequest));
+				const turnRequest = await preparation.measure("turn-request", () => prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, notifications.waitForActiveNativeTurnCompletion));
+				preparation.ready();
+				const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
+				if ("result" in turnStart) return turnStart.result;
+				const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart.turn);
+				let finalizedResult;
+				try {
+					await activeTurn.ready;
+					finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
+				} finally {
+					await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
+				}
+				if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
+				return finalizedResult;
+			} finally {
+				turnRuntime.deadlines.dispose();
+			}
 		} finally {
-			await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
+			await attemptTools.disposeMcpTools();
 		}
-		if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
-		return finalizedResult;
 	} finally {
-		turnRuntime.deadlines.dispose();
+		params.abortSignal?.removeEventListener("abort", connection.abortFromUpstream);
 	}
 }
 //#endregion