@openclaw/codex 2026.9.1-beta.1 → 2026.9.1

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

@@ -1,49 +1,54 @@
-import { C as resolveCodexModelBackedReviewerPolicyContext, D as readCodexRequirementsToml, d as withMcpElicitationsApprovalPolicy, f as isCodexPairedNodeRemoteExecPlacementSandbox, g as resolveCodexPluginsPolicy, h as readCodexPluginConfig, j as resolveOpenClawExecPolicyForCodexAppServer, m as isCodexSandboxExecServerEnabled, o as resolveCodexComputerUseConfig, p as isCodexRemoteExecPlacementSandbox, r as resolveCodexAppServerHomeScope, u as shouldAutoApproveCodexAppServerApprovals, x as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-giW8X0QA.js";
-import { A as resolveCodexTurnAssistantCompletionIdleTimeoutMs, E as isCodexAppServerStartupError, F as isCodexAppServerApprovalRequest, G as CodexAppServerRpcError, I as isCodexAppServerBrokenPipeError, K as createCodexElicitationResponse, L as isCodexAppServerConnectionClosedError, M as resolveCodexTurnTerminalIdleTimeoutMs, N as withCodexStartupTimeout, O as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, P as getCodexAppServerClientInstanceId, Q as protectCodexAppServerLiveThread, R as isCodexAppServerIndeterminateRequestCancellationError, T as CodexAppServerStartupError, U as resolveCodexAppServerClientInstanceId, V as isCodexAppServerRequestTimeoutError, Y as ensureCodexAppServerClientRuntime, _ as retireSharedCodexAppServerClientIfCurrent, _t as flattenCodexDynamicToolFunctions, a as createIsolatedCodexAppServerClient, at as readRecentCodexRateLimits, c as isCodexAppServerStartSelectionChangedError, ct as resolveCodexAppServerAuthAccountCacheKey, dt as resolveCodexAppServerFallbackApiKeyCacheKey, et as retainCodexAppServerLiveThread, ft as resolveCodexAppServerPreparedApiKeyCacheKey, g as retainSharedCodexAppServerClientIfCurrent, it as readCodexRateLimitsRevision, j as resolveCodexTurnCompletionIdleTimeoutMs, k as resolveCodexStartupTimeoutMs, lt as resolveCodexAppServerAuthProfileId, n as clearSharedCodexAppServerClientIfCurrent, nt as withAbortableTimeout, o as getLeasedSharedCodexAppServerClient, ot as rememberCodexRateLimitsRead, p as releaseLeasedSharedCodexAppServerClient, pt as resolveCodexAppServerPreparedAuthHandoff, r as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, s as getSharedCodexAppServerClient, u as readCodexAppServerClientDesktopGenerationFingerprint, ut as resolveCodexAppServerAuthProfileIdForAgent, vt as isJsonObject, w as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, xt as resolveCodexAppServerHomeDir, z as isCodexAppServerIndeterminateTransportError } from "./shared-client-DKz23hHY.js";
-import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, i as createCodexSessionGenerationSupersededError, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore } from "./session-binding-Bcynfd-_.js";
-import { A as shouldSynthesizeToolProgressForItem, B as readNullableString, E as itemStatus, F as readItem, I as readItemString, N as readCodexErrorNotificationMessage, O as shouldClearTerminalPresentationForNativeItem, T as itemName, V as splitPlanText, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, j as extractRawAssistantText, l as retireCodexAppServerClientAfterTimedOutTurn, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, u as retireUnsafeCodexTurnClientBestEffort, z as readNonNegativeInteger } from "./attempt-client-cleanup-bfsmcQ6m.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-Bk1I90Bg.js";
-import { l as readCodexTurn, o as assertCodexTurnStartResponse, s as readCodexDynamicToolCallParams, u as readCodexTurnCompletedNotification } from "./protocol-validators-VeJxxJ0U.js";
-import { n as buildCodexAppServerRuntimeFingerprint, o as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-C1CAdfcP.js";
-import { C as toCodexDynamicToolProgressResponse, Dt as resolveRecoverableCodexPluginConfigKeys, F as resolveCodexWebSearchPlan, I as buildDeveloperInstructions, J as areCodexDynamicToolFingerprintsCompatible, S as shouldReleaseTurnAfterTerminalDynamicTool, T as resolveCodexToolAbortTerminalReason, V as resolveCodexAppServerThreadModelSelection, X as codexLegacyDynamicToolsFingerprint, Y as codexDynamicToolsFingerprint, Z as filterCodexDynamicTools, _ as isDynamicToolTerminalDiagnosticEvent, _t as buildCodexPluginThreadConfigTimeoutFallback, a as isCodexAppServerProfilerEnabled, at as buildContextEngineBinding, b as resolveTerminalDynamicToolBatchAction, bt as mergeCodexThreadConfigs, c as buildCodexNativeHookRelayConfig, ct as fitCodexProjectedContextForTurnStart, d as emitCodexNativePreToolUseFailureDiagnostic, dt as resolveCodexContextEngineProjectionMaxChars, et as isMessageOnlyCodexSourceReply, f as resolveCodexNativeHookRelayEvents, ft as resolveCodexContextEngineProjectionReserveTokens, g as hasPendingDynamicToolTerminalDiagnostic, gt as buildCodexPluginThreadConfigInputFingerprint, h as handleDynamicToolCallWithTimeout, ht as buildCodexPluginThreadConfig, i as startOrResumeThread, it as resolveCodexDynamicToolsLoadingForRuntime, l as buildCodexNativeHookRelayDisabledConfig, lt as neutralizeCodexExplicitMentionSigils, m as scheduleCodexNativeHookRelayUnregister, mt as buildCodexPluginAppsConfigPatchFromPolicyContext, n as buildTurnStartParams, ot as isContextEngineBindingCompatible, p as resolveCodexNativeHookRelayTtlMs, pt as resolveCodexContinuityProjectionMaxChars, r as buildCodexUserInput, s as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, st as buildCodexContinuityCalibration, t as buildTurnCollaborationMode, tt as isSystemAgentOnlyCodexDynamicToolAllowlist, u as createCodexNativeHookRelay, ut as projectContextEngineAssemblyForCodex, v as isMatchingDynamicToolTerminalDiagnostic, w as toCodexDynamicToolProtocolResponse, x as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, xt as shouldBuildCodexPluginThreadConfig, y as resolveDynamicToolCallTimeoutMs, yt as buildPluginAppPolicyContext } from "./thread-lifecycle-L7oEkTlq.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
-import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
-import { a as buildCodexUserPromptMessage, c as readCodexMirrorSourceFingerprint, i as mirrorPromptAtTurnStartBestEffort, l as serializeCodexMirrorSourceEvidence, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-DsCMWBca.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-BRMh0aIq.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-C5_D8Gmb.js";
-import { r as formatCodexDisplayText } from "./command-formatters-DEsIufkt.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BrNH1bjy.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-BMvPX73o.js";
-import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-B4FfbcCg.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 readCodexMirroredSessionHistoryMessages, c as inferCodexDynamicToolMeta, d as sanitizeCodexToolArguments, f as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as isCodexCommandBearingToolCall, n as CodexEventProjection, o as CodexToolProgressProjection, r as emitCodexAgentEvent, s as shouldEmitTranscriptToolProgress, t as codexNativeSubagentMonitorRuntime, u as resolveCodexToolProgressDetailMode } from "./native-subagent-monitor-4Mfq2HDs.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-Dnlfa--w.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-CTCT3w5L.js";
-import { asBoolean, asFiniteNumber, asOptionalRecord, hasNonEmptyString, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+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 { 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-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, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds, 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 { resolveAgentConfig as resolveAgentConfig$1 } from "openclaw/plugin-sdk/agent-scope-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 { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
-import { captureFinalCodexCronCreatorToolAllowlist, materializeStaticMcpToolsForScheduledHarnessRun, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
-import { 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
@@ -69,6 +74,12 @@ function createCodexSteeringQueue(params) {
 	let sendChain = Promise.resolve();
 	let sealedError;
 	let closedError;
+	const assertActive = () => {
+		const unavailableError = closedError ?? sealedError;
+		if (unavailableError) throw unavailableError;
+		params.signal.throwIfAborted();
+		params.assertActive();
+	};
 	const clearBatchTimer = () => {
 		if (batchTimer) {
 			clearTimeout(batchTimer);
@@ -121,19 +132,20 @@ function createCodexSteeringQueue(params) {
 	const sendBatch = async (items) => {
 		const liveItems = items.filter((item) => !item.settled);
 		if (liveItems.length === 0) return;
-		const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-		if (unavailableError) {
-			for (const item of liveItems) rejectItem(item, unavailableError);
-			throw unavailableError;
-		}
-		const clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-		const batch = { items: liveItems };
-		dispatchedBatches.set(clientUserMessageId, batch);
+		let clientUserMessageId;
 		try {
+			assertActive();
+			const input = [];
+			for (const item of liveItems) {
+				input.push(...await params.prepareMessage(item.text, item));
+				assertActive();
+			}
+			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
+			dispatchedBatches.set(clientUserMessageId, { items: liveItems });
 			await params.client.request("turn/steer", {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
-				input: liveItems.flatMap((item) => buildCodexUserInput(item.text, item.images)),
+				input,
 				clientUserMessageId
 			}, {
 				timeoutMs: params.requestTimeoutMs,
@@ -141,8 +153,8 @@ function createCodexSteeringQueue(params) {
 			});
 			for (const item of liveItems) reportItemAcceptance(item, true);
 		} catch (error) {
-			dispatchedBatches.delete(clientUserMessageId);
-			const acceptedUnconfirmed = isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error);
+			if (clientUserMessageId) dispatchedBatches.delete(clientUserMessageId);
+			const acceptedUnconfirmed = clientUserMessageId !== void 0 && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error));
 			for (const item of liveItems) {
 				if (acceptedUnconfirmed) reportItemAcceptance(item, true);
 				rejectItem(item, error);
@@ -176,15 +188,12 @@ function createCodexSteeringQueue(params) {
 			rejectDelivery = reject;
 		});
 		const item = {
+			...options,
 			acceptance: "open",
 			text,
-			images: options?.images,
-			isInboundUserMessage: options?.isInboundUserMessage,
-			onQueueAccepted: options?.onQueueAccepted,
 			resolve: resolveDelivery,
 			reject: rejectDelivery,
-			settled: false,
-			userTurnTranscriptRecorder: options?.userTurnTranscriptRecorder
+			settled: false
 		};
 		pendingMessages.add(item);
 		return {
@@ -196,10 +205,11 @@ function createCodexSteeringQueue(params) {
 	if (params.signal.aborted) abortQueue();
 	return {
 		async queue(text, options) {
-			const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-			if (unavailableError) {
+			try {
+				assertActive();
+			} catch (error) {
 				options?.onQueueAccepted?.(false);
-				throw unavailableError;
+				throw error;
 			}
 			const { item, delivery } = createPendingMessage(text, options);
 			batchedMessages.push(item);
@@ -243,20 +253,20 @@ function normalizeCodexSteerDebounceMs(value) {
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
-	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp) {
+	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
 		this.params = params;
 		this.emitAgentEvent = emitAgentEvent;
 		this.matchesToolProgressEcho = matchesToolProgressEcho;
 		this.nextTranscriptTimestamp = nextTranscriptTimestamp;
+		this.checkpointCommentary = checkpointCommentary;
 		this.assistantTextByItem = /* @__PURE__ */ new Map();
 		this.assistantItemOrder = [];
 		this.assistantTimestampByItem = /* @__PURE__ */ new Map();
 		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();
@@ -265,27 +275,7 @@ var CodexAssistantProjection = class {
 		this.persistableAssistantBarrier = 0;
 		this.persistedAssistantBoundary = false;
 		this.persistableAssistantBarrierItemIds = /* @__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();
+		this.completedAssistantItemIds = /* @__PURE__ */ new Set();
 	}
 	handleNotification(method, params) {
 		if (method === "model/rerouted") this.responseModel = readStringField(params, "toModel") ?? this.responseModel;
@@ -309,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;
@@ -346,12 +337,11 @@ var CodexAssistantProjection = class {
 		}
 	}
 	recordItemCompleted(item, itemId, activeItemIds) {
+		if (itemId && item?.type === "agentMessage") this.completedAssistantItemIds.add(itemId);
 		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)) {
@@ -364,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");
@@ -372,6 +363,7 @@ var CodexAssistantProjection = class {
 		}
 	}
 	recordSnapshotItem(item) {
+		if (item.type === "agentMessage") this.completedAssistantItemIds.add(item.id);
 		this.rememberAssistantPhase(item);
 		if (item.type === "agentMessage" && typeof item.text === "string") {
 			this.rememberAssistantItem(item.id);
@@ -387,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;
@@ -410,15 +399,17 @@ var CodexAssistantProjection = class {
 		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && activeItemIds.size === 0;
 		if (text && phase !== "commentary" && candidateWasSupersededBeforeRaw && itemId !== this.streamedPartialAssistantItemId && !isIdlessTerminalAssistantAfterCompletedWork) return;
 		if (phase) this.assistantPhaseByItem.set(itemId, phase);
+		this.completedAssistantItemIds.add(itemId);
 		this.rememberAssistantItem(itemId);
 		this.assistantTextByItem.set(itemId, text);
 		if (!text) return;
 		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);
@@ -433,16 +424,18 @@ var CodexAssistantProjection = class {
 	}
 	collectCommentaryMessages() {
 		return this.assistantItemOrder.flatMap((itemId) => {
-			if (!this.isCommentaryAssistantItem(itemId)) return [];
-			const text = this.assistantTextByItem.get(itemId)?.trim();
-			const timestamp = this.assistantTimestampByItem.get(itemId);
-			if (!text || timestamp === void 0) return [];
-			return [{
+			const message = this.readCommentaryMessage(itemId);
+			return message ? [{
 				itemId,
-				message: createAssistantCommentaryMessage(this.params, text, itemId, timestamp)
-			}];
+				message
+			}] : [];
 		});
 	}
+	readCommentaryMessage(itemId) {
+		const text = this.assistantTextByItem.get(itemId)?.trim();
+		const timestamp = this.assistantTimestampByItem.get(itemId);
+		return this.isCommentaryAssistantItem(itemId) && text && timestamp !== void 0 ? createAssistantCommentaryMessage(this.params, text, itemId, timestamp) : void 0;
+	}
 	collectAsyncMessages() {
 		return this.assistantItemOrder.flatMap((itemId) => {
 			if (!this.isAsyncAssistantItem(itemId)) return [];
@@ -455,19 +448,20 @@ var CodexAssistantProjection = class {
 			}];
 		});
 	}
-	createCompletedAssistantBoundaryMessage(completedItemIds, options) {
-		const itemId = this.latestCompletedTerminalAssistantItemId;
-		const text = itemId ? this.assistantTextByItem.get(itemId)?.trim() : void 0;
-		const itemIndex = itemId ? this.assistantItemOrder.indexOf(itemId) : -1;
-		if (!itemId || !completedItemIds.has(itemId) || itemIndex < this.persistableAssistantBarrier || !text || isSilentReplyPayloadText(text) || this.isToolProgressEchoText(itemId, text)) return;
-		const message = this.createAssistantMessage(text, options);
-		return {
-			itemId,
-			message: {
-				...message,
-				timestamp: this.assistantTimestampByItem.get(itemId) ?? message.timestamp
-			}
-		};
+	collectCompletedAssistantMessages(completedItemIds, options) {
+		return this.assistantItemOrder.flatMap((itemId) => {
+			const text = this.assistantTextByItem.get(itemId)?.trim();
+			if (!completedItemIds.has(itemId) || this.isNonTerminalAssistantItem(itemId) || !text || isSilentReplyPayloadText(text) || this.isToolProgressEchoText(itemId, text)) return [];
+			const message = this.createAssistantMessage(text, options);
+			const timestamp = this.assistantTimestampByItem.get(itemId) ?? message.timestamp;
+			return [{
+				itemId,
+				message: {
+					...message,
+					timestamp
+				}
+			}];
+		});
 	}
 	markAssistantBoundaryPersisted(itemId) {
 		const index = this.assistantItemOrder.indexOf(itemId);
@@ -526,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");
@@ -548,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"
 			}
@@ -574,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: {
@@ -597,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) {
@@ -610,7 +604,6 @@ var CodexAssistantProjection = class {
 			return;
 		}
 		this.latestTerminalAssistantCandidateSuperseded = true;
-		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
 		this.terminalAssistantCandidateEarlierActiveItemIds.clear();
 		this.supersedeVisibleAnswerCandidate();
 	}
@@ -655,9 +648,15 @@ var CodexAssistantProjection = class {
 		this.persistableAssistantBarrier = this.assistantItemOrder.length;
 	}
 	rememberAssistantItem(itemId) {
-		if (!itemId || this.assistantItemOrder.includes(itemId)) return;
-		this.assistantItemOrder.push(itemId);
-		this.assistantTimestampByItem.set(itemId, this.nextTranscriptTimestamp());
+		if (!itemId) return;
+		if (!this.assistantTimestampByItem.has(itemId)) {
+			this.assistantItemOrder.push(itemId);
+			this.assistantTimestampByItem.set(itemId, this.nextTranscriptTimestamp());
+		}
+		if (this.isCommentaryAssistantItem(itemId)) this.checkpointCommentary?.(itemId, {
+			read: () => this.readCommentaryMessage(itemId),
+			ready: () => this.completedAssistantItemIds.has(itemId)
+		});
 	}
 	createAsyncDelivery(itemId) {
 		if (!this.isAsyncAssistantItem(itemId)) return;
@@ -1005,49 +1004,29 @@ function reasoningMethodOrder(method) {
 const attemptTerminal = agentHarnessAttemptTerminal;
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
-const CODEX_META_KEY$1 = "__openclaw";
-function readTurnTaintMetadata(message) {
-	return asOptionalRecord(CODEX_META_KEY$1 in message ? message[CODEX_META_KEY$1] : void 0);
-}
-function applyStickyTurnTaint(messages) {
-	let tainted = false;
-	return messages.map((message) => {
-		if (message.role === "user") {
-			tainted = false;
-			return message;
-		}
-		const metadata = readTurnTaintMetadata(message);
-		tainted ||= metadata?.turnTainted === true || metadata?.resultContentSource === "network";
-		return message.role === "assistant" && tainted ? {
-			...message,
-			__openclaw: {
-				...metadata,
-				turnTainted: true
-			}
-		} : message;
-	});
-}
 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 = [
 		...commentaryMessages,
 		...asyncMessages,
+		...(params.assistantMessages ?? []).map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:assistant:${itemId}`)),
 		...params.toolMessages
 	].toSorted((left, right) => (asDateTimestampMs(left.timestamp) ?? 0) - (asDateTimestampMs(right.timestamp) ?? 0));
 	messages.push(...visibleWorkMessages);
-	if (params.lastAssistant) messages.push(attachCodexMirrorIdentity(params.lastAssistant, params.lastAssistantIdentity ?? `${params.turnId}:assistant`));
-	return applyStickyTurnTaint(messages).map((message) => projectAgentHarnessTranscriptMessageForDisplay({
+	if (params.lastAssistant) messages.push(attachCodexMirrorIdentity(params.lastAssistant, `${params.turnId}:assistant`));
+	const taint = { tainted: false };
+	return messages.map((message) => projectAgentHarnessTranscriptMessageForDisplay({
 		hidden: params.runParams.trigger === "memory",
-		message
+		message: applyCodexTranscriptTaint(message, taint)
 	}));
 }
 function buildCodexSteeringMessagesSnapshot(params) {
 	const asyncMessages = params.assistantProjection.collectAsyncMessages().filter(({ itemId }) => params.completedItemIds.has(itemId));
 	const commentaryMessages = params.assistantProjection.collectCommentaryMessages().filter(({ itemId }) => params.completedItemIds.has(itemId));
-	const assistantBoundary = params.assistantProjection.createCompletedAssistantBoundaryMessage(params.completedItemIds, {
+	const assistantMessages = params.assistantProjection.collectCompletedAssistantMessages(params.completedItemIds, {
 		tokenUsage: void 0,
 		aborted: false,
 		promptError: void 0
@@ -1060,12 +1039,11 @@ function buildCodexSteeringMessagesSnapshot(params) {
 			reasoningText: void 0,
 			asyncMessages,
 			commentaryMessages,
+			assistantMessages,
 			toolMessages: params.toolMessages,
-			lastAssistant: assistantBoundary?.message,
-			...assistantBoundary ? { lastAssistantIdentity: `${params.turnId}:assistant:${assistantBoundary.itemId}` } : {},
-			createAssistantMirrorMessage: (title, text) => params.assistantProjection.createAssistantMirrorMessage(title, text)
+			lastAssistant: void 0
 		}).filter((message) => message.role !== "user"),
-		...assistantBoundary ? { assistantBoundaryItemId: assistantBoundary.itemId } : {}
+		assistantBoundaryItemId: assistantMessages.at(-1)?.itemId
 	};
 }
 //#endregion
@@ -1111,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);
@@ -1125,7 +1102,9 @@ function buildCodexAttemptResult(input) {
 	});
 	const toolMetas = input.toolProgressProjection.toolMetas;
 	const hadPotentialSideEffects = input.toolTelemetry.didSendViaMessagingTool || Boolean(input.toolTelemetry.successfulCronAdds || input.toolTelemetry.acceptedSessionSpawns?.length) || input.generatedMediaProjection.hasGeneratedMedia() || input.toolProgressProjection.hasPotentialSideEffects;
-	return {
+	const sentMediaUrls = new Set(input.toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
+	const toolAutoDeliveryMediaUrls = input.toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
+	const result = {
 		terminal: attemptTerminal.normalize({
 			aborted: input.aborted,
 			promptError,
@@ -1172,8 +1151,83 @@ function buildCodexAttemptResult(input) {
 		yieldDetected: input.yieldDetected || false,
 		didSendDeterministicApprovalPrompt: input.guardianReviewCount > 0 ? false : void 0
 	};
+	const transferTtsProvenance = resolveCodexTtsProvenanceTransfer(input.runParams.hostCapabilities);
+	for (const toolResult of input.toolTelemetry.coreTtsToolResults ?? []) transferTtsProvenance?.(toolResult, result, toolAutoDeliveryMediaUrls ?? []);
+	return result;
 }
 //#endregion
+//#region extensions/codex/src/app-server/transcript-checkpoint.ts
+/** Commits completed work in receipt order without waiting for the enclosing turn. */
+var CodexTranscriptCheckpoint = class {
+	constructor(params, threadId, turnId) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.pending = [];
+		this.commentaryItemIds = /* @__PURE__ */ new Set();
+		this.lastTimestamp = 0;
+		this.writing = Promise.resolve();
+		this.tainted = false;
+		this.closed = false;
+		this.nextTimestamp = () => {
+			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
+			return this.lastTimestamp;
+		};
+		this.enqueueCommentary = (itemId, entry) => {
+			if (this.params.config?.ui?.prefs?.chatPersistCommentary === false || this.commentaryItemIds.has(itemId)) return;
+			this.commentaryItemIds.add(itemId);
+			this.enqueue({
+				...entry,
+				read: () => {
+					const message = entry.read();
+					return message ? attachCodexMirrorIdentity(message, `${this.turnId}:commentary:${itemId}`) : void 0;
+				}
+			});
+		};
+		this.enqueue = (entry) => {
+			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
+		};
+	}
+	flush(close = false) {
+		if (this.closed) return this.writing;
+		this.closed = close;
+		this.writing = this.writing.then(async () => {
+			const blocked = close ? -1 : this.pending.findIndex((entry) => entry.ready?.() === false);
+			const count = blocked < 0 ? this.pending.length : blocked;
+			if (count === 0) return;
+			const taint = { tainted: this.tainted };
+			const messages = this.pending.slice(0, count).flatMap((entry) => {
+				const message = entry.read();
+				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
+					hidden: this.params.trigger === "memory",
+					message: applyCodexTranscriptTaint(message, taint)
+				})] : [];
+			});
+			try {
+				await codexTranscriptMirrorRuntime.mirror({
+					...this.params.sessionTarget,
+					sessionId: this.params.sessionId,
+					cwd: this.params.workspaceDir,
+					messages,
+					idempotencyScope: `codex-app-server:${this.threadId}`,
+					runId: this.params.runId,
+					runMirrorIdentityPrefix: `${this.turnId}:`,
+					config: this.params.config
+				});
+				this.pending.splice(0, count);
+				this.tainted = taint.tainted;
+			} catch (error) {
+				embeddedAgentLog.warn("failed to checkpoint codex app-server transcript", {
+					runId: this.params.runId,
+					sessionId: this.params.sessionId,
+					error: formatErrorMessage(error)
+				});
+			}
+		});
+		return this.writing;
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/usage-limit-error.ts
 /**
 * Enriches Codex usage-limit failures with current rate-limit information and
@@ -1183,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;
 }
@@ -1322,13 +1380,14 @@ 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;
 		this.aborted = false;
 		this.responseCompletions = new CodexResponseCompletionProjection();
 		this.completedCompactionCount = 0;
-		this.lastTranscriptTimestamp = 0;
+		this.transcriptCheckpoint = new CodexTranscriptCheckpoint(params, threadId, turnId);
 		this.asyncDeliveryProjection = new CodexAsyncDeliveryProjection(params, threadId, turnId, options);
 		this.contextTokens = options.initialContextTokens;
 		this.contextTokensSource = options.initialContextTokens === void 0 ? void 0 : "resolved";
@@ -1341,22 +1400,26 @@ var CodexAppServerEventProjector = class {
 			signal: options.runAbortSignal
 		});
 		this.toolProgressProjection = new CodexToolProgressProjection(params);
-		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, () => this.nextTranscriptTimestamp(), {
+		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, this.transcriptCheckpoint.nextTimestamp, {
 			nativePostToolUseRelayEnabled: options.nativePostToolUseRelayEnabled,
 			prepareNativeMcpAppResultDetails: options.prepareNativeMcpAppResultDetails,
-			trajectoryRecorder: options.trajectoryRecorder
+			trajectoryRecorder: options.trajectoryRecorder,
+			checkpointMessage: this.transcriptCheckpoint.enqueue
 		});
 		this.eventProjection = new CodexEventProjection(threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
-		this.assistantProjection = new CodexAssistantProjection(params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), () => this.nextTranscriptTimestamp());
+		this.assistantProjection = new CodexAssistantProjection(params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
 		this.reasoningProjection = new CodexReasoningProjection(params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
 	}
-	nextTranscriptTimestamp() {
-		this.lastTranscriptTimestamp = Math.max(Date.now(), this.lastTranscriptTimestamp + 1);
-		return this.lastTranscriptTimestamp;
-	}
 	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,
@@ -1376,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) {
@@ -1410,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") {
@@ -1437,9 +1486,11 @@ var CodexAppServerEventProjector = class {
 				break;
 			case "item/started":
 				await this.handleItemStarted(params);
+				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/completed":
 				await this.handleItemCompleted(params);
+				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/commandExecution/outputDelta":
 				this.toolProgressProjection.handleOutputDelta(params, "bash");
@@ -1478,10 +1529,11 @@ var CodexAppServerEventProjector = class {
 				await this.handleTurnCompleted(params);
 				break;
 			case "rawResponse/completed":
-				this.responseCompletions.record(params);
+				this.responseCompletions.record(params, this.params.hostCapabilities.reportOutputTokens);
 				break;
 			case "rawResponseItem/completed":
 				await this.handleRawResponseItemCompleted(params);
+				await this.transcriptCheckpoint.flush();
 				break;
 			case "model/rerouted":
 				this.eventProjection.handleModelRerouted(params);
@@ -1492,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;
 			}
@@ -1507,9 +1563,7 @@ var CodexAppServerEventProjector = class {
 			case "model/verification":
 			case "turn/moderationMetadata":
 			case "model/safetyBuffering/updated": break;
-			default:
-				this.diagnostics.warnUnknownEvent(notification, params);
-				break;
+			default: this.diagnostics.warnUnknownEvent(notification, params);
 		}
 	}
 	buildResult(toolTelemetry, options) {
@@ -1583,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",
@@ -1614,6 +1659,7 @@ var CodexAppServerEventProjector = class {
 			phase: "start",
 			item
 		});
+		if (this.projectionClosed) return;
 		this.toolTranscriptProjection.recordNativeToolCall(item);
 		this.toolProgressProjection.emitToolResultSummary(item);
 		this.emitAgentEvent({
@@ -1638,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,
@@ -1667,7 +1708,7 @@ var CodexAppServerEventProjector = class {
 				threadId: this.threadId,
 				turnId: this.turnId,
 				itemId,
-				timestamp: this.nextTranscriptTimestamp()
+				timestamp: this.transcriptCheckpoint.nextTimestamp()
 			});
 			this.eventProjection.emitCompactionEnd(itemId, true);
 		}
@@ -1681,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({
@@ -1702,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) {
@@ -1720,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",
@@ -1763,6 +1806,7 @@ var CodexAppServerEventProjector = class {
 				item
 			});
 		}
+		if (this.projectionClosed) return;
 		this.activeItemIds.delete(item.id);
 		this.eventProjection.emitStandardItemEvent({
 			phase: "end",
@@ -1774,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;
@@ -1798,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");
@@ -1817,23 +1848,11 @@ 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 visibility = asOptionalRecord(asOptionalRecord(asOptionalRecord(tool)?.["_meta"])?.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 uri = normalizeOptionalString(asOptionalRecord(item.appContext)?.resourceUri) ?? normalizeOptionalString(item.mcpAppResourceUri);
+	const appContext = asOptionalRecord(item.appContext);
+	const uri = normalizeOptionalString(appContext?.resourceUri) ?? normalizeOptionalString(item.mcpAppResourceUri);
 	return uri?.startsWith("ui://") ? uri : void 0;
 }
 function readMcpAppConnectorId(item) {
@@ -1914,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 } : {},
@@ -1944,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,
@@ -1953,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({
@@ -1974,9 +1993,9 @@ function createCodexNativeMcpAppResultDetailsPreparer(params) {
 const RESTORED_PLAN_PREAMBLE = "OpenClaw restored the session progress card after context compaction. This is application state, not a new user request. Continue the current task and call progress_card whenever the status meaningfully changes.";
 const PROGRESS_CARD_MAX_STEPS = 50;
 const PROGRESS_CARD_MAX_STEP_UTF8_BYTES = 512;
-const PROGRESS_CARD_MAX_UTF8_BYTES = 8 * 1024;
-const RESTORED_PLAN_MAX_MARKDOWN_BYTES = 2 * 1024;
-const RESTORED_PLAN_MAX_PAYLOAD_BYTES = 32 * 1024;
+const PROGRESS_CARD_MAX_UTF8_BYTES = 8192;
+const RESTORED_PLAN_MAX_MARKDOWN_BYTES = 2048;
+const RESTORED_PLAN_MAX_PAYLOAD_BYTES = 32768;
 const RESTORED_PLAN_TRUNCATION_SUFFIX = "…";
 function canonicalizeNativeProgressCardInput(input) {
 	const markdown = input.markdown === void 0 ? void 0 : truncateUtf8(stripInvisibleUnicode(input.markdown), PROGRESS_CARD_MAX_UTF8_BYTES);
@@ -1986,8 +2005,10 @@ function canonicalizeNativeProgressCardInput(input) {
 		const text = truncateUtf8(stripInvisibleUnicode(step.step), PROGRESS_CARD_MAX_STEP_UTF8_BYTES);
 		if (!text.trim()) continue;
 		let status = step.status;
-		if (status === "in_progress") if (hasInProgressStep) status = "pending";
-		else hasInProgressStep = true;
+		if (status === "in_progress") {
+			if (hasInProgressStep) status = "pending";
+			else hasInProgressStep = true;
+		}
 		plan.push({
 			step: text,
 			status
@@ -2056,7 +2077,8 @@ function serializePlan(plan) {
 }
 function truncateUtf8(value, maxBytes) {
 	if (Buffer$1.byteLength(value, "utf8") <= maxBytes) return value;
-	return `${truncateUtf8Prefix(value, maxBytes - Buffer$1.byteLength(RESTORED_PLAN_TRUNCATION_SUFFIX, "utf8"))}${RESTORED_PLAN_TRUNCATION_SUFFIX}`;
+	const suffixBytes = Buffer$1.byteLength(RESTORED_PLAN_TRUNCATION_SUFFIX, "utf8");
+	return `${truncateUtf8Prefix(value, maxBytes - suffixBytes)}${RESTORED_PLAN_TRUNCATION_SUFFIX}`;
 }
 function readPlanSteps(value) {
 	if (!Array.isArray(value)) return [];
@@ -2076,7 +2098,7 @@ function isPlanStatus(value) {
 //#endregion
 //#region extensions/codex/src/app-server/user-input-bridge.ts
 /** Owns per-turn Codex request_user_input and ordinary MCP elicitation lifecycles. */
-const DEFAULT_USER_INPUT_TIMEOUT_MS = 15 * 6e4;
+const DEFAULT_USER_INPUT_TIMEOUT_MS = 9e5;
 const NONBLOCKING_USER_INPUT_TIMEOUT_MS = 12e4;
 const MAX_USER_INPUT_QUESTIONS = 3;
 const MAX_USER_INPUT_OPTIONS = 4;
@@ -2200,7 +2222,10 @@ function createCodexUserInputBridge(params) {
 				failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
 				run: async (signal) => {
 					const result = await execute(compiled.input, timeoutMs, signal);
-					if (result.status === "answered") return createCodexElicitationResponse("accept", compiled.input.kind === "ready" && compiled.input.plan.kind === "url" ? null : result.content);
+					if (result.status === "answered") {
+						const content = compiled.input.kind === "ready" && compiled.input.plan.kind === "url" ? null : result.content;
+						return createCodexElicitationResponse("accept", content);
+					}
 					if (result.status === "declined") return declineElicitation(result.message);
 					if (result.status === "unsupported") return declineElicitation(result.message);
 					return cancelValue;
@@ -2314,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, sandboxSessionKey, 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;
@@ -2359,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")),
@@ -2420,59 +2446,111 @@ 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({
 		params,
 		agentId: sessionAgentId,
 		notifyUserMessagePersisted,
-		sessionKey: sandboxSessionKey,
+		sessionKey: contextSessionKey,
 		cwd: effectiveCwd,
 		threadId: resourceState.thread.threadId,
 		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) throw new Error("codex app-server turn is no longer accepting steering");
+	};
+	const workspaceOnly = resolveAttemptFsWorkspaceOnly({
+		config: params.config,
+		sessionAgentId
+	});
+	const imageContext = {
+		workspaceDir: connection.effectiveWorkspace,
+		model: params.model,
+		config: params.config,
+		workspaceOnly,
+		localRoots: workspaceOnly ? void 0 : getAgentScopedMediaLocalRoots(params.config ?? {}, sessionAgentId),
+		sandbox: connection.sandbox?.enabled && connection.sandbox.fsBridge ? {
+			root: connection.sandbox.workspaceDir,
+			bridge: connection.sandbox.fsBridge
+		} : void 0
+	};
 	const activeSteeringQueue = createCodexSteeringQueue({
 		client: resourceState.client,
 		threadId: resourceState.thread.threadId,
 		turnId: activeTurnId,
 		requestTimeoutMs: connection.appServer.requestTimeoutMs,
 		signal: runAbortController.signal,
+		assertActive: assertSteeringActive,
+		prepareMessage: async (text, options) => {
+			const result = await detectAndLoadAgentHarnessPromptImages({
+				...imageContext,
+				prompt: text,
+				existingImages: options.images,
+				imageOrder: options.imageOrder,
+				media: options.media,
+				userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
+			});
+			if (result.failedMediaCount) throw new Error(`failed to hydrate ${result.failedMediaCount} structured image attachment(s) for Codex steering`);
+			return buildCodexUserInput(text, result.images);
+		},
 		beforeConfirmConsumed: async (items) => {
-			const inboundItems = items.filter((item) => item.isInboundUserMessage === true);
-			if (inboundItems.length === 0) return;
+			const transcriptItems = items.filter((item) => item.isInboundUserMessage === true || item.userTurnTranscriptRecorder !== void 0);
+			if (transcriptItems.length === 0) return;
 			await promptMirrorPromise;
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
 			if (params.sessionTarget && messages.length > 0) {
@@ -2490,7 +2568,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 				});
 				activeProjector.markSteeringTranscriptPersisted();
 			}
-			for (const item of inboundItems) {
+			for (const item of transcriptItems) {
 				const recorder = item.userTurnTranscriptRecorder;
 				if (!recorder) continue;
 				await recorder.persistApproved();
@@ -2500,7 +2578,8 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	});
 	steeringQueueRef.current = activeSteeringQueue;
 	const claimPendingUserInputAnswer = async (text, optionsLocal) => {
-		if (optionsLocal?.isInboundUserMessage !== true || optionsLocal.images?.length) return false;
+		if (optionsLocal?.isInboundUserMessage !== true || hasPromptImageInput(optionsLocal)) return false;
+		assertSteeringActive();
 		return await claimPendingAgentQuestionAnswer({
 			sessionKey: params.sessionKey ?? params.sessionId,
 			text,
@@ -2514,14 +2593,17 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		resolvedBy
 	});
 	const queueMessage = async (text, optionsLocal) => {
-		const isInboundUserMessage = optionsLocal?.isInboundUserMessage === true;
 		if (await claimPendingUserInputAnswer(text, optionsLocal)) {
 			optionsLocal?.onQueueAccepted?.(true);
 			return;
-		} else if (isInboundUserMessage && optionsLocal?.images?.length) try {
-			await cancelPendingUserInput("image-reply");
-		} catch (error) {
-			embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
+		}
+		if (optionsLocal?.isInboundUserMessage === true && hasPromptImageInput(optionsLocal)) {
+			assertSteeringActive();
+			try {
+				await cancelPendingUserInput("image-reply");
+			} catch (error) {
+				embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
+			}
 		}
 		try {
 			await activeSteeringQueue.queue(text, optionsLocal);
@@ -2536,21 +2618,32 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const handle = {
 		kind: "embedded",
 		runId: params.runId,
+		startedAtMs: params.startedAtMs,
 		toolAuthorityFingerprint: params.toolAuthorityFingerprint,
+		permissionChangeOwner: params.permissionChange?.owner,
+		applyPermissionMode: async (mode, revokeApprovals) => {
+			if (!params.permissionChange || terminalState.terminalOutcomeFrozen || params.abortSignal?.aborted || !state.permissionChangeRestart && (state.completed || runAbortController.signal.aborted)) return false;
+			const applied = params.permissionChange.request(mode);
+			state.permissionChangeRestart ??= "requested";
+			runAbortController.abort("permission-change");
+			revokeApprovals();
+			return await applied;
+		},
 		claimPendingUserInputAnswer,
 		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,
-		supportsQueueMessageImages: true,
+		supportsQueueMessageImages: params.model.input.includes("image"),
 		sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
 		taskSuggestionDeliveryMode: params.taskSuggestionDeliveryMode,
 		cancel: () => abortExplicitly("cancelled"),
@@ -2563,26 +2656,10 @@ 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;
-		}
-		interruptTurn(activeTurnId).finally(completeTurn);
-	};
-	runAbortController.signal.addEventListener("abort", abortListener, { once: true });
-	if (runAbortController.signal.aborted) abortListener();
+	if (!runAbortController.signal.aborted && params.permissionChange && !params.permissionChange.applied()) {
+		state.permissionChangeRestart = "requested";
+		runAbortController.abort("permission-change");
+	}
 	return {
 		activeTurnId,
 		activeProjector,
@@ -2590,7 +2667,8 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		handle,
 		freezeRunTerminalOutcome,
 		notifyUserMessagePersisted,
-		abortListener
+		abortListener,
+		ready: bindProjection()
 	};
 }
 //#endregion
@@ -2599,11 +2677,16 @@ 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();
 		if (params.isFinalFallbackAttempt !== false) await maybeEmitFastModeAutoResetBestEffort();
@@ -2613,36 +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 && 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 retainLiveIncognitoThread = (terminalState.turnSucceeded || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
+		const retainLiveThread = ((retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.turnSucceeded && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint) && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) ? (await bindingStore.read(bindingIdentity))?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
 			if ((await bindingStore.read(bindingIdentity))?.threadId !== resourceState.thread.threadId) return false;
-			return await retainCodexAppServerLiveThread(resourceState.client, resourceState.thread.threadId, resourceState.thread.liveThreadOwnership?.release ?? (async (threadId) => {
-				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-					threadId,
-					timeoutMs: 5e3
-				})) {
-					await closeCodexStartupClientBestEffort(resourceState.client);
-					throw new CodexAppServerUnsafeSubscriptionError(`Codex retained thread subscription could not be released: ${threadId}`);
-				}
-			}), resourceState.thread.liveThreadConfigFingerprint, connection.mutable.pluginAppServer.serviceTier);
-		}) : false;
-		const retainLiveThread = retainLiveIncognitoThread || retainedPersistentThread;
-		const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveIncognitoThread ? await bindingStore.mutate(bindingIdentity, {
+			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
+				release: resourceState.thread.liveThreadOwnership?.release,
+				configFingerprint: resourceState.thread.liveThreadConfigFingerprint,
+				serviceTier: connection.mutable.pluginAppServer.serviceTier,
+				ephemeralPolicy: resourceState.thread.liveThreadEphemeralPolicy
+			});
+		}) : false) || retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy === void 0;
+		const 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,
@@ -2652,8 +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.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 checkpointCleanup;
 		await runCleanupStep("codex-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		const nativeHookRelay = resourceState.nativeHookRelay;
 		resourceState.nativeHookRelay = void 0;
@@ -2667,17 +2752,17 @@ 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);
 		});
 		await runCleanupStep("codex-steering-cancel", () => steeringQueueRef.current?.cancel());
-		await runCleanupStep("codex-terminal-freeze", freezeRunTerminalOutcome);
 		await runCleanupStep("codex-reply-backend-detach", () => params.replyOperation?.detachBackend(handle));
 		await runCleanupStep("codex-active-run-clear", () => {
 			clearActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile);
 		});
 	}
+	await state.abortCleanup;
 }
 //#endregion
 //#region extensions/codex/src/app-server/workspace-dir-cache.ts
@@ -2751,21 +2836,21 @@ const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
 const CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS = 2e4;
 const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_TOKENS = 8e3;
 const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_RATIO = .5;
-const CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES = 64 * 1024;
+const CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES = 65536;
 const CODEX_APP_SERVER_BYTE_UNITS = {
 	b: 1,
 	k: 1024,
 	kb: 1024,
 	kib: 1024,
-	m: 1024 * 1024,
-	mb: 1024 * 1024,
-	mib: 1024 * 1024,
-	g: 1024 * 1024 * 1024,
-	gb: 1024 * 1024 * 1024,
-	gib: 1024 * 1024 * 1024,
-	t: 1024 * 1024 * 1024 * 1024,
-	tb: 1024 * 1024 * 1024 * 1024,
-	tib: 1024 * 1024 * 1024 * 1024
+	m: 1048576,
+	mb: 1048576,
+	mib: 1048576,
+	g: 1073741824,
+	gb: 1073741824,
+	gib: 1073741824,
+	t: 1099511627776,
+	tb: 1099511627776,
+	tib: 1099511627776
 };
 const codexSessionRecordCache = /* @__PURE__ */ new Map();
 function parseCodexAppServerByteLimit(value) {
@@ -3062,11 +3147,12 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const requirementsToml = readCodexRequirementsToml({});
 	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
-	const { sessionAgentId } = resolveSessionAgentIds({
+	const { sessionAgentId } = resolveSessionAgentIdsStrict({
 		sessionKey: params.sessionKey,
 		config: params.config,
 		agentId: params.agentId
 	});
+	const policyAgentId = params.sandboxAgentId ?? sessionAgentId;
 	preDynamicStartupStages.mark("config");
 	const resolvedWorkspace = resolveUserPath(params.workspaceDir);
 	await ensureCodexWorkspaceDirOnce(resolvedWorkspace);
@@ -3075,6 +3161,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const contextSessionKey = params.sessionKey?.trim() || sandboxSessionKey;
 	const sandbox = params.sandbox !== void 0 ? params.sandbox : await resolveSandboxContext({
 		config: params.config,
+		agentId: params.sandboxAgentId,
 		sessionKey: sandboxSessionKey,
 		workspaceDir: resolvedWorkspace
 	});
@@ -3085,18 +3172,24 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		execOverrides: params.execOverrides,
 		approvals: params.permissionMode === "full" ? void 0 : loadExecApprovals(),
 		config: params.config,
-		agentId: sessionAgentId
+		agentId: policyAgentId
 	});
 	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
 	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
 	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
+	const assertLocalTargetSupported = (unsupported) => {
+		if (preparedEnvironment?.localProcessEnv && unsupported) throw new Error("This runtime cannot target the diagnosed local installation. Use the saved prompt with a suggested external or manual handoff on this machine.");
+	};
+	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;
-	const disableLoginShell = remoteExec || preparedEnvironment?.managedLocalIdentity === true || preparedEnvironment !== void 0 && Object.keys(preparedEnvironment.credentialScrubEnv).length > 0;
+	const disableLoginShell = remoteExec || preparedEnvironment?.localProcessEnv !== void 0 || preparedEnvironment?.managedLocalIdentity === true || preparedEnvironment !== void 0 && Object.keys(preparedEnvironment.credentialScrubEnv).length > 0;
 	const withPreparedProcessEnv = (appServer) => {
+		assertLocalTargetSupported(appServer.start.transport === "websocket" || Boolean(appServer.remoteWorkspaceRoot));
 		return shellEnvironment ? {
 			...appServer,
 			start: {
@@ -3118,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,
@@ -3361,6 +3454,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		pluginConfig,
 		computerUseConfig,
 		sessionAgentId,
+		policyAgentId,
 		resolvedWorkspace,
 		sandboxSessionKey,
 		contextSessionKey,
@@ -3378,629 +3472,21 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		startupPreparedAuth,
 		startupClientAuthProfileId,
 		effectiveWorkspace,
-		effectiveCwd,
-		appServer,
-		sessionPermissionPolicy,
-		nativeHookRelayEvents,
-		runAbortController,
-		terminalState,
-		abortExplicitly,
-		abortFromUpstream,
-		resolveReviewerPolicyContext,
-		resolveRuntimeOptionsForCurrentBinding,
-		mutable,
-		initialStartupBindingHadInactiveThreadBootstrap,
-		initialInactiveThreadBootstrapBindingForcedFreshStart
-	};
-}
-//#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);
-	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 memoryPrompt = await prepareMemorySystemPromptAddition({
-		availableTools: new Set(params.toolNames),
-		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)
+		effectiveCwd,
+		appServer,
+		sessionPermissionPolicy,
+		nativeHookRelayEvents,
+		runAbortController,
+		terminalState,
+		abortExplicitly,
+		abortFromUpstream,
+		resolveReviewerPolicyContext,
+		resolveRuntimeOptionsForCurrentBinding,
+		mutable,
+		initialStartupBindingHadInactiveThreadBootstrap,
+		initialInactiveThreadBootstrapBindingForcedFreshStart
 	};
 }
-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) {
@@ -4048,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");
 }
@@ -4070,39 +3541,11 @@ 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) {
 	const { connection, runtimeParams, activeSessionId, activeSessionFile, buildActiveRunAttemptParams, effectiveContextWindowInfo, effectiveContextTokenBudget, effectiveRuntimeProviderId, effectiveRuntimeModelId, hookChannelId } = runtime;
-	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, sandboxSessionKey, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart, sandbox } = connection;
+	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart, sandbox } = connection;
 	const { toolBridge } = attemptTools;
 	const activeTranscriptTarget = {
 		agentId: sessionAgentId,
@@ -4128,12 +3571,20 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	const hookContext = {
 		runId: params.runId,
 		agentId: sessionAgentId,
-		sessionKey: sandboxSessionKey,
+		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();
@@ -4349,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";
@@ -4357,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. */
@@ -4436,101 +3866,17 @@ function isInvalidCodexImagePayloadError(message) {
 	return /\b(?:invalid|malformed)\b[\s\S]{0,120}\b(?:image|image url|base64)\b/iu.test(normalizedMessage) || /\b(?:image|image url|base64)\b[\s\S]{0,120}\b(?:invalid|malformed)\b/iu.test(normalizedMessage);
 }
 //#endregion
-//#region extensions/codex/src/app-server/settled-turn-context.ts
-function collectUniqueMessageIdentities(messages) {
-	const identities = /* @__PURE__ */ new Map();
-	for (const [index, message] of messages.entries()) {
-		const identity = readMirrorIdentity(message);
-		if (!identity) continue;
-		if (identities.has(identity)) return;
-		identities.set(identity, index);
-	}
-	return identities;
-}
-function adoptPersistedHostPrompt(params) {
-	const promptIdentity = `${params.turnId}:prompt`;
-	if (params.mirroredMessages.some((message) => readMirrorIdentity(message) === promptIdentity)) return params;
-	const sourcePrompt = params.settledMessages[0];
-	const sourceKey = sourcePrompt?.idempotencyKey;
-	if (sourcePrompt?.role !== "user" || readMirrorIdentity(sourcePrompt) !== promptIdentity || typeof sourceKey !== "string" || sourceKey.trim().length === 0) return params;
-	const matches = params.historyMessages.flatMap((message, index) => message.role === "user" && message.idempotencyKey === sourceKey ? [{
-		index,
-		message
-	}] : []);
-	const persistedPrompt = matches.length === 1 ? matches[0] : void 0;
-	const persistedMetadata = persistedPrompt?.message;
-	if (!persistedPrompt || readMirrorIdentity(persistedPrompt.message) !== void 0 || readCodexMirrorSourceFingerprint(persistedPrompt.message) !== void 0 || persistedMetadata?.["__openclaw"]?.mirrorOrigin === "codex-app-server") return params;
-	const sourceUpstreamText = readUpstreamUserText(sourcePrompt);
-	const persistedUpstreamText = readUpstreamUserText(persistedPrompt.message);
-	if (persistedUpstreamText !== void 0 && persistedUpstreamText !== sourceUpstreamText) return params;
-	let logicalPrompt = attachCodexMirrorIdentity(persistedPrompt.message, promptIdentity);
-	if (sourceUpstreamText !== void 0) logicalPrompt = attachUpstreamUserText(logicalPrompt, sourceUpstreamText);
-	if (serializeCodexMirrorSourceEvidence(logicalPrompt) !== serializeCodexMirrorSourceEvidence(sourcePrompt)) return params;
-	const historyMessages = [...params.historyMessages];
-	historyMessages[persistedPrompt.index] = logicalPrompt;
-	return {
-		historyMessages,
-		mirroredMessages: [logicalPrompt, ...params.mirroredMessages]
-	};
-}
-/** Freezes one complete active transcript branch through the settled tool-result boundary. */
-function buildCodexSettledTurnFinalizationContext(params) {
-	const { historyMessages, mirroredMessages } = adoptPersistedHostPrompt(params);
-	const boundaryMessage = params.settledMessages.findLast((message) => message.role === "toolResult");
-	const boundaryIdentity = boundaryMessage ? readMirrorIdentity(boundaryMessage) : void 0;
-	if (!boundaryMessage || !boundaryIdentity || !boundaryIdentity.startsWith(`${params.turnId}:tool:`)) return;
-	const settledBoundaryIndex = params.settledMessages.indexOf(boundaryMessage);
-	const requiredIdentities = params.settledMessages.slice(0, settledBoundaryIndex + 1).map(readMirrorIdentity);
-	if (requiredIdentities.length === 0 || requiredIdentities.some((identity) => !identity) || new Set(requiredIdentities).size !== requiredIdentities.length || !requiredIdentities.includes(`${params.turnId}:prompt`)) return;
-	const historyIdentities = collectUniqueMessageIdentities(historyMessages);
-	const mirroredIdentities = collectUniqueMessageIdentities(mirroredMessages);
-	if (!historyIdentities || !mirroredIdentities) return;
-	const mirroredBoundaryIndex = mirroredIdentities.get(boundaryIdentity);
-	if (mirroredBoundaryIndex === void 0) return;
-	const mirroredThroughBoundary = mirroredMessages.slice(0, mirroredBoundaryIndex + 1);
-	if (mirroredThroughBoundary.length !== requiredIdentities.length || mirroredThroughBoundary.some((message, index) => readMirrorIdentity(message) !== requiredIdentities[index])) return;
-	const historyBoundaryIndex = historyIdentities.get(boundaryIdentity);
-	if (historyBoundaryIndex === void 0) return;
-	let previousHistoryIndex = -1;
-	for (const mirroredMessage of mirroredThroughBoundary) {
-		const identity = readMirrorIdentity(mirroredMessage);
-		const historyIndex = identity ? historyIdentities.get(identity) : void 0;
-		const historyMessage = historyIndex === void 0 ? void 0 : historyMessages[historyIndex];
-		if (historyIndex === void 0 || historyIndex <= previousHistoryIndex || historyIndex > historyBoundaryIndex || !historyMessage || serializeCodexMirrorSourceEvidence(historyMessage) !== serializeCodexMirrorSourceEvidence(mirroredMessage)) return;
-		previousHistoryIndex = historyIndex;
-	}
-	return {
-		source: "openclaw-transcript",
-		messages: Object.freeze(structuredClone(params.historyMessages.slice(0, historyBoundaryIndex + 1)))
-	};
-}
-/** Reads and freezes the current active transcript branch after mirroring has settled. */
-async function captureCodexSettledTurnFinalizationContext(params) {
-	try {
-		const historyMessages = await readCodexMirroredSessionHistoryMessages(params);
-		if (!historyMessages) return;
-		return buildCodexSettledTurnFinalizationContext({
-			historyMessages,
-			mirroredMessages: params.mirroredMessages,
-			settledMessages: params.settledMessages,
-			turnId: params.turnId
-		});
-	} catch (error) {
-		embeddedAgentLog.warn("codex settled-turn finalization context capture failed", {
-			error: formatErrorMessage(error),
-			turnId: params.turnId
-		});
-		return;
-	}
-}
-//#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
 /** Creates a trajectory recorder when the host exposes its capture capability. */
 function createCodexTrajectoryRecorder(params) {
 	if (!params.trajectory) return null;
 	const trajectory = params.trajectory;
 	return {
-		recordEvent: trajectory.recordEvent,
+		recordEvent: (type, data) => {
+			try {
+				trajectory.recordEvent(type, data);
+			} catch {}
+		},
 		flush: trajectory.flush
 	};
 }
@@ -4594,39 +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 drainNotificationQueue();
-	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
-		});
+	const abortGraceElapsed = createDeferred();
+	let settlementClosed = false;
+	let abortGraceTimer;
+	const beginAbortGrace = () => {
+		if (settlementClosed) return;
+		abortGraceTimer = setTimeout(() => abortGraceElapsed.resolve(), TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
+		abortGraceTimer.unref?.();
+	};
+	const 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([settlement, abortGraceElapsed.promise]);
+		if (runAbortController.signal.aborted) await state.abortCleanup;
+	} finally {
+		settlementClosed = true;
+		abortListener[Symbol.dispose]();
+		clearTimeout(abortGraceTimer);
+		deadlines.dispose();
+		if (!state.projectionClosed) await resources.runCleanupStep("codex-transcript-checkpoint", closeProjection);
 	}
 	const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected: toolState.yieldDetected });
 	const projectedTerminal = attemptTerminal.project(result.terminal);
-	const effectiveTimedOut = state.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",
@@ -4669,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;
@@ -4709,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,
@@ -4729,14 +4069,13 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		turnId: activeTurnId
 	});
 	const { assistantTranscriptOwned, assistantTranscriptIdempotencyKey, terminalAnchor } = mirrorOutcome;
-	const shouldCaptureSettledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed);
-	const settledTurnFinalizationContext = shouldCaptureSettledTurnFinalizationContext ? await captureCodexSettledTurnFinalizationContext({
+	const settledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed) ? await captureCodexSettledTurnFinalizationContext({
 		...activeTranscriptTarget,
 		mirroredMessages: mirrorOutcome.mirroredMessages,
 		settledMessages: result.messagesSnapshot,
 		turnId: activeTurnId
-	}) : void 0;
-	if (shouldCaptureSettledTurnFinalizationContext && !settledTurnFinalizationContext) embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
+	}) ?? Object.freeze({ source: "unavailable" }) : void 0;
+	if (settledTurnFinalizationContext?.source === "unavailable") embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
 		threadId: resourceState.thread.threadId,
 		turnId: activeTurnId
 	});
@@ -4839,8 +4178,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			yielded: toolState.yieldDetected
 		})
 	});
-	const finalizedResult = {
-		...result,
+	const finalizedResult = Object.assign(result, {
 		...toolState.yieldAcknowledgment ? { yieldAcknowledgment: toolState.yieldAcknowledgment } : {},
 		terminal: attemptTerminal.normalize({
 			timedOut: effectiveTimedOut,
@@ -4858,15 +4196,12 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		...resourceState.runtimeContinuationStarted ? { runtimeContinuationStarted: true } : {},
 		...!finalAborted && !effectiveTimedOut && !finalPromptError && preparedAuthBinding ? { authBindingFingerprint: preparedAuthBinding.fingerprint } : {},
 		systemPromptReport
-	};
+	});
 	if (turnSucceeded && toolState.yieldDetected && !runAbortController.signal.aborted) resourceState.nativeHookRelay?.authorizeRetentionAfterSuccessfulYield();
 	return finalizedResult;
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-notification-state.ts
-/**
-* 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;
@@ -4890,81 +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
@@ -5058,7 +4319,7 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		state.lifecycleStarted = true;
 	};
 	const emitLifecycleTerminal = (data) => {
-		if (!state.lifecycleStarted || state.lifecycleTerminalEmitted) return;
+		if (!state.lifecycleStarted || state.lifecycleTerminalEmitted || state.permissionChangeRestart) return;
 		emitCodexAppServerEvent(params, {
 			stream: "lifecycle",
 			data: {
@@ -5159,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,
@@ -5170,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();
 			}
@@ -5269,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);
@@ -5280,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", {
@@ -5306,7 +4529,6 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-prompt.ts
-const CODEX_META_KEY = "__openclaw";
 function isRestrictivePromptToolsAllow(toolsAllow) {
 	return toolsAllow !== void 0 && !toolsAllow.some((name) => name.trim() === "*");
 }
@@ -5405,7 +4627,7 @@ async function prepareCodexAttemptPrompt(context) {
 				if (isRestrictivePromptToolsAllow(toolsAllow)) throw new Error("Codex app-server cannot enforce before_prompt_build toolsAllow; use the embedded or Copilot runtime for turn-scoped tool policy.");
 				return promptState.developerInstructions;
 			} },
-			messages: structuredClone(historyState.messages),
+			messages: historyState.messages,
 			ctx: hookContext,
 			bootstrapContextRunKind: params.bootstrapContextRunKind,
 			toolAuthority: {
@@ -5483,11 +4705,9 @@ async function prepareCodexAttemptPrompt(context) {
 		const cutoff = Date.parse(binding.historyCoveredThrough ?? "");
 		return historyState.messages.filter((message) => {
 			if (message.role !== "user" && message.role !== "assistant") return false;
-			const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
-			const mirrorIdentity = meta && typeof meta === "object" && !Array.isArray(meta) ? meta.mirrorIdentity : void 0;
-			const mirrorOrigin = meta && typeof meta === "object" && !Array.isArray(meta) ? meta.mirrorOrigin : void 0;
+			const mirrorIdentity = readMirrorIdentity(message);
 			const timestamp = typeof message.timestamp === "number" ? message.timestamp : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
-			return !("idempotencyKey" in message && typeof message.idempotencyKey === "string" && message.idempotencyKey.startsWith("codex-app-server:")) && mirrorOrigin !== "codex-app-server" && !(typeof mirrorIdentity === "string" && mirrorIdentity.startsWith("codex-app-server:")) && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
+			return !("idempotencyKey" in message && typeof message.idempotencyKey === "string" && message.idempotencyKey.startsWith("codex-app-server:")) && !hasCodexMirrorOrigin(message) && !mirrorIdentity?.startsWith("codex-app-server:") && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
 		});
 	};
 	const applyResumeStaleBindingContinuityProjection = (binding) => {
@@ -5519,7 +4739,8 @@ async function prepareCodexAttemptPrompt(context) {
 		return projected;
 	};
 	const applyNoContextEngineContinuityProjection = (action, binding) => {
-		if (activeContextEngine || !historyState.messages.some((message) => message.role === "user")) return false;
+		const hasContinuity = historyState.messages.some((message) => message.role === "user" || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
+		if (activeContextEngine || !hasContinuity) return false;
 		if (action === "resumed" && promptState.precomputedStaleBindingContinuityProjectionApplied) return true;
 		if (action === "started" && promptState.staleBindingContinuityForcedFreshStart) return true;
 		if (action === "started" && promptState.inactiveThreadBootstrapBindingForcedFreshStart) return false;
@@ -5612,7 +4833,7 @@ function prepareCodexAttemptResources(prompt) {
 	const { context, turnState, buildRenderedCodexDeveloperInstructions } = prompt;
 	const { runtime, attemptTools } = context;
 	const { connection, hookChannelId } = runtime;
-	const { appServer, params, effectiveCwd, sessionAgentId, sandboxSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
+	const { appServer, params, effectiveCwd, sessionAgentId, contextSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
 	const { toolBridge } = attemptTools;
 	const trajectoryRecorder = createCodexTrajectoryRecorder({
 		attempt: params,
@@ -5652,7 +4873,7 @@ function prepareCodexAttemptResources(prompt) {
 		emitCodexNativePreToolUseFailureDiagnostic({
 			agentId: sessionAgentId,
 			sessionId: params.sessionId,
-			sessionKey: sandboxSessionKey,
+			sessionKey: contextSessionKey,
 			runId: params.runId,
 			signal: runAbortController.signal,
 			failure,
@@ -5774,8 +4995,10 @@ function prepareCodexAttemptResources(prompt) {
 			events: nativeHookRelayEvents,
 			agentId: sessionAgentId,
 			sessionId: params.sessionId,
-			sessionKey: sandboxSessionKey,
+			sessionKey: contextSessionKey,
 			config: params.config,
+			autoApproveMcpTools: shouldAutoApproveCodexAppServerApprovals(appServer),
+			projectedMcpServers: runtime.bundleMcpThreadConfig.configPatch?.mcp_servers,
 			runId: params.runId,
 			channelId: hookChannelId,
 			...requester ? { requester } : {},
@@ -5917,295 +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") {
-	return normalizeAppToolApprovalMode(asOptionalRecord(asOptionalRecord(asOptionalRecord(asOptionalRecord(config.apps)?.[appId])?.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 policyContext = buildPluginAppPolicyContext(apps, Object.fromEntries(Object.entries(config.policyContext.pluginAppIds).map(([key, ids]) => [key, ids.filter((id) => Object.hasOwn(apps, id))]).filter(([, ids]) => ids.length > 0)));
-	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) {
@@ -6218,7 +5152,7 @@ function resolveCodexAttemptBundleManifestRegistry(preparedModelRuntime) {
 	return metadataSnapshot?.pluginIds === void 0 ? metadataSnapshot?.manifestRegistry : void 0;
 }
 async function prepareCodexAttemptRuntime(connection) {
-	const { params, pluginConfig, usesSupervisionConnection, appServer, startupAuthProfileId, startupPreparedAuth, startupClientAuthProfileId, agentDir, preDynamicStartupStages, effectiveWorkspace, contextSessionKey, sandboxSessionKey, sessionAgentId, sandbox, attemptClientFactory, runAbortController, activeContextEngine, mutable } = connection;
+	const { params, pluginConfig, usesSupervisionConnection, appServer, startupAuthProfileId, startupPreparedAuth, startupClientAuthProfileId, agentDir, preDynamicStartupStages, effectiveWorkspace, contextSessionKey, sandboxSessionKey, sessionAgentId, policyAgentId, sandbox, attemptClientFactory, runAbortController, activeContextEngine, mutable } = connection;
 	const preparedAuthBinding = !usesSupervisionConnection && appServer.start.homeScope !== "user" && startupAuthProfileId ? await prepareCodexAppServerAuthBinding({
 		authProfileId: startupAuthProfileId,
 		authProfileStore: params.authProfileStore,
@@ -6291,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,
@@ -6299,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({
@@ -6322,10 +5257,11 @@ async function prepareCodexAttemptRuntime(connection) {
 	preDynamicStartupStages.mark("bundle-mcp");
 	const sandboxExecServerEnabled = isCodexSandboxExecServerEnabled(pluginConfig, sandbox);
 	const nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
-		agentId: sessionAgentId,
+		agentId: policyAgentId,
 		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,
@@ -6375,7 +5311,7 @@ async function prepareCodexAttemptRuntime(connection) {
 		bundleMcpThreadConfig,
 		bundleManifestRegistry,
 		authenticatedScheduledMode,
-		ownsScheduledConfiguredMcpSurface,
+		configuredMcpSurface,
 		canResolveScheduledConfiguredMcpCreatorAuthority: mayResolveScheduledConfiguredMcpCreatorAuthority,
 		codexMcpToolOverrides,
 		sandboxExecServerEnabled,
@@ -6469,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
@@ -6485,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
@@ -6527,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
@@ -6538,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,
@@ -6549,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)
 					});
@@ -6560,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,
@@ -6596,6 +5516,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				data: {
 					phase: "start",
 					name: call.tool,
+					itemId: call.callId,
 					toolCallId: call.callId,
 					...toolMeta ? { meta: toolMeta } : {},
 					...toolArgs ? { args: toolArgs } : {},
@@ -6618,7 +5539,8 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				})) terminalDiagnosticObserved = true;
 			}, { include: DYNAMIC_TOOL_TERMINAL_DIAGNOSTIC_TYPES });
 			try {
-				const { execution } = openClawDynamicToolExecutions.claim(call, () => {
+				const { execution } = openClawDynamicToolExecutions.claim(call, async () => {
+					await projector?.transcriptCheckpoint.flush();
 					emitDynamicToolStartedDiagnostic({
 						call,
 						agentId: sessionAgentId,
@@ -6626,7 +5548,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						sessionId: params.sessionId,
 						sessionKey: params.sessionKey
 					});
-					return handleDynamicToolCallWithTimeout({
+					const response = await handleDynamicToolCallWithTimeout({
 						call,
 						toolBridge,
 						signal,
@@ -6648,6 +5570,9 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 							});
 						}
 					});
+					recordCodexDynamicToolResult(projector, call, response, toCodexDynamicToolProtocolResponse(response));
+					await projector?.transcriptCheckpoint.flush();
+					return response;
 				});
 				const response = await execution;
 				const protocolResponse = toCodexDynamicToolProtocolResponse(response);
@@ -6671,7 +5596,6 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					success: protocolResponse.success,
 					contentItems: protocolResponse.contentItems
 				});
-				recordCodexDynamicToolResult(projector, call, response, protocolResponse);
 				if (protocolResponse.success && call.tool === "progress_card") {
 					const progressCardInput = response.executedArguments ?? call.arguments;
 					await projector?.recordDynamicProgressCardUpdate(progressCardInput);
@@ -6684,6 +5608,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						data: {
 							phase: "result",
 							name: call.tool,
+							itemId: call.callId,
 							toolCallId: call.callId,
 							...toolMeta ? { meta: toolMeta } : {},
 							...commandBearing ? { commandBearing: true } : {},
@@ -6740,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 };
@@ -6759,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-BvyT1uyd.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;
@@ -7006,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;
@@ -7205,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,
@@ -7286,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);
 							}
@@ -7333,15 +6247,12 @@ async function startCodexAttemptThread(params) {
 			releaseSharedClientLease
 		};
 	} catch (error) {
-		if (params.signal.aborted || shouldClearSharedClientAfterStartupAbandon(error)) {
+		if (params.signal.aborted || isCodexAppServerStartupError(error)) {
 			releaseSharedClientLease?.();
 			releaseSharedClientLease = void 0;
 			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
 			startupClientForAbandonedRequestCleanup = void 0;
-		} else if (!isCodexAppServerStartSelectionChangedError(error) && (shouldClearSharedClientAfterStartupRace(error) || shouldClearSharedClientAfterStartupFailure({
-			error,
-			spawnedBy: params.spawnedBy
-		}))) {
+		} else if (!isCodexAppServerStartSelectionChangedError(error) && (shouldClearSharedClientAfterStartupRace(error) || shouldClearSharedClientAfterStartupFailure(error, params.spawnedBy))) {
 			releaseSharedClientLease?.();
 			releaseSharedClientLease = void 0;
 			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
@@ -7352,14 +6263,11 @@ async function startCodexAttemptThread(params) {
 		params.signal.removeEventListener("abort", abandonStartupAcquire);
 	}
 }
-function shouldClearSharedClientAfterStartupAbandon(error) {
-	return isCodexAppServerStartupError(error);
-}
 function shouldClearSharedClientAfterStartupRace(error) {
-	return shouldClearSharedClientAfterStartupAbandon(error) || isCodexAppServerRequestTimeoutError(error);
+	return isCodexAppServerStartupError(error) || isCodexAppServerRequestTimeoutError(error);
 }
-function shouldClearSharedClientAfterStartupFailure(params) {
-	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
@@ -7369,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;
@@ -7409,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,
@@ -7445,11 +6354,12 @@ async function startCodexAttemptRuntime(resources) {
 		if (usesSupervisionConnection && (state.thread.connectionScope !== "supervision" || state.thread.supervisionSourceThreadId !== connection.mutable.startupBinding?.supervisionSourceThreadId)) throw new Error("Codex supervised thread lost its private connection ownership");
 		if (state.thread.lifecycle.action === "started" || state.thread.lifecycle.action === "forked") {
 			const activePolicy = resolveReviewerPolicyContext(state.thread);
+			const activeConfig = resolveRuntimeOptionsForCurrentBinding({
+				modelProvider: activePolicy.modelProvider,
+				model: activePolicy.model
+			});
 			const activeAppServer = resolveCodexAppServerForModelProvider({
-				appServer: resolveRuntimeOptionsForCurrentBinding({
-					modelProvider: activePolicy.modelProvider,
-					model: activePolicy.model
-				}),
+				appServer: activeConfig,
 				provider: activePolicy.modelProvider,
 				model: activePolicy.model,
 				config: params.config,
@@ -7490,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
 		});
@@ -7504,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
@@ -7513,8 +6423,8 @@ 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 { params, preDynamicStartupStages, mutable, startupAuthProfileId, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, sandbox, sessionPermissionPolicy, runAbortController, sessionAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
+	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)}`, {
 		runId: params.runId,
@@ -7557,20 +6467,29 @@ async function prepareCodexAttemptTools(runtime) {
 		...onCodexToolOutcome ? { onToolOutcome: onCodexToolOutcome } : {}
 	};
 	const computerContextEpoch = { value: 0 };
+	const runCleanups = [];
 	const cronCreatorToolAllowlist = [];
 	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;
@@ -7581,6 +6500,7 @@ async function prepareCodexAttemptTools(runtime) {
 	let resolveCreatorAuthorityImpl;
 	const runtimeYieldCompletionClaim = {};
 	const commonToolParams = {
+		nodeExecAvailability: {},
 		params: dynamicToolParams,
 		resolvedWorkspace,
 		effectiveWorkspace,
@@ -7592,6 +6512,7 @@ async function prepareCodexAttemptTools(runtime) {
 		nativeProviderWebSearchSupport,
 		runAbortController,
 		sessionAgentId,
+		policyAgentId,
 		pluginConfig,
 		profilerEnabled,
 		...params.cronCreatorAuthorityUnavailableReason === "queued-local-operator" && bundleMcpThreadConfig.staticServerNames.length > 0 ? { cronCreatorAuthorityUnavailableReason: "queued-local-operator-configured-mcp" } : {},
@@ -7616,8 +6537,35 @@ 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),
 		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
 		cronCreatorToolAllowlistCaptureRef,
 		onPersistentWebSearchPolicyResolved: (allowed) => {
@@ -7627,7 +6575,7 @@ async function prepareCodexAttemptTools(runtime) {
 			toolState.webSearchAllowed = allowed;
 		}
 	});
-	const registeredTools = await buildDynamicTools({
+	const registeredTools = nativeSpecs ? [] : await buildDynamicTools({
 		...commonToolParams,
 		forceHeartbeatTool: true,
 		ignoreDisableMessageTool: true,
@@ -7639,7 +6587,7 @@ async function prepareCodexAttemptTools(runtime) {
 		runSessionKey: params.sessionKey && params.sessionKey !== sandboxSessionKey ? params.sessionKey : void 0,
 		sessionId: params.sessionId,
 		runId: params.runId,
-		agentId: sessionAgentId,
+		agentId: policyAgentId,
 		agentDir: agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId),
 		agentAccountId: params.agentAccountId,
 		messageProvider: params.messageProvider ?? params.messageChannel,
@@ -7685,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,
@@ -7696,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;
@@ -7712,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 = {
@@ -7729,7 +6701,7 @@ async function prepareCodexAttemptTools(runtime) {
 			remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
 			remoteWorkspaceRequestTimeoutMs: connection.appServer.requestTimeoutMs,
 			sessionId: params.sessionId,
-			sessionKey: sandboxSessionKey,
+			sessionKey: contextSessionKey,
 			runId: params.runId,
 			channelId: hookChannelId,
 			currentChannelProvider: resolveCodexMessageToolProvider(params),
@@ -7753,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 }),
@@ -7771,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.");
@@ -7789,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,
@@ -7799,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
@@ -7830,14 +6805,15 @@ 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,
 			dynamicToolParams,
 			compactionPlanState,
 			computerContextEpoch,
+			runCleanups,
 			toolBridge,
 			toolState,
 			toolOutcomeOrdinals,
@@ -7848,7 +6824,7 @@ async function prepareCodexAttemptTools(runtime) {
 		};
 	} catch (error) {
 		await scopedMcpTools?.dispose();
-		await scheduledConfiguredMcp?.dispose();
+		await configuredMcp?.dispose();
 		throw error;
 	}
 }
@@ -7888,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({
@@ -7951,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;
@@ -8135,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
 			});
@@ -8156,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,
@@ -8178,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
@@ -8255,268 +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];
-		}
-	};
-	const clearCompletionIdleTimer = () => clearTimer("completion");
-	const clearAllTimers = () => {
-		for (const kind of Object.keys(timers)) clearTimer(kind);
-	};
-	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());
-	}
-	function scheduleTerminalIdleWatch() {
-		scheduleWatch("terminal", fireTerminalIdleTimeout, completionLastActivityAt, turnTerminalIdleTimeoutMs, terminalIdleWatchArmed && 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
+//#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
 		});
-	}
-	function fireTerminalIdleTimeout() {
-		if (params.isCompleted() || params.isTerminalTurnNotificationQueued() || params.signal.aborted || !terminalIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0) return;
-		const idleMs = Math.max(0, Date.now() - completionLastActivityAt);
-		if (idleMs < turnTerminalIdleTimeoutMs) {
-			scheduleTerminalIdleWatch();
-			return;
-		}
-		reportTimeout({
-			kind: "terminal",
-			idleMs,
-			timeoutMs: turnTerminalIdleTimeoutMs,
-			lastActivityReason: completionLastActivityReason,
-			details: completionLastActivityDetails
+		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 dispose = () => {
+		deadline = { kind: "closed" };
+		clearTimeout(timer);
+		params.signal.removeEventListener("abort", dispose);
+	};
+	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);
-		},
-		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
@@ -8524,24 +7287,18 @@ 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,
 		completed: false,
+		abortCleanup: Promise.resolve(),
+		permissionChangeRestart: void 0,
 		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,
@@ -8550,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 = {};
@@ -8577,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) => {
@@ -8599,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
@@ -8694,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 };