@openclaw/codex 2026.9.1 → 2026.9.2

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

@@ -1,41 +1,43 @@
-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 } from "./session-binding-record-CyaXZvTe.js";
+import { A as resolveOpenClawExecPolicyForCodexAppServer, B as isJsonObject, D as isCodexSandboxExecServerEnabled, E as isCodexRemoteExecPlacementSandbox, M as resolveCodexAppServerHomeDir, O as readCodexPluginConfig, T as isCodexPairedNodeRemoteExecPlacementSandbox, d as shouldAutoApproveCodexAppServerApprovals, f as withMcpElicitationsApprovalPolicy, h as resolveCodexModelBackedReviewerPolicyContext, k as resolveCodexPluginsPolicy, l as hasCodexMcpToolApprovalOverrides, m as canUseCodexModelBackedApprovalsReviewerForModel, o as resolveCodexComputerUseConfig, r as resolveCodexAppServerHomeScope, y as readCodexRequirementsToml, z as flattenCodexDynamicToolFunctions } from "./config-CyapYSji.js";
+import { A as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, B as isCodexAppServerIndeterminateRequestCancellationError, Bt as resolveCodexAppServerAuthAccountCacheKey, F as withCodexStartupTimeout, Gt as resolveCodexAppServerPreparedApiKeyCacheKey, H as isCodexAppServerOverloadError, Ht as resolveCodexAppServerAuthProfileIdForAgent, I as getCodexAppServerClientInstanceId, It as readCodexRateLimitsRevision, K as resolveCodexAppServerClientInstanceId, Kt as resolveCodexAppServerPreparedAuthHandoff, L as isCodexAppServerApprovalRequest, Lt as readRecentCodexRateLimits, M as isCodexAppServerStartupError, P as resolveCodexStartupTimeoutMs, Pt as withAbortableTimeout, R as isCodexAppServerBrokenPipeError, Rt as rememberCodexRateLimitsRead, Tt as ensureCodexAppServerClientRuntime, V as isCodexAppServerIndeterminateTransportError, Vt as resolveCodexAppServerAuthProfileId, W as isCodexAppServerRequestTimeoutError, Wt as resolveCodexAppServerFallbackApiKeyCacheKey, _t as toCodexDynamicToolProgressResponse, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, ct as createCodexElicitationResponse, dt as isDynamicToolTerminalDiagnosticEvent, f as readCodexAppServerClientDesktopGenerationFingerprint, ft as isMatchingDynamicToolTerminalDiagnostic, gt as shouldReleaseTurnAfterTerminalDynamicTool, h as releaseLeasedSharedCodexAppServerClient, ht as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, i as clearSharedCodexAppServerClientIfCurrent, it as readCodexDynamicToolCallParams, j as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, k as CodexAppServerStartupError, kt as protectCodexAppServerLiveThread, l as getSharedCodexAppServerClient, lt as handleDynamicToolCallWithTimeout, mt as resolveTerminalDynamicToolBatchAction, ot as readCodexTurn, pt as resolveDynamicToolCallTimeoutMs, q as CodexAppServerRpcError, rt as assertCodexTurnStartResponse, s as createIsolatedCodexAppServerClient, st as readCodexTurnCompletedNotification, u as isCodexAppServerStartSelectionChangedError, ut as hasPendingDynamicToolTerminalDiagnostic, v as retainSharedCodexAppServerClientIfCurrent, vt as toCodexDynamicToolProtocolResponse, y as retireSharedCodexAppServerClientIfCurrent, yt as resolveCodexToolAbortTerminalReason, z as isCodexAppServerConnectionClosedError } from "./shared-client-CKhX2kFt.js";
+import { c as resolveCodexRunSessionBindingAuthority, l as resolveCodexSessionBinding, n as assertCodexBindingMayBeReplaced, r as createCodexSessionGenerationSupersededError, u as scopeCodexRunBindingStore } from "./session-binding-4Ki04sW-.js";
+import { E as itemStatus, 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, 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-Bp1ZOnk2.js";
+import { a as isCodexTurnAbortMarkerNotification, d as readNotificationItemId, f as readRawResponseToolCallId, l as isTerminalTurnStatus, o as isPendingOpenClawDynamicToolCompletionNotification, p as updateActiveTurnItemIds, r as codexExecutionToolName, s as isRawFunctionToolOutputCompletionNotification, t as CodexUsageProjection, u as readCodexNotificationItem } from "./event-projector-usage-ZqEVbAEY.js";
+import { c as defaultCodexAppInventoryCache, i as buildCodexPluginAppCacheKey, r as buildCodexAppServerRuntimeFingerprint } from "./thread-resume-BLgqkUc1.js";
+import { A as readCodexMcpToolConnectorId, B as emitCodexNativePreToolUseFailureDiagnostic, C as buildDeveloperInstructions, Ct as buildCodexPluginThreadConfigInputFingerprint, D as resolveCodexAppServerThreadModelSelection, Et 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, St as buildCodexPluginThreadConfig, 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 buildCodexPluginThreadConfigTimeoutFallback, xt as resolveCodexContinuityProjectionMaxChars, yt as resolveCodexContextEngineProjectionMaxChars, z as createCodexNativeHookRelay } from "./thread-lifecycle-DPK30jad.js";
+import { l as isIncognitoSessionKey, r as retainCodexAppServerBindingSubscription } from "./thread-ownership-CbucAmmp.js";
+import { a as assertCodexSessionRuntimeOwnership, n as CodexThreadPolicyHandoffError, s as resolveCodexBindingAppServerConnection } from "./thread-policy-CTalhWFy.js";
+import { a as buildCodexUserPromptMessage, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-_njEB84z.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 { a as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-Byl34PC-.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-B1mgvpP8.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-Fx_l4eNa.js";
+import { a as formatCodexDisplayText } from "./command-formatters-DSbGMXA0.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BaueHmSj.js";
 import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Ds_QVm-X.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-B9kp6iGC.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-BwpvTxaX.js";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-BpG9Ltc5.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-B3bvQGcg.js";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-aQVdyL5g.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-CSazkWns.js";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-BOM3Y1pl.js";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-BwCLTY_U.js";
 import { asOptionalRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+import { resolveAgentConfig, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
+import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 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 { 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, resolveAgentDir as resolveAgentDir$1, 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 { 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 { isDeepStrictEqual } from "node:util";
+import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$2 } from "openclaw/plugin-sdk/agent-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";
@@ -49,6 +51,48 @@ import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generat
 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";
+//#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 +174,61 @@ 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;
 			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 +255,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 +264,7 @@ function createCodexSteeringQueue(params) {
 		});
 		const item = {
 			...options,
+			assertCurrent,
 			acceptance: "open",
 			text,
 			resolve: resolveDelivery,
@@ -204,14 +280,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);
@@ -320,6 +397,7 @@ var CodexAssistantProjection = class {
 		this.emitAgentEvent({
 			stream: "assistant",
 			data: {
+				itemId,
 				...streamPayload,
 				...replaceable ? { replaceable: true } : {}
 			}
@@ -1055,12 +1133,11 @@ function buildCodexAttemptResult(input) {
 	const commentaryMessages = input.assistantProjection.collectCommentaryMessages();
 	const reasoningText = input.reasoningProjection.reasoningText();
 	const planText = input.reasoningProjection.planText();
-	const unavailableThreadUsage = input.tokenUsage ? {
-		...input.tokenUsage,
+	const usage = input.usageProjection.usage;
+	const projectedUsage = input.aborted && usage ? {
+		...usage,
 		contextUsage: { state: "unavailable" }
-	} : void 0;
-	const completedUsage = input.responseCompletions.usage ?? (input.responseCompletions.modelIterations > 0 ? unavailableThreadUsage : input.tokenUsage);
-	const projectedUsage = input.aborted ? unavailableThreadUsage : completedUsage;
+	} : usage;
 	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);
@@ -1077,10 +1154,11 @@ function buildCodexAttemptResult(input) {
 	const assistantMessageOptions = {
 		tokenUsage: projectedUsage,
 		aborted: input.aborted,
-		promptError: input.promptError
+		promptError: input.promptError,
+		providerRefusal: input.providerRefusal
 	};
-	const lastAssistant = assistantTexts.length ? input.assistantProjection.createAssistantMessage(assistantTexts.join("\n\n"), assistantMessageOptions) : void 0;
-	const currentAttemptAssistant = input.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
+	const lastAssistant = input.providerRefusal ? input.assistantProjection.createAssistantMessage("", assistantMessageOptions) : assistantTexts.length ? input.assistantProjection.createAssistantMessage(assistantTexts.join("\n\n"), assistantMessageOptions) : void 0;
+	const currentAttemptAssistant = input.providerRefusal ? lastAssistant : input.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
 	const messagesSnapshot = buildCodexMessagesSnapshot({
 		runParams: input.runParams,
 		turnId: input.turnId,
@@ -1092,8 +1170,8 @@ function buildCodexAttemptResult(input) {
 		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({
+	const promptError = input.providerRefusal ? null : input.promptError ?? storedMissingToolResultError ?? (turnFailed ? input.completedTurn?.error?.message ?? "codex app-server turn failed" : null);
+	const agentHarnessResultClassification = input.providerRefusal ? void 0 : classifyAgentHarnessTerminalOutcome({
 		assistantTexts,
 		reasoningText,
 		planText,
@@ -1115,7 +1193,7 @@ function buildCodexAttemptResult(input) {
 		...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
 		bootstrapPromptWarningSignaturesSeen: input.runParams.bootstrapPromptWarningSignaturesSeen,
 		bootstrapPromptWarningSignature: input.runParams.bootstrapPromptWarningSignature,
-		...input.responseCompletions.modelIterations > 0 ? { modelIterations: input.responseCompletions.modelIterations } : {},
+		...input.usageProjection.modelIterations > 0 ? { modelIterations: input.usageProjection.modelIterations } : {},
 		messagesSnapshot,
 		assistantTexts,
 		toolMetas,
@@ -1124,6 +1202,7 @@ function buildCodexAttemptResult(input) {
 		...input.toolProgressProjection.lastToolError ? { lastToolError: input.toolProgressProjection.lastToolError } : {},
 		didSendViaMessagingTool: input.toolTelemetry.didSendViaMessagingTool,
 		didDeliverSourceReplyViaMessageTool: input.toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
+		sourceReplyDelivered: input.toolTelemetry.sourceReplyDelivered,
 		messagingToolSentTexts: input.toolTelemetry.messagingToolSentTexts,
 		messagingToolSentMediaUrls: input.toolTelemetry.messagingToolSentMediaUrls,
 		messagingToolSentTargets: input.toolTelemetry.messagingToolSentTargets,
@@ -1156,93 +1235,39 @@ function buildCodexAttemptResult(input) {
 	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 === "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,6 +1393,95 @@ function readCodexErrorPayload(error) {
 	};
 }
 //#endregion
+//#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.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/event-projector.ts
 var CodexAppServerEventProjector = class {
 	constructor(params, threadId, turnId, options = {}) {
@@ -1378,14 +1492,12 @@ 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.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.transcriptCheckpoint = new CodexTranscriptCheckpoint(params, threadId, turnId);
 		this.asyncDeliveryProjection = new CodexAsyncDeliveryProjection(params, threadId, turnId, options);
@@ -1446,9 +1558,7 @@ var CodexAppServerEventProjector = class {
 	}
 	/** 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);
@@ -1513,23 +1623,23 @@ 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);
@@ -1539,17 +1649,19 @@ var CodexAppServerEventProjector = class {
 				this.eventProjection.handleModelRerouted(params);
 				break;
 			case "error": {
-				this.responseCompletions.clear();
+				this.usageProjection.invalidateContext();
 				if (params.willRetry === true) break;
 				const codexErrorInfo = isJsonObject(params.error) ? params.error.codexErrorInfo : void 0;
+				const message = readCodexErrorNotificationMessage(params);
 				const compactionFailure = codexErrorInfo === "other" && this.isCompacting();
 				this.settledTurnFailureFinalizationAllowed = codexErrorInfo === "serverOverloaded" || compactionFailure;
-				this.promptError = resolveCodexPromptError({
-					message: readCodexErrorNotificationMessage(params),
+				this.terminalFailure.record({
+					message,
 					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":
@@ -1573,15 +1685,15 @@ var CodexAppServerEventProjector = class {
 			turnId: this.turnId,
 			upstreamUserText: this.options.upstreamUserText,
 			completedTurn: this.completedTurn,
-			promptError: this.promptError,
-			promptErrorSource: this.promptErrorSource,
+			promptError: this.terminalFailure.promptError,
+			promptErrorSource: this.terminalFailure.promptErrorSource,
+			providerRefusal: this.terminalFailure.providerRefusal,
 			synthesizedMissingToolResultError: this.synthesizedMissingToolResultError,
 			recordSynthesizedMissingToolResultError: (error) => {
 				this.synthesizedMissingToolResultError = error;
-				this.promptErrorSource = this.promptErrorSource ?? "prompt";
+				this.terminalFailure.promptErrorSource ??= "prompt";
 			},
 			aborted: this.aborted,
-			tokenUsage: this.tokenUsage,
 			contextTokens: this.contextTokens,
 			contextTokensSource: this.contextTokensSource,
 			completedCompactionCount: this.completedCompactionCount,
@@ -1593,7 +1705,7 @@ var CodexAppServerEventProjector = class {
 			nativeToolLifecycleProjection: this.nativeToolLifecycleProjector,
 			assistantProjection: this.assistantProjection,
 			reasoningProjection: this.reasoningProjection,
-			responseCompletions: this.responseCompletions,
+			usageProjection: this.usageProjection,
 			toolTranscriptProjection: this.toolTranscriptProjection,
 			toolProgressProjection: this.toolProgressProjection,
 			generatedMediaProjection: this.generatedMediaProjection
@@ -1616,16 +1728,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 +1748,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 +1794,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);
@@ -1689,17 +1808,20 @@ var CodexAppServerEventProjector = class {
 		await 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 +1832,7 @@ var CodexAppServerEventProjector = class {
 				itemId,
 				timestamp: this.transcriptCheckpoint.nextTimestamp()
 			});
+			if (!this.isCompactionProjectionActive()) return;
 			this.eventProjection.emitCompactionEnd(itemId, true);
 		}
 		this.toolProgressProjection.recordToolMeta(item);
@@ -1724,8 +1847,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 +1865,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 +1889,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);
@@ -1778,8 +1904,9 @@ var CodexAppServerEventProjector = class {
 			await this.emitSnapshotOnlyNativeToolProgress(item);
 			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);
@@ -1825,19 +1952,6 @@ var CodexAppServerEventProjector = class {
 		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);
 	}
@@ -2107,7 +2221,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 +2271,7 @@ function createCodexUserInputBridge(params) {
 		agentId: params.paramsForRun.agentId,
 		runId: params.paramsForRun.runId,
 		timeoutMs,
-		gatewayCall,
+		gatewayCall: params.gatewayCall,
 		delivery: params.paramsForRun,
 		signal,
 		promptOptions: {
@@ -2350,6 +2463,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 +2504,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 +2519,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,
@@ -2510,7 +2639,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");
 	};
@@ -2577,36 +2706,52 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		}
 	});
 	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)
+			},
 			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 +2760,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 +2784,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,
@@ -2663,6 +2813,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	return {
 		activeTurnId,
 		activeProjector,
+		runtimeModelSelection,
 		streamState,
 		handle,
 		freezeRunTerminalOutcome,
@@ -2708,8 +2859,8 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		});
 		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 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) ? 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,
@@ -2751,8 +2902,6 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			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 +3144,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 +3228,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 +3240,7 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 			await params.bindingStore.mutate(params.identity, {
 				kind: "clear",
 				threadId: binding.threadId
-			});
+			}, params.assertCurrent);
 			return { binding: void 0 };
 		}
 	}
@@ -3106,6 +3257,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 +3272,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 +3294,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({});
@@ -3174,7 +3326,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		config: params.config,
 		agentId: policyAgentId
 	});
-	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
+	const agentDir = params.agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId);
 	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
 	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
 	const assertLocalTargetSupported = (unsupported) => {
@@ -3233,16 +3385,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;
@@ -3393,104 +3546,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
-		});
-		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;
-	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
-	};
+	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
+		});
+		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;
+	}
 }
 //#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 +3662,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 +3672,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 +3708,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;
@@ -3940,18 +4096,32 @@ 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 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 } = 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 settlementPhase = "active";
 	let abortGraceTimer;
 	const beginAbortGrace = () => {
-		if (settlementClosed) return;
-		abortGraceTimer = setTimeout(() => abortGraceElapsed.resolve(), TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
+		if (settlementPhase !== "active") return;
+		abortGraceTimer = setTimeout(() => {
+			settlementPhase = "expired";
+			abortGraceElapsed.resolve();
+		}, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
 		abortGraceTimer.unref?.();
 	};
 	const abortListener = addAbortListener(runAbortController.signal, () => {
@@ -3961,244 +4131,308 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		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);
 		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
-	});
-	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", {
+	};
+	const settlement = drainNotificationQueue().then(closeProjection);
+	let projectionDrained = false;
+	try {
+		try {
+			projectionDrained = await Promise.race([settlement.then(() => true), abortGraceElapsed.promise.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);
+		let enrichedPromptError = resourceState.executionDisconnectError ?? state.clientClosedPromptError ?? (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 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: finalPromptErrorMessage
-		});
-		await bindingStore.mutate(bindingIdentity, {
-			kind: "clear",
-			threadId: resourceState.thread.threadId
+			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
 		});
-	}
-	const refreshedUsageLimitPromptError = await refreshCodexUsageLimitPromptError({
-		client: resourceState.client,
-		message: finalPromptErrorMessage,
-		timeoutMs: appServer.requestTimeoutMs,
-		signal: runAbortController.signal
-	});
-	if (refreshedUsageLimitPromptError) {
-		await markCodexAuthProfileBlockedFromRateLimits({
+		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: refreshedUsageLimitPromptError.rateLimitsForProfile
+			rateLimits: readRecentCodexRateLimits(resourceState.client)
 		});
-		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: {
+		const projectTerminalOutcome = () => {
+			const effectiveTimedOut = state.timeout !== void 0;
+			const clientClosedPromptErrorForFinal = state.clientClosedPromptError;
+			const 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" : 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({
+				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
+			};
+		};
+		const mirrorTerminal = projectTerminalOutcome();
+		const unavailableMirror = {
+			assistantTranscriptOwned: false,
+			mirroredMessages: []
+		};
+		let mirrorOutcome = unavailableMirror;
+		try {
+			if (projectionDrained && settlementPhase === "active") mirrorOutcome = await Promise.race([codexTranscriptMirrorRuntime.mirrorBestEffort({
+				assertWriteCurrent: () => {
+					if (settlementPhase !== "active") 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,
+				agentId: sessionAgentId,
+				notifyUserMessagePersisted,
+				result,
+				sessionKey: contextSessionKey,
+				cwd: effectiveCwd,
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId
+			}), abortGraceElapsed.promise.then(() => unavailableMirror)]);
+			if (runAbortController.signal.aborted) await state.abortCleanup;
+		} finally {
+			closeSettlement();
+		}
+		const { effectiveTimedOut, finalPromptError, codexAppServerFailure, promptTimeoutOutcome, finalAborted, turnSucceeded, attemptSucceeded, completedTurnStatus } = projectTerminalOutcome();
+		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 { 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,
-			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({
+			turnId: activeTurnId,
+			reason: usesSupervisionConnection ? "native_auth_finalization_unsupported" : "context_unavailable"
+		});
+		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 {
+			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 +4656,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,6 +4691,14 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 				if (notification.method === "item/completed") {
 					if (activeTurnItemIds.size === 0) scheduleTerminalDynamicToolReleaseCheck();
 					const item = readCodexNotificationItem(notification.params);
+					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") await steeringQueueRef.current?.confirmConsumed(item.clientId);
 				}
 				if (isCodexTurnAbortMarkerNotification(notification, { currentPromptTexts: [turnState.codexTurnPromptText] })) state.sawCodexInterruptMarker = true;
@@ -4633,7 +4875,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
 			}
 		});
 	};
@@ -4758,6 +5000,7 @@ async function prepareCodexAttemptPrompt(context) {
 		const previousThreadId = binding.threadId;
 		const hadInactiveThreadBootstrapBinding = isInactiveThreadBootstrapBinding(binding);
 		const startupBindingResolution = await rotateOversizedCodexAppServerStartupBinding({
+			assertCurrent: connection.assertCurrent,
 			binding,
 			bindingStore,
 			identity: bindingIdentity,
@@ -4766,6 +5009,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()
@@ -5016,6 +5260,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 +5302,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 +5357,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 +5369,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 +5481,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,
@@ -5677,7 +5922,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-Bh_gf6-t.js");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -5802,15 +6047,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 +6073,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 +6096,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 +6159,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 +6167,6 @@ async function startCodexAttemptThread(params) {
 			timeoutMs: params.startupTimeoutMs,
 			signal: params.signal,
 			onTimeout: async () => {
-				startupAbandoned = true;
 				startupAbandonController.abort();
 				await params.onStartupTimeout();
 				await releaseStartupResourcesOnTimeout?.();
@@ -5942,7 +6194,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 +6212,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 +6228,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 +6300,7 @@ async function startCodexAttemptThread(params) {
 						};
 						releaseStartupResourcesOnTimeout = releaseStartupSandboxEnvironment;
 						try {
+							params.assertCurrent?.();
 							const sandboxEnvironmentRequired = shouldRequireCodexSandboxExecServerEnvironment({
 								sandbox: params.sandbox,
 								nativeToolSurfaceEnabled: params.nativeToolSurfaceEnabled,
@@ -6061,10 +6316,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 +6353,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 +6444,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 +6453,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 +6464,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 +6497,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,11 +6508,9 @@ 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
@@ -6278,15 +6521,16 @@ async function startCodexAttemptRuntime(resources) {
 	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 +6586,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,
@@ -6413,7 +6658,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 +6668,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 +6738,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 = {};
@@ -6540,8 +6782,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,7 +6799,7 @@ async function prepareCodexAttemptTools(runtime) {
 				agentDir,
 				assertCurrent: () => {
 					runAbortController.signal.throwIfAborted();
-					params.hostCapabilities.assertActive();
+					connection.assertCurrent();
 				}
 			});
 		} finally {
@@ -6588,7 +6831,7 @@ async function prepareCodexAttemptTools(runtime) {
 		sessionId: params.sessionId,
 		runId: params.runId,
 		agentId: policyAgentId,
-		agentDir: agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId),
+		agentDir: agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId),
 		agentAccountId: params.agentAccountId,
 		messageProvider: params.messageProvider ?? params.messageChannel,
 		messageChannel: params.messageChannel,
@@ -6672,6 +6915,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,7 +6974,7 @@ 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,
@@ -6732,17 +6984,14 @@ async function prepareCodexAttemptTools(runtime) {
 			directToolNames: resolveCodexDynamicToolDirectNames(params, 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 +7000,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,7 +7040,7 @@ async function prepareCodexAttemptTools(runtime) {
 					...runtimeAuthority ? { runtimeAuthority } : {}
 				});
 			} finally {
-				await materialized.dispose();
+				await materialized?.dispose();
 			}
 		};
 		return {
@@ -6806,9 +7048,9 @@ async function prepareCodexAttemptTools(runtime) {
 			registeredTools: registeredWithScopedMcp,
 			scopedMcpTools,
 			configuredMcp,
+			disposeMcpTools,
 			configuredMcpOwnershipVersion: configuredMcpSurface === "scheduled" ? 1 : void 0,
-			cronCreatorToolAllowlist,
-			cronCreatorToolAllowlistCaptureRef,
+			captureCronCreatorToolAllowlist,
 			scheduledAppAuthoritySourceRef,
 			dynamicToolParams,
 			compactionPlanState,
@@ -6823,8 +7065,7 @@ async function prepareCodexAttemptTools(runtime) {
 			runtimeYieldCompletionClaim
 		};
 	} catch (error) {
-		await scopedMcpTools?.dispose();
-		await configuredMcp?.dispose();
+		await disposeMcpTools();
 		throw error;
 	}
 }
@@ -6909,6 +7150,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 	};
 	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, {
@@ -6949,9 +7191,11 @@ 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();
 			throwIfTurnStartAcceptedAfterAbort();
 			return startedTurn;
 		} catch (error) {
@@ -7004,7 +7248,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 +7284,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 +7344,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 +7423,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 +7433,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
 				}) };
@@ -7407,35 +7649,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