@openclaw/codex 2026.10.1-beta.2 → 2026.10.5-beta.1

package/dist/.setup/{run-attempt-BLDZeYLD.mjs → run-attempt-Dx7a4Mfm.mjs}

@@ -1,88 +1,93 @@
 import { n as readCodexRuntimeModelId } from "./model-runtime-BdqzOMkU.mjs";
-import { g as createCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-BDqhOdJp.mjs";
+import { g as createCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-DmVhedNs.mjs";
 import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
-import { i as matchesCodexNativeSubagentSubmissionBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-BZB8RgcF.mjs";
-import { n as defineCodexBuildState } from "./build-state-CqQnsg7T.mjs";
-import { c as shouldAutoApproveCodexAppServerApprovals, f as readCodexRequirementsToml, l as withMcpElicitationsApprovalPolicy, n as hasCodexMcpToolApprovalOverrides } from "./config-security-KAPScztc.mjs";
-import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-BQq-CHTF.mjs";
+import { i as matchesCodexNativeSubagentSubmissionBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-DU_0biMD.mjs";
+import { n as defineCodexBuildState } from "./build-state-CzLMy1S9.mjs";
+import { c as withMcpElicitationsApprovalPolicy, d as readCodexRequirementsToml, n as hasCodexMcpToolApprovalOverrides, s as shouldAutoApproveCodexAppServerApprovals } from "./config-security-clxAZYWX.mjs";
+import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-DsWSCPHO.mjs";
 import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
 import { t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
-import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-HG_Rr3W_.mjs";
-import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey, w as retireSharedCodexAppServerClientIfCurrent } from "./auth-cache-key-CGm0UJOr.mjs";
-import { o as formatCodexDisplayText } from "./command-formatters-DV3DHhdr.mjs";
-import { a as codexPrewriteRejectionCause, i as CodexAppServerScopedRequestRejectedError, r as CodexAppServerRpcError } from "./rpc-error-hmWM21RB.mjs";
-import { n as waitForPromiseOrAbort } from "./timeout-CXOfNoaX.mjs";
+import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-DDzeNQ8m.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey, w as retireSharedCodexAppServerClientIfCurrent } from "./auth-cache-key-DyfUvsSa.mjs";
+import { i as withCodexAppServerGitConfig } from "./transport-stdio-CRWTkKOn.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-xW9KpoSZ.mjs";
+import { a as codexPrewriteRejectionCause, i as CodexAppServerScopedRequestRejectedError, r as CodexAppServerRpcError } from "./rpc-error-C98SHchT.mjs";
+import { n as waitForPromiseOrAbort } from "./timeout-D0mEWSGG.mjs";
 import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.mjs";
-import { i as readCodexProviderRefusal, n as extractRawAssistantText, o as readItem, r as readCodexErrorNotificationMessage, s as readNullableString } from "./event-projector-values-DTqZHizf.mjs";
-import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-fXkKbPVC.mjs";
-import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BW8rd98k.mjs";
-import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-C-08ez1w.mjs";
-import { n as requestCodexAppServerClientJson } from "./request-jSbhc1sg.mjs";
-import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-0Gxk3_eq.mjs";
-import { a as isCodexDurableCustomMessage, c as resolveCodexContextEngineProjectionMaxChars, i as fitCodexProjectedContextForTurnStart, l as resolveCodexContinuityProjectionMaxChars, n as CodexContextAttachmentError, o as neutralizeCodexExplicitMentionSigils, r as buildCodexContinuityCalibration, s as projectContextEngineAssemblyForCodex, t as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, u as resolveProjectionPromptBudgetTokens } from "./context-engine-projection-CsgYSQhW.mjs";
-import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-YSegaktH.mjs";
-import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BogBHKLk.mjs";
+import { i as readCodexProviderRefusal, n as extractRawResponseItemText, o as readItem, r as readCodexErrorNotificationMessage, s as readNullableString } from "./event-projector-values-CLvG1Hil.mjs";
+import { i as readMirrorIdentity, n as attachCodexMirrorIdentity, t as attachCodexAssistantItemIds } from "./upstream-prompt-provenance-Ccd9MFRJ.mjs";
+import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-Bg9DbDI6.mjs";
+import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-B7HAAZSI.mjs";
+import { n as requestCodexAppServerClientJson } from "./request-Y8dmbqZ3.mjs";
+import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-C1YVVLEA.mjs";
+import { a as isCodexDurableCustomMessage, c as resolveCodexContextEngineProjectionMaxChars, i as fitCodexProjectedContextForTurnStart, l as resolveCodexContinuityProjectionMaxChars, n as CodexContextAttachmentError, o as neutralizeCodexExplicitMentionSigils, r as buildCodexContinuityCalibration, s as projectContextEngineAssemblyForCodex, t as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, u as resolveProjectionPromptBudgetTokens } from "./context-engine-projection-ps-yn_ci.mjs";
+import { a as buildCodexMirrorIdempotencyKey, i as buildCodexMirrorDedupeIdentity, s as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-BzUXnrvv.mjs";
+import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BO6i_pfk.mjs";
 import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CgHQ8Vot.mjs";
-import { E as isCodexContextRestartSelectionChangedError, H as prepareCodexWorkspaceReferences, I as ensureCodexAppServerClientRuntime, M as getCodexInferenceThreadQualification, U as protectCodexAppServerLiveThread, X as readRecentCodexRateLimits, Y as readCodexRateLimitsRevision, _ as retainSharedCodexAppServerClientIfCurrent, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, dt as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, et as resolveCodexAppServerAuthAccountCacheKey, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, ht as withCodexStartupTimeout, i as clearSharedCodexAppServerClientIfCurrent, j as getCodexInferenceThread, l as getSharedCodexAppServerClient, lt as CodexAppServerStartupError, mt as resolveCodexStartupTimeoutMs, s as createIsolatedCodexAppServerClient, tt as resolveCodexAppServerPreparedAuthHandoff, u as isCodexAppServerStartSelectionChangedError, ut as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, w as CodexThreadClientReplacementError, x as CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED } from "./shared-client-qhyYWbew.mjs";
+import { E as isCodexContextRestartSelectionChangedError, H as prepareCodexWorkspaceReferences, I as ensureCodexAppServerClientRuntime, M as getCodexInferenceThreadQualification, U as protectCodexAppServerLiveThread, X as readRecentCodexRateLimits, Y as readCodexRateLimitsRevision, _ as retainSharedCodexAppServerClientIfCurrent, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, dt as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, et as resolveCodexAppServerAuthAccountCacheKey, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, ht as withCodexStartupTimeout, i as clearSharedCodexAppServerClientIfCurrent, j as getCodexInferenceThread, l as getSharedCodexAppServerClient, lt as CodexAppServerStartupError, mt as resolveCodexStartupTimeoutMs, s as createIsolatedCodexAppServerClient, tt as resolveCodexAppServerPreparedAuthHandoff, u as isCodexAppServerStartSelectionChangedError, ut as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, w as CodexThreadClientReplacementError, x as CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED } from "./shared-client-ByIwuAC-.mjs";
 import { a as isCodexResponsesOAuthRun, r as isCodexResponsesOAuth } from "./responses-oauth-twnuTaAa.mjs";
-import { A as resolveTerminalDynamicToolBatchAction, D as isDynamicToolTerminalDiagnosticEvent, E as hasPendingDynamicToolTerminalDiagnostic, H as resolveCodexAppServerClientInstanceId, M as toCodexDynamicToolProgressResponse, N as toCodexDynamicToolProtocolResponse, O as isMatchingDynamicToolTerminalDiagnostic, T as handleDynamicToolCallWithTimeout, _ as assertCodexTurnStartResponse, a as isCodexAppServerIndeterminateRequestCancellationError, i as isCodexAppServerConnectionClosedError, j as shouldReleaseTurnAfterTerminalDynamicTool, k as resolveDynamicToolCallTimeoutMs, l as CodexServerRequestResolvedError, o as isCodexAppServerIndeterminateTransportError, r as isCodexAppServerApprovalRequest, w as createCodexElicitationResponse, x as readCodexTurnCompletedNotification, y as readCodexDynamicToolCallParams, z as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS } from "./client-C8lgBOoO.mjs";
-import { n as isCodexWebSocketOpenFailure } from "./transport-websocket-zqJ0Cmtn.mjs";
-import { a as isCodexNotificationForTurn, b as shouldClearTerminalPresentationForNativeItem, g as itemName, i as CodexProjectionDiagnostics, n as getCodexAppServerTurnRouter, o as readCodexNotificationThreadId, t as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, y as matchesCodexSnapshotTurn } from "./turn-router-sS69wYnI.mjs";
-import { d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as shouldRetireCodexStartupClient } from "./attempt-client-cleanup-BH0hW2xU.mjs";
-import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BoMwpuPN.mjs";
-import { a as isRawFunctionToolOutputCompletionNotification, c as readNotificationItemId, i as isPendingOpenClawDynamicToolCompletionNotification, l as readRawResponseToolCallId, o as isTerminalTurnStatus, r as isCodexTurnAbortMarkerNotification, s as readCodexNotificationItem, t as CodexUsageProjection, u as updateActiveTurnItemIds } from "./event-projector-usage-03R0I2dM.mjs";
-import { n as listAllCodexAppServerModels } from "./models-DSseKSMg.mjs";
-import { B as hasCodexNativeToolCatalog, Ct as mergeCodexThreadConfigs, D as assertCodexNativeHookRelayAllowed, E as CodexManagedHooksOnlyError, F as scheduleCodexNativeHookRelayUnregister, G as areCodexDynamicToolFingerprintsCompatible, J as codexLegacyDynamicToolsFingerprint, N as resolveCodexNativeHookRelayEvents, O as buildCodexNativeHookRelayConfig, P as resolveCodexNativeHookRelayTtlMs, S as joinPresentSections, T as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, V as loadCodexNativeToolCatalog, Z as fingerprintJsonObject, _t as buildCodexPluginThreadConfigInputFingerprint, b as resolveCodexAppServerThreadModelSelection, dt as isSystemAgentOnlyCodexDynamicToolAllowlist, g as buildDeveloperInstructions, j as createCodexNativeHookRelay, k as buildCodexNativeHookRelayDisabledConfig, l as isCodexNativeDelegationDisabledForRun, m as resolveCodexWebSearchPlan, mt as resolveCodexDynamicToolsLoadingForRuntime, nt as stabilizeJsonValue, q as codexDynamicToolsFingerprint, st as filterCodexDynamicTools } from "./thread-requests-CL1e8Wmx.mjs";
-import { _ as buildContextEngineBinding, a as buildTurnStartParams, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, g as isCodexAppServerProfilerEnabled, h as resolveScheduledCodexAppCreatorCaptureDecision, i as buildTurnCollaborationMode, l as buildLegacyScheduledCodexAppRecoveryPrompt, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, s as startOrResumeThread, t as buildCodexHistoryProvenancePrefix, u as buildScheduledCodexAppAuthorityInputFingerprint, v as isContextEngineBindingCompatible } from "./thread-lifecycle-Cbz_7ySv.mjs";
-import { o as createCodexSessionGenerationSupersededError, r as resolveCodexSessionBinding, s as resolveCodexRunSessionBindingAuthority, t as clearCodexBindingForClient } from "./session-binding-Ce7BqiPN.mjs";
-import { a as CodexToolTranscriptProjection, c as shouldEmitTranscriptToolProgress, d as resolveCodexToolProgressDetailMode, f as sanitizeCodexAgentEventRecord, i as emitCodexAgentEvent, p as sanitizeCodexToolArguments, r as CodexEventProjection, s as CodexToolProgressProjection, t as codexNativeSubagentMonitorRuntime, u as isCodexCommandBearingToolCall } from "./native-subagent-monitor-BUYOUp9X.mjs";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-CuahdPLC.mjs";
-import { n as CodexThreadPolicyHandoffError, s as restoreCodexThreadInstructionsAfterCompaction } from "./thread-policy-DoNxbhqt.mjs";
-import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DwuSrt3s.mjs";
-import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-GbT-5NcW.mjs";
+import { D as toCodexDynamicToolProgressResponse, E as resolveDynamicToolCallTimeoutMs, L as resolveCodexAppServerClientInstanceId, M as readCodexAppServerWarningMessage, O as toCodexDynamicToolProtocolResponse, P as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS, T as handleDynamicToolCallWithTimeout, _ as assertCodexTurnStartResponse, a as isCodexAppServerIndeterminateRequestCancellationError, i as isCodexAppServerConnectionClosedError, l as CodexServerRequestResolvedError, o as isCodexAppServerIndeterminateTransportError, r as isCodexAppServerApprovalRequest, w as createCodexElicitationResponse, x as readCodexTurnCompletedNotification, y as readCodexDynamicToolCallParams } from "./client-y7nO6X9c.mjs";
+import { n as isCodexWebSocketOpenFailure } from "./transport-websocket-DIyPfkHo.mjs";
+import { S as shouldClearTerminalPresentationForNativeItem, _ as itemName, a as isCodexNotificationForTurn, b as matchesCodexSnapshotTurn, i as CodexProjectionDiagnostics, n as getCodexAppServerTurnRouter, o as readCodexNotificationScope, s as readCodexNotificationThreadId, t as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, x as shouldAdvancePersistableAssistantBarrier } from "./turn-router-DKDAziUW.mjs";
+import { d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as shouldRetireCodexStartupClient } from "./attempt-client-cleanup-t-kd_1ys.mjs";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BaxlhaNx.mjs";
+import { a as isRawFunctionToolOutputCompletionNotification, c as readRawResponseToolCallId, i as isCodexTurnAbortMarkerNotification, l as updateActiveTurnItemIds, o as isTerminalTurnStatus, r as completePendingOpenClawDynamicToolNotification, s as readCodexNotificationItem, t as CodexUsageProjection } from "./event-projector-usage-BpKfdoTm.mjs";
+import { n as listAllCodexAppServerModels } from "./models-DdRyi93L.mjs";
+import { d as mergeCodexThreadConfigs } from "./project-doc-thread-config-BVcvnps8.mjs";
+import { B as resolveCodexDynamicToolsLoadingForRuntime, L as isSystemAgentOnlyCodexDynamicToolAllowlist, P as filterCodexDynamicTools, V as joinPresentSections, _ as buildDeveloperInstructions, b as codexDynamicToolsFingerprint, h as resolveCodexWebSearchPlan, k as stabilizeJsonValue, l as isCodexNativeDelegationDisabledForRun, v as areCodexDynamicToolFingerprintsCompatible, w as fingerprintJsonObject, x as codexLegacyDynamicToolsFingerprint } from "./thread-requests-BgzJwJtS.mjs";
+import { i as resolveCodexSessionBinding, n as createCodexSessionGenerationSupersededError, t as clearCodexBindingForClient } from "./session-binding-JEHNMPsr.mjs";
+import { i as resolveCodexAppServerThreadModelSelection } from "./thread-model-selection-DcVebr8N.mjs";
+import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-2t3KBqiX.mjs";
+import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-Be53aiaG.mjs";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.mjs";
-import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
-import { a as runCodexAgentEndHook, i as reportCodexBackgroundCleanupFailure, n as ensureCodexWorkspaceDirOnce, o as shouldKeepCodexSharedAbortOpen, r as estimateCodexAppServerProjectedTurnTokens, s as withCodexAppServerFastModeServiceTier, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-BuZgVbDA.mjs";
-import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-metadata-CgIf7sOx.mjs";
-import "./inference-context-D-9gWlTR.mjs";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BN7CNUB5.mjs";
-import { a as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as shouldEnableCodexAppServerNativeToolSurface, i as resolveCodexAppServerHookChannelId, l as shouldRequireCodexSandboxExecServerEnvironment, o as resolveCodexMessageToolProvider, p as mapCodexAppServerRemoteWorkspacePath, r as resolveCodexAppServerExecutionCwd, s as resolveCodexSandboxEnvironmentSelection, t as buildDynamicTools, u as shouldWarnCodexDynamicToolBuildStageSummary } from "./dynamic-tool-build-C8xGEXmR.mjs";
-import { n as resolveCodexPluginThreadConfigStartupPolicy, t as createCodexPluginThreadConfigStartupProvider } from "./plugin-thread-config-deadline-B8LGaZNW.mjs";
-import { i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BxIUJ0Zd.mjs";
-import { r as prepareCodexNativeMcpFormResourceContext, t as createCodexNativeMcpAppResultDetailsPreparer } from "./native-mcp-app-CqcPVmhH.mjs";
-import { a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeProcessAuthority, f as readCodexRetainedBackgroundCommands, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as CodexNativeToolLifecycleProjector, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexRemoteWorkspaceFileReader, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as createCodexNativePreToolUseFailureBuffer } from "./dynamic-tools-DyERJnR6.mjs";
-import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BfLRARNL.mjs";
-import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-Bg4FZw1f.mjs";
-import { a as getCodexContextFileDisplayBasename, i as getCodexContextFileBasename, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as isNonEmptyString, r as buildCodexWorkspaceBootstrapContext, s as normalizeCodexContextFilePath } from "./attempt-workspace-context-BY0jprWJ.mjs";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-BZsMjkIO.mjs";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-D68Whix6.mjs";
-import { a as runCodexComputerUseLiveTest, i as createComputerUseRequest, t as ensureCodexComputerUse } from "./computer-use-BBN9y326.mjs";
-import { asOptionalRecord, normalizeLowercaseStringOrEmpty, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createHash } from "node:crypto";
+import { a as CodexToolTranscriptProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolArguments, i as emitCodexAgentEvent, l as resolveCodexToolProgressDetailMode, o as CodexToolProgressProjection, r as CodexEventProjection, s as shouldEmitTranscriptToolProgress, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexAgentEventRecord } from "./native-subagent-monitor-iHc8oLg5.mjs";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-BSV-51ig.mjs";
+import { n as CodexThreadPolicyHandoffError, s as restoreCodexThreadInstructionsAfterCompaction } from "./thread-policy-CHgY-KNl.mjs";
+import { t as attemptTerminal } from "./attempt-terminal-jO5IMj9K.mjs";
+import { a as runCodexAgentEndHook, c as withCodexAppServerFastModeServiceTier, i as reportCodexBackgroundCleanupFailure, n as ensureCodexWorkspaceDirOnce, o as runCodexCleanupStep, r as estimateCodexAppServerProjectedTurnTokens, s as shouldKeepCodexSharedAbortOpen, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-KN4oh-7O.mjs";
+import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-metadata-DCvcG_N_.mjs";
+import "./inference-context-DNlGwzwy.mjs";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-CLMKN4x-.mjs";
+import { a as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as shouldEnableCodexAppServerNativeToolSurface, i as resolveCodexAppServerHookChannelId, l as shouldRequireCodexSandboxExecServerEnvironment, o as resolveCodexMessageToolProvider, p as mapCodexAppServerRemoteWorkspacePath, r as resolveCodexAppServerExecutionCwd, s as resolveCodexSandboxEnvironmentSelection, t as buildDynamicTools, u as shouldWarnCodexDynamicToolBuildStageSummary } from "./dynamic-tool-build-D731PCdv.mjs";
+import { a as buildCodexNativeHookRelayDisabledConfig, d as scheduleCodexNativeHookRelayUnregister, i as buildCodexNativeHookRelayConfig, l as resolveCodexNativeHookRelayEvents, n as CodexManagedHooksOnlyError, r as assertCodexNativeHookRelayAllowed, s as createCodexNativeHookRelay, t as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, u as resolveCodexNativeHookRelayTtlMs } from "./native-hook-relay-BUWIOrSr.mjs";
+import { a as prepareCodexPluginThreadConfigStartupProvider, c as buildLegacyScheduledCodexAppRecoveryPrompt, d as resolveScheduledCodexAppCreatorCaptureDecision, i as isContextEngineBindingCompatible, l as buildScheduledCodexAppServerConnectionIdentity, n as isCodexAppServerProfilerEnabled, o as resolveCodexPluginThreadConfigStartupPolicy, r as buildContextEngineBinding, s as assertScheduledCodexAppAuthorityRuntime, t as startOrResumeThread, u as captureScheduledCodexAppAuthority } from "./thread-lifecycle-run-CfP4PnEf.mjs";
+import { i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-CD2MAWU8.mjs";
+import { o as hasCodexNativeToolCatalog, s as loadCodexNativeToolCatalog } from "./native-skill-isolation-UMVoNjZz.mjs";
+import { r as prepareCodexNativeMcpFormResourceContext, t as createCodexNativeMcpAppResultDetailsPreparer } from "./native-mcp-app-CjxJQ4F7.mjs";
+import { _ as invalidateCodexComputerFrame, a as handleCodexAppServerApprovalRequest, c as createCodexNativePreToolUseFailureBuffer, f as buildTurnCollaborationMode, g as buildCodexUserInput, h as readCodexRetainedBackgroundCommands, i as createCodexDynamicToolDiagnostics, l as buildCodexHistoryProvenancePrefix, m as CodexNativeProcessAuthority, n as projectCodexExecutableDynamicTools, o as ensureCodexSandboxExecServerEnvironment, p as buildTurnStartParams, r as routeCodexAppServerElicitationRequest, s as releaseCodexSandboxExecServerEnvironment, t as createCodexDynamicToolBridge, u as buildCodexParentLocalInstructions, v as createCodexRemoteWorkspaceFileReader, y as CodexNativeToolLifecycleProjector } from "./dynamic-tools-D0pYbxHH.mjs";
+import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-Bee2o6jj.mjs";
+import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-D_zv8J7V.mjs";
+import { a as getCodexContextFileDisplayBasename, i as getCodexContextFileBasename, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as isNonEmptyString, r as buildCodexWorkspaceBootstrapContext, s as normalizeCodexContextFilePath } from "./attempt-workspace-context-CcwP3DA3.mjs";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-BPL6D3RO.mjs";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-CjRaV3bx.mjs";
+import { a as runCodexComputerUseLiveTest, i as createComputerUseRequest, t as ensureCodexComputerUse } from "./computer-use-CiToXF5C.mjs";
+import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { resolveAgentConfig, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
+import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { isPathStrictlyInside, readFileWindowFully, root } from "openclaw/plugin-sdk/file-access-runtime";
 import { addAbortListener } from "node:events";
 import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 import { Type } from "typebox";
-import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { createStageTimingTracker, formatStageTimings } from "openclaw/plugin-sdk/time-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, HEARTBEAT_RESPONSE_TOOL_NAME, agentHarnessStructuredInput, applyEmbeddedAttemptToolsAllow, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, normalizeHeartbeatToolResponse, prepareWatchedSessionsHarnessContext, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$1, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { resolveAgentDir as resolveAgentDir$2 } from "openclaw/plugin-sdk/agent-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, HEARTBEAT_RESPONSE_TOOL_NAME, agentHarnessStructuredInput, applyEmbeddedAttemptToolsAllow, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, normalizeHeartbeatToolResponse, prepareWatchedSessionsHarnessContext, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { AgentHarnessProjectionSettlement, createAgentHarnessAttemptCancellation, createAgentHarnessAttemptDeadlineController, createAgentHarnessAttemptLifecycle, shouldIncludeAgentHarnessRuntimeContext } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
-import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
+import { getSessionEntry, patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { acknowledgeInternalToolResult, createAgentHarnessToolExecutionRegistry } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
-import { createNativeSessionBindingAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
+import { createNativeSessionBindingAuthority, prepareNativeSessionGenerationAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
+import { appendSessionYieldContext, composeSessionTranscriptWriteAssertion, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-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";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
@@ -135,6 +140,38 @@ function createCodexAttemptPreparationTiming(params) {
 //#endregion
 //#region extensions/codex/src/app-server/attempt-steering.ts
 const CODEX_STEER_ALL_DEBOUNCE_MS = 500;
+function createCodexQuestionInputHandlers(sessionKey, assertActive) {
+	const questionAuthority = (kind, assertSource, toolAuthorityPreparation) => ({
+		kind,
+		toolAuthorityPreparation,
+		assertCurrent: () => {
+			assertSource?.();
+			assertActive();
+		}
+	});
+	const claimPendingUserInputAnswer = async (text, optionsLocal, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run", toolAuthorityPreparation) => {
+		if (optionsLocal?.isInboundUserMessage !== true || hasPromptImageInput(optionsLocal)) return false;
+		assertActive();
+		return await claimPendingAgentQuestionAnswer({
+			sessionKey,
+			text,
+			authority: questionAuthority(authorityKind, assertCurrent, toolAuthorityPreparation),
+			sourceRecorder: optionsLocal.userTurnTranscriptRecorder,
+			persist: optionsLocal.userTurnTranscriptRecorder ? async () => {
+				await optionsLocal.userTurnTranscriptRecorder?.persistApproved();
+			} : void 0
+		});
+	};
+	const cancelPendingUserInput = (resolvedBy, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run", toolAuthorityPreparation) => cancelPendingAgentQuestionForSession({
+		sessionKey,
+		resolvedBy,
+		authority: questionAuthority(authorityKind, assertCurrent, toolAuthorityPreparation)
+	});
+	return {
+		claimPendingUserInputAnswer,
+		cancelPendingUserInput
+	};
+}
 var CodexSteeringAcceptedUnconfirmedError = class extends Error {
 	constructor(message, options) {
 		super(message, options);
@@ -177,16 +214,14 @@ function createCodexSteeringQueue(params) {
 		reportItemAcceptance(item, true);
 	};
 	const resolveItem = (item) => {
-		if (item.settled) return;
+		if (!pendingMessages.has(item)) return;
 		acceptItem(item);
-		item.settled = true;
 		pendingMessages.delete(item);
 		item.onQueueSettled?.();
 		item.resolve();
 	};
 	const rejectItem = (item, error) => {
-		if (item.settled) return;
-		item.settled = true;
+		if (!pendingMessages.has(item)) return;
 		pendingMessages.delete(item);
 		reportItemAcceptance(item, false);
 		item.onQueueSettled?.();
@@ -217,7 +252,7 @@ function createCodexSteeringQueue(params) {
 		closeQueue(/* @__PURE__ */ new Error("codex app-server steering queue cancelled"));
 	};
 	const sendBatch = async (items) => {
-		const pendingItems = items.filter((item) => !item.settled);
+		const pendingItems = items.filter((item) => pendingMessages.has(item));
 		let liveItems = [];
 		if (pendingItems.length === 0) return;
 		let clientUserMessageId;
@@ -226,7 +261,7 @@ function createCodexSteeringQueue(params) {
 			assertActive();
 			const prepared = [];
 			const isCurrent = (item) => {
-				if (item.settled) return false;
+				if (!pendingMessages.has(item)) return false;
 				try {
 					item.assertCurrent();
 					return true;
@@ -256,8 +291,15 @@ function createCodexSteeringQueue(params) {
 				liveItems = liveItems.filter(isCurrent);
 				if (liveItems.length === 0) return;
 			}
+			const withCurrent = params.withPreparedCurrent && liveItems.some((item) => item.preparation) ? (write) => params.withPreparedCurrent(write, liveItems.flatMap((item) => item.preparation ? [{
+				...item.preparation,
+				onRefused: (error) => {
+					rejectItem(item, error);
+					return "discarded";
+				}
+			}] : [])) : params.withCurrent;
 			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-			if (!params.withCurrent) dispatchedBatches.set(clientUserMessageId, liveItems);
+			if (!withCurrent) dispatchedBatches.set(clientUserMessageId, liveItems);
 			const request = {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
@@ -267,7 +309,7 @@ function createCodexSteeringQueue(params) {
 			await params.client.request("turn/steer", request, {
 				timeoutMs: params.requestTimeoutMs,
 				signal: params.signal,
-				...params.withCurrent ? { withCurrent: params.withCurrent } : {},
+				...withCurrent ? { withCurrent } : {},
 				onIngressRejected: () => dispatchedBatches.delete(request.clientUserMessageId),
 				assertCurrent: () => {
 					assertActive();
@@ -305,7 +347,7 @@ function createCodexSteeringQueue(params) {
 	params.signal.addEventListener("abort", abortQueue, { once: true });
 	if (params.signal.aborted) abortQueue();
 	return {
-		async queue(text, options, assertCurrent = () => {}) {
+		async queue(text, options, assertCurrent = () => {}, preparation) {
 			try {
 				assertActive();
 				assertCurrent();
@@ -318,11 +360,11 @@ function createCodexSteeringQueue(params) {
 			const item = {
 				...options,
 				assertCurrent,
+				preparation,
 				acceptance: "open",
 				text,
 				resolve,
-				reject,
-				settled: false
+				reject
 			};
 			pendingMessages.add(item);
 			batchedMessages.push(item);
@@ -352,6 +394,146 @@ 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/event-projector-steering.ts
+/** Owns the raw assistant cutoffs committed before each steer in one native turn. */
+var CodexSteeringAssistantSegments = class {
+	constructor() {
+		this.streamedPartialAssistantItemReplaceable = false;
+		this.visible = /* @__PURE__ */ new Set();
+		this.completed = /* @__PURE__ */ new Map();
+		this.handoffItems = /* @__PURE__ */ new Set();
+		this.handoffGeneration = 0;
+		this.persisted = /* @__PURE__ */ new Map();
+		this.pending = /* @__PURE__ */ new Map();
+		this.occurrences = /* @__PURE__ */ new Map();
+		this.receiptIds = /* @__PURE__ */ new Map();
+	}
+	beginSnapshot() {
+		this.pending.clear();
+	}
+	recordStream(itemId, knownFinalAnswer) {
+		const replace = this.streamedPartialAssistantItemId !== void 0 && this.streamedPartialAssistantItemId !== itemId;
+		if (replace && (!knownFinalAnswer || this.streamedPartialAssistantItemReplaceable)) this.streamedPartialAssistantItemReplaceable = true;
+		else if (this.streamedPartialAssistantItemId === void 0) this.streamedPartialAssistantItemReplaceable = !knownFinalAnswer;
+		this.streamedPartialAssistantItemId = itemId;
+		const replaceable = this.streamedPartialAssistantItemReplaceable;
+		const replacement = replace && replaceable;
+		if (replacement) this.visible.clear();
+		this.visible.add(itemId);
+		let occurrence = this.occurrences.get(itemId);
+		if (!occurrence) {
+			occurrence = {
+				ids: [],
+				ownedCount: 0
+			};
+			this.occurrences.set(itemId, occurrence);
+		}
+		if (!occurrence.current) {
+			occurrence.current = randomUUID();
+			occurrence.ids.push(occurrence.current);
+		}
+		return {
+			occurrenceId: occurrence.current,
+			replacement,
+			replaceable
+		};
+	}
+	clearProvisionalStream(itemId) {
+		if (this.streamedPartialAssistantItemId === itemId && this.streamedPartialAssistantItemReplaceable) {
+			this.streamedPartialAssistantItemId = void 0;
+			const occurrence = this.occurrences.get(itemId);
+			return {
+				itemId,
+				occurrenceId: occurrence?.current ?? occurrence?.ids.at(-1),
+				text: "",
+				delta: "",
+				replace: true
+			};
+		}
+	}
+	collectOccurrenceIds(itemIds) {
+		return [...new Set(itemIds.flatMap((itemId) => this.occurrences.get(itemId)?.ids ?? []))];
+	}
+	isVisible(itemId) {
+		return this.visible.has(itemId);
+	}
+	recordCompletion(itemId) {
+		if (!this.completed.has(itemId)) this.completed.set(itemId, this.handoffGeneration);
+	}
+	isCompleted(itemId) {
+		return this.completed.has(itemId);
+	}
+	recordHandoff(itemId) {
+		if (itemId && this.handoffItems.has(itemId)) return false;
+		if (itemId) this.handoffItems.add(itemId);
+		this.handoffGeneration += 1;
+		return true;
+	}
+	survivesHandoff(itemId) {
+		const completedAt = this.completed.get(itemId);
+		return this.persisted.has(itemId) && (completedAt === void 0 || completedAt >= this.handoffGeneration);
+	}
+	remainingText(itemId, text) {
+		const prefix = this.persisted.get(itemId);
+		return prefix && text.startsWith(prefix.text) ? text.slice(prefix.text.length) : text;
+	}
+	capture(itemId, text, completed) {
+		if (text === void 0) return;
+		const remainder = this.remainingText(itemId, text);
+		if (!remainder.trim() || isSilentReplyPayloadText(remainder)) return;
+		const prefix = this.persisted.get(itemId);
+		const split = prefix !== void 0 || !completed;
+		const segment = prefix?.nextSegment ?? 0;
+		const mirrorItemId = split ? `${itemId}:segment:${segment}` : itemId;
+		const occurrence = this.occurrences.get(itemId);
+		const unownedIds = occurrence?.ids.slice(occurrence.ownedCount) ?? [];
+		const occurrenceIds = unownedIds.length ? unownedIds : this.receiptIds.get(mirrorItemId) ?? [];
+		this.receiptIds.set(mirrorItemId, occurrenceIds);
+		this.pending.set(mirrorItemId, {
+			itemId,
+			text,
+			completed,
+			split,
+			segment,
+			occurrenceCount: occurrence?.ids.length ?? 0
+		});
+		if (occurrence) delete occurrence.current;
+		return {
+			itemId: mirrorItemId,
+			text: remainder,
+			split,
+			occurrenceIds
+		};
+	}
+	consume(mirrorItemId) {
+		const prefix = this.pending.get(mirrorItemId);
+		if (!prefix) return;
+		this.pending.delete(mirrorItemId);
+		const occurrence = this.occurrences.get(prefix.itemId);
+		if (occurrence) occurrence.ownedCount = Math.max(occurrence.ownedCount, prefix.occurrenceCount);
+		if (prefix.split) this.persisted.set(prefix.itemId, {
+			text: prefix.text,
+			nextSegment: prefix.segment + 1
+		});
+		return {
+			itemId: prefix.itemId,
+			completed: prefix.completed
+		};
+	}
+	adoptCompletion(sourceId, itemId, text, sourceText) {
+		const pending = [...this.pending.values()].find((prefix) => prefix.itemId === sourceId);
+		const persisted = this.persisted.get(sourceId);
+		const prefix = pending?.text ?? persisted?.text ?? sourceText;
+		if (!prefix || !text.startsWith(prefix)) return false;
+		if (persisted) this.persisted.set(itemId, persisted);
+		const occurrence = this.occurrences.get(sourceId);
+		if (occurrence) this.occurrences.set(itemId, occurrence);
+		if (pending) pending.itemId = itemId;
+		this.visible.delete(sourceId);
+		return true;
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
 	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
@@ -373,11 +555,9 @@ var CodexAssistantProjection = class {
 		this.pendingRawCommentaryEchoes = 0;
 		this.rawPromotedAssistantItemIds = /* @__PURE__ */ new Set();
 		this.assistantStarted = false;
-		this.streamedPartialAssistantItemReplaceable = false;
 		this.persistableAssistantBarrier = 0;
 		this.persistedAssistantBoundary = false;
-		this.persistableAssistantBarrierItemIds = /* @__PURE__ */ new Set();
-		this.completedAssistantItemIds = /* @__PURE__ */ new Set();
+		this.steeringSegments = new CodexSteeringAssistantSegments();
 	}
 	handleNotification(method, params) {
 		if (method === "model/rerouted") this.responseModel = readStringField(params, "toModel") ?? this.responseModel;
@@ -408,12 +588,7 @@ var CodexAssistantProjection = class {
 		}
 		const knownFinalAnswer = this.isFinalAnswerAssistantItem(itemId);
 		if (knownFinalAnswer) this.emitAnswerCandidate(itemId, "candidate");
-		const replace = this.streamedPartialAssistantItemId !== void 0 && this.streamedPartialAssistantItemId !== itemId;
-		if (replace && (!knownFinalAnswer || this.streamedPartialAssistantItemReplaceable)) this.streamedPartialAssistantItemReplaceable = true;
-		else if (this.streamedPartialAssistantItemId === void 0) this.streamedPartialAssistantItemReplaceable = !knownFinalAnswer;
-		this.streamedPartialAssistantItemId = itemId;
-		const replaceable = this.streamedPartialAssistantItemReplaceable;
-		const replacement = replace && replaceable;
+		const { occurrenceId, replacement, replaceable } = this.steeringSegments.recordStream(itemId, knownFinalAnswer);
 		const streamPayload = {
 			text,
 			delta: replacement ? "" : delta,
@@ -423,6 +598,7 @@ var CodexAssistantProjection = class {
 			stream: "assistant",
 			data: {
 				itemId,
+				occurrenceId,
 				...streamPayload,
 				...replaceable ? { replaceable: true } : {}
 			}
@@ -443,38 +619,35 @@ var CodexAssistantProjection = class {
 			delta: item.text
 		});
 	}
-	recordItemCompleted(item, itemId, activeItemIds) {
-		if (itemId && item?.type === "agentMessage") this.completedAssistantItemIds.add(itemId);
-		this.noteNativeWorkBarrier(item);
+	recordItemCompleted(item, notification) {
+		this.adoptSteeringPrefixForCompletion(item);
+		if (item?.type === "agentMessage" && (!notification || notification.itemId)) this.steeringSegments.recordCompletion(notification?.itemId ?? item.id);
+		if (notification) this.noteNativeWorkBarrier(item);
 		this.rememberAssistantPhase(item);
-		if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
-		if (item?.type === "agentMessage" && !this.isNonTerminalAssistantItem(item.id)) {
-			this.markLatestTerminalAssistantCandidate(item.id, activeItemIds);
-			this.pendingRawTerminalAssistantEchoItemId = item.id;
-		} else if (itemId && !this.isNonTerminalAssistantItem(itemId)) {
-			this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
-			if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		if (notification) {
+			const { itemId, activeItemIds } = notification;
+			if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+			if (item?.type === "agentMessage" && !this.isNonTerminalAssistantItem(item.id)) {
+				this.markLatestTerminalAssistantCandidate(item.id, activeItemIds);
+				this.pendingRawTerminalAssistantEchoItemId = item.id;
+			} else if (itemId && !this.isNonTerminalAssistantItem(itemId)) {
+				this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
+				if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
+			}
 		}
 		if (item?.type === "agentMessage" && typeof item.text === "string") {
 			this.rememberAssistantItem(item.id);
 			this.assistantTextByItem.set(item.id, item.text);
-			if (this.isCommentaryAssistantItem(item.id)) {
-				this.emitCommentaryProgress({
-					itemId: item.id,
-					text: item.text,
-					phase: "end"
-				});
-				this.pendingRawCommentaryEchoes += 1;
-			} else if (item.text && !this.isAsyncAssistantItem(item.id) && this.isFinalAnswerAssistantItem(item.id)) this.emitAnswerCandidate(item.id, "candidate");
-			return this.createAsyncDelivery(item.id);
-		}
-	}
-	recordSnapshotItem(item) {
-		if (item.type === "agentMessage") this.completedAssistantItemIds.add(item.id);
-		this.rememberAssistantPhase(item);
-		if (item.type === "agentMessage" && typeof item.text === "string") {
-			this.rememberAssistantItem(item.id);
-			this.assistantTextByItem.set(item.id, item.text);
+			if (notification) {
+				if (this.isCommentaryAssistantItem(item.id)) {
+					this.emitCommentaryProgress({
+						itemId: item.id,
+						text: item.text,
+						phase: "end"
+					});
+					this.pendingRawCommentaryEchoes += 1;
+				} else if (item.text && !this.isAsyncAssistantItem(item.id) && this.isFinalAnswerAssistantItem(item.id)) this.emitAnswerCandidate(item.id, "candidate");
+			}
 			return this.createAsyncDelivery(item.id);
 		}
 	}
@@ -496,13 +669,19 @@ var CodexAssistantProjection = class {
 			this.pendingRawTerminalAssistantEchoItemId = void 0;
 			return;
 		}
-		const text = extractRawAssistantText(item);
+		const text = extractRawResponseItemText(item);
 		if (text === void 0 || !text && (phase === "commentary" || activeItemIds.size > 0 || readStringField(item, "type") !== "message")) return;
 		const itemId = rawItemId ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
 		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && activeItemIds.size === 0;
-		if (text && phase !== "commentary" && candidateWasSupersededBeforeRaw && itemId !== this.streamedPartialAssistantItemId && !isIdlessTerminalAssistantAfterCompletedWork) return;
+		if (text && phase !== "commentary" && candidateWasSupersededBeforeRaw && itemId !== this.steeringSegments.streamedPartialAssistantItemId && !isIdlessTerminalAssistantAfterCompletedWork) return;
+		this.adoptSteeringPrefixForCompletion({
+			...item,
+			type: "agentMessage",
+			id: itemId,
+			text
+		});
 		if (phase) this.assistantPhaseByItem.set(itemId, phase);
-		this.completedAssistantItemIds.add(itemId);
+		this.steeringSegments.recordCompletion(itemId);
 		this.rememberAssistantItem(itemId);
 		this.assistantTextByItem.set(itemId, text);
 		if (!text) return;
@@ -534,6 +713,9 @@ var CodexAssistantProjection = class {
 			}] : [];
 		});
 	}
+	collectTerminalAssistantItemIds() {
+		return this.steeringSegments.collectOccurrenceIds(this.assistantItemOrder.filter((itemId) => !this.isNonTerminalAssistantItem(itemId)));
+	}
 	readCommentaryMessage(itemId) {
 		const text = this.assistantTextByItem.get(itemId)?.trim();
 		const timestamp = this.assistantTimestampByItem.get(itemId);
@@ -548,34 +730,37 @@ var CodexAssistantProjection = class {
 			}] : [];
 		});
 	}
-	collectCompletedAssistantMessages(completedItemIds, options) {
+	collectSteeringAssistantMessages(completedItemIds, options) {
+		this.steeringSegments.beginSnapshot();
 		return this.assistantItemOrder.flatMap((itemId) => {
-			const text = this.assistantTextByItem.get(itemId)?.trim();
-			if (!completedItemIds.has(itemId) || this.isNonTerminalAssistantItem(itemId) || !text || isSilentReplyPayloadText(text) || this.isToolProgressEchoText(itemId, text)) return [];
-			const message = this.createAssistantMessage(text, options);
-			const timestamp = this.assistantTimestampByItem.get(itemId) ?? message.timestamp;
+			const sourceText = this.assistantTextByItem.get(itemId);
+			const completed = completedItemIds.has(itemId);
+			if (!completed && !this.steeringSegments.isVisible(itemId) || this.isNonTerminalAssistantItem(itemId) || sourceText && this.isToolProgressEchoText(itemId, sourceText.trim())) return [];
+			const segment = this.steeringSegments.capture(itemId, sourceText, completed);
+			if (!segment) return [];
+			const message = attachCodexAssistantItemIds(this.createAssistantMessage(segment.text, options), segment.occurrenceIds);
+			message.timestamp = segment.split ? this.nextTranscriptTimestamp() : this.assistantTimestampByItem.get(itemId) ?? message.timestamp;
 			return [{
-				itemId,
-				message: {
-					...message,
-					timestamp
-				}
+				itemId: segment.itemId,
+				message
 			}];
 		});
 	}
-	markAssistantBoundaryPersisted(itemId) {
-		const index = this.assistantItemOrder.indexOf(itemId);
-		if (index >= 0) {
+	markSteeringMessagePersisted(mirrorItemId) {
+		const prefix = this.steeringSegments.consume(mirrorItemId);
+		if (!prefix) return;
+		if (prefix.completed) {
+			const index = this.assistantItemOrder.indexOf(prefix.itemId);
 			this.persistableAssistantBarrier = Math.max(this.persistableAssistantBarrier, index + 1);
-			this.persistedAssistantBoundary = true;
 		}
+		this.persistedAssistantBoundary = true;
 	}
 	finalizeAnswerCandidate(turn) {
 		if (turn.status !== "completed") {
 			this.supersedeVisibleAnswerCandidate();
 			return;
 		}
-		for (const itemId of this.assistantItemOrder) if (!this.completedAssistantItemIds.has(itemId) && !this.isAsyncAssistantItem(itemId) && (this.isFinalAnswerAssistantItem(itemId) || this.isCommentaryAssistantItem(itemId))) {
+		for (const itemId of this.assistantItemOrder) if (!this.steeringSegments.isCompleted(itemId) && !this.isAsyncAssistantItem(itemId) && (this.isFinalAnswerAssistantItem(itemId) || this.isCommentaryAssistantItem(itemId))) {
 			if (itemId === this.visibleAnswerCandidateItemId) this.supersedeVisibleAnswerCandidate();
 			this.assistantTextByItem.delete(itemId);
 		}
@@ -599,13 +784,13 @@ var CodexAssistantProjection = class {
 		this.emitAnswerCandidate(itemId, "selected");
 	}
 	hasAssistantItemTextForSynthesis() {
-		return this.assistantItemOrder.some((itemId) => Boolean(itemId) && !this.isNonTerminalAssistantItem(itemId) && Boolean(this.assistantTextByItem.get(itemId)));
+		return this.assistantItemOrder.some((itemId) => !this.isNonTerminalAssistantItem(itemId) && Boolean(this.assistantTextByItem.get(itemId)));
 	}
 	createCurrentAttemptAssistantMessage(options) {
 		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
 			const itemId = this.assistantItemOrder[i];
 			if (!itemId || this.isNonTerminalAssistantItem(itemId) || !this.assistantTextByItem.has(itemId)) continue;
-			const text = this.assistantTextByItem.get(itemId) ?? "";
+			const text = this.remainingAssistantText(itemId) ?? "";
 			const normalizedText = text.trim();
 			if (normalizedText && this.isToolProgressEchoText(itemId, normalizedText)) continue;
 			return this.createAssistantMessage(text, options);
@@ -618,6 +803,19 @@ var CodexAssistantProjection = class {
 			responseModel: this.responseModel
 		} : message;
 	}
+	remainingAssistantText(itemId) {
+		const text = this.assistantTextByItem.get(itemId);
+		return text === void 0 ? void 0 : this.steeringSegments.remainingText(itemId, text);
+	}
+	adoptSteeringPrefixForCompletion(item) {
+		const sourceId = this.steeringSegments.streamedPartialAssistantItemId;
+		if (item?.type !== "agentMessage" || !sourceId || item.id === sourceId || this.steeringSegments.isCompleted(sourceId) || this.assistantTimestampByItem.has(item.id) || this.isNonTerminalAssistantItem(sourceId) || item.delivery === "async" || item.phase !== void 0 && item.phase !== this.assistantPhaseByItem.get(sourceId)) return;
+		const sourceText = this.assistantTextByItem.get(sourceId);
+		if (!this.steeringSegments.adoptCompletion(sourceId, item.id, item.text, sourceText)) return;
+		if (this.visibleAnswerCandidateItemId === sourceId) this.supersedeVisibleAnswerCandidate();
+		this.assistantTextByItem.delete(sourceId);
+		this.steeringSegments.streamedPartialAssistantItemId = item.id;
+	}
 	rememberAssistantPhase(item) {
 		if (item?.type !== "agentMessage") return;
 		const phase = readStringField(item, "phase");
@@ -643,9 +841,14 @@ var CodexAssistantProjection = class {
 		return this.assistantPhaseByItem.get(itemId) === "final_answer";
 	}
 	emitCommentaryProgress(params) {
-		const progressText = params.text.trim();
+		const cleared = this.steeringSegments.clearProvisionalStream(params.itemId);
+		if (cleared) this.emitAgentEvent({
+			stream: "assistant",
+			data: cleared
+		});
+		const progressText = params.text.trimEnd();
 		const previous = this.lastCommentaryProgressEventByItem.get(params.itemId);
-		if (!progressText || previous?.phase === params.phase && previous.text === progressText) return;
+		if (!progressText.trim() || previous?.phase === params.phase && previous.text === progressText) return;
 		this.lastCommentaryProgressEventByItem.set(params.itemId, {
 			phase: params.phase,
 			text: progressText
@@ -711,21 +914,19 @@ var CodexAssistantProjection = class {
 		this.supersedeVisibleAnswerCandidate();
 	}
 	resolveFinalAssistantText() {
-		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
-			const itemId = this.assistantItemOrder[i];
-			if (!itemId) continue;
-			const text = this.assistantTextByItem.get(itemId)?.trim();
-			if (this.isNonTerminalAssistantItem(itemId)) continue;
-			if (text && !this.isToolProgressEchoText(itemId, text)) return text;
-		}
+		const selectedId = this.assistantItemOrder.findLast((itemId) => {
+			const text = this.remainingAssistantText(itemId)?.trim();
+			return Boolean(text && !this.isNonTerminalAssistantItem(itemId) && !this.isToolProgressEchoText(itemId, text));
+		});
+		return selectedId ? this.remainingAssistantText(selectedId)?.trim() : void 0;
 	}
 	collectPersistableAssistantTexts(minIndex) {
 		let texts = [];
 		let replaceable = false;
-		for (let index = minIndex; index < this.assistantItemOrder.length; index += 1) {
+		for (let index = 0; index < this.assistantItemOrder.length; index += 1) {
 			const itemId = this.assistantItemOrder[index];
-			if (!itemId || this.isNonTerminalAssistantItem(itemId)) continue;
-			const text = this.assistantTextByItem.get(itemId)?.trim();
+			if (!itemId || this.isNonTerminalAssistantItem(itemId) || index < minIndex && !this.steeringSegments.survivesHandoff(itemId)) continue;
+			const text = this.remainingAssistantText(itemId)?.trim();
 			if (!text || this.isToolProgressEchoText(itemId, text)) continue;
 			if (isSilentReplyPayloadText(text)) {
 				texts.push(text);
@@ -742,10 +943,7 @@ var CodexAssistantProjection = class {
 		return texts;
 	}
 	noteNativeWorkBarrier(item) {
-		if (!item || !shouldAdvancePersistableAssistantBarrier(item)) return;
-		if (item.id && this.persistableAssistantBarrierItemIds.has(item.id)) return;
-		if (item.id) this.persistableAssistantBarrierItemIds.add(item.id);
-		this.persistableAssistantBarrier = this.assistantItemOrder.length;
+		if (item && shouldAdvancePersistableAssistantBarrier(item) && this.steeringSegments.recordHandoff(item.id)) this.persistableAssistantBarrier = this.assistantItemOrder.length;
 	}
 	rememberAssistantItem(itemId) {
 		if (!itemId) return;
@@ -755,7 +953,7 @@ var CodexAssistantProjection = class {
 		}
 		if (this.isCommentaryAssistantItem(itemId)) this.checkpointCommentary?.(itemId, {
 			read: () => this.readCommentaryMessage(itemId),
-			ready: () => this.completedAssistantItemIds.has(itemId)
+			ready: () => this.steeringSegments.isCompleted(itemId)
 		});
 	}
 	createAsyncDelivery(itemId) {
@@ -773,9 +971,6 @@ var CodexAssistantProjection = class {
 		return this.rawPromotedAssistantItemIds.has(itemId) && this.matchesToolProgressEcho(text);
 	}
 };
-function shouldAdvancePersistableAssistantBarrier(item) {
-	return shouldClearTerminalPresentationForNativeItem(item) || item.type === "dynamicToolCall" || item.type === "sleep";
-}
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-async-delivery.ts
 /** Owns authorization, exactly-once settlement, and terminal retry for async user messages. */
@@ -1098,29 +1293,9 @@ function normalizePlanStepStatus(status) {
 	return status === "completed" ? "completed" : "pending";
 }
 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;
+	return new Map(Array.isArray(value) ? value.flatMap((text, index) => typeof text === "string" ? [[index, text]] : []) : []);
 }
 //#endregion
-//#region extensions/codex/src/app-server/event-projector-settlement.ts
-var CodexProjectionSettlement = class extends AgentHarnessProjectionSettlement {
-	constructor(params, isActive) {
-		super(params, isActive, { label: "codex app-server" });
-		this.turnTainted = false;
-	}
-	get completedAnswer() {
-		const turn = this.terminalReceipt;
-		const answer = turn?.items?.findLast((item) => item.type === "agentMessage" && item.phase !== "commentary" && item.delivery !== "async" && typeof item.text === "string" && item.text.trim().length > 0);
-		return turn?.status === "completed" && answer ? {
-			turn,
-			answer
-		} : void 0;
-	}
-};
-//#endregion
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
 function buildCodexMessagesSnapshot(params) {
 	const messages = promptSnapshot(params.runParams, params.turnId, params.upstreamUserText);
@@ -1149,45 +1324,24 @@ function buildCodexMessagesSnapshot(params) {
 function buildCodexSteeringMessagesSnapshot(params) {
 	const asyncMessages = params.assistantProjection.collectAsyncMessages().filter(({ itemId }) => params.completedItemIds.has(itemId));
 	const commentaryMessages = params.assistantProjection.collectCommentaryMessages().filter(({ itemId }) => params.completedItemIds.has(itemId));
-	const assistantMessages = params.assistantProjection.collectCompletedAssistantMessages(params.completedItemIds, {
+	const assistantMessages = params.assistantProjection.collectSteeringAssistantMessages(params.completedItemIds, {
 		tokenUsage: void 0,
 		aborted: false,
 		promptError: void 0
 	});
-	return {
-		messages: buildCodexMessagesSnapshot({
-			runParams: params.runParams,
-			turnId: params.turnId,
-			upstreamUserText: params.upstreamUserText,
-			reasoningText: void 0,
-			asyncMessages,
-			commentaryMessages,
-			assistantMessages,
-			toolMessages: params.toolMessages,
-			lastAssistant: void 0
-		}).filter((message) => message.role !== "user"),
-		assistantBoundaryItemId: assistantMessages.at(-1)?.itemId
-	};
+	return buildCodexMessagesSnapshot({
+		runParams: params.runParams,
+		turnId: params.turnId,
+		upstreamUserText: params.upstreamUserText,
+		reasoningText: void 0,
+		asyncMessages,
+		commentaryMessages,
+		assistantMessages,
+		toolMessages: params.toolMessages,
+		lastAssistant: void 0
+	}).filter((message) => message.role !== "user");
 }
 //#endregion
-//#region extensions/codex/src/app-server/event-projector-terminal-failure.ts
-var CodexTerminalFailureProjection = class {
-	constructor() {
-		this.promptErrorSource = null;
-	}
-	record(params) {
-		const refusal = readCodexProviderRefusal(params.message, params.codexErrorInfo, params);
-		if (!this.providerRefusal || refusal?.category === "misalignment" && this.providerRefusal.category === "misalignment" && params.misalignment != null) this.providerRefusal = refusal;
-		if (this.providerRefusal) return;
-		this.promptError = resolveCodexPromptError({
-			message: params.message,
-			codexErrorInfo: params.codexErrorInfo,
-			rateLimits: params.rateLimits
-		}) ?? params.fallbackMessage;
-		this.promptErrorSource = params.promptErrorSource;
-	}
-};
-//#endregion
 //#region extensions/codex/src/app-server/event-projector-tool-search-evidence.ts
 const MAX_RETAINED_SEARCHES = 16;
 const MAX_RETAINED_DYNAMIC_CALLS = 32;
@@ -1195,17 +1349,7 @@ const MAX_DISCOVERED_TOOLS = 32;
 const MAX_ID_CHARS = 256;
 const MAX_NAME_CHARS = 128;
 function readBoundedString(value, maxChars) {
-	if (typeof value !== "string") return;
-	const normalized = value.trim();
-	if (!normalized) return;
-	return normalized.slice(0, maxChars);
-}
-function trimOldest(map, maxSize) {
-	while (map.size > maxSize) {
-		const oldest = map.keys().next().value;
-		if (oldest === void 0) return;
-		map.delete(oldest);
-	}
+	return normalizeOptionalString(value)?.slice(0, maxChars);
 }
 function collectToolRefs(values, output, seen, inheritedNamespace) {
 	if (!Array.isArray(values)) return false;
@@ -1256,7 +1400,7 @@ var CodexToolSearchEvidenceProjection = class {
 				...execution ? { execution } : {},
 				...status ? { status } : {}
 			});
-			trimOldest(this.calls, MAX_RETAINED_SEARCHES);
+			pruneMapToMaxSize(this.calls, MAX_RETAINED_SEARCHES);
 			return;
 		}
 		if (type !== "tool_search_output") return;
@@ -1273,7 +1417,7 @@ var CodexToolSearchEvidenceProjection = class {
 			tools,
 			truncated
 		});
-		trimOldest(this.outputs, MAX_RETAINED_SEARCHES);
+		pruneMapToMaxSize(this.outputs, MAX_RETAINED_SEARCHES);
 	}
 	recordDynamicToolCall(params) {
 		const callId = readBoundedString(params.callId, MAX_ID_CHARS);
@@ -1287,7 +1431,7 @@ var CodexToolSearchEvidenceProjection = class {
 			namespace: requestedNamespace,
 			tool
 		});
-		trimOldest(this.dynamicCalls, MAX_RETAINED_DYNAMIC_CALLS);
+		pruneMapToMaxSize(this.dynamicCalls, MAX_RETAINED_DYNAMIC_CALLS);
 	}
 	recordDynamicToolResult(params) {
 		const callId = readBoundedString(params.callId, MAX_ID_CHARS);
@@ -1330,8 +1474,7 @@ var CodexTranscriptCheckpoint = class {
 		this.lastTimestamp = 0;
 		this.writing = Promise.resolve();
 		this.tainted = false;
-		this.closed = false;
-		this.abandoned = false;
+		this.state = "open";
 		this.nextTimestamp = () => {
 			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
 			return this.lastTimestamp;
@@ -1348,16 +1491,16 @@ var CodexTranscriptCheckpoint = class {
 			});
 		};
 		this.enqueue = (entry) => {
-			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
+			if (this.params.sessionTarget && this.state === "open") this.pending.push(entry);
 		};
 	}
 	abandon() {
-		this.closed = this.abandoned = true;
+		this.state = "abandoned";
 		this.pending.length = 0;
 	}
 	flush(close = false) {
-		if (this.closed) return this.writing;
-		this.closed = close;
+		if (this.state !== "open") return this.writing;
+		this.state = close ? "closed" : "open";
 		this.writing = this.writing.then(async () => {
 			const blocked = close ? -1 : this.pending.findIndex((entry) => entry.ready?.() === false);
 			const count = blocked < 0 ? this.pending.length : blocked;
@@ -1373,9 +1516,9 @@ var CodexTranscriptCheckpoint = class {
 			});
 			try {
 				await codexTranscriptMirrorRuntime.mirror({
-					assertWriteCurrent: () => {
-						if (this.abandoned) throw new Error("Codex transcript checkpoint was retired before write");
-					},
+					assertWriteCurrent: createNativeSessionBindingAuthority([], () => {
+						if (this.state === "abandoned") throw new Error("Codex transcript checkpoint was retired before write");
+					}).assertLegacyCurrent,
 					...this.params.sessionTarget,
 					sessionId: this.params.sessionId,
 					cwd: this.params.workspaceDir,
@@ -1400,6 +1543,20 @@ var CodexTranscriptCheckpoint = class {
 };
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-result.ts
+var CodexProjectionSettlement = class extends AgentHarnessProjectionSettlement {
+	constructor(params, isActive) {
+		super(params, isActive, { label: "codex app-server" });
+		this.turnTainted = false;
+	}
+	get completedAnswer() {
+		const turn = this.terminalReceipt;
+		const answer = turn?.items?.findLast((item) => item.type === "agentMessage" && item.phase !== "commentary" && item.delivery !== "async" && typeof item.text === "string" && item.text.trim().length > 0);
+		return turn?.status === "completed" && answer ? {
+			turn,
+			answer
+		} : void 0;
+	}
+};
 /** Owns per-turn projection state and builds results from the same state. */
 var CodexTurnProjection = class {
 	constructor(params, threadId, turnId, options = {}) {
@@ -1413,7 +1570,7 @@ var CodexTurnProjection = class {
 		this.activeCompactionItemIds = /* @__PURE__ */ new Set();
 		this.projectionController = new AbortController();
 		this.settledTurnFailureFinalizationAllowed = false;
-		this.terminalFailure = new CodexTerminalFailureProjection();
+		this.promptErrorSource = null;
 		this.synthesizedMissingToolResultError = null;
 		this.aborted = false;
 		this.usageProjection = new CodexUsageProjection();
@@ -1448,8 +1605,7 @@ var CodexTurnProjection = class {
 	}
 	buildResult(toolTelemetry, options) {
 		this.eventProjection.flushPendingGuardianWarning();
-		const { params: runParams, turnId, completedTurn, aborted, contextTokens, contextTokensSource, completedCompactionCount, synthesizedMissingToolResultError: previousMissingToolResultError } = this;
-		const { promptError: initialPromptError, promptErrorSource: initialPromptErrorSource, providerRefusal } = this.terminalFailure;
+		const { params: runParams, turnId, completedTurn, aborted, contextTokens, contextTokensSource, completedCompactionCount, synthesizedMissingToolResultError: previousMissingToolResultError, promptError: initialPromptError, promptErrorSource: initialPromptErrorSource, providerRefusal } = this;
 		const upstreamUserText = this.options.upstreamUserText;
 		const turnTainted = this.settlement.turnTainted;
 		const observedItemCount = (/* @__PURE__ */ new Set([...this.observedItemIds, ...this.completedItemIds])).size;
@@ -1504,7 +1660,7 @@ var CodexTurnProjection = class {
 			commentaryMessages,
 			toolMessages: this.toolTranscriptProjection.transcriptMessages,
 			steeringMessages: options?.steeringMessages,
-			lastAssistant,
+			lastAssistant: lastAssistant ? attachCodexAssistantItemIds(lastAssistant, this.assistantProjection.collectTerminalAssistantItemIds()) : void 0,
 			turnTainted
 		});
 		const turnFailed = completedTurn?.status === "failed";
@@ -1570,6 +1726,17 @@ var CodexTurnProjection = class {
 		for (const toolResult of toolTelemetry.coreTtsToolResults ?? []) transferTtsProvenance?.(toolResult, result, toolAutoDeliveryMediaUrls ?? []);
 		return result;
 	}
+	recordTerminalFailure(params) {
+		const refusal = readCodexProviderRefusal(params.message, params.codexErrorInfo, params);
+		if (!this.providerRefusal || refusal?.category === "misalignment" && this.providerRefusal.category === "misalignment" && params.misalignment != null) this.providerRefusal = refusal;
+		if (this.providerRefusal) return;
+		this.promptError = resolveCodexPromptError({
+			message: params.message,
+			codexErrorInfo: params.codexErrorInfo,
+			rateLimits: params.rateLimits
+		}) ?? params.fallbackMessage;
+		this.promptErrorSource = params.promptErrorSource;
+	}
 	emitAgentEvent(event) {
 		if (!this.projectionClosed) emitCodexAgentEvent(this.params, event);
 	}
@@ -1586,17 +1753,17 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		return this.completedTurn?.status;
 	}
 	getPendingNativeCommands() {
-		return !this.projectionClosed && !this.aborted && !this.options.runAbortSignal?.aborted && this.completedTurn?.status === "completed" && !this.terminalFailure.promptError ? this.nativeToolLifecycleProjector.pendingCommands() : /* @__PURE__ */ new Map();
+		return !this.projectionClosed && !this.aborted && !this.options.runAbortSignal?.aborted && this.completedTurn?.status === "completed" && !this.promptError ? this.nativeToolLifecycleProjector.pendingCommands() : /* @__PURE__ */ new Map();
 	}
 	/** Native completion owns the answer independently of unfinished host projection. */
 	recoverCompletedAnswer() {
 		const completed = this.settlement.completedAnswer;
-		if (!completed || this.aborted || this.terminalFailure.promptError) return false;
+		if (!completed || this.aborted || this.promptError) return false;
 		this.closeCompactionProgress();
 		this.projectionController.abort();
 		this.transcriptCheckpoint.abandon();
 		this.completedTurn = completed.turn;
-		this.assistantProjection.recordSnapshotItem(completed.answer);
+		this.assistantProjection.recordItemCompleted(completed.answer);
 		this.assistantProjection.finalizeAnswerCandidate(completed.turn);
 		return true;
 	}
@@ -1608,7 +1775,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		if (!this.projectionClosed) this.nativeToolLifecycleProjector.recordMcpToolCallReceipt(notification);
 	}
 	buildSteeringTranscriptPrefix() {
-		const snapshot = buildCodexSteeringMessagesSnapshot({
+		return buildCodexSteeringMessagesSnapshot({
 			runParams: this.params,
 			turnId: this.turnId,
 			upstreamUserText: this.options.upstreamUserText,
@@ -1616,15 +1783,10 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 			assistantProjection: this.assistantProjection,
 			toolMessages: this.toolTranscriptProjection.transcriptMessages
 		});
-		this.pendingSteeringAssistantBoundaryItemId = snapshot.assistantBoundaryItemId;
-		return snapshot.messages;
 	}
-	markSteeringTranscriptPersisted() {
-		const itemId = this.pendingSteeringAssistantBoundaryItemId;
-		if (itemId) {
-			this.assistantProjection.markAssistantBoundaryPersisted(itemId);
-			this.pendingSteeringAssistantBoundaryItemId = void 0;
-		}
+	markSteeringTranscriptMessagePersisted(mirrorIdentity) {
+		const prefix = `${this.turnId}:assistant:`;
+		if (mirrorIdentity.startsWith(prefix)) this.assistantProjection.markSteeringMessagePersisted(mirrorIdentity.slice(prefix.length));
 	}
 	/** Fence delayed projections before the turn's final snapshot leaves its owner. */
 	closeProjection() {
@@ -1735,7 +1897,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 				this.eventProjection.handleCyberPolicyError(codexErrorInfo, this.params.modelId);
 				const compactionFailure = codexErrorInfo === "other" && this.isCompacting();
 				this.settledTurnFailureFinalizationAllowed = codexErrorInfo === "serverOverloaded" || compactionFailure;
-				this.terminalFailure.record({
+				this.recordTerminalFailure({
 					message: readCodexErrorNotificationMessage(params),
 					codexErrorInfo,
 					misalignment: isJsonObject(params.error) ? params.error.misalignment : void 0,
@@ -1803,8 +1965,8 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	}
 	markTimedOut() {
 		this.aborted = true;
-		this.terminalFailure.promptError = "codex app-server attempt timed out";
-		this.terminalFailure.promptErrorSource = "prompt";
+		this.promptError = "codex app-server attempt timed out";
+		this.promptErrorSource = "prompt";
 	}
 	markAborted() {
 		this.aborted = true;
@@ -1900,11 +2062,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 			this.completedCompactionCount += 1;
 		}
 		if (!this.asyncDeliveryProjection.allows(item, true)) return;
-		const asyncMessage = this.assistantProjection.recordItemCompleted(item, itemId, this.activeItemIds);
-		if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
-		if (this.projectionClosed) return;
-		await this.reasoningProjection.recordItem(item);
-		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
+		await this.recordCompletedItemContent(item, { itemId });
 		if (this.projectionClosed) return;
 		if (item?.type === "contextCompaction" && itemId) {
 			if (!this.isCompactionProjectionActive()) return;
@@ -1963,13 +2121,13 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		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());
+		const compactionFailure = turn.status === "failed" && (this.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({
+			this.recordTerminalFailure({
 				message: turn.error?.message,
 				codexErrorInfo,
 				misalignment: turn.error?.misalignment,
@@ -1988,11 +2146,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		for (const item of turnItems) {
 			if (!this.asyncDeliveryProjection.allows(item)) continue;
 			this.diagnostics.warnUnknownItemStatus(item);
-			const asyncMessage = this.assistantProjection.recordSnapshotItem(item);
-			if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
-			if (this.projectionClosed) return;
-			await this.reasoningProjection.recordItem(item);
-			await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
+			await this.recordCompletedItemContent(item);
 			if (this.projectionClosed) return;
 			this.toolProgressProjection.recordToolMeta(item);
 			this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
@@ -2020,10 +2174,20 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		this.assistantProjection.finalizeAnswerCandidate(turn);
 		await this.reasoningProjection.maybeEndReasoning();
 	}
+	async recordCompletedItemContent(item, notification) {
+		const asyncMessage = this.assistantProjection.recordItemCompleted(item, notification && {
+			...notification,
+			activeItemIds: this.activeItemIds
+		});
+		if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
+		if (this.projectionClosed) return;
+		await this.reasoningProjection.recordItem(item);
+		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
+	}
 	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
-		if (item.role === "assistant" && extractRawAssistantText(item)) this.eventProjection.markSafetyBufferingAssistantStarted();
+		if (item.role === "assistant" && extractRawResponseItemText(item)) this.eventProjection.markSafetyBufferingAssistantStarted();
 		this.toolSearchEvidenceProjection?.recordRawResponseItem(item);
 		this.toolTranscriptProjection.recordRawNativeToolItem(item);
 		this.assistantProjection.handleRawResponseItemCompleted(item, this.activeItemIds);
@@ -2086,7 +2250,7 @@ var CodexCompactionPlanState = class {
 				role: "user",
 				content: [{
 					type: "input_text",
-					text: `${RESTORED_PLAN_PREAMBLE}\n${serializePlan(this.latestPlan)}`
+					text: `${RESTORED_PLAN_PREAMBLE}\n${this.latestPlan}`
 				}]
 			}]
 		}, {
@@ -2101,25 +2265,19 @@ function readBoundedPlan(markdownValue, stepsValue) {
 		steps: readPlanSteps(stepsValue)
 	});
 	const markdown = canonical.markdown === void 0 ? void 0 : truncateUtf8(canonical.markdown, RESTORED_PLAN_MAX_MARKDOWN_BYTES);
-	const steps = [];
+	const plan = [];
+	const restored = {
+		...markdown?.trim() ? { markdown } : {},
+		plan
+	};
+	let serialized = markdown?.trim() ? JSON.stringify(restored) : void 0;
 	for (const step of canonical.plan) {
-		const candidate = {
-			...markdown?.trim() ? { markdown } : {},
-			steps: [...steps, step]
-		};
-		if (Buffer$1.byteLength(serializePlan(candidate), "utf8") > RESTORED_PLAN_MAX_PAYLOAD_BYTES) break;
-		steps.push(step);
+		restored.plan.push(step);
+		const candidate = JSON.stringify(restored);
+		if (Buffer$1.byteLength(candidate, "utf8") > RESTORED_PLAN_MAX_PAYLOAD_BYTES) break;
+		serialized = candidate;
 	}
-	return markdown?.trim() || steps.length > 0 ? {
-		...markdown?.trim() ? { markdown } : {},
-		steps
-	} : void 0;
-}
-function serializePlan(plan) {
-	return JSON.stringify({
-		markdown: plan.markdown,
-		plan: plan.steps
-	});
+	return serialized;
 }
 function truncateUtf8(value, maxBytes) {
 	if (Buffer$1.byteLength(value, "utf8") <= maxBytes) return value;
@@ -2157,9 +2315,7 @@ async function restoreCodexAttemptCompactionContext(resources) {
 		thread.liveThreadOwnership?.assertCurrent();
 		if (state.thread !== thread || state.client !== client) throw new Error("Codex compaction thread ownership changed");
 	};
-	computerContextEpoch.value += 1;
-	delete computerContextEpoch.frameToolCallId;
-	delete computerContextEpoch.frameImageIdentity;
+	invalidateCodexComputerFrame(computerContextEpoch);
 	try {
 		await compactionPlanState.restore({
 			client,
@@ -2266,7 +2422,7 @@ function createCodexUserInputBridge(params) {
 			const mode = readOwnDataString(request.params, "mode");
 			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params, { richForm: mode === "openaiForm" || mode === "openai/form" });
 			if (agentHarnessStructuredInput.isRecord(requestSnapshot) && readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
-			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-r9axtppm.mjs");
+			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DXG_qaXr.mjs");
 			const compiled = agentHarnessStructuredInput.isRecord(requestSnapshot) ? compileCodexOrdinaryElicitation({
 				snapshot: requestSnapshot,
 				turnId: params.turnId
@@ -2322,8 +2478,8 @@ function readUserInputParams(value) {
 	const threadId = readBoundedUserInputText(snapshot, "threadId", MAX_USER_INPUT_ID);
 	const turnId = readBoundedUserInputText(snapshot, "turnId", MAX_USER_INPUT_ID);
 	const itemId = readBoundedUserInputText(snapshot, "itemId", MAX_USER_INPUT_ID);
-	const questions = readArray(snapshot, "questions", MAX_USER_INPUT_QUESTIONS);
-	if (!threadId || !turnId || !itemId || !questions) return;
+	const questions = readValue(snapshot, "questions");
+	if (!threadId || !turnId || !itemId || !Array.isArray(questions) || questions.length > MAX_USER_INPUT_QUESTIONS) return;
 	const parsed = [];
 	for (const questionValue of questions) {
 		const question = readQuestion(questionValue);
@@ -2363,7 +2519,7 @@ function readOptions(value) {
 	for (const entry of value) {
 		if (!agentHarnessStructuredInput.isRecord(entry)) return;
 		const label = readBoundedUserInputText(entry, "label", MAX_USER_INPUT_ID);
-		const description = readBoundedUserInputText(entry, "description", MAX_USER_INPUT_TEXT, true);
+		const description = readBoundedUserInputText(entry, "description", MAX_USER_INPUT_TEXT);
 		if (!label) return;
 		options.push({
 			label,
@@ -2375,13 +2531,9 @@ function readOptions(value) {
 function readValue(record, key) {
 	return Object.hasOwn(record, key) ? record[key] : void 0;
 }
-function readBoundedUserInputText(record, key, maximum, allowEmpty = false) {
-	const value = readValue(record, key);
-	return typeof value === "string" && value.length <= maximum && (allowEmpty || value.length > 0) ? value : void 0;
-}
-function readArray(record, key, maximum) {
+function readBoundedUserInputText(record, key, maximum) {
 	const value = readValue(record, key);
-	return Array.isArray(value) && value.length <= maximum ? value : void 0;
+	return typeof value === "string" && value.length <= maximum && value.length > 0 ? value : void 0;
 }
 function readOwnDataString(value, key) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
@@ -2561,10 +2713,11 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			state.activeLocalProjections -= 1;
 		}
 	};
+	const isSteeringAvailable = () => !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted;
 	const assertSteeringActive = () => {
 		connection.assertCurrent();
 		runAbortController.signal.throwIfAborted();
-		if (state.completed || state.terminalTurnNotificationQueued) throw new Error("codex app-server turn is no longer accepting steering");
+		if (!isSteeringAvailable()) throw new Error("codex app-server turn is no longer accepting steering");
 	};
 	const workspaceOnly = resolveAttemptFsWorkspaceOnly({
 		config: params.config,
@@ -2590,6 +2743,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		signal: runAbortController.signal,
 		assertActive: assertSteeringActive,
 		withCurrent: connection.withCurrent,
+		withPreparedCurrent: connection.authority.withPreparedCurrent,
 		prepareMessage: async (text, options, assertMessageCurrent) => {
 			const attachmentNote = await connection.prepareInputAttachments({
 				maxChars: Math.max(0, CODEX_TURN_START_TEXT_INPUT_MAX_CHARS - text.length - 2),
@@ -2640,10 +2794,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
 			if (params.sessionTarget && messages.length > 0) {
 				await codexTranscriptMirrorRuntime.mirror({
-					assertCurrent: () => {
-						connection.assertLegacyCurrent();
-						assertSteeringActive();
-					},
+					assertCurrent: composeSessionTranscriptWriteAssertion([connection.assertLegacyCurrent, createNativeSessionBindingAuthority([], assertSteeringActive).assertLegacyCurrent]),
 					agentId: sessionAgentId,
 					sessionKey: contextSessionKey,
 					sessionId: params.sessionId,
@@ -2653,10 +2804,10 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 					idempotencyScope: `codex-app-server:${resourceState.thread.threadId}`,
 					runId: params.runId,
 					runMirrorIdentityPrefix: `${activeTurnId}:`,
+					onAssistantMessageOwned: (identity) => activeProjector.markSteeringTranscriptMessagePersisted(identity),
 					config: params.config
 				});
 				assertSteeringActive();
-				activeProjector.markSteeringTranscriptPersisted();
 			}
 			for (const item of transcriptItems) {
 				const recorder = item.userTurnTranscriptRecorder;
@@ -2668,38 +2819,15 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		}
 	});
 	steeringQueueRef.current = activeSteeringQueue;
+	const { claimPendingUserInputAnswer, cancelPendingUserInput } = createCodexQuestionInputHandlers(params.sessionKey ?? params.sessionId, assertSteeringActive);
 	const injectionGuard = (assertCurrent) => () => {
 		assertCurrent?.();
 		assertSteeringActive();
 		return true;
 	};
-	const claimPendingUserInputAnswer = async (text, optionsLocal, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run") => {
-		if (optionsLocal?.isInboundUserMessage !== true || hasPromptImageInput(optionsLocal)) return false;
-		assertSteeringActive();
-		return await claimPendingAgentQuestionAnswer({
-			sessionKey: params.sessionKey ?? params.sessionId,
-			text,
-			authority: {
-				kind: authorityKind,
-				assertCurrent: injectionGuard(assertCurrent)
-			},
-			sourceRecorder: optionsLocal.userTurnTranscriptRecorder,
-			persist: optionsLocal.userTurnTranscriptRecorder ? async () => {
-				await optionsLocal.userTurnTranscriptRecorder?.persistApproved();
-			} : void 0
-		});
-	};
-	const cancelPendingUserInput = (resolvedBy, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run") => cancelPendingAgentQuestionForSession({
-		sessionKey: params.sessionKey ?? params.sessionId,
-		resolvedBy,
-		authority: {
-			kind: authorityKind,
-			assertCurrent: injectionGuard(assertCurrent)
-		}
-	});
-	const queueMessage = async (text, optionsLocal, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run") => {
+	const queueMessage = async (text, optionsLocal, assertCurrent, authorityKind = assertCurrent ? "source-bound" : "run", preparation) => {
 		const canClaim = injectionGuard(assertCurrent);
-		if (await claimPendingUserInputAnswer(text, optionsLocal, assertCurrent, authorityKind)) {
+		if (await claimPendingUserInputAnswer(text, optionsLocal, assertCurrent, authorityKind, preparation)) {
 			optionsLocal?.onQueueAccepted?.(true);
 			optionsLocal?.onQueueSettled?.();
 			return;
@@ -2707,7 +2835,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		if (optionsLocal?.isInboundUserMessage === true && hasPromptImageInput(optionsLocal)) {
 			assertSteeringActive();
 			try {
-				await cancelPendingUserInput("image-reply", assertCurrent, authorityKind);
+				await cancelPendingUserInput("image-reply", assertCurrent, authorityKind, preparation);
 			} catch (error) {
 				canClaim();
 				if (error instanceof Error && error.name === "QuestionDispatchRefusedError") throw error;
@@ -2715,7 +2843,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			}
 		}
 		try {
-			await activeSteeringQueue.queue(text, optionsLocal, injectionGuard(assertCurrent));
+			await activeSteeringQueue.queue(text, optionsLocal, canClaim, preparation);
 		} catch (error) {
 			if (error instanceof CodexSteeringAcceptedUnconfirmedError) return {
 				transcriptCommit: "unconfirmed",
@@ -2726,10 +2854,13 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	};
 	const messageInjection = {
 		version: 2,
-		isAvailable: () => !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted,
+		isAvailable: isSteeringAvailable,
 		queueMessage,
 		claimPendingUserInputAnswer,
-		cancelPendingUserInput
+		cancelPendingUserInput,
+		claimPendingUserInputAnswerAsync: (text, options, preparation, kind) => claimPendingUserInputAnswer(text, options, preparation.assertCurrent, kind, preparation),
+		cancelPendingUserInputAsync: (resolvedBy, preparation, kind) => cancelPendingUserInput(resolvedBy, preparation.assertCurrent, kind, preparation),
+		queueMessageAsync: connection.authority.withPreparedCurrent ? (text, options, preparation, kind) => queueMessage(text, options, preparation.assertCurrent, kind, preparation) : void 0
 	};
 	const handle = {
 		kind: "embedded",
@@ -2803,7 +2934,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
 			if (thread.preserveNativeModel !== true && thread.connectionScope !== "supervision" && !params.expectedSessionRuntimeOwnership) {
 				const route = resourceState.turnRoute;
-				params.registerPluginRuntimeRefreshConsumer?.(() => resourceState.turnRoute === route && route?.signal.aborted === false && turnRuntime.turnIdRef.current === activeTurnId && !state.completed && !state.terminalTurnNotificationQueued && !runAbortController.signal.aborted);
+				params.registerPluginRuntimeRefreshConsumer?.(() => resourceState.turnRoute === route && route?.signal.aborted === false && turnRuntime.turnIdRef.current === activeTurnId && isSteeringAvailable());
 			}
 			params.replyOperation?.attachBackend(handle);
 			setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
@@ -2988,17 +3119,9 @@ const CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES = 65536;
 const CODEX_APP_SERVER_BYTE_UNITS = {
 	b: 1,
 	k: 1024,
-	kb: 1024,
-	kib: 1024,
-	m: 1048576,
-	mb: 1048576,
-	mib: 1048576,
-	g: 1073741824,
-	gb: 1073741824,
-	gib: 1073741824,
-	t: 1099511627776,
-	tb: 1099511627776,
-	tib: 1099511627776
+	m: 1024 ** 2,
+	g: 1024 ** 3,
+	t: 1024 ** 4
 };
 function parseCodexAppServerByteLimit(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
@@ -3008,7 +3131,8 @@ function parseCodexAppServerByteLimit(value) {
 	const amount = Number(match[1]);
 	if (!Number.isFinite(amount) || amount <= 0) return;
 	const unit = (match[2] ?? "b").toLowerCase();
-	const multiplier = CODEX_APP_SERVER_BYTE_UNITS[unit];
+	const unitPrefix = /^[kmgt](?:i?b)?$/.test(unit) ? unit.charAt(0) : unit;
+	const multiplier = CODEX_APP_SERVER_BYTE_UNITS[unitPrefix];
 	if (multiplier === void 0) return;
 	return Math.max(1, Math.round(amount * multiplier));
 }
@@ -3066,8 +3190,8 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 }
 async function readCodexAppServerRolloutTokenSnapshot(file, openedHandle) {
 	let handle = openedHandle;
-	if (!handle) try {
-		handle = await fs.open(file, "r");
+	try {
+		handle ??= await fs.open(file, "r");
 	} catch {
 		return;
 	}
@@ -3120,10 +3244,10 @@ function readCodexAppServerRolloutTokenSnapshotLine(line) {
 		const totalTokens = typeof value === "number" && Number.isFinite(value) ? value : void 0;
 		const windowValue = info.model_context_window ?? info.modelContextWindow;
 		const modelContextWindow = typeof windowValue === "number" && Number.isFinite(windowValue) && windowValue > 0 ? Math.floor(windowValue) : void 0;
-		const snapshot = {};
-		if (totalTokens !== void 0) snapshot.totalTokens = totalTokens;
-		if (modelContextWindow !== void 0) snapshot.modelContextWindow = modelContextWindow;
-		return snapshot.totalTokens !== void 0 || snapshot.modelContextWindow !== void 0 ? snapshot : void 0;
+		return totalTokens !== void 0 || modelContextWindow !== void 0 ? {
+			totalTokens,
+			modelContextWindow
+		} : void 0;
 	} catch {
 		return;
 	}
@@ -3141,7 +3265,6 @@ function maxDefinedNumber(values) {
 	const nums = values.filter((value) => value !== void 0);
 	return nums.length ? Math.max(...nums) : void 0;
 }
-/** Clears and drops a binding when the native Codex thread is too large to resume safely. */
 async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const binding = params.binding;
 	if (!binding?.threadId) return { binding };
@@ -3252,7 +3375,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		config: params.config,
 		agentId: policyAgentId
 	});
-	const agentDir = params.agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId);
+	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
 	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
 	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
 	const assertLocalTargetSupported = (unsupported) => {
@@ -3268,16 +3391,19 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const disableLoginShell = remoteExec || preparedEnvironment?.localProcessEnv !== void 0 || preparedEnvironment?.managedLocalIdentity === true || preparedEnvironment !== void 0 && Object.keys(preparedEnvironment.credentialScrubEnv).length > 0;
 	let shellEnvironment = baseShellEnvironment;
 	let shellPathPrepend;
+	let shellGitConfigParameters;
 	const withPreparedProcessEnv = (appServer) => {
 		assertLocalTargetSupported(appServer.start.transport !== "stdio" || Boolean(appServer.remoteWorkspaceRoot));
-		const localToolEnv = !sandbox?.enabled && !remoteExec && appServer.start.transport === "stdio" && !isCodexAppServerProxyLaunch(appServer.start.args) && !appServer.remoteWorkspaceRoot ? preparedEnvironment?.localToolEnv : void 0;
+		const ownedLocalProcess = !sandbox?.enabled && !remoteExec && appServer.start.transport === "stdio" && !isCodexAppServerProxyLaunch(appServer.start.args) && !appServer.remoteWorkspaceRoot;
+		const localToolEnv = ownedLocalProcess ? preparedEnvironment?.localToolEnv : void 0;
+		shellGitConfigParameters = ownedLocalProcess ? preparedEnvironment?.localGitConfigParameters : void 0;
 		const hasLocalToolEnv = localToolEnv && Object.keys(localToolEnv).length > 0;
 		shellPathPrepend = hasLocalToolEnv ? preparedEnvironment?.localToolPathPrepend : void 0;
 		shellEnvironment = hasLocalToolEnv ? {
 			...baseShellEnvironment,
 			...localToolEnv
 		} : baseShellEnvironment;
-		return shellEnvironment ? {
+		const prepared = shellEnvironment ? {
 			...appServer,
 			start: {
 				...appServer.start,
@@ -3287,6 +3413,10 @@ async function prepareCodexAttemptConnection({ params, options }) {
 				}
 			}
 		} : appServer;
+		return shellGitConfigParameters ? {
+			...prepared,
+			start: withCodexAppServerGitConfig(prepared.start, shellGitConfigParameters)
+		} : prepared;
 	};
 	let bindingIdentity = sessionBindingIdentity({
 		sessionId: params.sessionId,
@@ -3299,10 +3429,11 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	let activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
 	const isInactiveThreadBootstrapBinding = (binding) => !activeContextEngine && binding?.contextEngine?.projection?.mode === "thread_bootstrap";
 	if (bindingIdentity.kind === "session" && bindingIdentity.sessionKey) {
-		const authority = await resolveCodexRunSessionBindingAuthority({
-			identity: bindingIdentity,
+		const { state: authority } = await prepareNativeSessionGenerationAuthority({
 			config: params.config,
-			storePath: params.sessionTarget?.storePath
+			storePath: params.sessionTarget?.storePath,
+			target: bindingIdentity,
+			createSupersededError: createCodexSessionGenerationSupersededError
 		});
 		if (authority === "superseded") throw createCodexSessionGenerationSupersededError(bindingIdentity.sessionId);
 		if (authority === "ephemeral") {
@@ -3398,10 +3529,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	};
 	let reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
 	preDynamicStartupStages.mark("auth-profile");
-	let configuredAppServer = await resolveRuntimeOptionsForBinding(startupBinding, {
-		modelProvider: reviewerPolicyContext.modelProvider,
-		model: reviewerPolicyContext.model
-	});
+	let configuredAppServer = await resolveRuntimeOptionsForBinding(startupBinding, reviewerPolicyContext);
 	const effectiveWorkspace = sandbox?.enabled ? sandbox.workspaceAccess === "rw" ? resolvedWorkspace : sandbox.workspaceDir : resolvedWorkspace;
 	const requestedCwd = params.cwd ? resolveUserPath(params.cwd) : void 0;
 	if (sandbox?.enabled && requestedCwd && requestedCwd !== resolvedWorkspace) throw new Error("cwd override is not supported for sandboxed Codex app-server runs; omit cwd or use the agent workspace as cwd");
@@ -3415,31 +3543,30 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const effectiveCwd = sandbox?.enabled ? effectiveWorkspace : sessionPermissionCwd;
 	if (effectiveWorkspace !== resolvedWorkspace) await ensureCodexWorkspaceDirOnce(effectiveWorkspace);
 	preDynamicStartupStages.mark("effective-workspace");
-	const applySessionPermissionPolicy = (appServer, selection) => applyCodexSessionPermissionPolicy({
-		appServer,
-		permissionMode: params.permissionMode,
-		sessionRoot: params.sessionRoot,
-		defaultRoot: effectiveWorkspace,
-		pluginConfig,
-		canUseAutoReview: canUseCodexModelBackedApprovalsReviewerForModel({
-			modelProvider: selection.modelProvider,
-			model: selection.model,
-			config: params.config,
-			env: {
-				...process.env,
-				...appServer.start.env,
-				...shellEnvironment
-			},
-			agentDir,
-			homeScope: appServer.start.homeScope,
-			codexArgs: appServer.start.args
-		}),
-		requirementsToml,
-		policyLocked: startupBinding?.connectionScope === "supervision",
-		execMode: execPolicy.mode
-	});
 	const resolveFinalAppServer = (configured, selection) => {
-		const session = applySessionPermissionPolicy(configured, selection);
+		const session = applyCodexSessionPermissionPolicy({
+			appServer: configured,
+			permissionMode: params.permissionMode,
+			sessionRoot: params.sessionRoot,
+			defaultRoot: effectiveWorkspace,
+			pluginConfig,
+			canUseAutoReview: canUseCodexModelBackedApprovalsReviewerForModel({
+				modelProvider: selection.modelProvider,
+				model: selection.model,
+				config: params.config,
+				env: {
+					...process.env,
+					...configured.start.env,
+					...shellEnvironment
+				},
+				agentDir,
+				homeScope: configured.start.homeScope,
+				codexArgs: configured.start.args
+			}),
+			requirementsToml,
+			policyLocked: startupBinding?.connectionScope === "supervision",
+			execMode: execPolicy.mode
+		});
 		const trusted = resolveCodexAppServerForModelProvider({
 			appServer: session,
 			provider: selection.modelProvider,
@@ -3509,10 +3636,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		preDynamicStartupStages.mark("rotate-binding");
 		if (startupBinding !== startupBindingBeforeRotation) {
 			reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
-			configuredAppServer = await resolveRuntimeOptionsForBinding(startupBinding, {
-				modelProvider: reviewerPolicyContext.modelProvider,
-				model: reviewerPolicyContext.model
-			});
+			configuredAppServer = await resolveRuntimeOptionsForBinding(startupBinding, reviewerPolicyContext);
 			appServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
 		}
 		const sessionPermissionPolicy = resolveCodexEffectiveSessionPermissionPolicy({
@@ -3599,6 +3723,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			agentDir,
 			shellEnvironment,
 			shellPathPrepend,
+			shellGitConfigParameters,
 			disableLoginShell,
 			bindingIdentity,
 			bindingStore,
@@ -3700,15 +3825,7 @@ function buildCodexSystemPromptReport(params) {
 			nonProjectContextChars: params.developerInstructions.length,
 			hash: sha256Text(params.developerInstructions)
 		},
-		injectedWorkspaceFiles: buildCodexBootstrapInjectionStats({
-			bootstrapFiles: params.workspaceBootstrapContext.bootstrapFiles,
-			injectedFiles: params.workspaceBootstrapContext.promptContextFiles ?? [],
-			omitReferenceFiles: params.omitWorkspaceReferences,
-			omitPersonalProfiles: !params.parentLocalEgress,
-			developerInstructionFiles: [...params.workspaceBootstrapContext.threadDeveloperInstructionFiles ?? [], ...params.workspaceBootstrapContext.personaFiles ?? []],
-			memoryToolRoutedBootstrapFiles: params.workspaceBootstrapContext.memoryToolRoutedBootstrapFiles ?? [],
-			memoryToolRouted: params.workspaceBootstrapContext.memoryToolRouted === true
-		}),
+		injectedWorkspaceFiles: buildCodexBootstrapInjectionStats(params),
 		skills: {
 			promptChars: skillsPrompt.length,
 			hash: sha256Text(skillsPrompt),
@@ -3730,27 +3847,19 @@ function buildCodexSkillReportEntries(skillsPrompt) {
 }
 function buildCodexToolReportEntry(tool) {
 	const summary = tool.description.trim();
+	const deferred = tool.deferLoading === true;
+	const schema = deferred ? null : tool.inputSchema;
+	let schemaChars = 0;
+	if (!deferred) try {
+		schemaChars = JSON.stringify(schema).length;
+	} catch {
+		schemaChars = 0;
+	}
+	const properties = isJsonObject(schema) && isJsonObject(schema.properties) ? schema.properties : null;
 	return {
 		name: tool.name,
 		summaryChars: summary.length,
 		summaryHash: sha256Text(summary),
-		...tool.deferLoading === true ? {
-			schemaChars: 0,
-			schemaHash: stableJsonHash(null),
-			propertiesCount: null
-		} : buildCodexToolSchemaStats(tool.inputSchema)
-	};
-}
-function buildCodexToolSchemaStats(schema) {
-	const schemaChars = (() => {
-		try {
-			return JSON.stringify(schema).length;
-		} catch {
-			return 0;
-		}
-	})();
-	const properties = isJsonObject(schema) && isJsonObject(schema.properties) ? schema.properties : null;
-	return {
 		schemaChars,
 		schemaHash: stableJsonHash(schema),
 		propertiesCount: properties ? Object.keys(properties).length : null
@@ -3763,17 +3872,18 @@ function stableJsonHash(value) {
 	return sha256Text(JSON.stringify(stabilizeJsonValue(value)) ?? "null");
 }
 function buildCodexBootstrapInjectionStats(params) {
-	const injectedIndex = indexCodexContextFileContent(params.injectedFiles);
-	const developerInstructionIndex = indexCodexContextFileContent(params.developerInstructionFiles ?? []);
-	const memoryToolRoutedPaths = new Set((params.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonBlankString(file.path)).filter(isNonEmptyString).map(normalizeCodexContextFilePath));
-	return params.bootstrapFiles.map((file) => {
+	const context = params.workspaceBootstrapContext;
+	const readInjected = indexCodexContextFileContent(context.promptContextFiles ?? []);
+	const readDeveloperInstruction = indexCodexContextFileContent([...context.threadDeveloperInstructionFiles ?? [], ...context.personaFiles ?? []]);
+	const memoryToolRoutedPaths = new Set((context.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonBlankString(file.path)).filter(isNonEmptyString).map(normalizeCodexContextFilePath));
+	return context.bootstrapFiles.map((file) => {
 		const fileName = readNonBlankString(file.name);
 		const pathValue = readNonBlankString(file.path) ?? fileName ?? "";
 		const displayName = (fileName ?? getCodexContextFileDisplayBasename(pathValue)) || pathValue;
 		const baseName = getCodexContextFileBasename(pathValue || fileName || "");
 		const rawChars = file.missing ? 0 : (file.content ?? "").trimEnd().length;
-		const memoryToolRoutedFile = baseName === "memory.md" && params.memoryToolRouted === true && memoryToolRoutedPaths.has(normalizeCodexContextFilePath(pathValue));
-		const injected = memoryToolRoutedFile ? void 0 : readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) ?? readCodexIndexedContextFileContent(developerInstructionIndex, pathValue, fileName);
+		const memoryToolRoutedFile = baseName === "memory.md" && context.memoryToolRouted === true && memoryToolRoutedPaths.has(normalizeCodexContextFilePath(pathValue));
+		const injected = memoryToolRoutedFile ? void 0 : readInjected(pathValue, fileName) ?? readDeveloperInstruction(pathValue, fileName);
 		if (!file.missing && injected === void 0 && CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName)) return {
 			name: displayName,
 			path: pathValue,
@@ -3783,7 +3893,7 @@ function buildCodexBootstrapInjectionStats(params) {
 			injectedChars: null,
 			truncated: null
 		};
-		const omitted = params.omitPersonalProfiles && file.personalUser === true || memoryToolRoutedFile || params.omitReferenceFiles && readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) !== void 0;
+		const omitted = !params.parentLocalEgress && file.personalUser === true || memoryToolRoutedFile || params.omitWorkspaceReferences && readInjected(pathValue, fileName) !== void 0;
 		const injectedChars = omitted ? 0 : injected?.length ?? 0;
 		const truncated = omitted ? false : !file.missing && injectedChars < rawChars;
 		return {
@@ -3806,15 +3916,11 @@ function indexCodexContextFileContent(files) {
 		const baseName = getCodexContextFileBasename(pathValue);
 		if (baseName && !byBaseName.has(baseName)) byBaseName.set(baseName, file.content);
 	}
-	return {
-		byPath,
-		byBaseName
+	return (pathValue, fileName) => {
+		const baseName = getCodexContextFileBasename(fileName ?? pathValue);
+		return byPath.get(pathValue) ?? (fileName ? byPath.get(fileName) : void 0) ?? (baseName ? byBaseName.get(baseName) : void 0);
 	};
 }
-function readCodexIndexedContextFileContent(index, pathValue, fileName) {
-	const baseName = getCodexContextFileBasename(fileName ?? pathValue);
-	return index.byPath.get(pathValue) ?? (fileName ? index.byPath.get(fileName) : void 0) ?? (baseName ? index.byBaseName.get(baseName) : void 0);
-}
 function readPositiveNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
 }
@@ -3892,7 +3998,7 @@ function resolveCodexDeliveryHintPreservedInputRange(params) {
 	if (!deliveryHint || !promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !decoratedPrompt.endsWith(promptWithoutDeliveryHint)) return;
 	const promptWithoutDeliveryHintStart = prompt.length - promptWithoutDeliveryHint.length;
 	const inputStart = Math.max(promptInputRange.start, promptWithoutDeliveryHintStart);
-	const inputEnd = Math.max(inputStart, Math.min(promptInputRange.end, promptWithoutDeliveryHint.length + promptWithoutDeliveryHintStart));
+	const inputEnd = Math.max(inputStart, promptInputRange.end);
 	const decoratedPromptSuffixStart = decoratedPrompt.length - promptWithoutDeliveryHint.length;
 	const requestHeader = "Current user request:\n";
 	const requestHeaderStart = decoratedPromptSuffixStart - 22;
@@ -3914,7 +4020,7 @@ function splitLeadingCodexDeliveryHint(prompt) {
 //#region extensions/codex/src/app-server/run-attempt-context.ts
 async function prepareCodexAttemptContext(runtime, attemptTools) {
 	const { connection, runtimeParams, effectiveContextWindowInfo, effectiveContextTokenBudget, effectiveRuntimeProviderId, effectiveRuntimeModelId, hookChannelId } = runtime;
-	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart, sandbox } = connection;
+	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, sandbox } = connection;
 	const { toolBridge } = attemptTools;
 	const activeTranscriptTarget = {
 		agentId: sessionAgentId,
@@ -4022,7 +4128,10 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		dynamicTools: toolBridge.availableSpecs
 	});
 	const refreshableInstructions = joinPresentSections(skillsInstructions, workspaceBootstrapContext.sharedPersonaInstructions, workspaceBootstrapContext.memoryInstructions) || void 0;
-	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
+	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, {
+		dynamicTools: toolBridge.availableSpecs,
+		nativeCodeModeOnlyEnabled: runtime.nativeToolSurfaceEnabled && connection.appServer.codeModeOnly
+	}), agentWorkspaceDeveloperInstructions);
 	const watchedSessionsContext = await prepareCodexWatchedSessionsContext({
 		attempt: runtimeParams,
 		dynamicTools: toolBridge.availableSpecs,
@@ -4058,10 +4167,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 			promptContextRange: void 0,
 			developerInstructions: baseDeveloperInstructions,
 			contextEngineProjection: void 0,
-			precomputedStaleBindingContinuityProjectionApplied: false,
-			staleBindingContinuityForcedFreshStart: false,
-			noEngineContinuityProjectionApplied: false,
-			inactiveThreadBootstrapBindingForcedFreshStart: initialInactiveThreadBootstrapBindingForcedFreshStart
+			noEngineContinuityProjectionApplied: false
 		},
 		codexContextProjectionMaxChars: resolveCodexContextEngineProjectionMaxChars({ contextTokenBudget: effectiveContextTokenBudget }),
 		codexContinuityProjectionMaxChars: resolveCodexContinuityProjectionMaxChars({
@@ -4113,12 +4219,15 @@ function createCodexModelCallDiagnosticEmitter(params) {
 	let started = false;
 	let terminalEmitted = false;
 	let requestPayloadBytes;
-	const privateData = (modelContent) => modelContent && Object.keys(modelContent).length > 0 ? { modelContent } : void 0;
-	const buildContent = () => ({
-		...params.capture.inputMessages ? { inputMessages: params.buildInputMessages() } : {},
-		...params.capture.systemPrompt ? { systemPrompt: params.buildSystemPrompt() } : {},
-		...toolDefinitions ? { toolDefinitions } : {}
-	});
+	const buildPrivateData = (terminalOutput) => {
+		const modelContent = {
+			...params.capture.inputMessages ? { inputMessages: params.buildInputMessages() } : {},
+			...params.capture.systemPrompt ? { systemPrompt: params.buildSystemPrompt() } : {},
+			...toolDefinitions ? { toolDefinitions } : {},
+			...terminalOutput && params.capture.outputMessages ? terminalOutput : {}
+		};
+		return Object.keys(modelContent).length > 0 ? { modelContent } : void 0;
+	};
 	const emitTerminal = (type, outputMessages, fields = {}) => {
 		if (!started || terminalEmitted) return false;
 		terminalEmitted = true;
@@ -4128,10 +4237,7 @@ function createCodexModelCallDiagnosticEmitter(params) {
 			durationMs: Math.max(0, now() - startedAt),
 			...fields,
 			...requestPayloadBytes !== void 0 ? { requestPayloadBytes } : {}
-		}, privateData({
-			...buildContent(),
-			...params.capture.outputMessages ? { outputMessages } : {}
-		}));
+		}, buildPrivateData({ outputMessages }));
 		return true;
 	};
 	return {
@@ -4144,7 +4250,7 @@ function createCodexModelCallDiagnosticEmitter(params) {
 			emitTrustedDiagnosticEventWithPrivateData({
 				type: "model.call.started",
 				...params.baseFields
-			}, privateData(buildContent()));
+			}, buildPrivateData());
 		},
 		emitCompleted(result) {
 			emitTerminal("model.call.completed", result.lastAssistant ? [result.lastAssistant] : result.assistantTexts);
@@ -4373,8 +4479,7 @@ function createCodexTrajectoryRecorder(trajectory) {
 	};
 }
 function recordCodexTrajectoryContext(recorder, params) {
-	if (!recorder) return;
-	recorder.recordEvent("context.compiled", {
+	recorder?.recordEvent("context.compiled", {
 		systemPrompt: params.developerInstructions,
 		prompt: params.prompt ?? params.attempt.prompt,
 		imagesCount: params.attempt.images?.length ?? 0,
@@ -4401,12 +4506,11 @@ function toTrajectoryToolDefinitions(tools) {
 	if (!tools || tools.length === 0) return;
 	return flattenCodexDynamicToolFunctions(tools).flatMap((tool) => {
 		const name = tool.name?.trim();
-		if (!name) return [];
-		return [{
+		return name ? [{
 			name,
 			description: tool.description,
 			parameters: tool.inputSchema
-		}];
+		}] : [];
 	}).toSorted((left, right) => left.name.localeCompare(right.name));
 }
 function normalizeCodexTrajectoryError(value) {
@@ -4422,7 +4526,7 @@ function normalizeCodexTrajectoryError(value) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-finalize.ts
 async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, requestRuntime, activeTurn) {
-	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder } = resources;
 	const { context, systemPromptReport } = prompt;
 	const { runtime, attemptTools, activeTranscriptTarget, hookContext } = context;
 	const { hookRunner } = context;
@@ -4454,6 +4558,8 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			readRetainedNativeCommands,
 			steeringMessages: params.pluginRuntimeRefreshPending?.() ? turnRuntime.steeringQueueRef.current?.getAcceptedMessages() : void 0
 		});
+		const terminalAssistantSource = result.messagesSnapshot.find((message) => readMirrorIdentity(message) === `${activeTurnId}:assistant`);
+		const terminalSourceKey = terminalAssistantSource?.role === "assistant" ? buildCodexMirrorIdempotencyKey(`codex-app-server:${resourceState.thread.threadId}`, buildCodexMirrorDedupeIdentity(terminalAssistantSource)) : 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);
@@ -4534,7 +4640,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			for (const message of [
 				result.lastAssistant,
 				result.currentAttemptAssistant,
-				result.messagesSnapshot.find((candidate) => readMirrorIdentity(candidate) === `${activeTurnId}:assistant`)
+				terminalAssistantSource
 			]) if (message?.role === "assistant") {
 				if (!message.diagnostics?.some((diagnostic) => diagnostic.type === "provider_refusal") || finalAborted || finalPromptError) {
 					message.stopReason = finalAborted ? "aborted" : finalPromptError ? "error" : "stop";
@@ -4563,11 +4669,11 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			const mirrorTerminal = projectTerminalOutcome();
 			state.pendingSettlementStage = "transcript/mirror";
 			return codexTranscriptMirrorRuntime.mirrorBestEffort({
-				assertWriteCurrent: () => {
+				assertWriteCurrent: createNativeSessionBindingAuthority([], () => {
 					if (!isSettlementActive() || state.settlementWarning !== warning) throw new Error("Codex transcript settlement is no longer active");
 					const current = projectTerminalOutcome();
 					if (current.finalAborted !== mirrorTerminal.finalAborted || current.effectiveTimedOut !== mirrorTerminal.effectiveTimedOut || current.finalPromptError !== mirrorTerminal.finalPromptError) throw new Error("Codex transcript terminal outcome changed before write");
-				},
+				}).assertLegacyCurrent,
 				params,
 				settlementWarning: warning,
 				agentId: sessionAgentId,
@@ -4579,43 +4685,40 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 				turnId: activeTurnId
 			});
 		};
-		try {
-			if (projectionDrained && isSettlementActive() && !state.settlementWarning) mirrorOutcome = await Promise.race([
-				mirrorFinal(),
-				drainGraceElapsed.promise.then(() => unavailableMirror),
-				degradedSettlement.then(() => unavailableMirror)
+		if (projectionDrained && isSettlementActive() && !state.settlementWarning) mirrorOutcome = await Promise.race([
+			mirrorFinal(),
+			drainGraceElapsed.promise.then(() => unavailableMirror),
+			degradedSettlement.then(() => unavailableMirror)
+		]);
+		if (state.settlementWarning && !runAbortController.signal.aborted) {
+			mirrorOutcome = await Promise.race([mirrorFinal(), drainGraceElapsed.promise.then(() => unavailableMirror)]);
+			if (mirrorOutcome === unavailableMirror) trajectoryRecorder?.recordEvent("turn.settlement_persistence_unavailable", {
+				pendingStage: "transcript/mirror",
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId
+			});
+		}
+		if (toolState.yieldMessage && projectTerminalOutcome().turnSucceeded) {
+			state.pendingSettlementStage = "transcript/yield-context";
+			await Promise.race([
+				appendSessionYieldContext({
+					...activeTranscriptTarget.sessionTarget,
+					agentId: activeTranscriptTarget.agentId,
+					sessionId: activeTranscriptTarget.sessionId,
+					sessionKey: activeTranscriptTarget.sessionKey,
+					config: params.config,
+					message: toolState.yieldMessage,
+					assertCurrent: () => {
+						connection.assertLegacyCurrent();
+						if (!isSettlementActive() || !projectTerminalOutcome().turnSucceeded) throw new Error("Codex yield settlement is no longer active");
+					}
+				}),
+				drainGraceElapsed.promise,
+				degradedSettlement
 			]);
-			if (state.settlementWarning && !runAbortController.signal.aborted) {
-				mirrorOutcome = await Promise.race([mirrorFinal(), drainGraceElapsed.promise.then(() => unavailableMirror)]);
-				if (mirrorOutcome === unavailableMirror) trajectoryRecorder?.recordEvent("turn.settlement_persistence_unavailable", {
-					pendingStage: "transcript/mirror",
-					threadId: resourceState.thread.threadId,
-					turnId: activeTurnId
-				});
-			}
-			if (toolState.yieldMessage && projectTerminalOutcome().turnSucceeded) {
-				state.pendingSettlementStage = "transcript/yield-context";
-				await Promise.race([
-					appendSessionYieldContext({
-						...activeTranscriptTarget.sessionTarget,
-						agentId: activeTranscriptTarget.agentId,
-						sessionId: activeTranscriptTarget.sessionId,
-						sessionKey: activeTranscriptTarget.sessionKey,
-						config: params.config,
-						message: toolState.yieldMessage,
-						assertCurrent: () => {
-							connection.assertLegacyCurrent();
-							if (!isSettlementActive() || !projectTerminalOutcome().turnSucceeded) throw new Error("Codex yield settlement is no longer active");
-						}
-					}),
-					drainGraceElapsed.promise,
-					degradedSettlement
-				]);
-			}
-			await settleReplyMedia(activeTurn, result, turnRuntime, runAbortController.signal);
-		} finally {
-			closeSettlement();
 		}
+		await settleReplyMedia(activeTurn, result, turnRuntime, runAbortController.signal);
+		closeSettlement();
 		const { effectiveTimedOut, finalPromptError, codexAppServerFailure, promptTimeoutOutcome, finalAborted, turnSucceeded, attemptSucceeded, completedTurnStatus } = projectTerminalOutcome();
 		terminalState.settledTurnStatus = turnSucceeded ? "completed" : completedTurnStatus === "failed" && !finalAborted && !effectiveTimedOut && !state.clientClosedPromptError && !resourceState.executionDisconnectError ? "failed" : void 0;
 		terminalState.sharedAbortAllowedAfterTerminalOutcome = shouldKeepCodexSharedAbortOpen({
@@ -4731,14 +4834,15 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			yieldDetected: toolState.yieldDetected,
 			promptError: normalizeCodexTrajectoryError(finalPromptError)
 		});
-		markTrajectoryEndRecorded();
+		resourceState.trajectoryEndRecorded = true;
 		const terminalAssistantText = collectTerminalAssistantText(result);
+		const terminalAssistantItemId = assistantTranscriptIdempotencyKey ?? terminalSourceKey;
 		if (terminalAssistantText && (assistantTranscriptIdempotencyKey || (!streamState.eventEmitted || streamState.needsTerminalSnapshot) && !finalAborted && !finalPromptError)) emitCodexAppServerEvent(params, {
 			stream: "assistant",
 			data: {
 				text: terminalAssistantText,
-				...assistantTranscriptIdempotencyKey ? {
-					itemId: assistantTranscriptIdempotencyKey,
+				...terminalAssistantItemId ? {
+					itemId: terminalAssistantItemId,
 					replace: true,
 					replaceable: true
 				} : {}
@@ -4803,58 +4907,53 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 	const { connection } = prompt.context.runtime;
 	const { params, attemptStartedAt, runAbortController, fastModeAutoStartedAtMs, fastModeAutoProgressState } = connection;
 	const { state, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds } = turnRuntime;
-	const releaseTurnAfterTerminalDynamicTool = (value) => {
-		if (!shouldReleaseTurnAfterTerminalDynamicTool({
-			completed: state.completed,
-			aborted: runAbortController.signal.aborted,
-			responseSuccess: value.response.success,
-			currentTurnHadNonTerminalDynamicToolResult: state.currentTurnHadNonTerminalDynamicToolResult,
-			activeAppServerTurnRequests: state.activeAppServerTurnRequests,
-			activeTurnItemIdsCount: activeTurnItemIds.size,
-			pendingOpenClawDynamicToolCompletionIdsCount: pendingOpenClawDynamicToolCompletionIds.size
-		})) return;
-		state.pendingTerminalDynamicToolRelease = void 0;
-		trajectoryRecorder?.recordEvent("turn.dynamic_tool_terminal_release", {
-			threadId: value.call.threadId,
-			turnId: value.call.turnId,
-			toolCallId: value.call.callId,
-			name: value.call.tool,
-			durationMs: value.durationMs
-		});
-		embeddedAgentLog.info("codex app-server turn released after terminal dynamic tool result", {
-			threadId: value.call.threadId,
-			turnId: value.call.turnId,
-			toolCallId: value.call.callId,
-			tool: value.call.tool,
-			durationMs: value.durationMs
-		});
-		turnRuntime.steeringQueueRef.current?.cancel();
-		turnRuntime.interruptTurn(value.call.turnId, { locallyCompleted: true });
-		turnRuntime.completeTurn();
-	};
+	const batchHadNonTerminalResult = () => state.currentTurnHadNonTerminalDynamicToolResult && !state.currentTurnHadToolAuthoredFinalReply;
 	const scheduleTerminalDynamicToolReleaseCheck = () => {
 		if (state.terminalDynamicToolReleaseCheckScheduled || !state.pendingTerminalDynamicToolRelease && !state.currentTurnHadNonTerminalDynamicToolResult) return;
 		state.terminalDynamicToolReleaseCheckScheduled = true;
 		setImmediate(() => {
 			state.terminalDynamicToolReleaseCheckScheduled = false;
-			if (state.pendingTerminalDynamicToolRelease?.response.success === true && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0) turnRuntime.steeringQueueRef.current?.cancel();
-			const action = resolveTerminalDynamicToolBatchAction({
-				activeAppServerTurnRequests: state.activeAppServerTurnRequests,
-				activeTurnItemIdsCount: activeTurnItemIds.size,
-				pendingOpenClawDynamicToolCompletionIdsCount: pendingOpenClawDynamicToolCompletionIds.size,
-				currentTurnHadNonTerminalDynamicToolResult: state.currentTurnHadNonTerminalDynamicToolResult,
-				hasPendingTerminalDynamicToolRelease: state.pendingTerminalDynamicToolRelease !== void 0
-			});
-			if (action === "release-pending-terminal" && state.pendingTerminalDynamicToolRelease) releaseTurnAfterTerminalDynamicTool(state.pendingTerminalDynamicToolRelease);
-			else if (action === "clear-nonterminal-batch") {
+			if (state.pendingTerminalDynamicToolRelease?.response.success === true && !batchHadNonTerminalResult() && state.activeAppServerTurnRequests === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0) turnRuntime.steeringQueueRef.current?.cancel();
+			if (state.activeAppServerTurnRequests > 0 || activeTurnItemIds.size > 0 || pendingOpenClawDynamicToolCompletionIds.size > 0) return;
+			if (batchHadNonTerminalResult()) {
 				state.pendingTerminalDynamicToolRelease = void 0;
 				state.currentTurnHadNonTerminalDynamicToolResult = false;
+				state.currentTurnHadToolAuthoredFinalReply = false;
+				return;
 			}
+			const value = state.pendingTerminalDynamicToolRelease;
+			if (!value || state.completed || runAbortController.signal.aborted || !value.response.success || state.activeAppServerTurnRequests !== 0 || activeTurnItemIds.size !== 0 || pendingOpenClawDynamicToolCompletionIds.size !== 0) return;
+			state.pendingTerminalDynamicToolRelease = void 0;
+			state.currentTurnHadToolAuthoredFinalReply = false;
+			trajectoryRecorder?.recordEvent("turn.dynamic_tool_terminal_release", {
+				threadId: value.call.threadId,
+				turnId: value.call.turnId,
+				toolCallId: value.call.callId,
+				name: value.call.tool,
+				durationMs: value.durationMs
+			});
+			embeddedAgentLog.info("codex app-server turn released after terminal dynamic tool result", {
+				threadId: value.call.threadId,
+				turnId: value.call.turnId,
+				toolCallId: value.call.callId,
+				tool: value.call.tool,
+				durationMs: value.durationMs
+			});
+			turnRuntime.steeringQueueRef.current?.cancel();
+			turnRuntime.interruptTurn(value.call.turnId, { locallyCompleted: true });
+			turnRuntime.completeTurn();
 		}).unref?.();
 	};
-	const scheduleTurnReleaseAfterTerminalDynamicTool = (value) => {
-		state.pendingTerminalDynamicToolRelease = value;
-		scheduleTerminalDynamicToolReleaseCheck();
+	const recordDynamicToolResult = (value) => {
+		if (value.response.success && value.response.toolAuthoredFinalReply === true) state.currentTurnHadToolAuthoredFinalReply = true;
+		if (value.response.terminate === true && value.response.success) {
+			state.pendingTerminalDynamicToolRelease = value;
+			scheduleTerminalDynamicToolReleaseCheck();
+		} else if (value.response.asyncStarted === true) scheduleTerminalDynamicToolReleaseCheck();
+		else {
+			state.currentTurnHadNonTerminalDynamicToolResult = true;
+			if (!state.currentTurnHadToolAuthoredFinalReply) state.pendingTerminalDynamicToolRelease = void 0;
+		}
 	};
 	const { emitLifecycleStart, emitLifecycleTerminal, emitExecutionPhaseOnce } = createAgentHarnessAttemptLifecycle({
 		attempt: params,
@@ -4934,8 +5033,8 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		}
 	};
 	return {
+		recordDynamicToolResult,
 		scheduleTerminalDynamicToolReleaseCheck,
-		scheduleTurnReleaseAfterTerminalDynamicTool,
 		emitLifecycleStart,
 		emitLifecycleTerminal,
 		buildLifecycleTerminalMeta,
@@ -4946,6 +5045,78 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/session-warnings.ts
+const MAX_WARNING_RECEIPTS = 256;
+const ULTRAFAST_REQUIREMENT_WARNING_PREFIX = "Ignoring unknown `features` requirement `ultrafast_mode` from ";
+function readWarningReceipts(entry) {
+	const state = entry.pluginExtensions?.codex?.warningReceipts;
+	if (!isJsonObject(state) || state.version !== 1 || state.sessionId !== entry.sessionId || state.lifecycleRevision !== (entry.lifecycleRevision ?? null) || !Array.isArray(state.hashes)) return [];
+	return state.hashes.slice(0, MAX_WARNING_RECEIPTS).filter((value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value));
+}
+/** Session-owned receipts survive native reconnects and Gateway restart, but not chat reset. */
+async function projectCodexSessionWarning(params) {
+	const { notification, session } = params;
+	const body = isJsonObject(notification.params) ? notification.params : void 0;
+	const scope = readCodexNotificationScope(body);
+	const message = body ? readCodexAppServerWarningMessage(body) : "";
+	if (notification.method !== "warning" && notification.method !== "configWarning" || !body || !message.startsWith(ULTRAFAST_REQUIREMENT_WARNING_PREFIX) || message.length === 62 || !session.sessionKey || scope.threadId && scope.threadId !== params.threadId) {
+		params.assertCurrent();
+		await params.project();
+		return;
+	}
+	const hash = createHash("sha256").update(JSON.stringify([
+		message,
+		body.path ?? null,
+		body.range ?? null
+	])).digest("hex");
+	let foundSession = false;
+	let projectionAttempted = false;
+	const project = async () => {
+		params.assertCurrent();
+		projectionAttempted = true;
+		return await params.project();
+	};
+	try {
+		await patchSessionEntry({
+			agentId: session.agentId,
+			sessionKey: session.sessionKey,
+			storePath: session.storePath,
+			preserveActivity: true,
+			requireWriteSuccess: true,
+			skipMaintenance: true,
+			update: async (entry) => {
+				foundSession = true;
+				params.assertCurrent();
+				if (entry.sessionId !== session.sessionId || session.expectedLifecycleRevision !== void 0 && entry.lifecycleRevision !== session.expectedLifecycleRevision) return null;
+				const hashes = readWarningReceipts(entry);
+				if (hashes.includes(hash)) return null;
+				if (!await project()) return null;
+				params.assertCurrent();
+				if (hashes.length >= MAX_WARNING_RECEIPTS) return null;
+				return { pluginExtensions: {
+					...entry.pluginExtensions,
+					codex: {
+						...entry.pluginExtensions?.codex,
+						warningReceipts: {
+							version: 1,
+							sessionId: entry.sessionId,
+							lifecycleRevision: entry.lifecycleRevision ?? null,
+							hashes: [...hashes, hash]
+						}
+					}
+				} };
+			}
+		});
+	} catch (error) {
+		if (projectionAttempted) throw error;
+		params.assertCurrent();
+		embeddedAgentLog.debug("Codex warning receipt store unavailable", { error });
+		await project();
+		return;
+	}
+	if (!foundSession) await project();
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-notification-controller.ts
 function createCodexAttemptNotificationController(resources, turnRuntime, lifecycle) {
 	const { prompt, state: resourceState, projectorRef } = resources;
@@ -4956,20 +5127,11 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 	const { state, turnIdRef, steeringQueueRef, activeTurnItemIds, pendingOpenClawDynamicToolCompletionIds, openClawDynamicToolExecutions, completeTurn, noteProgress, deadlines } = turnRuntime;
 	const { scheduleTerminalDynamicToolReleaseCheck, reportExecutionNotification, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const pendingNativeCommandItems = /* @__PURE__ */ new Set();
-	const nativeItemObservers = /* @__PURE__ */ new Set();
+	let nativeItemsCompletion;
 	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 completion = nativeItemsCompletion ??= createDeferred();
+		if (!await waitForPromiseOrAbort(completion.promise, signal)) signal.throwIfAborted();
 	};
 	const readTerminalTurn = (notification, notificationTurnId) => notification.method === "turn/completed" && isCodexNotificationForTurn(notification.params, resourceState.thread.threadId, notificationTurnId) ? readCodexTurnCompletedNotification(notification.params)?.turn : void 0;
 	const handleNotification = async (notification) => {
@@ -4992,10 +5154,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 				updateActiveTurnItemIds(notification, activeTurnItemIds);
 				noteProgress(`notification:${notification.method}`);
 				reportExecutionNotification(notification);
-				if (isPendingOpenClawDynamicToolCompletionNotification(notification, pendingOpenClawDynamicToolCompletionIds)) {
-					const itemId = readNotificationItemId(notification);
-					if (itemId) pendingOpenClawDynamicToolCompletionIds.delete(itemId);
-				}
+				completePendingOpenClawDynamicToolNotification(notification, pendingOpenClawDynamicToolCompletionIds);
 				if (notification.method === "item/completed") {
 					if (activeTurnItemIds.size === 0) scheduleTerminalDynamicToolReleaseCheck();
 					const item = readCodexNotificationItem(notification.params);
@@ -5009,9 +5168,28 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 					}
 					if (item?.type === "userMessage" && typeof item.clientId === "string") steeringQueueRef.current?.confirmConsumed(item.clientId);
 				}
-				if (isCodexTurnAbortMarkerNotification(notification, { currentPromptTexts: [turnState.codexTurnPromptText] })) state.sawCodexInterruptMarker = true;
+				if (isCodexTurnAbortMarkerNotification(notification, { currentPromptText: turnState.codexTurnPromptText })) state.sawCodexInterruptMarker = true;
 			}
-			await projector.handleNotification(notification);
+			if (notification.method === "warning" || notification.method === "configWarning") {
+				const { params, sessionAgentId, assertCurrent } = runtime.connection;
+				await projectCodexSessionWarning({
+					session: {
+						agentId: sessionAgentId,
+						sessionId: params.sessionId,
+						sessionKey: params.sessionTarget?.sessionKey ?? params.sessionKey,
+						storePath: params.sessionTarget?.storePath ?? resolveStorePath(params.config?.session?.store, { agentId: sessionAgentId }),
+						expectedLifecycleRevision: params.sessionTarget?.expectedLifecycleRevision
+					},
+					threadId: resourceState.thread.threadId,
+					notification,
+					assertCurrent,
+					project: async () => {
+						if (state.projectionClosed || projectorRef.current !== projector || turnIdRef.current !== turnId) return false;
+						await projector.handleNotification(notification);
+						return true;
+					}
+				});
+			} else await projector.handleNotification(notification);
 			if (isCurrentTurn && activeTurnItemIds.size === 0 && isRawFunctionToolOutputCompletionNotification(notification)) await maybeAnnounceFastModeAutoOff();
 		} catch (error) {
 			embeddedAgentLog.debug("codex app-server projector notification threw", {
@@ -5024,7 +5202,10 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 				const item = readCodexNotificationItem(notification.params);
 				if (item?.type === "commandExecution") pendingNativeCommandItems.delete(item.id);
 			}
-			for (const observe of nativeItemObservers) observe();
+			if (pendingNativeCommandItems.size === 0) {
+				nativeItemsCompletion?.resolve();
+				nativeItemsCompletion = void 0;
+			}
 			if (completedTurn) {
 				if (completedTurn.status === "interrupted" && state.sawCodexInterruptMarker) projector.markAborted();
 				completeTurn();
@@ -5095,6 +5276,7 @@ async function prepareCodexAttemptPrompt(context) {
 	const { connection, runtimeParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
 	const { params, activeContextEngine, usesSupervisionConnection, mutable, isInactiveThreadBootstrapBinding, bindingStore, bindingIdentity, agentDir, appServer, contextSessionKey, effectiveWorkspace, sandbox } = connection;
 	const { toolBridge } = attemptTools;
+	const availableToolNames = () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString);
 	const nativeHistoryProvenancePrefix = params.trigger === "user" ? buildCodexHistoryProvenancePrefix(params) : void 0;
 	const forkedSession = !mutable.startupBinding?.threadId && params.sessionTarget ? getSessionEntry({
 		...params.sessionTarget,
@@ -5140,10 +5322,10 @@ async function prepareCodexAttemptPrompt(context) {
 	};
 	const applyContinuityProjection = async (messages) => {
 		const projection = await projectContextEngineAssemblyForCodex({
-			assembledMessages: messages,
+			assembledMessages: [...messages, ...params.continuation?.messages ?? []],
 			prompt: params.prompt,
 			maxRenderedContextChars: codexContinuityProjectionMaxChars,
-			toolPayloadMode: params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
+			toolPayloadMode: params.continuation || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
 			prepareFileContext,
 			currentUserTurnIdempotencyKey
 		});
@@ -5162,7 +5344,7 @@ async function prepareCodexAttemptPrompt(context) {
 				sessionKey: contextSessionKey,
 				messages: historyState.messages,
 				tokenBudget: effectiveContextTokenBudget,
-				availableTools: new Set(flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString)),
+				availableTools: new Set(availableToolNames()),
 				citationsMode: params.config?.memory?.citations,
 				sandboxed: sandbox?.enabled === true,
 				modelId: effectiveRuntimeModelId,
@@ -5177,7 +5359,7 @@ async function prepareCodexAttemptPrompt(context) {
 			});
 			if (!assembled) throw new Error("context engine assemble returned no result");
 			const contextEngineProjection = readContextEngineThreadBootstrapProjection(assembled.contextProjection);
-			const projectionDecision = contextEngineProjection ? resolveContextEngineBootstrapProjectionDecision({
+			const projectionDecision = contextEngineProjection && !params.continuation ? resolveContextEngineBootstrapProjectionDecision({
 				startupBinding: decisionStartupBinding,
 				expectedBinding: buildContextEngineBinding({ ...runtimeParams }, contextEngineProjection),
 				projection: contextEngineProjection,
@@ -5188,11 +5370,11 @@ async function prepareCodexAttemptPrompt(context) {
 				reason: "per-turn-projection"
 			};
 			const projection = await projectContextEngineAssemblyForCodex({
-				assembledMessages: assembled.messages,
+				assembledMessages: [...assembled.messages, ...params.continuation?.messages ?? []],
 				prompt: params.prompt,
 				systemPromptAddition: assembled.systemPromptAddition,
 				maxRenderedContextChars: codexContextProjectionMaxChars,
-				toolPayloadMode: contextEngineProjection || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
+				toolPayloadMode: contextEngineProjection || params.continuation || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
 				...projectionDecision.project ? { prepareFileContext } : {},
 				currentUserTurnIdempotencyKey
 			});
@@ -5220,7 +5402,7 @@ async function prepareCodexAttemptPrompt(context) {
 			promptState.promptContextRange = projectionDecision.project ? projection.promptContextRange : void 0;
 			promptState.developerInstructions = joinPresentSections(baseDeveloperInstructions, projection.developerInstructionAddition);
 		} catch (assembleErr) {
-			if (assembleErr instanceof CodexContextAttachmentError || params.pluginRuntimeRefreshMessages) throw assembleErr;
+			if (assembleErr instanceof CodexContextAttachmentError || params.continuation || params.pluginRuntimeRefreshMessages) throw assembleErr;
 			assertProjectionCurrent();
 			embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 		}
@@ -5238,7 +5420,7 @@ async function prepareCodexAttemptPrompt(context) {
 		bootstrapContextRunKind: params.bootstrapContextRunKind,
 		toolAuthority: {
 			fingerprint: params.toolAuthorityFingerprint,
-			activeToolNames: () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString),
+			activeToolNames: availableToolNames,
 			assertActive: connection.assertLegacyCurrent
 		}
 	});
@@ -5306,53 +5488,49 @@ async function prepareCodexAttemptPrompt(context) {
 		...parentLocalContext,
 		skillsInstructions
 	}) : buildTurnCollaborationMode(params).settings.developer_instructions) ?? void 0);
-	const rebuildCodexPromptBuildFromCurrentProjection = async () => {
-		turnState.promptBuild = await buildPromptFromCurrentInputs();
-		turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild);
-	};
-	const rebuildCodexTurnPromptTextFromCurrentProjection = async () => {
+	const rebuildCodexPromptBuildFromCurrentProjection = async (preserveInstructions = false) => {
 		const nextPromptBuild = await buildPromptFromCurrentInputs();
-		turnState.promptBuild = {
+		turnState.promptBuild = preserveInstructions ? {
 			...turnState.promptBuild,
 			prompt: nextPromptBuild.prompt,
 			promptInputRange: nextPromptBuild.promptInputRange
-		};
+		} : nextPromptBuild;
 		turnState.codexTurnPromptText = decorateCodexTurnPromptText(nextPromptBuild);
 	};
-	const selectNewerVisibleHistoryAfterBinding = (binding) => {
+	const applyResumeStaleBindingContinuityProjection = async (binding) => {
 		const cutoff = Date.parse(binding.historyCoveredThrough ?? "");
-		return historyState.messages.filter((message) => {
+		const newerVisibleMessages = historyState.messages.filter((message) => {
 			if (message.role !== "user" && message.role !== "assistant" && !isCodexDurableCustomMessage(message)) return false;
 			const mirrorIdentity = readMirrorIdentity(message);
 			const timestamp = typeof message.timestamp === "number" ? message.timestamp : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
 			return !("idempotencyKey" in message && typeof message.idempotencyKey === "string" && message.idempotencyKey.startsWith("codex-app-server:")) && !hasCodexMirrorOrigin(message) && !mirrorIdentity?.startsWith("codex-app-server:") && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
 		});
-	};
-	const applyResumeStaleBindingContinuityProjection = async (binding) => {
-		const newerVisibleMessages = selectNewerVisibleHistoryAfterBinding(binding);
 		if (newerVisibleMessages.length === 0) return false;
 		await applyContinuityProjection(newerVisibleMessages);
 		return true;
 	};
+	let staleBindingContinuityForcedFreshStart = false;
+	let inactiveThreadBootstrapBindingForcedFreshStart = connection.initialInactiveThreadBootstrapBindingForcedFreshStart;
 	const precomputeNoContextEngineStaleBindingProjection = async () => {
-		promptState.precomputedStaleBindingContinuityProjectionApplied = false;
-		promptState.staleBindingContinuityForcedFreshStart = false;
 		const binding = mutable.startupBinding;
-		if (activeContextEngine || !binding?.threadId || binding.pendingSupervisionBranch) return false;
+		if (activeContextEngine || params.continuation || !binding?.threadId || binding.pendingSupervisionBranch) return false;
 		if (isInactiveThreadBootstrapBinding(binding)) {
-			promptState.inactiveThreadBootstrapBindingForcedFreshStart = true;
+			inactiveThreadBootstrapBindingForcedFreshStart = true;
 			return false;
 		}
-		const projected = await applyResumeStaleBindingContinuityProjection(binding);
-		promptState.precomputedStaleBindingContinuityProjectionApplied = projected;
-		return projected;
+		return await applyResumeStaleBindingContinuityProjection(binding);
 	};
 	const applyNoContextEngineContinuityProjection = async (action, binding) => {
 		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary" || message.role === "assistant" && message.content.some((part) => part.type === "text" && part.text.trim())));
-		if (activeContextEngine || !hasContinuity && !params.pluginRuntimeRefreshMessages?.length) return false;
-		if (action === "resumed" && promptState.precomputedStaleBindingContinuityProjectionApplied) return true;
-		if (action === "started" && promptState.staleBindingContinuityForcedFreshStart) return true;
-		if (action === "started" && promptState.inactiveThreadBootstrapBindingForcedFreshStart) return false;
+		if (activeContextEngine) return false;
+		if (params.continuation) {
+			await applyContinuityProjection(action === "started" ? historyState.messages : []);
+			return true;
+		}
+		if (!hasContinuity && !params.pluginRuntimeRefreshMessages?.length) return false;
+		if (action === "resumed" && precomputedStaleBindingContinuityProjectionApplied) return true;
+		if (action === "started" && staleBindingContinuityForcedFreshStart) return true;
+		if (action === "started" && inactiveThreadBootstrapBindingForcedFreshStart) return false;
 		if (action === "resumed" && binding) return applyResumeStaleBindingContinuityProjection(binding);
 		if (action === "started") {
 			await applyContinuityProjection(historyState.messages);
@@ -5360,7 +5538,8 @@ async function prepareCodexAttemptPrompt(context) {
 		}
 		return false;
 	};
-	if (await precomputeNoContextEngineStaleBindingProjection()) await rebuildCodexPromptBuildFromCurrentProjection();
+	const precomputedStaleBindingContinuityProjectionApplied = await precomputeNoContextEngineStaleBindingProjection();
+	if (precomputedStaleBindingContinuityProjectionApplied) await rebuildCodexPromptBuildFromCurrentProjection();
 	const rotateStartupBindingForProjectedTurn = async () => {
 		const binding = mutable.startupBinding;
 		if (!binding?.threadId) return;
@@ -5385,9 +5564,9 @@ async function prepareCodexAttemptPrompt(context) {
 		mutable.startupBinding = startupBindingResolution.binding;
 		mutable.startupContextTokens = startupBindingResolution.startupContextTokens;
 		if (mutable.startupBinding?.threadId) return;
-		promptState.inactiveThreadBootstrapBindingForcedFreshStart = hadInactiveThreadBootstrapBinding;
-		promptState.staleBindingContinuityForcedFreshStart = promptState.precomputedStaleBindingContinuityProjectionApplied && !promptState.inactiveThreadBootstrapBindingForcedFreshStart;
-		if (promptState.staleBindingContinuityForcedFreshStart) await applyContinuityProjection(historyState.messages);
+		inactiveThreadBootstrapBindingForcedFreshStart = hadInactiveThreadBootstrapBinding;
+		staleBindingContinuityForcedFreshStart = precomputedStaleBindingContinuityProjectionApplied && !inactiveThreadBootstrapBindingForcedFreshStart;
+		if (staleBindingContinuityForcedFreshStart) await applyContinuityProjection(historyState.messages);
 		if (activeContextEngine) {
 			promptState.contextEngineProjection = void 0;
 			await applyActiveContextEngineProjection(void 0);
@@ -5434,7 +5613,7 @@ async function prepareCodexAttemptPrompt(context) {
 			Object.assign(systemPromptReport, buildSystemPromptReport(!workspaceReferencesIncluded));
 		},
 		buildRenderedCodexDeveloperInstructions,
-		rebuildCodexTurnPromptTextFromCurrentProjection,
+		rebuildCodexTurnPromptTextFromCurrentProjection: () => rebuildCodexPromptBuildFromCurrentProjection(true),
 		applyNoContextEngineContinuityProjection,
 		systemPromptReport
 	};
@@ -5462,28 +5641,22 @@ function createNativeSubagentAssignmentStore(params) {
 		const binding = bindingStore.read(identity);
 		if (!binding || !matchesCodexNativeSubagentSubmissionBinding(binding, owner)) throw new Error("Native assignment binding is no longer current.");
 	};
+	const mutate = (kind) => (assignment, assertSourceCurrent) => bindingStore.mutate(identity, {
+		kind,
+		owner,
+		assignment
+	}, () => {
+		assertCurrent();
+		assertSourceCurrent();
+	});
 	return {
 		assertCurrent,
 		read: () => {
 			assertCurrent();
 			return bindingStore.readNativeSubagentAssignments?.(identity, owner) ?? [];
 		},
-		record: (assignment, assertSourceCurrent) => bindingStore.mutate(identity, {
-			kind: "record-native-subagent-assignment",
-			owner,
-			assignment
-		}, () => {
-			assertCurrent();
-			assertSourceCurrent();
-		}),
-		consume: (assignment, assertSourceCurrent) => bindingStore.mutate(identity, {
-			kind: "consume-native-subagent-assignment",
-			owner,
-			assignment
-		}, () => {
-			assertCurrent();
-			assertSourceCurrent();
-		})
+		record: mutate("record-native-subagent-assignment"),
+		consume: mutate("consume-native-subagent-assignment")
 	};
 }
 //#endregion
@@ -5596,14 +5769,8 @@ function prepareCodexAttemptResources(prompt) {
 		releaseSharedClientLeaseOnce();
 		await retireSharedCodexClientForOneShotCleanup();
 	};
-	const runCleanupStep = (step, operation) => runAgentCleanupStep({
-		runId: params.runId,
-		sessionId: params.sessionId,
-		step,
-		log: embeddedAgentLog,
-		cleanup: async () => {
-			await operation();
-		}
+	const runCleanupStep = (step, operation) => runCodexCleanupStep(params, step, async () => {
+		await operation();
 	});
 	let nativeSubagentMonitorSettlement;
 	let nativeSubagentMonitorGeneration = 0;
@@ -5621,13 +5788,14 @@ function prepareCodexAttemptResources(prompt) {
 		const generation = ++nativeSubagentMonitorGeneration;
 		const sessionKey = params.sessionKey;
 		const storePath = params.sessionTarget?.storePath;
-		const parentSession = sessionKey && storePath ? getSessionEntry({
+		const readParentSession = () => sessionKey && storePath ? getSessionEntry({
 			agentId: sessionAgentId,
 			sessionKey,
 			storePath,
 			readConsistency: "latest",
 			hydrateSkillPromptRefs: false
 		}) : void 0;
+		const parentSession = readParentSession();
 		const historyOwner = createCodexNativeSubagentHistoryOwner({
 			parentThreadId,
 			sessionId: params.sessionId,
@@ -5637,13 +5805,7 @@ function prepareCodexAttemptResources(prompt) {
 		const { bindingStore, bindingIdentity } = connection;
 		const assertParentSessionCurrent = () => {
 			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.");
+				if (readParentSession()?.lifecycleRevision !== historyOwner.lifecycleRevision) throw new Error("Native submission session lifecycle is no longer current.");
 			}
 		};
 		const submissionStore = historyOwner && thread.lifecycle.preserveExistingBinding !== true ? {
@@ -5832,11 +5994,11 @@ function prepareCodexAttemptResources(prompt) {
 	};
 	const startupTimeoutMs = resolveCodexStartupTimeoutMs({
 		timeoutMs: params.timeoutMs,
+		requestTimeoutMs: appServer.requestTimeoutMs,
 		timeoutFloorMs: options.startupTimeoutFloorMs
 	});
-	const requesterChannel = params.messageChannel ?? params.messageProvider;
 	const requester = buildCodexHookRequester(params);
-	const buildNativeHookRelayFinalConfigPatch = async (decision) => {
+	const buildNativeHookRelayFinalConfigPatch = async (decision, relayClient) => {
 		state.nativeSpawnAdmissionInstalled = false;
 		const previousRelay = state.nativeHookRelay;
 		previousRelay?.unregister();
@@ -5873,7 +6035,7 @@ function prepareCodexAttemptResources(prompt) {
 			approvalContext: {
 				trigger: params.trigger,
 				approvalReviewerDeviceId: params.approvalReviewerDeviceId,
-				turnSourceChannel: requesterChannel,
+				turnSourceChannel: params.messageChannel ?? params.messageProvider,
 				turnSourceTo: params.currentMessagingTarget ?? params.currentChannelId,
 				turnSourceAccountId: params.agentAccountId,
 				turnSourceThreadId: params.currentThreadTs
@@ -5894,6 +6056,12 @@ function prepareCodexAttemptResources(prompt) {
 				tools: decision.nativeModelInputTools,
 				readQualification: (threadId) => getCodexInferenceThreadQualification(state.client, threadId)
 			} : void 0,
+			remoteCallback: appServer.nativeHookRelay && {
+				config: appServer.nativeHookRelay,
+				client: relayClient,
+				timeoutMs: appServer.requestTimeoutMs,
+				onCleanupFailure: (error) => reportCodexBackgroundCleanupFailure(params, error)
+			},
 			assertCurrent: connection.assertLegacyCurrent,
 			onPreToolUseFailure: (failure) => {
 				const projector = projectorRef.current;
@@ -5929,9 +6097,6 @@ function prepareCodexAttemptResources(prompt) {
 		nativeModelAdmission,
 		nativeProcessAuthority,
 		releaseNativeProcessAuthority,
-		markTrajectoryEndRecorded: () => {
-			state.trajectoryEndRecorded = true;
-		},
 		releaseSharedClientLeaseAndRetireOneShotClient,
 		releaseSandboxExecEnvironment,
 		runCleanupStep,
@@ -5953,32 +6118,6 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 	const { runAbortController } = connection;
 	const { state, turnIdRef, completeTurn } = turnRuntime;
 	const { noteNotificationReceived, enqueueNotification } = notifications;
-	const attachRouteAbort = (route) => {
-		const onAbort = () => {
-			if (state.completed || state.terminalTurnNotificationQueued || runAbortController.signal.aborted) return;
-			const reasonText = formatErrorMessage(route.signal.reason);
-			const closedClient = reasonText.includes("turn router closed");
-			const closeCause = route.signal.reason instanceof Error && route.signal.reason.cause instanceof Error ? route.signal.reason.cause : void 0;
-			state.clientClosedPromptError = closedClient ? "codex app-server client closed before turn completed" : `codex app-server turn route closed before turn completed: ${reasonText}`;
-			state.clientClosedDiagnostic = closedClient && closeCause ? formatErrorMessage(closeCause) : void 0;
-			state.clientClosedAbort = closedClient;
-			const activeTurnId = turnIdRef.current;
-			if (activeTurnId) trajectoryRecorder?.recordEvent("turn.client_closed", {
-				threadId: resourceState.thread.threadId,
-				turnId: activeTurnId
-			});
-			embeddedAgentLog.warn(state.clientClosedPromptError, {
-				threadId: resourceState.thread.threadId,
-				turnId: activeTurnId,
-				...state.clientClosedDiagnostic ? { transportError: state.clientClosedDiagnostic } : {}
-			});
-			runAbortController.abort(closedClient ? "client_closed" : "turn_route_closed");
-			completeTurn();
-		};
-		route.signal.addEventListener("abort", onAbort, { once: true });
-		if (route.signal.aborted) onAbort();
-		return () => route.signal.removeEventListener("abort", onAbort);
-	};
 	const ensureCurrentThreadRoute = async () => {
 		if (resourceState.turnRoute?.threadId !== resourceState.thread.threadId) {
 			await releaseCurrentRoute();
@@ -5986,7 +6125,31 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 		}
 		if (!resourceState.routeActivated) {
 			if (!resourceState.nativeSubagentMonitor) await registerNativeSubagentMonitor(resourceState.thread.threadId);
-			resourceState.detachRouteAbort = attachRouteAbort(resourceState.turnRoute);
+			const route = resourceState.turnRoute;
+			const onAbort = () => {
+				if (state.completed || state.terminalTurnNotificationQueued || runAbortController.signal.aborted) return;
+				const reasonText = formatErrorMessage(route.signal.reason);
+				const closedClient = reasonText.includes("turn router closed");
+				const closeCause = route.signal.reason instanceof Error && route.signal.reason.cause instanceof Error ? route.signal.reason.cause : void 0;
+				state.clientClosedPromptError = closedClient ? "codex app-server client closed before turn completed" : `codex app-server turn route closed before turn completed: ${reasonText}`;
+				state.clientClosedDiagnostic = closedClient && closeCause ? formatErrorMessage(closeCause) : void 0;
+				state.clientClosedAbort = closedClient;
+				const activeTurnId = turnIdRef.current;
+				if (activeTurnId) trajectoryRecorder?.recordEvent("turn.client_closed", {
+					threadId: resourceState.thread.threadId,
+					turnId: activeTurnId
+				});
+				embeddedAgentLog.warn(state.clientClosedPromptError, {
+					threadId: resourceState.thread.threadId,
+					turnId: activeTurnId,
+					...state.clientClosedDiagnostic ? { transportError: state.clientClosedDiagnostic } : {}
+				});
+				runAbortController.abort(closedClient ? "client_closed" : "turn_route_closed");
+				completeTurn();
+			};
+			route.signal.addEventListener("abort", onAbort, { once: true });
+			if (route.signal.aborted) onAbort();
+			resourceState.detachRouteAbort = () => route.signal.removeEventListener("abort", onAbort);
 			await resourceState.turnRoute.activate({
 				onNotificationReceived: noteNotificationReceived,
 				onNotification: enqueueNotification,
@@ -6000,29 +6163,6 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 	return { ensureCurrentThreadRoute };
 }
 //#endregion
-//#region extensions/codex/src/app-server/run-attempt-client-prewarm.ts
-/** Starts the shared process while tools and prompt context are still being prepared. */
-function prewarmCodexAttemptClient(params) {
-	const { connection, authProfileStore, authBindingFingerprint } = params;
-	const { appServer, attemptClientFactory, options, pluginConfig, runtimeArtifactRequest, startupAuthRequirement, startupClientAuthProfileId, startupPreparedAuth, agentDir, params: runParams, runAbortController } = connection;
-	if (options.clientFactory || attemptClientFactory !== getLeasedSharedCodexAppServerClient || runtimeArtifactRequest) return;
-	getSharedCodexAppServerClient({
-		assertCurrent: connection.assertLegacyCurrent,
-		startOptions: appServer.start,
-		pluginConfig,
-		...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
-		authRequirement: startupAuthRequirement,
-		authProfileStore,
-		authBindingFingerprint,
-		agentDir,
-		config: runParams.config,
-		timeoutMs: appServer.requestTimeoutMs,
-		abandonSignal: runAbortController.signal
-	}).catch((error) => {
-		embeddedAgentLog.debug("codex app-server client prewarm failed", { error });
-	});
-}
-//#endregion
 //#region extensions/codex/src/app-server/scheduled-configured-mcp-authority.ts
 /** Limits fresh scheduled-authority capture to authenticated local durable operator turns. */
 function canResolveScheduledConfiguredMcpCreatorAuthority(params) {
@@ -6040,10 +6180,27 @@ async function prepareCodexAttemptRuntime(connection) {
 	}) : void 0;
 	assertScheduledCodexAppAuthorityRuntime(connection, params);
 	const attemptAuthProfileStore = preparedAuthBinding?.authProfileStore ?? params.authProfileStore;
-	prewarmCodexAttemptClient({
-		connection,
+	const clientOptions = {
+		startOptions: appServer.start,
+		pluginConfig,
+		...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
+		authRequirement: connection.startupAuthRequirement,
 		authProfileStore: attemptAuthProfileStore,
-		authBindingFingerprint: preparedAuthBinding?.fingerprint
+		authBindingFingerprint: preparedAuthBinding?.fingerprint,
+		...connection.runtimeArtifactRequest ? {
+			runtimeArtifactMode: "capture",
+			...connection.runtimeArtifactRequest.expected ? { expectedRuntimeArtifact: connection.runtimeArtifactRequest.expected } : {}
+		} : {},
+		agentDir,
+		config: params.config,
+		abandonSignal: runAbortController.signal,
+		timeoutMs: appServer.requestTimeoutMs
+	};
+	if (!connection.options.clientFactory && attemptClientFactory === getLeasedSharedCodexAppServerClient && !connection.runtimeArtifactRequest) getSharedCodexAppServerClient({
+		...clientOptions,
+		assertCurrent: connection.assertLegacyCurrent
+	}).catch((error) => {
+		embeddedAgentLog.debug("codex app-server client prewarm failed", { error });
 	});
 	const effectiveContextWindowInfo = usesSupervisionConnection ? void 0 : params.contextWindowInfo;
 	const effectiveContextTokenBudget = usesSupervisionConnection ? void 0 : params.contextTokenBudget;
@@ -6088,7 +6245,7 @@ async function prepareCodexAttemptRuntime(connection) {
 		agentDir,
 		config: params.config
 	});
-	const startupEnvApiKeyCacheKey = usesSupervisionConnection ? void 0 : startupPreparedAuth || startupAuthProfileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start });
+	const startupEnvApiKeyCacheKey = usesSupervisionConnection || startupPreparedAuth || startupAuthProfileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start });
 	preDynamicStartupStages.mark("auth-cache");
 	const codexMcpToolOverrides = resolveCodexMcpToolOverridesForAgent(params.config, {
 		agentId: sessionAgentId,
@@ -6136,22 +6293,9 @@ async function prepareCodexAttemptRuntime(connection) {
 	});
 	if (nativeToolSurfaceEnabled && sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority) {
 		const client = await attemptClientFactory({
+			...clientOptions,
 			assertCurrent: connection.assertCurrent,
-			startOptions: appServer.start,
-			pluginConfig,
-			...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
-			authRequirement: connection.startupAuthRequirement,
-			authProfileStore: attemptAuthProfileStore,
-			authBindingFingerprint: preparedAuthBinding?.fingerprint,
-			...connection.runtimeArtifactRequest ? {
-				runtimeArtifactMode: "capture",
-				...connection.runtimeArtifactRequest.expected ? { expectedRuntimeArtifact: connection.runtimeArtifactRequest.expected } : {}
-			} : {},
-			agentId: sessionAgentId,
-			agentDir,
-			config: params.config,
-			abandonSignal: runAbortController.signal,
-			timeoutMs: appServer.requestTimeoutMs
+			agentId: sessionAgentId
 		});
 		try {
 			connection.assertCurrent();
@@ -6210,6 +6354,7 @@ async function prepareCodexAttemptRuntime(connection) {
 	preDynamicStartupStages.mark("context-engine-support");
 	return {
 		connection,
+		clientOptions,
 		preparedAuthBinding,
 		runtimeParams,
 		effectiveContextWindowInfo,
@@ -6269,27 +6414,18 @@ function toTranscriptToolResultContentItem(item) {
 		type: "text",
 		text: typeof record.text === "string" ? record.text : ""
 	};
-	if (record.type === "inputImage") return typeof record.imageUrl === "string" ? {
+	if (record.type === "inputImage" && typeof record.imageUrl === "string") return {
 		type: "image",
 		url: record.imageUrl
-	} : {
-		type: "text",
-		text: formatUnsupportedCodexDynamicToolOutput(record.type)
 	};
+	const rawType = typeof record.type === "string" ? record.type.replace(/\s+/g, " ").trim() : "";
 	return {
 		type: "text",
-		text: formatUnsupportedCodexDynamicToolOutput(record.type)
+		text: `[Unsupported Codex dynamic tool output: ${rawType ? truncateUtf16Safe(rawType, 80) : "unknown"}${rawType.length > 80 ? "..." : ""}]`
 	};
 }
-function formatUnsupportedCodexDynamicToolOutput(type) {
-	const rawType = typeof type === "string" ? type.replace(/\s+/g, " ").trim() : "";
-	return `[Unsupported Codex dynamic tool output: ${rawType ? truncateUtf16Safe(rawType, 80) : "unknown"}${rawType.length > 80 ? "..." : ""}]`;
-}
 function resolveCodexDynamicToolDirectNames(params, registeredTools, hostSystemAgentActive = false) {
-	const names = [];
-	if (hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow)) names.push("openclaw");
-	if (registeredTools.some((tool) => tool.name === "message")) names.push("message");
-	return names;
+	return [...hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow) ? ["openclaw"] : [], ...registeredTools.some((tool) => tool.name === "message") ? ["message"] : []];
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-server-requests.ts
@@ -6307,7 +6443,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 	const autoApprove = shouldAutoApproveCodexAppServerApprovals(appServer);
 	const { compactionPlanState, toolBridge, toolOutcomeOrdinals, suppressedDynamicToolOutcomeOrdinals, allocateCodexToolOutcomeOrdinal } = attemptTools;
 	const { state, turnIdRef, userInputBridgeRef, openClawDynamicToolExecutions, pendingOpenClawDynamicToolCompletionIds, noteProgress } = turnRuntime;
-	const { emitExecutionPhaseOnce, scheduleTurnReleaseAfterTerminalDynamicTool, scheduleTerminalDynamicToolReleaseCheck } = lifecycle;
+	const { emitExecutionPhaseOnce, recordDynamicToolResult, scheduleTerminalDynamicToolReleaseCheck } = lifecycle;
 	let refreshDrain;
 	let refreshStopping = false;
 	const settlePluginRuntimeRefresh = async (turnId) => {
@@ -6441,24 +6577,21 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			});
 			setExecutionTimeoutMs?.(dynamicToolTimeoutMs);
 			const toolStartedAt = Date.now();
-			const diagnosticContext = {
+			const diagnostics = createCodexDynamicToolDiagnostics({
 				call,
 				agentId: sessionAgentId,
 				runId: params.runId,
 				sessionId: params.sessionId,
 				sessionKey: params.sessionKey
-			};
+			});
 			let terminalDiagnosticObserved = false;
 			const unsubscribeToolDiagnosticObserver = onInternalDiagnosticEvent((event) => {
-				if (isDynamicToolTerminalDiagnosticEvent(event) && isMatchingDynamicToolTerminalDiagnostic({
-					...diagnosticContext,
-					event
-				})) terminalDiagnosticObserved = true;
+				if (diagnostics.matchesTerminal(event)) terminalDiagnosticObserved = true;
 			}, { include: DYNAMIC_TOOL_TERMINAL_DIAGNOSTIC_TYPES });
 			try {
 				const { execution } = openClawDynamicToolExecutions.claim(call, async () => {
 					await projector?.transcriptCheckpoint.flush();
-					emitDynamicToolStartedDiagnostic(diagnosticContext);
+					diagnostics.started();
 					const response = await handleDynamicToolCallWithTimeout({
 						call,
 						toolBridge,
@@ -6540,30 +6673,18 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						data: activity
 					});
 				}
-				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic(diagnosticContext)) emitDynamicToolTerminalDiagnostic({
-					...diagnosticContext,
-					response,
-					durationMs: toolDurationMs
-				});
+				if (!terminalDiagnosticObserved && !diagnostics.hasPendingTerminal()) diagnostics.terminal(response, toolDurationMs);
 				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
 				if (params.pluginRuntimeRefreshPending?.()) await settlePluginRuntimeRefresh(turnId);
-				else if (response.terminate === true && response.success) scheduleTurnReleaseAfterTerminalDynamicTool({
+				else recordDynamicToolResult({
 					call,
 					response,
 					durationMs: toolDurationMs
 				});
-				else if (response.asyncStarted === true) scheduleTerminalDynamicToolReleaseCheck();
-				else {
-					state.currentTurnHadNonTerminalDynamicToolResult = true;
-					state.pendingTerminalDynamicToolRelease = void 0;
-				}
 				return protocolResponse;
 			} catch (error) {
 				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
-				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic(diagnosticContext)) emitDynamicToolErrorDiagnostic({
-					...diagnosticContext,
-					durationMs: Math.max(0, Date.now() - toolStartedAt)
-				});
+				if (!terminalDiagnosticObserved && !diagnostics.hasPendingTerminal()) diagnostics.error(Math.max(0, Date.now() - toolStartedAt));
 				await settlePluginRuntimeRefresh(turnId);
 				throw error;
 			} finally {
@@ -6584,7 +6705,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-CUTOOnKw.mjs");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-C13pR7tD.mjs");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6601,7 +6722,7 @@ function startCodexComputerUseHealthMonitor(params) {
 	const state = getComputerUseHealthMonitorState();
 	const existing = state.monitors.get(params.client);
 	if (!params.config.enabled || !params.config.healthCheckEnabled) {
-		if (existing) clearComputerUseHealthMonitor(params.client, existing);
+		clearComputerUseHealthMonitor(params.client, existing);
 		return {
 			started: false,
 			reason: params.config.enabled ? "health_disabled" : "disabled"
@@ -6621,7 +6742,7 @@ function startCodexComputerUseHealthMonitor(params) {
 		intervalMs,
 		reason: "already_started"
 	};
-	if (existing) clearComputerUseHealthMonitor(params.client, existing);
+	clearComputerUseHealthMonitor(params.client, existing);
 	const monitor = {
 		fingerprint,
 		timer: setInterval(() => {
@@ -6632,8 +6753,7 @@ function startCodexComputerUseHealthMonitor(params) {
 	};
 	monitor.timer.unref?.();
 	monitor.disposeCloseHandler = params.client.addCloseHandler((client) => {
-		const active = state.monitors.get(client);
-		if (active) clearComputerUseHealthMonitor(client, active);
+		clearComputerUseHealthMonitor(client, state.monitors.get(client));
 	});
 	state.monitors.set(params.client, monitor);
 	return {
@@ -6666,7 +6786,7 @@ async function runCodexComputerUseHealthProbe(client, config, monitor, tools) {
 		}
 		if (repair?.attempted && repair.warnings.length === 0) embeddedAgentLog.info("codex computer-use periodic health reloaded MCP servers", { mcpServerName: config.mcpServerName });
 	} catch (error) {
-		embeddedAgentLog.warn("codex computer-use periodic health probe crashed", {
+		embeddedAgentLog.warn("codex computer-use periodic health check crashed", {
 			mcpServerName: config.mcpServerName,
 			error: error instanceof Error ? error.message : String(error)
 		});
@@ -6675,6 +6795,7 @@ async function runCodexComputerUseHealthProbe(client, config, monitor, tools) {
 	}
 }
 function clearComputerUseHealthMonitor(client, monitor) {
+	if (!monitor) return;
 	clearInterval(monitor.timer);
 	monitor.disposeCloseHandler();
 	getComputerUseHealthMonitorState().monitors.delete(client);
@@ -6688,8 +6809,8 @@ const CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS = 3;
 */
 async function startCodexAttemptThread(params) {
 	let pluginAppServer = params.appServer;
-	const startupRuntimeAuthProfileId = params.startupPreparedAuth?.kind === "profile" ? params.startupPreparedAuth.profileId : params.startupAuthProfileId ?? void 0;
-	const startupRuntimeAuthProfileStore = params.startupPreparedAuth?.kind === "profile" ? params.startupPreparedAuth.store : void 0;
+	const startupRuntimeAuthProfileId = params.clientOptions.preparedAuth?.kind === "profile" ? params.clientOptions.preparedAuth.profileId : params.clientOptions.authProfileId ?? void 0;
+	const startupRuntimeAuthProfileStore = params.clientOptions.preparedAuth?.kind === "profile" ? params.clientOptions.preparedAuth.store : void 0;
 	let releaseSharedClientLease;
 	let startupClientForAbandonedRequestCleanup;
 	let releaseStartupResourcesOnTimeout;
@@ -6711,12 +6832,13 @@ async function startCodexAttemptThread(params) {
 			},
 			operation: async () => {
 				const threadConfig = mergeCodexThreadConfigs(params.configuredMcpDynamicSurface ? void 0 : params.bundleMcpThreadConfig?.configPatch);
-				const { pluginThreadConfigRequired, pluginThreadConfigPluginConfig, resolvedPluginPolicy, enabledPluginConfigKeys } = resolveCodexPluginThreadConfigStartupPolicy({
+				const pluginStartupPolicy = resolveCodexPluginThreadConfigStartupPolicy({
 					pluginConfig: params.pluginConfig,
 					nativeToolSurfaceEnabled: params.nativeToolSurfaceEnabled,
-					hostedAppsSupported: !isCodexResponsesOAuth(params.startupPreparedAuth),
+					hostedAppsSupported: !isCodexResponsesOAuth(params.clientOptions.preparedAuth),
 					scheduledRuntimeAuthority: params.buildAttemptParams().scheduledRuntimeAuthority
 				});
+				const { pluginThreadConfigRequired, resolvedPluginPolicy, enabledPluginConfigKeys } = pluginStartupPolicy;
 				pluginAppServer = resolvedPluginPolicy?.enabled === true || params.computerUseConfig.enabled || params.nativeToolSurfaceEnabled && params.configuredMcpOwnershipVersion !== 1 && hasCodexMcpToolApprovalOverrides(params.config?.mcp?.servers, params.bundleMcpThreadConfig.userStaticServerNames, params.bundleMcpThreadConfig.configPatch?.mcp_servers) ? {
 					...params.appServer,
 					approvalPolicy: withMcpElicitationsApprovalPolicy(params.appServer.approvalPolicy)
@@ -6732,20 +6854,14 @@ async function startCodexAttemptThread(params) {
 						params.assertCurrent?.();
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
 						startupClient = await params.attemptClientFactory({
+							...params.clientOptions,
 							assertCurrent: () => {
 								params.assertCurrent?.();
 								params.authority?.assertLegacyCurrent();
 							},
 							startOptions: params.appServer.start,
 							pluginConfig: params.pluginConfig,
-							...params.startupPreparedAuth ? { preparedAuth: params.startupPreparedAuth } : { authProfileId: params.startupAuthProfileId },
-							authRequirement: params.startupAuthRequirement,
 							authProfileStore: attemptParams.authProfileStore,
-							authBindingFingerprint: params.startupAuthBindingFingerprint,
-							...params.runtimeArtifactRequest ? {
-								runtimeArtifactMode: "capture",
-								...params.runtimeArtifactRequest.expected ? { expectedRuntimeArtifact: params.runtimeArtifactRequest.expected } : {}
-							} : {},
 							agentId: params.sessionAgentId,
 							agentDir: params.agentDir,
 							config: params.config,
@@ -6778,7 +6894,7 @@ async function startCodexAttemptThread(params) {
 						ensureCodexAppServerClientRuntime(activeStartupClient, {
 							agentDir: params.agentDir,
 							authProfileId: startupRuntimeAuthProfileId,
-							authMode: params.startupPreparedAuth?.kind === "api-key" || isCodexResponsesOAuth(params.startupPreparedAuth) ? "prepared-api-key" : "profile",
+							authMode: params.clientOptions.preparedAuth?.kind === "api-key" || isCodexResponsesOAuth(params.clientOptions.preparedAuth) ? "prepared-api-key" : "profile",
 							authProfileStore: startupRuntimeAuthProfileStore ?? attemptParams.authProfileStore,
 							config: params.config
 						});
@@ -6823,11 +6939,11 @@ async function startCodexAttemptThread(params) {
 							appServerVersion: activeStartupClient.getServerVersion(),
 							runtimeIdentity: startupRuntimeIdentity
 						});
-						const basePluginThreadConfigInputFingerprint = pluginThreadConfigRequired ? buildCodexPluginThreadConfigInputFingerprint({
-							pluginConfig: pluginThreadConfigPluginConfig,
-							appCacheKey: pluginAppCacheKey
-						}) : void 0;
-						const pluginThreadConfigInputFingerprint = basePluginThreadConfigInputFingerprint ? buildScheduledCodexAppAuthorityInputFingerprint(basePluginThreadConfigInputFingerprint, attemptParams.scheduledRuntimeAuthority) : void 0;
+						const createPluginThreadConfig = prepareCodexPluginThreadConfigStartupProvider({
+							startupPolicy: pluginStartupPolicy,
+							appCacheKey: pluginAppCacheKey,
+							scheduledRuntimeAuthority: attemptParams.scheduledRuntimeAuthority
+						});
 						embeddedAgentLog.debug("codex plugin thread config eligibility", buildCodexPluginThreadConfigEligibilityLogData({
 							sessionId: attemptParams.sessionId,
 							sessionKey: attemptParams.sessionKey ?? "",
@@ -6919,10 +7035,9 @@ async function startCodexAttemptThread(params) {
 							config: threadConfig,
 							shellEnvironment: params.shellEnvironment,
 							shellPathPrepend: params.shellPathPrepend,
+							shellGitConfigParameters: params.shellGitConfigParameters,
 							disableLoginShell: params.disableLoginShell,
-							finalConfigPatch: params.finalConfigPatch,
 							buildFinalConfigPatch: params.buildFinalConfigPatch,
-							nativeHookRelayGeneration: params.nativeHookRelayGeneration,
 							nativeHookRelayRequired: params.nativeHookRelayRequired,
 							nativeModelAdmission: params.nativeModelAdmission,
 							nativeCodeModeEnabled: params.nativeToolSurfaceEnabled,
@@ -6936,18 +7051,13 @@ async function startCodexAttemptThread(params) {
 							appServerRuntimeFingerprint,
 							contextEngineProjection: params.contextEngineProjection,
 							signal,
-							pluginThreadConfig: pluginThreadConfigRequired ? createCodexPluginThreadConfigStartupProvider({
-								inputFingerprint: pluginThreadConfigInputFingerprint,
-								enabledPluginConfigKeys,
-								policy: resolvedPluginPolicy,
+							pluginThreadConfig: createPluginThreadConfig?.({
 								requestTimeoutMs: params.appServer.requestTimeoutMs,
 								signal,
-								pluginConfig: pluginThreadConfigPluginConfig,
 								client: activeStartupClient,
 								configCwd: startupExecutionCwd,
-								appCacheKey: pluginAppCacheKey,
 								scheduledRuntimeAuthority: attemptParams.scheduledRuntimeAuthority
-							}) : void 0
+							})
 						});
 						try {
 							const startupThread = await startOrResumeThread(buildThreadLifecycleParams(startupAbandonController.signal, reserveStartupThread));
@@ -7077,10 +7187,10 @@ async function startCodexAttemptRuntime(resources) {
 	const { prompt, state, trajectoryRecorder, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
 	const { context, turnState, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
 	const { runtime, attemptTools, promptState } = context;
-	const { connection, runtimeParams, preparedAuthBinding, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
+	const { connection, runtimeParams, clientOptions, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
 	const { toolBridge, toolState } = attemptTools;
 	const developerInstructions = joinPresentSections(turnState.promptBuild.developerInstructions, attemptTools.configuredMcp?.diagnosticNotice);
-	const { params, attemptClientFactory, bindingStore, appServer, pluginConfig, computerUseConfig, startupClientAuthProfileId, runtimeArtifactRequest, startupPreparedAuth, agentDir, sessionAgentId, effectiveWorkspace, effectiveCwd, sandbox, runAbortController, usesSupervisionConnection, resolveReviewerPolicyContext, resolveRuntimeOptionsForCurrentBinding, startupAuthProfileId, startupAuthRequirement } = connection;
+	const { params, attemptClientFactory, bindingStore, appServer, pluginConfig, computerUseConfig, runtimeArtifactRequest, agentDir, sessionAgentId, effectiveWorkspace, effectiveCwd, sandbox, runAbortController, usesSupervisionConnection, resolveReviewerPolicyContext, resolveRuntimeOptionsForCurrentBinding, startupAuthProfileId } = connection;
 	let pluginAppServer = withCodexAppServerFastModeServiceTier(appServer, runtimeParams);
 	const loopDetectionEnabled = (sessionAgentId && params.config ? resolveAgentConfig(params.config, sessionAgentId)?.tools?.loopDetection?.enabled : void 0) ?? params.config?.tools?.loopDetection?.enabled ?? false;
 	try {
@@ -7097,17 +7207,15 @@ async function startCodexAttemptRuntime(resources) {
 			appServer: pluginAppServer,
 			pluginConfig,
 			computerUseConfig,
-			startupAuthProfileId: startupClientAuthProfileId,
-			startupAuthRequirement,
-			startupAuthBindingFingerprint: preparedAuthBinding?.fingerprint,
+			clientOptions,
 			...runtimeArtifactRequest ? { runtimeArtifactRequest } : {},
-			startupPreparedAuth,
 			startupAuthAccountCacheKey,
 			startupEnvApiKeyCacheKey,
 			agentDir,
 			config: params.config,
 			shellEnvironment: connection.shellEnvironment,
 			shellPathPrepend: connection.shellPathPrepend,
+			shellGitConfigParameters: connection.shellGitConfigParameters,
 			disableLoginShell: connection.disableLoginShell,
 			buildAttemptParams: () => ({ ...runtimeParams }),
 			...effectiveRuntimeModelId !== runtimeParams.modelId ? { runtimeModelId: effectiveRuntimeModelId } : {},
@@ -7155,10 +7263,7 @@ 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 = await resolveRuntimeOptionsForCurrentBinding({
-				modelProvider: activePolicy.modelProvider,
-				model: activePolicy.model
-			});
+			const activeConfig = await resolveRuntimeOptionsForCurrentBinding(activePolicy);
 			connection.assertCurrent();
 			const activeAppServer = resolveCodexAppServerForModelProvider({
 				appServer: activeConfig,
@@ -7215,10 +7320,11 @@ function resolveInactiveCodexHeartbeatResponseDescriptor(params) {
 		description: descriptor.description
 	} : void 0;
 }
-/** Keeps the thread-stable heartbeat endpoint executable on ordinary Codex turns. */
-function createInactiveCodexHeartbeatResponseTool(descriptor) {
+function selectInactiveCodexHeartbeatResponseTool(params) {
+	if (params.disableTools) return;
+	const descriptor = params.descriptor;
 	if (descriptor.name !== HEARTBEAT_RESPONSE_TOOL_NAME) throw new Error(`Expected ${HEARTBEAT_RESPONSE_TOOL_NAME}, received ${descriptor.name}`);
-	return {
+	const tool = {
 		name: descriptor.name,
 		label: descriptor.name,
 		description: descriptor.description,
@@ -7239,10 +7345,7 @@ function createInactiveCodexHeartbeatResponseTool(descriptor) {
 			};
 		}
 	};
-}
-function selectInactiveCodexHeartbeatResponseTool(params) {
-	if (params.disableTools) return;
-	const allowed = applyEmbeddedAttemptToolsAllow([createInactiveCodexHeartbeatResponseTool(params.descriptor)], params.toolsAllow);
+	const allowed = applyEmbeddedAttemptToolsAllow([tool], params.toolsAllow);
 	return filterCodexDynamicTools(allowed, params.pluginConfig)[0];
 }
 //#endregion
@@ -7394,23 +7497,11 @@ async function prepareCodexAttemptTools(runtime) {
 	let scopedMcpTools;
 	let toolDisposal;
 	const disposeTools = (reason) => toolDisposal ??= (async () => {
-		await runAgentCleanupStep({
-			runId: params.runId,
-			sessionId: params.sessionId,
-			step: "codex-dynamic-tool-cleanup",
-			log: embeddedAgentLog,
-			cleanup: async () => {
-				const errors = (await Promise.allSettled(runCleanups.splice(0).map(async (cleanup) => await cleanup(reason)))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-				if (params.oneShotCliRun && errors.length) throw new AggregateError(errors, "Codex tool cleanup failed");
-			}
-		});
-		for (const [step, materialized] of [["codex-scoped-mcp-dispose", scopedMcpTools], ["codex-configured-mcp-dispose", configuredMcp]]) await runAgentCleanupStep({
-			runId: params.runId,
-			sessionId: params.sessionId,
-			step,
-			log: embeddedAgentLog,
-			cleanup: async () => materialized?.dispose()
+		await runCodexCleanupStep(params, "codex-dynamic-tool-cleanup", async () => {
+			const errors = (await Promise.allSettled(runCleanups.splice(0).map(async (cleanup) => await cleanup(reason)))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+			if (params.oneShotCliRun && errors.length) throw new AggregateError(errors, "Codex tool cleanup failed");
 		});
+		for (const [step, materialized] of [["codex-scoped-mcp-dispose", scopedMcpTools], ["codex-configured-mcp-dispose", configuredMcp]]) await runCodexCleanupStep(params, step, async () => materialized?.dispose());
 	})();
 	try {
 		const tools = await buildDynamicTools({
@@ -7441,7 +7532,7 @@ async function prepareCodexAttemptTools(runtime) {
 			sessionId: params.sessionId,
 			runId: params.runId,
 			agentId: policyAgentId,
-			agentDir: agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId),
+			agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
 			agentAccountId: params.agentAccountId,
 			messageProvider: params.messageProvider ?? params.messageChannel,
 			messageChannel: params.messageChannel,
@@ -7695,14 +7786,12 @@ async function resolveCodexExplicitSkillInputs(params) {
 async function prepareCodexProviderReviewContinuation(params) {
 	const acknowledgment = params.acknowledgment;
 	if (!acknowledgment) return;
-	let nativeChanged = false;
-	let dispatched = false;
-	let dispose = () => {};
+	let state = "prepared";
 	const assertCurrent = () => {
 		params.signal.throwIfAborted();
 		params.assertCurrent();
 		acknowledgment.read();
-		if (nativeChanged) throw new Error("The native provider review changed before dispatch");
+		if (state === "changed") throw new Error("The native provider review changed before dispatch");
 	};
 	assertCurrent();
 	const snapshot = acknowledgment.read();
@@ -7718,16 +7807,16 @@ async function prepareCodexProviderReviewContinuation(params) {
 	assertCurrent();
 	const { review } = snapshot;
 	if (review.nativeThreadId !== params.turnStartParams.threadId || !review.review?.continuation) throw new Error("Provider review no longer matches the native thread");
-	dispose = params.client.addNotificationHandler((notification) => {
+	const dispose = params.client.addNotificationHandler((notification) => {
 		const event = notification.params;
 		if (!isJsonObject(event) || event.threadId !== review.nativeThreadId) return;
-		if (notification.method === "turn/started") nativeChanged = true;
+		if (notification.method === "turn/started") state = "changed";
 		else if (notification.method === "turn/completed" || notification.method === "error" && event.willRetry !== true) {
 			const turn = isJsonObject(event.turn) ? event.turn : void 0;
 			const turnId = turn?.id ?? event.turnId;
 			const error = isJsonObject(turn?.error) ? turn.error : isJsonObject(event.error) ? event.error : void 0;
 			const failure = readCodexProviderRefusal(typeof error?.message === "string" ? error.message : void 0, error?.codexErrorInfo, { misalignment: error?.misalignment });
-			if (turnId !== review.nativeTurnId || turn && turn.status !== "failed" || failure?.category !== "misalignment" || error?.misalignment != null && !isDeepStrictEqual(failure.review, review.review)) nativeChanged = true;
+			if (turnId !== review.nativeTurnId || turn && turn.status !== "failed" || failure?.category !== "misalignment" || error?.misalignment != null && !isDeepStrictEqual(failure.review, review.review)) state = "changed";
 		}
 	});
 	try {
@@ -7761,13 +7850,13 @@ async function prepareCodexProviderReviewContinuation(params) {
 			dispose,
 			dispatch: () => {
 				assertCurrent();
-				if (dispatched) throw new Error("Provider review continuation already dispatched");
-				dispatched = true;
+				if (state === "dispatched") throw new Error("Provider review continuation already dispatched");
+				state = "dispatched";
 				dispose();
 			},
 			accept: async (turnId) => {
 				assertCurrent();
-				if (!dispatched) throw new Error("Provider review continuation has not dispatched");
+				if (state !== "dispatched") throw new Error("Provider review continuation has not dispatched");
 				await acknowledgment.acceptNativeTurn({
 					nativeThreadId: params.turnStartParams.threadId,
 					nativeTurnId: turnId,
@@ -7861,14 +7950,6 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			embeddedAgentLog.debug("codex app-server model call diagnostic ended with error", { error: formatErrorMessage(error) });
 		}
 	});
-	const throwIfTurnStartAcceptedAfterAbort = () => {
-		if (!runAbortController.signal.aborted) return;
-		const reason = runAbortController.signal.reason;
-		if (reason instanceof Error) throw reason;
-		const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : "codex app-server turn start aborted before acceptance");
-		error.name = "AbortError";
-		throw error;
-	};
 	const prepareWorkspaceReferences = () => {
 		const references = prepareCodexWorkspaceReferences(resourceState.client, resourceState.thread.threadId, workspaceBootstrapContext.promptContext);
 		prompt.refreshWorkspaceReferences(references.include);
@@ -8021,7 +8102,13 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			assertTurnCurrent();
 			resourceState.nativeSubagentMonitor?.bindTurn(acceptedTurnId, modelMapping);
 			if (upstreamUserText.includes(workspaceBootstrapContext.promptContext ?? "")) references.accepted();
-			throwIfTurnStartAcceptedAfterAbort();
+			if (runAbortController.signal.aborted) {
+				const reason = runAbortController.signal.reason;
+				if (reason instanceof Error) throw reason;
+				const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : "codex app-server turn start aborted before acceptance");
+				error.name = "AbortError";
+				throw error;
+			}
 			await continuation?.accept(acceptedTurnId);
 			return {
 				turn: startedTurn,
@@ -8081,7 +8168,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-start.ts
 async function startCodexAttemptTurn(resources, turnRuntime, notifications, requestRuntime) {
-	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded } = resources;
+	const { prompt, state: resourceState, trajectoryRecorder } = resources;
 	const { context, turnState, systemPromptReport } = prompt;
 	const { runtime, historyState, hookContext, hookRunner } = context;
 	const { connection, runtimeParams } = runtime;
@@ -8141,11 +8228,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 						threadId: resourceState.thread.threadId
 					}
 				});
-				try {
-					started = await startCodexTurn();
-				} catch (retryError) {
-					turnStartError = retryError;
-				}
+				started = await startCodexTurn();
 			}
 		} catch (retrySetupError) {
 			turnStartError = retrySetupError;
@@ -8180,7 +8263,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				aborted: runAbortController.signal.aborted,
 				promptError: message
 			});
-			markTrajectoryEndRecorded();
+			resourceState.trajectoryEndRecorded = true;
 			runAgentHarnessLlmOutputHook({
 				event: {
 					...buildLlmOutputEvent(),
@@ -8212,35 +8295,26 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				ctx: hookContext,
 				hookRunner
 			});
-			if (usageLimitError) {
-				await markCodexAuthProfileBlockedFromRateLimits({
-					params,
-					authProfileId: startupAuthProfileId,
-					rateLimits: usageLimitError.rateLimitsForProfile
-				});
-				return { result: buildCodexTurnStartFailureResult({
-					params,
-					message: usageLimitError.message,
-					promptError: new CodexUsageLimitPromptError(usageLimitError.message),
-					messagesSnapshot,
-					systemPromptReport
-				}) };
-			}
-			if (isCodexContextRestartSelectionChangedError(turnStartError)) return { result: {
-				...buildCodexTurnStartFailureResult({
-					params,
-					message,
-					messagesSnapshot,
-					systemPromptReport
-				}),
-				codexAppServerFailure: {
-					kind: "client_closed_before_turn_completed",
-					transport: appServer.start.transport,
-					threadId: resourceState.thread.threadId,
-					replaySafe: true
-				}
-			} };
-			throw turnStartError;
+			if (usageLimitError) await markCodexAuthProfileBlockedFromRateLimits({
+				params,
+				authProfileId: startupAuthProfileId,
+				rateLimits: usageLimitError.rateLimitsForProfile
+			});
+			else if (!isCodexContextRestartSelectionChangedError(turnStartError)) throw turnStartError;
+			const result = buildCodexTurnStartFailureResult({
+				params,
+				message,
+				...usageLimitError ? { promptError: new CodexUsageLimitPromptError(usageLimitError.message) } : {},
+				messagesSnapshot,
+				systemPromptReport
+			});
+			if (!usageLimitError) result.codexAppServerFailure = {
+				kind: "client_closed_before_turn_completed",
+				transport: appServer.start.transport,
+				threadId: resourceState.thread.threadId,
+				replaySafe: true
+			};
+			return { result };
 		}
 	}
 	if (!started) throw new Error("codex app-server turn/start failed without an error");
@@ -8274,6 +8348,7 @@ var CodexAttemptState = class {
 		this.projectionClosed = false;
 		this.terminalDynamicToolReleaseCheckScheduled = false;
 		this.currentTurnHadNonTerminalDynamicToolResult = false;
+		this.currentTurnHadToolAuthoredFinalReply = false;
 	}
 };
 function createCodexAttemptTurnState(resources) {
@@ -8409,10 +8484,13 @@ function createCodexAttemptTurnState(resources) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt.ts
 async function runCodexAppServerAttempt(params, options) {
-	if (params.requireWorkspaceOnly === true && (params.disableTools === true || typeof params.hostCapabilities?.createToolSurface !== "function")) throw new Error("Codex required-root execution requires an enabled host-mediated tool surface");
+	if (params.requireWorkspaceOnly === true && (params.disableTools === true || typeof params.hostCapabilities?.createToolSurfaceAsync !== "function")) throw new Error("Codex required-root execution requires an enabled host-mediated tool surface");
 	const preparation = createCodexAttemptPreparationTiming(params);
 	const connection = await preparation.measure("connection", () => prepareCodexAttemptConnection({
-		params,
+		params: params.continuation ? {
+			...params,
+			prompt: `${params.continuation.prompt}\n\n${params.prompt}`
+		} : params,
 		options
 	}));
 	try {