@openclaw/codex 2026.9.3 → 2026.9.5

package/dist/{run-attempt-DwKds3DN.js → .setup/run-attempt-rlA07pUv.mjs}

@@ -1,59 +1,64 @@
-import { l as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-CaZjYwNS.js";
-import { n as defineCodexBuildState } from "./build-state-6RL6qohz.js";
-import { b as readCodexRequirementsToml, c as hasCodexMcpToolApprovalOverrides, d as withMcpElicitationsApprovalPolicy, i as resolveCodexAppServerHomeScope, m as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig, u as shouldAutoApproveCodexAppServerApprovals } from "./config-options-jnIFvwxD.js";
-import { S as resolveCodexPluginsPolicy, a as flattenCodexDynamicToolFunctions, b as isCodexSandboxExecServerEnabled, o as isJsonObject, s as resolveCodexAppServerHomeDir, v as isCodexPairedNodeRemoteExecPlacementSandbox, x as readCodexPluginConfig, y as isCodexRemoteExecPlacementSandbox } from "./protocol-CAAcVIKF.js";
-import { A as isMatchingDynamicToolTerminalDiagnostic, D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, F as toCodexDynamicToolProgressResponse, I as toCodexDynamicToolProtocolResponse, L as resolveCodexToolAbortTerminalReason, M as resolveTerminalDynamicToolBatchAction, N as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, O as hasPendingDynamicToolTerminalDiagnostic, P as shouldReleaseTurnAfterTerminalDynamicTool, S as readCodexDynamicToolCallParams, T as readCodexTurnCompletedNotification, a as isCodexAppServerBrokenPipeError, c as isCodexAppServerIndeterminateTransportError, d as isCodexAppServerRequestTimeoutError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, l as isCodexAppServerOverloadError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError, w as readCodexTurn, x as assertCodexTurnStartResponse } from "./client-BEKu4yDx.js";
-import { c as resolveCodexAppServerPreparedApiKeyCacheKey, m as retireSharedCodexAppServerClientIfCurrent, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-Kq6oerr6.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-Bqnx1N4z.js";
-import { a as formatCodexDisplayText } from "./command-formatters-DeTfrapr.js";
-import { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-BeqLPbtM.js";
-import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey, s as defaultCodexAppInventoryCache } from "./plugin-app-cache-key-CdSQzWyX.js";
-import { t as withAbortableTimeout } from "./timeout-BVw8aaM1.js";
-import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-JDfTI4VI.js";
-import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-DibE0krH.js";
-import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Co2Vfcf_.js";
-import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-QqgcPCgk.js";
-import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CwzO4_RG.js";
-import { B as prepareCodexWorkspaceReferences, D as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, E as CodexAppServerStartupError, F as ensureCodexAppServerClientRuntime, J as rememberCodexRateLimitsRead, K as readCodexRateLimitsRevision, M as withCodexStartupTimeout, O as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, V as protectCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, Z as resolveCodexAppServerPreparedAuthHandoff, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, j as resolveCodexStartupTimeoutMs, k as isCodexAppServerStartupError, l as getSharedCodexAppServerClient, q as readRecentCodexRateLimits, s as createIsolatedCodexAppServerClient, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent } from "./shared-client-CVhez2Uo.js";
-import { F as readCodexProviderRefusal, H as readNullableString, L as readItem, M as extractRawAssistantText, O as matchesCodexSnapshotTurn, P as readCodexErrorNotificationMessage, R as readItemString, U as splitPlanText, V as readNonNegativeInteger, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, k as shouldClearTerminalPresentationForNativeItem, l as retireUnsafeCodexTurnClientBestEffort, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, u as terminateCodexBackgroundTerminals } from "./attempt-client-cleanup-D6cR54TV.js";
-import { a as isRawFunctionToolOutputCompletionNotification, c as readNotificationItemId, i as isPendingOpenClawDynamicToolCompletionNotification, l as readRawResponseToolCallId, o as isTerminalTurnStatus, r as isCodexTurnAbortMarkerNotification, s as readCodexNotificationItem, t as codexExecutionToolName, u as updateActiveTurnItemIds } from "./attempt-notifications--H8zXR5-.js";
-import { t as CodexUsageProjection } from "./event-projector-usage-CIyrYYid.js";
-import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-CoRCzWW4.js";
-import { $ as codexLegacyDynamicToolsFingerprint, A as readCodexMcpToolConnectorId, B as emitCodexNativePreToolUseFailureDiagnostic, C as buildDeveloperInstructions, Ct as buildCodexPluginThreadConfigTimeoutFallback, D as resolveCodexAppServerThreadModelSelection, Dt as shouldBuildCodexPluginThreadConfig, H as resolveCodexNativeHookRelayTtlMs, I as buildCodexNativeHookRelayConfig, K as hasCodexNativeToolCatalog, L as buildCodexNativeHookRelayDisabledConfig, M as isCodexAppServerProfilerEnabled, P as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, Q as codexDynamicToolsFingerprint, S as resolveCodexWebSearchPlan, St as buildCodexPluginThreadConfigInputFingerprint, Tt as mergeCodexThreadConfigs, U as scheduleCodexNativeHookRelayUnregister, V as resolveCodexNativeHookRelayEvents, _t as projectContextEngineAssemblyForCodex, bt as resolveCodexContinuityProjectionMaxChars, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, ft as CodexContextAttachmentError, gt as neutralizeCodexExplicitMentionSigils, h as resolveScheduledCodexAppCreatorCaptureDecision, ht as isCodexDurableCustomMessage, i as buildCodexUserInput, j as readCodexMcpToolUiVisibility, l as buildLegacyScheduledCodexAppRecoveryPrompt, lt as resolveCodexDynamicToolsLoadingForRuntime, m as readCurrentCodexScheduledAppPolicy$1, mt as fitCodexProjectedContextForTurnStart, n as buildTurnCollaborationMode, nt as filterCodexDynamicTools, ot as isSystemAgentOnlyCodexDynamicToolAllowlist, p as intersectCodexPluginThreadConfigWithScheduledAuthority, pt as buildCodexContinuityCalibration, q as loadCodexNativeToolCatalog, r as buildTurnStartParams, s as startOrResumeThread, u as buildScheduledCodexAppAuthorityInputFingerprint, ut as buildContextEngineBinding, vt as resolveCodexContextEngineProjectionMaxChars, xt as buildCodexPluginThreadConfig, yt as resolveCodexContextEngineProjectionReserveTokens, z as createCodexNativeHookRelay } from "./thread-lifecycle-D1pzRwHB.js";
-import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding, s as scopeCodexRunBindingStore } from "./session-binding-CKSepwIC.js";
-import { n as CodexThreadPolicyHandoffError } from "./thread-policy-D8kI7yAO.js";
-import { r as retainCodexAppServerBindingSubscription } from "./thread-ownership-D6oASVRu.js";
-import { i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-t5TOccct.js";
-import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.js";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BmBM4qBV.js";
-import { C as shouldRequireCodexSandboxExecServerEnvironment, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeToolLifecycleProjector, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as readBoundedCodexRemoteWorkspaceFile, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-D-JBoaLt.js";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-W4tfK5Y5.js";
-import { a as CodexToolProgressProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as resolveCodexToolProgressDetailMode, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, s as inferCodexDynamicToolMeta, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexToolArguments } from "./native-subagent-monitor-BbCUKRwC.js";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-DeW95wB5.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-B22InTp_.js";
-import { a as getCodexWorkspaceMemoryToolNames, c as readContextEngineThreadBootstrapProjection, d as resolveCodexDeliveryHintPreservedInputRange, f as resolveContextEngineBootstrapProjectionDecision, i as buildCodexWorkspaceBootstrapContext, l as readMirroredSessionHistoryMessages, n as buildCodexSystemPromptReport, r as buildCodexWatchedSessionsContext, s as prependCodexOpenClawPromptContext, t as buildCodexOpenClawPromptContext, u as renderCodexSkillsCollaborationInstructions } from "./attempt-context-AO4DSjE0.js";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-Du6gdUDd.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DgNfRAGA.js";
+import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-DUle8DLz.mjs";
+import { b as createCodexNativeSubagentHistoryOwner, i as matchesCodexNativeSubagentSubmissionBinding, n as assertCodexBindingMayBeReplaced, p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
+import { n as defineCodexBuildState } from "./build-state-Xx9ybZqa.mjs";
+import { E as readCodexRequirementsToml, h as resolveCodexAppServerHomeDir, l as shouldAutoApproveCodexAppServerApprovals, m as isJsonObject, n as hasCodexMcpToolApprovalOverrides, p as flattenCodexDynamicToolFunctions, u as withMcpElicitationsApprovalPolicy } from "./config-security-BRQ2mgW9.mjs";
+import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-CcB9iPoq.mjs";
+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, c as isCodexAppServerIndeterminateTransportError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError, w as readCodexTurn, x as assertCodexTurnStartResponse } from "./client-vXs2929Q.mjs";
+import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-BsanJ8QG.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, m as retireSharedCodexAppServerClientIfCurrent, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-QirmgiCo.mjs";
+import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-CGEkdawF.mjs";
+import { i as CodexAppServerRpcError, t as withAbortableTimeout } from "./timeout-DZF05XrR.mjs";
+import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.mjs";
+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-DyTQ_XqL.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-BOxKP7db.mjs";
+import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-Bm38niE8.mjs";
+import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-CedDWjM-.mjs";
+import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-CzM-94NC.mjs";
+import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-WqZtZfXN.mjs";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-DhLWa_7K.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-BpTtuLQ5.mjs";
+import { _ as CodexProjectionDiagnostics, a as closeCodexStartupClientBestEffort, d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, g as waitForPromiseOrAbort, l as retireUnsafeCodexTurnClientBestEffort, m as getCodexAppServerTurnRouter, o as interruptCodexTurnAndWaitBestEffort, p as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError, u as shouldRetireCodexStartupClient, v as isCodexNotificationForTurn, y as readCodexNotificationThreadId } from "./attempt-client-cleanup-BpYKdTA0.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-C7Ntzs-f.mjs";
+import { At as shouldBuildCodexPluginThreadConfig, Ct as resolveCodexContinuityProjectionMaxChars, Et as buildCodexPluginThreadConfigTimeoutFallback, G as scheduleCodexNativeHookRelayUnregister, H as emitCodexNativePreToolUseFailureDiagnostic, I as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, J as hasCodexNativeToolCatalog, M as readCodexMcpToolUiVisibility, Ot as mergeCodexThreadConfigs, P as isCodexAppServerProfilerEnabled, R as buildCodexNativeHookRelayConfig, St as resolveCodexContextEngineProjectionReserveTokens, T as buildDeveloperInstructions, Tt as buildCodexPluginThreadConfigInputFingerprint, U as resolveCodexNativeHookRelayEvents, V as createCodexNativeHookRelay, W as resolveCodexNativeHookRelayTtlMs, Y as loadCodexNativeToolCatalog, _ as resolveScheduledCodexAppCreatorCaptureDecision, _t as fitCodexProjectedContextForTurnStart, a as buildTurnStartParams, bt as projectContextEngineAssemblyForCodex, ct as isSystemAgentOnlyCodexDynamicToolAllowlist, d as buildLegacyScheduledCodexAppRecoveryPrompt, dt as resolveCodexDynamicToolsLoadingForRuntime, et as codexDynamicToolsFingerprint, f as buildScheduledCodexAppAuthorityInputFingerprint, ft as buildContextEngineBinding, g as readCurrentCodexScheduledAppPolicy$1, gt as buildCodexContinuityCalibration, h as intersectCodexPluginThreadConfigWithScheduledAuthority, ht as CodexContextAttachmentError, i as buildTurnCollaborationMode, it as filterCodexDynamicTools, j as readCodexMcpToolConnectorId, k as resolveCodexAppServerThreadModelSelection, l as startOrResumeThread, m as captureScheduledCodexAppAuthority, mt as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, p as buildScheduledCodexAppServerConnectionIdentity, t as buildCodexHistoryProvenancePrefix, tt as codexLegacyDynamicToolsFingerprint, u as assertScheduledCodexAppAuthorityRuntime, vt as isCodexDurableCustomMessage, w as resolveCodexWebSearchPlan, wt as buildCodexPluginThreadConfig, xt as resolveCodexContextEngineProjectionMaxChars, yt as neutralizeCodexExplicitMentionSigils, z as buildCodexNativeHookRelayDisabledConfig } from "./thread-lifecycle-Cik28qWn.mjs";
+import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding, s as scopeCodexRunBindingStore } from "./session-binding-_0W_fHRr.mjs";
+import { n as CodexThreadPolicyHandoffError } from "./thread-policy-Cjs4B8xf.mjs";
+import { r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-skomxnIt.mjs";
+import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-D4qp_leP.mjs";
+import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-C0ow7DOc.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-fulhZuz8.mjs";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-DNUR1s0A.mjs";
+import { _ as inferCodexDynamicToolMeta, b as sanitizeCodexToolArguments, v as isCodexCommandBearingToolCall, x as sanitizeCodexToolResponse, y as resolveCodexToolProgressDetailMode } from "./native-subagent-task-ids-DsuOonKv.mjs";
+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-D16lOp67.mjs";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-B8J4Dy-O.mjs";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-CjfzafAZ.mjs";
+import { a as CodexToolProgressProjection, i as CodexToolTranscriptProjection, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-B1hxzIOy.mjs";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-DhurXY0l.mjs";
+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-VXVwTCfS.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-DsS5buNa.mjs";
 import { asOptionalRecord, normalizeOptionalString, 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 { 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 { Buffer as Buffer$1 } from "node:buffer";
 import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
-import { isDeepStrictEqual } from "node:util";
-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 { 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, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, 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 { parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
-import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { getSessionEntry, parseSqliteSessionFileMarker } 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 { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
@@ -62,7 +67,6 @@ import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generat
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
-import { acknowledgeInternalToolResult } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
 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. */
@@ -122,6 +126,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();
@@ -147,9 +152,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();
@@ -167,7 +176,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);
 	};
@@ -186,13 +195,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 {
@@ -203,17 +213,17 @@ 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) }));
 				} 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);
@@ -226,7 +236,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, {
@@ -235,7 +245,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;
@@ -243,15 +253,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;
 		}
 	};
@@ -324,6 +331,7 @@ function createCodexSteeringQueue(params) {
 			for (const item of batch.items) resolveItem(item);
 			return true;
 		},
+		getAcceptedMessages: () => acceptedMessages.slice(),
 		sealAdmission: sealQueueAdmission,
 		cancel: cancelQueue
 	};
@@ -333,9 +341,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) {
@@ -349,6 +354,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();
@@ -412,7 +418,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;
@@ -421,6 +427,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);
@@ -524,14 +534,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) {
@@ -612,6 +619,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";
@@ -751,7 +763,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
 		};
 	}
@@ -970,8 +982,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;
@@ -981,16 +992,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
@@ -1030,10 +1039,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({
@@ -1051,7 +1077,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");
@@ -1065,6 +1091,7 @@ var CodexReasoningProjection = class {
 				title: "Plan updated",
 				source,
 				...params.explanation ? { explanation: params.explanation } : {},
+				...params.explanationFormat ? { explanationFormat: params.explanationFormat } : {},
 				...params.steps ? { steps: params.steps } : {}
 			}
 		});
@@ -1074,16 +1101,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
@@ -1152,7 +1175,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) {
@@ -1162,6 +1186,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)
 	}));
 }
@@ -1189,164 +1214,6 @@ 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() {
@@ -1413,6 +1280,7 @@ var CodexTranscriptCheckpoint = class {
 				const message = entry.read();
 				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
 					hidden: this.params.trigger === "memory",
+					inputProvenance: this.params.inputProvenance,
 					message: applyCodexTranscriptTaint(message, taint)
 				})] : [];
 			});
@@ -1482,7 +1350,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);
 	}
@@ -1539,6 +1407,7 @@ var CodexTurnProjection = class {
 			asyncMessages,
 			commentaryMessages,
 			toolMessages: this.toolTranscriptProjection.transcriptMessages,
+			steeringMessages: options?.steeringMessages,
 			lastAssistant,
 			turnTainted
 		});
@@ -1685,6 +1554,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":
@@ -1748,6 +1618,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) {
@@ -1755,6 +1628,7 @@ 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({
@@ -1775,8 +1649,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 			case "item/fileChange/patchUpdated":
 			case "item/mcpToolCall/progress":
 			case "model/verification":
-			case "turn/moderationMetadata":
-			case "model/safetyBuffering/updated": break;
+			case "turn/moderationMetadata": break;
 			default: this.diagnostics.warnUnknownEvent(notification, params);
 		}
 		if (!this.projectionClosed && [
@@ -1785,6 +1658,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);
 	}
@@ -1794,7 +1684,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");
 		}
@@ -1821,8 +1712,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) {
@@ -1870,10 +1762,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);
@@ -1882,7 +1776,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) {
@@ -1943,11 +1837,13 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		const turn = readCodexTurn(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,
@@ -1974,7 +1870,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);
@@ -2007,6 +1903,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));
@@ -2288,7 +2185,9 @@ function createCodexUserInputBridge(params) {
 			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);
+			const response = job.abort.signal.aborted ? job.cancelValue : value ?? job.failureValue;
+			job.onResponse?.(response);
+			job.resolve(response);
 		}).finally(() => {
 			if (jobs[0] === job) jobs.shift();
 			activeCompletion = void 0;
@@ -2351,6 +2250,11 @@ function createCodexUserInputBridge(params) {
 				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;
@@ -2377,7 +2281,7 @@ function createCodexUserInputBridge(params) {
 				});
 			}
 			if (readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
-			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.js");
+			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.mjs");
 			const compiled = compileCodexOrdinaryElicitation({
 				snapshot: requestSnapshot,
 				turnId: params.turnId
@@ -2435,6 +2339,7 @@ function readUserInputParams(value) {
 	return {
 		threadId,
 		turnId,
+		itemId,
 		questions: parsed,
 		isBlocking: readValue(snapshot, "isBlocking") !== false
 	};
@@ -2546,6 +2451,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
 	userInputBridgeRef.current = createCodexUserInputBridge({
 		paramsForRun: params,
+		onOrdinaryResponse: (response) => projectorRef.current?.recordUserInputResponse(response),
 		threadId: resourceState.thread.threadId,
 		turnId: activeTurnId,
 		signal: runAbortController.signal
@@ -2633,7 +2539,10 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		state.terminalTurnNotificationQueued = true;
 		deadlines.beginSettlement(Date.now());
 	}
-	emitLifecycleStart();
+	emitLifecycleStart({
+		provider: projectionParams.provider,
+		model: projectionParams.modelId
+	});
 	const activeProjector = projectorRef.current;
 	noteProgress("turn:start");
 	const abortListener = () => {
@@ -2729,12 +2638,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(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) {
@@ -2858,6 +2788,11 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		cancel: () => abortExplicitly("cancelled"),
 		abort: () => abortExplicitly("aborted")
 	};
+	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);
+	}
+	const projectionReady = bindProjection();
 	params.replyOperation?.attachBackend(handle);
 	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
 	const freezeRunTerminalOutcome = () => {
@@ -2878,7 +2813,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		freezeRunTerminalOutcome,
 		notifyUserMessagePersisted,
 		abortListener,
-		ready: bindProjection()
+		ready: projectionReady
 	};
 }
 //#endregion
@@ -2891,6 +2826,8 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	const { maybeEmitFastModeAutoResetBestEffort, emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, abortListener, handle, freezeRunTerminalOutcome } = activeTurn;
+	resourceState.releaseInferenceContext?.();
+	resourceState.releaseInferenceContext = void 0;
 	prompt.context.attemptTools.scheduledAppAuthoritySourceRef.current = void 0;
 	freezeRunTerminalOutcome();
 	const projectionClose = state.projectionClosed ? void 0 : activeTurn.activeProjector.closeProjection();
@@ -2900,6 +2837,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");
@@ -2919,8 +2857,9 @@ 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 () => {
+		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.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,
@@ -2929,20 +2868,42 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 				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 (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 unsubscribeCodexThreadBestEffort(resourceState.client, {
 					threadId: resourceState.thread.threadId,
-					timeoutMs: 5e3
+					timeoutMs: 5e3,
+					assertCurrent: connection.assertCurrent
 				})) {
 					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");
-					});
+					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 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");
+						});
+					}
 				}
 			}
 		}
@@ -2960,13 +2921,14 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		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-abort-listener-remove", () => {
@@ -2981,72 +2943,6 @@ 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
-	};
-	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
-		}
-	};
-	if (!params.messageChannel && !params.messageProvider) {
-		await awaitAgentEndSideEffects(sideEffectParams);
-		return;
-	}
-	runAgentEndSideEffects(sideEffectParams);
-}
-//#endregion
 //#region extensions/codex/src/app-server/startup-binding.ts
 const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
 const CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS = 2e4;
@@ -3467,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,
@@ -3477,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;
@@ -3521,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
 	});
@@ -3632,7 +3529,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
 			});
@@ -3660,7 +3557,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,
@@ -3778,6 +3675,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		const messages = await readMirroredSessionHistoryMessages({
 			...activeTranscriptTarget,
 			signal: connection.runAbortController.signal,
+			contextTokenBudget: effectiveContextTokenBudget,
 			...transcriptReadFence ? { admission: transcriptReadFence } : {}
 		});
 		connection.runAbortController.signal.throwIfAborted();
@@ -3802,6 +3700,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 			modelId: params.modelId
 		} : {},
 		trigger: params.trigger,
+		inputProvenance: params.inputProvenance,
 		...buildAgentHookContextChannelFields({
 			sessionKey: contextSessionKey,
 			messageChannel: params.messageChannel,
@@ -3846,6 +3745,7 @@ 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,
@@ -4212,6 +4112,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();
@@ -4231,7 +4132,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);
@@ -4476,7 +4380,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			hookRunner
 		});
 		state.shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
-		if (state.shouldDelayNativeHookRelayUnregister) 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
@@ -4521,27 +4425,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 } : {},
@@ -4668,7 +4575,7 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		state.pendingTerminalDynamicToolRelease = value;
 		scheduleTerminalDynamicToolReleaseCheck();
 	};
-	const emitLifecycleStart = () => {
+	const emitLifecycleStart = (model) => {
 		emitCodexAppServerEvent(params, {
 			stream: "lifecycle",
 			data: {
@@ -4676,10 +4583,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: {
@@ -4777,13 +4691,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 { 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,
@@ -4838,6 +4768,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();
@@ -4876,6 +4811,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);
@@ -4892,9 +4828,9 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const drainNotificationQueue = async () => {
 		await resourceState.turnRoute?.drain();
 	};
-	registerNativeSubagentMonitor(resourceState.thread.threadId);
 	return {
 		waitForActiveNativeTurnCompletion,
+		waitForNativeTerminalItems,
 		noteNotificationReceived,
 		enqueueNotification,
 		drainNotificationQueue
@@ -4910,13 +4846,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) {
@@ -4942,11 +4889,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;
@@ -4991,12 +4939,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,
@@ -5024,13 +4972,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.");
@@ -5080,23 +5032,34 @@ 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 = {
 		promptBuild: firstPromptBuild,
 		codexTurnPromptText: decorateCodexTurnPromptText(firstPromptBuild)
 	};
-	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, buildTurnCollaborationMode(params, {
+	let parentLocalEgress = false;
+	const parentLocalContext = {
 		turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
 		skillsCollaborationInstructions,
 		memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
-	}).settings.developer_instructions ?? void 0);
+	};
+	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, (parentLocalEgress ? buildCodexParentLocalInstructions(params, parentLocalContext) : buildTurnCollaborationMode(params, parentLocalContext).settings.developer_instructions) ?? void 0);
 	const rebuildCodexPromptBuildFromCurrentProjection = async () => {
 		turnState.promptBuild = await buildPromptFromCurrentInputs();
 		turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild);
@@ -5140,7 +5103,7 @@ async function prepareCodexAttemptPrompt(context) {
 	};
 	const applyNoContextEngineContinuityProjection = async (action, binding) => {
 		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
-		if (activeContextEngine || !hasContinuity) return false;
+		if (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;
@@ -5184,7 +5147,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) });
 			}
@@ -5213,10 +5176,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);
@@ -5225,6 +5189,10 @@ async function prepareCodexAttemptPrompt(context) {
 				workspaceReferencesIncluded = include;
 			}
 		},
+		setParentLocalEgress: () => {
+			parentLocalEgress = true;
+			Object.assign(systemPromptReport, buildSystemPromptReport(!workspaceReferencesIncluded));
+		},
 		buildRenderedCodexDeveloperInstructions,
 		rebuildCodexTurnPromptTextFromCurrentProjection,
 		applyNoContextEngineContinuityProjection,
@@ -5280,6 +5248,7 @@ function prepareCodexAttemptResources(prompt) {
 		sharedCodexClientRetiredForOneShotCleanup: false,
 		sandboxExecEnvironment: void 0,
 		executionDisconnectError: void 0,
+		releaseInferenceContext: void 0,
 		codexEnvironmentSelection: void 0,
 		codexExecutionCwd: effectiveCwd,
 		codexSandboxPolicy: void 0,
@@ -5366,17 +5335,65 @@ 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({
+			agentId: sessionAgentId,
+			sessionKey,
+			storePath,
+			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,
+			submissionStore,
 			agentId: sessionAgentId,
 			retainClient: () => retainSharedCodexAppServerClientIfCurrent(state.client),
 			retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(state.client, protectedThreadId),
@@ -5387,13 +5404,15 @@ function prepareCodexAttemptResources(prompt) {
 			} } : {}
 		});
 	};
-	const releaseCurrentRoute = () => {
+	const releaseCurrentRoute = async () => {
+		state.releaseInferenceContext?.();
+		state.releaseInferenceContext = void 0;
 		state.detachRouteAbort();
 		state.detachRouteAbort = () => void 0;
 		state.turnRoute?.release();
 		state.turnRoute = void 0;
 		state.routeActivated = false;
-		unregisterNativeSubagentMonitor();
+		await unregisterNativeSubagentMonitor();
 	};
 	const startupTimeoutMs = resolveCodexStartupTimeoutMs({
 		timeoutMs: params.timeoutMs,
@@ -5401,8 +5420,11 @@ 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();
 		if (params.pluginHarnessToolPolicyRestricted === true) {
 			state.nativeHookRelay = void 0;
 			return {
@@ -5446,6 +5468,8 @@ function prepareCodexAttemptResources(prompt) {
 				else pendingNativePreToolUseFailures.push(failure);
 			}
 		});
+		await state.nativeHookRelay?.prepareInvocation();
+		connection.assertCurrent();
 		return {
 			configPatch: state.nativeHookRelay ? buildCodexNativeHookRelayConfig({
 				relay: state.nativeHookRelay,
@@ -5478,7 +5502,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, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseOnce, runCleanupStep } = resources;
 	const { connection } = prompt.context.runtime;
 	const { runAbortController } = connection;
 	const { state, turnIdRef, completeTurn } = turnRuntime;
@@ -5511,12 +5535,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,
@@ -5531,8 +5555,18 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 		await ensureCurrentThreadRoute();
 	} catch (error) {
 		activateNativePreToolUseFailureFallback();
-		releaseCurrentRoute();
-		resourceState.nativeHookRelay?.unregister();
+		await runCleanupStep("codex-route-failure-route-release", releaseCurrentRoute);
+		const relay = resourceState.nativeHookRelay;
+		relay?.unregister();
+		await runAgentCleanupStep({
+			runId: connection.params.runId,
+			sessionId: connection.params.sessionId,
+			step: "codex-route-failure-native-hook-relay",
+			log: embeddedAgentLog,
+			cleanup: async () => {
+				await relay?.drain();
+			}
+		});
 		await releaseSandboxExecEnvironment();
 		releaseSharedClientLeaseOnce();
 		throw error;
@@ -5659,7 +5693,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,
@@ -5837,7 +5871,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;
@@ -5847,7 +5881,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;
@@ -5908,7 +5959,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();
@@ -5948,8 +6001,10 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			});
 			const dynamicToolTimeoutMs = resolveDynamicToolCallTimeoutMs({
 				call,
-				config: params.config
+				config: params.config,
+				toolBridge
 			});
+			setExecutionTimeoutMs?.(dynamicToolTimeoutMs);
 			const toolStartedAt = Date.now();
 			let terminalDiagnosticObserved = false;
 			const unsubscribeToolDiagnosticObserver = onInternalDiagnosticEvent((event) => {
@@ -6055,7 +6110,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
@@ -6081,6 +6137,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);
@@ -6100,7 +6157,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-T-NwqeSH.js");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Dy38Z5iU.mjs");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6123,7 +6180,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,
@@ -6135,7 +6192,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
@@ -6151,21 +6208,23 @@ 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({
 			config,
+			tools,
 			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, { timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs })
 		});
 		if (!liveTest.ok) {
@@ -6368,6 +6427,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,
@@ -6416,15 +6476,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)}`, {
@@ -6586,7 +6647,8 @@ async function startCodexAttemptThread(params) {
 							startupSandboxEnvironmentAcquired = false;
 							startCodexComputerUseHealthMonitor({
 								client: activeStartupClient,
-								config: params.computerUseConfig
+								config: params.computerUseConfig,
+								tools: computerUseTools
 							});
 							startupAttemptSucceeded = true;
 							return {
@@ -6621,7 +6683,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;
@@ -6632,13 +6693,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", {
@@ -6649,8 +6717,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,
@@ -6681,10 +6749,6 @@ 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) {
@@ -6772,10 +6836,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,
@@ -6816,12 +6881,16 @@ 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-native-hook-relay", async () => {
+			nativeHookRelay?.unregister();
+			await nativeHookRelay?.drain();
+		});
 		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;
@@ -7047,6 +7116,45 @@ async function prepareCodexAttemptTools(runtime) {
 		...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",
+			"deny"
+		];
+		const outcome = await requestPluginApprovalOutcome({
+			hostCapabilities: params.hostCapabilities,
+			signal: approval.signal,
+			title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
+			description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
+			allowedDecisions,
+			toolName: approval.safeToolName,
+			toolCallId: approval.toolCallId,
+			mcpTool: {
+				server: approval.serverName,
+				tool: approval.toolName
+			},
+			isMcpToolApprovalActive: approval.isActive
+		});
+		if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
+	};
+	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}`);
+	};
 	const configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
@@ -7060,28 +7168,7 @@ async function prepareCodexAttemptTools(runtime) {
 		toolOverrides: codexMcpToolOverrides,
 		autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
 		projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
-		...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: async (approval) => {
-			const allowedDecisions = approval.mode === "prompt" ? ["allow-once", "deny"] : [
-				"allow-once",
-				"allow-always",
-				"deny"
-			];
-			const outcome = await requestPluginApprovalOutcome({
-				hostCapabilities: params.hostCapabilities,
-				signal: approval.signal,
-				title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
-				description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
-				allowedDecisions,
-				toolName: approval.safeToolName,
-				toolCallId: approval.toolCallId,
-				mcpTool: {
-					server: approval.serverName,
-					tool: approval.toolName
-				},
-				isMcpToolApprovalActive: approval.isActive
-			});
-			if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
-		} } : {},
+		...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: requestInteractiveMcpApproval } : {},
 		policyContext,
 		warn: (message) => embeddedAgentLog.warn(message)
 	}) : void 0;
@@ -7104,6 +7191,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,
@@ -7274,7 +7363,7 @@ async function resolveCodexExplicitSkillInputs(params) {
 //#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;
@@ -7332,14 +7421,14 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		connection.mutable.pluginAppServer = turnAppServer;
 		const references = prepareWorkspaceReferences();
 		const referencesRetained = turnState.codexTurnPromptText.includes(workspaceBootstrapContext.promptContext ?? "");
-		const turnStartParams = buildTurnStartParams({
-			...runtimeParams,
-			images: [...prompt.contextImages, ...runtimeParams.images ?? []]
-		}, {
+		const inferenceRoute = usesSupervisionConnection ? void 0 : getCodexInferenceThread(resourceState.client, resourceState.thread.threadId);
+		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,
@@ -7352,10 +7441,49 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			skillsCollaborationInstructions: context.skillsCollaborationInstructions,
 			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
 			preserveNativeTurnSettings: usesSupervisionConnection,
+			parentLocalEgress: inferenceRoute !== void 0,
 			messageToolAvailable: toolBridge.availableTools.some((tool) => tool.name === "message"),
 			requireExplicitMessageTarget: attemptTools.requireExplicitMessageTarget,
 			sessionStatusAvailable: toolBridge.availableTools.some((tool) => tool.name === "session_status")
 		});
+		if (inferenceRoute) {
+			prompt.setParentLocalEgress();
+			resourceState.releaseInferenceContext?.();
+			const inferenceThread = resourceState.thread;
+			const registration = inferenceRoute.context.register({
+				threadId: resourceState.thread.threadId,
+				text: buildCodexParentLocalInstructions(runtimeParams, {
+					turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
+					skillsCollaborationInstructions: context.skillsCollaborationInstructions,
+					memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
+				}) ?? "",
+				signal: runAbortController.signal,
+				assertCurrent: () => {
+					params.hostCapabilities.assertActive();
+					connection.assertCurrent();
+					if (resourceState.thread !== inferenceThread || getCodexInferenceThread(resourceState.client, inferenceThread.threadId) !== inferenceRoute) throw new Error("Codex inference thread ownership changed");
+					inferenceThread.liveThreadOwnership?.assertCurrent();
+				}
+			});
+			resourceState.releaseInferenceContext = registration.release;
+			turnStartParams.responsesapiClientMetadata = {
+				...turnStartParams.responsesapiClientMetadata,
+				[CODEX_INFERENCE_GENERATION_KEY]: registration.generation
+			};
+		} else if (!usesSupervisionConnection) {
+			embeddedAgentLog.warn("Codex parent-local egress workaround is unavailable for this connection or native network profile; legacy collaboration delivery is not guaranteed.");
+			prompt.systemPromptReport.source = "estimate";
+			prompt.systemPromptReport.injectedWorkspaceFiles = prompt.systemPromptReport.injectedWorkspaceFiles.map((file) => [
+				"SOUL.MD",
+				"IDENTITY.MD",
+				"USER.MD"
+			].includes(file.name.toUpperCase()) ? {
+				...file,
+				injectionStatus: "native_unverified",
+				injectedChars: null,
+				truncated: null
+			} : file);
+		}
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
 		recordCodexTrajectoryContext(resources.trajectoryRecorder, {
 			attempt: params,
@@ -7398,7 +7526,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 				});
 				if (resourceState.startupClientUnsafe) await retireUnsafeCodexTurnClientBestEffort(resourceState.client, "startup interrupt");
 			} finally {
-				releaseCurrentRoute();
+				await releaseCurrentRoute();
 			}
 			else await activeTurnRoute.cancelTurn();
 			throw error;
@@ -7425,7 +7553,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 {
@@ -7605,9 +7733,19 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 					cleanup: async () => closeCodexStartupClientBestEffort(resourceState.client)
 				});
 			}
-			releaseCurrentRoute();
+			await releaseCurrentRoute();
 			activateNativePreToolUseFailureFallback();
-			resourceState.nativeHookRelay?.unregister();
+			const relay = resourceState.nativeHookRelay;
+			relay?.unregister();
+			await runAgentCleanupStep({
+				runId: params.runId,
+				sessionId: params.sessionId,
+				step: "codex-turn-start-failure-native-hook-relay",
+				log: embeddedAgentLog,
+				cleanup: async () => {
+					await relay?.drain();
+				}
+			});
 			await releaseSandboxExecEnvironment();
 			await runAgentCleanupStep({
 				runId: params.runId,
@@ -7720,36 +7858,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();
@@ -7775,19 +7907,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;
@@ -7882,7 +8023,7 @@ async function runCodexAppServerAttempt(params, options) {
 			try {
 				const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
 				const notifications = createCodexAttemptNotificationController(resources, turnRuntime, lifecycle);
-				const serverRequests = createCodexAttemptServerRequestController(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();
@@ -7891,10 +8032,22 @@ async function runCodexAppServerAttempt(params, options) {
 				const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart.turn);
 				let finalizedResult;
 				try {
-					await activeTurn.ready;
-					finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
-				} finally {
-					await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
+					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;