@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{run-attempt-CvsAAGa0.js → .setup/run-attempt-BHu11r7h.mjs}

@@ -1,72 +1,78 @@
-import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-oL4Na1ZG.js";
-import { l as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-Bcvslnhf.js";
-import { n as defineCodexBuildState } from "./build-state-BCmg9-5p.js";
-import { b as readCodexRequirementsToml, c as hasCodexMcpToolApprovalOverrides, d as withMcpElicitationsApprovalPolicy, i as resolveCodexAppServerHomeScope, m as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig, u as shouldAutoApproveCodexAppServerApprovals } from "./config-options-CXMq1T-C.js";
-import { S as resolveCodexPluginsPolicy, a as flattenCodexDynamicToolFunctions, b as isCodexSandboxExecServerEnabled, o as isJsonObject, s as resolveCodexAppServerHomeDir, v as isCodexPairedNodeRemoteExecPlacementSandbox, x as readCodexPluginConfig, y as isCodexRemoteExecPlacementSandbox } from "./protocol-5bh1G-H7.js";
-import { A as isMatchingDynamicToolTerminalDiagnostic, D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, F as toCodexDynamicToolProgressResponse, I as toCodexDynamicToolProtocolResponse, L as resolveCodexToolAbortTerminalReason, M as resolveTerminalDynamicToolBatchAction, N as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, O as hasPendingDynamicToolTerminalDiagnostic, P as shouldReleaseTurnAfterTerminalDynamicTool, S as readCodexDynamicToolCallParams, T as readCodexTurnCompletedNotification, a as isCodexAppServerBrokenPipeError, c as isCodexAppServerIndeterminateTransportError, d as isCodexAppServerRequestTimeoutError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, l as isCodexAppServerOverloadError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError, w as readCodexTurn, x as assertCodexTurnStartResponse } from "./client-B57KWPQx.js";
-import { c as resolveCodexAppServerPreparedApiKeyCacheKey, m as retireSharedCodexAppServerClientIfCurrent, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-7orQae_j.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CBMmWBr9.js";
-import { o as formatCodexDisplayText } from "./command-formatters-lxlkNZgU.js";
-import { t as CodexAppServerRpcError } from "./rpc-error-ttN_QjEm.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-8vx68WLH.js";
-import { D as splitPlanText, E as readNullableString, S as readItemString, T as readNonNegativeInteger, d as matchesCodexSnapshotTurn, f as shouldClearTerminalPresentationForNativeItem, g as extractRawAssistantText, v as readCodexErrorNotificationMessage, x as readItem, y as readCodexProviderRefusal } from "./event-projector-items-5VhsECCO.js";
-import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey, s as defaultCodexAppInventoryCache } from "./plugin-app-cache-key-d0eKxy7b.js";
-import { t as withAbortableTimeout } from "./timeout-BVw8aaM1.js";
-import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-oIORaQ5T.js";
-import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-DibE0krH.js";
-import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-CWlKVccJ.js";
-import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-D3udKbIE.js";
-import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CwzO4_RG.js";
-import { A as CodexAppServerStartupError, F as resolveCodexStartupTimeoutMs, G as protectCodexAppServerLiveThread, I as withCodexStartupTimeout, M as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, N as isCodexAppServerStartupError, O as getCodexInferenceThread, Q as rememberCodexRateLimitsRead, W as prepareCodexWorkspaceReferences, X as readCodexRateLimitsRevision, Z as readRecentCodexRateLimits, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, et as resolveCodexAppServerAuthAccountCacheKey, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, j as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, l as getSharedCodexAppServerClient, s as createIsolatedCodexAppServerClient, tt as resolveCodexAppServerPreparedAuthHandoff, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent, z as ensureCodexAppServerClientRuntime } from "./shared-client-CscigXXL.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, l as retireUnsafeCodexTurnClientBestEffort, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, u as terminateCodexBackgroundTerminals } from "./attempt-client-cleanup-DKHzbwt5.js";
-import { a as isRawFunctionToolOutputCompletionNotification, c as readNotificationItemId, i as isPendingOpenClawDynamicToolCompletionNotification, l as readRawResponseToolCallId, o as isTerminalTurnStatus, r as isCodexTurnAbortMarkerNotification, s as readCodexNotificationItem, t as codexExecutionToolName, u as updateActiveTurnItemIds } from "./attempt-notifications-C9XufG6l.js";
-import { t as CodexUsageProjection } from "./event-projector-usage-BfXmpOec.js";
-import { $ as codexDynamicToolsFingerprint, A as readCodexMcpToolConnectorId, B as createCodexNativeHookRelay, C as resolveCodexWebSearchPlan, Ct as buildCodexPluginThreadConfigInputFingerprint, Et as mergeCodexThreadConfigs, F as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, H as resolveCodexNativeHookRelayEvents, J as loadCodexNativeToolCatalog, L as buildCodexNativeHookRelayConfig, N as isCodexAppServerProfilerEnabled, O as resolveCodexAppServerThreadModelSelection, Ot as shouldBuildCodexPluginThreadConfig, R as buildCodexNativeHookRelayDisabledConfig, St as buildCodexPluginThreadConfig, U as resolveCodexNativeHookRelayTtlMs, V as emitCodexNativePreToolUseFailureDiagnostic, W as scheduleCodexNativeHookRelayUnregister, _t as neutralizeCodexExplicitMentionSigils, a as buildCodexUserInput, bt as resolveCodexContextEngineProjectionReserveTokens, c as startOrResumeThread, d as buildScheduledCodexAppAuthorityInputFingerprint, dt as buildContextEngineBinding, et as codexLegacyDynamicToolsFingerprint, f as buildScheduledCodexAppServerConnectionIdentity, g as resolveScheduledCodexAppCreatorCaptureDecision, gt as isCodexDurableCustomMessage, h as readCurrentCodexScheduledAppPolicy$1, ht as fitCodexProjectedContextForTurnStart, i as buildTurnStartParams, j as readCodexMcpToolUiVisibility, l as assertScheduledCodexAppAuthorityRuntime, m as intersectCodexPluginThreadConfigWithScheduledAuthority, mt as buildCodexContinuityCalibration, p as captureScheduledCodexAppAuthority, pt as CodexContextAttachmentError, q as hasCodexNativeToolCatalog, r as buildTurnCollaborationMode, rt as filterCodexDynamicTools, st as isSystemAgentOnlyCodexDynamicToolAllowlist, t as buildCodexParentLocalInstructions, u as buildLegacyScheduledCodexAppRecoveryPrompt, ut as resolveCodexDynamicToolsLoadingForRuntime, vt as projectContextEngineAssemblyForCodex, w as buildDeveloperInstructions, wt as buildCodexPluginThreadConfigTimeoutFallback, xt as resolveCodexContinuityProjectionMaxChars, yt as resolveCodexContextEngineProjectionMaxChars } from "./thread-lifecycle-DXl1-I6b.js";
-import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding, s as scopeCodexRunBindingStore } from "./session-binding-CI8UuilT.js";
-import { n as CodexThreadPolicyHandoffError } from "./thread-policy-BuEQfE0g.js";
-import { r as retainCodexAppServerBindingSubscription } from "./thread-ownership-BsDRTsyp.js";
-import { i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-C5CKgNy6.js";
-import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.js";
-import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-context-Dr_mzvk4.js";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BmBM4qBV.js";
-import { _ as sanitizeCodexToolResponse, g as sanitizeCodexToolArguments, h as resolveCodexToolProgressDetailMode, m as isCodexCommandBearingToolCall, p as inferCodexDynamicToolMeta } from "./native-subagent-task-ids-BzTdT0Uw.js";
-import { n as createCodexNativeSubagentHistoryOwner } from "./native-subagent-history-owner-Pcp7JuVF.js";
-import { C as shouldRequireCodexSandboxExecServerEnvironment, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeToolLifecycleProjector, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as readBoundedCodexRemoteWorkspaceFile, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-CmN5RAip.js";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-BvCUL69A.js";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-Bz3FT8W5.js";
-import { a as CodexToolProgressProjection, i as CodexToolTranscriptProjection, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-fQ7eIXEf.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BBmXA8Eg.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-D44yeDII.js";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-Du6gdUDd.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-ClPJpRio.js";
-import { asOptionalRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-BoRei8Z4.mjs";
+import { i as matchesCodexNativeSubagentSubmissionBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, x as createCodexNativeSubagentHistoryOwner } from "./session-binding-record-BGoz8wOK.mjs";
+import { n as defineCodexBuildState } from "./build-state-C7EnDVgr.mjs";
+import { d as resolveCodexAppServerHomeDir, l as shouldAutoApproveCodexAppServerApprovals, n as hasCodexMcpToolApprovalOverrides, u as withMcpElicitationsApprovalPolicy, y as readCodexRequirementsToml } from "./config-security-BEReZ6go.mjs";
+import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-CcB9iPoq.mjs";
+import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
+import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-BvaRs51b.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-B2mpaI9D.mjs";
+import { h as retireSharedCodexAppServerClientIfCurrent } from "./session-catalog-events-Bj6j94E_.mjs";
+import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-Bmqvr9tO.mjs";
+import { n as waitForPromiseOrAbort, o as CodexAppServerRpcError, r as withAbortableTimeout } from "./timeout-C910MdAB.mjs";
+import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.mjs";
+import { C as readItemString, D as readNullableString, E as readNonNegativeInteger, O as splitPlanText, S as readItem, _ as extractRawAssistantText, b as readCodexProviderRefusal, d as matchesCodexSnapshotTurn, f as shouldClearTerminalPresentationForNativeItem, y as readCodexErrorNotificationMessage } from "./event-projector-items-C6L_5ZiT.mjs";
+import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
+import { a as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-B2CsSdnV.mjs";
+import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-ThoatDcb.mjs";
+import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-BoTP_mrL.mjs";
+import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-CzM-94NC.mjs";
+import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BrqhSCf9.mjs";
+import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-WqZtZfXN.mjs";
+import { A as getCodexInferenceThread, B as prepareCodexWorkspaceReferences, K as readCodexRateLimitsRevision, P as ensureCodexAppServerClientRuntime, V as protectCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, Z as resolveCodexAppServerPreparedAuthHandoff, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as resolveCodexStartupTimeoutMs, c as getLeasedSharedCodexAppServerClient, et as CodexAppServerStartupError, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, l as getSharedCodexAppServerClient, nt as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, ot as withCodexStartupTimeout, q as readRecentCodexRateLimits, s as createIsolatedCodexAppServerClient, tt as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent, w as CodexThreadClientReplacementError } from "./shared-client-DA4VR4Eb.mjs";
+import { A as isMatchingDynamicToolTerminalDiagnostic, B as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS, C as readCodexDynamicToolCallParams, D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, F as toCodexDynamicToolProgressResponse, I as toCodexDynamicToolProtocolResponse, L as resolveCodexToolAbortTerminalReason, M as resolveTerminalDynamicToolBatchAction, N as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, O as hasPendingDynamicToolTerminalDiagnostic, P as shouldReleaseTurnAfterTerminalDynamicTool, S as assertCodexTurnStartResponse, T as readCodexTurnCompletedNotification, c as isCodexAppServerIndeterminateTransportError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, m as CodexServerRequestResolvedError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-Cs08OXVQ.mjs";
+import { _ as CodexProjectionDiagnostics, d as shouldRetireCodexStartupClient, f as terminateCodexBackgroundTerminals, h as getCodexAppServerTurnRouter, m as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as retireUnsafeCodexTurnClientBestEffort, v as isCodexNotificationForTurn, y as readCodexNotificationThreadId } from "./attempt-client-cleanup-CEv1cKwF.mjs";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-DhLWa_7K.mjs";
+import { a as isPendingOpenClawDynamicToolCompletionNotification, c as readCodexNotificationItem, d as updateActiveTurnItemIds, i as isCodexTurnAbortMarkerNotification, l as readNotificationItemId, o as isRawFunctionToolOutputCompletionNotification, r as codexExecutionToolName, s as isTerminalTurnStatus, t as CodexUsageProjection, u as readRawResponseToolCallId } from "./event-projector-usage-CnBS8Wa3.mjs";
+import { A as emitCodexNativePreToolUseFailureDiagnostic, C as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, Ct as shouldBuildCodexPluginThreadConfig, D as buildCodexNativeHookRelayDisabledConfig, E as buildCodexNativeHookRelayConfig, K as codexDynamicToolsFingerprint, M as resolveCodexNativeHookRelayTtlMs, N as scheduleCodexNativeHookRelayUnregister, R as hasCodexNativeToolCatalog, T as assertCodexNativeHookRelayAllowed, U as areCodexDynamicToolFingerprintsCompatible, X as fingerprintJsonObject, at as filterCodexDynamicTools, ft as resolveCodexDynamicToolsLoadingForRuntime, gt as buildCodexPluginThreadConfigTimeoutFallback, ht as buildCodexPluginThreadConfigInputFingerprint, j as resolveCodexNativeHookRelayEvents, k as createCodexNativeHookRelay, lt as isSystemAgentOnlyCodexDynamicToolAllowlist, m as buildDeveloperInstructions, mt as buildCodexPluginThreadConfig, p as resolveCodexWebSearchPlan, q as codexLegacyDynamicToolsFingerprint, v as resolveCodexAppServerThreadModelSelection, w as CodexManagedHooksOnlyError, xt as mergeCodexThreadConfigs, z as loadCodexNativeToolCatalog } from "./thread-requests-BLvGkP2R.mjs";
+import { A as resolveCodexContinuityProjectionMaxChars, C as buildCodexContinuityCalibration, D as projectContextEngineAssemblyForCodex, E as neutralizeCodexExplicitMentionSigils, O as resolveCodexContextEngineProjectionMaxChars, S as CodexContextAttachmentError, T as isCodexDurableCustomMessage, _ as readCodexMcpToolUiVisibility, a as buildTurnStartParams, b as isContextEngineBindingCompatible, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, g as readCodexMcpToolConnectorId, h as resolveScheduledCodexAppCreatorCaptureDecision, i as buildTurnCollaborationMode, k as resolveCodexContextEngineProjectionReserveTokens, l as buildLegacyScheduledCodexAppRecoveryPrompt, m as readCurrentCodexScheduledAppPolicy$1, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, p as intersectCodexPluginThreadConfigWithScheduledAuthority, s as startOrResumeThread, t as buildCodexHistoryProvenancePrefix, u as buildScheduledCodexAppAuthorityInputFingerprint, v as isCodexAppServerProfilerEnabled, w as fitCodexProjectedContextForTurnStart, x as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, y as buildContextEngineBinding } from "./thread-lifecycle-B3mfz1TG.mjs";
+import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding } from "./session-binding-Cm0apEbd.mjs";
+import { n as CodexThreadPolicyHandoffError } from "./thread-policy-DGuQsuFC.mjs";
+import { r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DcTtAcXj.mjs";
+import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BtHDBp1G.mjs";
+import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-DUMbefVY.mjs";
+import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.mjs";
+import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
+import { a as shouldKeepCodexSharedAbortOpen, i as runCodexAgentEndHook, n as ensureCodexWorkspaceDirOnce, o as withCodexAppServerFastModeServiceTier, r as estimateCodexAppServerProjectedTurnTokens, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-B7JbY4-F.mjs";
+import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-context-D96l9-ew.mjs";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BsruvNrH.mjs";
+import { C as sanitizeCodexToolArguments, S as resolveCodexToolProgressDetailMode, b as inferCodexDynamicToolMeta, w as sanitizeCodexToolResponse, x as isCodexCommandBearingToolCall } from "./native-subagent-task-ids-wb8CKZGN.mjs";
+import { C as shouldEnableCodexAppServerNativeToolSurface, E as mapCodexAppServerRemoteWorkspacePath, S as resolveCodexSandboxEnvironmentSelection, T as shouldWarnCodexDynamicToolBuildStageSummary, _ as formatCodexDynamicToolBuildStageSummary, a as emitDynamicToolStartedDiagnostic, b as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as ensureCodexSandboxExecServerEnvironment, d as hasCodexNativeBackgroundProcesses, f as readBoundedCodexRemoteWorkspaceFile, g as disableCodexPluginThreadConfig, h as createCodexDynamicToolBuildStageTracker, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as buildDynamicTools, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as CodexNativeToolLifecycleProjector, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as CodexNativeProcessAuthority, v as resolveCodexAppServerExecutionCwd, w as shouldRequireCodexSandboxExecServerEnvironment, x as resolveCodexMessageToolProvider, y as resolveCodexAppServerHookChannelId } from "./dynamic-tools-BDXl-8Cw.mjs";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-BfE88FZ5.mjs";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-C0MZzCuP.mjs";
+import { a as CodexToolProgressProjection, i as CodexToolTranscriptProjection, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-D3filLY2.mjs";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BI1QK_98.mjs";
+import { a as getCodexContextFileDisplayBasename, c as normalizeCodexContextFilePath, d as shouldInjectCodexOpenClawPromptContext, i as getCodexContextFileBasename, l as normalizeCodexDynamicToolName, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as getCodexWorkspaceMemoryToolNames, r as buildCodexWorkspaceBootstrapContext, s as isNonEmptyString$1 } from "./attempt-workspace-context-DUVEn_CS.mjs";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-fmwouT5I.mjs";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-Ctmo83k_.mjs";
+import { asOptionalRecord, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { resolveAgentConfig, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { isPathStrictlyInside, readFileWindowFully, root } from "openclaw/plugin-sdk/file-access-runtime";
 import { addAbortListener } from "node:events";
 import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
-import { Buffer as Buffer$1 } from "node:buffer";
+import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
-import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
-import { isDeepStrictEqual } from "node:util";
-import { getSessionEntry, parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
-import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
+import { acknowledgeInternalToolResult } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
 import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { appendSessionYieldContext, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { prepareAgentWorkspaceAttachments } from "openclaw/plugin-sdk/agent-workspace-runtime";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
-import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+import { normalizeMediaReferenceForComparison, saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
-import { acknowledgeInternalToolResult } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 //#region extensions/codex/src/app-server/attempt-preparation-timing.ts
 /** Records startup before the native turn owns inference and tool execution. */
@@ -126,6 +132,7 @@ var CodexSteeringAcceptedUnconfirmedError = class extends Error {
 * app-server `turn/steer` requests.
 */
 function createCodexSteeringQueue(params) {
+	const acceptedMessages = [];
 	let batchedMessages = [];
 	const dispatchedBatches = /* @__PURE__ */ new Map();
 	const pendingMessages = /* @__PURE__ */ new Set();
@@ -151,9 +158,13 @@ function createCodexSteeringQueue(params) {
 		item.acceptance = accepted ? "accepted" : "rejected";
 		item.onQueueAccepted?.(accepted);
 	};
+	const acceptItem = (item) => {
+		if (item.acceptance === "open") acceptedMessages.push(item.prepared.message);
+		reportItemAcceptance(item, true);
+	};
 	const resolveItem = (item) => {
 		if (item.settled) return;
-		reportItemAcceptance(item, true);
+		acceptItem(item);
 		item.settled = true;
 		pendingMessages.delete(item);
 		item.resolve();
@@ -171,7 +182,7 @@ function createCodexSteeringQueue(params) {
 		params.signal.removeEventListener("abort", abortQueue);
 		clearBatchTimer();
 		batchedMessages = [];
-		for (const batch of dispatchedBatches.values()) for (const item of batch.items) reportItemAcceptance(item, true);
+		for (const batch of dispatchedBatches.values()) for (const item of batch.items) acceptItem(item);
 		dispatchedBatches.clear();
 		for (const item of pendingMessages) rejectItem(item, error);
 	};
@@ -190,13 +201,14 @@ function createCodexSteeringQueue(params) {
 		closeQueue(/* @__PURE__ */ new Error("codex app-server steering queue cancelled"));
 	};
 	const sendBatch = async (items) => {
-		let liveItems = items.filter((item) => !item.settled);
-		if (liveItems.length === 0) return;
+		const pendingItems = items.filter((item) => !item.settled);
+		let liveItems = [];
+		if (pendingItems.length === 0) return;
 		let clientUserMessageId;
 		let skippedRevokedBatch = false;
 		try {
 			assertActive();
-			const prepared = /* @__PURE__ */ new Map();
+			const prepared = [];
 			const isCurrent = (item) => {
 				if (item.settled) return false;
 				try {
@@ -207,17 +219,20 @@ function createCodexSteeringQueue(params) {
 					return false;
 				}
 			};
-			for (const item of liveItems) {
+			for (const item of pendingItems) {
 				if (!isCurrent(item)) continue;
 				try {
-					prepared.set(item, await params.prepareMessage(item.text, item));
+					prepared.push(Object.assign(item, { prepared: await params.prepareMessage(item.text, item, () => {
+						assertActive();
+						item.assertCurrent();
+					}) }));
 				} catch (error) {
 					if (isCurrent(item)) throw error;
 				}
 				assertActive();
 				isCurrent(item);
 			}
-			liveItems = liveItems.filter(isCurrent);
+			liveItems = prepared.filter(isCurrent);
 			if (liveItems.length === 0) return;
 			if (params.beforeSubmit) {
 				await params.beforeSubmit(liveItems);
@@ -230,7 +245,7 @@ function createCodexSteeringQueue(params) {
 			const request = {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
-				input: liveItems.flatMap((item) => prepared.get(item) ?? []),
+				input: liveItems.flatMap((item) => item.prepared.input),
 				clientUserMessageId
 			};
 			await params.client.request("turn/steer", request, {
@@ -239,7 +254,7 @@ function createCodexSteeringQueue(params) {
 				assertCurrent: () => {
 					assertActive();
 					liveItems = liveItems.filter(isCurrent);
-					request.input = liveItems.flatMap((item) => prepared.get(item) ?? []);
+					request.input = liveItems.flatMap((item) => item.prepared.input);
 					dispatchedBatches.set(request.clientUserMessageId, { items: liveItems });
 					if (liveItems.length === 0) {
 						skippedRevokedBatch = true;
@@ -247,15 +262,12 @@ function createCodexSteeringQueue(params) {
 					}
 				}
 			});
-			for (const item of liveItems) reportItemAcceptance(item, true);
+			for (const item of liveItems) acceptItem(item);
 		} catch (error) {
 			if (clientUserMessageId) dispatchedBatches.delete(clientUserMessageId);
 			if (skippedRevokedBatch) return;
-			const acceptedUnconfirmed = clientUserMessageId !== void 0 && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error));
-			for (const item of liveItems) {
-				if (acceptedUnconfirmed) reportItemAcceptance(item, true);
-				rejectItem(item, error);
-			}
+			if (clientUserMessageId !== void 0 && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error))) for (const item of liveItems) acceptItem(item);
+			for (const item of items) rejectItem(item, error);
 			throw error;
 		}
 	};
@@ -328,6 +340,7 @@ function createCodexSteeringQueue(params) {
 			for (const item of batch.items) resolveItem(item);
 			return true;
 		},
+		getAcceptedMessages: () => acceptedMessages.slice(),
 		sealAdmission: sealQueueAdmission,
 		cancel: cancelQueue
 	};
@@ -337,9 +350,6 @@ function normalizeCodexSteerDebounceMs(value) {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : CODEX_STEER_ALL_DEBOUNCE_MS;
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-terminal.ts
-const attemptTerminal = agentHarnessAttemptTerminal;
-//#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
 	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
@@ -353,6 +363,7 @@ var CodexAssistantProjection = class {
 		this.assistantTimestampByItem = /* @__PURE__ */ new Map();
 		this.assistantPhaseByItem = /* @__PURE__ */ new Map();
 		this.assistantDeliveryByItem = /* @__PURE__ */ new Map();
+		this.assistantQuestionsByItem = /* @__PURE__ */ new Map();
 		this.latestTerminalAssistantCandidateSuperseded = false;
 		this.terminalAssistantCandidateEarlierActiveItemIds = /* @__PURE__ */ new Set();
 		this.lastCommentaryProgressEventByItem = /* @__PURE__ */ new Map();
@@ -416,7 +427,7 @@ var CodexAssistantProjection = class {
 		});
 		if (knownFinalAnswer && !replaceable) await this.params.onPartialReply?.(streamPayload);
 	}
-	recordItemStarted(item, itemId) {
+	async recordItemStarted(item, itemId) {
 		this.noteNativeWorkBarrier(item);
 		this.rememberAssistantPhase(item);
 		if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
@@ -425,6 +436,10 @@ var CodexAssistantProjection = class {
 			this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
 			if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		}
+		if (item?.type === "agentMessage" && itemId && item.text && !this.assistantTextByItem.has(itemId)) await this.handleAssistantDelta({
+			itemId,
+			delta: item.text
+		});
 	}
 	recordItemCompleted(item, itemId, activeItemIds) {
 		if (itemId && item?.type === "agentMessage") this.completedAssistantItemIds.add(itemId);
@@ -441,7 +456,7 @@ var CodexAssistantProjection = class {
 		if (item?.type === "agentMessage" && typeof item.text === "string") {
 			this.rememberAssistantItem(item.id);
 			this.assistantTextByItem.set(item.id, item.text);
-			if (item.text && this.isCommentaryAssistantItem(item.id)) {
+			if (this.isCommentaryAssistantItem(item.id)) {
 				this.emitCommentaryProgress({
 					itemId: item.id,
 					text: item.text,
@@ -475,15 +490,11 @@ var CodexAssistantProjection = class {
 			this.pendingRawCommentaryEchoes -= 1;
 			return;
 		}
-		const text = extractRawAssistantText(item);
 		if (isPendingTerminalAssistantEcho) {
-			const typedItemId = pendingTerminalAssistantEchoItemId;
 			this.pendingRawTerminalAssistantEchoItemId = void 0;
-			if (this.assistantTextByItem.get(typedItemId)?.trim() || !text) return;
-			this.rememberAssistantItem(typedItemId);
-			this.assistantTextByItem.set(typedItemId, text);
 			return;
 		}
+		const text = extractRawAssistantText(item);
 		if (text === void 0 || !text && (phase === "commentary" || activeItemIds.size > 0 || readStringField(item, "type") !== "message")) return;
 		const itemId = rawItemId ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
 		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && activeItemIds.size === 0;
@@ -528,14 +539,11 @@ var CodexAssistantProjection = class {
 	}
 	collectAsyncMessages() {
 		return this.assistantItemOrder.flatMap((itemId) => {
-			if (!this.isAsyncAssistantItem(itemId)) return [];
-			const text = this.assistantTextByItem.get(itemId)?.trim();
-			const timestamp = this.assistantTimestampByItem.get(itemId);
-			if (!text || timestamp === void 0) return [];
-			return [{
+			const delivery = this.createAsyncDelivery(itemId);
+			return delivery ? [{
 				itemId,
-				message: createAssistantAsyncMessage(this.params, text, itemId, timestamp)
-			}];
+				message: delivery.message
+			}] : [];
 		});
 	}
 	collectCompletedAssistantMessages(completedItemIds, options) {
@@ -616,6 +624,11 @@ var CodexAssistantProjection = class {
 		if (phase) this.assistantPhaseByItem.set(item.id, phase);
 		const delivery = readItemString(item, "delivery");
 		if (delivery) this.assistantDeliveryByItem.set(item.id, delivery);
+		if (item.questions !== void 0) {
+			const questions = readCodexAsyncQuestions(item.questions);
+			if (questions && delivery === "async") this.assistantQuestionsByItem.set(item.id, questions);
+			else this.assistantQuestionsByItem.delete(item.id);
+		}
 	}
 	isCommentaryAssistantItem(itemId) {
 		return this.assistantPhaseByItem.get(itemId) === "commentary";
@@ -755,7 +768,7 @@ var CodexAssistantProjection = class {
 		if (!text?.trim() || timestamp === void 0) return;
 		return {
 			itemId,
-			message: createAssistantAsyncMessage(this.params, text, itemId, timestamp),
+			message: createAssistantAsyncMessage(this.params, text, itemId, timestamp, this.assistantQuestionsByItem.get(itemId)),
 			text
 		};
 	}
@@ -808,7 +821,7 @@ var CodexGeneratedMediaProjection = class {
 		this.config = config;
 		this.remote = remote;
 		this.itemIds = /* @__PURE__ */ new Set();
-		this.urlsByItemId = /* @__PURE__ */ new Map();
+		this.mediaByItemId = /* @__PURE__ */ new Map();
 		this.gatewayMaterializedItemIds = /* @__PURE__ */ new Set();
 		this.pendingMaterializationsByItemId = /* @__PURE__ */ new Map();
 	}
@@ -818,6 +831,11 @@ var CodexGeneratedMediaProjection = class {
 	async recordNative(item) {
 		if (item?.type !== "imageGeneration") return;
 		this.itemIds.add(item.id);
+		const savedPath = readItemString(item, "savedPath")?.trim();
+		if (savedPath) this.mediaByItemId.set(item.id, {
+			...this.mediaByItemId.get(item.id),
+			savedPath
+		});
 		const result = readItemString(item, "result");
 		if (result) {
 			await this.recordImage({
@@ -828,7 +846,6 @@ var CodexGeneratedMediaProjection = class {
 			});
 			return;
 		}
-		const savedPath = readItemString(item, "savedPath")?.trim();
 		if (savedPath) {
 			if (this.remote?.remoteWorkspaceRoot) {
 				if (!this.remote.readFile) {
@@ -929,22 +946,53 @@ var CodexGeneratedMediaProjection = class {
 			});
 		}
 	}
-	buildToolMediaUrls(params) {
+	projectDelivery(params) {
+		const generatedUrls = /* @__PURE__ */ new Set();
+		const generatedUrlBySource = /* @__PURE__ */ new Map();
+		for (const { mediaUrl, savedPath } of this.mediaByItemId.values()) {
+			if (!mediaUrl) continue;
+			generatedUrls.add(mediaUrl);
+			generatedUrlBySource.set(normalizeMediaReferenceForComparison(mediaUrl), mediaUrl);
+			if (savedPath) generatedUrlBySource.set(normalizeMediaReferenceForComparison(savedPath), mediaUrl);
+		}
+		const sentMediaUrls = new Set(params.messagingToolSentMediaUrls);
+		const generatedUrlsByTarget = /* @__PURE__ */ new Map();
+		for (const delivery of params.confirmedMediaDeliveries ?? []) for (const sourceUrl of delivery.sourceUrls) {
+			const generatedUrl = generatedUrlBySource.get(normalizeMediaReferenceForComparison(sourceUrl));
+			if (!generatedUrl) continue;
+			if (delivery.kind === "sourceReply") generatedUrls.delete(generatedUrl);
+			else {
+				const targetUrls = generatedUrlsByTarget.get(delivery.target) ?? /* @__PURE__ */ new Set();
+				targetUrls.add(generatedUrl);
+				generatedUrlsByTarget.set(delivery.target, targetUrls);
+				sentMediaUrls.add(generatedUrl);
+			}
+		}
 		const mediaUrls = new Set(params.toolMediaUrls?.map((url) => url.trim()).filter(Boolean) ?? []);
-		if ((params.messagingToolSentMediaUrls?.length ?? 0) === 0) for (const mediaUrl of this.urlsByItemId.values()) mediaUrls.add(mediaUrl);
-		return mediaUrls.size > 0 ? [...mediaUrls] : params.toolMediaUrls;
-	}
-	buildHostOwnedMediaUrls(params) {
-		if ((params.messagingToolSentMediaUrls?.length ?? 0) > 0) return;
-		const mediaUrls = [...this.urlsByItemId.values()];
-		return mediaUrls.length > 0 ? mediaUrls : void 0;
+		for (const mediaUrl of generatedUrls) mediaUrls.add(mediaUrl);
+		return {
+			toolMediaUrls: mediaUrls.size > 0 ? [...mediaUrls] : params.toolMediaUrls,
+			hostOwnedToolMediaUrls: generatedUrls.size > 0 ? [...generatedUrls] : void 0,
+			messagingToolSentMediaUrls: [...sentMediaUrls],
+			messagingToolSentTargets: params.messagingToolSentTargets.map((target) => {
+				const aliases = generatedUrlsByTarget.get(target);
+				return aliases ? {
+					...target,
+					mediaUrls: [.../* @__PURE__ */ new Set([...target.mediaUrls ?? [], ...aliases])]
+				} : target;
+			})
+		};
 	}
 	recordUrl(params) {
-		if (this.urlsByItemId.has(params.itemId) && params.replaceExisting !== true) {
+		const existing = this.mediaByItemId.get(params.itemId);
+		if (existing?.mediaUrl && params.replaceExisting !== true) {
 			this.itemIds.add(params.itemId);
 			return;
 		}
-		this.urlsByItemId.set(params.itemId, params.mediaUrl);
+		this.mediaByItemId.set(params.itemId, {
+			...existing,
+			mediaUrl: params.mediaUrl
+		});
 		this.itemIds.add(params.itemId);
 	}
 };
@@ -974,8 +1022,7 @@ var CodexReasoningProjection = class {
 		this.params = params;
 		this.emitAgentEvent = emitAgentEvent;
 		this.onNativePlanUpdate = onNativePlanUpdate;
-		this.reasoningTextByGroup = /* @__PURE__ */ new Map();
-		this.reasoningItemOrder = /* @__PURE__ */ new Map();
+		this.reasoningTextByItem = /* @__PURE__ */ new Map();
 		this.planTextByItem = /* @__PURE__ */ new Map();
 		this.reasoningStarted = false;
 		this.reasoningEnded = false;
@@ -985,16 +1032,14 @@ var CodexReasoningProjection = class {
 		const delta = readStringField(params, "delta") ?? "";
 		if (!delta) return;
 		this.reasoningStarted = true;
-		if (!this.reasoningItemOrder.has(itemId)) this.reasoningItemOrder.set(itemId, this.reasoningItemOrder.size);
+		const item = this.reasoningTextByItem.get(itemId) ?? {
+			summary: /* @__PURE__ */ new Map(),
+			content: /* @__PURE__ */ new Map()
+		};
+		this.reasoningTextByItem.set(itemId, item);
 		const groupIndex = method === "item/reasoning/textDelta" ? readNonNegativeInteger(params, "contentIndex") ?? 0 : readNonNegativeInteger(params, "summaryIndex") ?? 0;
-		const groupKey = `${method}\0${itemId}\0${groupIndex}`;
-		const current = this.reasoningTextByGroup.get(groupKey);
-		this.reasoningTextByGroup.set(groupKey, {
-			itemId,
-			method,
-			index: groupIndex,
-			text: `${current?.text ?? ""}${delta}`
-		});
+		const sections = method === "item/reasoning/textDelta" ? item.content : item.summary;
+		sections.set(groupIndex, `${sections.get(groupIndex) ?? ""}${delta}`);
 		await this.params.onReasoningStream?.({
 			text: this.reasoningText(),
 			isReasoningSnapshot: true
@@ -1034,10 +1079,27 @@ var CodexReasoningProjection = class {
 		});
 		this.emitPlanUpdate({
 			explanation,
+			...params.explanationFormat === "plain" ? { explanationFormat: "plain" } : {},
 			steps: plan
 		}, source);
 	}
-	recordItem(item) {
+	async recordItem(item) {
+		if (item?.type === "reasoning") {
+			const previousText = this.reasoningText();
+			this.reasoningTextByItem.set(item.id, {
+				summary: readReasoningSections(item.summary),
+				content: readReasoningSections(item.content)
+			});
+			const text = this.reasoningText();
+			if (text !== previousText) {
+				this.reasoningStarted = true;
+				await this.params.onReasoningStream?.({
+					text,
+					isReasoningSnapshot: true
+				});
+			}
+			return;
+		}
 		if (item?.type === "plan" && typeof item.text === "string" && item.text) {
 			this.planTextByItem.set(item.id, item.text);
 			this.emitPlanUpdate({
@@ -1055,7 +1117,7 @@ var CodexReasoningProjection = class {
 		await this.params.onReasoningEnd?.();
 	}
 	reasoningText() {
-		return collectReasoningTextValues(this.reasoningTextByGroup, this.reasoningItemOrder).join("\n\n");
+		return [...this.reasoningTextByItem.values()].flatMap(({ summary, content }) => [summary, content]).flatMap((sections) => [...sections].toSorted(([left], [right]) => left - right)).map(([, text]) => text).filter((text) => text.trim().length > 0).join("\n\n");
 	}
 	planText() {
 		return this.turnPlanText ?? [...this.planTextByItem.values()].filter((text) => text.trim().length > 0).join("\n\n");
@@ -1069,6 +1131,7 @@ var CodexReasoningProjection = class {
 				title: "Plan updated",
 				source,
 				...params.explanation ? { explanation: params.explanation } : {},
+				...params.explanationFormat ? { explanationFormat: params.explanationFormat } : {},
 				...params.steps ? { steps: params.steps } : {}
 			}
 		});
@@ -1078,16 +1141,12 @@ function normalizePlanStepStatus(status) {
 	if (status === "inProgress" || status === "in_progress") return "in_progress";
 	return status === "completed" ? "completed" : "pending";
 }
-function collectReasoningTextValues(groups, itemOrder) {
-	return [...groups.values()].toSorted((left, right) => {
-		const itemDelta = (itemOrder.get(left.itemId) ?? Number.MAX_SAFE_INTEGER) - (itemOrder.get(right.itemId) ?? Number.MAX_SAFE_INTEGER);
-		if (itemDelta !== 0) return itemDelta;
-		const methodDelta = reasoningMethodOrder(left.method) - reasoningMethodOrder(right.method);
-		return methodDelta !== 0 ? methodDelta : left.index - right.index;
-	}).map((group) => group.text).filter((text) => text.trim().length > 0);
-}
-function reasoningMethodOrder(method) {
-	return method === "item/reasoning/summaryTextDelta" ? 0 : 1;
+function readReasoningSections(value) {
+	const sections = /* @__PURE__ */ new Map();
+	if (Array.isArray(value)) value.forEach((text, index) => {
+		if (typeof text === "string") sections.set(index, text);
+	});
+	return sections;
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-settlement.ts
@@ -1156,7 +1215,8 @@ function buildCodexMessagesSnapshot(params) {
 		...commentaryMessages,
 		...asyncMessages,
 		...(params.assistantMessages ?? []).map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:assistant:${itemId}`)),
-		...params.toolMessages
+		...params.toolMessages,
+		...params.steeringMessages ?? []
 	].toSorted((left, right) => (asDateTimestampMs(left.timestamp) ?? 0) - (asDateTimestampMs(right.timestamp) ?? 0));
 	messages.push(...visibleWorkMessages);
 	if (params.lastAssistant) {
@@ -1166,6 +1226,7 @@ function buildCodexMessagesSnapshot(params) {
 	const taint = { tainted: false };
 	return messages.map((message) => projectAgentHarnessTranscriptMessageForDisplay({
 		hidden: params.runParams.trigger === "memory",
+		inputProvenance: params.runParams.inputProvenance,
 		message: applyCodexTranscriptTaint(message, taint)
 	}));
 }
@@ -1193,171 +1254,14 @@ function buildCodexSteeringMessagesSnapshot(params) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/app-server/usage-limit-error.ts
-/**
-* Enriches Codex usage-limit failures with current rate-limit information and
-* marks blocked auth profiles when Codex exposes a reset time.
-*/
-const CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS = 5e3;
-var CodexUsageLimitPromptError = class extends Error {
-	constructor(..._args) {
-		super(..._args);
-		this.status = 429;
-	}
-};
-function resolveCodexPromptError(source) {
-	const usageLimitMessage = formatCodexUsageLimitErrorMessage(source);
-	if (usageLimitMessage) return new CodexUsageLimitPromptError(usageLimitMessage);
-	const info = source.codexErrorInfo;
-	let status = info === "rateLimitExceeded" ? 429 : info === "serverOverloaded" ? 503 : info === "internalServerError" ? 500 : void 0;
-	if (isJsonObject(info)) for (const variant of [
-		"httpConnectionFailed",
-		"responseStreamConnectionFailed",
-		"responseStreamDisconnected",
-		"responseTooManyFailedAttempts"
-	]) {
-		const detail = info[variant];
-		if (isJsonObject(detail) && typeof detail.httpStatusCode === "number") {
-			status = detail.httpStatusCode;
-			break;
-		}
-	}
-	return status === void 0 ? source.message ?? void 0 : Object.assign(new Error(source.message ?? "codex app-server error"), {
-		status,
-		...info === "serverOverloaded" ? { code: "OVERLOADED" } : {}
-	});
-}
-/** Marks a Codex auth profile blocked until the reset time advertised by rate limits. */
-async function markCodexAuthProfileBlockedFromRateLimits(params) {
-	const authProfileId = params.authProfileId?.trim();
-	if (!authProfileId || !params.params.authProfileStore) return;
-	const blockedUntil = resolveCodexUsageLimitResetAtMs(params.rateLimits);
-	if (!blockedUntil) return;
-	try {
-		await markAuthProfileBlockedUntil({
-			store: params.params.authProfileStore,
-			profileId: authProfileId,
-			blockedUntil,
-			source: "codex_rate_limits",
-			agentDir: params.params.agentDir,
-			runId: params.params.runId,
-			modelId: params.params.modelId
-		});
-	} catch (error) {
-		embeddedAgentLog.debug("failed to mark Codex auth profile blocked from app-server limits", {
-			authProfileId,
-			error: formatErrorMessage(error)
-		});
-	}
-}
-/** Formats a turn-start usage-limit error, refreshing rate limits when needed. */
-async function formatCodexTurnStartUsageLimitError(params) {
-	return refreshCodexUsageLimitError({
-		client: params.client,
-		source: readCodexTurnStartUsageLimitErrorSource(params.client, params.error, params.errorNotification, params.rateLimitsRevisionBeforeTurnStart),
-		timeoutMs: params.timeoutMs,
-		signal: params.signal
-	});
-}
-/** Refreshes a generic prompt usage-limit message into a reset-aware message. */
-async function refreshCodexUsageLimitPromptError(params) {
-	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(params.message)) return;
-	return refreshCodexUsageLimitError({
-		client: params.client,
-		source: {
-			message: params.message,
-			codexErrorInfo: "usageLimitExceeded",
-			rateLimits: readRecentCodexRateLimits(params.client)
-		},
-		timeoutMs: params.timeoutMs,
-		signal: params.signal
-	});
-}
-async function refreshCodexUsageLimitError(params) {
-	const initialMessage = formatCodexUsageLimitErrorMessage(params.source);
-	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(initialMessage)) return initialMessage ? {
-		message: initialMessage,
-		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
-	} : void 0;
-	const rateLimits = await readCodexRateLimitsFromAppServerForUsageLimitError({
-		client: params.client,
-		timeoutMs: params.timeoutMs,
-		signal: params.signal
-	});
-	if (!rateLimits) return initialMessage ? {
-		message: initialMessage,
-		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
-	} : void 0;
-	const message = formatCodexUsageLimitErrorMessage({
-		message: params.source.message,
-		codexErrorInfo: params.source.codexErrorInfo,
-		rateLimits,
-		rateLimitsAuthoritative: true
-	}) ?? initialMessage;
-	return message ? {
-		message,
-		rateLimitsForProfile: rateLimits
-	} : void 0;
-}
-async function readCodexRateLimitsFromAppServerForUsageLimitError(params) {
-	if (params.signal?.aborted) return;
-	try {
-		const rateLimits = await params.client.request(CODEX_CONTROL_METHODS.rateLimits, void 0, {
-			timeoutMs: resolveCodexUsageLimitRateLimitRefreshTimeoutMs(params.timeoutMs),
-			signal: params.signal
-		});
-		rememberCodexRateLimitsRead(params.client, rateLimits);
-		return rateLimits;
-	} catch (error) {
-		embeddedAgentLog.debug("codex app-server rate-limit refresh failed after usage-limit error", { error: formatErrorMessage(error) });
-		return;
-	}
-}
-function resolveCodexUsageLimitRateLimitRefreshTimeoutMs(timeoutMs) {
-	if (timeoutMs === void 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS;
-	return Math.max(100, Math.min(timeoutMs, CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS));
-}
-function readCodexTurnStartUsageLimitErrorSource(client, error, errorNotification, rateLimitsRevisionBeforeTurnStart) {
-	const notificationError = readCodexErrorNotification(errorNotification);
-	const errorPayload = readCodexErrorPayload(error);
-	const rateLimits = errorPayload.rateLimits ?? readRecentCodexRateLimits(client);
-	const cacheUpdatedDuringTurnStart = rateLimitsRevisionBeforeTurnStart !== void 0 && readCodexRateLimitsRevision(client) > rateLimitsRevisionBeforeTurnStart;
-	return {
-		message: notificationError?.message ?? errorPayload.message ?? formatErrorMessage(error),
-		codexErrorInfo: notificationError?.codexErrorInfo ?? errorPayload.codexErrorInfo,
-		rateLimits,
-		rateLimitsTrustedForProfile: errorPayload.rateLimits !== void 0 || cacheUpdatedDuringTurnStart
-	};
-}
-function readCodexErrorNotification(notification) {
-	if (notification?.method !== "error" || !isJsonObject(notification.params)) return;
-	const error = notification.params.error;
-	return isJsonObject(error) ? {
-		message: readStringField(error, "message"),
-		codexErrorInfo: error.codexErrorInfo
-	} : void 0;
-}
-function readCodexErrorPayload(error) {
-	const message = error instanceof Error ? error.message : void 0;
-	if (!error || typeof error !== "object" || !("data" in error)) return { message };
-	const data = error.data;
-	if (!isJsonObject(data)) return { message };
-	const nestedError = isJsonObject(data.error) ? data.error : data;
-	const rateLimits = nestedError.rateLimits ?? data.rateLimits;
-	return {
-		message: readStringField(nestedError, "message") ?? message,
-		codexErrorInfo: nestedError.codexErrorInfo,
-		rateLimits
-	};
-}
-//#endregion
 //#region extensions/codex/src/app-server/event-projector-terminal-failure.ts
 var CodexTerminalFailureProjection = class {
 	constructor() {
 		this.promptErrorSource = null;
 	}
 	record(params) {
-		this.providerRefusal ??= readCodexProviderRefusal(params.message, params.codexErrorInfo);
+		const refusal = readCodexProviderRefusal(params.message, params.codexErrorInfo, params);
+		if (!this.providerRefusal || refusal?.category === "misalignment" && this.providerRefusal.category === "misalignment" && params.misalignment != null) this.providerRefusal = refusal;
 		if (this.providerRefusal) return;
 		this.promptError = resolveCodexPromptError({
 			message: params.message,
@@ -1417,6 +1321,7 @@ var CodexTranscriptCheckpoint = class {
 				const message = entry.read();
 				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
 					hidden: this.params.trigger === "memory",
+					inputProvenance: this.params.inputProvenance,
 					message: applyCodexTranscriptTaint(message, taint)
 				})] : [];
 			});
@@ -1486,7 +1391,7 @@ var CodexTurnProjection = class {
 			trajectoryRecorder: options.trajectoryRecorder,
 			checkpointMessage: this.transcriptCheckpoint.enqueue
 		});
-		this.eventProjection = new CodexEventProjection(threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
+		this.eventProjection = new CodexEventProjection(params.provider, threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
 		this.assistantProjection = new CodexAssistantProjection(this.settlement.params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
 		this.reasoningProjection = new CodexReasoningProjection(this.settlement.params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
 	}
@@ -1543,6 +1448,7 @@ var CodexTurnProjection = class {
 			asyncMessages,
 			commentaryMessages,
 			toolMessages: this.toolTranscriptProjection.transcriptMessages,
+			steeringMessages: options?.steeringMessages,
 			lastAssistant,
 			turnTainted
 		});
@@ -1557,7 +1463,8 @@ var CodexTurnProjection = class {
 		});
 		const toolMetas = this.toolProgressProjection.toolMetas;
 		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || Boolean(toolTelemetry.successfulCronAdds || toolTelemetry.acceptedSessionSpawns?.length) || this.generatedMediaProjection.hasGeneratedMedia() || this.toolProgressProjection.hasPotentialSideEffects;
-		const sentMediaUrls = new Set(toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
+		const mediaDelivery = this.generatedMediaProjection.projectDelivery(toolTelemetry);
+		const sentMediaUrls = new Set(mediaDelivery.messagingToolSentMediaUrls.map((url) => url.trim()));
 		const toolAutoDeliveryMediaUrls = toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
 		const result = {
 			terminal: attemptTerminal.normalize({
@@ -1581,12 +1488,9 @@ var CodexTurnProjection = class {
 			didDeliverSourceReplyViaMessageTool: toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
 			sourceReplyDelivered: toolTelemetry.sourceReplyDelivered,
 			messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,
-			messagingToolSentMediaUrls: toolTelemetry.messagingToolSentMediaUrls,
-			messagingToolSentTargets: toolTelemetry.messagingToolSentTargets,
+			...mediaDelivery,
 			messagingToolSourceReplyPayloads: toolTelemetry.messagingToolSourceReplyPayloads ?? [],
 			heartbeatToolResponse: toolTelemetry.heartbeatToolResponse,
-			toolMediaUrls: this.generatedMediaProjection.buildToolMediaUrls(toolTelemetry),
-			hostOwnedToolMediaUrls: this.generatedMediaProjection.buildHostOwnedMediaUrls(toolTelemetry),
 			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
 			successfulCronAdds: toolTelemetry.successfulCronAdds,
 			acceptedSessionSpawns: toolTelemetry.acceptedSessionSpawns,
@@ -1617,6 +1521,7 @@ var CodexTurnProjection = class {
 };
 //#endregion
 //#region extensions/codex/src/app-server/event-projector.ts
+const optedOutNotificationMethods = new Set(CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS);
 var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
@@ -1689,6 +1594,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		this.assistantProjection.handleNotification(notification.method, params);
 		switch (notification.method) {
 			case "item/agentMessage/delta":
+				if (readStringField(params, "delta")) this.eventProjection.markSafetyBufferingAssistantStarted();
 				await this.assistantProjection.handleAssistantDelta(params);
 				break;
 			case "item/reasoning/summaryTextDelta":
@@ -1752,6 +1658,9 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 			case "model/rerouted":
 				this.eventProjection.handleModelRerouted(params);
 				break;
+			case "model/safetyBuffering/updated":
+				this.eventProjection.handleSafetyBuffering(params);
+				break;
 			case "error": {
 				this.usageProjection.invalidateContext();
 				if (params.willRetry === true) {
@@ -1759,29 +1668,29 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 					break;
 				}
 				const codexErrorInfo = isJsonObject(params.error) ? params.error.codexErrorInfo : void 0;
+				this.eventProjection.handleCyberPolicyError(codexErrorInfo, this.params.modelId);
 				const compactionFailure = codexErrorInfo === "other" && this.isCompacting();
 				this.settledTurnFailureFinalizationAllowed = codexErrorInfo === "serverOverloaded" || compactionFailure;
 				this.terminalFailure.record({
 					message: readCodexErrorNotificationMessage(params),
 					codexErrorInfo,
+					misalignment: isJsonObject(params.error) ? params.error.misalignment : void 0,
+					nativeThreadId: this.threadId,
+					nativeTurnId: this.turnId,
 					rateLimits: this.options.readRecentRateLimits?.(),
 					fallbackMessage: "codex app-server error",
 					promptErrorSource: compactionFailure ? "compaction" : "prompt"
 				});
 				break;
 			}
-			case "thread/compacted":
 			case "turn/started":
-			case "turn/diff/updated":
 			case "item/reasoning/summaryPartAdded":
 			case "item/commandExecution/terminalInteraction":
-			case "item/fileChange/outputDelta":
 			case "item/fileChange/patchUpdated":
 			case "item/mcpToolCall/progress":
 			case "model/verification":
-			case "turn/moderationMetadata":
-			case "model/safetyBuffering/updated": break;
-			default: this.diagnostics.warnUnknownEvent(notification, params);
+			case "turn/moderationMetadata": break;
+			default: if (!optedOutNotificationMethods.has(notification.method)) this.diagnostics.warnUnknownEvent(notification, params);
 		}
 		if (!this.projectionClosed && [
 			"item/started",
@@ -1789,6 +1698,23 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 			"rawResponseItem/completed"
 		].includes(notification.method)) await this.settlement.project("transcript/checkpoint", () => this.transcriptCheckpoint.flush());
 	}
+	recordUserInputResponse(params) {
+		if (this.projectionClosed) return;
+		this.toolTranscriptProjection.recordToolCall({
+			id: params.itemId,
+			name: "request_user_input",
+			arguments: { questions: params.questions }
+		});
+		this.toolTranscriptProjection.recordToolResult({
+			id: params.itemId,
+			name: "request_user_input",
+			text: JSON.stringify({
+				response: params.response,
+				request: { questions: params.questions }
+			}),
+			isError: false
+		});
+	}
 	recordDynamicToolCall(params) {
 		this.toolTranscriptProjection.recordDynamicToolCall(params);
 	}
@@ -1798,7 +1724,8 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		if (update) {
 			const projected = {
 				plan: update.steps,
-				...update.explanation ? { explanation: update.explanation } : {}
+				...update.explanation ? { explanation: update.explanation } : {},
+				...update.explanationFormat ? { explanationFormat: update.explanationFormat } : {}
 			};
 			await this.reasoningProjection.handleTurnPlanUpdated(projected, "openclaw");
 		}
@@ -1825,8 +1752,9 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	}
 	async handleItemStarted(params) {
 		const item = readItem(params.item);
+		if (item?.type === "agentMessage" && item.text) this.eventProjection.markSafetyBufferingAssistantStarted();
 		const itemId = item?.id ?? readStringField(params, "itemId");
-		this.assistantProjection.recordItemStarted(item, itemId);
+		await this.assistantProjection.recordItemStarted(item, itemId);
 		if (itemId) this.activeItemIds.add(itemId);
 		this.recordNativeToolOutcome(item);
 		if (item?.type === "contextCompaction" && itemId) {
@@ -1874,10 +1802,12 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	}
 	async handleItemCompleted(params) {
 		const item = readItem(params.item);
+		const itemId = item?.id ?? readStringField(params, "itemId");
+		if (item?.type === "contextCompaction" && itemId && this.completedItemIds.has(itemId)) return;
+		if (item?.type === "agentMessage" && item.text) this.eventProjection.markSafetyBufferingAssistantStarted();
 		this.diagnostics.warnUnknownItemStatus(item);
 		this.recordNativeToolOutcome(item);
 		this.nativeToolLifecycleProjector.clearTerminalPresentationForNativeItem(item);
-		const itemId = item?.id ?? readStringField(params, "itemId");
 		if (itemId) {
 			this.activeItemIds.delete(itemId);
 			this.completedItemIds.add(itemId);
@@ -1886,7 +1816,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		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.reasoningProjection.recordItem(item);
 		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
 		if (this.projectionClosed) return;
 		if (item?.type === "contextCompaction" && itemId) {
@@ -1944,17 +1874,22 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		});
 	}
 	async handleTurnCompleted(params) {
-		const turn = readCodexTurn(params.turn);
+		const turn = readCodexTurnCompletedNotification(params)?.turn;
 		if (!turn || turn.id !== this.turnId) return;
 		this.completedTurn = turn;
+		this.eventProjection.endSafetyBuffering();
 		const compactionFailure = turn.status === "failed" && (this.terminalFailure.promptErrorSource === "compaction" || turn.error?.codexErrorInfo === "other" && this.isCompacting());
 		this.settledTurnFailureFinalizationAllowed = turn.status === "failed" && (turn.error?.codexErrorInfo === "serverOverloaded" || compactionFailure);
 		if (turn.status !== "completed") this.usageProjection.invalidateContext();
 		if (turn.status === "failed") {
 			const codexErrorInfo = turn.error?.codexErrorInfo;
+			this.eventProjection.handleCyberPolicyError(codexErrorInfo, this.params.modelId);
 			this.terminalFailure.record({
 				message: turn.error?.message,
 				codexErrorInfo,
+				misalignment: turn.error?.misalignment,
+				nativeThreadId: this.threadId,
+				nativeTurnId: this.turnId,
 				rateLimits: this.options.readRecentRateLimits?.(),
 				fallbackMessage: "codex app-server turn failed",
 				promptErrorSource: compactionFailure ? "compaction" : "prompt"
@@ -1968,7 +1903,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 				this.eventProjection.emitCompactionEnd(itemId, false);
 			}
 		}
-		const turnItems = turn.items ?? [];
+		const turnItems = turn.items;
 		const unsettledAsyncDeliveries = this.asyncDeliveryProjection.pending();
 		const lastToolItem = turnItems.findLast((item) => matchesCodexSnapshotTurn(item, this.turnId) && (item.type === "dynamicToolCall" || shouldClearTerminalPresentationForNativeItem(item)));
 		if (lastToolItem?.type !== "dynamicToolCall") this.nativeToolLifecycleProjector.clearTerminalPresentationForNativeItem(lastToolItem);
@@ -1978,7 +1913,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 			const asyncMessage = this.assistantProjection.recordSnapshotItem(item);
 			if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 			if (this.projectionClosed) return;
-			this.reasoningProjection.recordItem(item);
+			await this.reasoningProjection.recordItem(item);
 			await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
 			if (this.projectionClosed) return;
 			this.toolProgressProjection.recordToolMeta(item);
@@ -2011,6 +1946,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
+		if (item.role === "assistant" && extractRawAssistantText(item)) this.eventProjection.markSafetyBufferingAssistantStarted();
 		this.toolTranscriptProjection.recordRawNativeToolItem(item);
 		this.assistantProjection.handleRawResponseItemCompleted(item, this.activeItemIds);
 		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordRaw(item));
@@ -2282,50 +2218,31 @@ const MAX_USER_INPUT_HEADER = 64;
 const MAX_USER_INPUT_TEXT = 4096;
 /** Creates the single per-turn owner for Codex operator input. */
 function createCodexUserInputBridge(params) {
-	const jobs = [];
-	let activeCompletion;
+	const cleanup = new AbortController();
+	const bridgeSignal = params.signal ? AbortSignal.any([params.signal, cleanup.signal]) : cleanup.signal;
+	let completion = Promise.resolve();
 	const inputSessionKey = params.paramsForRun.sessionKey ?? params.paramsForRun.sessionId;
-	const pump = () => {
-		const job = jobs[0];
-		if (activeCompletion || !job) return;
-		activeCompletion = job.run(job.abort.signal).catch((error) => {
-			embeddedAgentLog.warn("failed to bridge codex operator input", { error });
-			return job.abort.signal.aborted ? job.cancelValue : job.failureValue;
-		}).then((value) => {
-			job.resolve(job.abort.signal.aborted ? job.cancelValue : value ?? job.failureValue);
-		}).finally(() => {
-			if (jobs[0] === job) jobs.shift();
-			activeCompletion = void 0;
-			pump();
-		});
-	};
-	const enqueue = (definition) => {
-		if (params.signal?.aborted) return Promise.resolve(definition.cancelValue);
-		return new Promise((resolve) => {
-			jobs.push({
-				...definition,
-				resolve
-			});
-			pump();
+	const enqueue = (job, requestSignal) => {
+		const signal = requestSignal ? AbortSignal.any([bridgeSignal, requestSignal]) : bridgeSignal;
+		if (signal.aborted) return Promise.resolve(job.cancelValue);
+		return new Promise((resolve, reject) => {
+			const onAbort = () => resolve(job.cancelValue);
+			signal.addEventListener("abort", onAbort, { once: true });
+			completion = completion.then(async () => {
+				signal.removeEventListener("abort", onAbort);
+				if (signal.aborted) return;
+				let value;
+				try {
+					value = await job.run(signal);
+				} catch (error) {
+					if (!signal.aborted) embeddedAgentLog.warn("failed to bridge codex operator input", { error });
+				}
+				const response = signal.aborted ? job.cancelValue : value ?? job.failureValue;
+				if (!(signal.reason instanceof CodexServerRequestResolvedError)) job.onResponse?.(response);
+				resolve(response);
+			}).catch(reject);
 		});
 	};
-	const cancelJob = (job) => {
-		const index = jobs.indexOf(job);
-		if (index < 0) return;
-		if (index === 0) {
-			job.abort.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
-			return;
-		}
-		jobs.splice(index, 1);
-		job.resolve(job.cancelValue);
-	};
-	const cancelPending = async () => {
-		const pendingCompletion = activeCompletion;
-		const queuedJobs = jobs.splice(1);
-		for (const job of queuedJobs) job.resolve(job.cancelValue);
-		jobs[0]?.abort.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
-		await pendingCompletion;
-	};
 	const execute = (input, timeoutMs, signal) => agentHarnessStructuredInput.run({
 		input,
 		sessionKey: inputSessionKey,
@@ -2341,9 +2258,8 @@ function createCodexUserInputBridge(params) {
 			urlIntro: "Codex needs confirmation:"
 		}
 	});
-	params.signal?.addEventListener("abort", () => void cancelPending(), { once: true });
 	return {
-		async handleRequest(request) {
+		async handleRequest(request, requestSignal) {
 			const requestParams = readUserInputParams(request.params);
 			if (!requestParams || requestParams.threadId !== params.threadId || requestParams.turnId !== params.turnId) return;
 			if (requestParams.questions.length === 0) return emptyUserInputResponse();
@@ -2351,47 +2267,38 @@ function createCodexUserInputBridge(params) {
 			const input = compileUserInputQuestions(requestParams.questions);
 			const cancelValue = emptyUserInputResponse();
 			return await enqueue({
-				requestId: request.id,
-				abort: new AbortController(),
 				cancelValue,
 				failureValue: cancelValue,
+				onResponse: requestParams.questions.some((question) => question.isSecret) ? void 0 : (response) => params.onOrdinaryResponse?.({
+					itemId: requestParams.itemId,
+					questions: requestParams.questions,
+					response
+				}),
 				run: async (signal) => {
 					const result = await execute(input, timeoutMs, signal);
 					return result.status === "answered" ? gatewayAnswersToCodexResponse(result.answers) : cancelValue;
 				}
-			});
+			}, requestSignal);
 		},
-		async handleElicitationRequest(request) {
+		async handleElicitationRequest(request, requestSignal) {
 			if (readOwnDataString(request.params, "threadId") !== params.threadId) return;
 			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params);
-			if (!agentHarnessStructuredInput.isRecord(requestSnapshot)) {
-				const cancelValue = createCodexElicitationResponse("cancel");
-				return await enqueue({
-					requestId: request.id,
-					abort: new AbortController(),
-					cancelValue,
-					failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
-					run: async (signal) => {
-						const result = await execute({
-							kind: "unsupported",
-							message: "OpenClaw declined a malformed or over-limit MCP elicitation request."
-						}, params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS, signal);
-						return result.status === "unsupported" ? declineElicitation(result.message) : cancelValue;
-					}
-				});
-			}
-			if (readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
-			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.js");
-			const compiled = compileCodexOrdinaryElicitation({
+			if (agentHarnessStructuredInput.isRecord(requestSnapshot) && readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
+			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.mjs");
+			const compiled = agentHarnessStructuredInput.isRecord(requestSnapshot) ? compileCodexOrdinaryElicitation({
 				snapshot: requestSnapshot,
 				turnId: params.turnId
-			});
+			}) : {
+				kind: "compiled",
+				input: {
+					kind: "unsupported",
+					message: "OpenClaw declined a malformed or over-limit MCP elicitation request."
+				}
+			};
 			if (compiled.kind === "ignored") return;
 			const cancelValue = createCodexElicitationResponse("cancel");
 			const timeoutMs = params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS;
 			return await enqueue({
-				requestId: request.id,
-				abort: new AbortController(),
 				cancelValue,
 				failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
 				run: async (signal) => {
@@ -2400,20 +2307,15 @@ function createCodexUserInputBridge(params) {
 						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);
+					if (result.status === "declined" || result.status === "unsupported") return declineElicitation(result.message);
 					return cancelValue;
 				}
-			});
+			}, requestSignal);
 		},
-		handleNotification(notification) {
-			if (notification.method !== "serverRequest/resolved" || !isJsonObject(notification.params)) return;
-			const requestId = readRequestId(notification.params);
-			if (requestId === void 0 || readOwnDataString(notification.params, "threadId") !== params.threadId) return;
-			const job = jobs.find((candidate) => typeof candidate.requestId === typeof requestId && candidate.requestId === requestId);
-			if (job) cancelJob(job);
-		},
-		cancelPending
+		async cancelPending() {
+			cleanup.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
+			await completion;
+		}
 	};
 }
 function compileUserInputQuestions(questions) {
@@ -2439,6 +2341,7 @@ function readUserInputParams(value) {
 	return {
 		threadId,
 		turnId,
+		itemId,
 		questions: parsed,
 		isBlocking: readValue(snapshot, "isBlocking") !== false
 	};
@@ -2493,11 +2396,6 @@ function readOwnDataString(value, key) {
 	const descriptor = Object.getOwnPropertyDescriptor(value, key);
 	return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
 }
-function readRequestId(record) {
-	const descriptor = Object.getOwnPropertyDescriptor(record, "requestId");
-	const value = descriptor && "value" in descriptor ? descriptor.value : void 0;
-	return typeof value === "string" || typeof value === "number" ? value : void 0;
-}
 function gatewayAnswersToCodexResponse(answers) {
 	return { answers: Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [questionId, { answers: values }])) };
 }
@@ -2509,7 +2407,7 @@ function declineElicitation(message) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-active-turn.ts
-function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turn) {
+function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, { turn, upstreamUserText }) {
 	const { prompt, state: resourceState, projectorRef, trajectoryRecorder, pendingNativePreToolUseFailures } = resources;
 	const { context, turnState } = prompt;
 	const { runtime, attemptTools, hookContext } = context;
@@ -2536,6 +2434,31 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			provider: runtimeModelSelection.provider
 		}
 	} : dynamicToolParams;
+	const hostPrepareReplyMedia = params.hostCapabilities.prepareReplyMedia;
+	const remoteWorkspaceRoot = connection.appServer.remoteWorkspaceRoot;
+	const replyMediaClient = resourceState.client;
+	const prepareReplyMedia = hostPrepareReplyMedia && remoteWorkspaceRoot ? async (content, transferSignal) => hostPrepareReplyMedia({
+		...content,
+		workspaceRoot: remoteWorkspaceRoot,
+		signal: runAbortController.signal,
+		readWorkspaceFile: async (relativePath, { maxBytes, signal }) => {
+			connection.assertCurrent();
+			const file = await readBoundedCodexRemoteWorkspaceFile({
+				client: replyMediaClient,
+				path: mapCodexAppServerRemoteWorkspacePath({
+					value: path.resolve(params.workspaceDir, relativePath),
+					localWorkspaceRoot: params.workspaceDir,
+					remoteWorkspaceRoot
+				}),
+				workspaceRoot: remoteWorkspaceRoot,
+				maxBytes,
+				signal: transferSignal ? AbortSignal.any([signal, transferSignal]) : signal,
+				timeoutMs: connection.appServer.requestTimeoutMs
+			});
+			connection.assertCurrent();
+			return Buffer.from(file.dataBase64, "base64");
+		}
+	}) : void 0;
 	const progressCardTool = toolBridge.availableTools.find((tool) => tool.name === "progress_card");
 	let nativePlanUpdateOrdinal = 0;
 	const prepareNativeMcpAppResultDetails = createCodexNativeMcpAppResultDetailsPreparer({
@@ -2547,19 +2470,6 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		eventEmitted: false,
 		needsTerminalSnapshot: false
 	};
-	emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
-	userInputBridgeRef.current = createCodexUserInputBridge({
-		paramsForRun: params,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		signal: runAbortController.signal
-	});
-	trajectoryRecorder?.recordEvent("prompt.submitted", {
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		prompt: turnState.codexTurnPromptText,
-		imagesCount: params.images?.length ?? 0
-	});
 	projectorRef.current = new CodexAppServerEventProjector({
 		...projectionParams,
 		onAgentEvent: (event) => {
@@ -2576,7 +2486,17 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		asyncUserMessageAllowed: params.disableTools !== true && (params.toolsAllow === void 0 || toolBridge.availableTools.some((tool) => tool.name === "message")),
 		onAsyncDelivery: async (delivery) => {
 			return await codexTranscriptMirrorRuntime.deliverAsyncMessageBestEffort({
-				params: projectionParams,
+				params: prepareReplyMedia && projectionParams.onBlockReply ? {
+					...projectionParams,
+					onBlockReply: async (payload, options) => {
+						const prepared = await prepareReplyMedia({
+							kind: "payload",
+							payload
+						});
+						if (prepared.kind !== "payload") throw new Error("Reply media preparation returned the wrong result kind");
+						await projectionParams.onBlockReply?.(prepared.payload, options);
+					}
+				} : projectionParams,
 				cwd: effectiveCwd,
 				threadId: resourceState.thread.threadId,
 				turnId: activeTurnId,
@@ -2587,9 +2507,9 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		runAbortSignal: runAbortController.signal,
 		remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
 		remoteWorkspaceRequestTimeoutMs: connection.appServer.requestTimeoutMs,
-		readRemoteWorkspaceFile: ({ path, maxBytes, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
+		readRemoteWorkspaceFile: ({ path: remotePath, maxBytes, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
 			client: resourceState.client,
-			path,
+			path: remotePath,
 			maxBytes,
 			signal,
 			timeoutMs
@@ -2611,7 +2531,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			}
 		} } : {},
 		...prepareNativeMcpAppResultDetails ? { prepareNativeMcpAppResultDetails } : {},
-		upstreamUserText: turnState.codexTurnPromptText,
+		upstreamUserText,
 		onContextCompacted: async () => {
 			computerContextEpoch.value += 1;
 			delete computerContextEpoch.frameToolCallId;
@@ -2632,19 +2552,14 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			}
 		}
 	});
-	if (isTerminalTurnStatus(turn.turn.status)) {
-		projectorRef.current.settlement.terminalReceipt = turn.turn;
-		state.terminalTurnNotificationQueued = true;
-		deadlines.beginSettlement(Date.now());
-	}
-	emitLifecycleStart();
 	const activeProjector = projectorRef.current;
-	noteProgress("turn:start");
+	let activationFailed = false;
 	const abortListener = () => {
 		state.abortCleanup = interruptTurn(activeTurnId).then(async (confirmed) => {
-			if (!terminalState.explicitCancellationObserved && !state.permissionChangeRestart && !state.timeout) return;
+			if (!activationFailed && !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 (resources.nativeProcessAuthority) await resources.nativeProcessAuthority.cancelTurn(resourceState.client, resourceState.thread.threadId, activeTurnId);
+			else await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
 			if (state.permissionChangeRestart) state.permissionChangeRestart = "confirmed";
 		});
 		state.abortCleanup.then(completeTurn, (error) => {
@@ -2652,32 +2567,18 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			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: contextSessionKey,
-		cwd: effectiveCwd,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		upstreamUserText: turnState.codexTurnPromptText
-	});
-	const bindProjection = async () => {
+	const bindProjection = async (promptMirrorPromise) => {
 		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]);
+				await Promise.race([resourceState.turnRoute.bindTurn(activeTurnId, { beforeNotifications: promptMirrorPromise }), completion]);
 			} catch (error) {
 				if (!state.terminalTurnNotificationQueued && !runAbortController.signal.aborted) throw error;
 				await Promise.race([resourceState.turnRoute.drain(), completion]);
 				if (!state.completed) throw error;
 			}
+			else await Promise.race([promptMirrorPromise, completion]);
 			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({
@@ -2707,6 +2608,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	});
 	const imageContext = {
 		workspaceDir: connection.effectiveWorkspace,
+		agentWorkspaceDir: params.workspaceDir,
 		model: params.model,
 		config: params.config,
 		workspaceOnly,
@@ -2723,7 +2625,18 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		requestTimeoutMs: connection.appServer.requestTimeoutMs,
 		signal: runAbortController.signal,
 		assertActive: assertSteeringActive,
-		prepareMessage: async (text, options) => {
+		prepareMessage: async (text, options, assertMessageCurrent) => {
+			const attachmentNote = await prepareAgentWorkspaceAttachments({
+				workspaceDir: params.workspaceDir,
+				turn: {
+					config: params.config,
+					media: options.media,
+					timeoutMs: params.timeoutMs,
+					abortSignal: runAbortController.signal,
+					userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
+				},
+				assertCurrent: assertMessageCurrent
+			});
 			const result = await detectAndLoadAgentHarnessPromptImages({
 				...imageContext,
 				prompt: text,
@@ -2733,12 +2646,33 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 				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);
+			const source = await buildResolvedCodexUserPromptMessage({
+				...params,
+				prompt: text,
+				transcriptPrompt: text,
+				userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
+			});
+			return {
+				input: buildCodexUserInput(attachmentNote ? `${text}\n\n${attachmentNote}` : text, result.images),
+				message: {
+					...source,
+					role: "user",
+					content: result.images.length ? [{
+						type: "text",
+						text
+					}, ...result.images] : text,
+					...result.images.length ? { __openclaw: {
+						...asOptionalRecord(Reflect.get(source, "__openclaw")),
+						mediaImageBlockFactIndexes: result.imageFactIndexes
+					} } : {}
+				}
+			};
 		},
 		beforeSubmit: async (items) => {
 			const transcriptItems = items.filter((item) => item.isInboundUserMessage === true || item.userTurnTranscriptRecorder !== void 0);
 			if (transcriptItems.length === 0) return;
-			await promptMirrorPromise;
+			await projectionReady;
+			await notifications.drainNotificationQueue();
 			assertSteeringActive();
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
 			if (params.sessionTarget && messages.length > 0) {
@@ -2862,33 +2796,83 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		cancel: () => abortExplicitly("cancelled"),
 		abort: () => abortExplicitly("aborted")
 	};
-	params.replyOperation?.attachBackend(handle);
-	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
 	const freezeRunTerminalOutcome = () => {
 		if (terminalState.terminalOutcomeFrozen) return;
 		terminalState.terminalOutcomeFrozen = true;
 		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 	};
-	if (!runAbortController.signal.aborted && params.permissionChange && !params.permissionChange.applied()) {
-		state.permissionChangeRestart = "requested";
-		runAbortController.abort("permission-change");
-	}
+	const projectionReady = Promise.resolve().then(async () => {
+		runAbortController.signal.addEventListener("abort", abortListener, { once: true });
+		if (runAbortController.signal.aborted) abortListener();
+		try {
+			emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
+			userInputBridgeRef.current = createCodexUserInputBridge({
+				paramsForRun: params,
+				onOrdinaryResponse: (response) => activeProjector.recordUserInputResponse(response),
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				signal: runAbortController.signal
+			});
+			trajectoryRecorder?.recordEvent("prompt.submitted", {
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				prompt: turnState.codexTurnPromptText,
+				imagesCount: params.images?.length ?? 0
+			});
+			if (isTerminalTurnStatus(turn.turn.status)) {
+				activeProjector.settlement.terminalReceipt = turn.turn;
+				state.terminalTurnNotificationQueued = true;
+				deadlines.beginSettlement(Date.now());
+			}
+			emitLifecycleStart({
+				provider: projectionParams.provider,
+				model: projectionParams.modelId
+			});
+			noteProgress("turn:start");
+			for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
+			if (thread.preserveNativeModel !== true && thread.connectionScope !== "supervision" && !params.expectedSessionRuntimeOwnership) {
+				const route = resourceState.turnRoute;
+				params.registerPluginRuntimeRefreshConsumer?.(() => resourceState.turnRoute === route && route?.signal.aborted === false && turnRuntime.turnIdRef.current === activeTurnId && !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted);
+			}
+			params.replyOperation?.attachBackend(handle);
+			setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
+			if (!runAbortController.signal.aborted && params.permissionChange && !params.permissionChange.applied()) {
+				state.permissionChangeRestart = "requested";
+				runAbortController.abort("permission-change");
+			}
+			await bindProjection(mirrorPromptAtTurnStartBestEffort({
+				params,
+				agentId: sessionAgentId,
+				notifyUserMessagePersisted,
+				sessionKey: contextSessionKey,
+				cwd: effectiveCwd,
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				upstreamUserText
+			}));
+		} catch (error) {
+			activationFailed = true;
+			runAbortController.abort(error);
+			throw error;
+		}
+	});
 	return {
 		activeTurnId,
 		activeProjector,
 		runtimeModelSelection,
 		streamState,
+		prepareReplyMedia,
 		handle,
 		freezeRunTerminalOutcome,
 		notifyUserMessagePersisted,
 		abortListener,
-		ready: bindProjection()
+		ready: projectionReady
 	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-cleanup.ts
 async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRuntime, activeTurn) {
-	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, releaseSharedClientLeaseAndRetireOneShotClient, releaseSandboxExecEnvironment, runCleanupStep } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, releaseSharedClientLeaseAndRetireOneShotClient, releaseSandboxExecEnvironment, releaseNativeProcessAuthority, retainThreadSubscription, releaseThreadSubscription, runCleanupStep } = resources;
 	const { connection } = prompt.context.runtime;
 	const { params, options, runAbortController, terminalState, bindingStore, bindingIdentity } = connection;
 	const { state, steeringQueueRef, userInputBridgeRef, deadlines } = turnRuntime;
@@ -2906,6 +2890,7 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	else await state.abortCleanup?.catch(() => {});
 	if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-terminals", () => terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId, true));
 	try {
+		await state.pluginRuntimeRefreshStop;
 		steeringQueueRef.current?.cancel();
 		if (params.isFinalFallbackAttempt !== false) await maybeEmitFastModeAutoResetBestEffort();
 		codexModelCallDiagnostics.emitError("codex app-server run completed without model-call terminal event");
@@ -2925,56 +2910,60 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			aborted: runAbortController.signal.aborted && !state.clientClosedAbort
 		});
 		await runCleanupStep("codex-trajectory-flush", () => trajectoryRecorder?.flush());
-		const retainLiveIncognitoThread = (terminalState.settledTurnStatus === "completed" || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
-		const retainLiveThread = ((retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.settledTurnStatus !== void 0 && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint) && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) ? bindingStore.read(bindingIdentity)?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
-			if (bindingStore.read(bindingIdentity)?.threadId !== resourceState.thread.threadId) return false;
-			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
-				release: resourceState.thread.liveThreadOwnership?.release,
-				configFingerprint: resourceState.thread.liveThreadConfigFingerprint,
-				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 (!retainLiveThread) {
-			if (bindingReleased) {
-				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-					threadId: resourceState.thread.threadId,
-					timeoutMs: 5e3
-				})) {
-					await closeCodexStartupClientBestEffort(resourceState.client);
-					if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-unsubscribe", async () => {
-						throw new Error("Codex one-shot thread unsubscribe was not confirmed");
-					});
+		const pluginRuntimeRefreshing = state.pluginRuntimeRefreshStop !== void 0 && !runAbortController.signal.aborted && terminalState.settledTurnStatus === "completed";
+		const retainLiveIncognitoThread = !pluginRuntimeRefreshing && (terminalState.settledTurnStatus === "completed" || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
+		const retainLiveThread = !pluginRuntimeRefreshing && (retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.settledTurnStatus !== void 0 && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && !resourceState.thread.ringZeroConfigFingerprint) && await retainThreadSubscription() || retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy === void 0;
+		if (pluginRuntimeRefreshing) await withExclusiveCodexAppServerThread({
+			bindingStore,
+			identity: bindingIdentity,
+			threadId: resourceState.thread.threadId,
+			run: () => bindingStore.withLease(bindingIdentity, async () => {
+				if (!isSameCodexAppServerThreadOwner(bindingStore.read(bindingIdentity), resourceState.thread)) throw new Error("Codex plugin refresh lost its managed thread binding.");
+				if (!await releaseThreadSubscription(connection.assertCurrent)) throw new Error("Plugin reload could not release the previous Codex thread.");
+				if (!await bindingStore.mutate(bindingIdentity, {
+					kind: "clear",
+					threadId: resourceState.thread.threadId
+				}, connection.assertCurrent)) throw new Error("Codex plugin refresh lost its managed thread binding.");
+			})
+		});
+		else {
+			const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveThread ? await bindingStore.mutate(bindingIdentity, {
+				kind: "clear",
+				threadId: resourceState.thread.threadId
+			}) : true;
+			if (!retainLiveThread) {
+				if (bindingReleased) {
+					if (!await releaseThreadSubscription()) {
+						if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-unsubscribe", async () => {
+							throw new Error("Codex one-shot thread unsubscribe was not confirmed");
+						});
+					}
 				}
 			}
 		}
 	} finally {
+		if (resourceState.thread.liveThreadOwnership) await runCleanupStep("codex-unsettled-subscription", async () => {
+			await releaseThreadSubscription();
+		});
 		await runCleanupStep("codex-user-input-cancel", () => userInputBridgeRef.current?.cancelPending());
 		await runCleanupStep("codex-turn-deadline-clear", () => deadlines.dispose());
-		await runCleanupStep("codex-dynamic-tool-cleanup", async () => {
-			const cleanupReason = terminalState.settledTurnStatus === "completed" ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
-			const cleanups = prompt.context.attemptTools.runCleanups.splice(0);
-			const errors = (await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)))).filter((result) => result.status === "rejected");
-			if (params.oneShotCliRun && errors.length) throw new AggregateError(errors.map((result) => result.reason), "Codex tool cleanup failed");
-		});
+		await prompt.context.attemptTools.disposeTools(terminalState.settledTurnStatus === "completed" ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error");
 		await runCleanupStep("codex-route-release", releaseCurrentRoute);
 		await checkpointCleanup;
 		await runCleanupStep("codex-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		const nativeHookRelay = resourceState.nativeHookRelay;
 		resourceState.nativeHookRelay = void 0;
-		await runCleanupStep("codex-native-hook-relay-release", () => {
+		await runCleanupStep("codex-native-hook-relay-release", async () => {
 			if (!nativeHookRelay) return;
 			if (state.shouldDelayNativeHookRelayUnregister && !params.oneShotCliRun) scheduleCodexNativeHookRelayUnregister({
 				relay: nativeHookRelay,
 				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
 			});
 			else nativeHookRelay.unregister();
+			await nativeHookRelay.drain();
 		});
 		await runCleanupStep("codex-sandbox-release", releaseSandboxExecEnvironment);
+		await runCleanupStep("codex-native-process-source-release", releaseNativeProcessAuthority);
 		await runCleanupStep("codex-abort-listener-remove", () => {
 			runAbortController.signal.removeEventListener("abort", abortListener);
 		});
@@ -2987,70 +2976,37 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	await state.abortCleanup;
 }
 //#endregion
-//#region extensions/codex/src/app-server/workspace-dir-cache.ts
-/** Process-local cache of Codex workspaces already created by the run loop. */
-const codexWorkspaceDirCache = /* @__PURE__ */ new Set();
-//#endregion
-//#region extensions/codex/src/app-server/run-attempt-lifecycle.ts
-const CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN = 4;
-function shouldKeepCodexSharedAbortOpen(params) {
-	const terminal = attemptTerminal.project(params.result.terminal);
-	if (params.explicitCancellationObserved || terminal.aborted || terminal.externalAbort) return false;
-	return params.trigger === "memory" || !params.attemptSucceeded;
-}
-function withCodexAppServerFastModeServiceTier(appServer, params) {
-	const fastMode = typeof params.fastMode === "function" ? params.fastMode() : params.fastMode;
-	const serviceTier = fastMode === void 0 ? appServer.serviceTier : fastMode ? "priority" : void 0;
-	if (serviceTier === appServer.serviceTier) return appServer;
-	if (serviceTier) return {
-		...appServer,
-		serviceTier
-	};
+//#region extensions/codex/src/app-server/session-binding-scope.ts
+/** Carries one prepared run identity through callers that rederive it from public params. */
+function scopeCodexRunBindingStore(params) {
+	const mapSessionIdentity = (identity) => identity.agentId === params.logicalIdentity.agentId && identity.sessionId === params.logicalIdentity.sessionId && identity.sessionKey?.trim() === params.logicalIdentity.sessionKey?.trim() ? params.physicalIdentity : identity;
+	const mapIdentity = (identity) => identity.kind === "session" ? mapSessionIdentity(identity) : identity;
+	const mapHistoryOwner = (identity, owner) => {
+		const mapped = mapIdentity(identity);
+		return identity.kind === "session" && mapped.kind === "session" && owner.sessionId === identity.sessionId ? {
+			...owner,
+			sessionId: mapped.sessionId
+		} : owner;
+	};
+	const readMany = params.bindingStore.readMany?.bind(params.bindingStore);
 	return {
-		...appServer,
-		serviceTier: null
-	};
-}
-function estimateCodexAppServerProjectedTurnTokens(params) {
-	const inputChars = params.prompt.length + (params.developerInstructions?.length ?? 0);
-	return Math.max(1, Math.ceil(inputChars / CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN));
-}
-async function ensureCodexWorkspaceDirOnce(workspaceDir) {
-	const normalized = path.resolve(workspaceDir);
-	if (codexWorkspaceDirCache.has(normalized)) return;
-	await fs.mkdir(normalized, { recursive: true });
-	codexWorkspaceDirCache.add(normalized);
-}
-async function emitCodexAppServerEvent(params, event) {
-	try {
-		emitAgentEvent({
-			runId: params.runId,
-			stream: event.stream,
-			data: event.data,
-			...params.sessionKey ? { sessionKey: params.sessionKey } : {}
-		});
-	} catch (error) {
-		embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
-	}
-	try {
-		await params.onAgentEvent?.(event);
-	} catch (error) {
-		embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
-	}
-}
-async function runCodexAgentEndHook(params, hookParams) {
-	const sideEffectParams = {
-		...hookParams,
-		ctx: {
-			...hookParams.ctx,
-			config: params.config
-		}
+		...params.bindingStore,
+		read: (identity) => params.bindingStore.read(mapIdentity(identity)),
+		...readMany ? { readMany: (identities) => readMany(identities.map(mapIdentity)) } : {},
+		readNativeSubagentSubmissions: (identity, owner) => params.bindingStore.readNativeSubagentSubmissions(mapIdentity(identity), mapHistoryOwner(identity, owner)),
+		hasOtherThreadOwner: (threadId, identity) => params.bindingStore.hasOtherThreadOwner(threadId, identity ? mapIdentity(identity) : void 0),
+		mutate: (identity, mutation, assertCurrent) => params.bindingStore.mutate(mapIdentity(identity), mutation.kind === "record-native-subagent-submission" || mutation.kind === "consume-native-subagent-submission" ? {
+			...mutation,
+			owner: mapHistoryOwner(identity, mutation.owner)
+		} : mutation, assertCurrent),
+		prepareSessionGenerationReclaim: (identity) => params.bindingStore.prepareSessionGenerationReclaim(mapSessionIdentity(identity)),
+		adoptSessionGeneration: (identity, expectedPreviousSessionId, assertCurrent) => params.bindingStore.adoptSessionGeneration(mapSessionIdentity(identity), expectedPreviousSessionId, assertCurrent),
+		resetSessionGeneration: (identity) => params.bindingStore.resetSessionGeneration(mapSessionIdentity(identity)),
+		retireSessionGeneration: (identity) => params.bindingStore.retireSessionGeneration(mapSessionIdentity(identity)),
+		withSessionDeletion: (identity, assertCurrent, run) => params.bindingStore.withSessionDeletion(mapSessionIdentity(identity), assertCurrent, run),
+		withThreadArchiveFence: (run) => params.bindingStore.withThreadArchiveFence(run),
+		withLease: (identity, run) => params.bindingStore.withLease(mapIdentity(identity), run)
 	};
-	if (!params.messageChannel && !params.messageProvider) {
-		await awaitAgentEndSideEffects(sideEffectParams);
-		return;
-	}
-	runAgentEndSideEffects(sideEffectParams);
 }
 //#endregion
 //#region extensions/codex/src/app-server/startup-binding.ts
@@ -3074,7 +3030,6 @@ const CODEX_APP_SERVER_BYTE_UNITS = {
 	tb: 1099511627776,
 	tib: 1099511627776
 };
-const codexSessionRecordCache = /* @__PURE__ */ new Map();
 function parseCodexAppServerByteLimit(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
 	if (typeof value !== "string") return;
@@ -3142,51 +3097,6 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 	}
 	return files;
 }
-async function readCodexSessionRecordForSessionFile(sessionFile) {
-	if (isSqliteSessionFileMarker(sessionFile)) return;
-	const sessionsFile = path.join(path.dirname(sessionFile), "sessions.json");
-	const resolvedSessionFile = path.resolve(sessionFile);
-	let stat;
-	try {
-		stat = await fs.stat(sessionsFile);
-	} catch {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	const cached = codexSessionRecordCache.get(resolvedSessionFile);
-	if (cached?.sessionsFile === sessionsFile && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.record;
-	let store;
-	try {
-		store = JSON.parse(await fs.readFile(sessionsFile, "utf8"));
-	} catch {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	if (!isJsonObject(store)) {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	let found;
-	for (const [sessionKey, record] of Object.entries(store)) {
-		if (!isJsonObject(record) || typeof record.sessionFile !== "string") continue;
-		if (path.resolve(record.sessionFile) !== resolvedSessionFile) continue;
-		found = {
-			sessionKey,
-			...record
-		};
-		break;
-	}
-	codexSessionRecordCache.set(resolvedSessionFile, {
-		sessionsFile,
-		mtimeMs: stat.mtimeMs,
-		size: stat.size,
-		record: found
-	});
-	return found;
-}
-function isSqliteSessionFileMarker(sessionFile) {
-	return parseSqliteSessionFileMarker(sessionFile) !== void 0;
-}
 async function readCodexAppServerRolloutTokenSnapshot(file, openedHandle) {
 	let handle = openedHandle;
 	if (!handle) try {
@@ -3210,12 +3120,8 @@ async function readCodexAppServerRolloutTokenSnapshot(file, openedHandle) {
 			const bytesToRead = Math.min(position, CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES);
 			const nextPosition = position - bytesToRead;
 			const chunk = Buffer.allocUnsafe(bytesToRead);
-			let bytesRead = 0;
-			while (bytesRead < bytesToRead) {
-				const result = await handle.read(chunk, bytesRead, bytesToRead - bytesRead, nextPosition + bytesRead);
-				if (result.bytesRead === 0) return snapshot;
-				bytesRead += result.bytesRead;
-			}
+			const bytesRead = await readFileWindowFully(handle, chunk, nextPosition);
+			if (bytesRead < bytesToRead) return snapshot;
 			let lineEnd = bytesRead;
 			while (lineEnd > 0) {
 				const index = chunk.lastIndexOf(10, lineEnd - 1);
@@ -3258,9 +3164,6 @@ function readCodexAppServerRolloutTokenSnapshotLine(line) {
 function readCompactionConfig(config) {
 	return isJsonObject(config?.agents?.defaults?.compaction) ? config.agents.defaults.compaction : void 0;
 }
-function resolveCodexAppServerNativeThreadReserveTokens(_config) {
-	return CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
-}
 function resolveCodexAppServerNativeThreadTokenFuse(params) {
 	const projectedTurnTokens = typeof params.projectedTurnTokens === "number" && Number.isFinite(params.projectedTurnTokens) && params.projectedTurnTokens > 0 ? Math.floor(params.projectedTurnTokens) : 0;
 	const contextWindow = params.modelContextWindow ?? CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS;
@@ -3273,11 +3176,6 @@ function maxFiniteNumber(values) {
 	if (nums.length === 0) return;
 	return Math.max(...nums);
 }
-function minFiniteNumber(values) {
-	const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value));
-	if (nums.length === 0) return;
-	return Math.min(...nums);
-}
 function hasContextEngineThreadBootstrapProjection(binding) {
 	return binding.contextEngine?.projection?.mode === "thread_bootstrap";
 }
@@ -3286,7 +3184,6 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const binding = params.binding;
 	if (!binding?.threadId) return { binding };
 	if (binding.connectionScope === "supervision") return { binding };
-	const sessionRecord = await readCodexSessionRecordForSessionFile(params.sessionFile);
 	const rolloutFiles = await listCodexAppServerRolloutFilesForThread(params.agentDir, binding.threadId, params.codexHome, binding.rolloutPath);
 	const maxBytes = parseCodexAppServerByteLimit(readCompactionConfig(params.config)?.maxActiveTranscriptBytes);
 	if (maxBytes !== void 0 && params.contextEngineActive === true && hasContextEngineThreadBootstrapProjection(binding)) embeddedAgentLog.debug("codex app-server deferring native transcript byte guard for context-engine thread bootstrap", {
@@ -3320,25 +3217,19 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const nativeTokenSnapshots = await Promise.all(rolloutFiles.map(async (file) => readCodexAppServerRolloutTokenSnapshot(file.path, file.handle)));
 	const nativeTokens = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.totalTokens));
 	const nativeModelContextWindow = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.modelContextWindow));
-	const sessionModelContextWindow = typeof sessionRecord?.contextTokens === "number" && Number.isFinite(sessionRecord.contextTokens) && sessionRecord.contextTokens > 0 ? Math.floor(sessionRecord.contextTokens) : void 0;
-	const reserveTokens = resolveCodexAppServerNativeThreadReserveTokens(params.config);
+	const reserveTokens = CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
 	const maxTokens = resolveCodexAppServerNativeThreadTokenFuse({
-		modelContextWindow: minFiniteNumber([nativeModelContextWindow, sessionModelContextWindow]),
+		modelContextWindow: nativeModelContextWindow,
 		reserveTokens,
 		projectedTurnTokens: params.projectedTurnTokens
 	});
-	const sessionTokens = sessionRecord?.totalTokensFresh === true && sessionRecord.totalTokensVersion === 1 && typeof sessionRecord?.totalTokens === "number" && Number.isFinite(sessionRecord.totalTokens) ? sessionRecord.totalTokens : void 0;
-	const tokenCount = maxFiniteNumber([sessionTokens, nativeTokens]);
-	if (tokenCount !== void 0 && tokenCount >= maxTokens) {
+	if (nativeTokens !== void 0 && nativeTokens >= maxTokens) {
 		assertCodexBindingMayBeReplaced(binding, "rotating a full native context", params.expectedSessionRuntimeOwnership);
 		embeddedAgentLog.warn("codex app-server native transcript exceeded active token limit; starting a fresh thread", {
 			threadId: binding.threadId,
 			maxTokens,
-			sessionKey: sessionRecord?.sessionKey,
-			sessionTokens,
 			nativeTokens,
 			nativeModelContextWindow,
-			sessionModelContextWindow,
 			reserveTokens,
 			projectedTurnTokens: params.projectedTurnTokens
 		});
@@ -3348,10 +3239,9 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 		}, params.assertCurrent);
 		return { binding: void 0 };
 	}
-	const startupContextTokens = nativeModelContextWindow ?? sessionModelContextWindow;
 	return {
 		binding,
-		...startupContextTokens ? { startupContextTokens } : {}
+		...nativeModelContextWindow ? { startupContextTokens: nativeModelContextWindow } : {}
 	};
 }
 //#endregion
@@ -3473,7 +3363,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const usesSupervisionConnection = startupBinding?.connectionScope === "supervision";
 	if (usesSupervisionConnection) activeContextEngine = void 0;
 	if (usesSupervisionConnection && pluginConfig.supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
-	const resolveRuntimeOptionsForBinding = (binding, selection) => resolveCodexBindingAppServerConnection({
+	const resolveRuntimeOptionsForBinding = async (binding, selection) => (await resolveCodexBindingAppServerConnection({
 		binding,
 		pluginConfig,
 		execPolicy,
@@ -3483,8 +3373,9 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		agentDir,
 		requirementsToml,
 		openClawSandboxActive: sandbox?.enabled === true,
-		sessionPermissionMode: params.permissionMode
-	}).appServer;
+		sessionPermissionMode: params.permissionMode,
+		assertCurrent
+	})).appServer;
 	const initialStartupBindingHadInactiveThreadBootstrap = isInactiveThreadBootstrapBinding(startupBinding);
 	const appServerHomeScope = resolveCodexAppServerHomeScope({ appServer: pluginConfig.appServer });
 	const preparedAuthRoute = usesSupervisionConnection ? void 0 : params.runtimePlan?.auth.modelRoute;
@@ -3527,7 +3418,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	};
 	let reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
 	preDynamicStartupStages.mark("auth-profile");
-	let configuredAppServer = resolveRuntimeOptionsForBinding(startupBinding, {
+	let configuredAppServer = await resolveRuntimeOptionsForBinding(startupBinding, {
 		modelProvider: reviewerPolicyContext.modelProvider,
 		model: reviewerPolicyContext.model
 	});
@@ -3626,9 +3517,8 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			binding: startupBinding,
 			bindingStore,
 			identity: bindingIdentity,
-			sessionFile: params.sessionFile,
 			agentDir,
-			codexHome: appServer.start.env?.CODEX_HOME,
+			codexHome: appServer.start.codexHome ?? appServer.start.env?.CODEX_HOME,
 			config: params.config,
 			contextEngineActive: Boolean(activeContextEngine),
 			expectedSessionRuntimeOwnership: params.expectedSessionRuntimeOwnership
@@ -3638,7 +3528,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		preDynamicStartupStages.mark("rotate-binding");
 		if (startupBinding !== startupBindingBeforeRotation) {
 			reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
-			configuredAppServer = resolveRuntimeOptionsForBinding(startupBinding, {
+			configuredAppServer = await resolveRuntimeOptionsForBinding(startupBinding, {
 				modelProvider: reviewerPolicyContext.modelProvider,
 				model: reviewerPolicyContext.model
 			});
@@ -3666,7 +3556,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			pluginAppServer: appServer,
 			continuityCalibration: startupBindingBeforeRotation?.continuityCalibration
 		};
-		const resolveRuntimeOptionsForCurrentBinding = (selection) => resolveFinalAppServer(resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection).appServer;
+		const resolveRuntimeOptionsForCurrentBinding = async (selection) => resolveFinalAppServer(await resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection).appServer;
 		assertCurrent();
 		return {
 			params,
@@ -3723,19 +3613,327 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	}
 }
 //#endregion
-//#region extensions/codex/src/app-server/run-attempt-state.ts
-async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields, expected) {
-	const currentBinding = bindingStore.read(identity);
-	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
-	if (!expectedThreadId) return;
-	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
-		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
-			...fields,
-			boundThreadId: currentBinding.threadId
-		});
+//#region extensions/codex/src/app-server/attempt-context.ts
+/**
+* Builds Codex app-server prompt context,
+* system-prompt reports, and context-engine projection decisions.
+*/
+/** Reads mirrored Codex session history for harness hooks. */
+async function readMirroredSessionHistoryMessages(params) {
+	const { admission, signal, contextTokenBudget, ...target } = params;
+	const messages = await readCodexMirroredSessionHistoryMessages(target, admission, signal, contextTokenBudget);
+	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;
 	}
-	if (expected || currentBinding?.connectionScope === "supervision") {
+	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"
+	};
+}
+/**
+* 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 ?? [],
+			omitReferenceFiles: params.omitWorkspaceReferences,
+			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 === "memory.md" && 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 omitted = memoryToolRoutedFile || params.omitReferenceFiles && readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) !== void 0;
+		const injectedChars = omitted ? 0 : injected?.length ?? 0;
+		const truncated = omitted ? 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))
+	});
+}
+/** 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()
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/run-attempt-state.ts
+async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields, expected) {
+	const currentBinding = bindingStore.read(identity);
+	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
+	if (!expectedThreadId) return;
+	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
+		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
+			...fields,
+			boundThreadId: currentBinding.threadId
+		});
+		return;
+	}
+	if (expected || currentBinding?.connectionScope === "supervision") {
 		embeddedAgentLog.warn("codex app-server image payload error detected for native-owned thread; preserving binding", fields);
 		return;
 	}
@@ -3784,6 +3982,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		const messages = await readMirroredSessionHistoryMessages({
 			...activeTranscriptTarget,
 			signal: connection.runAbortController.signal,
+			contextTokenBudget: effectiveContextTokenBudget,
 			...transcriptReadFence ? { admission: transcriptReadFence } : {}
 		});
 		connection.runAbortController.signal.throwIfAborted();
@@ -3853,9 +4052,11 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		});
 		historyState.messages = await readFencedHistory() ?? historyState.messages;
 	}
+	historyState.messages.push(...params.pluginRuntimeRefreshMessages ?? []);
 	const memoryToolNames = getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs);
 	const workspaceBootstrapContext = await buildCodexWorkspaceBootstrapContext({
 		params: runtimeParams,
+		agentWorkspaceDeveloperInstructions: connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions,
 		resolvedWorkspace: runtimeParams.bootstrapWorkspaceDir ?? resolvedWorkspace,
 		executionWorkspace: resolvedWorkspace,
 		effectiveWorkspace,
@@ -3865,7 +4066,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		ringZeroActive: isHostScopedAgentToolActive("openclaw") && isSystemAgentOnlyCodexDynamicToolAllowlist(runtimeParams.toolsAllow),
 		sandboxed: sandbox?.enabled === true
 	});
-	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions ? connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions ?? workspaceBootstrapContext.threadDeveloperInstructions : void 0;
+	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions;
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
 	const watchedSessionsContext = buildCodexWatchedSessionsContext({
 		attempt: runtimeParams,
@@ -4102,6 +4303,28 @@ 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/run-attempt-reply-media.ts
+async function settleReplyMedia(activeTurn, result, { state, settlementExpired }, signal) {
+	if (activeTurn.prepareReplyMedia && !signal.aborted) {
+		state.pendingSettlementStage = "reply/media";
+		const transferAbort = new AbortController();
+		settlementExpired.then(() => transferAbort.abort(/* @__PURE__ */ new Error("Reply media settlement expired")));
+		try {
+			const prepared = await activeTurn.prepareReplyMedia({
+				kind: "attempt",
+				attempt: result
+			}, transferAbort.signal);
+			if (prepared.kind !== "attempt") throw new Error("Reply media preparation returned the wrong result kind");
+			result.preparedReplyMedia = prepared.preparedMedia;
+		} catch (error) {
+			if (!signal.aborted) throw error;
+		} finally {
+			transferAbort.abort();
+		}
+	}
+	if (signal.aborted) await state.abortCleanup;
+}
+//#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
 /** Creates a trajectory recorder when the host exposes its capture capability. */
 function createCodexTrajectoryRecorder(params) {
@@ -4219,6 +4442,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		clearTimeout(drainGraceTimer);
 		deadlines.dispose();
 	};
+	if (state.pluginRuntimeRefreshStop) await state.pluginRuntimeRefreshStop.catch(() => void 0);
 	const settlement = drainNotificationQueue().then(async () => {
 		await closeProjection();
 		await activeProjector.settlement.drain();
@@ -4238,7 +4462,10 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		} finally {
 			if (!state.projectionClosed) await resources.runCleanupStep("codex-transcript-checkpoint", closeProjection);
 		}
-		const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected: toolState.yieldDetected });
+		const result = activeProjector.buildResult(toolBridge.telemetry, {
+			yieldDetected: toolState.yieldDetected,
+			steeringMessages: params.pluginRuntimeRefreshPending?.() ? turnRuntime.steeringQueueRef.current?.getAcceptedMessages() : void 0
+		});
 		const projectedTerminal = attemptTerminal.project(result.terminal);
 		const isFinalAborted = () => terminalState.explicitCancellationObserved || !resourceState.executionDisconnectError && (projectedTerminal.aborted || runAbortController.signal.aborted && !state.clientClosedAbort);
 		const currentPromptError = (fallback) => resourceState.executionDisconnectError ?? state.clientClosedPromptError ?? (state.timeout ? `codex app-server ${state.timeout.kind === "execution" ? "execution budget" : "terminal settlement"} timed out` : fallback);
@@ -4399,7 +4626,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 					degradedSettlement
 				]);
 			}
-			if (runAbortController.signal.aborted) await state.abortCleanup;
+			await settleReplyMedia(activeTurn, result, turnRuntime, runAbortController.signal);
 		} finally {
 			closeSettlement();
 		}
@@ -4483,7 +4710,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			hookRunner
 		});
 		state.shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
-		if (turnSucceeded && !runAbortController.signal.aborted) try {
+		if (turnSucceeded && !runAbortController.signal.aborted && !state.pluginRuntimeRefreshStop) try {
 			const continuityCalibration = context.promptState.noEngineContinuityProjectionApplied ? buildCodexContinuityCalibration({
 				promptChars: prompt.turnState.codexTurnPromptText.length,
 				inputTokens: result.attemptUsage?.contextUsage?.state === "available" ? result.attemptUsage.contextUsage.promptTokens ?? 0 : 0
@@ -4528,27 +4755,30 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		});
 		markTrajectoryEndRecorded();
 		const terminalAssistantText = collectTerminalAssistantText(result);
-		if (terminalAssistantText && (!streamState.eventEmitted || streamState.needsTerminalSnapshot) && !finalAborted && !finalPromptError) emitCodexAppServerEvent(params, {
+		if (terminalAssistantText && (assistantTranscriptIdempotencyKey || (!streamState.eventEmitted || streamState.needsTerminalSnapshot) && !finalAborted && !finalPromptError)) emitCodexAppServerEvent(params, {
 			stream: "assistant",
-			data: { text: terminalAssistantText }
+			data: {
+				text: terminalAssistantText,
+				...assistantTranscriptIdempotencyKey ? {
+					itemId: assistantTranscriptIdempotencyKey,
+					replace: true,
+					replaceable: true
+				} : {}
+			}
 		});
-		emitLifecycleTerminal(finalPromptError ? {
-			phase: "error",
-			error: formatErrorMessage(finalPromptError),
-			...buildLifecycleTerminalMeta({
-				aborted: finalAborted,
-				timedOut: effectiveTimedOut
-			})
-		} : {
-			phase: "end",
+		emitLifecycleTerminal({
+			phase: finalPromptError ? "error" : "end",
+			...finalPromptError ? { error: formatErrorMessage(finalPromptError) } : {},
+			...assistantTranscriptIdempotencyKey ? { assistantTranscriptIdempotencyKey } : {},
 			...buildLifecycleTerminalMeta({
 				aborted: finalAborted,
 				timedOut: effectiveTimedOut,
-				yielded: toolState.yieldDetected
+				yielded: finalPromptError ? void 0 : toolState.yieldDetected
 			})
 		});
 		const finalizedResult = Object.assign(result, {
 			...runtimeModelSelection ? { runtimeModelSelection } : {},
+			...turnSucceeded && params.pluginRuntimeRefreshPending?.() ? { pluginRuntimeRefreshMessages: params.suppressNextUserMessagePersistence && !params.pluginRuntimeRefreshMessages ? [params.userTurnTranscriptRecorder?.getPersistedMessage?.() ?? buildCodexUserPromptMessage(params), ...result.messagesSnapshot] : result.messagesSnapshot } : {},
 			...toolState.yieldAcknowledgment ? { yieldAcknowledgment: toolState.yieldAcknowledgment } : {},
 			...codexAppServerFailure ? { codexAppServerFailure } : {},
 			...promptTimeoutOutcome ? { promptTimeoutOutcome } : {},
@@ -4675,7 +4905,7 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		state.pendingTerminalDynamicToolRelease = value;
 		scheduleTerminalDynamicToolReleaseCheck();
 	};
-	const emitLifecycleStart = () => {
+	const emitLifecycleStart = (model) => {
 		emitCodexAppServerEvent(params, {
 			stream: "lifecycle",
 			data: {
@@ -4683,10 +4913,17 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 				startedAt: attemptStartedAt
 			}
 		});
+		emitCodexAppServerEvent(params, {
+			stream: "lifecycle",
+			data: {
+				phase: "model",
+				...model
+			}
+		});
 		state.lifecycleStarted = true;
 	};
 	const emitLifecycleTerminal = (data) => {
-		if (!state.lifecycleStarted || state.lifecycleTerminalEmitted || state.permissionChangeRestart) return;
+		if (!state.lifecycleStarted || state.lifecycleTerminalEmitted || state.permissionChangeRestart || params.pluginRuntimeRefreshPending?.()) return;
 		emitCodexAppServerEvent(params, {
 			stream: "lifecycle",
 			data: {
@@ -4784,13 +5021,29 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-notification-controller.ts
 function createCodexAttemptNotificationController(resources, turnRuntime, lifecycle) {
-	const { prompt, state: resourceState, projectorRef, registerNativeSubagentMonitor } = resources;
+	const { prompt, state: resourceState, projectorRef } = resources;
 	const { context, turnState } = prompt;
 	const { attemptTools, runtime } = context;
 	const { appServer, runAbortController } = runtime.connection;
 	const { allocateCodexToolOutcomeOrdinal } = attemptTools;
-	const { state, turnIdRef, userInputBridgeRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, openClawDynamicToolExecutions, completeTurn, noteProgress, deadlines } = turnRuntime;
+	const { state, turnIdRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, openClawDynamicToolExecutions, completeTurn, noteProgress, deadlines } = turnRuntime;
 	const { scheduleTerminalDynamicToolReleaseCheck, reportExecutionNotification, maybeAnnounceFastModeAutoOff } = lifecycle;
+	const pendingNativeCommandItems = /* @__PURE__ */ new Set();
+	const nativeItemObservers = /* @__PURE__ */ new Set();
+	const waitForNativeTerminalItems = async (signal) => {
+		if (pendingNativeCommandItems.size === 0) return;
+		const completion = createDeferred();
+		const observe = () => {
+			if (pendingNativeCommandItems.size === 0) completion.resolve();
+		};
+		nativeItemObservers.add(observe);
+		try {
+			observe();
+			if (!await waitForPromiseOrAbort(completion.promise, signal)) signal.throwIfAborted();
+		} finally {
+			nativeItemObservers.delete(observe);
+		}
+	};
 	const isTerminalTurnNotificationForTurn = (notification, notificationTurnId) => isTerminalCodexTurnNotificationForTurn({
 		notification,
 		threadId: resourceState.thread.threadId,
@@ -4800,7 +5053,6 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		if (state.projectionClosed) return;
 		const projector = projectorRef.current;
 		const turnId = turnIdRef.current;
-		userInputBridgeRef.current?.handleNotification(notification);
 		if (!projector || !turnId) {
 			if (notification.method === "error") state.latestStartupErrorNotification = notification;
 			return;
@@ -4845,6 +5097,11 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			});
 		} finally {
 			state.activeLocalProjections -= 1;
+			if (isCurrentTurn && notification.method === "item/completed") {
+				const item = readCodexNotificationItem(notification.params);
+				if (item?.type === "commandExecution" && typeof item.id === "string") pendingNativeCommandItems.delete(item.id);
+			}
+			for (const observe of nativeItemObservers) observe();
 			if (isTerminal) {
 				if ((readCodexTurnCompletedNotification(notification.params)?.turn)?.status === "interrupted" && state.sawCodexInterruptMarker) projector.markAborted();
 				completeTurn();
@@ -4883,6 +5140,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			const modelToolCallId = readRawResponseToolCallId(notification);
 			if (modelToolCallId) allocateCodexToolOutcomeOrdinal?.(modelToolCallId);
 			const nativeItem = readCodexNotificationItem(notification.params);
+			if (notification.method === "item/started" && nativeItem?.type === "commandExecution" && typeof nativeItem.id === "string") pendingNativeCommandItems.add(nativeItem.id);
 			if (nativeItem?.type === "webSearch") {
 				projector.settlement.turnTainted ||= notification.method === "item/completed";
 				projector.recordNativeToolOutcome(nativeItem);
@@ -4899,9 +5157,9 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const drainNotificationQueue = async () => {
 		await resourceState.turnRoute?.drain();
 	};
-	registerNativeSubagentMonitor(resourceState.thread.threadId);
 	return {
 		waitForActiveNativeTurnCompletion,
+		waitForNativeTerminalItems,
 		noteNotificationReceived,
 		enqueueNotification,
 		drainNotificationQueue
@@ -4917,13 +5175,24 @@ async function prepareCodexAttemptPrompt(context) {
 	const { connection, buildActiveRunAttemptParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
 	const { params, activeContextEngine, usesSupervisionConnection, mutable, isInactiveThreadBootstrapBinding, bindingStore, bindingIdentity, agentDir, appServer, contextSessionKey, effectiveWorkspace, sandbox } = connection;
 	const { toolBridge } = attemptTools;
-	let contextImages = [];
-	const currentUserTurnIdempotencyKey = params.userTurnTranscriptRecorder?.message?.idempotencyKey;
+	const nativeHistoryProvenancePrefix = params.trigger === "user" ? buildCodexHistoryProvenancePrefix(params) : void 0;
+	const forkedSession = !mutable.startupBinding?.threadId && params.sessionTarget ? getSessionEntry({
+		...params.sessionTarget,
+		sessionKey: contextSessionKey,
+		hydrateSkillPromptRefs: false,
+		readConsistency: "latest"
+	}) : void 0;
+	const preserveForkedToolResults = Boolean(forkedSession?.sessionId === params.sessionId && forkedSession.createdVia === "spawn" && forkedSession.parentSessionKey && forkedSession.parentSessionKey !== contextSessionKey && forkedSession.forkSource?.sessionKey === forkedSession.parentSessionKey && forkedSession.forkSource.sessionId !== params.sessionId);
+	let contextImageGroups = [];
+	let turnContextImageGroups = [];
 	const assertProjectionCurrent = () => {
 		params.hostCapabilities.assertActive();
 		connection.assertCurrent();
 		connection.runAbortController.signal.throwIfAborted();
 	};
+	const admittedMessage = params.userTurnTranscriptRecorder?.message ?? await params.userTurnTranscriptRecorder?.resolveMessage();
+	assertProjectionCurrent();
+	const currentUserTurnIdempotencyKey = params.pluginRuntimeRefreshMessages ? void 0 : admittedMessage?.idempotencyKey;
 	const prepareFileContext = async (message, maxChars) => {
 		const prepare = params.hostCapabilities.prepareContextMedia;
 		if (!prepare) {
@@ -4949,11 +5218,12 @@ async function prepareCodexAttemptPrompt(context) {
 			originalHistoryMessages: historyState.messages,
 			prompt: params.prompt,
 			maxRenderedContextChars: codexContinuityProjectionMaxChars,
+			toolPayloadMode: params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
 			prepareFileContext,
 			currentUserTurnIdempotencyKey
 		});
 		assertProjectionCurrent();
-		contextImages = projection.images ?? [];
+		contextImageGroups = projection.imageGroups ?? [];
 		promptState.promptText = projection.promptText;
 		promptState.promptContextRange = projection.promptContextRange;
 		promptState.prePromptMessageCount = projection.prePromptMessageCount;
@@ -4998,12 +5268,12 @@ async function prepareCodexAttemptPrompt(context) {
 			prompt: params.prompt,
 			systemPromptAddition: assembled.systemPromptAddition,
 			maxRenderedContextChars: codexContextProjectionMaxChars,
-			toolPayloadMode: contextEngineProjection ? "preserve" : "elide",
+			toolPayloadMode: contextEngineProjection || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
 			...projectionDecision.project ? { prepareFileContext } : {},
 			currentUserTurnIdempotencyKey
 		});
 		assertProjectionCurrent();
-		contextImages = projectionDecision.project ? projection.images ?? [] : [];
+		contextImageGroups = projectionDecision.project ? projection.imageGroups ?? [] : [];
 		const decisionBinding = decisionStartupBinding;
 		embeddedAgentLog.info("codex app-server context-engine projection decision", {
 			sessionId: params.sessionId,
@@ -5031,13 +5301,17 @@ async function prepareCodexAttemptPrompt(context) {
 	if (activeContextEngine) try {
 		await applyActiveContextEngineProjection(runtime.nativeToolSurfaceEnabled ? mutable.startupBinding : void 0);
 	} catch (assembleErr) {
-		if (assembleErr instanceof CodexContextAttachmentError) throw assembleErr;
+		if (assembleErr instanceof CodexContextAttachmentError || params.pluginRuntimeRefreshMessages) throw assembleErr;
 		assertProjectionCurrent();
 		embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 	}
 	const codexModelInputHistoryMessages = [];
+	const admittedContent = admittedMessage?.content;
+	const currentUserMessage = admittedMessage ? typeof admittedContent === "string" ? admittedContent : (admittedContent ?? []).flatMap((part) => part.type === "text" ? [part.text] : []).join("\n") : params.pluginRuntimeRefreshMessages ? "" : params.prompt;
 	const buildPromptFromCurrentInputs = async () => {
 		return await resolveAgentHarnessBeforePromptBuildResult({
+			currentUserMessage,
+			currentUserMessageId: admittedMessage?.idempotencyKey,
 			prompt: prependCurrentInboundContext(promptState.promptText, params.currentInboundContext),
 			developerInstructions: { build: ({ toolsAllow }) => {
 				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.");
@@ -5087,12 +5361,21 @@ async function prepareCodexAttemptPrompt(context) {
 			promptInputRange: promptBuildResult.promptInputRange,
 			decoratedPrompt: turnPromptText
 		});
-		return fitCodexProjectedContextForTurnStart({
+		const imageOffset = projectedRanges && promptState.promptContextRange ? projectedRanges.contextRange.start - promptState.promptContextRange.start : void 0;
+		const fitted = fitCodexProjectedContextForTurnStart({
 			promptText: turnPromptText,
+			maxChars: CODEX_TURN_START_TEXT_INPUT_MAX_CHARS - (nativeHistoryProvenancePrefix?.length ?? 0),
 			contextRange: projectedRanges?.contextRange,
 			requestRange: projectedRanges?.requestRange,
-			preservedRange
+			preservedRange,
+			imageGroups: imageOffset === void 0 ? [] : contextImageGroups.map((group) => ({
+				images: group.images,
+				start: group.start + imageOffset,
+				end: group.end + imageOffset
+			}))
 		});
+		turnContextImageGroups = fitted.imageGroups ?? [];
+		return fitted.promptText;
 	};
 	const firstPromptBuild = await buildPromptFromCurrentInputs();
 	const turnState = {
@@ -5148,8 +5431,8 @@ async function prepareCodexAttemptPrompt(context) {
 		return projected;
 	};
 	const applyNoContextEngineContinuityProjection = async (action, binding) => {
-		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
-		if (activeContextEngine || !hasContinuity) return false;
+		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary" || message.role === "assistant" && message.content.some((part) => part.type === "text" && part.text.trim())));
+		if (activeContextEngine || !hasContinuity && !params.pluginRuntimeRefreshMessages?.length) return false;
 		if (action === "resumed" && promptState.precomputedStaleBindingContinuityProjectionApplied) return true;
 		if (action === "started" && promptState.staleBindingContinuityForcedFreshStart) return true;
 		if (action === "started" && promptState.inactiveThreadBootstrapBindingForcedFreshStart) return false;
@@ -5171,9 +5454,8 @@ async function prepareCodexAttemptPrompt(context) {
 			binding,
 			bindingStore,
 			identity: bindingIdentity,
-			sessionFile: params.sessionFile,
 			agentDir,
-			codexHome: appServer.start.env?.CODEX_HOME,
+			codexHome: appServer.start.codexHome ?? appServer.start.env?.CODEX_HOME,
 			config: params.config,
 			contextEngineActive: Boolean(activeContextEngine),
 			expectedSessionRuntimeOwnership: params.expectedSessionRuntimeOwnership,
@@ -5193,7 +5475,7 @@ async function prepareCodexAttemptPrompt(context) {
 			try {
 				await applyActiveContextEngineProjection(void 0);
 			} catch (assembleErr) {
-				if (assembleErr instanceof CodexContextAttachmentError) throw assembleErr;
+				if (assembleErr instanceof CodexContextAttachmentError || params.pluginRuntimeRefreshMessages) throw assembleErr;
 				assertProjectionCurrent();
 				embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 			}
@@ -5222,10 +5504,11 @@ async function prepareCodexAttemptPrompt(context) {
 	let workspaceReferencesIncluded = true;
 	return {
 		context,
-		get contextImages() {
-			return contextImages;
+		get contextImageGroups() {
+			return turnContextImageGroups;
 		},
 		codexModelInputHistoryMessages,
+		nativeHistoryProvenancePrefix,
 		turnState,
 		refreshWorkspaceReferences: (include) => {
 			turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild, include);
@@ -5266,6 +5549,13 @@ function prepareCodexAttemptResources(prompt) {
 	const { connection, hookChannelId } = runtime;
 	const { appServer, params, effectiveCwd, sessionAgentId, contextSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
 	const { toolBridge } = attemptTools;
+	let nativeProcessAuthorityReleased = false;
+	const releaseNativeProcessAuthority = () => {
+		if (!nativeProcessAuthorityReleased) {
+			nativeProcessAuthorityReleased = true;
+			nativeProcessAuthority?.release();
+		}
+	};
 	const trajectoryRecorder = createCodexTrajectoryRecorder({
 		attempt: params,
 		cwd: effectiveCwd,
@@ -5290,6 +5580,7 @@ function prepareCodexAttemptResources(prompt) {
 		nativePreToolUseFailureFallbackTerminalReason: void 0,
 		releaseSharedClientLease: void 0,
 		startupClientUnsafe: false,
+		turnStartAttempted: false,
 		sharedCodexClientRetiredForOneShotCleanup: false,
 		sandboxExecEnvironment: void 0,
 		executionDisconnectError: void 0,
@@ -5380,12 +5671,16 @@ function prepareCodexAttemptResources(prompt) {
 			await operation();
 		}
 	});
-	const unregisterNativeSubagentMonitor = () => {
-		state.nativeSubagentMonitor?.unregister();
+	let nativeSubagentMonitorSettlement;
+	const unregisterNativeSubagentMonitor = async () => {
+		const registration = state.nativeSubagentMonitor;
 		state.nativeSubagentMonitor = void 0;
+		if (registration) nativeSubagentMonitorSettlement = registration.unregister();
+		await nativeSubagentMonitorSettlement;
 	};
-	const registerNativeSubagentMonitor = (parentThreadId) => {
-		unregisterNativeSubagentMonitor();
+	const registerNativeSubagentMonitor = async (parentThreadId) => {
+		await unregisterNativeSubagentMonitor();
+		connection.assertCurrent();
 		const sessionKey = params.sessionKey;
 		const storePath = params.sessionTarget?.storePath;
 		const parentSession = sessionKey && storePath ? getSessionEntry({
@@ -5395,17 +5690,46 @@ function prepareCodexAttemptResources(prompt) {
 			readConsistency: "latest",
 			hydrateSkillPromptRefs: false
 		}) : void 0;
+		const historyOwner = createCodexNativeSubagentHistoryOwner({
+			parentThreadId,
+			sessionId: params.sessionId,
+			...parentSession?.sessionId === params.sessionId ? { lifecycleRevision: parentSession.lifecycleRevision } : {},
+			binding: state.thread
+		});
+		const { bindingStore, bindingIdentity } = connection;
+		const submissionStore = historyOwner ? {
+			assertCurrent: () => {
+				const current = bindingStore.read(bindingIdentity);
+				if (!current || !matchesCodexNativeSubagentSubmissionBinding(current, historyOwner)) throw new Error("Native submission binding is no longer current.");
+				if (historyOwner.lifecycleRevision && sessionKey && storePath) {
+					if (getSessionEntry({
+						agentId: sessionAgentId,
+						sessionKey,
+						storePath,
+						readConsistency: "latest",
+						hydrateSkillPromptRefs: false
+					})?.lifecycleRevision !== historyOwner.lifecycleRevision) throw new Error("Native submission session lifecycle is no longer current.");
+				}
+			},
+			read: () => bindingStore.readNativeSubagentSubmissions(bindingIdentity, historyOwner),
+			record: (receipt, assertCurrent) => bindingStore.mutate(bindingIdentity, {
+				kind: "record-native-subagent-submission",
+				owner: historyOwner,
+				receipt
+			}, assertCurrent),
+			consume: (receipt, assertCurrent) => bindingStore.mutate(bindingIdentity, {
+				kind: "consume-native-subagent-submission",
+				owner: historyOwner,
+				receipt
+			}, assertCurrent)
+		} : void 0;
 		state.nativeSubagentMonitor = codexNativeSubagentMonitorRuntime.register({
 			client: state.client,
 			parentThreadId,
 			requesterSessionKey: params.sessionKey,
 			taskRuntimeScope: params.agentHarnessTaskRuntimeScope,
-			historyOwner: createCodexNativeSubagentHistoryOwner({
-				parentThreadId,
-				sessionId: params.sessionId,
-				...parentSession?.sessionId === params.sessionId ? { lifecycleRevision: parentSession.lifecycleRevision } : {},
-				binding: state.thread
-			}),
+			historyOwner,
+			submissionStore,
 			agentId: sessionAgentId,
 			retainClient: () => retainSharedCodexAppServerClientIfCurrent(state.client),
 			retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(state.client, protectedThreadId),
@@ -5416,7 +5740,7 @@ function prepareCodexAttemptResources(prompt) {
 			} } : {}
 		});
 	};
-	const releaseCurrentRoute = () => {
+	const releaseCurrentRoute = async () => {
 		state.releaseInferenceContext?.();
 		state.releaseInferenceContext = void 0;
 		state.detachRouteAbort();
@@ -5424,7 +5748,89 @@ function prepareCodexAttemptResources(prompt) {
 		state.turnRoute?.release();
 		state.turnRoute = void 0;
 		state.routeActivated = false;
-		unregisterNativeSubagentMonitor();
+		await unregisterNativeSubagentMonitor();
+	};
+	let subscriptionSettlement;
+	const retainThreadSubscription = async () => {
+		const { client, thread } = state;
+		if (subscriptionSettlement?.thread === thread) return subscriptionSettlement.retained;
+		if (!thread || thread.clientId !== resolveCodexAppServerClientInstanceId(client)) return false;
+		const { bindingStore, bindingIdentity } = connection;
+		const retained = await bindingStore.withLease(bindingIdentity, async () => {
+			if (!isSameCodexAppServerThreadOwner(bindingStore.read(bindingIdentity), thread)) return false;
+			try {
+				if (!state.turnStartAttempted) runAbortController.signal.throwIfAborted();
+				if (!hasCodexNativeBackgroundProcesses(client, thread.threadId)) {
+					params.hostCapabilities.assertActive();
+					connection.assertCurrent();
+				}
+				thread.liveThreadOwnership?.assertCurrent();
+			} catch {
+				return false;
+			}
+			return await retainCodexAppServerBindingSubscription(client, thread.threadId, {
+				release: thread.liveThreadOwnership?.release,
+				configFingerprint: thread.liveThreadConfigFingerprint,
+				serviceTier: state.turnStartAttempted ? connection.mutable.pluginAppServer.serviceTier : thread.liveThreadOwnership?.serviceTier,
+				ephemeralPolicy: thread.liveThreadEphemeralPolicy
+			});
+		});
+		if (retained) subscriptionSettlement = {
+			thread,
+			retained: true
+		};
+		return retained;
+	};
+	const releaseThreadSubscription = async (assertCurrent) => {
+		const { client, thread } = state;
+		if (!thread || subscriptionSettlement?.thread === thread) return true;
+		subscriptionSettlement = {
+			thread,
+			retained: false
+		};
+		if (thread.liveThreadOwnership) try {
+			await thread.liveThreadOwnership.release(thread.threadId, assertCurrent);
+			return true;
+		} catch (error) {
+			await closeCodexStartupClientBestEffort(client);
+			throw error;
+		}
+		const released = await unsubscribeCodexThreadBestEffort(client, {
+			threadId: thread.threadId,
+			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
+			assertCurrent
+		});
+		if (!released) await closeCodexStartupClientBestEffort(client);
+		return released;
+	};
+	const cleanupBeforeActiveTurn = async () => {
+		await runCleanupStep("codex-pre-turn-hook-fallback", activateNativePreToolUseFailureFallback);
+		await runCleanupStep("codex-pre-turn-subscription", async () => {
+			const { thread } = state;
+			if (!thread || subscriptionSettlement?.thread === thread || state.startupClientUnsafe) return;
+			let retained = false;
+			try {
+				retained = Boolean(!state.turnStartAttempted && !runAbortController.signal.aborted && params.cleanupBundleMcpOnRunEnd !== true && thread.liveThreadOwnership && await retainThreadSubscription());
+			} finally {
+				if (!retained) {
+					if (!isIncognitoSessionKey(params.sessionKey) || await connection.bindingStore.mutate(connection.bindingIdentity, {
+						kind: "clear",
+						threadId: thread.threadId
+					})) await releaseThreadSubscription();
+				}
+			}
+		});
+		await runCleanupStep("codex-pre-turn-route-release", releaseCurrentRoute);
+		const relay = state.nativeHookRelay;
+		state.nativeHookRelay = void 0;
+		await runCleanupStep("codex-pre-turn-native-hook-relay", async () => {
+			relay?.unregister();
+			await relay?.drain();
+		});
+		await runCleanupStep("codex-pre-turn-sandbox-release", releaseSandboxExecEnvironment);
+		await runCleanupStep("codex-pre-turn-source-release", releaseNativeProcessAuthority);
+		await runCleanupStep("codex-pre-turn-trajectory-flush", () => trajectoryRecorder?.flush());
+		await runCleanupStep("codex-pre-turn-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 	};
 	const startupTimeoutMs = resolveCodexStartupTimeoutMs({
 		timeoutMs: params.timeoutMs,
@@ -5432,8 +5838,13 @@ function prepareCodexAttemptResources(prompt) {
 	});
 	const requesterChannel = params.messageChannel ?? params.messageProvider;
 	const requester = buildCodexHookRequester(params);
-	const buildNativeHookRelayFinalConfigPatch = (decision) => {
-		state.nativeHookRelay?.unregister();
+	const buildNativeHookRelayFinalConfigPatch = async (decision) => {
+		const previousRelay = state.nativeHookRelay;
+		previousRelay?.unregister();
+		await previousRelay?.drain();
+		connection.assertCurrent();
+		const requiresProcessAdmission = nativeProcessAuthority && runtime.nativeToolSurfaceEnabled;
+		const relayEvents = requiresProcessAdmission && !nativeHookRelayEvents.includes("pre_tool_use") ? [...nativeHookRelayEvents, "pre_tool_use"] : nativeHookRelayEvents;
 		if (params.pluginHarnessToolPolicyRestricted === true) {
 			state.nativeHookRelay = void 0;
 			return {
@@ -5442,10 +5853,13 @@ function prepareCodexAttemptResources(prompt) {
 			};
 		}
 		state.nativeHookRelay = createCodexNativeHookRelay({
-			options: options.nativeHookRelay,
+			options: requiresProcessAdmission ? {
+				...options.nativeHookRelay,
+				enabled: true
+			} : options.nativeHookRelay,
 			generation: decision.action === "resume" ? decision.binding.nativeHookRelayGeneration : void 0,
 			generationMismatchGraceMs: decision.action === "resume" && !decision.binding.nativeHookRelayGeneration ? CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS : void 0,
-			events: nativeHookRelayEvents,
+			events: relayEvents,
 			agentId: sessionAgentId,
 			sessionId: params.sessionId,
 			sessionKey: contextSessionKey,
@@ -5469,6 +5883,10 @@ function prepareCodexAttemptResources(prompt) {
 			loopDetectionPreToolUseRelay: appServer.loopDetectionPreToolUseRelay,
 			signal: runAbortController.signal,
 			hostCapabilities: params.hostCapabilities,
+			nativeProcessAuthority: requiresProcessAdmission ? {
+				owner: nativeProcessAuthority,
+				client: () => state.client
+			} : void 0,
 			assertCurrent: connection.assertCurrent,
 			onPreToolUseFailure: (failure) => {
 				const projector = projectorRef.current;
@@ -5477,21 +5895,40 @@ function prepareCodexAttemptResources(prompt) {
 				else pendingNativePreToolUseFailures.push(failure);
 			}
 		});
+		await state.nativeHookRelay?.prepareInvocation();
+		connection.assertCurrent();
 		return {
 			configPatch: state.nativeHookRelay ? buildCodexNativeHookRelayConfig({
 				relay: state.nativeHookRelay,
-				events: nativeHookRelayEvents,
+				events: relayEvents,
 				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
 			}) : options.nativeHookRelay?.enabled === false ? buildCodexNativeHookRelayDisabledConfig() : void 0,
 			nativeHookRelayGeneration: state.nativeHookRelay?.generation
 		};
 	};
+	const nativeProcessAuthority = sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority ? new CodexNativeProcessAuthority(params.hostCapabilities, (error) => {
+		const message = formatErrorMessage(error);
+		embeddedAgentLog.warn("codex native background work remains unsettled", {
+			runId: params.runId,
+			sessionId: params.sessionId,
+			error: message
+		});
+		emitCodexAppServerEvent(params, {
+			stream: "codex_app_server.lifecycle",
+			data: {
+				phase: "background_cleanup_failed",
+				error: message
+			}
+		});
+	}) : void 0;
 	return {
 		prompt,
 		trajectoryRecorder,
 		state,
 		projectorRef,
 		pendingNativePreToolUseFailures,
+		nativeProcessAuthority,
+		releaseNativeProcessAuthority,
 		markTrajectoryEndRecorded: () => {
 			state.trajectoryEndRecorded = true;
 		},
@@ -5502,6 +5939,9 @@ function prepareCodexAttemptResources(prompt) {
 		runCleanupStep,
 		registerNativeSubagentMonitor,
 		releaseCurrentRoute,
+		retainThreadSubscription,
+		releaseThreadSubscription,
+		cleanupBeforeActiveTurn,
 		startupTimeoutMs,
 		buildNativeHookRelayFinalConfigPatch
 	};
@@ -5509,7 +5949,7 @@ function prepareCodexAttemptResources(prompt) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-route.ts
 async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, handleServerRequest) {
-	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, registerNativeSubagentMonitor, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseOnce } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, registerNativeSubagentMonitor } = resources;
 	const { connection } = prompt.context.runtime;
 	const { runAbortController } = connection;
 	const { state, turnIdRef, completeTurn } = turnRuntime;
@@ -5542,12 +5982,12 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 	};
 	const ensureCurrentThreadRoute = async () => {
 		if (resourceState.turnRoute?.threadId !== resourceState.thread.threadId) {
-			releaseCurrentRoute();
+			await releaseCurrentRoute();
 			resourceState.turnRoute = resourceState.turnRouter.reserveThread({ threadId: resourceState.thread.threadId });
 		}
 		if (!resourceState.turnRoute) throw new Error("codex app-server turn route was not reserved");
 		if (!resourceState.routeActivated) {
-			if (!resourceState.nativeSubagentMonitor) registerNativeSubagentMonitor(resourceState.thread.threadId);
+			if (!resourceState.nativeSubagentMonitor) await registerNativeSubagentMonitor(resourceState.thread.threadId);
 			resourceState.detachRouteAbort = attachRouteAbort(resourceState.turnRoute);
 			await resourceState.turnRoute.activate({
 				onNotificationReceived: noteNotificationReceived,
@@ -5558,16 +5998,7 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 		}
 		return resourceState.turnRoute;
 	};
-	try {
-		await ensureCurrentThreadRoute();
-	} catch (error) {
-		activateNativePreToolUseFailureFallback();
-		releaseCurrentRoute();
-		resourceState.nativeHookRelay?.unregister();
-		await releaseSandboxExecEnvironment();
-		releaseSharedClientLeaseOnce();
-		throw error;
-	}
+	await ensureCurrentThreadRoute();
 	return { ensureCurrentThreadRoute };
 }
 //#endregion
@@ -5690,7 +6121,7 @@ async function prepareCodexAttemptRuntime(connection) {
 	const authenticatedScheduledMode = params.trigger === "cron" && params.scheduledToolPolicy !== void 0 && Array.isArray(params.toolsAllow);
 	const scheduledConfiguredMcpSurface = authenticatedScheduledMode && (bundleMcpThreadConfig.staticServerNames.length > 0 || mutable.startupBinding?.configuredMcpOwnershipVersion === 1);
 	const cronCreatorAuthorityCapability = params.cronCreatorAuthorityCapability;
-	const hasFreshCreatorAuthority = cronCreatorAuthorityCapability?.active === true && !(cronCreatorAuthorityCapability.controlUiAdmin && cronCreatorAuthorityCapability.callerOrigin.kind === "unknown") && cronCreatorAuthorityCapability.runId === params.runId && !cronCreatorAuthorityCapability.signal.aborted;
+	const hasFreshCreatorAuthority = cronCreatorAuthorityCapability?.active === true && !(cronCreatorAuthorityCapability.managementEntitlement && cronCreatorAuthorityCapability.callerOrigin.kind === "unknown") && cronCreatorAuthorityCapability.runId === params.runId && !cronCreatorAuthorityCapability.signal.aborted;
 	const mayResolveScheduledConfiguredMcpCreatorAuthority = !authenticatedScheduledMode && canResolveScheduledConfiguredMcpCreatorAuthority({
 		trigger: params.trigger,
 		connectionClass: appServer.connectionClass,
@@ -5710,25 +6141,64 @@ async function prepareCodexAttemptRuntime(connection) {
 	});
 	preDynamicStartupStages.mark("bundle-mcp");
 	const sandboxExecServerEnabled = isCodexSandboxExecServerEnabled(pluginConfig, sandbox);
-	const nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
+	let nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
 		agentId: policyAgentId,
 		runtimeSessionKey: sandboxSessionKey,
 		sandboxExecServerEnabled
 	});
+	if (nativeToolSurfaceEnabled && sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority) {
+		const client = await attemptClientFactory({
+			assertCurrent: connection.assertCurrent,
+			startOptions: appServer.start,
+			pluginConfig,
+			...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
+			authRequirement: connection.startupAuthRequirement,
+			authProfileStore: attemptAuthProfileStore,
+			authBindingFingerprint: preparedAuthBinding?.fingerprint,
+			...connection.runtimeArtifactRequest ? {
+				runtimeArtifactMode: "capture",
+				...connection.runtimeArtifactRequest.expected ? { expectedRuntimeArtifact: connection.runtimeArtifactRequest.expected } : {}
+			} : {},
+			agentId: sessionAgentId,
+			agentDir,
+			config: params.config,
+			abandonSignal: runAbortController.signal,
+			timeoutMs: appServer.requestTimeoutMs
+		});
+		try {
+			connection.assertCurrent();
+			await assertCodexNativeHookRelayAllowed(client, runAbortController.signal, appServer.requestTimeoutMs);
+			connection.assertCurrent();
+		} catch (error) {
+			if (!(error instanceof CodexManagedHooksOnlyError)) throw error;
+			connection.assertCurrent();
+			nativeToolSurfaceEnabled = false;
+			embeddedAgentLog.info("Codex managed-only hooks require sandbox-backed OpenClaw tools");
+		} finally {
+			if (attemptClientFactory === createIsolatedCodexAppServerClient) await client.closeAndWait();
+			else releaseLeasedSharedCodexAppServerClient(client);
+		}
+	}
 	const configuredMcpSurface = scheduledConfiguredMcpSurface ? "scheduled" : !nativeToolSurfaceEnabled && bundleMcpThreadConfig.staticServerNames.length > 0 ? "transient" : void 0;
 	preDynamicStartupStages.mark("native-tool-surface");
-	const nativeProviderWebSearchSupport = resolveCodexWebSearchPlan({
+	const webSearchPlan = resolveCodexWebSearchPlan({
 		config: params.config,
 		disableTools: params.disableTools,
 		nativeToolSurfaceEnabled
-	}).kind === "native-hosted" ? await resolveCodexProviderWebSearchSupport({
+	});
+	const supervisedSearchFingerprint = usesSupervisionConnection && !mutable.startupBinding?.pendingSupervisionBranch ? mutable.startupBinding?.webSearchThreadConfigFingerprint : void 0;
+	let nativeProviderWebSearchSupport;
+	if (webSearchPlan.kind !== "native-hosted" || supervisedSearchFingerprint === fingerprintJsonObject(resolveCodexWebSearchPlan({ disableTools: true }).threadConfig)) nativeProviderWebSearchSupport = "unsupported";
+	else if (supervisedSearchFingerprint === fingerprintJsonObject(webSearchPlan.threadConfig)) nativeProviderWebSearchSupport = "supported";
+	else nativeProviderWebSearchSupport = await resolveCodexProviderWebSearchSupport({
 		clientFactory: attemptClientFactory,
 		appServer,
 		authProfileId: startupClientAuthProfileId,
 		preparedAuth: startupPreparedAuth,
 		agentDir,
 		config: params.config,
-		modelProviderOverride: usesSupervisionConnection ? mutable.startupBinding?.modelProvider : resolveCodexAppServerThreadModelSelection({
+		expectedNativeModelProvider: usesSupervisionConnection ? mutable.startupBinding?.modelProvider : void 0,
+		modelProviderOverride: usesSupervisionConnection ? void 0 : resolveCodexAppServerThreadModelSelection({
 			provider: params.provider,
 			model: params.modelId,
 			binding: mutable.startupBinding,
@@ -5738,7 +6208,7 @@ async function prepareCodexAttemptRuntime(connection) {
 			config: params.config
 		}).modelProvider,
 		signal: runAbortController.signal
-	}) : "unsupported";
+	});
 	preDynamicStartupStages.mark("provider-capabilities");
 	for (const diagnostic of bundleMcpThreadConfig.diagnostics) embeddedAgentLog.warn(`bundle-mcp: ${diagnostic.pluginId}: ${diagnostic.message}`);
 	if (activeContextEngine) assertContextEngineHostSupport({
@@ -5868,7 +6338,7 @@ const DYNAMIC_TOOL_TERMINAL_DIAGNOSTIC_TYPES = [
 	"tool.execution.error",
 	"tool.execution.blocked"
 ];
-function createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle) {
+function createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle, waitForNativeItems) {
 	const { prompt, state: resourceState, projectorRef, trajectoryRecorder } = resources;
 	const { context } = prompt;
 	const { runtime, attemptTools } = context;
@@ -5878,7 +6348,24 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 	const { compactionPlanState, toolBridge, toolOutcomeOrdinals, suppressedDynamicToolOutcomeOrdinals, allocateCodexToolOutcomeOrdinal } = attemptTools;
 	const { state, turnIdRef, userInputBridgeRef, openClawDynamicToolExecutions, pendingOpenClawDynamicToolCompletionIds, noteProgress } = turnRuntime;
 	const { emitExecutionPhaseOnce, scheduleTurnReleaseAfterTerminalDynamicTool, scheduleTerminalDynamicToolReleaseCheck } = lifecycle;
-	const handleServerRequest = async (request, scope, requestSignal = new AbortController().signal) => {
+	let refreshDrain;
+	let refreshStopping = false;
+	const settlePluginRuntimeRefresh = async (turnId) => {
+		if (!params.pluginRuntimeRefreshPending?.()) return;
+		refreshDrain ??= createDeferred();
+		state.pluginRuntimeRefreshStop = refreshDrain.promise;
+		if (!refreshStopping && pendingOpenClawDynamicToolCompletionIds.size === 0) {
+			refreshStopping = true;
+			state.pendingTerminalDynamicToolRelease = void 0;
+			turnRuntime.steeringQueueRef.current?.cancel();
+			turnRuntime.interruptTurn(turnId, { locallyCompleted: true }).then(async (confirmed) => {
+				if (!confirmed) throw new Error("Plugin reload could not confirm the previous Codex turn stopped.");
+				await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId, params.oneShotCliRun === true, waitForNativeItems);
+			}).then(refreshDrain.resolve, refreshDrain.reject).finally(turnRuntime.completeTurn);
+		}
+		await refreshDrain.promise;
+	};
+	const handleServerRequest = async (request, scope, requestSignal = new AbortController().signal, setExecutionTimeoutMs) => {
 		const signal = AbortSignal.any([runAbortController.signal, requestSignal]);
 		const turnId = turnIdRef.current;
 		const projector = projectorRef.current;
@@ -5905,17 +6392,11 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					signal
 				});
 				if (approvalResult.kind === "handled") return approvalResult.response;
-				return await userInputBridgeRef.current?.handleElicitationRequest({
-					id: request.id,
-					params: request.params
-				});
+				return await userInputBridgeRef.current?.handleElicitationRequest(request, signal);
 			}
 			if (request.method === "item/tool/requestUserInput") {
 				if (scope.turnId === turnId) markCurrentTurnRequestProgress();
-				return await userInputBridgeRef.current?.handleRequest({
-					id: request.id,
-					params: request.params
-				});
+				return await userInputBridgeRef.current?.handleRequest(request, signal);
 			}
 			if (request.method !== "item/tool/call") {
 				if (isCodexAppServerApprovalRequest(request.method)) {
@@ -5939,7 +6420,9 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			const replayedExecution = openClawDynamicToolExecutions.get(call);
 			if (replayedExecution) {
 				markCurrentTurnRequestProgress();
-				return toCodexDynamicToolProtocolResponse(await replayedExecution);
+				const response = await replayedExecution;
+				await settlePluginRuntimeRefresh(turnId);
+				return toCodexDynamicToolProtocolResponse(response);
 			}
 			const toolCallOrdinal = allocateCodexToolOutcomeOrdinal?.(call.callId);
 			markCurrentTurnRequestProgress();
@@ -5964,23 +6447,38 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			const toolMeta = inferCodexDynamicToolMeta(call, resolveCodexToolProgressDetailMode(params.toolProgressDetail));
 			const toolArgs = sanitizeCodexToolArguments(call.arguments);
 			const commandBearing = isCodexCommandBearingToolCall(call.tool, toolArgs);
-			const shouldEmitDynamicToolProgress = shouldEmitTranscriptToolProgress(call.tool, toolArgs);
-			if (shouldEmitDynamicToolProgress) emitCodexAppServerEvent(params, {
-				stream: "tool",
-				data: {
-					phase: "start",
-					name: call.tool,
-					itemId: call.callId,
+			const shouldEmitDynamicToolProgress = shouldEmitTranscriptToolProgress(call.tool);
+			if (shouldEmitDynamicToolProgress) {
+				const activity = projectAgentToolActivity({
 					toolCallId: call.callId,
-					...toolMeta ? { meta: toolMeta } : {},
-					...toolArgs ? { args: toolArgs } : {},
-					...commandBearing ? { commandBearing: true } : {}
-				}
-			});
+					name: call.tool,
+					phase: "start",
+					args: toolArgs,
+					meta: toolMeta
+				});
+				emitCodexAppServerEvent(params, {
+					stream: "item",
+					data: activity
+				});
+				emitCodexAppServerEvent(params, {
+					stream: "tool",
+					data: {
+						phase: "start",
+						name: call.tool,
+						itemId: call.callId,
+						toolCallId: call.callId,
+						...toolMeta ? { meta: toolMeta } : {},
+						...toolArgs ? { args: toolArgs } : {},
+						...commandBearing ? { commandBearing: true } : {}
+					}
+				});
+			}
 			const dynamicToolTimeoutMs = resolveDynamicToolCallTimeoutMs({
 				call,
-				config: params.config
+				config: params.config,
+				toolBridge
 			});
+			setExecutionTimeoutMs?.(dynamicToolTimeoutMs);
 			const toolStartedAt = Date.now();
 			let terminalDiagnosticObserved = false;
 			const unsubscribeToolDiagnosticObserver = onInternalDiagnosticEvent((event) => {
@@ -6057,6 +6555,14 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				}
 				if (shouldEmitDynamicToolProgress) {
 					const progressResponse = toCodexDynamicToolProgressResponse(response, protocolResponse);
+					const activity = projectAgentToolActivity({
+						toolCallId: call.callId,
+						name: call.tool,
+						phase: "result",
+						args: response.executedArguments ?? call.arguments,
+						result: toTranscriptToolResult(progressResponse),
+						isError: !protocolResponse.success
+					});
 					emitCodexAppServerEvent(params, {
 						stream: "tool",
 						data: {
@@ -6070,6 +6576,10 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 							result: toTranscriptToolResult(progressResponse)
 						}
 					});
+					emitCodexAppServerEvent(params, {
+						stream: "item",
+						data: activity
+					});
 				}
 				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic({
 					call,
@@ -6086,7 +6596,8 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					durationMs: toolDurationMs
 				});
 				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
-				if (response.terminate === true && response.success) scheduleTurnReleaseAfterTerminalDynamicTool({
+				if (params.pluginRuntimeRefreshPending?.()) await settlePluginRuntimeRefresh(turnId);
+				else if (response.terminate === true && response.success) scheduleTurnReleaseAfterTerminalDynamicTool({
 					call,
 					response,
 					durationMs: toolDurationMs
@@ -6112,6 +6623,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					sessionKey: params.sessionKey,
 					durationMs: Math.max(0, Date.now() - toolStartedAt)
 				});
+				await settlePluginRuntimeRefresh(turnId);
 				throw error;
 			} finally {
 				toolOutcomeOrdinals.delete(call.callId);
@@ -6131,7 +6643,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-BJ0rXBZ_.js");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CLZ8udh-.mjs");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6154,7 +6666,7 @@ function startCodexComputerUseHealthMonitor(params) {
 			reason: params.config.enabled ? "health_disabled" : "disabled"
 		};
 	}
-	const fingerprint = buildComputerUseHealthMonitorFingerprint(params.config);
+	const fingerprint = buildComputerUseHealthMonitorFingerprint(params.config, params.tools);
 	const intervalMs = params.config.healthCheckIntervalMinutes * 6e4;
 	if (existing?.fingerprint === fingerprint) return {
 		started: false,
@@ -6166,7 +6678,7 @@ function startCodexComputerUseHealthMonitor(params) {
 		fingerprint,
 		intervalMs,
 		timer: setInterval(() => {
-			runCodexComputerUseHealthProbe(params.client, params.config, monitor);
+			runCodexComputerUseHealthProbe(params.client, params.config, monitor, params.tools);
 		}, intervalMs),
 		disposeCloseHandler: () => void 0,
 		running: false
@@ -6182,22 +6694,28 @@ function startCodexComputerUseHealthMonitor(params) {
 		intervalMs
 	};
 }
-function buildComputerUseHealthMonitorFingerprint(config) {
+function buildComputerUseHealthMonitorFingerprint(config, tools) {
 	return JSON.stringify({
 		autoRepair: config.autoRepair,
 		healthCheckIntervalMinutes: config.healthCheckIntervalMinutes,
 		liveTestTimeoutMs: config.liveTestTimeoutMs,
 		mcpServerName: config.mcpServerName,
-		toolCallTimeoutMs: config.toolCallTimeoutMs
+		toolCallTimeoutMs: config.toolCallTimeoutMs,
+		tools: tools?.toSorted()
 	});
 }
-async function runCodexComputerUseHealthProbe(client, config, monitor) {
+async function runCodexComputerUseHealthProbe(client, config, monitor, tools) {
 	if (monitor.running) return;
 	monitor.running = true;
 	try {
 		const { liveTest, repair } = await runCodexComputerUseLiveTest({
+			client,
 			config,
-			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, { timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs })
+			tools,
+			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, {
+				timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs,
+				...requestOptions?.signal ? { signal: requestOptions.signal } : {}
+			})
 		});
 		if (!liveTest.ok) {
 			embeddedAgentLog.warn("codex computer-use periodic health failed", {
@@ -6399,6 +6917,7 @@ async function startCodexAttemptThread(params) {
 					try {
 						const attemptParams = params.buildAttemptParams();
 						params.assertCurrent?.();
+						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
 						startupClient = await params.attemptClientFactory({
 							assertCurrent: params.assertCurrent,
 							startOptions: params.appServer.start,
@@ -6447,15 +6966,16 @@ async function startCodexAttemptThread(params) {
 							config: params.config
 						});
 						const turnRouter = getCodexAppServerTurnRouter(activeStartupClient);
+						let computerUseTools = [];
 						try {
-							await ensureCodexComputerUse({
+							computerUseTools = (await ensureCodexComputerUse({
 								client: activeStartupClient,
 								pluginConfig: params.pluginConfig,
 								config: params.config,
 								agentDir: params.agentDir,
 								timeoutMs: params.appServer.requestTimeoutMs,
 								signal: startupAbandonController.signal
-							});
+							})).tools;
 						} catch (error) {
 							if (startupAbandonController.signal.aborted || isCodexAppServerStartSelectionChangedError(error)) throw error;
 							throw new AgentHarnessPreflightError(`Codex Computer Use readiness failed: ${formatErrorMessage(error)}`, {
@@ -6517,7 +7037,8 @@ async function startCodexAttemptThread(params) {
 								appServerStartOptions: params.appServer.start,
 								timeoutMs: params.appServer.requestTimeoutMs,
 								signal: AbortSignal.any([params.signal, startupAbandonController.signal]),
-								onExecutionDisconnect: params.onExecutionDisconnect
+								onExecutionDisconnect: params.onExecutionDisconnect,
+								requireProcessAuthority: Boolean(attemptParams.hostCapabilities.retainSourceAuthority)
 							}) : void 0;
 							startupSandboxEnvironmentAcquired = Boolean(startupSandboxEnvironment);
 							if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
@@ -6617,7 +7138,8 @@ async function startCodexAttemptThread(params) {
 							startupSandboxEnvironmentAcquired = false;
 							startCodexComputerUseHealthMonitor({
 								client: activeStartupClient,
-								config: params.computerUseConfig
+								config: params.computerUseConfig,
+								tools: computerUseTools
 							});
 							startupAttemptSucceeded = true;
 							return {
@@ -6652,7 +7174,6 @@ async function startCodexAttemptThread(params) {
 							const sharedClient = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(startupClientForAbandonedRequestCleanup);
 							if (sharedClient.found && !sharedClient.closed) startupClientForAbandonedRequestCleanup = void 0;
 						}
-						throw error;
 					} finally {
 						if (!startupAttemptSucceeded) {
 							if (releaseSharedClientLease === startupClientLease) releaseSharedClientLease = void 0;
@@ -6663,13 +7184,20 @@ async function startCodexAttemptThread(params) {
 							}
 						}
 					}
+					if (startupAttemptError instanceof CodexThreadClientReplacementError && startupClient) {
+						if (!(await startupClient.closeAndWait()).exited) throw new AgentHarnessPreflightError("The previous conversation process did not confirm shutdown; the conversation was preserved.");
+					}
+					throw startupAttemptError;
 				};
+				let replacedSettledFailureClient = false;
 				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS; attempt += 1) try {
 					return await startupAttempt();
 				} catch (error) {
 					const selectionChanged = isCodexAppServerStartSelectionChangedError(error);
-					if (startupAbandonController.signal.aborted || !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
-					const refreshedSharedClient = selectionChanged ? retireSharedCodexAppServerClientIfCurrent(attemptedClient) : clearSharedCodexAppServerClientIfCurrent(attemptedClient);
+					const clientRetired = error instanceof CodexThreadClientReplacementError;
+					if (startupAbandonController.signal.aborted || clientRetired && replacedSettledFailureClient || !clientRetired && !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
+					replacedSettledFailureClient ||= clientRetired;
+					const refreshedSharedClient = clientRetired ? void 0 : selectionChanged ? retireSharedCodexAppServerClientIfCurrent(attemptedClient) : clearSharedCodexAppServerClientIfCurrent(attemptedClient);
 					if (startupClientForAbandonedRequestCleanup === attemptedClient) startupClientForAbandonedRequestCleanup = void 0;
 					if (attempt >= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS) {
 						embeddedAgentLog.warn(selectionChanged ? "codex app-server executable selection kept changing during startup; retries exhausted" : "codex app-server connection closed during startup; retries exhausted", {
@@ -6680,8 +7208,8 @@ async function startCodexAttemptThread(params) {
 						});
 						throw error;
 					}
-					const retryDelayMs = selectionChanged ? 0 : 1e3 * 2 ** (attempt - 1);
-					embeddedAgentLog.warn(selectionChanged ? "codex app-server executable selection changed during startup; restarting app-server and retrying" : "codex app-server connection closed during startup; restarting app-server and retrying", {
+					const retryDelayMs = selectionChanged || clientRetired ? 0 : 1e3 * 2 ** (attempt - 1);
+					embeddedAgentLog.warn(clientRetired ? "codex app-server retired a settled failed client; resuming on a fresh client" : selectionChanged ? "codex app-server executable selection changed during startup; restarting app-server and retrying" : "codex app-server connection closed during startup; restarting app-server and retrying", {
 						attempt,
 						nextAttempt: attempt + 1,
 						maxAttempts: CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS,
@@ -6712,14 +7240,10 @@ async function startCodexAttemptThread(params) {
 		params.signal.removeEventListener("abort", abandonStartupAcquire);
 	}
 }
-function shouldRetireCodexStartupClient(error, spawnedBy, signal) {
-	if (signal.aborted || isCodexAppServerStartupError(error) || isCodexAppServerRequestTimeoutError(error)) return true;
-	return !isCodexAppServerStartSelectionChangedError(error) && !isCodexAppServerOverloadError(error) && !(error instanceof AgentHarnessPreflightError && error.scope === void 0) && (isCodexAppServerBrokenPipeError(error) || !spawnedBy);
-}
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-start.ts
 async function startCodexAttemptRuntime(resources) {
-	const { prompt, state, trajectoryRecorder, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseAndRetireOneShotClient, releaseCurrentRoute, runCleanupStep, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
+	const { prompt, state, trajectoryRecorder, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
 	const { context, turnState, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
 	const { runtime, attemptTools, promptState } = context;
 	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
@@ -6763,7 +7287,7 @@ async function startCodexAttemptRuntime(resources) {
 			developerInstructions,
 			agentWorkspaceDeveloperInstructions: context.agentWorkspaceDeveloperInstructions,
 			buildFinalConfigPatch: buildNativeHookRelayFinalConfigPatch,
-			nativeHookRelayRequired: connection.options.nativeHookRelay?.enabled !== false && params.pluginHarnessToolPolicyRestricted !== true && connection.nativeHookRelayEvents.includes("pre_tool_use") && (hasBeforeToolCallPolicy() || appServer.loopDetectionPreToolUseRelay && Boolean(connection.sandboxSessionKey) && loopDetectionEnabled),
+			nativeHookRelayRequired: Boolean(resources.nativeProcessAuthority && nativeToolSurfaceEnabled) || 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,
@@ -6803,10 +7327,11 @@ 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({
+			const activeConfig = await resolveRuntimeOptionsForCurrentBinding({
 				modelProvider: activePolicy.modelProvider,
 				model: activePolicy.model
 			});
+			connection.assertCurrent();
 			const activeAppServer = resolveCodexAppServerForModelProvider({
 				appServer: activeConfig,
 				provider: activePolicy.modelProvider,
@@ -6847,14 +7372,8 @@ async function startCodexAttemptRuntime(resources) {
 			toolCount: flattenCodexDynamicToolFunctions(toolBridge.specs).length
 		});
 		connection.mutable.pluginAppServer = pluginAppServer;
+		await resources.registerNativeSubagentMonitor(state.thread.threadId);
 	} catch (error) {
-		await runCleanupStep("codex-start-failure-hook-fallback", activateNativePreToolUseFailureFallback);
-		await runCleanupStep("codex-start-failure-route-release", releaseCurrentRoute);
-		const nativeHookRelay = state.nativeHookRelay;
-		state.nativeHookRelay = void 0;
-		await runCleanupStep("codex-start-failure-native-hook-relay", () => nativeHookRelay?.unregister());
-		await runCleanupStep("codex-start-failure-sandbox-release", releaseSandboxExecEnvironment);
-		await runCleanupStep("codex-start-failure-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		throw error instanceof CodexThreadPolicyHandoffError ? error : state.executionDisconnectError ?? error;
 	}
 }
@@ -7005,93 +7524,103 @@ async function prepareCodexAttemptTools(runtime) {
 		}
 	}
 	let requireExplicitMessageTarget;
-	const tools = await buildDynamicTools({
-		...commonToolParams,
-		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
-		onMessageToolTargetResolved: (required) => {
-			requireExplicitMessageTarget = required;
-		},
-		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
-		cronCreatorToolAllowlistCaptureRef,
-		onPersistentWebSearchPolicyResolved: (allowed) => {
-			toolState.persistentWebSearchAllowed = allowed;
-		},
-		onWebSearchPolicyResolved: (allowed) => {
-			toolState.webSearchAllowed = allowed;
-		}
-	});
-	const registeredTools = nativeSpecs ? [] : await buildDynamicTools({
-		...commonToolParams,
-		forceHeartbeatTool: true,
-		ignoreDisableMessageTool: true,
-		ignoreRuntimePlan: true
-	});
-	const policyContext = {
-		config: params.config,
-		sessionKey: sandboxSessionKey,
-		runSessionKey: params.sessionKey && params.sessionKey !== sandboxSessionKey ? params.sessionKey : void 0,
-		sessionId: params.sessionId,
-		runId: params.runId,
-		agentId: policyAgentId,
-		agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
-		agentAccountId: params.agentAccountId,
-		messageProvider: params.messageProvider ?? params.messageChannel,
-		messageChannel: params.messageChannel,
-		chatType: params.chatType,
-		messageTo: params.messageTo,
-		messageThreadId: params.messageThreadId,
-		currentChannelId: params.currentChannelId,
-		currentMessagingTarget: params.currentMessagingTarget,
-		currentThreadTs: params.currentThreadTs,
-		currentMessageId: params.currentMessageId,
-		groupId: params.groupId,
-		groupChannel: params.groupChannel,
-		groupSpace: params.groupSpace,
-		memberRoleIds: params.memberRoleIds,
-		spawnedBy: params.spawnedBy,
-		senderId: params.senderId,
-		senderName: params.senderName,
-		senderUsername: params.senderUsername,
-		senderE164: params.senderE164,
-		senderIsOwner: params.senderIsOwner,
-		modelProvider: params.provider,
-		modelId: params.modelId,
-		modelApi: params.model.api,
-		modelContextWindowTokens: params.model.contextWindow,
-		modelHasVision: params.model.input?.includes("image") ?? false,
-		workspaceDir: effectiveWorkspace,
-		cwd: effectiveCwd ?? effectiveWorkspace,
-		sandboxToolPolicy: sandbox?.tools,
-		conversationToolPolicy: params.conversationToolPolicy,
-		inputProvenance: params.inputProvenance,
-		trustedInternalHandoff: params.trustedInternalHandoff,
-		scheduledToolPolicy: params.scheduledToolPolicy
-	};
-	const reservedToolNames = [...tools.map((tool) => tool.name), ...registeredTools.map((tool) => tool.name)];
-	const turnSourceChannel = params.messageChannel ?? params.messageProvider;
-	const turnSourceTo = params.currentMessagingTarget ?? params.currentChannelId;
-	const requester = {
-		...turnSourceChannel ? { channel: turnSourceChannel } : {},
-		...params.agentAccountId ? { accountId: params.agentAccountId } : {},
-		...params.senderId ? { senderId: params.senderId } : {},
-		...params.senderIsOwner !== void 0 ? { senderIsOwner: params.senderIsOwner } : {},
-		...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
-	};
-	const hasRequester = Object.keys(requester).length > 0;
-	const configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
-		sessionId: params.sessionId,
-		sessionKey: params.sessionKey,
-		agentId: sessionAgentId,
-		workspaceDir: effectiveWorkspace,
-		agentDir: policyContext.agentDir,
-		cfg: params.config,
-		manifestRegistry: bundleManifestRegistry,
-		reservedToolNames,
-		toolsAllow: params.toolsAllow,
-		toolOverrides: codexMcpToolOverrides,
-		autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
-		projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
-		...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: async (approval) => {
+	let configuredMcp;
+	let scopedMcpTools;
+	let toolDisposal;
+	const disposeTools = (reason) => toolDisposal ??= (async () => {
+		await runAgentCleanupStep({
+			runId: params.runId,
+			sessionId: params.sessionId,
+			step: "codex-dynamic-tool-cleanup",
+			log: embeddedAgentLog,
+			cleanup: async () => {
+				const errors = (await Promise.allSettled(runCleanups.splice(0).map(async (cleanup) => await cleanup(reason)))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+				if (params.oneShotCliRun && errors.length) throw new AggregateError(errors, "Codex tool cleanup failed");
+			}
+		});
+		for (const [step, materialized] of [["codex-scoped-mcp-dispose", scopedMcpTools], ["codex-configured-mcp-dispose", configuredMcp]]) await runAgentCleanupStep({
+			runId: params.runId,
+			sessionId: params.sessionId,
+			step,
+			log: embeddedAgentLog,
+			cleanup: async () => materialized?.dispose()
+		});
+	})();
+	try {
+		const tools = await buildDynamicTools({
+			...commonToolParams,
+			registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
+			onMessageToolTargetResolved: (required) => {
+				requireExplicitMessageTarget = required;
+			},
+			cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
+			cronCreatorToolAllowlistCaptureRef,
+			onPersistentWebSearchPolicyResolved: (allowed) => {
+				toolState.persistentWebSearchAllowed = allowed;
+			},
+			onWebSearchPolicyResolved: (allowed) => {
+				toolState.webSearchAllowed = allowed;
+			}
+		});
+		const registeredTools = nativeSpecs ? [] : await buildDynamicTools({
+			...commonToolParams,
+			forceHeartbeatTool: true,
+			ignoreDisableMessageTool: true,
+			ignoreRuntimePlan: true
+		});
+		const policyContext = {
+			config: params.config,
+			sessionKey: sandboxSessionKey,
+			runSessionKey: params.sessionKey && params.sessionKey !== sandboxSessionKey ? params.sessionKey : void 0,
+			sessionId: params.sessionId,
+			runId: params.runId,
+			agentId: policyAgentId,
+			agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
+			agentAccountId: params.agentAccountId,
+			messageProvider: params.messageProvider ?? params.messageChannel,
+			messageChannel: params.messageChannel,
+			chatType: params.chatType,
+			messageTo: params.messageTo,
+			messageThreadId: params.messageThreadId,
+			currentChannelId: params.currentChannelId,
+			currentMessagingTarget: params.currentMessagingTarget,
+			currentThreadTs: params.currentThreadTs,
+			currentMessageId: params.currentMessageId,
+			groupId: params.groupId,
+			groupChannel: params.groupChannel,
+			groupSpace: params.groupSpace,
+			memberRoleIds: params.memberRoleIds,
+			spawnedBy: params.spawnedBy,
+			senderId: params.senderId,
+			senderName: params.senderName,
+			senderUsername: params.senderUsername,
+			senderE164: params.senderE164,
+			senderIsOwner: params.senderIsOwner,
+			modelProvider: params.provider,
+			modelId: params.modelId,
+			modelApi: params.model.api,
+			modelContextWindowTokens: params.model.contextWindow,
+			modelHasVision: params.model.input?.includes("image") ?? false,
+			workspaceDir: effectiveWorkspace,
+			cwd: effectiveCwd ?? effectiveWorkspace,
+			sandboxToolPolicy: sandbox?.tools,
+			conversationToolPolicy: params.conversationToolPolicy,
+			inputProvenance: params.inputProvenance,
+			trustedInternalHandoff: params.trustedInternalHandoff,
+			scheduledToolPolicy: params.scheduledToolPolicy
+		};
+		const reservedToolNames = [...tools.map((tool) => tool.name), ...registeredTools.map((tool) => tool.name)];
+		const turnSourceChannel = params.messageChannel ?? params.messageProvider;
+		const turnSourceTo = params.currentMessagingTarget ?? params.currentChannelId;
+		const requester = {
+			...turnSourceChannel ? { channel: turnSourceChannel } : {},
+			...params.agentAccountId ? { accountId: params.agentAccountId } : {},
+			...params.senderId ? { senderId: params.senderId } : {},
+			...params.senderIsOwner !== void 0 ? { senderIsOwner: params.senderIsOwner } : {},
+			...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
+		};
+		const hasRequester = Object.keys(requester).length > 0;
+		const requestInteractiveMcpApproval = async (approval) => {
 			const allowedDecisions = approval.mode === "prompt" ? ["allow-once", "deny"] : [
 				"allow-once",
 				"allow-always",
@@ -7112,21 +7641,41 @@ async function prepareCodexAttemptTools(runtime) {
 				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;
-	let scopedMcpTools = void 0;
-	const disposeMcpTools = async () => {
-		for (const [step, materialized] of [["codex-scoped-mcp-dispose", scopedMcpTools], ["codex-configured-mcp-dispose", configuredMcp]]) await runAgentCleanupStep({
-			runId: params.runId,
+		};
+		const requestRequesterMcpApproval = async (approval) => {
+			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: ["allow-once", "deny"],
+				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}`);
+		};
+		configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
 			sessionId: params.sessionId,
-			step,
-			log: embeddedAgentLog,
-			cleanup: async () => materialized?.dispose()
-		});
-	};
-	try {
+			sessionKey: params.sessionKey,
+			agentId: sessionAgentId,
+			workspaceDir: effectiveWorkspace,
+			agentDir: policyContext.agentDir,
+			cfg: params.config,
+			manifestRegistry: bundleManifestRegistry,
+			reservedToolNames,
+			toolsAllow: params.toolsAllow,
+			toolOverrides: codexMcpToolOverrides,
+			autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
+			projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
+			...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: requestInteractiveMcpApproval } : {},
+			policyContext,
+			warn: (message) => embeddedAgentLog.warn(message)
+		}) : void 0;
 		scopedMcpTools = authenticatedScheduledMode ? void 0 : await materializeRequesterScopedMcpToolsForHarnessRun({
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -7135,6 +7684,8 @@ async function prepareCodexAttemptTools(runtime) {
 			cfg: params.config,
 			manifestRegistry: bundleManifestRegistry,
 			toolOverrides: codexMcpToolOverrides,
+			autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
+			requestInteractiveCodexApproval: requestRequesterMcpApproval,
 			requesterSenderId: params.senderId,
 			agentAccountId: params.agentAccountId,
 			messageChannel: params.messageChannel ?? params.messageProvider,
@@ -7212,7 +7763,7 @@ async function prepareCodexAttemptTools(runtime) {
 						agentDir: policyContext.agentDir,
 						cfg: params.config,
 						manifestRegistry: bundleManifestRegistry,
-						reservedToolNames: toolBridge.availableTools.map((tool) => tool.name),
+						reservedToolNames: configuredMcp ? reservedToolNames : toolBridge.availableTools.map((tool) => tool.name),
 						toolsAllow: params.toolsAllow,
 						toolOverrides: codexMcpToolOverrides,
 						autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
@@ -7251,14 +7802,13 @@ async function prepareCodexAttemptTools(runtime) {
 			requireExplicitMessageTarget,
 			scopedMcpTools,
 			configuredMcp,
-			disposeMcpTools,
+			disposeTools,
 			configuredMcpOwnershipVersion: configuredMcpSurface === "scheduled" ? 1 : void 0,
 			captureCronCreatorToolAllowlist,
 			scheduledAppAuthoritySourceRef,
 			dynamicToolParams,
 			compactionPlanState,
 			computerContextEpoch,
-			runCleanups,
 			toolBridge,
 			toolState,
 			toolOutcomeOrdinals,
@@ -7268,7 +7818,7 @@ async function prepareCodexAttemptTools(runtime) {
 			runtimeYieldCompletionClaim
 		};
 	} catch (error) {
-		await disposeMcpTools();
+		await disposeTools("error");
 		throw error;
 	}
 }
@@ -7302,10 +7852,102 @@ async function resolveCodexExplicitSkillInputs(params) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/provider-review-continuation.ts
+/** Reconcile the acknowledged failure with the native thread immediately before turn/start. */
+async function prepareCodexProviderReviewContinuation(params) {
+	const acknowledgment = params.acknowledgment;
+	if (!acknowledgment) return;
+	let nativeChanged = false;
+	let dispatched = false;
+	let dispose = () => {};
+	const assertCurrent = () => {
+		params.signal.throwIfAborted();
+		params.assertCurrent();
+		acknowledgment.read();
+		if (nativeChanged) throw new Error("The native provider review changed before dispatch");
+	};
+	assertCurrent();
+	const snapshot = acknowledgment.read();
+	if (snapshot.phase === "accepted") throw new Error("Provider review continuation cannot start another native turn");
+	const assertWorkStart = () => acknowledgment.assertRuntime({
+		provider: params.provider,
+		model: params.model,
+		runtimeId: "codex",
+		api: params.api,
+		assertCurrent
+	});
+	await assertWorkStart();
+	assertCurrent();
+	const { review } = snapshot;
+	if (review.nativeThreadId !== params.turnStartParams.threadId || !review.review?.continuation) throw new Error("Provider review no longer matches the native thread");
+	dispose = params.client.addNotificationHandler((notification) => {
+		const event = notification.params;
+		if (!isJsonObject(event) || event.threadId !== review.nativeThreadId) return;
+		if (notification.method === "turn/started") nativeChanged = true;
+		else if (notification.method === "turn/completed" || notification.method === "error" && event.willRetry !== true) {
+			const turn = isJsonObject(event.turn) ? event.turn : void 0;
+			const turnId = turn?.id ?? event.turnId;
+			const error = isJsonObject(turn?.error) ? turn.error : isJsonObject(event.error) ? event.error : void 0;
+			const failure = readCodexProviderRefusal(typeof error?.message === "string" ? error.message : void 0, error?.codexErrorInfo, { misalignment: error?.misalignment });
+			if (turnId !== review.nativeTurnId || turn && turn.status !== "failed" || failure?.category !== "misalignment" || error?.misalignment != null && !isDeepStrictEqual(failure.review, review.review)) nativeChanged = true;
+		}
+	});
+	try {
+		const page = await params.client.request("thread/turns/list", {
+			threadId: params.turnStartParams.threadId,
+			limit: 1,
+			sortDirection: "desc",
+			itemsView: "notLoaded"
+		}, {
+			signal: params.signal,
+			timeoutMs: params.timeoutMs,
+			assertCurrent
+		});
+		assertCurrent();
+		const latest = page.data[0];
+		const refusal = latest && readCodexProviderRefusal(latest.error?.message, latest.error?.codexErrorInfo, { misalignment: latest.error?.misalignment });
+		if (page.data.length !== 1 || !latest || latest.id !== review.nativeTurnId || latest.threadId !== void 0 && latest.threadId !== params.turnStartParams.threadId || latest.status !== "failed" || refusal?.category !== "misalignment" || latest.error?.misalignment != null && !isDeepStrictEqual(refusal.review, review.review)) throw new Error("The native provider review changed; refresh the findings before continuing");
+		await assertWorkStart();
+		assertCurrent();
+		const message = review.review.continuation.message;
+		params.turnStartParams.input = [{
+			type: "text",
+			text: message,
+			text_elements: []
+		}];
+		params.turnStartParams.responsesapiClientMetadata = {
+			...params.turnStartParams.responsesapiClientMetadata,
+			misalignment_override: JSON.stringify({ timestamp: Date.now() })
+		};
+		return {
+			dispose,
+			dispatch: () => {
+				assertCurrent();
+				if (dispatched) throw new Error("Provider review continuation already dispatched");
+				dispatched = true;
+				dispose();
+			},
+			accept: async (turnId) => {
+				assertCurrent();
+				if (!dispatched) throw new Error("Provider review continuation has not dispatched");
+				await acknowledgment.acceptNativeTurn({
+					nativeThreadId: params.turnStartParams.threadId,
+					nativeTurnId: turnId,
+					assertCurrent
+				});
+				assertCurrent();
+			}
+		};
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-request.ts
 async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, waitForActiveNativeTurnCompletion) {
 	const { prompt, state: resourceState, releaseCurrentRoute } = resources;
-	const { context, turnState, buildRenderedCodexDeveloperInstructions } = prompt;
+	const { context, turnState, buildRenderedCodexDeveloperInstructions, nativeHistoryProvenancePrefix } = prompt;
 	const { runtime, attemptTools, hookContextWindowFields, workspaceBootstrapContext } = context;
 	const { connection, runtimeParams, effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
 	const { tools, toolBridge } = attemptTools;
@@ -7359,19 +8001,25 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 	const startCodexTurn = async () => {
 		const activeTurnRoute = await ensureCurrentThreadRoute();
 		assertCodexSessionRuntimeOwnership(resourceState.thread, params.expectedSessionRuntimeOwnership);
+		const selectedThread = resourceState.thread;
+		const { threadId, liveThreadOwnership, model, modelProvider } = selectedThread;
+		const turnClient = resourceState.client;
+		const assertTurnCurrent = () => {
+			connection.assertCurrent();
+			liveThreadOwnership?.assertCurrent();
+			if (resourceState.thread !== selectedThread || selectedThread.threadId !== threadId || selectedThread.liveThreadOwnership !== liveThreadOwnership || selectedThread.model !== model || selectedThread.modelProvider !== modelProvider) throw new Error("Codex native model or thread ownership changed during turn start.");
+		};
 		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, runtimeParams);
 		connection.mutable.pluginAppServer = turnAppServer;
 		const references = prepareWorkspaceReferences();
-		const referencesRetained = turnState.codexTurnPromptText.includes(workspaceBootstrapContext.promptContext ?? "");
 		const inferenceRoute = usesSupervisionConnection ? void 0 : getCodexInferenceThread(resourceState.client, resourceState.thread.threadId);
-		const turnStartParams = buildTurnStartParams({
-			...runtimeParams,
-			images: [...prompt.contextImages, ...runtimeParams.images ?? []]
-		}, {
+		const turnStartParams = buildTurnStartParams(runtimeParams, {
 			threadId: resourceState.thread.threadId,
 			cwd: resourceState.codexExecutionCwd,
 			appServer: turnAppServer,
 			promptText: turnState.codexTurnPromptText,
+			historyProvenancePrefix: nativeHistoryProvenancePrefix,
+			contextImageGroups: prompt.contextImageGroups,
 			explicitSkillInputs,
 			sandboxPolicy: resourceState.codexSandboxPolicy,
 			environmentSelection: resourceState.codexEnvironmentSelection,
@@ -7427,6 +8075,17 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 				truncated: null
 			} : file);
 		}
+		const continuation = await prepareCodexProviderReviewContinuation({
+			acknowledgment: params.providerReviewAcknowledgment,
+			client: resourceState.client,
+			turnStartParams,
+			provider: params.provider,
+			model: params.modelId,
+			api: runtimeParams.model.api,
+			signal: runAbortController.signal,
+			timeoutMs: params.timeoutMs,
+			assertCurrent: assertTurnCurrent
+		});
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
 		recordCodexTrajectoryContext(resources.trajectoryRecorder, {
 			attempt: params,
@@ -7450,29 +8109,41 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			}
 		});
 		let acceptedTurnId;
+		const upstreamUserText = turnStartParams.input.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
 		try {
-			const startedTurn = assertCodexTurnStartResponse(await resourceState.client.request("turn/start", turnStartParams, {
+			const startedTurn = assertCodexTurnStartResponse(await turnClient.request("turn/start", turnStartParams, {
 				timeoutMs: params.timeoutMs,
 				signal: runAbortController.signal,
-				assertCurrent: connection.assertCurrent
+				assertCurrent: () => {
+					assertTurnCurrent();
+					continuation?.dispatch();
+				}
 			}));
 			acceptedTurnId = startedTurn.turn.id;
-			connection.assertCurrent();
-			if (referencesRetained) references.accepted();
+			resources.nativeProcessAuthority?.bindTurn(turnClient, threadId, acceptedTurnId);
+			assertTurnCurrent();
+			if (upstreamUserText.includes(workspaceBootstrapContext.promptContext ?? "")) references.accepted();
 			throwIfTurnStartAcceptedAfterAbort();
-			return startedTurn;
+			await continuation?.accept(acceptedTurnId);
+			return {
+				turn: startedTurn,
+				upstreamUserText
+			};
 		} catch (error) {
 			if (acceptedTurnId || isCodexAppServerIndeterminateRequestCancellationError(error)) try {
-				resourceState.startupClientUnsafe = !await interruptCodexTurnAndWaitBestEffort(resourceState.client, {
-					threadId: resourceState.thread.threadId,
+				resourceState.startupClientUnsafe = !await interruptCodexTurnAndWaitBestEffort(turnClient, {
+					threadId,
 					turnId: acceptedTurnId ?? ""
 				});
-				if (resourceState.startupClientUnsafe) await retireUnsafeCodexTurnClientBestEffort(resourceState.client, "startup interrupt");
+				if (resourceState.startupClientUnsafe) await retireUnsafeCodexTurnClientBestEffort(turnClient, "startup interrupt");
 			} finally {
-				releaseCurrentRoute();
+				await releaseCurrentRoute();
 			}
 			else await activeTurnRoute.cancelTurn();
+			if (params.providerReviewAcknowledgment) throw new Error("Could not continue this chat. Review its latest status before trying again.");
 			throw error;
+		} finally {
+			continuation?.dispose();
 		}
 	};
 	if (resourceState.thread.lifecycle.action === "resumed" && (resourceState.thread.lifecycle.activeTurnIds?.length ?? 0) > 0) {
@@ -7496,7 +8167,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		systemPrompt: buildRenderedCodexDeveloperInstructions(),
 		prompt: turnState.codexTurnPromptText,
 		historyMessages: prompt.codexModelInputHistoryMessages,
-		imagesCount: prompt.contextImages.length + (params.images?.length ?? 0),
+		imagesCount: prompt.contextImageGroups.reduce((count, group) => count + group.images.length, 0) + (params.images?.length ?? 0),
 		tools
 	});
 	return {
@@ -7508,7 +8179,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-start.ts
 async function startCodexAttemptTurn(resources, turnRuntime, notifications, requestRuntime) {
-	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded, activateNativePreToolUseFailureFallback, releaseCurrentRoute, releaseSandboxExecEnvironment, releaseSharedClientLeaseAndRetireOneShotClient } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded } = resources;
 	const { context, turnState, systemPromptReport } = prompt;
 	const { runtime, historyState, hookContext, hookContextWindowFields, hookRunner } = context;
 	const { connection, runtimeParams, effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
@@ -7516,7 +8187,8 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 	const { state, turnIdRef } = turnRuntime;
 	const { waitForActiveNativeTurnCompletion } = notifications;
 	const { codexModelCallDiagnostics, startCodexTurn, buildLlmInputEvent } = requestRuntime;
-	let turn;
+	let started;
+	resourceState.turnStartAttempted = true;
 	try {
 		codexModelCallDiagnostics.emitStarted();
 		runAgentHarnessLlmInputHook({
@@ -7524,10 +8196,10 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			ctx: hookContext,
 			hookRunner
 		});
-		turn = await startCodexTurn();
+		started = await startCodexTurn();
 	} catch (error) {
 		let turnStartError = error;
-		if (isCodexActiveCompactTurnError(turnStartError)) {
+		if (!params.providerReviewAcknowledgment && isCodexActiveCompactTurnError(turnStartError)) {
 			embeddedAgentLog.info("codex app-server turn/start blocked by active compact turn; waiting to retry", { threadId: resourceState.thread.threadId });
 			if (await waitForActiveNativeTurnCompletion() && !runAbortController.signal.aborted) {
 				emitCodexAppServerEvent(params, {
@@ -7538,13 +8210,13 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 					}
 				});
 				try {
-					turn = await startCodexTurn();
+					started = await startCodexTurn();
 				} catch (retryError) {
 					turnStartError = retryError;
 				}
 			}
 		}
-		if (turn === void 0 && resourceState.thread.connectionScope !== "supervision" && shouldUseFreshCodexThreadAfterContextEngineOverflow({
+		if (started === void 0 && !params.providerReviewAcknowledgment && resourceState.thread.connectionScope !== "supervision" && shouldUseFreshCodexThreadAfterContextEngineOverflow({
 			error: turnStartError,
 			contextEngineActive: Boolean(activeContextEngine),
 			thread: resourceState.thread
@@ -7586,7 +8258,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 					}
 				});
 				try {
-					turn = await startCodexTurn();
+					started = await startCodexTurn();
 				} catch (retryError) {
 					turnStartError = retryError;
 				}
@@ -7594,7 +8266,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 		} catch (retrySetupError) {
 			turnStartError = retrySetupError;
 		}
-		if (turn === void 0) {
+		if (started === void 0) {
 			const usageLimitError = await formatCodexTurnStartUsageLimitError({
 				client: resourceState.client,
 				error: turnStartError,
@@ -7604,7 +8276,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				signal: runAbortController.signal
 			});
 			const message = usageLimitError?.message ?? formatErrorMessage(turnStartError);
-			if (isInvalidCodexImagePayloadError(message)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
+			if (!params.providerReviewAcknowledgment && isInvalidCodexImagePayloadError(message)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 				phase: "turn_start",
 				threadId: resourceState.thread.threadId,
 				error: message
@@ -7661,33 +8333,6 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				ctx: hookContext,
 				hookRunner
 			});
-			if ((isIncognitoSessionKey(params.sessionKey) ? await bindingStore.mutate(bindingIdentity, {
-				kind: "clear",
-				threadId: resourceState.thread.threadId
-			}) : true) && !resourceState.startupClientUnsafe) {
-				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-					threadId: resourceState.thread.threadId,
-					timeoutMs: 5e3
-				})) await runAgentCleanupStep({
-					runId: params.runId,
-					sessionId: params.sessionId,
-					step: "codex-retire-unsafe-startup-client",
-					log: embeddedAgentLog,
-					cleanup: async () => closeCodexStartupClientBestEffort(resourceState.client)
-				});
-			}
-			releaseCurrentRoute();
-			activateNativePreToolUseFailureFallback();
-			resourceState.nativeHookRelay?.unregister();
-			await releaseSandboxExecEnvironment();
-			await runAgentCleanupStep({
-				runId: params.runId,
-				sessionId: params.sessionId,
-				step: "codex-trajectory-flush-startup-failure",
-				log: embeddedAgentLog,
-				cleanup: async () => trajectoryRecorder?.flush()
-			});
-			await releaseSharedClientLeaseAndRetireOneShotClient();
 			if (usageLimitError) {
 				await markCodexAuthProfileBlockedFromRateLimits({
 					params,
@@ -7719,11 +8364,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			throw turnStartError;
 		}
 	}
-	if (!turn) {
-		activateNativePreToolUseFailureFallback();
-		await releaseSharedClientLeaseAndRetireOneShotClient();
-		throw new Error("codex app-server turn/start failed without an error");
-	}
+	if (!started) throw new Error("codex app-server turn/start failed without an error");
 	const authoritySourceRef = context.attemptTools.scheduledAppAuthoritySourceRef;
 	if (resourceState.thread.pluginAppPolicyContext) authoritySourceRef.current = {
 		client: resourceState.client,
@@ -7731,9 +8372,9 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 		policyContext: resourceState.thread.pluginAppPolicyContext,
 		configCwd: connection.effectiveCwd
 	};
-	turnIdRef.current = turn.turn.id;
-	resourceState.nativeSubagentMonitor?.bindTurn(turn.turn.id);
-	return { turn };
+	turnIdRef.current = started.turn.turn.id;
+	resourceState.nativeSubagentMonitor?.bindTurn(started.turn.turn.id);
+	return started;
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-deadlines.ts
@@ -7791,36 +8432,30 @@ function createCodexAttemptDeadlineController(params) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-state.ts
 const CODEX_NATIVE_HOOK_RELAY_RENEW_INTERVAL_MS = 6e4;
+var CodexAttemptState = class {
+	constructor() {
+		this.completed = false;
+		this.abortCleanup = Promise.resolve();
+		this.localCompletionRequested = false;
+		this.terminalTurnNotificationQueued = false;
+		this.sawCodexInterruptMarker = false;
+		this.clientClosedAbort = false;
+		this.shouldDelayNativeHookRelayUnregister = false;
+		this.lifecycleStarted = false;
+		this.lifecycleTerminalEmitted = false;
+		this.nativeHookRelayLastRenewedAt = 0;
+		this.activeAppServerTurnRequests = 0;
+		this.activeLocalProjections = 0;
+		this.projectionClosed = false;
+		this.terminalDynamicToolReleaseCheckScheduled = false;
+		this.currentTurnHadNonTerminalDynamicToolResult = false;
+	}
+};
 function createCodexAttemptTurnState(resources) {
 	const { prompt, state: resourceState, projectorRef, trajectoryRecorder, startupTimeoutMs } = resources;
 	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,
-		timeout: void 0,
-		settlementWarning: void 0,
-		pendingSettlementStage: void 0,
-		clientClosedPromptError: void 0,
-		clientClosedDiagnostic: void 0,
-		clientClosedAbort: false,
-		shouldDelayNativeHookRelayUnregister: false,
-		lifecycleStarted: false,
-		lifecycleTerminalEmitted: false,
-		nativeHookRelayLastRenewedAt: 0,
-		activeAppServerTurnRequests: 0,
-		activeLocalProjections: 0,
-		projectionClosed: false,
-		pendingTerminalDynamicToolRelease: void 0,
-		terminalDynamicToolReleaseCheckScheduled: false,
-		currentTurnHadNonTerminalDynamicToolResult: false
-	};
+	const state = new CodexAttemptState();
 	const { promise: completion, resolve: resolveCompletion } = createDeferred();
 	const settlementExpired = createDeferred();
 	const pendingOpenClawDynamicToolCompletionIds = /* @__PURE__ */ new Set();
@@ -7846,19 +8481,28 @@ function createCodexAttemptTurnState(resources) {
 		if (!completed) await closeCodexStartupClientBestEffort(resourceState.client);
 		return completed;
 	};
+	let pendingNativeHookRenewal;
 	const renewNativeHookRelayForTurnProgress = () => {
-		if (!resourceState.nativeHookRelay || options.nativeHookRelay?.ttlMs !== void 0) return;
+		if (!resourceState.nativeHookRelay || options.nativeHookRelay?.ttlMs !== void 0 || pendingNativeHookRenewal) return;
 		const now = Date.now();
 		const renewsRecently = now - state.nativeHookRelayLastRenewedAt < CODEX_NATIVE_HOOK_RELAY_RENEW_INTERVAL_MS;
 		const expiresSoon = now >= resourceState.nativeHookRelay.expiresAtMs - CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS;
 		if (renewsRecently && !expiresSoon) return;
-		state.nativeHookRelayLastRenewedAt = now;
-		resourceState.nativeHookRelay.renew(resolveCodexNativeHookRelayTtlMs({
+		const relay = resourceState.nativeHookRelay;
+		relay.renew(resolveCodexNativeHookRelayTtlMs({
 			explicitTtlMs: void 0,
 			attemptTimeoutMs: params.timeoutMs,
 			startupTimeoutMs,
 			turnStartTimeoutMs: params.timeoutMs
 		}));
+		pendingNativeHookRenewal = relay.drain();
+		pendingNativeHookRenewal.then(() => {
+			pendingNativeHookRenewal = void 0;
+			if (resourceState.nativeHookRelay === relay) state.nativeHookRelayLastRenewedAt = now;
+		}, (error) => {
+			pendingNativeHookRenewal = void 0;
+			embeddedAgentLog.debug("native hook relay renewal did not drain", { error });
+		});
 	};
 	const noteProgress = (reason) => {
 		if (state.completed || state.projectionClosed || runAbortController.signal.aborted) return;
@@ -7948,32 +8592,50 @@ async function runCodexAppServerAttempt(params, options) {
 			const attemptContext = await preparation.measure("context", () => prepareCodexAttemptContext(runtime, attemptTools));
 			const resources = prepareCodexAttemptResources(await preparation.measure("prompt", () => prepareCodexAttemptPrompt(attemptContext)));
 			attemptTools.runtimeYieldCompletionClaim.current = () => resources.state.nativeHookRelay?.hasClaimedDirectChild() ?? false;
-			await preparation.measure("runtime-start", () => startCodexAttemptRuntime(resources));
-			const turnRuntime = createCodexAttemptTurnState(resources);
+			let activeTurnOwnsCleanup = false;
 			try {
-				const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
-				const notifications = createCodexAttemptNotificationController(resources, turnRuntime, lifecycle);
-				const serverRequests = createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle);
-				const { ensureCurrentThreadRoute } = await preparation.measure("thread-route", () => prepareCodexAttemptRoute(resources, turnRuntime, notifications, serverRequests.handleServerRequest));
-				const turnRequest = await preparation.measure("turn-request", () => prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, notifications.waitForActiveNativeTurnCompletion));
-				preparation.ready();
-				const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
-				if ("result" in turnStart) return turnStart.result;
-				const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart.turn);
-				let finalizedResult;
+				await preparation.measure("runtime-start", () => startCodexAttemptRuntime(resources));
+				const turnRuntime = createCodexAttemptTurnState(resources);
 				try {
-					await activeTurn.ready;
-					finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
+					const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
+					const notifications = createCodexAttemptNotificationController(resources, turnRuntime, lifecycle);
+					const serverRequests = createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle, notifications.waitForNativeTerminalItems);
+					const { ensureCurrentThreadRoute } = await preparation.measure("thread-route", () => prepareCodexAttemptRoute(resources, turnRuntime, notifications, serverRequests.handleServerRequest));
+					const turnRequest = await preparation.measure("turn-request", () => prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, notifications.waitForActiveNativeTurnCompletion));
+					preparation.ready();
+					const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
+					if ("result" in turnStart) return turnStart.result;
+					const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart);
+					activeTurnOwnsCleanup = true;
+					let finalizedResult;
+					try {
+						try {
+							await activeTurn.ready;
+							finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
+						} finally {
+							await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
+						}
+					} catch (error) {
+						if (!finalizedResult || !turnRuntime.state.pluginRuntimeRefreshStop) throw error;
+						const original = attemptTerminal.project(finalizedResult.terminal).promptError;
+						finalizedResult.terminal = attemptTerminal.merge(finalizedResult.terminal, {
+							kind: "failed",
+							source: "prompt",
+							error: new AggregateError(original ? [original, error] : [error], "Plugin runtime changed, but native continuation failed. Inspect the existing thread before continuing; do not repeat completed actions.")
+						});
+						delete finalizedResult.pluginRuntimeRefreshMessages;
+						delete finalizedResult.settledTurnFinalizationContext;
+					}
+					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;
 			} finally {
-				turnRuntime.deadlines.dispose();
+				if (!activeTurnOwnsCleanup) await resources.cleanupBeforeActiveTurn();
 			}
 		} finally {
-			await attemptTools.disposeMcpTools();
+			await attemptTools.disposeTools(connection.runAbortController.signal.aborted ? "cancel" : "error");
 		}
 	} finally {
 		params.abortSignal?.removeEventListener("abort", connection.abortFromUpstream);