@openclaw/codex 2026.8.2 → 2026.9.1

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

@@ -1,54 +1,54 @@
-import { C as isCodexRemoteExecPlacementSandbox, D as resolveOpenClawExecPolicyForCodexAppServer, E as resolveCodexPluginsPolicy, P as resolveCodexAppServerHomeDir, S as isCodexPairedNodeRemoteExecPlacementSandbox, T as readCodexPluginConfig, d as withMcpElicitationsApprovalPolicy, m as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig, p as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveCodexAppServerHomeScope, u as shouldAutoApproveCodexAppServerApprovals, v as readCodexRequirementsToml, w as isCodexSandboxExecServerEnabled } from "./config-CcYL77O6.js";
-import { $ as CodexAppServerRpcError, A as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, B as resolveCodexTurnTerminalIdleTimeoutMs, Dt as readCodexRateLimitsRevision, Ft as resolveCodexAppServerFallbackApiKeyCacheKey, G as isCodexAppServerConnectionClosedError, H as getCodexAppServerClientInstanceId, Ht as isJsonObject, I as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, It as resolveCodexAppServerPreparedApiKeyCacheKey, J as isCodexAppServerOverloadError, K as isCodexAppServerIndeterminateRequestCancellationError, L as resolveCodexStartupTimeoutMs, Lt as resolveCodexAppServerPreparedAuthHandoff, M as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, Mt as resolveCodexAppServerAuthProfileId, N as TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS, Nt as resolveCodexAppServerAuthProfileIdForAgent, Ot as readRecentCodexRateLimits, P as isCodexAppServerStartupError, Q as resolveCodexAppServerClientInstanceId, R as resolveCodexTurnAssistantCompletionIdleTimeoutMs, Tt as withAbortableTimeout, U as isCodexAppServerApprovalRequest, V as withCodexStartupTimeout, Vt as flattenCodexDynamicToolFunctions, W as isCodexAppServerBrokenPipeError, X as isCodexAppServerRequestTimeoutError, _t as ensureCodexAppServerClientRuntime, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as resolveDynamicToolCallTimeoutMs, c as getLeasedSharedCodexAppServerClient, ct as shouldReleaseTurnAfterTerminalDynamicTool, dt as resolveCodexToolAbortTerminalReason, et as createCodexElicitationResponse, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, it as isMatchingDynamicToolTerminalDiagnostic, j as CodexAppServerStartupError, jt as resolveCodexAppServerAuthAccountCacheKey, kt as rememberCodexRateLimitsRead, l as getSharedCodexAppServerClient, lt as toCodexDynamicToolProgressResponse, nt as hasPendingDynamicToolTerminalDiagnostic, ot as resolveTerminalDynamicToolBatchAction, q as isCodexAppServerIndeterminateTransportError, rt as isDynamicToolTerminalDiagnosticEvent, s as createIsolatedCodexAppServerClient, st as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, tt as handleDynamicToolCallWithTimeout, u as isCodexAppServerStartSelectionChangedError, ut as toCodexDynamicToolProtocolResponse, v as retainSharedCodexAppServerClientIfCurrent, xt as protectCodexAppServerLiveThread, y as retireSharedCodexAppServerClientIfCurrent, z as resolveCodexTurnCompletionIdleTimeoutMs } from "./shared-client-B1tT5U6r.js";
-import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, i as createCodexSessionGenerationSupersededError, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore } from "./session-binding-D0zinCP1.js";
-import { c as assertCodexTurnStartResponse, d as readCodexTurn, f as readCodexTurnCompletedNotification, l as readCodexDynamicToolCallParams } from "./protocol-validators-Bg5rpNxk.js";
-import { B as readNonNegativeInteger, D as itemStatus, E as itemName, H as splitPlanText, I as readItem, L as readItemString, M as extractRawAssistantText, P as readCodexErrorNotificationMessage, V as readNullableString, _ as readCodexNotificationThreadId, a as closeCodexStartupClientBestEffort, d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, g as isCodexNotificationForTurn, h as CodexProjectionDiagnostics, j as shouldSynthesizeToolProgressForItem, k as shouldClearTerminalPresentationForNativeItem, l as retireCodexAppServerClientAfterTimedOutTurn, m as getCodexAppServerTurnRouter, o as interruptCodexTurnAndWaitBestEffort, p as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-CpVfwctT.js";
-import { C as readRawResponseToolCallId, E as updateActiveTurnItemIds, S as readNotificationItemId, T as updateActiveCompletionBlockerItemIds, _ as isReasoningItemCompletionNotification, a as codexExecutionToolName, b as isTerminalTurnStatus, c as isAssistantCompletionReleaseNotification, d as isNativeToolProgressNotification, f as isPendingOpenClawDynamicToolCompletionNotification, g as isRawToolOutputCompletionNotification, h as isRawReasoningCompletionNotification, l as isCodexTurnAbortMarkerNotification, m as isRawFunctionToolOutputCompletionNotification, o as describeNotificationActivity, p as isRawAssistantProgressNotification, r as projectCodexThreadUsageUpdate, s as isAssistantCommentaryCompletionNotification, t as CodexResponseCompletionProjection, u as isFileChangePatchUpdatedNotification, v as isReasoningProgressNotification, w as shouldDisarmAssistantCompletionIdleWatch, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-B2r5vhWH.js";
-import { i as buildCodexPluginAppCacheKey, r as buildCodexAppServerRuntimeFingerprint, s as defaultCodexAppInventoryCache } from "./thread-resume-BFt1-ZDa.js";
-import { $ as resolveCodexContinuityProjectionMaxChars, B as isMessageOnlyCodexSourceReply, D as resolveCodexAppServerThreadModelSelection, F as codexDynamicToolsFingerprint, G as buildContextEngineBinding, I as codexLegacyDynamicToolsFingerprint, J as fitCodexProjectedContextForTurnStart, K as isContextEngineBindingCompatible, L as filterCodexDynamicTools, P as areCodexDynamicToolFingerprintsCompatible, Q as resolveCodexContextEngineProjectionReserveTokens, S as buildDeveloperInstructions, V as isSystemAgentOnlyCodexDynamicToolAllowlist, W as resolveCodexDynamicToolsLoadingForRuntime, X as projectContextEngineAssemblyForCodex, Y as neutralizeCodexExplicitMentionSigils, Z as resolveCodexContextEngineProjectionMaxChars, a as isCodexAppServerProfilerEnabled, at as buildPluginAppPolicyContext, c as buildCodexNativeHookRelayConfig, d as emitCodexNativePreToolUseFailureDiagnostic, et as buildCodexPluginAppsConfigPatchFromPolicyContext, f as resolveCodexNativeHookRelayEvents, i as startOrResumeThread, l as buildCodexNativeHookRelayDisabledConfig, m as scheduleCodexNativeHookRelayUnregister, n as buildTurnStartParams, nt as buildCodexPluginThreadConfigInputFingerprint, ot as mergeCodexThreadConfigs, p as resolveCodexNativeHookRelayTtlMs, pt as resolveRecoverableCodexPluginConfigKeys, q as buildCodexContinuityCalibration, r as buildCodexUserInput, rt as buildCodexPluginThreadConfigTimeoutFallback, s as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, st as shouldBuildCodexPluginThreadConfig, t as buildTurnCollaborationMode, tt as buildCodexPluginThreadConfig, u as createCodexNativeHookRelay, x as resolveCodexWebSearchPlan } from "./thread-lifecycle-CGGKP720.js";
-import { l as isIncognitoSessionKey, r as retainCodexAppServerBindingSubscription } from "./thread-ownership-RkaoZCmQ.js";
+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 { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.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-1ep4XjzF.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-D6m_TdVy.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-BqHEHXQJ.js";
-import { r as formatCodexDisplayText } from "./command-formatters--UToCokS.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-ScnAyG90.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-CF7BmrDk.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-dIjNVCYH.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CawQJfUS.js";
+import { a as formatCodexDisplayText } from "./command-formatters-CLHhEB1Q.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-DeWVTCMj.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-E6uDsPlx.js";
 import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Ds_QVm-X.js";
-import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-BOeJf7yo.js";
-import { i as createAssistantMirrorMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-C5-Ds8mA.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-vXYUZH37.js";
-import { n as readCodexMirroredSessionHistoryMessages } from "./session-history-C5J1AKzG.js";
-import { C as shouldRequireCodexSandboxExecServerEnvironment, D as CodexNativeToolLifecycleProjector, E as readBoundedCodexRemoteWorkspaceFile, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as resolveCodexProviderWebSearchSupport, d as releaseCodexSandboxExecServerEnvironment, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as ensureCodexSandboxExecServerEnvironment, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-BmeXjwNZ.js";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-Bk3IUwod.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DQQm4gWT.js";
-import { asBoolean, asFiniteNumber, asOptionalRecord, hasNonEmptyString, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+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 { asOptionalRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { 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, buildBootstrapContextForFiles, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
-import crypto, { createHash } from "node:crypto";
-import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
+import { createHash } from "node:crypto";
+import { 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 { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
 import { addAbortListener } from "node:events";
 import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
-import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
-import { captureFinalCodexCronCreatorToolAllowlist, materializeStaticMcpToolsForScheduledHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
-import { prepareMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
-import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
 //#region extensions/codex/src/app-server/attempt-steering.ts
 /**
 * Debounced steering queue for forwarding user messages to an active Codex
@@ -265,9 +265,8 @@ var CodexAssistantProjection = class {
 		this.assistantPhaseByItem = /* @__PURE__ */ new Map();
 		this.assistantDeliveryByItem = /* @__PURE__ */ new Map();
 		this.latestTerminalAssistantCandidateSuperseded = false;
-		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
 		this.terminalAssistantCandidateEarlierActiveItemIds = /* @__PURE__ */ new Set();
-		this.lastCommentaryProgressTextByItem = /* @__PURE__ */ new Map();
+		this.lastCommentaryProgressEventByItem = /* @__PURE__ */ new Map();
 		this.lastAnswerCandidateEventByItem = /* @__PURE__ */ new Map();
 		this.pendingRawCommentaryEchoes = 0;
 		this.rawPromotedAssistantItemIds = /* @__PURE__ */ new Set();
@@ -278,27 +277,6 @@ var CodexAssistantProjection = class {
 		this.persistableAssistantBarrierItemIds = /* @__PURE__ */ new Set();
 		this.completedAssistantItemIds = /* @__PURE__ */ new Set();
 	}
-	hasCompletedTerminalAssistantText(completedItemIds) {
-		const latestCompletedItemId = this.latestCompletedTerminalAssistantItemId;
-		if (!latestCompletedItemId) return false;
-		const finalItem = this.resolveFinalAssistantTextItem();
-		return this.latestCompletedItemId === latestCompletedItemId && finalItem?.itemId === latestCompletedItemId && completedItemIds.has(latestCompletedItemId);
-	}
-	getLatestTerminalAssistantCandidate() {
-		const itemId = this.latestTerminalAssistantCandidateItemId;
-		if (!itemId) return;
-		const text = this.assistantTextByItem.get(itemId)?.trim();
-		return {
-			itemId,
-			hasText: Boolean(text && !this.isToolProgressEchoText(itemId, text))
-		};
-	}
-	hasLatestTerminalAssistantCandidateText() {
-		return !this.latestTerminalAssistantCandidateSuperseded && this.getLatestTerminalAssistantCandidate()?.hasText === true;
-	}
-	canReleaseLatestTerminalAssistantAfterToolHandoff() {
-		return this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff && this.hasLatestTerminalAssistantCandidateText();
-	}
 	handleNotification(method, params) {
 		if (method === "model/rerouted") this.responseModel = readStringField(params, "toModel") ?? this.responseModel;
 	}
@@ -321,12 +299,13 @@ var CodexAssistantProjection = class {
 		if (isCommentary) {
 			this.emitCommentaryProgress({
 				itemId,
-				text
+				text,
+				phase: "update"
 			});
 			return;
 		}
-		if (this.isFinalAnswerAssistantItem(itemId)) this.emitAnswerCandidate(itemId, "candidate");
-		const knownFinalAnswer = this.shouldStreamAssistantPartial(itemId);
+		const knownFinalAnswer = this.isFinalAnswerAssistantItem(itemId);
+		if (knownFinalAnswer) this.emitAnswerCandidate(itemId, "candidate");
 		const replace = this.streamedPartialAssistantItemId !== void 0 && this.streamedPartialAssistantItemId !== itemId;
 		if (replace && (!knownFinalAnswer || this.streamedPartialAssistantItemReplaceable)) this.streamedPartialAssistantItemReplaceable = true;
 		else if (this.streamedPartialAssistantItemId === void 0) this.streamedPartialAssistantItemReplaceable = !knownFinalAnswer;
@@ -362,9 +341,7 @@ var CodexAssistantProjection = class {
 		this.noteNativeWorkBarrier(item);
 		this.rememberAssistantPhase(item);
 		if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
-		if (itemId && !this.isNonTerminalAssistantItem(itemId)) this.latestCompletedItemId = itemId;
 		if (item?.type === "agentMessage" && !this.isNonTerminalAssistantItem(item.id)) {
-			this.latestCompletedTerminalAssistantItemId = item.id;
 			this.markLatestTerminalAssistantCandidate(item.id, activeItemIds);
 			this.pendingRawTerminalAssistantEchoItemId = item.id;
 		} else if (itemId && !this.isNonTerminalAssistantItem(itemId)) {
@@ -377,7 +354,8 @@ var CodexAssistantProjection = class {
 			if (item.text && this.isCommentaryAssistantItem(item.id)) {
 				this.emitCommentaryProgress({
 					itemId: item.id,
-					text: item.text
+					text: item.text,
+					phase: "end"
 				});
 				this.pendingRawCommentaryEchoes += 1;
 			} else if (item.text && !this.isAsyncAssistantItem(item.id) && this.isFinalAnswerAssistantItem(item.id)) this.emitAnswerCandidate(item.id, "candidate");
@@ -401,10 +379,7 @@ var CodexAssistantProjection = class {
 		const pendingTerminalAssistantEchoItemId = this.pendingRawTerminalAssistantEchoItemId;
 		const isPendingTerminalAssistantEcho = role === "assistant" && phase !== "commentary" && pendingTerminalAssistantEchoItemId !== void 0 && (rawItemId === void 0 || rawItemId === pendingTerminalAssistantEchoItemId);
 		if (pendingTerminalAssistantEchoItemId !== void 0 && !isPendingTerminalAssistantEcho) this.pendingRawTerminalAssistantEchoItemId = void 0;
-		if (!isPendingTerminalAssistantEcho) {
-			this.latestCompletedItemId = void 0;
-			this.markTerminalAssistantCandidateSupersededBy(rawItemId);
-		}
+		if (!isPendingTerminalAssistantEcho) this.markTerminalAssistantCandidateSupersededBy(rawItemId);
 		if (role !== "assistant") return;
 		if (phase === "commentary" && this.pendingRawCommentaryEchoes > 0) {
 			this.pendingRawCommentaryEchoes -= 1;
@@ -431,9 +406,10 @@ var CodexAssistantProjection = class {
 		this.rawPromotedAssistantItemIds.add(itemId);
 		if (phase === "commentary") this.emitCommentaryProgress({
 			itemId,
-			text
+			text,
+			phase: "end"
 		});
-		else this.markLatestTerminalAssistantCandidate(itemId, activeItemIds, { canReleaseAfterToolHandoff: isIdlessTerminalAssistantAfterCompletedWork });
+		else this.markLatestTerminalAssistantCandidate(itemId, activeItemIds);
 	}
 	collectAssistantTexts() {
 		const afterHandoff = this.collectPersistableAssistantTexts(this.persistableAssistantBarrier);
@@ -544,9 +520,6 @@ var CodexAssistantProjection = class {
 			responseModel: this.responseModel
 		} : message;
 	}
-	createAssistantMirrorMessage(title, text) {
-		return createAssistantMirrorMessage(this.params, title, text);
-	}
 	rememberAssistantPhase(item) {
 		if (item?.type !== "agentMessage") return;
 		const phase = readItemString(item, "phase");
@@ -566,20 +539,21 @@ var CodexAssistantProjection = class {
 	isFinalAnswerAssistantItem(itemId) {
 		return this.assistantPhaseByItem.get(itemId) === "final_answer";
 	}
-	shouldStreamAssistantPartial(itemId) {
-		return this.assistantPhaseByItem.get(itemId) === "final_answer";
-	}
 	emitCommentaryProgress(params) {
 		const progressText = params.text.trim();
-		if (!progressText || this.lastCommentaryProgressTextByItem.get(params.itemId) === progressText) return;
-		this.lastCommentaryProgressTextByItem.set(params.itemId, progressText);
+		const previous = this.lastCommentaryProgressEventByItem.get(params.itemId);
+		if (!progressText || previous?.phase === params.phase && previous.text === progressText) return;
+		this.lastCommentaryProgressEventByItem.set(params.itemId, {
+			phase: params.phase,
+			text: progressText
+		});
 		this.emitAgentEvent({
 			stream: "item",
 			data: {
 				itemId: params.itemId,
 				kind: "preamble",
 				title: "Preamble",
-				phase: "update",
+				phase: params.phase,
 				progressText,
 				source: "codex-app-server"
 			}
@@ -592,9 +566,12 @@ var CodexAssistantProjection = class {
 			this.supersedeVisibleAnswerCandidate();
 			this.visibleAnswerCandidateItemId = itemId;
 		}
-		const signature = `${status}\0${text}`;
-		if (this.lastAnswerCandidateEventByItem.get(itemId) === signature) return;
-		this.lastAnswerCandidateEventByItem.set(itemId, signature);
+		const previous = this.lastAnswerCandidateEventByItem.get(itemId);
+		if (previous?.status === status && previous.text === text) return;
+		this.lastAnswerCandidateEventByItem.set(itemId, {
+			status,
+			text
+		});
 		this.emitAgentEvent({
 			stream: "item",
 			data: {
@@ -615,10 +592,9 @@ var CodexAssistantProjection = class {
 		this.emitAnswerCandidate(itemId, "superseded");
 		this.visibleAnswerCandidateItemId = void 0;
 	}
-	markLatestTerminalAssistantCandidate(itemId, activeItemIds, options) {
+	markLatestTerminalAssistantCandidate(itemId, activeItemIds) {
 		this.latestTerminalAssistantCandidateItemId = itemId;
 		this.latestTerminalAssistantCandidateSuperseded = false;
-		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = options?.canReleaseAfterToolHandoff === true;
 		this.terminalAssistantCandidateEarlierActiveItemIds = new Set(activeItemIds);
 	}
 	markTerminalAssistantCandidateSupersededBy(itemId, options) {
@@ -628,7 +604,6 @@ var CodexAssistantProjection = class {
 			return;
 		}
 		this.latestTerminalAssistantCandidateSuperseded = true;
-		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
 		this.terminalAssistantCandidateEarlierActiveItemIds.clear();
 		this.supersedeVisibleAnswerCandidate();
 	}
@@ -1031,7 +1006,7 @@ const attemptTerminal = agentHarnessAttemptTerminal;
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
 function buildCodexMessagesSnapshot(params) {
 	const messages = promptSnapshot(params.runParams, params.turnId, params.upstreamUserText);
-	if (params.reasoningText) messages.push(attachCodexMirrorIdentity(params.createAssistantMirrorMessage("Codex reasoning", params.reasoningText), `${params.turnId}:reasoning`));
+	if (params.reasoningText) messages.push(attachCodexMirrorIdentity(createAssistantReasoningMessage(params.runParams, params.reasoningText), `${params.turnId}:reasoning`));
 	const commentaryMessages = params.runParams.config?.ui?.prefs?.chatPersistCommentary === false ? [] : params.commentaryMessages.map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:commentary:${itemId}`));
 	const asyncMessages = params.asyncMessages.map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:async:${itemId}`));
 	const visibleWorkMessages = [
@@ -1066,8 +1041,7 @@ function buildCodexSteeringMessagesSnapshot(params) {
 			commentaryMessages,
 			assistantMessages,
 			toolMessages: params.toolMessages,
-			lastAssistant: void 0,
-			createAssistantMirrorMessage: (title, text) => params.assistantProjection.createAssistantMirrorMessage(title, text)
+			lastAssistant: void 0
 		}).filter((message) => message.role !== "user"),
 		assistantBoundaryItemId: assistantMessages.at(-1)?.itemId
 	};
@@ -1115,8 +1089,7 @@ function buildCodexAttemptResult(input) {
 		asyncMessages,
 		commentaryMessages,
 		toolMessages: input.toolTranscriptProjection.transcriptMessages,
-		lastAssistant,
-		createAssistantMirrorMessage: (title, text) => input.assistantProjection.createAssistantMirrorMessage(title, text)
+		lastAssistant
 	});
 	const turnFailed = input.completedTurn?.status === "failed";
 	const promptError = input.promptError ?? storedMissingToolResultError ?? (turnFailed ? input.completedTurn?.error?.message ?? "codex app-server turn failed" : null);
@@ -1264,6 +1237,10 @@ const CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS = 5e3;
 function createCodexUsageLimitPromptError(message) {
 	return Object.assign(new Error(message), { 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;
 }
@@ -1403,6 +1380,7 @@ var CodexAppServerEventProjector = class {
 		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.synthesizedMissingToolResultError = null;
@@ -1435,6 +1413,13 @@ var CodexAppServerEventProjector = class {
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
 	}
+	getActiveMcpToolCall(serverName) {
+		if (this.projectionClosed || this.aborted) return;
+		return this.nativeToolLifecycleProjector.getActiveMcpToolCall(serverName);
+	}
+	recordMcpToolCallReceipt(notification) {
+		if (!this.projectionClosed) this.nativeToolLifecycleProjector.recordMcpToolCallReceipt(notification);
+	}
 	buildSteeringTranscriptPrefix() {
 		const snapshot = buildCodexSteeringMessagesSnapshot({
 			runParams: this.params,
@@ -1454,25 +1439,10 @@ var CodexAppServerEventProjector = class {
 			this.pendingSteeringAssistantBoundaryItemId = void 0;
 		}
 	}
-	hasCompletedTerminalAssistantText() {
-		return this.assistantProjection.hasCompletedTerminalAssistantText(this.completedItemIds);
-	}
-	getLatestTerminalAssistantCandidate() {
-		return this.assistantProjection.getLatestTerminalAssistantCandidate();
-	}
-	hasLatestTerminalAssistantCandidateText() {
-		return this.assistantProjection.hasLatestTerminalAssistantCandidateText();
-	}
-	canReleaseLatestTerminalAssistantAfterToolHandoff() {
-		return this.assistantProjection.canReleaseLatestTerminalAssistantAfterToolHandoff();
-	}
-	/** Restores a completed final item after only the enclosing turn timeout fired. */
-	recoverCompletedTerminalAssistantAfterTurnWatchTimeout() {
-		if (!this.aborted || this.promptError !== "codex app-server attempt timed out" || !this.hasCompletedTerminalAssistantText()) return false;
-		this.aborted = false;
-		this.promptError = void 0;
-		this.promptErrorSource = null;
-		return true;
+	/** Fence delayed projections before the turn's final snapshot leaves its owner. */
+	closeProjection() {
+		this.projectionClosed = true;
+		return this.transcriptCheckpoint.flush(true);
 	}
 	/** Resolves the shared model-order position for a native tool item. */
 	recordNativeToolOutcome(item) {
@@ -1488,6 +1458,7 @@ var CodexAppServerEventProjector = class {
 		this.nativeToolLifecycleProjector.recordPreToolUseFailure(failure);
 	}
 	async handleNotification(notification) {
+		if (this.projectionClosed) return;
 		const params = isJsonObject(notification.params) ? notification.params : void 0;
 		if (!params) return;
 		if (notification.method === "hook/started" || notification.method === "hook/completed") {
@@ -1573,7 +1544,11 @@ var CodexAppServerEventProjector = class {
 				const codexErrorInfo = isJsonObject(params.error) ? params.error.codexErrorInfo : void 0;
 				const compactionFailure = codexErrorInfo === "other" && this.isCompacting();
 				this.settledTurnFailureFinalizationAllowed = codexErrorInfo === "serverOverloaded" || compactionFailure;
-				this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
+				this.promptError = resolveCodexPromptError({
+					message: readCodexErrorNotificationMessage(params),
+					codexErrorInfo,
+					rateLimits: this.options.readRecentRateLimits?.()
+				}) ?? "codex app-server error";
 				this.promptErrorSource = compactionFailure ? "compaction" : "prompt";
 				break;
 			}
@@ -1662,16 +1637,7 @@ var CodexAppServerEventProjector = class {
 			await runAgentHarnessBeforeCompactionHook({
 				sessionFile: this.params.sessionFile,
 				messages: await this.toolTranscriptProjection.readMirroredSessionMessages(),
-				ctx: {
-					runId: this.params.runId,
-					agentId: this.params.agentId,
-					sessionKey: this.params.sessionKey,
-					sessionId: this.params.sessionId,
-					workspaceDir: this.params.workspaceDir,
-					messageProvider: this.params.messageProvider ?? void 0,
-					trigger: this.params.trigger,
-					channelId: this.params.messageChannel ?? this.params.messageProvider ?? void 0
-				}
+				ctx: this.options.agentHookContext ?? {}
 			});
 			this.emitAgentEvent({
 				stream: "compaction",
@@ -1693,6 +1659,7 @@ var CodexAppServerEventProjector = class {
 			phase: "start",
 			item
 		});
+		if (this.projectionClosed) return;
 		this.toolTranscriptProjection.recordNativeToolCall(item);
 		this.toolProgressProjection.emitToolResultSummary(item);
 		this.emitAgentEvent({
@@ -1717,27 +1684,22 @@ var CodexAppServerEventProjector = class {
 		if (!this.asyncDeliveryProjection.allows(item, true)) return;
 		const asyncMessage = this.assistantProjection.recordItemCompleted(item, itemId, this.activeItemIds);
 		if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
+		if (this.projectionClosed) return;
 		this.reasoningProjection.recordItem(item);
 		await this.generatedMediaProjection.recordNative(item);
+		if (this.projectionClosed) return;
 		if (item?.type === "contextCompaction" && itemId) {
 			this.activeCompactionItemIds.delete(itemId);
 			this.completedCompactionCount += 1;
 			await this.options.onContextCompacted?.();
+			if (this.projectionClosed) return;
 			await runAgentHarnessAfterCompactionHook({
 				sessionFile: this.params.sessionFile,
 				messages: await this.toolTranscriptProjection.readMirroredSessionMessages(),
 				compactedCount: -1,
-				ctx: {
-					runId: this.params.runId,
-					agentId: this.params.agentId,
-					sessionKey: this.params.sessionKey,
-					sessionId: this.params.sessionId,
-					workspaceDir: this.params.workspaceDir,
-					messageProvider: this.params.messageProvider ?? void 0,
-					trigger: this.params.trigger,
-					channelId: this.params.messageChannel ?? this.params.messageProvider ?? void 0
-				}
+				ctx: this.options.agentHookContext ?? {}
 			});
+			if (this.projectionClosed) return;
 			await persistCodexContextCompactionActivity({
 				sessionTarget: this.params.sessionTarget,
 				config: this.params.config,
@@ -1760,8 +1722,10 @@ var CodexAppServerEventProjector = class {
 			phase: "result",
 			item
 		});
+		if (this.projectionClosed) return;
 		this.toolTranscriptProjection.recordNativeToolCall(item);
 		await this.toolTranscriptProjection.recordNativeToolResultWithDetails(item);
+		if (this.projectionClosed) return;
 		this.toolProgressProjection.emitToolResultSummary(item);
 		this.toolProgressProjection.emitToolResultOutput(item);
 		this.emitAgentEvent({
@@ -1781,12 +1745,11 @@ var CodexAppServerEventProjector = class {
 		this.settledTurnFailureFinalizationAllowed = turn.status === "failed" && (turn.error?.codexErrorInfo === "serverOverloaded" || compactionFailure);
 		if (turn.status !== "completed") this.responseCompletions.clear();
 		if (turn.status === "failed") {
-			const usageLimitMessage = formatCodexUsageLimitErrorMessage({
+			this.promptError = resolveCodexPromptError({
 				message: turn.error?.message,
 				codexErrorInfo: turn.error?.codexErrorInfo,
 				rateLimits: this.options.readRecentRateLimits?.()
-			});
-			this.promptError = usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : turn.error?.message ?? "codex app-server turn failed";
+			}) ?? "codex app-server turn failed";
 			this.promptErrorSource = compactionFailure ? "compaction" : "prompt";
 		}
 		if (compactionFailure) {
@@ -1799,39 +1762,40 @@ var CodexAppServerEventProjector = class {
 		}
 		const turnItems = turn.items ?? [];
 		const unsettledAsyncDeliveries = this.asyncDeliveryProjection.pending();
-		for (let index = turnItems.length - 1; index >= 0; index -= 1) {
-			const item = turnItems[index];
-			if (!item || !this.isCurrentTurnSnapshotItem(item)) continue;
-			if (item?.type === "dynamicToolCall") break;
-			if (shouldClearTerminalPresentationForNativeItem(item)) {
-				this.clearTerminalPresentationForNativeItem(item);
-				break;
-			}
-		}
+		const lastToolItem = turnItems.findLast((item) => matchesCodexSnapshotTurn(item, this.turnId) && (item.type === "dynamicToolCall" || shouldClearTerminalPresentationForNativeItem(item)));
+		if (lastToolItem?.type !== "dynamicToolCall") this.clearTerminalPresentationForNativeItem(lastToolItem);
 		for (const item of turnItems) {
 			if (!this.asyncDeliveryProjection.allows(item)) continue;
 			this.diagnostics.warnUnknownItemStatus(item);
 			const asyncMessage = this.assistantProjection.recordSnapshotItem(item);
 			if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
+			if (this.projectionClosed) return;
 			this.reasoningProjection.recordItem(item);
 			await this.generatedMediaProjection.recordNative(item);
+			if (this.projectionClosed) return;
 			this.toolProgressProjection.recordToolMeta(item);
 			this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
 			await this.emitSnapshotOnlyNativeToolProgress(item);
+			if (this.projectionClosed) return;
 			this.toolTranscriptProjection.recordNativeToolCall(item);
 			await this.toolTranscriptProjection.recordNativeToolResultWithDetails(item);
+			if (this.projectionClosed) return;
 			this.toolTranscriptProjection.emitAfterToolCallObservation(item);
 			this.toolProgressProjection.emitToolResultSummary(item);
 			this.toolProgressProjection.emitToolResultOutput(item);
 		}
 		this.toolProgressProjection.approvalTimeoutKinds.clear();
-		for (const delivery of unsettledAsyncDeliveries) await this.asyncDeliveryProjection.deliver(delivery);
+		for (const delivery of unsettledAsyncDeliveries) {
+			if (this.projectionClosed) return;
+			await this.asyncDeliveryProjection.deliver(delivery);
+		}
+		if (this.projectionClosed) return;
 		this.assistantProjection.finalizeAnswerCandidate(turn);
 		this.activeCompactionItemIds.clear();
 		await this.reasoningProjection.maybeEndReasoning();
 	}
 	async emitSnapshotOnlyNativeToolProgress(item) {
-		if (!shouldSynthesizeToolProgressForItem(item) || !this.isCurrentTurnSnapshotItem(item) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
+		if (!shouldSynthesizeToolProgressForItem(item) || !matchesCodexSnapshotTurn(item, this.turnId) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
 		if (!this.activeItemIds.has(item.id)) {
 			this.eventProjection.emitStandardItemEvent({
 				phase: "start",
@@ -1842,6 +1806,7 @@ var CodexAppServerEventProjector = class {
 				item
 			});
 		}
+		if (this.projectionClosed) return;
 		this.activeItemIds.delete(item.id);
 		this.eventProjection.emitStandardItemEvent({
 			phase: "end",
@@ -1853,10 +1818,6 @@ var CodexAppServerEventProjector = class {
 		});
 		this.completedItemIds.add(item.id);
 	}
-	isCurrentTurnSnapshotItem(item) {
-		const itemTurnId = readItemString(item, "turnId");
-		return itemTurnId === void 0 || itemTurnId === this.turnId;
-	}
 	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
@@ -1877,17 +1838,8 @@ var CodexAppServerEventProjector = class {
 			presentationOnly: true
 		});
 	}
-	formatCodexErrorMessage(params) {
-		const error = isJsonObject(params.error) ? params.error : void 0;
-		const usageLimitMessage = formatCodexUsageLimitErrorMessage({
-			message: error ? readStringField(error, "message") : void 0,
-			codexErrorInfo: error?.codexErrorInfo,
-			rateLimits: this.options.readRecentRateLimits?.()
-		});
-		return usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : readCodexErrorNotificationMessage(params);
-	}
 	emitAgentEvent(event) {
-		emitCodexAgentEvent(this.params, event);
+		if (!this.projectionClosed) emitCodexAgentEvent(this.params, event);
 	}
 	isHookNotificationForCurrentThread(params) {
 		const threadId = readStringField(params, "threadId");
@@ -1896,22 +1848,8 @@ var CodexAppServerEventProjector = class {
 	}
 };
 //#endregion
-//#region extensions/codex/src/app-server/mcp-tool-metadata.ts
-/** Hosted app ownership is authoritative only on metadata supplied by Codex. */
-function readCodexMcpToolConnectorId(tool) {
-	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
-	return normalizeOptionalString(metadata?.connector_id) ?? normalizeOptionalString(metadata?.connectorId);
-}
-/** Preserve MCP App visibility so model-only tools cannot become widget authority. */
-function readCodexMcpToolUiVisibility(tool) {
-	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
-	const visibility = asOptionalRecord(metadata?.ui)?.visibility;
-	if (!Array.isArray(visibility)) return;
-	return [...new Set(visibility.filter((value) => value === "app" || value === "model"))].toSorted();
-}
-//#endregion
 //#region extensions/codex/src/app-server/native-mcp-app.ts
-const CODEX_APPS_MCP_SERVER$1 = "codex_apps";
+const CODEX_APPS_MCP_SERVER = "codex_apps";
 function readMcpAppResourceUri(item) {
 	const appContext = asOptionalRecord(item.appContext);
 	const uri = normalizeOptionalString(appContext?.resourceUri) ?? normalizeOptionalString(item.mcpAppResourceUri);
@@ -1995,7 +1933,7 @@ function createNativeMcpRuntime(params) {
 			return { tools: status ? statusTools(status) : [] };
 		},
 		readResource: async (serverName, uri) => {
-			const isCodexAppsServer = serverName === CODEX_APPS_MCP_SERVER$1;
+			const isCodexAppsServer = serverName === CODEX_APPS_MCP_SERVER;
 			const response = await params.client.request("mcpServer/resource/read", {
 				threadId: params.threadId,
 				...isCodexAppsServer ? { originCallId: params.originCallId } : {},
@@ -2025,7 +1963,7 @@ function createCodexNativeMcpAppResultDetailsPreparer(params) {
 		const connectorId = readMcpAppConnectorId(item);
 		const toolResult = readMcpToolResult(item);
 		if (!serverName || !toolName || !uiResourceUri || !toolResult) return;
-		if (serverName === CODEX_APPS_MCP_SERVER$1 && !connectorId) return;
+		if (serverName === CODEX_APPS_MCP_SERVER && !connectorId) return;
 		const runtime = createNativeMcpRuntime({
 			...params,
 			originCallId: item.id,
@@ -2034,7 +1972,7 @@ function createCodexNativeMcpAppResultDetailsPreparer(params) {
 		const tools = (await runtime.listTools?.(serverName))?.tools ?? [];
 		const allowedAppToolNames = new Set(tools.filter((tool) => {
 			const uiVisibility = readCodexMcpToolUiVisibility(tool);
-			return (uiVisibility === void 0 || uiVisibility.includes("app")) && (serverName !== CODEX_APPS_MCP_SERVER$1 || readCodexMcpToolConnectorId(tool) === connectorId);
+			return (uiVisibility === void 0 || uiVisibility.includes("app")) && (serverName !== CODEX_APPS_MCP_SERVER || readCodexMcpToolConnectorId(tool) === connectorId);
 		}).map((tool) => tool.name));
 		if (!allowedAppToolNames.has(toolName)) return;
 		return await prepareHarnessNativeMcpAppPreview({
@@ -2401,14 +2339,14 @@ function declineElicitation(message) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-active-turn.ts
-async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turn) {
+function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turn) {
 	const { prompt, state: resourceState, projectorRef, trajectoryRecorder, pendingNativePreToolUseFailures } = resources;
 	const { context, turnState } = prompt;
-	const { runtime, attemptTools } = context;
+	const { runtime, attemptTools, hookContext } = context;
 	const { connection } = runtime;
-	const { params, runAbortController, terminalState, abortExplicitly, abortFromUpstream, bindingStore, bindingIdentity, sessionAgentId, contextSessionKey, effectiveCwd } = connection;
+	const { params, runAbortController, terminalState, abortExplicitly, abortFromUpstream, sessionAgentId, contextSessionKey, effectiveCwd } = connection;
 	const { dynamicToolParams, compactionPlanState, computerContextEpoch, toolBridge } = attemptTools;
-	const { state, userInputBridgeRef, steeringQueueRef, turnWatches, completeTurn, interruptTurn } = turnRuntime;
+	const { state, completion, userInputBridgeRef, steeringQueueRef, deadlines, noteProgress, completeTurn, interruptTurn } = turnRuntime;
 	const { emitExecutionPhaseOnce, emitLifecycleStart, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const { enqueueNotification } = notifications;
 	const activeTurnId = turn.turn.id;
@@ -2446,6 +2384,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			return dynamicToolParams.onAgentEvent?.(event);
 		}
 	}, resourceState.thread.threadId, activeTurnId, {
+		agentHookContext: hookContext,
 		initialContextTokens: connection.mutable.startupContextTokens,
 		nativePostToolUseRelayEnabled: resourceState.nativeHookRelay?.allowedEvents.includes("post_tool_use") === true && resourceState.nativeHookRelay.shouldRelayEvent("post_tool_use"),
 		asyncUserMessageAllowed: params.disableTools !== true && (params.toolsAllow === void 0 || toolBridge.availableTools.some((tool) => tool.name === "message")),
@@ -2507,13 +2446,27 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			}
 		}
 	});
-	if (isTerminalTurnStatus(turn.turn.status)) state.terminalTurnNotificationQueued = true;
+	if (isTerminalTurnStatus(turn.turn.status)) {
+		state.terminalTurnNotificationQueued = true;
+		deadlines.beginSettlement(Date.now());
+	}
 	emitLifecycleStart();
 	const activeProjector = projectorRef.current;
-	turnWatches.armTerminalIdleWatch();
-	turnWatches.touchActivity("turn:start", { arm: true });
-	turnWatches.armAttemptIdleWatch();
-	turnWatches.touchActivity("turn:start", { attemptProgress: true });
+	noteProgress("turn:start");
+	const abortListener = () => {
+		state.abortCleanup = interruptTurn(activeTurnId).then(async (confirmed) => {
+			if (!terminalState.explicitCancellationObserved && !state.permissionChangeRestart && !state.timeout) return;
+			if (!confirmed) throw new Error(state.permissionChangeRestart ? "Permission change could not confirm the previous Codex turn stopped." : "Codex cancellation could not confirm the turn stopped; background terminals may still be running.");
+			await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
+			if (state.permissionChangeRestart) state.permissionChangeRestart = "confirmed";
+		});
+		state.abortCleanup.then(completeTurn, (error) => {
+			embeddedAgentLog.warn("codex app-server cancellation cleanup failed", { error });
+			completeTurn();
+		});
+	};
+	runAbortController.signal.addEventListener("abort", abortListener, { once: true });
+	if (runAbortController.signal.aborted) abortListener();
 	for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
 	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
 	const promptMirrorPromise = mirrorPromptAtTurnStartBestEffort({
@@ -2526,35 +2479,40 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		turnId: activeTurnId,
 		upstreamUserText: turnState.codexTurnPromptText
 	});
-	await promptMirrorPromise;
-	if (resourceState.turnRoute) try {
-		await resourceState.turnRoute.bindTurn(activeTurnId);
-	} catch (error) {
-		if (!state.terminalTurnNotificationQueued) throw error;
-		await resourceState.turnRoute.drain();
-		if (!state.completed) {
-			turnWatches.clearAllTimers();
-			throw error;
-		}
-	}
-	if (!state.completed && isTerminalTurnStatus(turn.turn.status)) {
-		if (!isJsonObject(turn.turn)) throw new Error("Codex turn completion payload is not a JSON object");
-		await enqueueNotification({
-			method: "turn/completed",
-			params: {
-				threadId: resourceState.thread.threadId,
-				turnId: activeTurnId,
-				turn: turn.turn
+	const bindProjection = async () => {
+		state.activeLocalProjections += 1;
+		try {
+			await Promise.race([promptMirrorPromise, completion]);
+			if (state.completed) return;
+			if (resourceState.turnRoute) try {
+				await Promise.race([resourceState.turnRoute.bindTurn(activeTurnId), completion]);
+			} catch (error) {
+				if (!state.terminalTurnNotificationQueued && !runAbortController.signal.aborted) throw error;
+				await Promise.race([resourceState.turnRoute.drain(), completion]);
+				if (!state.completed) throw error;
 			}
-		}, {
-			threadId: resourceState.thread.threadId,
-			turnId: activeTurnId
-		});
-	}
+			if (!state.completed && isTerminalTurnStatus(turn.turn.status)) {
+				if (!isJsonObject(turn.turn)) throw new Error("Codex turn completion payload is not a JSON object");
+				await enqueueNotification({
+					method: "turn/completed",
+					params: {
+						threadId: resourceState.thread.threadId,
+						turnId: activeTurnId,
+						turn: turn.turn
+					}
+				}, {
+					threadId: resourceState.thread.threadId,
+					turnId: activeTurnId
+				});
+			}
+		} finally {
+			state.activeLocalProjections -= 1;
+		}
+	};
 	const assertSteeringActive = () => {
 		params.hostCapabilities.assertActive();
 		runAbortController.signal.throwIfAborted();
-		if (state.completed || state.terminalTurnNotificationQueued || state.timedOut) throw new Error("codex app-server turn is no longer accepting steering");
+		if (state.completed || state.terminalTurnNotificationQueued) throw new Error("codex app-server turn is no longer accepting steering");
 	};
 	const workspaceOnly = resolveAttemptFsWorkspaceOnly({
 		config: params.config,
@@ -2675,12 +2633,13 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		cancelPendingUserInput,
 		queueMessage,
 		messageInjection: {
-			isAvailable: () => !state.completed && !state.terminalTurnNotificationQueued && !state.timedOut && !runAbortController.signal.aborted,
+			isAvailable: () => !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted,
 			queueMessage
 		},
 		isStreaming: () => !state.completed && !runAbortController.signal.aborted,
 		isAborted: () => runAbortController.signal.aborted,
-		isStopped: () => state.completed || state.timedOut || runAbortController.signal.aborted,
+		isStopped: () => state.completed || runAbortController.signal.aborted,
+		ownsLiveness: () => deadlines.ownsExecutionWait() && resourceState.turnRoute?.signal.aborted === false && !state.completed && !state.terminalTurnNotificationQueued && state.activeAppServerTurnRequests === 0 && state.activeLocalProjections === 0,
 		isAbortable: () => !terminalState.terminalOutcomeFrozen || terminalState.sharedAbortAllowedAfterTerminalOutcome,
 		isCompacting: () => projectorRef.current?.isCompacting() ?? false,
 		supportsTranscriptCommitWait: true,
@@ -2697,36 +2656,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		terminalState.terminalOutcomeFrozen = true;
 		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 	};
-	const abortListener = () => {
-		if (state.timedOut) {
-			(async () => {
-				if (resourceState.thread.connectionScope !== "supervision") await bindingStore.mutate(bindingIdentity, {
-					kind: "clear",
-					threadId: resourceState.thread.threadId
-				});
-				await retireCodexAppServerClientAfterTimedOutTurn(resourceState.client, {
-					threadId: resourceState.thread.threadId,
-					turnId: activeTurnId,
-					reason: String(runAbortController.signal.reason ?? "timeout"),
-					suspectPhysicalClient: state.turnWatchTimeoutKind === "terminal"
-				});
-			})().finally(completeTurn);
-			return;
-		}
-		state.abortCleanup = interruptTurn(activeTurnId).then(async (confirmed) => {
-			if (!terminalState.explicitCancellationObserved && !state.permissionChangeRestart) return;
-			if (!confirmed) throw new Error(state.permissionChangeRestart ? "Permission change could not confirm the previous Codex turn stopped." : "Codex cancellation could not confirm the turn stopped; background terminals may still be running.");
-			await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
-			if (state.permissionChangeRestart) state.permissionChangeRestart = "confirmed";
-		});
-		state.abortCleanup.then(completeTurn, (error) => {
-			embeddedAgentLog.warn("codex app-server cancellation cleanup failed", { error });
-			completeTurn();
-		});
-	};
-	runAbortController.signal.addEventListener("abort", abortListener, { once: true });
-	if (runAbortController.signal.aborted) abortListener();
-	else if (params.permissionChange && !params.permissionChange.applied()) {
+	if (!runAbortController.signal.aborted && params.permissionChange && !params.permissionChange.applied()) {
 		state.permissionChangeRestart = "requested";
 		runAbortController.abort("permission-change");
 	}
@@ -2737,7 +2667,8 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		handle,
 		freezeRunTerminalOutcome,
 		notifyUserMessagePersisted,
-		abortListener
+		abortListener,
+		ready: bindProjection()
 	};
 }
 //#endregion
@@ -2746,12 +2677,15 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, releaseSharedClientLeaseAndRetireOneShotClient, releaseSandboxExecEnvironment, runCleanupStep } = resources;
 	const { connection } = prompt.context.runtime;
 	const { params, options, runAbortController, terminalState, bindingStore, bindingIdentity } = connection;
-	const { state, steeringQueueRef, userInputBridgeRef, turnWatches } = turnRuntime;
+	const { state, steeringQueueRef, userInputBridgeRef, deadlines } = turnRuntime;
 	const { maybeEmitFastModeAutoResetBestEffort, emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, abortListener, handle, freezeRunTerminalOutcome } = activeTurn;
 	prompt.context.attemptTools.scheduledAppAuthoritySourceRef.current = void 0;
 	freezeRunTerminalOutcome();
+	const projectionClose = state.projectionClosed ? void 0 : activeTurn.activeProjector.closeProjection();
+	state.projectionClosed = true;
+	const checkpointCleanup = projectionClose ? runCleanupStep("codex-transcript-checkpoint", () => projectionClose) : void 0;
 	await state.abortCleanup.catch(() => void 0);
 	try {
 		steeringQueueRef.current?.cancel();
@@ -2762,32 +2696,32 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			error: "codex app-server run completed without lifecycle terminal event",
 			...buildLifecycleTerminalMeta({
 				aborted: runAbortController.signal.aborted && !state.clientClosedAbort,
-				timedOut: state.timedOut
+				timedOut: state.timeout !== void 0
 			})
 		});
 		if (trajectoryRecorder && !resourceState.trajectoryEndRecorded) trajectoryRecorder.recordEvent("session.ended", {
-			status: state.timedOut || runAbortController.signal.aborted && !state.clientClosedAbort ? "interrupted" : "cleanup",
+			status: state.timeout || runAbortController.signal.aborted && !state.clientClosedAbort ? "interrupted" : "cleanup",
 			threadId: resourceState.thread.threadId,
 			turnId: activeTurnId,
-			timedOut: state.timedOut,
+			timedOut: state.timeout !== void 0,
 			aborted: runAbortController.signal.aborted && !state.clientClosedAbort
 		});
 		await runCleanupStep("codex-trajectory-flush", () => trajectoryRecorder?.flush());
 		const retainLiveIncognitoThread = (terminalState.turnSucceeded || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
-		const retainedPersistentThread = terminalState.turnSucceeded && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint ? (await bindingStore.read(bindingIdentity))?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
+		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;
 			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
 				release: resourceState.thread.liveThreadOwnership?.release,
 				configFingerprint: resourceState.thread.liveThreadConfigFingerprint,
-				serviceTier: connection.mutable.pluginAppServer.serviceTier
+				serviceTier: connection.mutable.pluginAppServer.serviceTier,
+				ephemeralPolicy: resourceState.thread.liveThreadEphemeralPolicy
 			});
-		}) : false;
-		const retainLiveThread = retainLiveIncognitoThread || retainedPersistentThread;
-		const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveIncognitoThread ? await bindingStore.mutate(bindingIdentity, {
+		}) : false) || retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy === void 0;
+		const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveThread ? await bindingStore.mutate(bindingIdentity, {
 			kind: "clear",
 			threadId: resourceState.thread.threadId
 		}) : true;
-		if (!state.timedOut && !retainLiveThread) {
+		if (!retainLiveThread) {
 			if (bindingReleased) {
 				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
 					threadId: resourceState.thread.threadId,
@@ -2797,14 +2731,14 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		}
 	} finally {
 		await runCleanupStep("codex-user-input-cancel", () => userInputBridgeRef.current?.cancelPending());
-		await runCleanupStep("codex-turn-watch-clear", () => turnWatches.clearAllTimers());
+		await runCleanupStep("codex-turn-deadline-clear", () => deadlines.dispose());
 		await runCleanupStep("codex-dynamic-tool-cleanup", async () => {
-			const cleanupReason = terminalState.turnSucceeded ? "completion" : state.timedOut ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
+			const cleanupReason = terminalState.turnSucceeded ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
 			const cleanups = prompt.context.attemptTools.runCleanups.splice(0);
 			await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)));
 		});
 		await runCleanupStep("codex-route-release", releaseCurrentRoute);
-		await runCleanupStep("codex-transcript-checkpoint", () => activeTurn.activeProjector.transcriptCheckpoint.flush(true));
+		await checkpointCleanup;
 		await runCleanupStep("codex-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		const nativeHookRelay = resourceState.nativeHookRelay;
 		resourceState.nativeHookRelay = void 0;
@@ -2818,7 +2752,7 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		});
 		await runCleanupStep("codex-sandbox-release", releaseSandboxExecEnvironment);
 		await runCleanupStep("codex-scoped-mcp-dispose", () => prompt.context.attemptTools.scopedMcpTools?.dispose());
-		await runCleanupStep("codex-scheduled-mcp-dispose", () => prompt.context.attemptTools.scheduledConfiguredMcp?.dispose());
+		await runCleanupStep("codex-configured-mcp-dispose", () => prompt.context.attemptTools.configuredMcp?.dispose());
 		await runCleanupStep("codex-abort-listener-remove", () => {
 			runAbortController.signal.removeEventListener("abort", abortListener);
 		});
@@ -3249,7 +3183,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	assertLocalTargetSupported(sandbox?.enabled === true || remoteExec);
 	const preparedShellEnvironment = preparedEnvironment ? {
 		...preparedEnvironment.credentialScrubEnv,
-		...!remoteExec ? preparedEnvironment.localIdentityEnv : void 0,
+		...sandbox?.enabled || remoteExec ? void 0 : preparedEnvironment.localIdentityEnv,
 		...preparedEnvironment.localProcessEnv
 	} : void 0;
 	const shellEnvironment = preparedShellEnvironment && Object.keys(preparedShellEnvironment).length > 0 ? preparedShellEnvironment : void 0;
@@ -3277,7 +3211,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	preDynamicStartupStages.mark("session-agent");
 	let activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
 	const isInactiveThreadBootstrapBinding = (binding) => !activeContextEngine && binding?.contextEngine?.projection?.mode === "thread_bootstrap";
-	if (bindingIdentity.kind === "session" && bindingIdentity.sessionKey && (params.sessionTarget?.storePath || params.config?.session?.store)) {
+	if (bindingIdentity.kind === "session" && bindingIdentity.sessionKey) {
 		const authority = resolveCodexRunSessionBindingAuthority({
 			identity: bindingIdentity,
 			config: params.config,
@@ -3554,615 +3488,6 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-context.ts
-/**
-* Builds Codex app-server prompt context, workspace bootstrap injections,
-* system-prompt reports, and context-engine projection decisions.
-*/
-const CODEX_NATIVE_PROJECT_DOC_BASENAMES = /* @__PURE__ */ new Set(["agents.md"]);
-const CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = /* @__PURE__ */ new Set([
-	"identity.md",
-	"soul.md",
-	"user.md"
-]);
-const CODEX_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = new Set(CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES);
-const CODEX_MEMORY_CONTEXT_BASENAME = "memory.md";
-const CODEX_MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set(["memory_search", "memory_get"]);
-const CODEX_BOOTSTRAP_CONTEXT_ORDER = /* @__PURE__ */ new Map([
-	["soul.md", 10],
-	["identity.md", 20],
-	["user.md", 30],
-	["bootstrap.md", 50],
-	["memory.md", 60]
-]);
-/** Reads mirrored Codex session history for harness hooks. */
-async function readMirroredSessionHistoryMessages(params) {
-	const { admission, ...target } = params;
-	const messages = await readCodexMirroredSessionHistoryMessages(target, admission, "model-context");
-	if (!messages) embeddedAgentLog.warn("failed to read mirrored session history for codex harness hooks", { sessionFile: params.sessionFile });
-	return messages;
-}
-/** Reads a valid thread-bootstrap projection request from context-engine output. */
-function readContextEngineThreadBootstrapProjection(projection) {
-	if (projection?.mode !== "thread_bootstrap") return;
-	const epoch = projection.epoch?.trim();
-	if (!epoch) {
-		embeddedAgentLog.warn("context engine requested Codex thread-bootstrap projection without an epoch; using per-turn projection");
-		return;
-	}
-	const fingerprint = projection.fingerprint?.trim();
-	return {
-		mode: "thread_bootstrap",
-		epoch,
-		...fingerprint ? { fingerprint } : {}
-	};
-}
-/**
-* Decides whether an existing Codex thread can reuse its context-engine
-* bootstrap projection or must be reprojected.
-*/
-function resolveContextEngineBootstrapProjectionDecision(params) {
-	const bindingProjection = params.startupBinding?.contextEngine?.projection;
-	if (!params.startupBinding?.threadId || !bindingProjection) return {
-		project: true,
-		reason: !params.startupBinding?.threadId ? "missing-thread-binding" : "missing-projection-binding"
-	};
-	if (!params.expectedBinding || !isContextEngineBindingCompatible(params.startupBinding.contextEngine, params.expectedBinding)) return {
-		project: true,
-		reason: "context-engine-binding-mismatch"
-	};
-	if (!areCodexDynamicToolFingerprintsCompatible({
-		previous: params.startupBinding.dynamicToolsFingerprint,
-		next: params.dynamicToolsFingerprint,
-		nextLegacy: params.legacyDynamicToolsFingerprint
-	})) return {
-		project: true,
-		reason: "dynamic-tools-mismatch"
-	};
-	return bindingProjection.mode !== "thread_bootstrap" || bindingProjection.epoch !== params.projection.epoch || bindingProjection.fingerprint !== params.projection.fingerprint ? {
-		project: true,
-		reason: "projection-mismatch"
-	} : {
-		project: false,
-		reason: "matching-thread-bootstrap-binding"
-	};
-}
-/**
-* Loads workspace bootstrap files and partitions them into Codex-native prompt,
-* developer-instruction, heartbeat, and memory-tool contexts.
-*/
-async function buildCodexWorkspaceBootstrapContext(params) {
-	try {
-		const inheritsAgentWorkspace = (params.executionWorkspace ?? params.resolvedWorkspace) !== params.resolvedWorkspace;
-		const promptWorkspace = inheritsAgentWorkspace ? params.resolvedWorkspace : params.effectiveWorkspace;
-		const memoryToolsAvailable = params.memoryToolNames.length > 0 && canRouteCodexWorkspaceMemoryThroughTools({
-			config: params.params.config,
-			agentId: params.params.agentId ?? params.sessionAgentId,
-			workspaceDir: inheritsAgentWorkspace ? params.resolvedWorkspace : params.effectiveWorkspace
-		});
-		const bootstrapFiles = await resolveBootstrapFilesForRun({
-			workspaceDir: params.resolvedWorkspace,
-			config: params.params.config,
-			sessionKey: params.sessionKey,
-			sessionId: params.params.sessionId,
-			chatType: params.params.chatType,
-			agentId: params.params.agentId ?? params.sessionAgentId,
-			warn: (message) => embeddedAgentLog.warn(message),
-			contextMode: params.params.bootstrapContextMode,
-			runKind: params.params.bootstrapContextRunKind
-		});
-		const memoryToolRoutedBootstrapFiles = memoryToolsAvailable ? selectCodexWorkspaceMemoryReferenceFiles({
-			bootstrapFiles,
-			workspaceDir: params.resolvedWorkspace
-		}) : [];
-		const memoryReferenceFiles = memoryToolRoutedBootstrapFiles.map((file) => remapCodexContextFilePath({
-			file: toCodexEmbeddedContextFile(file),
-			sourceWorkspaceDir: params.resolvedWorkspace,
-			targetWorkspaceDir: promptWorkspace
-		}));
-		const contextFiles = buildBootstrapContextForFiles(memoryToolsAvailable ? bootstrapFiles.filter((file) => !isCodexWorkspaceRootMemoryBootstrapFile({
-			file,
-			workspaceDir: params.resolvedWorkspace
-		})) : bootstrapFiles, {
-			config: params.params.config,
-			agentId: params.params.agentId ?? params.sessionAgentId,
-			warn: (message) => embeddedAgentLog.warn(message)
-		}).map((file) => remapCodexContextFilePath({
-			file,
-			sourceWorkspaceDir: params.resolvedWorkspace,
-			targetWorkspaceDir: promptWorkspace
-		}));
-		const promptContextFiles = selectCodexWorkspacePromptContextFiles(contextFiles, {
-			excludeMemory: memoryToolsAvailable,
-			memoryWorkspaceDir: params.effectiveWorkspace
-		});
-		const injectOpenClawContext = shouldInjectCodexOpenClawPromptContext(params.params);
-		const restrictedProjectDocNeedsOpenClawCarrier = params.params.pluginHarnessToolPolicyRestricted === true && !params.params.disableTools && !isMessageOnlyCodexSourceReply(params.params) && params.params.bootstrapContextMode !== "lightweight";
-		const threadDeveloperInstructionFiles = injectOpenClawContext && !params.ringZeroActive && (inheritsAgentWorkspace || restrictedProjectDocNeedsOpenClawCarrier) ? selectCodexWorkspaceAgentProjectInstructionFiles(contextFiles, params.resolvedWorkspace) : [];
-		const turnScopedDeveloperInstructionFiles = injectOpenClawContext ? selectCodexWorkspaceTurnScopedDeveloperInstructionFiles(contextFiles) : [];
-		return {
-			bootstrapFiles,
-			contextFiles,
-			inheritsAgentWorkspace,
-			promptContextFiles,
-			threadDeveloperInstructionFiles,
-			turnScopedDeveloperInstructionFiles,
-			memoryReferenceFiles,
-			memoryToolRoutedBootstrapFiles,
-			memoryToolNames: [...params.memoryToolNames],
-			memoryToolRouted: memoryToolsAvailable,
-			promptContext: renderCodexWorkspaceBootstrapPromptContext(promptContextFiles),
-			threadDeveloperInstructions: renderCodexWorkspaceDeveloperInstructions({
-				files: threadDeveloperInstructionFiles,
-				header: "## OpenClaw Agent Workspace Instructions",
-				preamble: "OpenClaw loaded this bounded snapshot from the configured agent workspace."
-			}),
-			turnScopedDeveloperInstructions: renderCodexWorkspaceCollaborationDeveloperInstructions(turnScopedDeveloperInstructionFiles),
-			memoryCollaborationInstructions: shouldInjectCodexOpenClawPromptContext(params.params) ? await renderCodexWorkspaceMemoryCollaborationInstructions({
-				files: memoryReferenceFiles,
-				toolNames: params.memoryToolNames,
-				memoryToolRouted: memoryToolsAvailable,
-				citationsMode: params.params.config?.memory?.citations,
-				agentId: params.params.agentId ?? params.sessionAgentId,
-				agentSessionKey: params.sessionKey,
-				sandboxed: params.sandboxed
-			}) : void 0
-		};
-	} catch (error) {
-		embeddedAgentLog.warn("failed to load codex workspace bootstrap instructions", { error });
-		return {
-			bootstrapFiles: [],
-			contextFiles: [],
-			inheritsAgentWorkspace: false
-		};
-	}
-}
-/**
-* Builds the prompt-size, bootstrap-file, skill, and tool-schema accounting
-* report for a Codex run.
-*/
-function buildCodexSystemPromptReport(params) {
-	const toolEntries = flattenCodexDynamicToolFunctions(params.tools).map(buildCodexToolReportEntry);
-	const schemaChars = toolEntries.reduce((sum, tool) => sum + tool.schemaChars, 0);
-	const skillsPrompt = params.skillsPrompt.trim();
-	const bootstrapMaxChars = readPositiveNumber(params.attempt.config?.agents?.defaults?.bootstrapMaxChars);
-	const bootstrapTotalMaxChars = readPositiveNumber(params.attempt.config?.agents?.defaults?.bootstrapTotalMaxChars);
-	return {
-		source: "run",
-		generatedAt: Date.now(),
-		sessionId: params.attempt.sessionId,
-		sessionKey: params.sessionKey,
-		provider: params.attempt.provider,
-		model: params.attempt.modelId,
-		workspaceDir: params.workspaceDir,
-		...bootstrapMaxChars ? { bootstrapMaxChars } : {},
-		...bootstrapTotalMaxChars ? { bootstrapTotalMaxChars } : {},
-		systemPrompt: {
-			chars: params.developerInstructions.length,
-			projectContextChars: 0,
-			nonProjectContextChars: params.developerInstructions.length,
-			hash: sha256Text(params.developerInstructions)
-		},
-		injectedWorkspaceFiles: buildCodexBootstrapInjectionStats({
-			bootstrapFiles: params.workspaceBootstrapContext.bootstrapFiles,
-			injectedFiles: params.workspaceBootstrapContext.promptContextFiles ?? [],
-			developerInstructionFiles: [...params.workspaceBootstrapContext.threadDeveloperInstructionFiles ?? [], ...params.workspaceBootstrapContext.turnScopedDeveloperInstructionFiles ?? []],
-			memoryToolRoutedBootstrapFiles: params.workspaceBootstrapContext.memoryToolRoutedBootstrapFiles ?? [],
-			memoryToolRouted: params.workspaceBootstrapContext.memoryToolRouted === true
-		}),
-		skills: {
-			promptChars: skillsPrompt.length,
-			hash: sha256Text(skillsPrompt),
-			entries: buildCodexSkillReportEntries(skillsPrompt)
-		},
-		tools: {
-			listChars: 0,
-			schemaChars,
-			entries: toolEntries
-		}
-	};
-}
-function buildCodexSkillReportEntries(skillsPrompt) {
-	if (!skillsPrompt) return [];
-	return Array.from(skillsPrompt.matchAll(/<skill>[\s\S]*?<\/skill>/gi)).map((match) => match[0] ?? "").map((block) => ({
-		name: block.match(/<name>\s*([^<]+?)\s*<\/name>/i)?.[1]?.trim() || "(unknown)",
-		blockChars: block.length
-	})).filter((entry) => entry.blockChars > 0);
-}
-function buildCodexToolReportEntry(tool) {
-	const summary = tool.description.trim();
-	if (tool.deferLoading === true) return {
-		name: tool.name,
-		summaryChars: summary.length,
-		summaryHash: sha256Text(summary),
-		schemaChars: 0,
-		schemaHash: stableJsonHash(null),
-		propertiesCount: null
-	};
-	return {
-		name: tool.name,
-		summaryChars: summary.length,
-		summaryHash: sha256Text(summary),
-		...buildCodexToolSchemaStats(tool.inputSchema)
-	};
-}
-function buildCodexToolSchemaStats(schema) {
-	const schemaChars = (() => {
-		try {
-			return JSON.stringify(schema).length;
-		} catch {
-			return 0;
-		}
-	})();
-	const properties = isJsonObject(schema) && isJsonObject(schema.properties) ? schema.properties : null;
-	return {
-		schemaChars,
-		schemaHash: stableJsonHash(schema),
-		propertiesCount: properties ? Object.keys(properties).length : null
-	};
-}
-function sha256Text(value) {
-	return createHash("sha256").update(value).digest("hex");
-}
-function normalizeForStableHash(value) {
-	if (Array.isArray(value)) return value.map((entry) => normalizeForStableHash(entry));
-	if (value && typeof value === "object") {
-		const record = value;
-		return Object.fromEntries(Object.keys(record).toSorted((left, right) => left.localeCompare(right)).map((key) => [key, normalizeForStableHash(record[key])]));
-	}
-	return value;
-}
-function stableJsonHash(value) {
-	return sha256Text(JSON.stringify(normalizeForStableHash(value)) ?? "null");
-}
-function buildCodexBootstrapInjectionStats(params) {
-	const injectedIndex = indexCodexContextFileContent(params.injectedFiles);
-	const developerInstructionIndex = indexCodexContextFileContent(params.developerInstructionFiles ?? []);
-	const memoryToolRoutedPaths = new Set((params.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonBlankString(file.path)).filter(isNonEmptyString$1).map(normalizeCodexContextFilePath));
-	return params.bootstrapFiles.map((file) => {
-		const fileName = readNonBlankString(file.name);
-		const pathValue = readNonBlankString(file.path) ?? fileName ?? "";
-		const displayName = (fileName ?? getCodexContextFileDisplayBasename(pathValue)) || pathValue;
-		const baseName = getCodexContextFileBasename(pathValue || fileName || "");
-		const rawChars = file.missing ? 0 : (file.content ?? "").trimEnd().length;
-		const memoryToolRoutedFile = baseName === CODEX_MEMORY_CONTEXT_BASENAME && params.memoryToolRouted === true && memoryToolRoutedPaths.has(normalizeCodexContextFilePath(pathValue));
-		const injected = memoryToolRoutedFile ? void 0 : readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) ?? readCodexIndexedContextFileContent(developerInstructionIndex, pathValue, fileName);
-		if (!file.missing && injected === void 0 && CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName)) return {
-			name: displayName,
-			path: pathValue,
-			missing: false,
-			rawChars,
-			injectionStatus: "native_unverified",
-			injectedChars: null,
-			truncated: null
-		};
-		const injectedChars = memoryToolRoutedFile ? 0 : injected?.length ?? 0;
-		const truncated = memoryToolRoutedFile ? false : !file.missing && injectedChars < rawChars;
-		return {
-			name: displayName,
-			path: pathValue,
-			missing: file.missing,
-			rawChars,
-			injectedChars,
-			truncated
-		};
-	});
-}
-function indexCodexContextFileContent(files) {
-	const byPath = /* @__PURE__ */ new Map();
-	const byBaseName = /* @__PURE__ */ new Map();
-	for (const file of files) {
-		const pathValue = readNonBlankString(file.path);
-		if (!pathValue) continue;
-		if (!byPath.has(pathValue)) byPath.set(pathValue, file.content);
-		const baseName = getCodexContextFileBasename(pathValue);
-		if (baseName && !byBaseName.has(baseName)) byBaseName.set(baseName, file.content);
-	}
-	return {
-		byPath,
-		byBaseName
-	};
-}
-function readCodexIndexedContextFileContent(index, pathValue, fileName) {
-	const pathContent = index.byPath.get(pathValue);
-	if (pathContent !== void 0) return pathContent;
-	if (fileName) {
-		const nameContent = index.byPath.get(fileName);
-		if (nameContent !== void 0) return nameContent;
-	}
-	const baseName = getCodexContextFileBasename(fileName ?? pathValue);
-	return baseName ? index.byBaseName.get(baseName) : void 0;
-}
-function readPositiveNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
-}
-/**
-* Builds OpenClaw-provided workspace prompt context for the current Codex turn.
-*/
-function buildCodexOpenClawPromptContext(params) {
-	if (!shouldInjectCodexOpenClawPromptContext(params.params)) return;
-	const sections = [params.workspacePromptContext?.trim() ? [
-		"## OpenClaw Workspace Context",
-		"",
-		params.workspacePromptContext.trim()
-	].join("\n") : void 0, params.watchedSessionsContext?.trim() || void 0].filter(isNonEmptyString$1);
-	if (sections.length === 0) return;
-	return [
-		"OpenClaw runtime context for this turn:",
-		"Treat this OpenClaw-provided context as supporting project/user reference for the current request.",
-		"",
-		...sections
-	].join("\n");
-}
-/**
-* Renders the watched-sessions block for the Codex per-turn runtime context.
-* Codex builds its own instruction layers, so the embedded prompt's Watched
-* Sessions section must be re-surfaced here or Codex-backed main sessions
-* keep refusing cross-session questions (openclaw#114797).
-*/
-function buildCodexWatchedSessionsContext(params) {
-	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
-	return buildWatchedSessionsHarnessContext({
-		config: params.attempt.config,
-		sessionKey: params.sessionKey,
-		sandboxed: params.sandboxed,
-		toolNames: flattenCodexDynamicToolFunctions(params.dynamicTools).map((tool) => normalizeCodexDynamicToolName(tool.name))
-	});
-}
-function shouldInjectCodexOpenClawPromptContext(params) {
-	return !(params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron");
-}
-/** Renders loaded OpenClaw skill prompts as Codex collaboration instructions. */
-function renderCodexSkillsCollaborationInstructions(params) {
-	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
-	return params.skillsPrompt?.trim() ? [
-		"## OpenClaw Skills",
-		"",
-		params.skillsPrompt.trim()
-	].join("\n") : void 0;
-}
-/**
-* Prepends OpenClaw context while preserving leading delivery metadata as
-* routing guidance instead of user request text.
-*/
-function prependCodexOpenClawPromptContext(prompt, context, options = {}) {
-	const { deliveryHint, prompt: promptWithoutDeliveryHint } = splitLeadingCodexDeliveryHint(prompt);
-	if (!context?.trim() && (!deliveryHint || options.preservePromptWithoutContext)) return prompt;
-	const promptSection = promptWithoutDeliveryHint.startsWith("OpenClaw assembled context for this turn:") ? promptWithoutDeliveryHint : ["Current user request:", promptWithoutDeliveryHint].join("\n");
-	const deliverySection = deliveryHint ? [
-		"OpenClaw delivery metadata:",
-		"This delivery metadata is runtime routing guidance, not the user's request.",
-		deliveryHint
-	].join("\n") : void 0;
-	return [
-		context?.trim(),
-		deliverySection,
-		promptSection
-	].filter(Boolean).join("\n\n");
-}
-/**
-* Maps the surviving user-request portion of an input range after delivery
-* metadata has been relocated before the request.
-*/
-function resolveCodexDeliveryHintPreservedInputRange(params) {
-	const { prompt, promptInputRange, decoratedPrompt } = params;
-	const { deliveryHint, prompt: promptWithoutDeliveryHint } = splitLeadingCodexDeliveryHint(prompt);
-	if (!deliveryHint || !promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !decoratedPrompt.endsWith(promptWithoutDeliveryHint)) return;
-	const promptWithoutDeliveryHintStart = prompt.length - promptWithoutDeliveryHint.length;
-	const inputStart = Math.max(promptInputRange.start, promptWithoutDeliveryHintStart);
-	const inputEnd = Math.max(inputStart, Math.min(promptInputRange.end, promptWithoutDeliveryHint.length + promptWithoutDeliveryHintStart));
-	const decoratedPromptSuffixStart = decoratedPrompt.length - promptWithoutDeliveryHint.length;
-	const requestHeader = "Current user request:\n";
-	const requestHeaderStart = decoratedPromptSuffixStart - 22;
-	return {
-		start: inputStart === promptWithoutDeliveryHintStart && decoratedPrompt.slice(requestHeaderStart, decoratedPromptSuffixStart) === requestHeader ? requestHeaderStart : decoratedPromptSuffixStart + inputStart - promptWithoutDeliveryHintStart,
-		end: decoratedPromptSuffixStart + inputEnd - promptWithoutDeliveryHintStart
-	};
-}
-function splitLeadingCodexDeliveryHint(prompt) {
-	const trimmedStart = prompt.trimStart();
-	const matchedHint = MESSAGE_TOOL_DELIVERY_HINTS.find((hint) => trimmedStart.startsWith(hint));
-	if (!matchedHint) return { prompt };
-	return {
-		deliveryHint: matchedHint,
-		prompt: trimmedStart.slice(matchedHint.length).replace(/^\s*\n/, "").trimStart()
-	};
-}
-function renderCodexWorkspaceBootstrapPromptContext(contextFiles) {
-	const files = contextFiles;
-	if (files.length === 0) return;
-	const lines = [
-		"OpenClaw loaded these user-editable workspace files for the current turn. Codex loads project-local AGENTS.md natively. When execution uses another folder, OpenClaw supplies the agent workspace AGENTS.md as thread-level developer instructions. SOUL.md, IDENTITY.md, and USER.md remain turn-scoped collaboration instructions. Those files are not repeated here.",
-		"",
-		"# Project Context",
-		"",
-		"The following project context files have been loaded:"
-	];
-	lines.push("");
-	for (const file of files) lines.push(`## ${file.path}`, "", file.content, "");
-	return lines.join("\n").trim();
-}
-function selectCodexWorkspacePromptContextFiles(contextFiles, options = {}) {
-	const excludeMemory = options.excludeMemory ?? true;
-	return contextFiles.filter((file) => {
-		const baseName = getCodexContextFileBasename(file.path);
-		return baseName && !CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName) && !CODEX_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES.has(baseName) && (!excludeMemory || !isCodexWorkspaceRootMemoryContextFile({
-			file,
-			workspaceDir: options.memoryWorkspaceDir
-		})) && !isMissingCodexBootstrapContextFile(file);
-	}).toSorted(compareCodexContextFiles);
-}
-function selectCodexWorkspaceTurnScopedDeveloperInstructionFiles(contextFiles) {
-	return selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES);
-}
-function selectCodexWorkspaceAgentProjectInstructionFiles(contextFiles, agentWorkspaceDir) {
-	const agentProjectDocPath = path.join(path.resolve(agentWorkspaceDir), "AGENTS.md");
-	return selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, CODEX_NATIVE_PROJECT_DOC_BASENAMES).filter((file) => path.resolve(file.path) === agentProjectDocPath);
-}
-function selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, basenames) {
-	return contextFiles.filter((file) => {
-		const baseName = getCodexContextFileBasename(file.path);
-		return baseName && basenames.has(baseName) && !isMissingCodexBootstrapContextFile(file) && file.content.trim().length > 0;
-	}).toSorted(compareCodexContextFiles);
-}
-function renderCodexWorkspaceCollaborationDeveloperInstructions(files) {
-	return renderCodexWorkspaceDeveloperInstructions({
-		files,
-		header: "## OpenClaw Agent Soul",
-		preamble: "OpenClaw loaded these workspace instruction files from the active agent workspace. They are the canonical definitions of who you are, how you think and work, and the human you work alongside. Internalize and follow them accordingly.",
-		wrapperTag: "AGENT_SOUL"
-	});
-}
-function renderCodexWorkspaceDeveloperInstructions(params) {
-	const { files, header, preamble, wrapperTag } = params;
-	if (files.length === 0) return;
-	const lines = [
-		header,
-		"",
-		preamble,
-		""
-	];
-	if (wrapperTag) lines.push(`<${wrapperTag}>`, "");
-	for (const file of files) lines.push(`### ${file.path}`, "", file.content, "");
-	if (wrapperTag) lines.push(`</${wrapperTag}>`);
-	return lines.join("\n").trim();
-}
-function selectCodexWorkspaceMemoryReferenceFiles(params) {
-	return params.bootstrapFiles.filter((file) => {
-		return isCodexWorkspaceRootMemoryBootstrapFile({
-			file,
-			workspaceDir: params.workspaceDir
-		}) && !file.missing && (file.content ?? "").trim().length > 0;
-	}).toSorted(compareCodexBootstrapFiles);
-}
-/**
-* Renders a memory-file reference that points Codex at memory tools instead of
-* embedding MEMORY.md contents.
-*/
-function renderCodexWorkspaceMemoryReference(params) {
-	if (params.files.length === 0) return;
-	const lines = [
-		"## OpenClaw Workspace Memory",
-		"",
-		`MEMORY.md exists in the active agent workspace as a memory file, not an instruction file. OpenClaw does not paste its contents into native Codex turns; use ${(params.toolNames?.length ? params.toolNames : Array.from(CODEX_MEMORY_TOOL_NAMES)).join(" or ")} when durable memory is relevant and the tools are available.`,
-		""
-	];
-	for (const file of params.files) lines.push(`- ${file.path}`);
-	return lines.join("\n").trim();
-}
-async function renderCodexWorkspaceMemoryCollaborationInstructions(params) {
-	const sections = [params.memoryToolRouted ? await renderCodexMemoryRecallInstructions({
-		toolNames: params.toolNames,
-		citationsMode: params.citationsMode,
-		agentId: params.agentId,
-		agentSessionKey: params.agentSessionKey,
-		sandboxed: params.sandboxed
-	}) : void 0, renderCodexWorkspaceMemoryReference({
-		files: params.files,
-		toolNames: params.toolNames
-	})].filter(isNonEmptyString$1);
-	return sections.length > 0 ? sections.join("\n\n") : void 0;
-}
-async function renderCodexMemoryRecallInstructions(params) {
-	const availableTools = new Set(params.toolNames);
-	const memoryPrompt = await prepareMemorySystemPromptAddition({
-		availableTools,
-		citationsMode: params.citationsMode,
-		agentId: params.agentId,
-		agentSessionKey: params.agentSessionKey,
-		sandboxed: params.sandboxed
-	});
-	if (!memoryPrompt) return;
-	return [memoryPrompt, renderCodexMemoryToolSearchBridge(params.toolNames)].filter(isNonEmptyString$1).join("\n").trim();
-}
-function renderCodexMemoryToolSearchBridge(toolNames) {
-	const memoryToolNames = toolNames.map((name) => normalizeCodexDynamicToolName(name)).filter((name) => CODEX_MEMORY_TOOL_NAMES.has(name)).toSorted();
-	if (memoryToolNames.length === 0) return;
-	return `Codex may expose ${memoryToolNames.join(" and ")} as deferred tools. When the memory guidance above calls for memory recall, use an already-loaded memory tool directly. If the needed memory tool is deferred and not currently callable, use \`tool_search\` to load it, then call that memory tool.`;
-}
-/** Lists available memory tool names understood by Codex workspace memory routing. */
-function getCodexWorkspaceMemoryToolNames(tools) {
-	const availableToolNames = new Set(flattenCodexDynamicToolFunctions(tools).map((tool) => normalizeCodexDynamicToolName(tool.name)));
-	return Array.from(CODEX_MEMORY_TOOL_NAMES).filter((name) => availableToolNames.has(name));
-}
-function canRouteCodexWorkspaceMemoryThroughTools(params) {
-	if (!params.config) return false;
-	return isSameCodexWorkspacePath(resolveAgentWorkspaceDir(params.config, params.agentId), params.workspaceDir);
-}
-function isMissingCodexBootstrapContextFile(file) {
-	return file.content.trimStart().startsWith("[MISSING] Expected at:");
-}
-function toCodexEmbeddedContextFile(file) {
-	return {
-		path: readNonBlankString(file.path) ?? readNonBlankString(file.name) ?? "",
-		content: file.content ?? ""
-	};
-}
-function isCodexWorkspaceRootMemoryBootstrapFile(params) {
-	return isCodexWorkspaceRootMemoryPath({
-		filePath: readNonBlankString(params.file.path) ?? readNonBlankString(params.file.name) ?? "",
-		workspaceDir: params.workspaceDir
-	});
-}
-function isCodexWorkspaceRootMemoryContextFile(params) {
-	if (!params.workspaceDir) return false;
-	return isCodexWorkspaceRootMemoryPath({
-		filePath: params.file.path,
-		workspaceDir: params.workspaceDir
-	});
-}
-function isCodexWorkspaceRootMemoryPath(params) {
-	const filePath = params.filePath.trim();
-	if (!filePath) return false;
-	return (path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(params.workspaceDir, filePath)) === path.join(path.resolve(params.workspaceDir), "MEMORY.md");
-}
-function isSameCodexWorkspacePath(left, right) {
-	return path.resolve(left) === path.resolve(right);
-}
-/**
-* Remaps bootstrap file paths from the resolved workspace to the effective Codex
-* workspace while preserving platform path separators.
-*/
-function remapCodexContextFilePath(params) {
-	const relativePath = path.relative(params.sourceWorkspaceDir, params.file.path);
-	if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath) || params.sourceWorkspaceDir === params.targetWorkspaceDir) return params.file;
-	const targetUsesPosixSeparators = params.targetWorkspaceDir.includes("/") && !params.targetWorkspaceDir.includes("\\");
-	const normalizedRelativePath = targetUsesPosixSeparators ? relativePath.replaceAll("\\", "/") : relativePath.replaceAll("/", "\\");
-	return {
-		...params.file,
-		path: targetUsesPosixSeparators ? path.posix.join(params.targetWorkspaceDir, normalizedRelativePath) : path.win32.join(params.targetWorkspaceDir, normalizedRelativePath)
-	};
-}
-function compareCodexContextFiles(left, right) {
-	const leftPath = normalizeCodexContextFilePath(left.path);
-	const rightPath = normalizeCodexContextFilePath(right.path);
-	const leftBase = getCodexContextFileBasename(left.path);
-	const rightBase = getCodexContextFileBasename(right.path);
-	const leftOrder = CODEX_BOOTSTRAP_CONTEXT_ORDER.get(leftBase) ?? Number.MAX_SAFE_INTEGER;
-	const rightOrder = CODEX_BOOTSTRAP_CONTEXT_ORDER.get(rightBase) ?? Number.MAX_SAFE_INTEGER;
-	if (leftOrder !== rightOrder) return leftOrder - rightOrder;
-	if (leftBase !== rightBase) return leftBase.localeCompare(rightBase);
-	return leftPath.localeCompare(rightPath);
-}
-function compareCodexBootstrapFiles(left, right) {
-	return compareCodexContextFiles(toCodexEmbeddedContextFile(left), toCodexEmbeddedContextFile(right));
-}
-function normalizeCodexContextFilePath(filePath) {
-	return filePath.trim().replaceAll("\\", "/").toLowerCase();
-}
-function getCodexContextFileDisplayBasename(filePath) {
-	return filePath.trim().replaceAll("\\", "/").split("/").pop()?.trim() ?? "";
-}
-function getCodexContextFileBasename(filePath) {
-	return normalizeCodexContextFilePath(filePath).split("/").pop() ?? "";
-}
-function normalizeCodexDynamicToolName(name) {
-	return name.trim().toLowerCase();
-}
-function isNonEmptyString$1(value) {
-	return typeof value === "string" && value.length > 0;
-}
-//#endregion
 //#region extensions/codex/src/app-server/run-attempt-state.ts
 async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields) {
 	const currentBinding = await bindingStore.read(identity);
@@ -4209,21 +3534,6 @@ function isCodexActiveCompactTurnError(error) {
 	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
 	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
 }
-function readCodexFinalizationHookNotification(notification, threadId, turnId) {
-	if (notification.method !== "hook/started" && notification.method !== "hook/completed") return;
-	const params = isJsonObject(notification.params) ? notification.params : void 0;
-	const run = params && isJsonObject(params.run) ? params.run : void 0;
-	if (params?.threadId !== threadId || params.turnId !== turnId || run?.eventName !== "stop" && run?.eventName !== "subagentStop" || typeof run.id !== "string" || !run.id) return;
-	if (notification.method === "hook/started") return {
-		phase: "started",
-		runId: run.id
-	};
-	return {
-		phase: "completed",
-		runId: run.id,
-		status: typeof run.status === "string" ? run.status : void 0
-	};
-}
 function joinPresentSections(...sections) {
 	return sections.filter((section) => Boolean(section?.trim())).join("\n\n");
 }
@@ -4231,34 +3541,6 @@ function prependCurrentInboundContext(prompt, context) {
 	const text = context?.text.trim();
 	return text ? [neutralizeCodexExplicitMentionSigils(text), prompt].filter(Boolean).join("\n\n") : prompt;
 }
-function buildCodexAppServerTimeoutDiagnostics(params) {
-	const readNonBlankDetailString = (key) => {
-		const value = params.details?.[key];
-		return hasNonEmptyString(value) ? value : void 0;
-	};
-	const activeAppServerTurnRequests = asFiniteNumber(params.details?.activeAppServerTurnRequests);
-	const activeTurnItemCount = asFiniteNumber(params.details?.activeTurnItemCount);
-	const terminalTurnNotificationQueued = asBoolean(params.details?.terminalTurnNotificationQueued);
-	const completionIdleWatchArmed = asBoolean(params.details?.completionIdleWatchArmed);
-	const assistantCompletionIdleWatchArmed = asBoolean(params.details?.assistantCompletionIdleWatchArmed);
-	const terminalIdleWatchArmed = asBoolean(params.details?.terminalIdleWatchArmed);
-	return {
-		...params.idleMs !== void 0 ? { idleMs: params.idleMs } : {},
-		...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
-		...params.lastActivityReason ? { lastActivityReason: params.lastActivityReason } : {},
-		...readNonBlankDetailString("lastNotificationMethod") ? { lastNotificationMethod: readNonBlankDetailString("lastNotificationMethod") } : {},
-		...readNonBlankDetailString("lastNotificationItemId") ? { lastNotificationItemId: readNonBlankDetailString("lastNotificationItemId") } : {},
-		...readNonBlankDetailString("lastNotificationItemType") ? { lastNotificationItemType: readNonBlankDetailString("lastNotificationItemType") } : {},
-		...readNonBlankDetailString("lastNotificationItemRole") ? { lastNotificationItemRole: readNonBlankDetailString("lastNotificationItemRole") } : {},
-		...readNonBlankDetailString("lastAssistantTextPreview") ? { lastAssistantTextPreview: readNonBlankDetailString("lastAssistantTextPreview") } : {},
-		...activeAppServerTurnRequests !== void 0 ? { activeAppServerTurnRequests } : {},
-		...activeTurnItemCount !== void 0 ? { activeTurnItemCount } : {},
-		...terminalTurnNotificationQueued !== void 0 ? { terminalTurnNotificationQueued } : {},
-		...completionIdleWatchArmed !== void 0 ? { completionIdleWatchArmed } : {},
-		...assistantCompletionIdleWatchArmed !== void 0 ? { assistantCompletionIdleWatchArmed } : {},
-		...terminalIdleWatchArmed !== void 0 ? { terminalIdleWatchArmed } : {}
-	};
-}
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-context.ts
 async function prepareCodexAttemptContext(runtime, attemptTools) {
@@ -4292,9 +3574,17 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		sessionKey: contextSessionKey,
 		sessionId: params.sessionId,
 		workspaceDir: params.workspaceDir,
-		messageProvider: params.messageProvider ?? void 0,
 		trigger: params.trigger,
-		channelId: hookChannelId,
+		...buildAgentHookContextChannelFields({
+			sessionKey: contextSessionKey,
+			messageChannel: params.messageChannel,
+			messageProvider: params.messageProvider,
+			currentChannelId: hookChannelId,
+			messageTo: params.messageTo,
+			senderId: params.senderId,
+			agentAccountId: params.agentAccountId
+		}),
+		channelContext: params.channelContext,
 		...hookContextWindowFields
 	};
 	const hookRunner = getAgentHarnessHookRunner();
@@ -4510,7 +3800,7 @@ function createCodexModelCallDiagnosticEmitter(params) {
 }
 /** Classifies model-call failures into timeout/abort buckets for diagnostics. */
 function classifyCodexModelCallFailureKind(params) {
-	if (params.timedOut || params.turnCompletionIdleTimedOut) return "timeout";
+	if (params.timedOut) return "timeout";
 	const errorMessage = params.error ? params.formatError(params.error).toLowerCase() : "";
 	if (errorMessage.includes("timed out") || errorMessage.includes("timeout")) return "timeout";
 	if (params.runAborted && !params.clientClosedAbort) return (typeof params.abortReason === "string" ? params.abortReason.toLowerCase() : params.abortReason ? params.formatError(params.abortReason).toLowerCase() : "").includes("timeout") ? "timeout" : "aborted";
@@ -4518,38 +3808,17 @@ function classifyCodexModelCallFailureKind(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-results.ts
-const CODEX_APP_SERVER_MISSING_TERMINAL_EVENT_USER_MESSAGE = "Codex stopped before confirming the turn was complete. The response may be incomplete; retry if needed.";
-const CODEX_APP_SERVER_MISSING_TERMINAL_EVENT_SIDE_EFFECT_USER_MESSAGE = "Codex stopped before confirming the turn was complete. Some work may already have been performed; verify the current state before retrying.";
-const CODEX_APP_SERVER_TERMINAL_IDLE_USER_MESSAGE = "Codex stopped responding: no activity arrived for the turn's liveness window, so the turn was ended and the connection was replaced. Retry to continue on a fresh session.";
 /** Joins terminal assistant text blocks into the final attempt answer. */
 function collectTerminalAssistantText(result) {
 	return result.assistantTexts.join("\n\n").trim();
 }
-/**
-* Builds the user-facing timeout outcome when Codex stops without a terminal
-* turn event.
-*/
-function buildCodexAppServerPromptTimeoutOutcome(params) {
-	if (!params.turnCompletionIdleTimedOut) return;
-	if (params.turnWatchTimeoutKind === "terminal") {
-		if (collectTerminalAssistantText(params.result)) return;
-		const terminalReplayBlockedReason = resolveCodexAppServerReplayBlockedReason(params.result);
-		return {
-			message: CODEX_APP_SERVER_TERMINAL_IDLE_USER_MESSAGE,
-			...terminalReplayBlockedReason ? {
-				replayInvalid: true,
-				livenessState: "abandoned"
-			} : {}
-		};
-	}
-	if (params.turnWatchTimeoutKind !== void 0 && params.turnWatchTimeoutKind !== "completion") return;
-	const replayBlockedReason = resolveCodexAppServerReplayBlockedReason(params.result);
+/** Reports the owner's deadline without guessing whether native work finished. */
+function buildCodexAppServerPromptTimeoutOutcome(timeout) {
+	if (!timeout) return;
 	return {
-		message: replayBlockedReason === "tool_activity" || replayBlockedReason === "potential_side_effect" || replayBlockedReason === "active_item" ? CODEX_APP_SERVER_MISSING_TERMINAL_EVENT_SIDE_EFFECT_USER_MESSAGE : CODEX_APP_SERVER_MISSING_TERMINAL_EVENT_USER_MESSAGE,
-		...replayBlockedReason ? {
-			replayInvalid: true,
-			livenessState: "abandoned"
-		} : {}
+		message: timeout.kind === "execution" ? "Codex reached the configured execution time limit. Some work may already have been performed; verify the current state before continuing." : "Codex finished its turn, but OpenClaw could not finish processing the result. Some work may already have been performed; verify the current state before continuing.",
+		replayInvalid: true,
+		livenessState: "abandoned"
 	};
 }
 /** Explains why an incomplete app-server turn cannot be safely replayed. */
@@ -4671,52 +3940,44 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
 	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, agentDir, attemptStartedAt, startupAuthProfileId } = connection;
 	const { toolBridge, toolState } = attemptTools;
-	const { state, completion, pendingOpenClawDynamicToolCompletionIds, activeTurnItemIds, activeCompletionBlockerItemIds, activeFinalizationHookRunIds, turnWatches } = turnRuntime;
+	const { state, completion, deadlines } = turnRuntime;
 	const { emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { drainNotificationQueue } = notifications;
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, activeProjector, streamState, freezeRunTerminalOutcome, notifyUserMessagePersisted } = activeTurn;
 	await completion;
-	await state.abortCleanup;
-	const drain = drainNotificationQueue();
 	const abortGraceElapsed = createDeferred();
+	let settlementClosed = false;
 	let abortGraceTimer;
-	const abortListener = addAbortListener(runAbortController.signal, () => {
+	const beginAbortGrace = () => {
+		if (settlementClosed) return;
 		abortGraceTimer = setTimeout(() => abortGraceElapsed.resolve(), TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
 		abortGraceTimer.unref?.();
+	};
+	const abortListener = addAbortListener(runAbortController.signal, () => {
+		state.abortCleanup.then(beginAbortGrace, beginAbortGrace);
 	});
+	const closeProjection = () => {
+		state.projectionClosed = true;
+		return activeProjector.closeProjection();
+	};
+	const settlement = drainNotificationQueue().then(closeProjection);
 	try {
-		await Promise.race([drain, abortGraceElapsed.promise]);
+		await Promise.race([settlement, abortGraceElapsed.promise]);
+		if (runAbortController.signal.aborted) await state.abortCleanup;
 	} finally {
+		settlementClosed = true;
 		abortListener[Symbol.dispose]();
 		clearTimeout(abortGraceTimer);
-	}
-	const hasQuiescentCompletedAssistant = activeProjector.hasCompletedTerminalAssistantText() && state.activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && activeFinalizationHookRunIds.size === 0 && state.unsettledFinalizationHookCount === 0 && state.rejectedFinalizationHookAssistant === void 0;
-	const hasRecoverableCompletedAssistant = !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && turnWatches.isAssistantCompletionIdleWatchArmed() && hasQuiescentCompletedAssistant;
-	const recoveredTurnWatchTimeout = state.turnCompletionIdleTimedOut && !terminalState.explicitCancellationObserved && hasRecoverableCompletedAssistant && activeProjector.recoverCompletedTerminalAssistantAfterTurnWatchTimeout();
-	if (recoveredTurnWatchTimeout) {
-		embeddedAgentLog.warn("codex app-server recovered completed assistant output after missing turn completion", {
-			threadId: resourceState.thread.threadId,
-			turnId: activeTurnId,
-			timeoutKind: state.turnWatchTimeoutKind,
-			idleMs: state.turnWatchTimeoutIdleMs,
-			timeoutMs: state.turnWatchTimeoutMs
-		});
-		trajectoryRecorder?.recordEvent("turn.watch_timeout_recovered", {
-			threadId: resourceState.thread.threadId,
-			turnId: activeTurnId,
-			timeoutKind: state.turnWatchTimeoutKind,
-			idleMs: state.turnWatchTimeoutIdleMs,
-			timeoutMs: state.turnWatchTimeoutMs
-		});
+		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.timedOut && !recoveredTurnWatchTimeout;
-	const effectiveTurnCompletionIdleTimedOut = state.turnCompletionIdleTimedOut && !recoveredTurnWatchTimeout;
-	const isFinalAborted = () => terminalState.explicitCancellationObserved || !resourceState.executionDisconnectError && (projectedTerminal.aborted || runAbortController.signal.aborted && !state.clientClosedAbort && !recoveredTurnWatchTimeout);
-	const clientClosedPromptErrorForFinal = state.clientClosedPromptError && hasRecoverableCompletedAssistant ? void 0 : state.clientClosedPromptError;
-	let finalPromptError = resourceState.executionDisconnectError ?? clientClosedPromptErrorForFinal ?? (effectiveTurnCompletionIdleTimedOut ? state.turnCompletionIdleTimeoutMessage : effectiveTimedOut ? "codex app-server attempt timed out" : projectedTerminal.promptError);
+	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",
@@ -4759,33 +4020,23 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	});
 	finalPromptError = resourceState.executionDisconnectError ?? finalPromptError;
 	const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : projectedTerminal.promptErrorSource;
-	const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : effectiveTurnCompletionIdleTimedOut ? "turn_completion_idle_timeout" : void 0;
+	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({
-		result,
-		turnCompletionIdleTimedOut: effectiveTurnCompletionIdleTimedOut,
-		turnWatchTimeoutKind: state.turnWatchTimeoutKind
-	});
-	const failureDiagnostics = codexAppServerFailureKind === "client_closed_before_turn_completed" && state.clientClosedDiagnostic ? { transportError: state.clientClosedDiagnostic } : codexAppServerFailureKind === "turn_completion_idle_timeout" && state.turnWatchTimeoutKind === "completion" ? buildCodexAppServerTimeoutDiagnostics({
-		idleMs: state.turnWatchTimeoutIdleMs,
-		timeoutMs: state.turnWatchTimeoutMs,
-		lastActivityReason: state.turnWatchTimeoutLastActivityReason,
-		details: state.turnWatchTimeoutDetails
-	}) : 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,
-		...codexAppServerFailureKind === "turn_completion_idle_timeout" && state.turnWatchTimeoutKind ? { turnWatchTimeoutKind: state.turnWatchTimeoutKind } : {},
 		transport: appServer.start.transport,
 		threadId: resourceState.thread.threadId,
 		turnId: activeTurnId,
-		replaySafe: replayBlockedReason === void 0,
+		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.terminalTurnNotificationQueued) && !state.timedOut && clientClosedPromptErrorForFinal === void 0;
-	const turnSucceeded = !finalAborted && !effectiveTimedOut && (finalPromptError === null || finalPromptError === void 0) && (completedTurnStatus === "completed" || recoveredTurnWatchTimeout || locallyCompletedTurn);
+	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;
@@ -4799,7 +4050,6 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const modelCallFailureKind = classifyCodexModelCallFailureKind({
 		error: finalPromptError,
 		timedOut: effectiveTimedOut,
-		turnCompletionIdleTimedOut: effectiveTurnCompletionIdleTimedOut,
 		runAborted: finalAborted,
 		abortReason: terminalState.explicitCancellationReason ?? runAbortController.signal.reason,
 		clientClosedAbort: state.clientClosedAbort,
@@ -4952,9 +4202,6 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-notification-state.ts
-/**
-* State machine for Codex app-server turn notifications and idle-watch updates.
-*/
 /** Emits coarse execution phases exactly once from app-server notifications. */
 function reportCodexExecutionNotification(params) {
 	const { notification } = params;
@@ -4978,82 +4225,7 @@ function reportCodexExecutionNotification(params) {
 }
 /** Returns true when a notification ends the current app-server turn. */
 function isTerminalCodexTurnNotificationForTurn(params) {
-	if (!isCodexNotificationForTurn(params.notification.params, params.threadId, params.turnId)) return false;
-	return params.notification.method === "turn/completed";
-}
-/**
-* Applies one notification to active item tracking, idle watches, and terminal
-* turn state.
-*/
-function applyCodexTurnNotificationState(params) {
-	const { notification, turnWatches } = params;
-	const isCurrentTurnNotification = isCodexNotificationForTurn(notification.params, params.threadId, params.turnId);
-	const isTurnCompletion = notification.method === "turn/completed" && isCurrentTurnNotification;
-	let turnCrossedToolHandoff = params.turnCrossedToolHandoff;
-	if (isCurrentTurnNotification) {
-		updateActiveTurnItemIds(notification, params.activeTurnItemIds);
-		updateActiveCompletionBlockerItemIds(notification, params.activeCompletionBlockerItemIds);
-		turnWatches.touchActivity(`notification:${notification.method}`, {
-			details: describeNotificationActivity(notification),
-			attemptProgress: true
-		});
-		params.onReportExecutionNotification(notification);
-		if (notification.method === "item/completed" && params.activeTurnItemIds.size === 0) params.onScheduleTerminalDynamicToolReleaseCheck();
-	}
-	const unblockedAssistantCompletionRelease = isCurrentTurnNotification && turnWatches.isAssistantCompletionIdleWatchArmed() && notification.method === "item/completed" && params.activeTurnItemIds.size === 0;
-	const trackedDynamicToolCompletion = isPendingOpenClawDynamicToolCompletionNotification(notification, params.pendingOpenClawDynamicToolCompletionIds);
-	const rawToolOutputCompletion = isRawToolOutputCompletionNotification(notification);
-	if (isCurrentTurnNotification && (rawToolOutputCompletion || isNativeToolProgressNotification(notification))) turnCrossedToolHandoff = true;
-	const assistantCompletionCanRelease = isAssistantCompletionReleaseNotification(notification, turnCrossedToolHandoff);
-	const postToolProgressNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && ((isRawAssistantProgressNotification(notification) || isRawReasoningCompletionNotification(notification)) && params.activeTurnItemIds.size === 0 || isReasoningProgressNotification(notification));
-	const postToolPatchUpdateNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && isFileChangePatchUpdatedNotification(notification);
-	const rawResponseItemCompletedWithNoActiveItems = isCurrentTurnNotification && notification.method === "rawResponseItem/completed" && params.activeTurnItemIds.size === 0 && params.activeAppServerTurnRequests === 0 && !assistantCompletionCanRelease && !postToolProgressNeedsTerminalGuard && !rawToolOutputCompletion;
-	const shouldArmNoToolPostProgressReplyWatch = isCurrentTurnNotification && !turnCrossedToolHandoff && params.activeTurnItemIds.size === 0 && (isReasoningItemCompletionNotification(notification) || isAssistantCommentaryCompletionNotification(notification));
-	const shouldArmNoToolPostRawProgressReplyWatch = !turnCrossedToolHandoff && rawResponseItemCompletedWithNoActiveItems && (isRawReasoningCompletionNotification(notification) || isRawAssistantProgressNotification(notification));
-	const shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem = isCurrentTurnNotification && notification.method === "item/completed" && params.activeTurnItemIds.size === 0 && !trackedDynamicToolCompletion && !assistantCompletionCanRelease && !shouldArmNoToolPostProgressReplyWatch;
-	const shouldUsePostToolContinuationWatch = turnCrossedToolHandoff && (postToolProgressNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard || rawToolOutputCompletion || trackedDynamicToolCompletion || shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem);
-	const armPostToolContinuationWatch = () => {
-		turnWatches.armCompletionIdleWatch({ timeoutMs: params.postToolRawAssistantCompletionIdleTimeoutMs });
-		turnWatches.extendAttemptIdleWatch(params.postToolRawAssistantCompletionIdleTimeoutMs);
-	};
-	const armPostProgressReplyWatch = () => {
-		turnWatches.armCompletionIdleWatch({ timeoutMs: CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS });
-		turnWatches.extendAttemptIdleWatch(CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS);
-	};
-	if (isCurrentTurnNotification && notification.method === "error") {
-		if (isRetryableErrorNotification(notification.params)) turnWatches.disarmCompletionIdleWatch();
-		else turnWatches.armCompletionIdleWatch({ pinnedByTerminalError: true });
-		turnWatches.disarmAssistantCompletionIdleWatch();
-	} else if (isTurnCompletion) turnWatches.disarmAssistantCompletionIdleWatch();
-	else if (isCurrentTurnNotification && assistantCompletionCanRelease) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
-	else if (postToolProgressNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard) armPostToolContinuationWatch();
-	else if (shouldArmNoToolPostProgressReplyWatch || shouldArmNoToolPostRawProgressReplyWatch) armPostProgressReplyWatch();
-	else if (trackedDynamicToolCompletion) armPostToolContinuationWatch();
-	else if (unblockedAssistantCompletionRelease) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
-	else if (shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) {
-		if (shouldUsePostToolContinuationWatch) armPostToolContinuationWatch();
-		else turnWatches.armCompletionIdleWatch();
-	} else if (rawResponseItemCompletedWithNoActiveItems) turnWatches.armCompletionIdleWatch();
-	else if (isCurrentTurnNotification && rawToolOutputCompletion) armPostToolContinuationWatch();
-	else if (isCurrentTurnNotification && shouldDisarmAssistantCompletionIdleWatch(notification)) turnWatches.disarmAssistantCompletionIdleWatch();
-	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolProgressNeedsTerminalGuard && !postToolPatchUpdateNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmNoToolPostProgressReplyWatch && !shouldArmNoToolPostRawProgressReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
-	if (trackedDynamicToolCompletion) {
-		const itemId = readNotificationItemId(notification);
-		if (itemId) {
-			params.pendingOpenClawDynamicToolCompletionIds.delete(itemId);
-			params.onScheduleTerminalDynamicToolReleaseCheck();
-		}
-	}
-	return {
-		isCurrentTurnNotification,
-		isTurnAbortMarker: isCurrentTurnNotification && isCodexTurnAbortMarkerNotification(notification, { currentPromptTexts: params.currentPromptTexts }),
-		isTurnTerminal: isTerminalCodexTurnNotificationForTurn({
-			notification,
-			threadId: params.threadId,
-			turnId: params.turnId
-		}),
-		turnCrossedToolHandoff
-	};
+	return params.notification.method === "turn/completed" && isCodexNotificationForTurn(params.notification.params, params.threadId, params.turnId) && readCodexTurnCompletedNotification(params.notification.params) !== void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-lifecycle-terminal.ts
@@ -5248,10 +4420,9 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const { prompt, state: resourceState, projectorRef, registerNativeSubagentMonitor } = resources;
 	const { context, turnState } = prompt;
 	const { attemptTools, runtime } = context;
-	const { connection } = runtime;
-	const { appServer, runAbortController } = connection;
+	const { appServer, runAbortController } = runtime.connection;
 	const { allocateCodexToolOutcomeOrdinal } = attemptTools;
-	const { state, turnIdRef, userInputBridgeRef, steeringQueueRef, turnWatches, activeTurnItemIds, activeCompletionBlockerItemIds, activeFinalizationHookRunIds, finalizationHookBatchStatuses, pendingOpenClawDynamicToolCompletionIds, postToolRawAssistantCompletionIdleTimeoutMs, completeTurn } = turnRuntime;
+	const { state, turnIdRef, userInputBridgeRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, completeTurn, noteProgress, deadlines } = turnRuntime;
 	const { scheduleTerminalDynamicToolReleaseCheck, reportExecutionNotification, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const isTerminalTurnNotificationForTurn = (notification, notificationTurnId) => isTerminalCodexTurnNotificationForTurn({
 		notification,
@@ -5259,81 +4430,47 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		turnId: notificationTurnId
 	});
 	const handleNotification = async (notification) => {
+		if (state.projectionClosed) return;
 		const projector = projectorRef.current;
 		const turnId = turnIdRef.current;
-		const steeringQueue = steeringQueueRef.current;
 		userInputBridgeRef.current?.handleNotification(notification);
 		if (!projector || !turnId) {
 			if (notification.method === "error") state.latestStartupErrorNotification = notification;
 			return;
 		}
-		if ((state.timedOut || state.localCompletionRequested) && notification.method === "turn/completed" && readCodexTurnCompletedNotification(notification.params)?.turn.status === "interrupted") {
+		const isCurrentTurn = isCodexNotificationForTurn(notification.params, resourceState.thread.threadId, turnId);
+		const isTerminal = isTerminalTurnNotificationForTurn(notification, turnId);
+		if ((state.timeout || state.localCompletionRequested) && isTerminal && readCodexTurnCompletedNotification(notification.params)?.turn.status === "interrupted") {
 			completeTurn();
 			return;
 		}
-		const notificationState = applyCodexTurnNotificationState({
-			notification,
-			threadId: resourceState.thread.threadId,
-			turnId,
-			currentPromptTexts: [turnState.codexTurnPromptText],
-			turnWatches,
-			activeTurnItemIds,
-			activeCompletionBlockerItemIds,
-			activeAppServerTurnRequests: state.activeAppServerTurnRequests,
-			pendingOpenClawDynamicToolCompletionIds,
-			turnCrossedToolHandoff: state.turnCrossedToolHandoff,
-			postToolRawAssistantCompletionIdleTimeoutMs,
-			onScheduleTerminalDynamicToolReleaseCheck: scheduleTerminalDynamicToolReleaseCheck,
-			onReportExecutionNotification: reportExecutionNotification
-		});
-		state.turnCrossedToolHandoff = notificationState.turnCrossedToolHandoff;
-		if (notificationState.isCurrentTurnNotification && notification.method === "item/completed") {
-			const item = readCodexNotificationItem(notification.params);
-			if (item?.type === "userMessage" && typeof item.clientId === "string") await steeringQueue?.confirmConsumed(item.clientId);
-		}
-		if (notificationState.isTurnAbortMarker) state.sawCodexInterruptMarker = true;
-		const hookNotification = readCodexFinalizationHookNotification(notification, resourceState.thread.threadId, turnId);
-		if (hookNotification?.phase === "started") {
-			if (activeFinalizationHookRunIds.size === 0) finalizationHookBatchStatuses.clear();
-			activeFinalizationHookRunIds.add(hookNotification.runId);
-			turnWatches.disarmAssistantCompletionIdleWatch();
-		}
-		if (notificationState.isTurnTerminal) state.terminalTurnNotificationQueued = true;
+		state.activeLocalProjections += 1;
 		try {
-			await projector.handleNotification(notification);
-			const canRelease = isAssistantCompletionReleaseNotification(notification, state.turnCrossedToolHandoff) || notificationState.isCurrentTurnNotification && state.turnCrossedToolHandoff && notification.method === "rawResponseItem/completed" && projector.canReleaseLatestTerminalAssistantAfterToolHandoff();
-			if (notificationState.isCurrentTurnNotification && canRelease) {
-				const itemId = projector.getLatestTerminalAssistantCandidate()?.itemId;
-				if (state.rejectedFinalizationHookAssistant && itemId && itemId !== state.rejectedFinalizationHookAssistant.itemId) state.rejectedFinalizationHookAssistant = void 0;
-				else if (state.rejectedFinalizationHookAssistant) turnWatches.disarmAssistantCompletionIdleWatch();
-				else if (activeFinalizationHookRunIds.size === 0 && !state.terminalTurnNotificationQueued && state.activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && projector.hasLatestTerminalAssistantCandidateText()) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
+			if (isCurrentTurn) {
+				updateActiveTurnItemIds(notification, activeTurnItemIds);
+				noteProgress(`notification:${notification.method}`);
+				reportExecutionNotification(notification);
+				if (isPendingOpenClawDynamicToolCompletionNotification(notification, pendingOpenClawDynamicToolCompletionIds)) {
+					const itemId = readNotificationItemId(notification);
+					if (itemId) pendingOpenClawDynamicToolCompletionIds.delete(itemId);
+				}
+				if (notification.method === "item/completed") {
+					if (activeTurnItemIds.size === 0) scheduleTerminalDynamicToolReleaseCheck();
+					const item = readCodexNotificationItem(notification.params);
+					if (item?.type === "userMessage" && typeof item.clientId === "string") await steeringQueueRef.current?.confirmConsumed(item.clientId);
+				}
+				if (isCodexTurnAbortMarkerNotification(notification, { currentPromptTexts: [turnState.codexTurnPromptText] })) state.sawCodexInterruptMarker = true;
 			}
-			if (notificationState.isCurrentTurnNotification && activeTurnItemIds.size === 0 && isRawFunctionToolOutputCompletionNotification(notification)) await maybeAnnounceFastModeAutoOff();
+			await projector.handleNotification(notification);
+			if (isCurrentTurn && activeTurnItemIds.size === 0 && isRawFunctionToolOutputCompletionNotification(notification)) await maybeAnnounceFastModeAutoOff();
 		} catch (error) {
 			embeddedAgentLog.debug("codex app-server projector notification threw", {
 				method: notification.method,
 				error
 			});
 		} finally {
-			if (hookNotification?.phase === "completed") {
-				state.unsettledFinalizationHookCount = Math.max(0, state.unsettledFinalizationHookCount - 1);
-				activeFinalizationHookRunIds.delete(hookNotification.runId);
-				finalizationHookBatchStatuses.set(hookNotification.runId, hookNotification.status);
-				if (activeFinalizationHookRunIds.size === 0) {
-					const statuses = new Set(finalizationHookBatchStatuses.values());
-					if (statuses.has("blocked") && !statuses.has("stopped")) {
-						const itemId = projector.getLatestTerminalAssistantCandidate()?.itemId;
-						state.rejectedFinalizationHookAssistant = itemId ? { itemId } : {};
-						turnWatches.disarmAssistantCompletionIdleWatch();
-					} else state.rejectedFinalizationHookAssistant = void 0;
-				}
-				if (activeFinalizationHookRunIds.size === 0 && state.rejectedFinalizationHookAssistant === void 0 && !state.terminalTurnNotificationQueued && state.activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && projector.hasLatestTerminalAssistantCandidateText()) turnWatches.armAssistantCompletionIdleWatch({
-					lastNotificationMethod: notification.method,
-					hookRunId: hookNotification.runId,
-					hookStatus: hookNotification.status
-				});
-			}
-			if (notificationState.isTurnTerminal) {
+			state.activeLocalProjections -= 1;
+			if (isTerminal) {
 				if ((readCodexTurnCompletedNotification(notification.params)?.turn)?.status === "interrupted" && state.sawCodexInterruptMarker) projector.markAborted();
 				completeTurn();
 			}
@@ -5358,10 +4495,12 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const noteNotificationReceived = (notification, scope, receivedAtMs) => {
 		const projector = projectorRef.current;
 		const turnId = turnIdRef.current;
-		if (!projector || !turnId) return;
+		if (!projector || !turnId || state.projectionClosed) return;
+		projector.recordMcpToolCallReceipt(notification);
 		if (isTerminalTurnNotificationForTurn(notification, turnId)) {
 			state.terminalTurnNotificationQueued = true;
 			steeringQueueRef.current?.sealAdmission();
+			deadlines.beginSettlement(receivedAtMs);
 		}
 		if (scope.turnId === turnId) {
 			const modelToolCallId = readRawResponseToolCallId(notification);
@@ -5369,11 +4508,6 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			const nativeItem = readCodexNotificationItem(notification.params);
 			if (nativeItem?.type === "webSearch") projector.recordNativeToolOutcome(nativeItem);
 		}
-		if (readCodexFinalizationHookNotification(notification, resourceState.thread.threadId, turnId)?.phase === "started") {
-			state.unsettledFinalizationHookCount += 1;
-			turnWatches.disarmAssistantCompletionIdleWatch();
-		}
-		turnWatches.noteNotificationReceived(notification.method, { receivedAtMs });
 	};
 	const enqueueNotification = async (notification, scope) => {
 		embeddedAgentLog.trace("codex app-server raw notification received", {
@@ -5863,6 +4997,8 @@ function prepareCodexAttemptResources(prompt) {
 			sessionId: params.sessionId,
 			sessionKey: contextSessionKey,
 			config: params.config,
+			autoApproveMcpTools: shouldAutoApproveCodexAppServerApprovals(appServer),
+			projectedMcpServers: runtime.bundleMcpThreadConfig.configPatch?.mcp_servers,
 			runId: params.runId,
 			channelId: hookChannelId,
 			...requester ? { requester } : {},
@@ -6004,297 +5140,6 @@ function prewarmCodexAttemptClient(params) {
 	});
 }
 //#endregion
-//#region extensions/codex/src/app-server/scheduled-app-authority.ts
-const CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE = "codex.apps";
-const CODEX_APPS_MCP_SERVER = "codex_apps";
-const MCP_STATUS_PAGE_SIZE = 100;
-const MCP_STATUS_MAX_PAGES = 100;
-const CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS = 6e4;
-const CODEX_APP_AUTHORITY_CAPTURE_MIN_TIMEOUT_MS = 100;
-function resolveScheduledCodexAppCreatorCaptureDecision(params) {
-	if (!params.appsMayBeVisible) return {
-		required: false,
-		supported: false
-	};
-	const unavailableReason = params.authenticatedScheduledMode ? "A scheduled Codex continuation cannot create new app-authorized automations. Recreate it from a fresh authenticated owner turn; no automation changes were saved." : params.usesSupervisionConnection ? "Codex apps are visible through a supervised connection that cannot capture creator authority. Use an isolated prepared-profile Codex creator turn; no automation changes were saved." : params.homeScope === "user" ? "Codex apps are visible through a user-home runtime that cannot capture isolated creator authority. Use an agent-scoped prepared-profile Codex creator turn; no automation changes were saved." : !params.hasPreparedAccountIdentity ? "Codex app authority requires a genuine ChatGPT account identity. Reauthenticate the selected Codex profile, then retry; no automation changes were saved." : void 0;
-	return {
-		required: true,
-		supported: !unavailableReason,
-		...unavailableReason ? { unavailableReason } : {}
-	};
-}
-function normalizeApprovalMode(value) {
-	return value === "allow" || value === "deny" || value === "auto" || value === "ask" ? value : void 0;
-}
-function normalizeAppToolApprovalMode(value) {
-	return value === "auto" || value === "prompt" || value === "writes" || value === "approve" ? value : void 0;
-}
-function defaultApprovalMode(entry) {
-	return entry.destructiveApprovalMode ?? (entry.allowDestructiveActions ? "allow" : "deny");
-}
-function parseScheduledCodexAppAuthority(authority) {
-	if (!authority || authority.runtimeId !== "codex") return;
-	if (authority.version !== 1) throw new Error("Unsupported Codex scheduled authority version; reauthorize this automation.");
-	if (authority.namespace !== CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE) throw new Error(`Unsupported Codex scheduled authority namespace ${authority.namespace}; reauthorize this automation.`);
-	const payload = asOptionalRecord(authority.payload);
-	const auth = asOptionalRecord(payload?.auth);
-	const profileId = normalizeOptionalString(auth?.profileId);
-	const accountId = normalizeOptionalString(auth?.accountId);
-	if (payload?.version !== 1 || !profileId || !accountId || !Array.isArray(payload.apps)) throw new Error("Stored Codex app authority is invalid; reauthorize this automation.");
-	const seen = /* @__PURE__ */ new Set();
-	const apps = payload.apps.map((raw) => {
-		const app = asOptionalRecord(raw);
-		const id = normalizeOptionalString(app?.id);
-		const destructiveApprovalMode = normalizeApprovalMode(app?.destructiveApprovalMode);
-		const rawTools = asOptionalRecord(app?.tools);
-		if (!id || seen.has(id) || typeof app?.allowDestructiveActions !== "boolean" || typeof app.allowOpenWorld !== "boolean" || !destructiveApprovalMode || !rawTools) throw new Error("Stored Codex app authority is invalid; reauthorize this automation.");
-		seen.add(id);
-		const tools = {};
-		for (const [name, rawMode] of Object.entries(rawTools)) {
-			const toolName = normalizeOptionalString(name);
-			const mode = normalizeAppToolApprovalMode(rawMode);
-			if (!toolName || !mode) throw new Error("Stored Codex app authority is invalid; reauthorize this automation.");
-			tools[toolName] = mode;
-		}
-		return {
-			id,
-			allowDestructiveActions: app.allowDestructiveActions,
-			allowOpenWorld: app.allowOpenWorld,
-			destructiveApprovalMode,
-			tools
-		};
-	});
-	return {
-		version: 1,
-		auth: {
-			profileId,
-			accountId
-		},
-		apps
-	};
-}
-async function readCodexScheduledAppToolNamesByApp(params) {
-	const toolNamesByApp = /* @__PURE__ */ new Map();
-	const seenCursors = /* @__PURE__ */ new Set();
-	let cursor;
-	for (let page = 0; page < MCP_STATUS_MAX_PAGES; page += 1) {
-		const response = await params.request("mcpServerStatus/list", {
-			...params.threadId ? { threadId: params.threadId } : {},
-			detail: "toolsAndAuthOnly",
-			limit: MCP_STATUS_PAGE_SIZE,
-			...cursor ? { cursor } : {}
-		});
-		if (!isJsonObject(response) || !Array.isArray(response.data)) throw new Error("Codex mcpServerStatus/list returned invalid scheduled app inventory");
-		for (const status of response.data) {
-			if (!isJsonObject(status) || !isJsonObject(status.tools)) throw new Error("Codex scheduled app inventory contained an invalid server status");
-			if (status.name !== CODEX_APPS_MCP_SERVER) continue;
-			for (const [toolName, tool] of Object.entries(status.tools)) {
-				const connectorId = readCodexMcpToolConnectorId(tool);
-				if (connectorId) {
-					const names = toolNamesByApp.get(connectorId) ?? /* @__PURE__ */ new Set();
-					names.add(toolName);
-					toolNamesByApp.set(connectorId, names);
-				}
-			}
-		}
-		if (response.nextCursor !== void 0 && response.nextCursor !== null && typeof response.nextCursor !== "string") throw new Error("Codex scheduled app inventory returned an invalid pagination cursor");
-		cursor = response.nextCursor;
-		if (!cursor) return toolNamesByApp;
-		if (seenCursors.has(cursor)) throw new Error("Codex app connector inventory repeated its pagination cursor");
-		seenCursors.add(cursor);
-	}
-	throw new Error("Codex app connector inventory exceeded its bounded page limit");
-}
-/** Reads the current account policy and connector-backed tool names under one caller deadline. */
-async function readCurrentCodexScheduledAppPolicy$1(params) {
-	const [configResponse, toolNamesByApp] = await Promise.all([params.request("config/read", {
-		includeLayers: false,
-		...params.configCwd ? { cwd: params.configCwd } : {}
-	}), readCodexScheduledAppToolNamesByApp(params)]);
-	if (!isJsonObject(configResponse)) throw new Error("Codex config/read returned an invalid scheduled app policy response");
-	return {
-		config: isJsonObject(configResponse.config) ? configResponse.config : {},
-		toolNamesByApp
-	};
-}
-function readToolApprovalMode(config, appId, toolName, fallback = "auto") {
-	const app = asOptionalRecord(asOptionalRecord(config.apps)?.[appId]);
-	return normalizeAppToolApprovalMode(asOptionalRecord(asOptionalRecord(app?.tools)?.[toolName])?.approval_mode) ?? fallback;
-}
-/** Captures only apps callable on the exact active Codex client/thread. */
-async function captureScheduledCodexAppAuthority(params) {
-	const requestedTimeoutMs = params.timeoutMs ?? CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS;
-	const timeoutMs = Math.min(CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS, Math.max(CODEX_APP_AUTHORITY_CAPTURE_MIN_TIMEOUT_MS, Number.isFinite(requestedTimeoutMs) ? Math.floor(requestedTimeoutMs) : CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS));
-	const deadlineMs = Date.now() + timeoutMs;
-	const boundedClient = { request: ((method, requestParams) => {
-		const remainingTimeoutMs = deadlineMs - Date.now();
-		if (remainingTimeoutMs <= 0) throw new CodexScheduledAppAuthorityCaptureTimeoutError();
-		return params.client.request(method, requestParams, {
-			timeoutMs: remainingTimeoutMs,
-			signal: params.signal
-		});
-	}) };
-	let installed;
-	let currentPolicy;
-	try {
-		[installed, currentPolicy] = await withAbortableTimeout({
-			promise: Promise.all([boundedClient.request("app/installed", {
-				threadId: params.threadId,
-				forceRefresh: false
-			}), readCurrentCodexScheduledAppPolicy$1({
-				request: (method, requestParams) => boundedClient.request(method, requestParams),
-				threadId: params.threadId,
-				configCwd: params.configCwd
-			})]),
-			timeoutMs,
-			signal: params.signal,
-			timeoutMessage: "Codex scheduled app authority capture deadline elapsed",
-			createTimeoutError: () => new CodexScheduledAppAuthorityCaptureTimeoutError()
-		});
-	} catch (error) {
-		if (params.signal?.aborted || !(error instanceof CodexScheduledAppAuthorityCaptureTimeoutError) && !isCodexAppServerRequestTimeoutError(error)) throw error;
-		throw new Error(`Codex app authority capture exceeded its ${timeoutMs} ms total budget. No automation changes were saved; retry after Codex app inventory is responsive.`, { cause: error });
-	}
-	const callableIds = new Set(installed.apps.filter((app) => app.enabled && app.callable).map((app) => app.id));
-	const apps = Object.entries(params.policyContext.apps).filter(([id]) => callableIds.has(id) && currentPolicy.toolNamesByApp.has(id)).map(([id, policy]) => ({
-		id,
-		allowDestructiveActions: policy.allowDestructiveActions,
-		allowOpenWorld: policy.allowOpenWorld !== false,
-		destructiveApprovalMode: defaultApprovalMode(policy),
-		tools: Object.fromEntries([...currentPolicy.toolNamesByApp.get(id) ?? []].toSorted().map((toolName) => [toolName, readToolApprovalMode(currentPolicy.config, id, toolName, appApprovalCeiling(defaultApprovalMode(policy)))]))
-	})).toSorted((left, right) => left.id.localeCompare(right.id));
-	if (apps.length === 0) return;
-	return {
-		version: 1,
-		runtimeId: "codex",
-		namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
-		payload: {
-			version: 1,
-			auth: {
-				profileId: params.profileId,
-				accountId: params.accountId
-			},
-			apps
-		}
-	};
-}
-var CodexScheduledAppAuthorityCaptureTimeoutError = class extends Error {
-	constructor() {
-		super("Codex scheduled app authority capture deadline elapsed");
-		this.name = "CodexScheduledAppAuthorityCaptureTimeoutError";
-	}
-};
-const APPROVAL_RANK = {
-	deny: 0,
-	ask: 1,
-	auto: 2,
-	allow: 3
-};
-function stricterApprovalMode(left, right) {
-	return APPROVAL_RANK[left] <= APPROVAL_RANK[right] ? left : right;
-}
-function intersectToolApprovalMode(captured, current) {
-	if (captured === current) return captured;
-	if (captured === "prompt" || current === "prompt") return "prompt";
-	if (captured === "approve") return current;
-	if (current === "approve") return captured;
-	return "prompt";
-}
-function appApprovalCeiling(mode) {
-	if (mode === "allow") return "approve";
-	return mode === "ask" ? "prompt" : "auto";
-}
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.entries(value).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
-	return JSON.stringify(value);
-}
-/** Intersects a stored app-ID cap with current policy without admitting new apps. */
-function intersectCodexPluginThreadConfigWithScheduledAuthority(config, authority, currentPolicy = {
-	config: {},
-	toolNamesByApp: /* @__PURE__ */ new Map()
-}) {
-	const scheduled = parseScheduledCodexAppAuthority(authority);
-	if (!scheduled) return config;
-	const omittedAppIds = scheduled.apps.map((app) => app.id).filter((id) => {
-		const currentTools = currentPolicy.toolNamesByApp.get(id);
-		return !Object.hasOwn(config.policyContext.apps, id) || !currentTools || currentTools.size === 0;
-	}).toSorted();
-	if (omittedAppIds.length > 0) {
-		const visibleIds = omittedAppIds.slice(0, 10).join(", ");
-		const remaining = omittedAppIds.length - Math.min(omittedAppIds.length, 10);
-		throw new AgentHarnessPreflightError(`Scheduled Codex apps are unavailable under the current policy or account: ${visibleIds}${remaining > 0 ? ` (and ${remaining} more)` : ""}. Restore access or reauthorize the automation from a fresh authenticated Codex owner turn.`);
-	}
-	const capturedById = new Map(scheduled.apps.map((app) => [app.id, app]));
-	const apps = {};
-	for (const [id, current] of Object.entries(config.policyContext.apps)) {
-		const captured = capturedById.get(id);
-		if (!captured) continue;
-		apps[id] = {
-			...current,
-			allowDestructiveActions: current.allowDestructiveActions && captured.allowDestructiveActions,
-			allowOpenWorld: current.allowOpenWorld !== false && captured.allowOpenWorld,
-			destructiveApprovalMode: stricterApprovalMode(defaultApprovalMode(current), captured.destructiveApprovalMode)
-		};
-	}
-	const pluginAppIds = Object.fromEntries(Object.entries(config.policyContext.pluginAppIds).map(([key, ids]) => [key, ids.filter((id) => Object.hasOwn(apps, id))]).filter(([, ids]) => ids.length > 0));
-	const policyContext = buildPluginAppPolicyContext(apps, pluginAppIds);
-	const configPatch = buildCodexPluginAppsConfigPatchFromPolicyContext(policyContext);
-	const appsPatch = asOptionalRecord(configPatch.apps);
-	for (const [appId, captured] of capturedById) {
-		const appPatch = asOptionalRecord(appsPatch?.[appId]);
-		if (!appPatch || !Object.hasOwn(apps, appId)) continue;
-		const currentApp = apps[appId];
-		if (!currentApp) continue;
-		const storedAppCeiling = appApprovalCeiling(captured.destructiveApprovalMode);
-		const currentAppCeiling = appApprovalCeiling(defaultApprovalMode(currentApp));
-		const toolNames = currentPolicy.toolNamesByApp.get(appId) ?? /* @__PURE__ */ new Set();
-		appPatch.tools = Object.fromEntries([...toolNames].toSorted().map((toolName) => {
-			return [toolName, { approval_mode: intersectToolApprovalMode(intersectToolApprovalMode(captured.tools[toolName] ?? storedAppCeiling, storedAppCeiling), intersectToolApprovalMode(readToolApprovalMode(currentPolicy.config, appId, toolName, currentAppCeiling), currentAppCeiling)) }];
-		}));
-	}
-	const fingerprint = crypto.createHash("sha256").update(stableStringify({
-		version: 1,
-		namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
-		authority: scheduled,
-		inputFingerprint: config.inputFingerprint,
-		policyContext,
-		configPatch
-	})).digest("hex");
-	return {
-		...config,
-		fingerprint,
-		configPatch,
-		provisionalAppIds: Object.keys(apps).toSorted(),
-		policyContext
-	};
-}
-function readScheduledCodexAppAuthorityAuth(authority) {
-	return parseScheduledCodexAppAuthority(authority)?.auth;
-}
-function assertScheduledCodexAppAuthorityRuntime(connection, params) {
-	const scheduledAuth = readScheduledCodexAppAuthorityAuth(params.scheduledRuntimeAuthority);
-	if (!scheduledAuth) return;
-	if (params.trigger !== "cron" || connection.usesSupervisionConnection || connection.appServer.start.homeScope === "user") throw new AgentHarnessPreflightError("This automation's Codex app authority requires an isolated scheduled prepared-profile runtime. Reauthorize it from a supported Codex creator turn.");
-	const prepared = connection.startupPreparedAuth;
-	if (prepared?.kind !== "profile" || prepared.profileId !== scheduledAuth.profileId || prepared.snapshot?.loginParams.type !== "chatgptAuthTokens" || prepared.snapshot.chatgptAccountId !== scheduledAuth.accountId) throw new AgentHarnessPreflightError(`This automation was authorized for Codex profile ${scheduledAuth.profileId}, but that exact prepared account is not active. Restore the profile or reauthorize the automation from a fresh owner turn.`);
-}
-function buildLegacyScheduledCodexAppRecoveryPrompt(params) {
-	if (params.trigger !== "cron" || !params.scheduledRuntimeAuthorityRecoveryRequired || params.scheduledRuntimeAuthority) return;
-	return "Scheduled Codex app access is unavailable because this automation predates runtime-specific app authority capture. Tell the operator to recreate or reauthorize it from a fresh authenticated Codex owner turn; do not claim an app action succeeded.";
-}
-/** Makes stored-cap identity part of thread reuse admission, including cap removal. */
-function buildScheduledCodexAppAuthorityInputFingerprint(baseFingerprint, authority) {
-	const scheduled = parseScheduledCodexAppAuthority(authority);
-	if (!scheduled) return baseFingerprint;
-	return crypto.createHash("sha256").update(stableStringify({
-		version: 1,
-		namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
-		baseFingerprint,
-		authority: scheduled
-	})).digest("hex");
-}
-//#endregion
 //#region extensions/codex/src/app-server/scheduled-configured-mcp-authority.ts
 /** Limits fresh scheduled-authority capture to authenticated local durable operator turns. */
 function canResolveScheduledConfiguredMcpCreatorAuthority(params) {
@@ -6380,6 +5225,7 @@ async function prepareCodexAttemptRuntime(connection) {
 	const bundleManifestRegistry = resolveCodexAttemptBundleManifestRegistry(params.preparedModelRuntime);
 	const bundleMcpThreadConfig = await loadCodexBundleMcpThreadConfig({
 		workspaceDir: effectiveWorkspace,
+		agentId: sessionAgentId,
 		cfg: params.config,
 		toolsEnabled: usesSupervisionConnection || supportsModelTools(params.model),
 		disableTools: params.disableTools,
@@ -6388,7 +5234,7 @@ async function prepareCodexAttemptRuntime(connection) {
 		toolOverrides: codexMcpToolOverrides
 	});
 	const authenticatedScheduledMode = params.trigger === "cron" && params.scheduledToolPolicy !== void 0 && Array.isArray(params.toolsAllow);
-	const ownsScheduledConfiguredMcpSurface = authenticatedScheduledMode && (bundleMcpThreadConfig.staticServerNames.length > 0 || mutable.startupBinding?.configuredMcpOwnershipVersion === 1);
+	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 mayResolveScheduledConfiguredMcpCreatorAuthority = !authenticatedScheduledMode && canResolveScheduledConfiguredMcpCreatorAuthority({
@@ -6415,6 +5261,7 @@ async function prepareCodexAttemptRuntime(connection) {
 		runtimeSessionKey: sandboxSessionKey,
 		sandboxExecServerEnabled
 	});
+	const configuredMcpSurface = scheduledConfiguredMcpSurface ? "scheduled" : !nativeToolSurfaceEnabled && bundleMcpThreadConfig.staticServerNames.length > 0 ? "transient" : void 0;
 	preDynamicStartupStages.mark("native-tool-surface");
 	const nativeProviderWebSearchSupport = resolveCodexWebSearchPlan({
 		config: params.config,
@@ -6464,7 +5311,7 @@ async function prepareCodexAttemptRuntime(connection) {
 		bundleMcpThreadConfig,
 		bundleManifestRegistry,
 		authenticatedScheduledMode,
-		ownsScheduledConfiguredMcpSurface,
+		configuredMcpSurface,
 		canResolveScheduledConfiguredMcpCreatorAuthority: mayResolveScheduledConfiguredMcpCreatorAuthority,
 		codexMcpToolOverrides,
 		sandboxExecServerEnabled,
@@ -6558,7 +5405,6 @@ function resolveCodexDynamicToolDirectNames(params, hostSystemAgentActive = fals
 	const names = [];
 	if (hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow)) names.push("openclaw");
 	if (params.sourceReplyDeliveryMode === "message_tool_only") names.push("message");
-	names.push("progress_card");
 	return names;
 }
 //#endregion
@@ -6574,37 +5420,32 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 	const { runtime, attemptTools } = context;
 	const { connection } = runtime;
 	const { params, computerUseConfig, runAbortController, appServer, sessionAgentId } = connection;
+	const autoApprove = shouldAutoApproveCodexAppServerApprovals(appServer);
 	const { compactionPlanState, toolBridge, toolOutcomeOrdinals, suppressedDynamicToolOutcomeOrdinals, allocateCodexToolOutcomeOrdinal } = attemptTools;
-	const { state, turnIdRef, userInputBridgeRef, openClawDynamicToolExecutions, pendingOpenClawDynamicToolCompletionIds, postToolRawAssistantCompletionIdleTimeoutMs, turnWatches } = turnRuntime;
+	const { state, turnIdRef, userInputBridgeRef, openClawDynamicToolExecutions, pendingOpenClawDynamicToolCompletionIds, noteProgress } = turnRuntime;
 	const { emitExecutionPhaseOnce, scheduleTurnReleaseAfterTerminalDynamicTool, scheduleTerminalDynamicToolReleaseCheck } = lifecycle;
 	const handleServerRequest = async (request, scope, requestSignal = new AbortController().signal) => {
 		const signal = AbortSignal.any([runAbortController.signal, requestSignal]);
 		const turnId = turnIdRef.current;
 		const projector = projectorRef.current;
-		let armCompletionWatchOnResponse = false;
 		let requestCountsAsTurnActivity = false;
-		let requestKeepsAttemptWatchArmed = false;
-		const markCurrentTurnRequestProgress = (options) => {
+		const markCurrentTurnRequestProgress = () => {
 			state.activeAppServerTurnRequests += 1;
-			requestKeepsAttemptWatchArmed = options?.hasIndependentTimeout !== true;
-			if (requestKeepsAttemptWatchArmed) state.activeAppServerTurnRequestsWithoutTimeout += 1;
-			turnWatches.clearCompletionIdleTimer();
-			turnWatches.disarmAssistantCompletionIdleWatch();
 			requestCountsAsTurnActivity = true;
-			turnWatches.touchActivity(`request:${request.method}:start`, { attemptProgress: true });
+			noteProgress(`request:${request.method}:start`);
 		};
 		try {
 			if (!turnId) return;
 			if (request.method === "mcpServer/elicitation/request") {
-				if (!scope.turnId || scope.turnId === turnId) {
-					armCompletionWatchOnResponse = true;
-					markCurrentTurnRequestProgress();
-				}
+				if (!scope.turnId || scope.turnId === turnId) markCurrentTurnRequestProgress();
 				const approvalResult = await routeCodexAppServerElicitationRequest({
 					requestParams: request.params,
 					paramsForRun: params,
 					threadId: resourceState.thread.threadId,
 					turnId,
+					autoApproveMcpTools: autoApprove,
+					projectedMcpServers: runtime.bundleMcpThreadConfig.configPatch?.mcp_servers,
+					getActiveMcpToolCall: (serverName) => projector?.getActiveMcpToolCall(serverName),
 					pluginAppPolicyContext: resourceState.thread.pluginAppPolicyContext,
 					...computerUseConfig.enabled ? { computerUseMcpServerName: computerUseConfig.mcpServerName } : {},
 					signal
@@ -6616,10 +5457,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				});
 			}
 			if (request.method === "item/tool/requestUserInput") {
-				if (scope.turnId === turnId) {
-					armCompletionWatchOnResponse = true;
-					markCurrentTurnRequestProgress();
-				}
+				if (scope.turnId === turnId) markCurrentTurnRequestProgress();
 				return await userInputBridgeRef.current?.handleRequest({
 					id: request.id,
 					params: request.params
@@ -6627,10 +5465,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			}
 			if (request.method !== "item/tool/call") {
 				if (isCodexAppServerApprovalRequest(request.method)) {
-					if (scope.turnId === turnId) {
-						armCompletionWatchOnResponse = true;
-						markCurrentTurnRequestProgress();
-					}
+					if (scope.turnId === turnId) markCurrentTurnRequestProgress();
 					return await handleCodexAppServerApprovalRequest({
 						method: request.method,
 						requestParams: request.params,
@@ -6638,7 +5473,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						threadId: resourceState.thread.threadId,
 						turnId,
 						nativeHookRelay: resourceState.nativeHookRelay,
-						autoApprove: shouldAutoApproveCodexAppServerApprovals(appServer),
+						autoApprove,
 						signal,
 						onNativeToolFailureDisposition: (itemId, disposition, approvalKind) => projector?.recordNativeToolApprovalFailure(itemId, disposition, approvalKind)
 					});
@@ -6649,15 +5484,11 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			if (!call || call.threadId !== resourceState.thread.threadId || call.turnId !== turnId) return;
 			const replayedExecution = openClawDynamicToolExecutions.get(call);
 			if (replayedExecution) {
-				armCompletionWatchOnResponse = true;
-				markCurrentTurnRequestProgress({ hasIndependentTimeout: true });
-				state.turnCrossedToolHandoff = true;
+				markCurrentTurnRequestProgress();
 				return toCodexDynamicToolProtocolResponse(await replayedExecution);
 			}
 			const toolCallOrdinal = allocateCodexToolOutcomeOrdinal?.(call.callId);
-			armCompletionWatchOnResponse = true;
-			markCurrentTurnRequestProgress({ hasIndependentTimeout: true });
-			state.turnCrossedToolHandoff = true;
+			markCurrentTurnRequestProgress();
 			pendingOpenClawDynamicToolCompletionIds.add(call.callId);
 			trajectoryRecorder?.recordEvent("tool.call", {
 				threadId: call.threadId,
@@ -6834,17 +5665,10 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			}
 		} finally {
 			if (requestCountsAsTurnActivity) {
-				state.activeAppServerTurnRequests = Math.max(0, state.activeAppServerTurnRequests - 1);
-				if (requestKeepsAttemptWatchArmed) state.activeAppServerTurnRequestsWithoutTimeout = Math.max(0, state.activeAppServerTurnRequestsWithoutTimeout - 1);
-				const postToolContinuationTimeoutMs = request.method === "item/tool/call" && state.turnCrossedToolHandoff ? postToolRawAssistantCompletionIdleTimeoutMs : void 0;
-				turnWatches.touchActivity(`request:${request.method}:response`, {
-					arm: armCompletionWatchOnResponse,
-					attemptProgress: true,
-					...postToolContinuationTimeoutMs !== void 0 ? { attemptTimeoutMs: postToolContinuationTimeoutMs } : {}
-				});
-				if (armCompletionWatchOnResponse && postToolContinuationTimeoutMs !== void 0) turnWatches.armCompletionIdleWatch({ timeoutMs: postToolContinuationTimeoutMs });
+				state.activeAppServerTurnRequests -= 1;
+				noteProgress(`request:${request.method}:response`);
 				scheduleTerminalDynamicToolReleaseCheck();
-			} else turnWatches.scheduleProgressWatches();
+			}
 		}
 	};
 	return { handleServerRequest };
@@ -6853,7 +5677,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-D9pYp4zL.js");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-C3jVimFn.js");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -7100,14 +5924,13 @@ async function startCodexAttemptThread(params) {
 				startupClientForAbandonedRequestCleanup = void 0;
 			},
 			operation: async () => {
-				const threadConfig = mergeCodexThreadConfigs(params.configuredMcpOwnershipVersion === 1 ? void 0 : params.bundleMcpThreadConfig?.configPatch);
+				const threadConfig = mergeCodexThreadConfigs(params.configuredMcpDynamicSurface ? void 0 : params.bundleMcpThreadConfig?.configPatch);
 				const { pluginThreadConfigRequired, pluginThreadConfigPluginConfig, resolvedPluginPolicy, enabledPluginConfigKeys } = resolveCodexPluginThreadConfigStartupPolicy({
 					pluginConfig: params.pluginConfig,
 					nativeToolSurfaceEnabled: params.nativeToolSurfaceEnabled,
 					scheduledRuntimeAuthority: params.buildAttemptParams().scheduledRuntimeAuthority
 				});
-				const computerUseMcpElicitationDelegationRequired = params.computerUseConfig.enabled;
-				pluginAppServer = resolvedPluginPolicy?.enabled === true || computerUseMcpElicitationDelegationRequired ? {
+				pluginAppServer = resolvedPluginPolicy?.enabled === true || params.computerUseConfig.enabled || params.nativeToolSurfaceEnabled && params.configuredMcpOwnershipVersion !== 1 && hasCodexMcpToolApprovalOverrides(params.config?.mcp?.servers, params.bundleMcpThreadConfig.userStaticServerNames, params.bundleMcpThreadConfig.configPatch?.mcp_servers) ? {
 					...params.appServer,
 					approvalPolicy: withMcpElicitationsApprovalPolicy(params.appServer.approvalPolicy)
 				} : params.appServer;
@@ -7299,9 +6122,9 @@ async function startCodexAttemptThread(params) {
 							nativeCodeModeEnabled: params.nativeToolSurfaceEnabled,
 							nativeProviderWebSearchSupport: params.nativeProviderWebSearchSupport,
 							nativeCodeModeOnlyEnabled: params.appServer.codeModeOnly,
-							userMcpServersEnabled: params.configuredMcpOwnershipVersion === 1 ? false : params.nativeToolSurfaceEnabled,
-							mcpServersFingerprint: params.configuredMcpOwnershipVersion === 1 ? void 0 : params.bundleMcpThreadConfig.fingerprint,
-							mcpServersFingerprintEvaluated: params.configuredMcpOwnershipVersion === 1 || params.bundleMcpThreadConfig.evaluated,
+							userMcpServersEnabled: params.configuredMcpDynamicSurface ? false : params.nativeToolSurfaceEnabled,
+							mcpServersFingerprint: params.configuredMcpDynamicSurface ? void 0 : params.bundleMcpThreadConfig.fingerprint,
+							mcpServersFingerprintEvaluated: params.configuredMcpDynamicSurface || params.bundleMcpThreadConfig.evaluated,
 							configuredMcpOwnershipVersion: params.configuredMcpOwnershipVersion,
 							environmentSelection: startupEnvironmentSelection,
 							appServerRuntimeFingerprint,
@@ -7380,10 +6203,7 @@ async function startCodexAttemptThread(params) {
 							if (startupAbandoned || params.signal.aborted) {
 								if (startupClientForAbandonedRequestCleanup === startupClient) startupClientForAbandonedRequestCleanup = void 0;
 								await closeCodexStartupClientBestEffort(startupClient);
-							} else if (!isCodexAppServerStartSelectionChangedError(startupAttemptError) && (shouldClearSharedClientAfterStartupRace(startupAttemptError) || shouldClearSharedClientAfterStartupFailure({
-								error: startupAttemptError,
-								spawnedBy: params.spawnedBy
-							}))) {
+							} else if (!isCodexAppServerStartSelectionChangedError(startupAttemptError) && (shouldClearSharedClientAfterStartupRace(startupAttemptError) || shouldClearSharedClientAfterStartupFailure(startupAttemptError, params.spawnedBy))) {
 								if (startupClientForAbandonedRequestCleanup === startupClient) startupClientForAbandonedRequestCleanup = void 0;
 								await closeCodexStartupClientBestEffort(startupClient);
 							}
@@ -7432,10 +6252,7 @@ async function startCodexAttemptThread(params) {
 			releaseSharedClientLease = void 0;
 			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
 			startupClientForAbandonedRequestCleanup = void 0;
-		} else if (!isCodexAppServerStartSelectionChangedError(error) && (shouldClearSharedClientAfterStartupRace(error) || shouldClearSharedClientAfterStartupFailure({
-			error,
-			spawnedBy: params.spawnedBy
-		}))) {
+		} else if (!isCodexAppServerStartSelectionChangedError(error) && (shouldClearSharedClientAfterStartupRace(error) || shouldClearSharedClientAfterStartupFailure(error, params.spawnedBy))) {
 			releaseSharedClientLease?.();
 			releaseSharedClientLease = void 0;
 			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
@@ -7449,9 +6266,8 @@ async function startCodexAttemptThread(params) {
 function shouldClearSharedClientAfterStartupRace(error) {
 	return isCodexAppServerStartupError(error) || isCodexAppServerRequestTimeoutError(error);
 }
-function shouldClearSharedClientAfterStartupFailure(params) {
-	if (isCodexAppServerOverloadError(params.error)) return false;
-	return isCodexAppServerBrokenPipeError(params.error) || !params.spawnedBy;
+function shouldClearSharedClientAfterStartupFailure(error, spawnedBy) {
+	return !isCodexAppServerOverloadError(error) && !(error instanceof AgentHarnessPreflightError && error.scope === void 0) && (isCodexAppServerBrokenPipeError(error) || !spawnedBy);
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-start.ts
@@ -7461,7 +6277,7 @@ async function startCodexAttemptRuntime(resources) {
 	const { runtime, attemptTools, promptState } = context;
 	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
 	const { toolBridge, toolState } = attemptTools;
-	const developerInstructions = joinPresentSections(turnState.promptBuild.developerInstructions, attemptTools.scheduledConfiguredMcp?.diagnosticNotice);
+	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;
 	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;
@@ -7501,6 +6317,7 @@ async function startCodexAttemptRuntime(resources) {
 			buildFinalConfigPatch: buildNativeHookRelayFinalConfigPatch,
 			nativeHookRelayRequired: connection.options.nativeHookRelay?.enabled !== false && params.pluginHarnessToolPolicyRestricted !== true && connection.nativeHookRelayEvents.includes("pre_tool_use") && (hasBeforeToolCallPolicy() || appServer.loopDetectionPreToolUseRelay && Boolean(connection.sandboxSessionKey) && loopDetectionEnabled),
 			bundleMcpThreadConfig,
+			configuredMcpDynamicSurface: attemptTools.configuredMcp !== void 0,
 			configuredMcpOwnershipVersion: attemptTools.configuredMcpOwnershipVersion,
 			nativeToolSurfaceEnabled,
 			nativeProviderWebSearchSupport,
@@ -7583,7 +6400,7 @@ async function startCodexAttemptRuntime(resources) {
 		recordCodexTrajectoryContext(trajectoryRecorder, {
 			attempt: params,
 			cwd: effectiveCwd,
-			developerInstructions: joinPresentSections(buildRenderedCodexDeveloperInstructions(), attemptTools.scheduledConfiguredMcp?.diagnosticNotice),
+			developerInstructions: joinPresentSections(buildRenderedCodexDeveloperInstructions(), attemptTools.configuredMcp?.diagnosticNotice),
 			prompt: turnState.codexTurnPromptText,
 			tools: toolBridge.availableSpecs
 		});
@@ -7597,7 +6414,7 @@ async function startCodexAttemptRuntime(resources) {
 		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 state.executionDisconnectError ?? error;
+		throw error instanceof CodexThreadPolicyHandoffError ? error : state.executionDisconnectError ?? error;
 	}
 }
 //#endregion
@@ -7606,7 +6423,7 @@ function isAuthorityResolutionOperationAbort(error, signal) {
 	return signal?.aborted === true && error === signal.reason;
 }
 async function prepareCodexAttemptTools(runtime) {
-	const { connection, bundleMcpThreadConfig, bundleManifestRegistry, runtimeParams, effectiveRuntimeModelId, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, hookChannelId, codexMcpToolOverrides, authenticatedScheduledMode, ownsScheduledConfiguredMcpSurface, canResolveScheduledConfiguredMcpCreatorAuthority } = 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 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)}`, {
@@ -7655,16 +6472,24 @@ async function prepareCodexAttemptTools(runtime) {
 	const cronCreatorToolAllowlistCaptureRef = {};
 	const scheduledAppAuthoritySourceRef = {};
 	const preparedChatgptAuth = connection.startupPreparedAuth?.kind === "profile" && connection.startupPreparedAuth.snapshot?.loginParams.type === "chatgptAuthTokens" && connection.startupPreparedAuth.snapshot.chatgptAccountId ? {
+		kind: "prepared-profile",
 		profileId: connection.startupPreparedAuth.profileId,
 		accountId: connection.startupPreparedAuth.snapshot.chatgptAccountId
 	} : void 0;
+	const configuredAppServerAuth = !preparedChatgptAuth && connection.appServer.start.transport !== "stdio" ? {
+		kind: "configured-app-server",
+		connectionFingerprint: buildScheduledCodexAppServerConnectionIdentity(connection.appServer)
+	} : void 0;
+	const scheduledCodexAppAuth = preparedChatgptAuth ?? configuredAppServerAuth;
 	const appPolicy = resolveCodexPluginsPolicy(pluginConfig);
+	const codexAppsMayBeVisible = appPolicy.enabled && (appPolicy.allowAllPlugins || appPolicy.pluginPolicies.some((entry) => entry.enabled));
 	const appCreatorCapture = resolveScheduledCodexAppCreatorCaptureDecision({
-		appsMayBeVisible: appPolicy.enabled && (appPolicy.allowAllPlugins || appPolicy.pluginPolicies.some((entry) => entry.enabled)),
+		appsMayBeVisible: codexAppsMayBeVisible,
 		authenticatedScheduledMode,
 		usesSupervisionConnection: connection.usesSupervisionConnection,
 		homeScope: connection.appServer.start.homeScope,
-		hasPreparedAccountIdentity: Boolean(preparedChatgptAuth)
+		hasPreparedAccountIdentity: Boolean(preparedChatgptAuth),
+		hasConfiguredAppServerIdentity: Boolean(configuredAppServerAuth)
 	});
 	const codexAppAuthorityUnavailableReason = appCreatorCapture.unavailableReason;
 	const canResolveScheduledCodexAppAuthority = appCreatorCapture.supported;
@@ -7675,6 +6500,7 @@ async function prepareCodexAttemptTools(runtime) {
 	let resolveCreatorAuthorityImpl;
 	const runtimeYieldCompletionClaim = {};
 	const commonToolParams = {
+		nodeExecAvailability: {},
 		params: dynamicToolParams,
 		resolvedWorkspace,
 		effectiveWorkspace,
@@ -7711,6 +6537,32 @@ async function prepareCodexAttemptTools(runtime) {
 			return pending;
 		} } : {}
 	};
+	let nativeSpecs;
+	if (hasCodexNativeToolCatalog(mutable.startupBinding)) {
+		runAbortController.signal.throwIfAborted();
+		params.hostCapabilities.assertActive();
+		const client = await connection.attemptClientFactory({
+			startOptions: connection.appServer.start,
+			authProfileId: connection.startupClientAuthProfileId,
+			agentDir,
+			config: params.config,
+			timeoutMs: connection.appServer.requestTimeoutMs
+		});
+		try {
+			nativeSpecs = await loadCodexNativeToolCatalog({
+				client,
+				binding: mutable.startupBinding,
+				appServer: connection.appServer,
+				agentDir,
+				assertCurrent: () => {
+					runAbortController.signal.throwIfAborted();
+					params.hostCapabilities.assertActive();
+				}
+			});
+		} finally {
+			releaseLeasedSharedCodexAppServerClient(client);
+		}
+	}
 	const tools = await buildDynamicTools({
 		...commonToolParams,
 		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
@@ -7723,7 +6575,7 @@ async function prepareCodexAttemptTools(runtime) {
 			toolState.webSearchAllowed = allowed;
 		}
 	});
-	const registeredTools = await buildDynamicTools({
+	const registeredTools = nativeSpecs ? [] : await buildDynamicTools({
 		...commonToolParams,
 		forceHeartbeatTool: true,
 		ignoreDisableMessageTool: true,
@@ -7781,9 +6633,10 @@ async function prepareCodexAttemptTools(runtime) {
 		...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
 	};
 	const hasRequester = Object.keys(requester).length > 0;
-	const scheduledConfiguredMcp = ownsScheduledConfiguredMcpSurface ? await materializeStaticMcpToolsForScheduledHarnessRun({
+	const configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
+		agentId: sessionAgentId,
 		workspaceDir: effectiveWorkspace,
 		agentDir: policyContext.agentDir,
 		cfg: params.config,
@@ -7792,6 +6645,29 @@ async function prepareCodexAttemptTools(runtime) {
 		toolsAllow: params.toolsAllow,
 		toolOverrides: codexMcpToolOverrides,
 		autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
+		projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
+		...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: async (approval) => {
+			const allowedDecisions = approval.mode === "prompt" ? ["allow-once", "deny"] : [
+				"allow-once",
+				"allow-always",
+				"deny"
+			];
+			const outcome = await requestPluginApprovalOutcome({
+				hostCapabilities: params.hostCapabilities,
+				signal: approval.signal,
+				title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
+				description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
+				allowedDecisions,
+				toolName: approval.safeToolName,
+				toolCallId: approval.toolCallId,
+				mcpTool: {
+					server: approval.serverName,
+					tool: approval.toolName
+				},
+				isMcpToolApprovalActive: approval.isActive
+			});
+			if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
+		} } : {},
 		policyContext,
 		warn: (message) => embeddedAgentLog.warn(message)
 	}) : void 0;
@@ -7808,13 +6684,13 @@ async function prepareCodexAttemptTools(runtime) {
 			requesterSenderId: params.senderId,
 			agentAccountId: params.agentAccountId,
 			messageChannel: params.messageChannel ?? params.messageProvider,
-			reservedToolNames,
+			reservedToolNames: [...reservedToolNames, ...configuredMcp?.tools.map((tool) => tool.name) ?? []],
 			toolsAllow: params.toolsAllow,
 			policyContext,
 			warn: (message) => embeddedAgentLog.warn(message)
 		});
-		const scopedExecutable = filterCodexDynamicTools(scheduledConfiguredMcp?.tools ?? scopedMcpTools?.tools ?? [], pluginConfig);
-		const scopedAdvertised = filterCodexDynamicTools(scheduledConfiguredMcp?.tools ?? scopedMcpTools?.advertisedTools ?? [], pluginConfig);
+		const scopedExecutable = filterCodexDynamicTools([...configuredMcp?.tools ?? [], ...scopedMcpTools?.tools ?? []], pluginConfig);
+		const scopedAdvertised = filterCodexDynamicTools([...configuredMcp?.tools ?? [], ...scopedMcpTools?.advertisedTools ?? []], pluginConfig);
 		const toolsWithScopedMcp = scopedExecutable.length > 0 ? [...tools, ...scopedExecutable] : tools;
 		const registeredWithScopedMcp = scopedAdvertised.length > 0 ? [...registeredTools, ...scopedAdvertised] : registeredTools;
 		const hookContext = {
@@ -7849,6 +6725,7 @@ async function prepareCodexAttemptTools(runtime) {
 		toolBridge = createCodexDynamicToolBridge({
 			tools: toolsWithScopedMcp,
 			registeredTools: registeredWithScopedMcp,
+			registeredSpecs: nativeSpecs,
 			signal: runAbortController.signal,
 			computerContextEpoch,
 			loading: resolveCodexDynamicToolsLoadingForRuntime(pluginConfig, effectiveRuntimeModelId, { connectionClass: connection.appServer.connectionClass }),
@@ -7867,9 +6744,9 @@ async function prepareCodexAttemptTools(runtime) {
 			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 && preparedChatgptAuth ? appSource ? await captureScheduledCodexAppAuthority({
+			const runtimeAuthority = canResolveScheduledCodexAppAuthority && scheduledCodexAppAuth ? appSource ? await captureScheduledCodexAppAuthority({
 				...appSource,
-				...preparedChatgptAuth,
+				auth: scheduledCodexAppAuth,
 				signal: options?.signal
 			}) : (() => {
 				throw new Error("Codex app authority is unavailable before the exact creator thread is active. Retry this automation mutation from the current owner turn.");
@@ -7885,8 +6762,9 @@ async function prepareCodexAttemptTools(runtime) {
 			const authorityRuntimeId = `cron-authority:${params.runId}`;
 			let materialized;
 			try {
-				materialized = await materializeStaticMcpToolsForScheduledHarnessRun({
+				materialized = await materializeStaticMcpToolsForHarnessRun({
 					sessionId: authorityRuntimeId,
+					agentId: sessionAgentId,
 					workspaceDir: effectiveWorkspace,
 					agentDir: policyContext.agentDir,
 					cfg: params.config,
@@ -7895,6 +6773,7 @@ async function prepareCodexAttemptTools(runtime) {
 					toolsAllow: params.toolsAllow,
 					toolOverrides: codexMcpToolOverrides,
 					autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
+					projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
 					policyContext,
 					warn: (message) => embeddedAgentLog.warn(message),
 					retireSessionRuntimeAfterDispose: true
@@ -7926,8 +6805,8 @@ async function prepareCodexAttemptTools(runtime) {
 			tools: toolsWithScopedMcp,
 			registeredTools: registeredWithScopedMcp,
 			scopedMcpTools,
-			scheduledConfiguredMcp,
-			configuredMcpOwnershipVersion: ownsScheduledConfiguredMcpSurface ? 1 : void 0,
+			configuredMcp,
+			configuredMcpOwnershipVersion: configuredMcpSurface === "scheduled" ? 1 : void 0,
 			cronCreatorToolAllowlist,
 			cronCreatorToolAllowlistCaptureRef,
 			scheduledAppAuthoritySourceRef,
@@ -7945,7 +6824,7 @@ async function prepareCodexAttemptTools(runtime) {
 		};
 	} catch (error) {
 		await scopedMcpTools?.dispose();
-		await scheduledConfiguredMcp?.dispose();
+		await configuredMcp?.dispose();
 		throw error;
 	}
 }
@@ -7985,7 +6864,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 	const { context, turnState, buildRenderedCodexDeveloperInstructions } = prompt;
 	const { runtime, attemptTools, hookContextWindowFields, workspaceBootstrapContext } = context;
 	const { connection, runtimeParams, effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
-	const { tools } = attemptTools;
+	const { tools, toolBridge } = attemptTools;
 	const { params, usesSupervisionConnection, codexModelCallId, codexModelCallTrace, codexModelContentCapture, appServer, runAbortController } = connection;
 	const { state } = turnRuntime;
 	const explicitSkillInputs = await resolveCodexExplicitSkillInputs({
@@ -8048,7 +6927,8 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
 			skillsCollaborationInstructions: context.skillsCollaborationInstructions,
 			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
-			preserveNativeTurnSettings: usesSupervisionConnection
+			preserveNativeTurnSettings: usesSupervisionConnection,
+			sessionStatusAvailable: toolBridge.availableTools.some((tool) => tool.name === "session_status")
 		});
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
 		state.latestStartupErrorNotification = void 0;
@@ -8232,7 +7112,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			trajectoryRecorder?.recordEvent("session.ended", {
 				status: "error",
 				threadId: resourceState.thread.threadId,
-				timedOut: state.timedOut,
+				timedOut: state.timeout !== void 0,
 				aborted: runAbortController.signal.aborted,
 				promptError: message
 			});
@@ -8253,8 +7133,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			});
 			const failureKind = classifyCodexModelCallFailureKind({
 				error: turnStartError,
-				timedOut: state.timedOut,
-				turnCompletionIdleTimedOut: state.turnCompletionIdleTimedOut,
+				timedOut: state.timeout !== void 0,
 				runAborted: runAbortController.signal.aborted,
 				abortReason: runAbortController.signal.reason,
 				clientClosedAbort: state.clientClosedAbort,
@@ -8275,11 +7154,10 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				ctx: hookContext,
 				hookRunner
 			});
-			const bindingReleased = isIncognitoSessionKey(params.sessionKey) ? await bindingStore.mutate(bindingIdentity, {
+			if ((isIncognitoSessionKey(params.sessionKey) ? await bindingStore.mutate(bindingIdentity, {
 				kind: "clear",
 				threadId: resourceState.thread.threadId
-			}) : true;
-			if (!state.timedOut && bindingReleased && !resourceState.startupClientUnsafe) {
+			}) : true) && !resourceState.startupClientUnsafe) {
 				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
 					threadId: resourceState.thread.threadId,
 					timeoutMs: 5e3
@@ -8352,279 +7230,56 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 	return { turn };
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-turn-watches.ts
-/**
-* Idle-watch controller for Codex app-server turn progress, completion, and
-* terminal-event gaps.
-*/
-/**
-* Creates a controller that arms/disarms timers as Codex app-server
-* notifications and tool handoffs progress.
-*/
-function createCodexAttemptTurnWatchController(params) {
-	const timers = {};
-	let completionIdleWatchArmed = false;
-	let completionIdleWatchPinnedByTerminalError = false;
-	let completionIdleTimeoutOverrideMs;
-	let assistantCompletionIdleWatchArmed = false;
-	let assistantCompletionLastActivityAt = Date.now();
-	let assistantCompletionLastActivityDetails;
-	let attemptIdleWatchArmed = false;
-	let terminalIdleWatchArmed = false;
-	let completionLastActivityAt = Date.now();
-	let completionLastActivityReason = "startup";
-	let completionLastActivityDetails;
-	let attemptIdleTimeoutOverrideMs;
-	let attemptLastProgressAt = Date.now();
-	let attemptLastProgressReason = "startup";
-	let attemptLastProgressDetails;
-	const turnCompletionIdleTimeoutMs = resolveTimerTimeoutMs(params.turnCompletionIdleTimeoutMs, 1);
-	const turnAssistantCompletionIdleTimeoutMs = resolveTimerTimeoutMs(params.turnAssistantCompletionIdleTimeoutMs, 1);
-	const turnAttemptIdleTimeoutMs = resolveTimerTimeoutMs(params.turnAttemptIdleTimeoutMs, 1);
-	const turnTerminalIdleTimeoutMs = resolveTimerTimeoutMs(params.turnTerminalIdleTimeoutMs, 1);
-	const interruptTimeoutMs = resolveTimerTimeoutMs(params.interruptTimeoutMs, 1);
-	const resolveWatchTimeoutMs = (timeoutMs) => resolveTimerTimeoutMs(timeoutMs, 1);
-	const clearTimer = (kind) => {
-		const timer = timers[kind];
-		if (timer) {
-			clearTimeout(timer);
-			delete timers[kind];
-		}
+//#region extensions/codex/src/app-server/attempt-deadlines.ts
+function createCodexAttemptDeadlineController(params) {
+	let deadline = { kind: "closed" };
+	let timer;
+	const armDeadline = (next) => {
+		clearTimeout(timer);
+		deadline = next;
+		const deadlineAtMs = next.startedAtMs + next.timeoutMs;
+		params.onDeadlineChanged?.({
+			kind: "bounded",
+			deadlineAtMs
+		});
+		timer = setTimeout(() => {
+			if (deadline !== next || params.signal.aborted) return;
+			deadline = { kind: "closed" };
+			params.onTimeout({
+				kind: next.kind,
+				elapsedMs: Math.max(0, Date.now() - next.startedAtMs),
+				timeoutMs: next.timeoutMs
+			});
+		}, resolveTimerTimeoutMs(Math.max(1, deadlineAtMs - Date.now()), 1));
+		timer.unref?.();
 	};
-	const clearCompletionIdleTimer = () => clearTimer("completion");
-	const clearAllTimers = () => {
-		for (const kind of Object.keys(timers)) clearTimer(kind);
+	const dispose = () => {
+		deadline = { kind: "closed" };
+		clearTimeout(timer);
+		params.signal.removeEventListener("abort", dispose);
 	};
-	function scheduleWatch(kind, callback, lastActivityAt, timeoutMs, ready) {
-		clearTimer(kind);
-		if (!ready || params.isCompleted() || params.signal.aborted) return;
-		const elapsedMs = Math.max(0, Date.now() - lastActivityAt);
-		const timer = setTimeout(callback, Math.max(1, timeoutMs - elapsedMs));
-		timer.unref?.();
-		timers[kind] = timer;
-	}
-	function scheduleCompletionIdleWatch() {
-		scheduleWatch("completion", fireCompletionIdleTimeout, completionLastActivityAt, completionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs, completionIdleWatchArmed && params.getActiveAppServerTurnRequests() === 0 && params.getActiveCompletionBlockerItemCount() === 0);
-	}
-	function scheduleAssistantCompletionIdleWatch() {
-		scheduleWatch("assistant", fireAssistantCompletionIdleRelease, assistantCompletionLastActivityAt, turnAssistantCompletionIdleTimeoutMs, assistantCompletionIdleWatchArmed && params.getActiveFinalizationHookCount() === 0);
-	}
-	function shouldPauseAttemptIdleWatch() {
-		if (params.getActiveAppServerTurnRequestsWithoutTimeout() > 0) return false;
-		return params.getActiveCompletionBlockerItemCount() > 0 || params.getActiveAppServerTurnRequests() > 0;
-	}
-	function scheduleAttemptIdleWatch() {
-		scheduleWatch("attempt", fireAttemptIdleTimeout, attemptLastProgressAt, attemptIdleTimeoutOverrideMs ?? turnAttemptIdleTimeoutMs, attemptIdleWatchArmed && !shouldPauseAttemptIdleWatch());
-	}
-	const terminalWorkIsActive = () => params.getActiveAppServerTurnRequests() > 0 || params.isTerminalTurnNotificationQueued() && params.getActiveFinalizationHookCount() > 0;
-	const terminalIdleTimeoutMs = () => params.isTerminalTurnNotificationQueued() && !terminalWorkIsActive() ? Math.min(TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS, turnTerminalIdleTimeoutMs) : turnTerminalIdleTimeoutMs;
-	function scheduleTerminalIdleWatch() {
-		scheduleWatch("terminal", fireTerminalIdleTimeout, completionLastActivityAt, terminalIdleTimeoutMs(), terminalIdleWatchArmed && (params.isTerminalTurnNotificationQueued() || params.getActiveAppServerTurnRequests() === 0));
-	}
-	function scheduleProgressWatches() {
-		scheduleAttemptIdleWatch();
-		scheduleCompletionIdleWatch();
-		scheduleTerminalIdleWatch();
-	}
-	function isCompletionIdleTimeoutDueBeforeAttempt(timeoutMs) {
-		if (params.isCompleted() || params.isTerminalTurnNotificationQueued() || params.signal.aborted || !completionIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0 || params.getActiveCompletionBlockerItemCount() > 0) return false;
-		const completionTimeoutMs = completionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs;
-		if (completionTimeoutMs > timeoutMs) return false;
-		return Math.max(0, Date.now() - completionLastActivityAt) >= completionTimeoutMs;
-	}
-	function recordAttemptProgress(reason, options) {
-		attemptIdleTimeoutOverrideMs = options?.attemptTimeoutMs !== void 0 ? resolveWatchTimeoutMs(options.attemptTimeoutMs) : void 0;
-		attemptLastProgressAt = completionLastActivityAt;
-		attemptLastProgressReason = reason;
-		attemptLastProgressDetails = options?.details;
-		params.onAttemptProgress(reason, options?.details);
-		scheduleAttemptIdleWatch();
-	}
-	function fireAssistantCompletionIdleRelease() {
-		if (params.isCompleted() || params.signal.aborted || !assistantCompletionIdleWatchArmed) return;
-		if (params.getActiveAppServerTurnRequests() > 0 || params.getActiveTurnItemCount() > 0 || params.getActiveFinalizationHookCount() > 0) {
-			scheduleAssistantCompletionIdleWatch();
-			return;
-		}
-		if (!params.canReleaseAssistantCompletionIdle()) {
-			assistantCompletionIdleWatchArmed = false;
-			assistantCompletionLastActivityDetails = void 0;
-			clearTimer("assistant");
-			return;
-		}
-		const idleMs = Math.max(0, Date.now() - assistantCompletionLastActivityAt);
-		if (idleMs < turnAssistantCompletionIdleTimeoutMs) {
-			scheduleAssistantCompletionIdleWatch();
-			return;
-		}
-		assistantCompletionIdleWatchArmed = false;
-		clearCompletionIdleTimer();
-		clearTimer("terminal");
-		const turnId = params.getTurnId();
-		const fields = {
-			threadId: params.threadId,
-			turnId,
-			idleMs,
-			timeoutMs: turnAssistantCompletionIdleTimeoutMs,
-			...assistantCompletionLastActivityDetails
-		};
-		params.onRecordEvent("turn.assistant_completion_idle_release", fields);
-		embeddedAgentLog.warn("codex app-server turn released after completed assistant item without terminal event", fields);
-		if (turnId) {
-			params.onInterruptTurn({
-				threadId: params.threadId,
-				turnId,
-				timeoutMs: interruptTimeoutMs
-			}).finally(params.onCompleted);
-			return;
-		}
-		params.onCompleted();
-	}
-	function reportTimeout(timeout) {
-		params.onTimeout(timeout);
-		const fields = {
-			threadId: params.threadId,
-			turnId: params.getTurnId(),
-			idleMs: timeout.idleMs,
-			timeoutMs: timeout.timeoutMs,
-			lastActivityReason: timeout.lastActivityReason,
-			...timeout.details
-		};
-		params.onRecordEvent(`turn.${timeout.kind}_idle_timeout`, fields);
-		embeddedAgentLog.warn(`codex app-server turn idle timed out waiting for ${timeout.kind === "terminal" ? "terminal event" : timeout.kind}`, fields);
-		params.onAbort(`turn_${timeout.kind}_idle_timeout`);
-	}
-	function fireAttemptIdleTimeout() {
-		if (params.isCompleted() || params.signal.aborted || !attemptIdleWatchArmed || shouldPauseAttemptIdleWatch()) return;
-		const idleMs = Math.max(0, Date.now() - attemptLastProgressAt);
-		const timeoutMs = attemptIdleTimeoutOverrideMs ?? turnAttemptIdleTimeoutMs;
-		if (idleMs < timeoutMs) {
-			scheduleAttemptIdleWatch();
-			return;
-		}
-		if (isCompletionIdleTimeoutDueBeforeAttempt(timeoutMs)) {
-			fireCompletionIdleTimeout();
-			return;
-		}
-		reportTimeout({
-			kind: "progress",
-			idleMs,
-			timeoutMs,
-			lastActivityReason: attemptLastProgressReason,
-			details: attemptLastProgressDetails
-		});
-	}
-	function fireCompletionIdleTimeout() {
-		if (params.isCompleted() || params.isTerminalTurnNotificationQueued() || params.signal.aborted || !completionIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0 || params.getActiveCompletionBlockerItemCount() > 0) return;
-		const timeoutMs = completionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs;
-		const idleMs = Math.max(0, Date.now() - completionLastActivityAt);
-		if (idleMs < timeoutMs) {
-			scheduleCompletionIdleWatch();
-			return;
-		}
-		const details = {
-			...completionLastActivityDetails,
-			activeAppServerTurnRequests: params.getActiveAppServerTurnRequests(),
-			activeTurnItemCount: params.getActiveTurnItemCount(),
-			terminalTurnNotificationQueued: params.isTerminalTurnNotificationQueued(),
-			completionIdleWatchArmed,
-			assistantCompletionIdleWatchArmed,
-			terminalIdleWatchArmed
-		};
-		reportTimeout({
-			kind: "completion",
-			idleMs,
-			timeoutMs,
-			lastActivityReason: completionLastActivityReason,
-			details
-		});
-	}
-	function fireTerminalIdleTimeout() {
-		if (params.isCompleted() || params.signal.aborted || !terminalIdleWatchArmed) return;
-		if (!params.isTerminalTurnNotificationQueued() && params.getActiveAppServerTurnRequests() > 0) {
-			scheduleTerminalIdleWatch();
-			return;
-		}
-		const timeoutMs = terminalIdleTimeoutMs();
-		const idleMs = Math.max(0, Date.now() - completionLastActivityAt);
-		if (idleMs < timeoutMs) {
-			scheduleTerminalIdleWatch();
-			return;
-		}
-		reportTimeout({
-			kind: "terminal",
-			idleMs,
-			timeoutMs,
-			lastActivityReason: completionLastActivityReason,
-			details: {
-				...completionLastActivityDetails,
-				terminalTurnNotificationQueued: params.isTerminalTurnNotificationQueued()
-			}
+	if (!params.signal.aborted) {
+		params.signal.addEventListener("abort", dispose, { once: true });
+		if (params.timeoutMs >= MAX_TIMER_TIMEOUT_MS) {
+			deadline = { kind: "unlimited" };
+			params.onDeadlineChanged?.({ kind: "unlimited" });
+		} else armDeadline({
+			kind: "execution",
+			startedAtMs: params.startedAtMs,
+			timeoutMs: params.timeoutMs
 		});
 	}
 	return {
-		isCompletionIdleWatchArmed: () => completionIdleWatchArmed,
-		isCompletionIdleWatchPinnedByTerminalError: () => completionIdleWatchPinnedByTerminalError,
-		isAssistantCompletionIdleWatchArmed: () => assistantCompletionIdleWatchArmed,
-		armAttemptIdleWatch: () => {
-			attemptIdleWatchArmed = true;
-			scheduleAttemptIdleWatch();
-		},
-		armTerminalIdleWatch: () => {
-			terminalIdleWatchArmed = true;
-			scheduleTerminalIdleWatch();
-		},
-		armCompletionIdleWatch: (options) => {
-			completionIdleWatchArmed = true;
-			completionIdleWatchPinnedByTerminalError = options?.pinnedByTerminalError === true;
-			completionIdleTimeoutOverrideMs = options?.timeoutMs !== void 0 ? resolveWatchTimeoutMs(options.timeoutMs) : void 0;
-			scheduleCompletionIdleWatch();
-		},
-		disarmCompletionIdleWatch: () => {
-			completionIdleWatchArmed = false;
-			completionIdleWatchPinnedByTerminalError = false;
-			completionIdleTimeoutOverrideMs = void 0;
-			clearCompletionIdleTimer();
-		},
-		armAssistantCompletionIdleWatch: (details) => {
-			assistantCompletionIdleWatchArmed = true;
-			assistantCompletionLastActivityAt = Date.now();
-			assistantCompletionLastActivityDetails = details;
-			scheduleAssistantCompletionIdleWatch();
-		},
-		disarmAssistantCompletionIdleWatch: () => {
-			assistantCompletionIdleWatchArmed = false;
-			assistantCompletionLastActivityDetails = void 0;
-			clearTimer("assistant");
-		},
-		touchActivity: (reason, options) => {
-			completionLastActivityAt = Date.now();
-			completionLastActivityReason = reason;
-			completionLastActivityDetails = options?.details;
-			completionIdleTimeoutOverrideMs = void 0;
-			if (options?.attemptProgress) recordAttemptProgress(reason, options);
-			params.onProgressDiagnostic(reason);
-			if (options?.arm) {
-				completionIdleWatchArmed = true;
-				completionIdleWatchPinnedByTerminalError = false;
-			}
-			scheduleProgressWatches();
-		},
-		noteNotificationReceived: (method, options) => {
-			const now = Date.now();
-			completionLastActivityAt = Math.max(completionLastActivityAt, Math.min(now, options?.receivedAtMs ?? now));
-			completionLastActivityReason = `notification:${method}`;
-			if (options?.details !== void 0) completionLastActivityDetails = options.details;
-			if (options?.attemptProgress) recordAttemptProgress(completionLastActivityReason, options);
-			if (params.isTerminalTurnNotificationQueued()) scheduleTerminalIdleWatch();
-		},
-		extendAttemptIdleWatch: (timeoutMs) => {
-			attemptIdleTimeoutOverrideMs = resolveWatchTimeoutMs(timeoutMs);
-			scheduleAttemptIdleWatch();
+		ownsExecutionWait: () => deadline.kind === "unlimited" || deadline.kind === "execution" && Date.now() < deadline.startedAtMs + deadline.timeoutMs,
+		beginSettlement: (startedAtMs) => {
+			if (deadline.kind === "closed" || deadline.kind === "settlement") return;
+			armDeadline({
+				kind: "settlement",
+				startedAtMs,
+				timeoutMs: TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS
+			});
 		},
-		scheduleProgressWatches,
-		clearCompletionIdleTimer,
-		clearAllTimers
+		dispose
 	};
 }
 //#endregion
@@ -8632,9 +7287,8 @@ function createCodexAttemptTurnWatchController(params) {
 const CODEX_NATIVE_HOOK_RELAY_RENEW_INTERVAL_MS = 6e4;
 function createCodexAttemptTurnState(resources) {
 	const { prompt, state: resourceState, projectorRef, trajectoryRecorder, startupTimeoutMs } = resources;
-	const { context } = prompt;
-	const { connection } = context.runtime;
-	const { params, options, appServer, runAbortController } = connection;
+	const { connection } = prompt.context.runtime;
+	const { params, options, runAbortController } = connection;
 	const state = {
 		latestStartupErrorNotification: void 0,
 		rateLimitsRevisionBeforeLastTurnStart: void 0,
@@ -8644,14 +7298,7 @@ function createCodexAttemptTurnState(resources) {
 		localCompletionRequested: false,
 		terminalTurnNotificationQueued: false,
 		sawCodexInterruptMarker: false,
-		timedOut: false,
-		turnCompletionIdleTimedOut: false,
-		turnWatchTimeoutKind: void 0,
-		turnWatchTimeoutIdleMs: void 0,
-		turnWatchTimeoutMs: void 0,
-		turnWatchTimeoutLastActivityReason: void 0,
-		turnWatchTimeoutDetails: void 0,
-		turnCompletionIdleTimeoutMessage: void 0,
+		timeout: void 0,
 		clientClosedPromptError: void 0,
 		clientClosedDiagnostic: void 0,
 		clientClosedAbort: false,
@@ -8660,26 +7307,16 @@ function createCodexAttemptTurnState(resources) {
 		lifecycleTerminalEmitted: false,
 		nativeHookRelayLastRenewedAt: 0,
 		activeAppServerTurnRequests: 0,
-		activeAppServerTurnRequestsWithoutTimeout: 0,
-		unsettledFinalizationHookCount: 0,
-		rejectedFinalizationHookAssistant: void 0,
-		turnCrossedToolHandoff: false,
+		activeLocalProjections: 0,
+		projectionClosed: false,
 		pendingTerminalDynamicToolRelease: void 0,
 		terminalDynamicToolReleaseCheckScheduled: false,
 		currentTurnHadNonTerminalDynamicToolResult: false
 	};
 	const { promise: completion, resolve: resolveCompletion } = createDeferred();
-	const turnCompletionIdleTimeoutMs = resolveCodexTurnCompletionIdleTimeoutMs(options.turnCompletionIdleTimeoutMs ?? appServer.turnCompletionIdleTimeoutMs);
-	const turnAssistantCompletionIdleTimeoutMs = resolveCodexTurnAssistantCompletionIdleTimeoutMs(options.turnAssistantCompletionIdleTimeoutMs ?? appServer.turnAssistantCompletionIdleTimeoutMs);
-	const postToolRawAssistantCompletionIdleTimeoutMs = resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(options.postToolRawAssistantCompletionIdleTimeoutMs ?? appServer.postToolRawAssistantCompletionIdleTimeoutMs, turnAssistantCompletionIdleTimeoutMs);
-	const turnTerminalIdleTimeoutMs = resolveCodexTurnTerminalIdleTimeoutMs(options.turnTerminalIdleTimeoutMs, params.runTimeoutOverrideMs);
-	const turnAttemptIdleTimeoutMs = Math.max(100, Math.floor(params.timeoutMs));
 	const pendingOpenClawDynamicToolCompletionIds = /* @__PURE__ */ new Set();
 	const openClawDynamicToolExecutions = createCodexDynamicToolExecutionRegistry();
 	const activeTurnItemIds = /* @__PURE__ */ new Set();
-	const activeCompletionBlockerItemIds = /* @__PURE__ */ new Set();
-	const activeFinalizationHookRunIds = /* @__PURE__ */ new Set();
-	const finalizationHookBatchStatuses = /* @__PURE__ */ new Map();
 	const turnIdRef = {};
 	const userInputBridgeRef = {};
 	const steeringQueueRef = {};
@@ -8687,7 +7324,7 @@ function createCodexAttemptTurnState(resources) {
 		if (state.completed) return;
 		state.completed = true;
 		steeringQueueRef.current?.cancel();
-		turnWatches.clearAllTimers();
+		deadlines.beginSettlement(Date.now());
 		resolveCompletion();
 	};
 	const interruptTurn = async (turnId, completionOptions) => {
@@ -8709,86 +7346,62 @@ function createCodexAttemptTurnState(resources) {
 		state.nativeHookRelayLastRenewedAt = now;
 		resourceState.nativeHookRelay.renew(resolveCodexNativeHookRelayTtlMs({
 			explicitTtlMs: void 0,
-			attemptTimeoutMs: turnAttemptIdleTimeoutMs,
+			attemptTimeoutMs: params.timeoutMs,
 			startupTimeoutMs,
 			turnStartTimeoutMs: params.timeoutMs
 		}));
 	};
-	const turnWatches = createCodexAttemptTurnWatchController({
-		threadId: resourceState.thread.threadId,
+	const noteProgress = (reason) => {
+		if (state.completed || state.projectionClosed || runAbortController.signal.aborted) return;
+		renewNativeHookRelayForTurnProgress();
+		params.onRunProgress?.({
+			reason,
+			provider: params.provider,
+			model: params.modelId,
+			backend: "codex-app-server"
+		});
+		emitTrustedDiagnosticEvent({
+			type: "run.progress",
+			runId: params.runId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			reason: `codex_app_server:${reason}`
+		});
+	};
+	const deadlines = createCodexAttemptDeadlineController({
+		startedAtMs: connection.attemptStartedAt,
+		timeoutMs: params.timeoutMs,
 		signal: runAbortController.signal,
-		getTurnId: () => turnIdRef.current,
-		isCompleted: () => state.completed,
-		isTerminalTurnNotificationQueued: () => state.terminalTurnNotificationQueued,
-		getActiveAppServerTurnRequests: () => state.activeAppServerTurnRequests,
-		getActiveAppServerTurnRequestsWithoutTimeout: () => state.activeAppServerTurnRequestsWithoutTimeout,
-		getActiveTurnItemCount: () => activeTurnItemIds.size,
-		getActiveCompletionBlockerItemCount: () => activeCompletionBlockerItemIds.size,
-		getActiveFinalizationHookCount: () => state.unsettledFinalizationHookCount,
-		canReleaseAssistantCompletionIdle: () => projectorRef.current?.hasLatestTerminalAssistantCandidateText() === true,
-		turnCompletionIdleTimeoutMs,
-		turnAssistantCompletionIdleTimeoutMs,
-		turnAttemptIdleTimeoutMs,
-		turnTerminalIdleTimeoutMs,
-		interruptTimeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS,
-		onInterruptTurn: ({ turnId, timeoutMs }) => interruptTurn(turnId, {
-			locallyCompleted: true,
-			timeoutMs
-		}),
+		onDeadlineChanged: params.onAttemptDeadlineChanged,
 		onTimeout: (timeout) => {
-			state.timedOut = true;
-			state.turnCompletionIdleTimedOut = true;
-			state.turnWatchTimeoutKind = timeout.kind;
-			state.turnWatchTimeoutIdleMs = timeout.idleMs;
-			state.turnWatchTimeoutMs = timeout.timeoutMs;
-			state.turnWatchTimeoutLastActivityReason = timeout.lastActivityReason;
-			state.turnWatchTimeoutDetails = timeout.details;
-			state.turnCompletionIdleTimeoutMessage = "codex app-server turn idle timed out waiting for turn/completed";
+			state.timeout = timeout;
 			projectorRef.current?.markTimedOut();
-		},
-		onAbort: (reason) => runAbortController.abort(reason),
-		onCompleted: completeTurn,
-		onRecordEvent: (name, fields) => trajectoryRecorder?.recordEvent(name, fields),
-		onAttemptProgress: (reason) => {
-			renewNativeHookRelayForTurnProgress();
-			params.onRunProgress?.({
-				reason,
-				provider: params.provider,
-				model: params.modelId,
-				backend: "codex-app-server"
-			});
-		},
-		onProgressDiagnostic: (reason) => {
-			emitTrustedDiagnosticEvent({
-				type: "run.progress",
-				runId: params.runId,
-				sessionId: params.sessionId,
-				sessionKey: params.sessionKey,
-				reason: `codex_app_server:${reason}`
-			});
+			const error = /* @__PURE__ */ new Error(timeout.kind === "execution" ? "codex app-server execution budget timed out" : "codex app-server terminal settlement timed out");
+			const fields = {
+				threadId: resourceState.thread.threadId,
+				turnId: turnIdRef.current,
+				...timeout
+			};
+			trajectoryRecorder?.recordEvent(`turn.${timeout.kind}_timeout`, fields);
+			embeddedAgentLog.warn(error.message, fields);
+			params.onAttemptTimeout?.(error);
+			runAbortController.abort(error);
 		}
 	});
 	return {
 		state,
 		completion,
-		turnCompletionIdleTimeoutMs,
-		turnAssistantCompletionIdleTimeoutMs,
-		postToolRawAssistantCompletionIdleTimeoutMs,
-		turnTerminalIdleTimeoutMs,
-		turnAttemptIdleTimeoutMs,
 		pendingOpenClawDynamicToolCompletionIds,
 		openClawDynamicToolExecutions,
 		activeTurnItemIds,
-		activeCompletionBlockerItemIds,
-		activeFinalizationHookRunIds,
-		finalizationHookBatchStatuses,
 		turnIdRef,
 		userInputBridgeRef,
 		steeringQueueRef,
 		completeTurn,
 		interruptTurn,
 		renewNativeHookRelayForTurnProgress,
-		turnWatches
+		noteProgress,
+		deadlines
 	};
 }
 //#endregion
@@ -8804,21 +7417,26 @@ async function runCodexAppServerAttempt(params, options) {
 	attemptTools.runtimeYieldCompletionClaim.current = () => resources.state.nativeHookRelay?.hasClaimedDirectChild() ?? false;
 	await startCodexAttemptRuntime(resources);
 	const turnRuntime = createCodexAttemptTurnState(resources);
-	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 = await activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart.turn);
-	let finalizedResult;
 	try {
-		finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
+		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;
+		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 {
-		await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
+		turnRuntime.deadlines.dispose();
 	}
-	if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
-	return finalizedResult;
 }
 //#endregion
 export { runCodexAppServerAttempt };