@openclaw/codex 2026.8.1-beta.3 → 2026.8.1

package/dist/{run-attempt-BV3HzuCf.js → run-attempt-BwNQDH2u.js}

@@ -1,42 +1,46 @@
-import { A as resolveOpenClawExecPolicyForCodexAppServer, C as parseAllowedApprovalPoliciesFromCodexRequirements, D as selectGuardianApprovalPolicy, E as readCodexRequirementsToml, O as selectGuardianApprovalsReviewer, S as resolveCodexModelBackedReviewerPolicyContext, T as parseAllowedSandboxModesFromCodexRequirements, b as canUseCodexModelBackedApprovalsReviewerForModel, d as withMcpElicitationsApprovalPolicy, f as isCodexPairedNodeRemoteExecPlacementSandbox, g as resolveCodexPluginsPolicy, h as readCodexPluginConfig, j as selectGuardianSandbox, k as selectUserApprovalsReviewer, l as resolveCodexAppServerNetworkProxy, m as isCodexSandboxExecServerEnabled, o as resolveCodexComputerUseConfig, p as isCodexRemoteExecPlacementSandbox, r as resolveCodexAppServerHomeScope, u as shouldAutoApproveCodexAppServerApprovals, w as parseAllowedApprovalsReviewersFromCodexRequirements } from "./config-CpNeo5AE.js";
-import { $ as rememberCodexRateLimitsRead, A as isCodexAppServerApprovalRequest, B as CodexAppServerRpcError, C as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, D as resolveCodexTurnTerminalIdleTimeoutMs, E as resolveCodexTurnCompletionIdleTimeoutMs, I as isCodexAppServerRequestTimeoutError, M as isCodexAppServerConnectionClosedError, N as isCodexAppServerIndeterminateRequestCancellationError, O as withCodexStartupTimeout, P as isCodexAppServerIndeterminateTransportError, Q as readRecentCodexRateLimits, R as resolveCodexAppServerClientInstanceId, T as resolveCodexTurnAssistantCompletionIdleTimeoutMs, V as createCodexElicitationResponse, W as ensureCodexAppServerClientRuntime, Y as retainCodexAppServerLiveThread, Z as readCodexRateLimitsRevision, a as getLeasedSharedCodexAppServerClient, at as resolveCodexAppServerPreparedAuthHandoff, b as CodexAppServerStartupError, et as resolveCodexAppServerAuthAccountCacheKey, f as retainSharedCodexAppServerClientIfCurrent, ft as resolveCodexAppServerHomeDir, g as withAbortableTimeout, i as createIsolatedCodexAppServerClient, it as resolveCodexAppServerPreparedApiKeyCacheKey, j as isCodexAppServerBrokenPipeError, k as getCodexAppServerClientInstanceId, l as releaseLeasedSharedCodexAppServerClient, lt as flattenCodexDynamicToolFunctions, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, nt as resolveCodexAppServerAuthProfileIdForAgent, o as getSharedCodexAppServerClient, p as retireSharedCodexAppServerClientIfCurrent, q as protectCodexAppServerLiveThread, rt as resolveCodexAppServerFallbackApiKeyCacheKey, s as isCodexAppServerStartSelectionChangedError, t as clearSharedCodexAppServerClientIfCurrent, tt as resolveCodexAppServerAuthProfileId, ut as isJsonObject, w as resolveCodexStartupTimeoutMs, x as isCodexAppServerStartupError, y as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS } from "./shared-client-Dw-rzii0.js";
-import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, i as createCodexSessionGenerationSupersededError, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore } from "./session-binding-BTrLf9Qm.js";
-import { A as shouldSynthesizeToolProgressForItem, B as readNullableString, E as itemStatus, F as readItem, I as readItemString, N as readCodexErrorNotificationMessage, O as shouldClearTerminalPresentationForNativeItem, T as itemName, V as splitPlanText, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, j as extractRawAssistantText, l as retireCodexAppServerClientAfterTimedOutTurn, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, u as retireUnsafeCodexTurnClientBestEffort, z as readNonNegativeInteger } from "./attempt-client-cleanup-URjUlCHg.js";
-import { C as readRawResponseToolCallId, E as updateActiveTurnItemIds, S as readNotificationItemId, T as updateActiveCompletionBlockerItemIds, _ as isReasoningItemCompletionNotification, a as codexExecutionToolName, b as isTerminalTurnStatus, c as isAssistantCompletionReleaseNotification, d as isNativeToolProgressNotification, f as isPendingOpenClawDynamicToolCompletionNotification, g as isRawToolOutputCompletionNotification, h as isRawReasoningCompletionNotification, l as isCodexTurnAbortMarkerNotification, m as isRawFunctionToolOutputCompletionNotification, o as describeNotificationActivity, p as isRawAssistantProgressNotification, r as projectCodexThreadUsageUpdate, s as isAssistantCommentaryCompletionNotification, t as CodexResponseCompletionProjection, u as isFileChangePatchUpdatedNotification, v as isReasoningProgressNotification, w as shouldDisarmAssistantCompletionIdleWatch, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-CLwNEJqW.js";
-import { l as readCodexTurn, o as assertCodexTurnStartResponse, s as readCodexDynamicToolCallParams, u as readCodexTurnCompletedNotification } from "./protocol-validators-VAVyEnDp.js";
-import { n as buildCodexAppServerRuntimeFingerprint, o as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-DMNQ8Zi8.js";
-import { B as neutralizeCodexExplicitMentionSigils, D as codexLegacyDynamicToolsFingerprint, E as codexDynamicToolsFingerprint, F as resolveCodexDynamicToolsLoadingForRuntime, G as buildCodexPluginAppsConfigPatchFromPolicyContext, H as resolveCodexContextEngineProjectionMaxChars, I as buildContextEngineBinding, J as buildCodexPluginThreadConfigTimeoutFallback, K as buildCodexPluginThreadConfig, L as isContextEngineBindingCompatible, M as isSystemAgentOnlyCodexDynamicToolAllowlist, O as filterCodexDynamicTools, Q as shouldBuildCodexPluginThreadConfig, R as buildCodexContinuityCalibration, T as areCodexDynamicToolFingerprintsCompatible, U as resolveCodexContextEngineProjectionReserveTokens, V as projectContextEngineAssemblyForCodex, W as resolveCodexContinuityProjectionMaxChars, X as buildPluginAppPolicyContext, Z as mergeCodexThreadConfigs, a as isCodexAppServerProfilerEnabled, f as resolveCodexWebSearchPlan, i as startOrResumeThread, it as resolveRecoverableCodexPluginConfigKeys, j as isMessageOnlyCodexSourceReply, n as buildTurnStartParams, p as buildDeveloperInstructions, q as buildCodexPluginThreadConfigInputFingerprint, r as buildCodexUserInput, t as buildTurnCollaborationMode, v as resolveCodexAppServerThreadModelSelection, z as fitCodexProjectedContextForTurnStart } from "./thread-lifecycle-DKdrnTMX.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
+import { C as isCodexRemoteExecPlacementSandbox, D as resolveOpenClawExecPolicyForCodexAppServer, E as resolveCodexPluginsPolicy, P as resolveCodexAppServerHomeDir, S as isCodexPairedNodeRemoteExecPlacementSandbox, T as readCodexPluginConfig, d as withMcpElicitationsApprovalPolicy, m as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig, p as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveCodexAppServerHomeScope, u as shouldAutoApproveCodexAppServerApprovals, v as readCodexRequirementsToml, w as isCodexSandboxExecServerEnabled } from "./config-Cxw3Cl3k.js";
+import { $ as CodexAppServerRpcError, A as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, B as resolveCodexTurnTerminalIdleTimeoutMs, Dt as readCodexRateLimitsRevision, Ft as resolveCodexAppServerFallbackApiKeyCacheKey, G as isCodexAppServerConnectionClosedError, H as getCodexAppServerClientInstanceId, Ht as isJsonObject, I as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, It as resolveCodexAppServerPreparedApiKeyCacheKey, J as isCodexAppServerOverloadError, K as isCodexAppServerIndeterminateRequestCancellationError, L as resolveCodexStartupTimeoutMs, Lt as resolveCodexAppServerPreparedAuthHandoff, M as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, Mt as resolveCodexAppServerAuthProfileId, N as TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS, Nt as resolveCodexAppServerAuthProfileIdForAgent, Ot as readRecentCodexRateLimits, P as isCodexAppServerStartupError, Q as resolveCodexAppServerClientInstanceId, R as resolveCodexTurnAssistantCompletionIdleTimeoutMs, Tt as withAbortableTimeout, U as isCodexAppServerApprovalRequest, V as withCodexStartupTimeout, Vt as flattenCodexDynamicToolFunctions, W as isCodexAppServerBrokenPipeError, X as isCodexAppServerRequestTimeoutError, _t as ensureCodexAppServerClientRuntime, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as resolveDynamicToolCallTimeoutMs, c as getLeasedSharedCodexAppServerClient, ct as shouldReleaseTurnAfterTerminalDynamicTool, dt as resolveCodexToolAbortTerminalReason, et as createCodexElicitationResponse, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, it as isMatchingDynamicToolTerminalDiagnostic, j as CodexAppServerStartupError, jt as resolveCodexAppServerAuthAccountCacheKey, kt as rememberCodexRateLimitsRead, l as getSharedCodexAppServerClient, lt as toCodexDynamicToolProgressResponse, nt as hasPendingDynamicToolTerminalDiagnostic, ot as resolveTerminalDynamicToolBatchAction, q as isCodexAppServerIndeterminateTransportError, rt as isDynamicToolTerminalDiagnosticEvent, s as createIsolatedCodexAppServerClient, st as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, tt as handleDynamicToolCallWithTimeout, u as isCodexAppServerStartSelectionChangedError, ut as toCodexDynamicToolProtocolResponse, v as retainSharedCodexAppServerClientIfCurrent, xt as protectCodexAppServerLiveThread, y as retireSharedCodexAppServerClientIfCurrent, z as resolveCodexTurnCompletionIdleTimeoutMs } from "./shared-client-kNkljY-R.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, i as createCodexSessionGenerationSupersededError, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore } from "./session-binding-q2WSTVmC.js";
+import { c as assertCodexTurnStartResponse, d as readCodexTurn, f as readCodexTurnCompletedNotification, l as readCodexDynamicToolCallParams } from "./protocol-validators-Bg5rpNxk.js";
+import { B as readNonNegativeInteger, D as itemStatus, E as itemName, H as splitPlanText, I as readItem, L as readItemString, M as extractRawAssistantText, P as readCodexErrorNotificationMessage, V as readNullableString, _ as readCodexNotificationThreadId, a as closeCodexStartupClientBestEffort, d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, g as isCodexNotificationForTurn, h as CodexProjectionDiagnostics, j as shouldSynthesizeToolProgressForItem, k as shouldClearTerminalPresentationForNativeItem, l as retireCodexAppServerClientAfterTimedOutTurn, m as getCodexAppServerTurnRouter, o as interruptCodexTurnAndWaitBestEffort, p as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-CVPvp9dL.js";
+import { C as readRawResponseToolCallId, E as updateActiveTurnItemIds, S as readNotificationItemId, T as updateActiveCompletionBlockerItemIds, _ as isReasoningItemCompletionNotification, a as codexExecutionToolName, b as isTerminalTurnStatus, c as isAssistantCompletionReleaseNotification, d as isNativeToolProgressNotification, f as isPendingOpenClawDynamicToolCompletionNotification, g as isRawToolOutputCompletionNotification, h as isRawReasoningCompletionNotification, l as isCodexTurnAbortMarkerNotification, m as isRawFunctionToolOutputCompletionNotification, o as describeNotificationActivity, p as isRawAssistantProgressNotification, r as projectCodexThreadUsageUpdate, s as isAssistantCommentaryCompletionNotification, t as CodexResponseCompletionProjection, u as isFileChangePatchUpdatedNotification, v as isReasoningProgressNotification, w as shouldDisarmAssistantCompletionIdleWatch, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-D3PHFFXh.js";
+import { i as buildCodexPluginAppCacheKey, r as buildCodexAppServerRuntimeFingerprint, s as defaultCodexAppInventoryCache } from "./thread-resume-DF54hagX.js";
+import { $ as resolveCodexContinuityProjectionMaxChars, B as isMessageOnlyCodexSourceReply, D as resolveCodexAppServerThreadModelSelection, F as codexDynamicToolsFingerprint, G as buildContextEngineBinding, I as codexLegacyDynamicToolsFingerprint, J as fitCodexProjectedContextForTurnStart, K as isContextEngineBindingCompatible, L as filterCodexDynamicTools, P as areCodexDynamicToolFingerprintsCompatible, Q as resolveCodexContextEngineProjectionReserveTokens, S as buildDeveloperInstructions, V as isSystemAgentOnlyCodexDynamicToolAllowlist, W as resolveCodexDynamicToolsLoadingForRuntime, X as projectContextEngineAssemblyForCodex, Y as neutralizeCodexExplicitMentionSigils, Z as resolveCodexContextEngineProjectionMaxChars, a as isCodexAppServerProfilerEnabled, at as buildPluginAppPolicyContext, c as buildCodexNativeHookRelayConfig, d as emitCodexNativePreToolUseFailureDiagnostic, et as buildCodexPluginAppsConfigPatchFromPolicyContext, f as resolveCodexNativeHookRelayEvents, i as startOrResumeThread, l as buildCodexNativeHookRelayDisabledConfig, m as scheduleCodexNativeHookRelayUnregister, n as buildTurnStartParams, nt as buildCodexPluginThreadConfigInputFingerprint, ot as mergeCodexThreadConfigs, p as resolveCodexNativeHookRelayTtlMs, pt as resolveRecoverableCodexPluginConfigKeys, q as buildCodexContinuityCalibration, r as buildCodexUserInput, rt as buildCodexPluginThreadConfigTimeoutFallback, s as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, st as shouldBuildCodexPluginThreadConfig, t as buildTurnCollaborationMode, tt as buildCodexPluginThreadConfig, u as createCodexNativeHookRelay, x as resolveCodexWebSearchPlan } from "./thread-lifecycle-Ss-uwnC4.js";
+import { l as isIncognitoSessionKey, r as retainCodexAppServerBindingSubscription } from "./thread-ownership-CeYBqg_4.js";
 import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
-import { a as buildCodexUserPromptMessage, c as readCodexMirrorSourceFingerprint, i as mirrorPromptAtTurnStartBestEffort, l as serializeCodexMirrorSourceEvidence, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BU0_LKAL.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-CH3K57v4.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-BI1dMHDG.js";
-import { r as formatCodexDisplayText } from "./command-formatters-D0nZ3qtd.js";
-import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-bg5QPSVP.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-DAvZwp96.js";
-import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-B4FfbcCg.js";
+import { a as buildCodexUserPromptMessage, i as mirrorPromptAtTurnStartBestEffort, l as readCodexMirrorSourceFingerprint, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, s as applyCodexTranscriptTaint, t as codexTranscriptMirrorRuntime, u as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-CkEQIna-.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-CGm_94eL.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-hFtzt2Up.js";
+import { r as formatCodexDisplayText } from "./command-formatters-C54Yg3eA.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-gLm40Vtq.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-CCQFs8lf.js";
+import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Ds_QVm-X.js";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-BOeJf7yo.js";
-import { n as createAssistantMessage, r as createAssistantMirrorMessage, t as createAssistantCommentaryMessage } from "./event-projector-assistant-message-BwxV4d6N.js";
-import { a as CodexToolProgressProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolResponse, i as readCodexMirroredSessionHistoryMessages, l as resolveCodexToolProgressDetailMode, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as CodexToolTranscriptProjection, s as inferCodexDynamicToolMeta, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexToolArguments } from "./native-subagent-monitor-GGq3RnOo.js";
-import { A as buildCodexNativeHookRelayConfig, B as isMatchingDynamicToolTerminalDiagnostic, C as shouldRequireCodexSandboxExecServerEnvironment, D as CodexNativeToolLifecycleProjector, E as readBoundedCodexRemoteWorkspaceFile, F as resolveCodexNativeHookRelayTtlMs, G as toCodexDynamicToolProgressResponse, H as resolveTerminalDynamicToolBatchAction, I as scheduleCodexNativeHookRelayUnregister, K as toCodexDynamicToolProtocolResponse, L as handleDynamicToolCallWithTimeout, M as createCodexNativeHookRelay, N as emitCodexNativePreToolUseFailureDiagnostic, P as resolveCodexNativeHookRelayEvents, R as hasPendingDynamicToolTerminalDiagnostic, S as shouldEnableCodexAppServerNativeToolSurface, U as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, V as resolveDynamicToolCallTimeoutMs, W as shouldReleaseTurnAfterTerminalDynamicTool, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as resolveCodexProviderWebSearchSupport, d as releaseCodexSandboxExecServerEnvironment, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, j as buildCodexNativeHookRelayDisabledConfig, k as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, q as resolveCodexToolAbortTerminalReason, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as ensureCodexSandboxExecServerEnvironment, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider, z as isDynamicToolTerminalDiagnosticEvent } from "./dynamic-tools-fJZhl4CE.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, o as killStaleComputerUseMcpChildren, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-BXH5NF-4.js";
+import { i as createAssistantMirrorMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-C5-Ds8mA.js";
+import { a as readCodexMirroredSessionHistoryMessages, c as inferCodexDynamicToolMeta, d as sanitizeCodexToolArguments, f as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as isCodexCommandBearingToolCall, n as CodexEventProjection, o as CodexToolProgressProjection, r as emitCodexAgentEvent, s as shouldEmitTranscriptToolProgress, t as codexNativeSubagentMonitorRuntime, u as resolveCodexToolProgressDetailMode } from "./native-subagent-monitor-CwFyoylz.js";
+import { C as shouldRequireCodexSandboxExecServerEnvironment, D as CodexNativeToolLifecycleProjector, E as readBoundedCodexRemoteWorkspaceFile, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as resolveCodexProviderWebSearchSupport, d as releaseCodexSandboxExecServerEnvironment, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as ensureCodexSandboxExecServerEnvironment, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-BFoUcRdx.js";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-CulOABwu.js";
 import { asBoolean, asFiniteNumber, asOptionalRecord, hasNonEmptyString, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildBootstrapContextForFiles, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import crypto, { createHash } from "node:crypto";
-import { hostname } from "node:os";
 import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveAgentConfig as resolveAgentConfig$1, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
+import { addAbortListener } from "node:events";
 import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
-import { isPathInside, isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
-import { captureFinalCodexCronCreatorToolAllowlist, materializeStaticMcpToolsForScheduledHarnessRun, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
+import { captureFinalCodexCronCreatorToolAllowlist, materializeStaticMcpToolsForScheduledHarnessRun, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { prepareMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
@@ -68,6 +72,12 @@ function createCodexSteeringQueue(params) {
 	let sendChain = Promise.resolve();
 	let sealedError;
 	let closedError;
+	const assertActive = () => {
+		const unavailableError = closedError ?? sealedError;
+		if (unavailableError) throw unavailableError;
+		params.signal.throwIfAborted();
+		params.assertActive();
+	};
 	const clearBatchTimer = () => {
 		if (batchTimer) {
 			clearTimeout(batchTimer);
@@ -120,19 +130,20 @@ function createCodexSteeringQueue(params) {
 	const sendBatch = async (items) => {
 		const liveItems = items.filter((item) => !item.settled);
 		if (liveItems.length === 0) return;
-		const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-		if (unavailableError) {
-			for (const item of liveItems) rejectItem(item, unavailableError);
-			throw unavailableError;
-		}
-		const clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-		const batch = { items: liveItems };
-		dispatchedBatches.set(clientUserMessageId, batch);
+		let clientUserMessageId;
 		try {
+			assertActive();
+			const input = [];
+			for (const item of liveItems) {
+				input.push(...await params.prepareMessage(item.text, item));
+				assertActive();
+			}
+			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
+			dispatchedBatches.set(clientUserMessageId, { items: liveItems });
 			await params.client.request("turn/steer", {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
-				input: liveItems.flatMap((item) => buildCodexUserInput(item.text, item.images)),
+				input,
 				clientUserMessageId
 			}, {
 				timeoutMs: params.requestTimeoutMs,
@@ -140,8 +151,8 @@ function createCodexSteeringQueue(params) {
 			});
 			for (const item of liveItems) reportItemAcceptance(item, true);
 		} catch (error) {
-			dispatchedBatches.delete(clientUserMessageId);
-			const acceptedUnconfirmed = isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error);
+			if (clientUserMessageId) dispatchedBatches.delete(clientUserMessageId);
+			const acceptedUnconfirmed = clientUserMessageId !== void 0 && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error));
 			for (const item of liveItems) {
 				if (acceptedUnconfirmed) reportItemAcceptance(item, true);
 				rejectItem(item, error);
@@ -175,15 +186,12 @@ function createCodexSteeringQueue(params) {
 			rejectDelivery = reject;
 		});
 		const item = {
+			...options,
 			acceptance: "open",
 			text,
-			images: options?.images,
-			isInboundUserMessage: options?.isInboundUserMessage,
-			onQueueAccepted: options?.onQueueAccepted,
 			resolve: resolveDelivery,
 			reject: rejectDelivery,
-			settled: false,
-			userTurnTranscriptRecorder: options?.userTurnTranscriptRecorder
+			settled: false
 		};
 		pendingMessages.add(item);
 		return {
@@ -195,10 +203,11 @@ function createCodexSteeringQueue(params) {
 	if (params.signal.aborted) abortQueue();
 	return {
 		async queue(text, options) {
-			const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-			if (unavailableError) {
+			try {
+				assertActive();
+			} catch (error) {
 				options?.onQueueAccepted?.(false);
-				throw unavailableError;
+				throw error;
 			}
 			const { item, delivery } = createPendingMessage(text, options);
 			batchedMessages.push(item);
@@ -242,15 +251,17 @@ function normalizeCodexSteerDebounceMs(value) {
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
-	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp) {
+	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
 		this.params = params;
 		this.emitAgentEvent = emitAgentEvent;
 		this.matchesToolProgressEcho = matchesToolProgressEcho;
 		this.nextTranscriptTimestamp = nextTranscriptTimestamp;
+		this.checkpointCommentary = checkpointCommentary;
 		this.assistantTextByItem = /* @__PURE__ */ new Map();
 		this.assistantItemOrder = [];
 		this.assistantTimestampByItem = /* @__PURE__ */ new Map();
 		this.assistantPhaseByItem = /* @__PURE__ */ new Map();
+		this.assistantDeliveryByItem = /* @__PURE__ */ new Map();
 		this.latestTerminalAssistantCandidateSuperseded = false;
 		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
 		this.terminalAssistantCandidateEarlierActiveItemIds = /* @__PURE__ */ new Set();
@@ -261,7 +272,9 @@ var CodexAssistantProjection = class {
 		this.assistantStarted = false;
 		this.streamedPartialAssistantItemReplaceable = false;
 		this.persistableAssistantBarrier = 0;
+		this.persistedAssistantBoundary = false;
 		this.persistableAssistantBarrierItemIds = /* @__PURE__ */ new Set();
+		this.completedAssistantItemIds = /* @__PURE__ */ new Set();
 	}
 	hasCompletedTerminalAssistantText(completedItemIds) {
 		const latestCompletedItemId = this.latestCompletedTerminalAssistantItemId;
@@ -293,7 +306,8 @@ var CodexAssistantProjection = class {
 		if (!delta) return;
 		if (itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		const isCommentary = this.isCommentaryAssistantItem(itemId);
-		if (!isCommentary && itemId !== this.latestTerminalAssistantCandidateItemId) this.markTerminalAssistantCandidateSupersededBy();
+		const isAsync = this.isAsyncAssistantItem(itemId);
+		if (!isCommentary && !isAsync && itemId !== this.latestTerminalAssistantCandidateItemId) this.markTerminalAssistantCandidateSupersededBy();
 		if (!this.assistantStarted) {
 			this.assistantStarted = true;
 			await this.params.onAssistantMessageStart?.();
@@ -301,6 +315,7 @@ var CodexAssistantProjection = class {
 		this.rememberAssistantItem(itemId);
 		const text = `${this.assistantTextByItem.get(itemId) ?? ""}${delta}`;
 		this.assistantTextByItem.set(itemId, text);
+		if (isAsync) return;
 		if (isCommentary) {
 			this.emitCommentaryProgress({
 				itemId,
@@ -332,24 +347,25 @@ var CodexAssistantProjection = class {
 	}
 	recordItemStarted(item, itemId) {
 		this.noteNativeWorkBarrier(item);
-		if (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		this.rememberAssistantPhase(item);
+		if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		if (item?.type === "agentMessage" && itemId) this.rememberAssistantItem(itemId);
-		if (itemId && itemId !== this.latestTerminalAssistantCandidateItemId) {
+		if (itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.latestTerminalAssistantCandidateItemId) {
 			this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
 			if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		}
 	}
 	recordItemCompleted(item, itemId, activeItemIds) {
+		if (itemId && item?.type === "agentMessage") this.completedAssistantItemIds.add(itemId);
 		this.noteNativeWorkBarrier(item);
-		if (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
-		if (itemId) this.latestCompletedItemId = itemId;
 		this.rememberAssistantPhase(item);
-		if (item?.type === "agentMessage" && !this.isCommentaryAssistantItem(item.id)) {
+		if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		if (itemId && !this.isNonTerminalAssistantItem(itemId)) this.latestCompletedItemId = itemId;
+		if (item?.type === "agentMessage" && !this.isNonTerminalAssistantItem(item.id)) {
 			this.latestCompletedTerminalAssistantItemId = item.id;
 			this.markLatestTerminalAssistantCandidate(item.id, activeItemIds);
 			this.pendingRawTerminalAssistantEchoItemId = item.id;
-		} else if (itemId) {
+		} else if (itemId && !this.isNonTerminalAssistantItem(itemId)) {
 			this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
 			if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		}
@@ -362,14 +378,17 @@ var CodexAssistantProjection = class {
 					text: item.text
 				});
 				this.pendingRawCommentaryEchoes += 1;
-			} else if (item.text && this.isFinalAnswerAssistantItem(item.id)) this.emitAnswerCandidate(item.id, "candidate");
+			} 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);
+			return this.createAsyncDelivery(item.id);
 		}
 	}
 	handleRawResponseItemCompleted(item, activeItemIds) {
@@ -403,6 +422,7 @@ var CodexAssistantProjection = class {
 		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && activeItemIds.size === 0;
 		if (text && phase !== "commentary" && candidateWasSupersededBeforeRaw && itemId !== this.streamedPartialAssistantItemId && !isIdlessTerminalAssistantAfterCompletedWork) return;
 		if (phase) this.assistantPhaseByItem.set(itemId, phase);
+		this.completedAssistantItemIds.add(itemId);
 		this.rememberAssistantItem(itemId);
 		this.assistantTextByItem.set(itemId, text);
 		if (!text) return;
@@ -418,6 +438,7 @@ var CodexAssistantProjection = class {
 		const audibleAfterHandoff = afterHandoff.filter((text) => !isSilentReplyPayloadText(text));
 		if (audibleAfterHandoff.length > 0) return audibleAfterHandoff;
 		if (afterHandoff.length > 0) return afterHandoff.slice(-1);
+		if (this.persistedAssistantBoundary) return [];
 		const recoveredAudible = this.collectPersistableAssistantTexts(0).filter((text) => !isSilentReplyPayloadText(text));
 		if (recoveredAudible.length > 0) return recoveredAudible.slice(-1);
 		const recovered = this.resolveFinalAssistantTextItem()?.text;
@@ -425,16 +446,52 @@ var CodexAssistantProjection = class {
 	}
 	collectCommentaryMessages() {
 		return this.assistantItemOrder.flatMap((itemId) => {
-			if (!this.isCommentaryAssistantItem(itemId)) return [];
+			const message = this.readCommentaryMessage(itemId);
+			return message ? [{
+				itemId,
+				message
+			}] : [];
+		});
+	}
+	readCommentaryMessage(itemId) {
+		const text = this.assistantTextByItem.get(itemId)?.trim();
+		const timestamp = this.assistantTimestampByItem.get(itemId);
+		return this.isCommentaryAssistantItem(itemId) && text && timestamp !== void 0 ? createAssistantCommentaryMessage(this.params, text, itemId, timestamp) : void 0;
+	}
+	collectAsyncMessages() {
+		return this.assistantItemOrder.flatMap((itemId) => {
+			if (!this.isAsyncAssistantItem(itemId)) return [];
 			const text = this.assistantTextByItem.get(itemId)?.trim();
 			const timestamp = this.assistantTimestampByItem.get(itemId);
 			if (!text || timestamp === void 0) return [];
 			return [{
 				itemId,
-				message: createAssistantCommentaryMessage(this.params, text, itemId, timestamp)
+				message: createAssistantAsyncMessage(this.params, text, itemId, timestamp)
+			}];
+		});
+	}
+	collectCompletedAssistantMessages(completedItemIds, options) {
+		return this.assistantItemOrder.flatMap((itemId) => {
+			const text = this.assistantTextByItem.get(itemId)?.trim();
+			if (!completedItemIds.has(itemId) || this.isNonTerminalAssistantItem(itemId) || !text || isSilentReplyPayloadText(text) || this.isToolProgressEchoText(itemId, text)) return [];
+			const message = this.createAssistantMessage(text, options);
+			const timestamp = this.assistantTimestampByItem.get(itemId) ?? message.timestamp;
+			return [{
+				itemId,
+				message: {
+					...message,
+					timestamp
+				}
 			}];
 		});
 	}
+	markAssistantBoundaryPersisted(itemId) {
+		const index = this.assistantItemOrder.indexOf(itemId);
+		if (index >= 0) {
+			this.persistableAssistantBarrier = Math.max(this.persistableAssistantBarrier, index + 1);
+			this.persistedAssistantBoundary = true;
+		}
+	}
 	finalizeAnswerCandidate(turn) {
 		if (turn.status !== "completed") {
 			this.supersedeVisibleAnswerCandidate();
@@ -444,7 +501,7 @@ var CodexAssistantProjection = class {
 		const authoritativeIndex = turnItems.findLastIndex((item) => {
 			if (item.type !== "agentMessage" || typeof item.text !== "string" || item.text.trim().length === 0) return false;
 			const phase = readItemString(item, "phase");
-			return phase === "final_answer" || phase === void 0;
+			return readItemString(item, "delivery") !== "async" && (phase === "final_answer" || phase === void 0);
 		});
 		const authoritative = authoritativeIndex >= 0 ? turnItems[authoritativeIndex] : void 0;
 		if (turnItems.slice(authoritativeIndex + 1).some(shouldClearTerminalPresentationForNativeItem) || authoritative?.id === this.latestTerminalAssistantCandidateItemId && this.latestTerminalAssistantCandidateSuperseded) {
@@ -462,7 +519,7 @@ var CodexAssistantProjection = class {
 	hasAssistantItemTextForSynthesis() {
 		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
 			const itemId = this.assistantItemOrder[i];
-			if (!itemId || this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			if (!itemId || this.isNonTerminalAssistantItem(itemId)) continue;
 			const text = this.assistantTextByItem.get(itemId);
 			if (text && text.length > 0) return true;
 		}
@@ -471,7 +528,7 @@ var CodexAssistantProjection = class {
 	createCurrentAttemptAssistantMessage(options) {
 		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
 			const itemId = this.assistantItemOrder[i];
-			if (!itemId || this.isCommentaryAssistantItem(itemId) || !this.assistantTextByItem.has(itemId)) continue;
+			if (!itemId || this.isNonTerminalAssistantItem(itemId) || !this.assistantTextByItem.has(itemId)) continue;
 			const text = this.assistantTextByItem.get(itemId) ?? "";
 			const normalizedText = text.trim();
 			if (normalizedText && this.isToolProgressEchoText(itemId, normalizedText)) continue;
@@ -492,10 +549,18 @@ var CodexAssistantProjection = class {
 		if (item?.type !== "agentMessage") return;
 		const phase = readItemString(item, "phase");
 		if (phase) this.assistantPhaseByItem.set(item.id, phase);
+		const delivery = readItemString(item, "delivery");
+		if (delivery) this.assistantDeliveryByItem.set(item.id, delivery);
 	}
 	isCommentaryAssistantItem(itemId) {
 		return this.assistantPhaseByItem.get(itemId) === "commentary";
 	}
+	isAsyncAssistantItem(itemId) {
+		return this.assistantDeliveryByItem.get(itemId) === "async";
+	}
+	isNonTerminalAssistantItem(itemId) {
+		return this.isCommentaryAssistantItem(itemId) || this.isAsyncAssistantItem(itemId);
+	}
 	isFinalAnswerAssistantItem(itemId) {
 		return this.assistantPhaseByItem.get(itemId) === "final_answer";
 	}
@@ -503,7 +568,7 @@ var CodexAssistantProjection = class {
 		return this.assistantPhaseByItem.get(itemId) === "final_answer";
 	}
 	emitCommentaryProgress(params) {
-		const progressText = params.text.replace(/\s+/g, " ").trim();
+		const progressText = params.text.trim();
 		if (!progressText || this.lastCommentaryProgressTextByItem.get(params.itemId) === progressText) return;
 		this.lastCommentaryProgressTextByItem.set(params.itemId, progressText);
 		this.emitAgentEvent({
@@ -570,7 +635,7 @@ var CodexAssistantProjection = class {
 			const itemId = this.assistantItemOrder[i];
 			if (!itemId) continue;
 			const text = this.assistantTextByItem.get(itemId)?.trim();
-			if (this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			if (this.isNonTerminalAssistantItem(itemId)) continue;
 			if (text && !this.isToolProgressEchoText(itemId, text)) return {
 				itemId,
 				text
@@ -582,7 +647,7 @@ var CodexAssistantProjection = class {
 		let replaceable = false;
 		for (let index = minIndex; index < this.assistantItemOrder.length; index += 1) {
 			const itemId = this.assistantItemOrder[index];
-			if (!itemId || this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			if (!itemId || this.isNonTerminalAssistantItem(itemId)) continue;
 			const text = this.assistantTextByItem.get(itemId)?.trim();
 			if (!text || this.isToolProgressEchoText(itemId, text)) continue;
 			if (isSilentReplyPayloadText(text)) {
@@ -606,9 +671,26 @@ var CodexAssistantProjection = class {
 		this.persistableAssistantBarrier = this.assistantItemOrder.length;
 	}
 	rememberAssistantItem(itemId) {
-		if (!itemId || this.assistantItemOrder.includes(itemId)) return;
-		this.assistantItemOrder.push(itemId);
-		this.assistantTimestampByItem.set(itemId, this.nextTranscriptTimestamp());
+		if (!itemId) return;
+		if (!this.assistantTimestampByItem.has(itemId)) {
+			this.assistantItemOrder.push(itemId);
+			this.assistantTimestampByItem.set(itemId, this.nextTranscriptTimestamp());
+		}
+		if (this.isCommentaryAssistantItem(itemId)) this.checkpointCommentary?.(itemId, {
+			read: () => this.readCommentaryMessage(itemId),
+			ready: () => this.completedAssistantItemIds.has(itemId)
+		});
+	}
+	createAsyncDelivery(itemId) {
+		if (!this.isAsyncAssistantItem(itemId)) return;
+		const text = this.assistantTextByItem.get(itemId);
+		const timestamp = this.assistantTimestampByItem.get(itemId);
+		if (!text?.trim() || timestamp === void 0) return;
+		return {
+			itemId,
+			message: createAssistantAsyncMessage(this.params, text, itemId, timestamp),
+			text
+		};
 	}
 	isToolProgressEchoText(itemId, text) {
 		return this.rawPromotedAssistantItemIds.has(itemId) && this.matchesToolProgressEcho(text);
@@ -618,6 +700,40 @@ 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. */
+var CodexAsyncDeliveryProjection = class {
+	constructor(params, threadId, turnId, options) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.options = options;
+		this.settledItemIds = /* @__PURE__ */ new Set();
+		this.pendingDeliveries = /* @__PURE__ */ new Map();
+	}
+	allows(item, reportUnauthorized = false) {
+		if (item?.type !== "agentMessage" || item.delivery !== "async") return true;
+		const allowed = this.params.disableTools !== true && (this.options.asyncUserMessageAllowed ?? (this.params.toolsAllow === void 0 || this.params.toolsAllow.some((name) => name === "*" || name === "message")));
+		if (!allowed && reportUnauthorized) embeddedAgentLog.warn("blocked unauthorized codex async user message", {
+			itemId: item.id,
+			threadId: this.threadId,
+			turnId: this.turnId
+		});
+		return allowed;
+	}
+	pending() {
+		return [...this.pendingDeliveries.values()];
+	}
+	async deliver(delivery) {
+		if (this.settledItemIds.has(delivery.itemId)) return;
+		const settlement = await this.options.onAsyncDelivery?.(delivery);
+		if (settlement === "settled") {
+			this.settledItemIds.add(delivery.itemId);
+			this.pendingDeliveries.delete(delivery.itemId);
+		} else if (settlement === "retry") this.pendingDeliveries.set(delivery.itemId, delivery);
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/event-projector-media.ts
 const GENERATED_IMAGE_MEDIA_SUBDIR = "tool-image-generation";
 var CodexGeneratedMediaProjection = class {
@@ -911,45 +1027,55 @@ function reasoningMethodOrder(method) {
 const attemptTerminal = agentHarnessAttemptTerminal;
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
-const CODEX_META_KEY$1 = "__openclaw";
-function readTurnTaintMetadata(message) {
-	return asOptionalRecord(CODEX_META_KEY$1 in message ? message[CODEX_META_KEY$1] : void 0);
-}
-function applyStickyTurnTaint(messages) {
-	let tainted = false;
-	return messages.map((message) => {
-		if (message.role === "user") {
-			tainted = false;
-			return message;
-		}
-		const metadata = readTurnTaintMetadata(message);
-		tainted ||= metadata?.turnTainted === true || metadata?.resultContentSource === "network";
-		return message.role === "assistant" && tainted ? {
-			...message,
-			__openclaw: {
-				...metadata,
-				turnTainted: true
-			}
-		} : message;
-	});
-}
 function buildCodexMessagesSnapshot(params) {
 	const messages = promptSnapshot(params.runParams, params.turnId, params.upstreamUserText);
 	if (params.reasoningText) messages.push(attachCodexMirrorIdentity(params.createAssistantMirrorMessage("Codex reasoning", params.reasoningText), `${params.turnId}:reasoning`));
-	if (params.planText) messages.push(attachCodexMirrorIdentity(params.createAssistantMirrorMessage("Codex plan", params.planText), `${params.turnId}:plan`));
-	const visibleWorkMessages = [...params.runParams.config?.ui?.prefs?.chatPersistCommentary === false ? [] : params.commentaryMessages.map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:commentary:${itemId}`)), ...params.toolMessages].toSorted((left, right) => (asDateTimestampMs(left.timestamp) ?? 0) - (asDateTimestampMs(right.timestamp) ?? 0));
+	const commentaryMessages = params.runParams.config?.ui?.prefs?.chatPersistCommentary === false ? [] : params.commentaryMessages.map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:commentary:${itemId}`));
+	const asyncMessages = params.asyncMessages.map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:async:${itemId}`));
+	const visibleWorkMessages = [
+		...commentaryMessages,
+		...asyncMessages,
+		...(params.assistantMessages ?? []).map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:assistant:${itemId}`)),
+		...params.toolMessages
+	].toSorted((left, right) => (asDateTimestampMs(left.timestamp) ?? 0) - (asDateTimestampMs(right.timestamp) ?? 0));
 	messages.push(...visibleWorkMessages);
 	if (params.lastAssistant) messages.push(attachCodexMirrorIdentity(params.lastAssistant, `${params.turnId}:assistant`));
-	return applyStickyTurnTaint(messages).map((message) => projectAgentHarnessTranscriptMessageForDisplay({
+	const taint = { tainted: false };
+	return messages.map((message) => projectAgentHarnessTranscriptMessageForDisplay({
 		hidden: params.runParams.trigger === "memory",
-		message
+		message: applyCodexTranscriptTaint(message, taint)
 	}));
 }
+function buildCodexSteeringMessagesSnapshot(params) {
+	const asyncMessages = params.assistantProjection.collectAsyncMessages().filter(({ itemId }) => params.completedItemIds.has(itemId));
+	const commentaryMessages = params.assistantProjection.collectCommentaryMessages().filter(({ itemId }) => params.completedItemIds.has(itemId));
+	const assistantMessages = params.assistantProjection.collectCompletedAssistantMessages(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,
+			createAssistantMirrorMessage: (title, text) => params.assistantProjection.createAssistantMirrorMessage(title, text)
+		}).filter((message) => message.role !== "user"),
+		assistantBoundaryItemId: assistantMessages.at(-1)?.itemId
+	};
+}
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-result.ts
 function buildCodexAttemptResult(input) {
 	input.nativeToolLifecycleProjection.finalizeActive();
 	const assistantTexts = input.assistantProjection.collectAssistantTexts();
+	const asyncMessages = input.assistantProjection.collectAsyncMessages();
 	const commentaryMessages = input.assistantProjection.collectCommentaryMessages();
 	const reasoningText = input.reasoningProjection.reasoningText();
 	const planText = input.reasoningProjection.planText();
@@ -984,7 +1110,7 @@ function buildCodexAttemptResult(input) {
 		turnId: input.turnId,
 		upstreamUserText: input.upstreamUserText,
 		reasoningText,
-		planText,
+		asyncMessages,
 		commentaryMessages,
 		toolMessages: input.toolTranscriptProjection.transcriptMessages,
 		lastAssistant,
@@ -1050,6 +1176,78 @@ function buildCodexAttemptResult(input) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/transcript-checkpoint.ts
+/** Commits completed work in receipt order without waiting for the enclosing turn. */
+var CodexTranscriptCheckpoint = class {
+	constructor(params, threadId, turnId) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.pending = [];
+		this.commentaryItemIds = /* @__PURE__ */ new Set();
+		this.lastTimestamp = 0;
+		this.writing = Promise.resolve();
+		this.tainted = false;
+		this.closed = false;
+		this.nextTimestamp = () => {
+			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
+			return this.lastTimestamp;
+		};
+		this.enqueueCommentary = (itemId, entry) => {
+			if (this.params.config?.ui?.prefs?.chatPersistCommentary === false || this.commentaryItemIds.has(itemId)) return;
+			this.commentaryItemIds.add(itemId);
+			this.enqueue({
+				...entry,
+				read: () => {
+					const message = entry.read();
+					return message ? attachCodexMirrorIdentity(message, `${this.turnId}:commentary:${itemId}`) : void 0;
+				}
+			});
+		};
+		this.enqueue = (entry) => {
+			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
+		};
+	}
+	flush(close = false) {
+		if (this.closed) return this.writing;
+		this.closed = close;
+		this.writing = this.writing.then(async () => {
+			const blocked = close ? -1 : this.pending.findIndex((entry) => entry.ready?.() === false);
+			const count = blocked < 0 ? this.pending.length : blocked;
+			if (count === 0) return;
+			const taint = { tainted: this.tainted };
+			const messages = this.pending.slice(0, count).flatMap((entry) => {
+				const message = entry.read();
+				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
+					hidden: this.params.trigger === "memory",
+					message: applyCodexTranscriptTaint(message, taint)
+				})] : [];
+			});
+			try {
+				await codexTranscriptMirrorRuntime.mirror({
+					...this.params.sessionTarget,
+					sessionId: this.params.sessionId,
+					cwd: this.params.workspaceDir,
+					messages,
+					idempotencyScope: `codex-app-server:${this.threadId}`,
+					runId: this.params.runId,
+					runMirrorIdentityPrefix: `${this.turnId}:`,
+					config: this.params.config
+				});
+				this.pending.splice(0, count);
+				this.tainted = taint.tainted;
+			} catch (error) {
+				embeddedAgentLog.warn("failed to checkpoint codex app-server transcript", {
+					runId: this.params.runId,
+					sessionId: this.params.sessionId,
+					error: formatErrorMessage(error)
+				});
+			}
+		});
+		return this.writing;
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/usage-limit-error.ts
 /**
 * Enriches Codex usage-limit failures with current rate-limit information and
@@ -1204,7 +1402,8 @@ var CodexAppServerEventProjector = class {
 		this.aborted = false;
 		this.responseCompletions = new CodexResponseCompletionProjection();
 		this.completedCompactionCount = 0;
-		this.lastTranscriptTimestamp = 0;
+		this.transcriptCheckpoint = new CodexTranscriptCheckpoint(params, threadId, turnId);
+		this.asyncDeliveryProjection = new CodexAsyncDeliveryProjection(params, threadId, turnId, options);
 		this.contextTokens = options.initialContextTokens;
 		this.contextTokensSource = options.initialContextTokens === void 0 ? void 0 : "resolved";
 		this.diagnostics = new CodexProjectionDiagnostics(threadId, turnId);
@@ -1216,35 +1415,37 @@ var CodexAppServerEventProjector = class {
 			signal: options.runAbortSignal
 		});
 		this.toolProgressProjection = new CodexToolProgressProjection(params);
-		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, () => this.nextTranscriptTimestamp(), {
+		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, this.transcriptCheckpoint.nextTimestamp, {
 			nativePostToolUseRelayEnabled: options.nativePostToolUseRelayEnabled,
 			prepareNativeMcpAppResultDetails: options.prepareNativeMcpAppResultDetails,
-			trajectoryRecorder: options.trajectoryRecorder
+			trajectoryRecorder: options.trajectoryRecorder,
+			checkpointMessage: this.transcriptCheckpoint.enqueue
 		});
 		this.eventProjection = new CodexEventProjection(threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
-		this.assistantProjection = new CodexAssistantProjection(params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), () => this.nextTranscriptTimestamp());
+		this.assistantProjection = new CodexAssistantProjection(params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
 		this.reasoningProjection = new CodexReasoningProjection(params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
 	}
-	nextTranscriptTimestamp() {
-		this.lastTranscriptTimestamp = Math.max(Date.now(), this.lastTranscriptTimestamp + 1);
-		return this.lastTranscriptTimestamp;
-	}
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
 	}
 	buildSteeringTranscriptPrefix() {
-		const commentaryMessages = this.assistantProjection.collectCommentaryMessages().filter(({ itemId }) => this.completedItemIds.has(itemId));
-		return buildCodexMessagesSnapshot({
+		const snapshot = buildCodexSteeringMessagesSnapshot({
 			runParams: this.params,
 			turnId: this.turnId,
 			upstreamUserText: this.options.upstreamUserText,
-			reasoningText: void 0,
-			planText: void 0,
-			commentaryMessages,
-			toolMessages: this.toolTranscriptProjection.transcriptMessages,
-			lastAssistant: void 0,
-			createAssistantMirrorMessage: (title, text) => this.assistantProjection.createAssistantMirrorMessage(title, text)
-		}).filter((message) => message.role !== "user");
+			completedItemIds: this.completedItemIds,
+			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;
+		}
 	}
 	hasCompletedTerminalAssistantText() {
 		return this.assistantProjection.hasCompletedTerminalAssistantText(this.completedItemIds);
@@ -1284,8 +1485,9 @@ var CodexAppServerEventProjector = class {
 		if (!params) return;
 		if (notification.method === "hook/started" || notification.method === "hook/completed") {
 			if (!this.isHookNotificationForCurrentThread(params)) return;
-		} else if (notification.method === "guardianWarning") {
-			if (readCodexNotificationThreadId(params) !== this.threadId) return;
+		} else if (notification.method === "guardianWarning" || notification.method === "warning" || notification.method === "configWarning") {
+			const warningThreadId = readCodexNotificationThreadId(params);
+			if (notification.method === "guardianWarning" && warningThreadId !== this.threadId || warningThreadId && warningThreadId !== this.threadId) return;
 		} else if (!isCodexNotificationForTurn(params, this.threadId, this.turnId)) return;
 		if (notification.method !== "guardianWarning" && notification.method !== "item/autoApprovalReview/started" && notification.method !== "item/autoApprovalReview/completed") this.eventProjection.flushPendingGuardianWarning();
 		this.nativeToolLifecycleProjector.handleNotification(notification);
@@ -1306,9 +1508,11 @@ var CodexAppServerEventProjector = class {
 				break;
 			case "item/started":
 				await this.handleItemStarted(params);
+				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/completed":
 				await this.handleItemCompleted(params);
+				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/commandExecution/outputDelta":
 				this.toolProgressProjection.handleOutputDelta(params, "bash");
@@ -1317,9 +1521,16 @@ var CodexAppServerEventProjector = class {
 			case "item/autoApprovalReview/completed":
 				this.eventProjection.handleGuardianReview(notification.method, params);
 				break;
+			case "autoApprovalReview/strictReviewRequired":
+				this.eventProjection.handleStrictReviewRequired(params);
+				break;
 			case "guardianWarning":
 				this.eventProjection.handleGuardianWarning(params);
 				break;
+			case "warning":
+			case "configWarning":
+				this.eventProjection.handleWarning(params);
+				break;
 			case "hook/started":
 			case "hook/completed":
 				this.eventProjection.handleHook(notification.method, params);
@@ -1331,7 +1542,7 @@ var CodexAppServerEventProjector = class {
 						this.contextTokensSource = this.params.authoredContextTokenCap === void 0 ? "runtime" : "runtime-configured";
 					}
 					this.emitAgentEvent({
-						stream: "codex_app_server.usage",
+						stream: "usage",
 						data
 					});
 				});
@@ -1344,6 +1555,10 @@ var CodexAppServerEventProjector = class {
 				break;
 			case "rawResponseItem/completed":
 				await this.handleRawResponseItemCompleted(params);
+				await this.transcriptCheckpoint.flush();
+				break;
+			case "model/rerouted":
+				this.eventProjection.handleModelRerouted(params);
 				break;
 			case "error": {
 				this.responseCompletions.clear();
@@ -1363,7 +1578,6 @@ var CodexAppServerEventProjector = class {
 			case "item/fileChange/outputDelta":
 			case "item/fileChange/patchUpdated":
 			case "item/mcpToolCall/progress":
-			case "model/rerouted":
 			case "model/verification":
 			case "turn/moderationMetadata":
 			case "model/safetyBuffering/updated": break;
@@ -1495,7 +1709,9 @@ var CodexAppServerEventProjector = class {
 			this.activeItemIds.delete(itemId);
 			this.completedItemIds.add(itemId);
 		}
-		this.assistantProjection.recordItemCompleted(item, itemId, this.activeItemIds);
+		if (!this.asyncDeliveryProjection.allows(item, true)) return;
+		const asyncMessage = this.assistantProjection.recordItemCompleted(item, itemId, this.activeItemIds);
+		if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 		this.reasoningProjection.recordItem(item);
 		await this.generatedMediaProjection.recordNative(item);
 		if (item?.type === "contextCompaction" && itemId) {
@@ -1525,9 +1741,9 @@ var CodexAppServerEventProjector = class {
 				threadId: this.threadId,
 				turnId: this.turnId,
 				itemId,
-				timestamp: this.nextTranscriptTimestamp()
+				timestamp: this.transcriptCheckpoint.nextTimestamp()
 			});
-			this.emitCompactionEnd(itemId, true);
+			this.eventProjection.emitCompactionEnd(itemId, true);
 		}
 		this.toolProgressProjection.recordToolMeta(item);
 		this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
@@ -1573,10 +1789,11 @@ var CodexAppServerEventProjector = class {
 			for (const itemId of failedCompactionItemIds) {
 				this.activeItemIds.delete(itemId);
 				this.activeCompactionItemIds.delete(itemId);
-				this.emitCompactionEnd(itemId, false);
+				this.eventProjection.emitCompactionEnd(itemId, false);
 			}
 		}
 		const turnItems = turn.items ?? [];
+		const unsettledAsyncDeliveries = this.asyncDeliveryProjection.pending();
 		for (let index = turnItems.length - 1; index >= 0; index -= 1) {
 			const item = turnItems[index];
 			if (!item || !this.isCurrentTurnSnapshotItem(item)) continue;
@@ -1587,8 +1804,10 @@ var CodexAppServerEventProjector = class {
 			}
 		}
 		for (const item of turnItems) {
+			if (!this.asyncDeliveryProjection.allows(item)) continue;
 			this.diagnostics.warnUnknownItemStatus(item);
-			this.assistantProjection.recordSnapshotItem(item);
+			const asyncMessage = this.assistantProjection.recordSnapshotItem(item);
+			if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 			this.reasoningProjection.recordItem(item);
 			await this.generatedMediaProjection.recordNative(item);
 			this.toolProgressProjection.recordToolMeta(item);
@@ -1601,23 +1820,11 @@ var CodexAppServerEventProjector = class {
 			this.toolProgressProjection.emitToolResultOutput(item);
 		}
 		this.toolProgressProjection.approvalTimeoutKinds.clear();
+		for (const delivery of unsettledAsyncDeliveries) await this.asyncDeliveryProjection.deliver(delivery);
 		this.assistantProjection.finalizeAnswerCandidate(turn);
 		this.activeCompactionItemIds.clear();
 		await this.reasoningProjection.maybeEndReasoning();
 	}
-	emitCompactionEnd(itemId, completed) {
-		this.emitAgentEvent({
-			stream: "compaction",
-			data: {
-				phase: "end",
-				backend: "codex-app-server",
-				completed,
-				threadId: this.threadId,
-				turnId: this.turnId,
-				itemId
-			}
-		});
-	}
 	async emitSnapshotOnlyNativeToolProgress(item) {
 		if (!shouldSynthesizeToolProgressForItem(item) || !this.isCurrentTurnSnapshotItem(item) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
 		if (!this.activeItemIds.has(item.id)) {
@@ -1675,24 +1882,7 @@ var CodexAppServerEventProjector = class {
 		return usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : readCodexErrorNotificationMessage(params);
 	}
 	emitAgentEvent(event) {
-		try {
-			emitAgentEvent({
-				runId: this.params.runId,
-				stream: event.stream,
-				data: event.data,
-				...this.params.sessionKey ? { sessionKey: this.params.sessionKey } : {}
-			});
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
-		}
-		try {
-			const maybePromise = this.params.onAgentEvent?.(event);
-			Promise.resolve(maybePromise).catch((error) => {
-				embeddedAgentLog.debug("codex app-server agent event handler rejected", { error });
-			});
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
-		}
+		emitCodexAgentEvent(this.params, event);
 	}
 	isHookNotificationForCurrentThread(params) {
 		const threadId = readStringField(params, "threadId");
@@ -1701,11 +1891,28 @@ var CodexAppServerEventProjector = class {
 	}
 };
 //#endregion
+//#region extensions/codex/src/app-server/mcp-tool-metadata.ts
+/** Hosted app ownership is authoritative only on metadata supplied by Codex. */
+function readCodexMcpToolConnectorId(tool) {
+	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
+	return normalizeOptionalString(metadata?.connector_id) ?? normalizeOptionalString(metadata?.connectorId);
+}
+/** Preserve MCP App visibility so model-only tools cannot become widget authority. */
+function readCodexMcpToolUiVisibility(tool) {
+	const visibility = asOptionalRecord(asOptionalRecord(asOptionalRecord(tool)?.["_meta"])?.ui)?.visibility;
+	if (!Array.isArray(visibility)) return;
+	return [...new Set(visibility.filter((value) => value === "app" || value === "model"))].toSorted();
+}
+//#endregion
 //#region extensions/codex/src/app-server/native-mcp-app.ts
+const CODEX_APPS_MCP_SERVER$1 = "codex_apps";
 function readMcpAppResourceUri(item) {
 	const uri = normalizeOptionalString(asOptionalRecord(item.appContext)?.resourceUri) ?? normalizeOptionalString(item.mcpAppResourceUri);
 	return uri?.startsWith("ui://") ? uri : void 0;
 }
+function readMcpAppConnectorId(item) {
+	return normalizeOptionalString(asOptionalRecord(item.appContext)?.connectorId);
+}
 function readMcpToolResult(item) {
 	const result = asOptionalRecord(item.result);
 	if (!result || !Array.isArray(result.content)) return;
@@ -1743,13 +1950,16 @@ function createNativeMcpRuntime(params) {
 				launchSummary: "Codex native MCP connection",
 				toolCount: Object.keys(status.tools).length
 			}])),
-			tools: loaded.flatMap((status) => statusTools(status).map((tool) => ({
-				serverName: status.name,
-				safeServerName: status.name,
-				toolName: String(tool.name),
-				inputSchema: asOptionalRecord(tool.inputSchema) ?? { type: "object" },
-				fallbackDescription: normalizeOptionalString(tool.description) ?? String(tool.name)
-			})))
+			tools: loaded.flatMap((status) => statusTools(status).map((tool) => {
+				const uiVisibility = readCodexMcpToolUiVisibility(tool);
+				return Object.assign({
+					serverName: status.name,
+					safeServerName: status.name,
+					toolName: String(tool.name),
+					inputSchema: asOptionalRecord(tool.inputSchema) ?? { type: "object" },
+					fallbackDescription: normalizeOptionalString(tool.description) ?? String(tool.name)
+				}, uiVisibility ? { uiVisibility } : {});
+			}))
 		};
 		return catalog;
 	};
@@ -1777,11 +1987,18 @@ function createNativeMcpRuntime(params) {
 			const status = (await loadStatuses()).find((entry) => entry.name === serverName);
 			return { tools: status ? statusTools(status) : [] };
 		},
-		readResource: async (serverName, uri) => await params.client.request("mcpServer/resource/read", {
-			threadId: params.threadId,
-			server: serverName,
-			uri
-		}),
+		readResource: async (serverName, uri) => {
+			const isCodexAppsServer = serverName === CODEX_APPS_MCP_SERVER$1;
+			const response = await params.client.request("mcpServer/resource/read", {
+				threadId: params.threadId,
+				...isCodexAppsServer ? { originCallId: params.originCallId } : {},
+				server: serverName,
+				uri,
+				...params.connectorId ? { connectorId: params.connectorId } : {}
+			});
+			if (isCodexAppsServer && response.originCallId !== params.originCallId) throw new Error(`Codex MCP resource response originCallId mismatch: expected ${params.originCallId}, received ${response.originCallId}`);
+			return response;
+		},
 		listResources: async (serverName) => {
 			return { resources: (await loadStatuses()).find((entry) => entry.name === serverName)?.resources ?? [] };
 		},
@@ -1794,15 +2011,25 @@ function createNativeMcpRuntime(params) {
 }
 function createCodexNativeMcpAppResultDetailsPreparer(params) {
 	if (params.attempt.config?.mcp?.apps?.enabled !== true) return;
-	const runtime = createNativeMcpRuntime(params);
 	return async (item) => {
 		const serverName = normalizeOptionalString(item.server);
 		const toolName = normalizeOptionalString(item.tool);
 		const uiResourceUri = readMcpAppResourceUri(item);
+		const connectorId = readMcpAppConnectorId(item);
 		const toolResult = readMcpToolResult(item);
 		if (!serverName || !toolName || !uiResourceUri || !toolResult) return;
-		const allowedAppToolNames = new Set((await runtime.getCatalog()).tools.filter((tool) => tool.serverName === serverName).map((tool) => tool.toolName));
-		if (allowedAppToolNames.size === 0) return;
+		if (serverName === CODEX_APPS_MCP_SERVER$1 && !connectorId) return;
+		const runtime = createNativeMcpRuntime({
+			...params,
+			originCallId: item.id,
+			...connectorId ? { connectorId } : {}
+		});
+		const tools = (await runtime.listTools?.(serverName))?.tools ?? [];
+		const allowedAppToolNames = new Set(tools.filter((tool) => {
+			const uiVisibility = readCodexMcpToolUiVisibility(tool);
+			return (uiVisibility === void 0 || uiVisibility.includes("app")) && (serverName !== CODEX_APPS_MCP_SERVER$1 || readCodexMcpToolConnectorId(tool) === connectorId);
+		}).map((tool) => tool.name));
+		if (!allowedAppToolNames.has(toolName)) return;
 		return await prepareHarnessNativeMcpAppPreview({
 			runtime,
 			serverName,
@@ -2208,6 +2435,16 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	}, resourceState.thread.threadId, activeTurnId, {
 		initialContextTokens: connection.mutable.startupContextTokens,
 		nativePostToolUseRelayEnabled: resourceState.nativeHookRelay?.allowedEvents.includes("post_tool_use") === true && resourceState.nativeHookRelay.shouldRelayEvent("post_tool_use"),
+		asyncUserMessageAllowed: params.disableTools !== true && (params.toolsAllow === void 0 || toolBridge.availableTools.some((tool) => tool.name === "message")),
+		onAsyncDelivery: async (delivery) => {
+			return await codexTranscriptMirrorRuntime.deliverAsyncMessageBestEffort({
+				params: dynamicToolParams,
+				cwd: effectiveCwd,
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				...delivery
+			});
+		},
 		readRecentRateLimits: () => readRecentCodexRateLimits(resourceState.client),
 		runAbortSignal: runAbortController.signal,
 		remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
@@ -2265,6 +2502,18 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	turnWatches.armAttemptIdleWatch();
 	turnWatches.touchActivity("turn:start", { attemptProgress: true });
 	for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
+	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
+	const promptMirrorPromise = mirrorPromptAtTurnStartBestEffort({
+		params,
+		agentId: sessionAgentId,
+		notifyUserMessagePersisted,
+		sessionKey: sandboxSessionKey,
+		cwd: effectiveCwd,
+		threadId: resourceState.thread.threadId,
+		turnId: activeTurnId,
+		upstreamUserText: turnState.codexTurnPromptText
+	});
+	await promptMirrorPromise;
 	if (resourceState.turnRoute) try {
 		await resourceState.turnRoute.bindTurn(activeTurnId);
 	} catch (error) {
@@ -2289,40 +2538,65 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			turnId: activeTurnId
 		});
 	}
-	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
-	const promptMirrorPromise = mirrorPromptAtTurnStartBestEffort({
-		params,
-		agentId: sessionAgentId,
-		notifyUserMessagePersisted,
-		sessionKey: sandboxSessionKey,
-		cwd: effectiveCwd,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		upstreamUserText: turnState.codexTurnPromptText
+	const assertSteeringActive = () => {
+		params.hostCapabilities.assertActive();
+		runAbortController.signal.throwIfAborted();
+		if (state.completed || state.terminalTurnNotificationQueued || state.timedOut) throw new Error("codex app-server turn is no longer accepting steering");
+	};
+	const workspaceOnly = resolveAttemptFsWorkspaceOnly({
+		config: params.config,
+		sessionAgentId
 	});
+	const imageContext = {
+		workspaceDir: connection.effectiveWorkspace,
+		model: params.model,
+		config: params.config,
+		workspaceOnly,
+		localRoots: workspaceOnly ? void 0 : getAgentScopedMediaLocalRoots(params.config ?? {}, sessionAgentId),
+		sandbox: connection.sandbox?.enabled && connection.sandbox.fsBridge ? {
+			root: connection.sandbox.workspaceDir,
+			bridge: connection.sandbox.fsBridge
+		} : void 0
+	};
 	const activeSteeringQueue = createCodexSteeringQueue({
 		client: resourceState.client,
 		threadId: resourceState.thread.threadId,
 		turnId: activeTurnId,
 		requestTimeoutMs: connection.appServer.requestTimeoutMs,
 		signal: runAbortController.signal,
+		assertActive: assertSteeringActive,
+		prepareMessage: async (text, options) => {
+			const result = await detectAndLoadAgentHarnessPromptImages({
+				...imageContext,
+				prompt: text,
+				existingImages: options.images,
+				imageOrder: options.imageOrder,
+				media: options.media,
+				userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
+			});
+			if (result.failedMediaCount) throw new Error(`failed to hydrate ${result.failedMediaCount} structured image attachment(s) for Codex steering`);
+			return buildCodexUserInput(text, result.images);
+		},
 		beforeConfirmConsumed: async (items) => {
 			const inboundItems = items.filter((item) => item.isInboundUserMessage === true);
 			if (inboundItems.length === 0) return;
 			await promptMirrorPromise;
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
-			if (params.sessionTarget && messages.length > 0) await codexTranscriptMirrorRuntime.mirror({
-				agentId: sessionAgentId,
-				sessionKey: contextSessionKey,
-				sessionId: params.sessionId,
-				storePath: params.sessionTarget.storePath,
-				cwd: effectiveCwd,
-				messages,
-				idempotencyScope: `codex-app-server:${resourceState.thread.threadId}`,
-				runId: params.runId,
-				runMirrorIdentityPrefix: `${activeTurnId}:`,
-				config: params.config
-			});
+			if (params.sessionTarget && messages.length > 0) {
+				await codexTranscriptMirrorRuntime.mirror({
+					agentId: sessionAgentId,
+					sessionKey: contextSessionKey,
+					sessionId: params.sessionId,
+					storePath: params.sessionTarget.storePath,
+					cwd: effectiveCwd,
+					messages,
+					idempotencyScope: `codex-app-server:${resourceState.thread.threadId}`,
+					runId: params.runId,
+					runMirrorIdentityPrefix: `${activeTurnId}:`,
+					config: params.config
+				});
+				activeProjector.markSteeringTranscriptPersisted();
+			}
 			for (const item of inboundItems) {
 				const recorder = item.userTurnTranscriptRecorder;
 				if (!recorder) continue;
@@ -2333,7 +2607,8 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	});
 	steeringQueueRef.current = activeSteeringQueue;
 	const claimPendingUserInputAnswer = async (text, optionsLocal) => {
-		if (optionsLocal?.isInboundUserMessage !== true || optionsLocal.images?.length) return false;
+		if (optionsLocal?.isInboundUserMessage !== true || hasPromptImageInput(optionsLocal)) return false;
+		assertSteeringActive();
 		return await claimPendingAgentQuestionAnswer({
 			sessionKey: params.sessionKey ?? params.sessionId,
 			text,
@@ -2347,14 +2622,17 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		resolvedBy
 	});
 	const queueMessage = async (text, optionsLocal) => {
-		const isInboundUserMessage = optionsLocal?.isInboundUserMessage === true;
 		if (await claimPendingUserInputAnswer(text, optionsLocal)) {
 			optionsLocal?.onQueueAccepted?.(true);
 			return;
-		} else if (isInboundUserMessage && optionsLocal?.images?.length) try {
-			await cancelPendingUserInput("image-reply");
-		} catch (error) {
-			embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
+		}
+		if (optionsLocal?.isInboundUserMessage === true && hasPromptImageInput(optionsLocal)) {
+			assertSteeringActive();
+			try {
+				await cancelPendingUserInput("image-reply");
+			} catch (error) {
+				embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
+			}
 		}
 		try {
 			await activeSteeringQueue.queue(text, optionsLocal);
@@ -2369,6 +2647,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const handle = {
 		kind: "embedded",
 		runId: params.runId,
+		startedAtMs: params.startedAtMs,
 		toolAuthorityFingerprint: params.toolAuthorityFingerprint,
 		claimPendingUserInputAnswer,
 		cancelPendingUserInput,
@@ -2383,7 +2662,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		isAbortable: () => !terminalState.terminalOutcomeFrozen || terminalState.sharedAbortAllowedAfterTerminalOutcome,
 		isCompacting: () => projectorRef.current?.isCompacting() ?? false,
 		supportsTranscriptCommitWait: true,
-		supportsQueueMessageImages: true,
+		supportsQueueMessageImages: params.model.input.includes("image"),
 		sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
 		taskSuggestionDeliveryMode: params.taskSuggestionDeliveryMode,
 		cancel: () => abortExplicitly("cancelled"),
@@ -2412,7 +2691,15 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			})().finally(completeTurn);
 			return;
 		}
-		interruptTurn(activeTurnId).finally(completeTurn);
+		const interrupted = interruptTurn(activeTurnId);
+		if (terminalState.explicitCancellationObserved) state.abortCleanup = interrupted.then(async (confirmed) => {
+			if (!confirmed) throw new Error("Codex cancellation could not confirm the turn stopped; background terminals may still be running.");
+			await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
+		});
+		(terminalState.explicitCancellationObserved ? state.abortCleanup : interrupted).then(completeTurn, (error) => {
+			embeddedAgentLog.warn("codex app-server cancellation cleanup failed", { error });
+			completeTurn();
+		});
 	};
 	runAbortController.signal.addEventListener("abort", abortListener, { once: true });
 	if (runAbortController.signal.aborted) abortListener();
@@ -2437,6 +2724,8 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, abortListener, handle, freezeRunTerminalOutcome } = activeTurn;
 	prompt.context.attemptTools.scheduledAppAuthoritySourceRef.current = void 0;
+	freezeRunTerminalOutcome();
+	await state.abortCleanup.catch(() => void 0);
 	try {
 		steeringQueueRef.current?.cancel();
 		if (params.isFinalFallbackAttempt !== false) await maybeEmitFastModeAutoResetBestEffort();
@@ -2460,15 +2749,11 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		const retainLiveIncognitoThread = terminalState.turnSucceeded && isIncognitoSessionKey(params.sessionKey);
 		const retainedPersistentThread = terminalState.turnSucceeded && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint ? (await bindingStore.read(bindingIdentity))?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
 			if ((await bindingStore.read(bindingIdentity))?.threadId !== resourceState.thread.threadId) return false;
-			return await retainCodexAppServerLiveThread(resourceState.client, resourceState.thread.threadId, resourceState.thread.liveThreadOwnership?.release ?? (async (threadId) => {
-				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-					threadId,
-					timeoutMs: 5e3
-				})) {
-					await closeCodexStartupClientBestEffort(resourceState.client);
-					throw new CodexAppServerUnsafeSubscriptionError(`Codex retained thread subscription could not be released: ${threadId}`);
-				}
-			}), resourceState.thread.liveThreadConfigFingerprint, connection.mutable.pluginAppServer.serviceTier);
+			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
+				release: resourceState.thread.liveThreadOwnership?.release,
+				configFingerprint: resourceState.thread.liveThreadConfigFingerprint,
+				serviceTier: connection.mutable.pluginAppServer.serviceTier
+			});
 		}) : false;
 		const retainLiveThread = retainLiveIncognitoThread || retainedPersistentThread;
 		const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveIncognitoThread ? await bindingStore.mutate(bindingIdentity, {
@@ -2486,7 +2771,13 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	} finally {
 		await runCleanupStep("codex-user-input-cancel", () => userInputBridgeRef.current?.cancelPending());
 		await runCleanupStep("codex-turn-watch-clear", () => turnWatches.clearAllTimers());
+		await runCleanupStep("codex-dynamic-tool-cleanup", async () => {
+			const cleanupReason = terminalState.turnSucceeded ? "completion" : state.timedOut ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
+			const cleanups = prompt.context.attemptTools.runCleanups.splice(0);
+			await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)));
+		});
 		await runCleanupStep("codex-route-release", releaseCurrentRoute);
+		await runCleanupStep("codex-transcript-checkpoint", () => activeTurn.activeProjector.transcriptCheckpoint.flush(true));
 		await runCleanupStep("codex-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		const nativeHookRelay = resourceState.nativeHookRelay;
 		resourceState.nativeHookRelay = void 0;
@@ -2505,12 +2796,12 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			runAbortController.signal.removeEventListener("abort", abortListener);
 		});
 		await runCleanupStep("codex-steering-cancel", () => steeringQueueRef.current?.cancel());
-		await runCleanupStep("codex-terminal-freeze", freezeRunTerminalOutcome);
 		await runCleanupStep("codex-reply-backend-detach", () => params.replyOperation?.detachBackend(handle));
 		await runCleanupStep("codex-active-run-clear", () => {
 			clearActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile);
 		});
 	}
+	await state.abortCleanup;
 }
 //#endregion
 //#region extensions/codex/src/app-server/workspace-dir-cache.ts
@@ -2579,105 +2870,6 @@ async function runCodexAgentEndHook(params, hookParams) {
 	runAgentEndSideEffects(sideEffectParams);
 }
 //#endregion
-//#region extensions/codex/src/app-server/session-permission-policy.ts
-function tupleForMode(mode, canUseAutoReview) {
-	switch (mode) {
-		case "read-only": return {
-			sandbox: "read-only",
-			approvalPolicy: "on-request",
-			approvalsReviewer: "user"
-		};
-		case "guarded": return {
-			sandbox: "workspace-write",
-			approvalPolicy: "on-request",
-			approvalsReviewer: "user"
-		};
-		case "workspace": return {
-			sandbox: "workspace-write",
-			approvalPolicy: "on-request",
-			approvalsReviewer: canUseAutoReview ? "auto_review" : "user"
-		};
-		case "full": return {
-			sandbox: "danger-full-access",
-			approvalPolicy: "never",
-			approvalsReviewer: "user"
-		};
-	}
-	return mode;
-}
-function requirementsAllowTuple(tuple, allowed) {
-	return (allowed.sandboxes === void 0 || allowed.sandboxes.has(tuple.sandbox)) && (allowed.approvalPolicies === void 0 || allowed.approvalPolicies.has(tuple.approvalPolicy)) && (allowed.reviewers === void 0 || allowed.reviewers.has(tuple.approvalsReviewer));
-}
-function tightenTupleForExecMode(tuple, execMode) {
-	switch (execMode) {
-		case "deny":
-		case "allowlist": return {
-			sandbox: "read-only",
-			approvalPolicy: "on-request",
-			approvalsReviewer: "user"
-		};
-		case "ask": return {
-			...tuple,
-			approvalPolicy: "on-request",
-			approvalsReviewer: "user"
-		};
-		case "auto":
-		case "full":
-		case void 0: return tuple;
-	}
-	return execMode;
-}
-function clampSessionPermissionTuple(params) {
-	if (!params.requirementsToml) return params.requested;
-	const allowed = {
-		sandboxes: parseAllowedSandboxModesFromCodexRequirements(params.requirementsToml, params.hostName ?? hostname()),
-		approvalPolicies: parseAllowedApprovalPoliciesFromCodexRequirements(params.requirementsToml),
-		reviewers: parseAllowedApprovalsReviewersFromCodexRequirements(params.requirementsToml)
-	};
-	if (requirementsAllowTuple(params.requested, allowed)) return params.requested;
-	const userReviewRequired = params.mode === "read-only" || params.mode === "guarded" || params.mode === "workspace" && !params.canUseAutoReview;
-	return {
-		sandbox: selectGuardianSandbox(allowed.sandboxes),
-		approvalPolicy: selectGuardianApprovalPolicy(allowed.approvalPolicies, userReviewRequired ? "ask" : "auto"),
-		approvalsReviewer: userReviewRequired ? selectUserApprovalsReviewer(allowed.reviewers) : selectGuardianApprovalsReviewer(allowed.reviewers, "auto")
-	};
-}
-/** Applies one complete session-mode tuple without mixing requirements-clamped fields. */
-function applyCodexSessionPermissionPolicy(params) {
-	if (!params.permissionMode) return params.appServer;
-	const sessionRoot = params.sessionRoot?.trim();
-	if (!sessionRoot) throw new Error("Codex session permission mode requires a recorded session root");
-	if (params.policyLocked) return {
-		...params.appServer,
-		sessionRoot
-	};
-	const requested = tightenTupleForExecMode(tupleForMode(params.permissionMode, params.canUseAutoReview), params.execMode);
-	const tuple = params.appServer.start.transport === "stdio" ? clampSessionPermissionTuple({
-		mode: params.permissionMode,
-		requested,
-		requirementsToml: params.requirementsToml,
-		hostName: params.hostName,
-		canUseAutoReview: params.canUseAutoReview
-	}) : requested;
-	const networkProxy = params.appServer.networkProxy ? resolveCodexAppServerNetworkProxy(params.pluginConfig.appServer?.networkProxy, tuple.sandbox).networkProxy : void 0;
-	const resolved = {
-		...params.appServer,
-		...tuple,
-		sessionRoot
-	};
-	if (networkProxy) resolved.networkProxy = networkProxy;
-	else delete resolved.networkProxy;
-	return resolved;
-}
-/** Keeps relative execution inside the prepared root without filesystem rediscovery. */
-function resolveCodexSessionPermissionCwd(params) {
-	if (!params.permissionMode) return params.requestedCwd ?? params.fallbackCwd;
-	const sessionRoot = params.sessionRoot?.trim();
-	if (!sessionRoot) throw new Error("Codex session permission mode requires a recorded session root");
-	const requestedCwd = params.requestedCwd?.trim();
-	return requestedCwd && isPathInside(sessionRoot, requestedCwd) ? requestedCwd : sessionRoot;
-}
-//#endregion
 //#region extensions/codex/src/app-server/startup-binding.ts
 const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
 const CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS = 2e4;
@@ -2994,7 +3186,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const requirementsToml = readCodexRequirementsToml({});
 	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
-	const { sessionAgentId } = resolveSessionAgentIds({
+	const { sessionAgentId } = resolveSessionAgentIdsStrict({
 		sessionKey: params.sessionKey,
 		config: params.config,
 		agentId: params.agentId
@@ -3150,6 +3342,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const sessionPermissionCwd = resolveCodexSessionPermissionCwd({
 		permissionMode: params.permissionMode,
 		sessionRoot: params.sessionRoot,
+		defaultRoot: effectiveWorkspace,
 		requestedCwd,
 		fallbackCwd: effectiveWorkspace
 	});
@@ -3160,14 +3353,20 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		appServer,
 		permissionMode: params.permissionMode,
 		sessionRoot: params.sessionRoot,
+		defaultRoot: effectiveWorkspace,
 		pluginConfig,
 		canUseAutoReview: canUseCodexModelBackedApprovalsReviewerForModel({
 			modelProvider: selection.modelProvider,
 			model: selection.model,
 			config: params.config,
-			env: process.env,
+			env: {
+				...process.env,
+				...appServer.start.env,
+				...shellEnvironment
+			},
 			agentDir,
-			homeScope: appServer.start.homeScope
+			homeScope: appServer.start.homeScope,
+			codexArgs: appServer.start.args
 		}),
 		requirementsToml,
 		policyLocked: startupBinding?.connectionScope === "supervision",
@@ -3180,7 +3379,11 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			provider: selection.modelProvider,
 			model: selection.model,
 			config: params.config,
-			env: process.env,
+			env: {
+				...process.env,
+				...session.start.env,
+				...shellEnvironment
+			},
 			agentDir
 		});
 		return {
@@ -3244,6 +3447,17 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		resolvedAppServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
 		appServer = resolvedAppServer.appServer;
 	}
+	const sessionPermissionPolicy = resolveCodexEffectiveSessionPermissionPolicy({
+		appServer,
+		permissionMode: params.permissionMode,
+		sessionRoot: params.sessionRoot,
+		defaultRoot: effectiveWorkspace
+	});
+	if (sessionPermissionPolicy) {
+		params.permissionMode = sessionPermissionPolicy.mode;
+		params.sessionRoot = sessionPermissionPolicy.root;
+		(params.execOverrides ??= {}).mode = sessionPermissionPolicy.execMode;
+	}
 	const nativeHookRelayEvents = resolveCodexNativeHookRelayEvents({
 		configuredEvents: options.nativeHookRelay?.events,
 		appServer
@@ -3290,6 +3504,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		effectiveWorkspace,
 		effectiveCwd,
 		appServer,
+		sessionPermissionPolicy,
 		nativeHookRelayEvents,
 		runAbortController,
 		terminalState,
@@ -4439,7 +4654,11 @@ function createCodexTrajectoryRecorder(params) {
 	if (!params.trajectory) return null;
 	const trajectory = params.trajectory;
 	return {
-		recordEvent: trajectory.recordEvent,
+		recordEvent: (type, data) => {
+			try {
+				trajectory.recordEvent(type, data);
+			} catch {}
+		},
 		flush: trajectory.flush
 	};
 }
@@ -4501,7 +4720,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { hookContextWindowFields, hookRunner } = context;
 	const { connection, preparedAuthBinding } = runtime;
 	const { effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
-	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, attemptStartedAt, startupAuthProfileId } = connection;
+	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, agentDir, attemptStartedAt, startupAuthProfileId } = connection;
 	const { toolBridge, toolState } = attemptTools;
 	const { state, completion, pendingOpenClawDynamicToolCompletionIds, activeTurnItemIds, activeCompletionBlockerItemIds, activeFinalizationHookRunIds, turnWatches } = turnRuntime;
 	const { emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
@@ -4509,7 +4728,20 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, activeProjector, streamState, freezeRunTerminalOutcome, notifyUserMessagePersisted } = activeTurn;
 	await completion;
-	await drainNotificationQueue();
+	await state.abortCleanup;
+	const drain = drainNotificationQueue();
+	const abortGraceElapsed = createDeferred();
+	let abortGraceTimer;
+	const abortListener = addAbortListener(runAbortController.signal, () => {
+		abortGraceTimer = setTimeout(() => abortGraceElapsed.resolve(), TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
+		abortGraceTimer.unref?.();
+	});
+	try {
+		await Promise.race([drain, abortGraceElapsed.promise]);
+	} finally {
+		abortListener[Symbol.dispose]();
+		clearTimeout(abortGraceTimer);
+	}
 	const hasQuiescentCompletedAssistant = activeProjector.hasCompletedTerminalAssistantText() && state.activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && activeFinalizationHookRunIds.size === 0 && state.unsettledFinalizationHookCount === 0 && state.rejectedFinalizationHookAssistant === void 0;
 	const hasRecoverableCompletedAssistant = !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && turnWatches.isAssistantCompletionIdleWatchArmed() && hasQuiescentCompletedAssistant;
 	const recoveredTurnWatchTimeout = state.turnCompletionIdleTimedOut && !terminalState.explicitCancellationObserved && hasRecoverableCompletedAssistant && activeProjector.recoverCompletedTerminalAssistantAfterTurnWatchTimeout();
@@ -4680,20 +4912,11 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			modelIterations: result.modelIterations ?? 0,
 			skillWorkshopAvailable: flattenCodexDynamicToolFunctions(attemptTools.toolBridge.availableSpecs).some((tool) => tool.name === "skill_workshop"),
 			compacted: (result.compactionCount ?? 0) > 0,
-			messageChannel: params.messageChannel,
-			messageProvider: params.messageProvider,
-			chatType: params.chatType,
-			agentAccountId: params.agentAccountId,
-			groupId: params.groupId,
-			groupChannel: params.groupChannel,
-			groupSpace: params.groupSpace,
-			memberRoleIds: params.memberRoleIds,
-			spawnedBy: params.spawnedBy,
 			senderId: params.senderId ?? void 0,
-			senderName: params.senderName,
-			senderUsername: params.senderUsername,
-			senderE164: params.senderE164,
-			senderIsOwner: params.senderIsOwner
+			foregroundPromptContext: buildEmbeddedForegroundPromptContext({
+				...params,
+				agentId: sessionAgentId
+			}, agentDir)
 		},
 		hookRunner
 	});
@@ -5854,10 +6077,6 @@ function resolveScheduledCodexAppCreatorCaptureDecision(params) {
 		...unavailableReason ? { unavailableReason } : {}
 	};
 }
-function readConnectorId(tool) {
-	const meta = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
-	return normalizeOptionalString(meta?.connector_id) ?? normalizeOptionalString(meta?.connectorId);
-}
 function normalizeApprovalMode(value) {
 	return value === "allow" || value === "deny" || value === "auto" || value === "ask" ? value : void 0;
 }
@@ -5924,7 +6143,7 @@ async function readCodexScheduledAppToolNamesByApp(params) {
 			if (!isJsonObject(status) || !isJsonObject(status.tools)) throw new Error("Codex scheduled app inventory contained an invalid server status");
 			if (status.name !== CODEX_APPS_MCP_SERVER) continue;
 			for (const [toolName, tool] of Object.entries(status.tools)) {
-				const connectorId = readConnectorId(tool);
+				const connectorId = readCodexMcpToolConnectorId(tool);
 				if (connectorId) {
 					const names = toolNamesByApp.get(connectorId) ?? /* @__PURE__ */ new Set();
 					names.add(toolName);
@@ -6518,6 +6737,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				data: {
 					phase: "start",
 					name: call.tool,
+					itemId: call.callId,
 					toolCallId: call.callId,
 					...toolMeta ? { meta: toolMeta } : {},
 					...toolArgs ? { args: toolArgs } : {},
@@ -6540,7 +6760,8 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				})) terminalDiagnosticObserved = true;
 			}, { include: DYNAMIC_TOOL_TERMINAL_DIAGNOSTIC_TYPES });
 			try {
-				const { execution } = openClawDynamicToolExecutions.claim(call, () => {
+				const { execution } = openClawDynamicToolExecutions.claim(call, async () => {
+					await projector?.transcriptCheckpoint.flush();
 					emitDynamicToolStartedDiagnostic({
 						call,
 						agentId: sessionAgentId,
@@ -6548,7 +6769,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						sessionId: params.sessionId,
 						sessionKey: params.sessionKey
 					});
-					return handleDynamicToolCallWithTimeout({
+					const response = await handleDynamicToolCallWithTimeout({
 						call,
 						toolBridge,
 						signal,
@@ -6570,6 +6791,9 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 							});
 						}
 					});
+					recordCodexDynamicToolResult(projector, call, response, toCodexDynamicToolProtocolResponse(response));
+					await projector?.transcriptCheckpoint.flush();
+					return response;
 				});
 				const response = await execution;
 				const protocolResponse = toCodexDynamicToolProtocolResponse(response);
@@ -6593,7 +6817,6 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					success: protocolResponse.success,
 					contentItems: protocolResponse.contentItems
 				});
-				recordCodexDynamicToolResult(projector, call, response, protocolResponse);
 				if (protocolResponse.success && call.tool === "progress_card") {
 					const progressCardInput = response.executedArguments ?? call.arguments;
 					await projector?.recordDynamicProgressCardUpdate(progressCardInput);
@@ -6606,6 +6829,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						data: {
 							phase: "result",
 							name: call.tool,
+							itemId: call.callId,
 							toolCallId: call.callId,
 							...toolMeta ? { meta: toolMeta } : {},
 							...commandBearing ? { commandBearing: true } : {},
@@ -6681,7 +6905,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 //#region extensions/codex/src/app-server/attempt-runtime-artifact.ts
 async function verifyStartupArtifact(params) {
 	if (!params.request) return;
-	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-BvyT1uyd.js");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-DeBvleJw.js");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6711,19 +6935,17 @@ function startCodexComputerUseHealthMonitor(params) {
 	}
 	const fingerprint = buildComputerUseHealthMonitorFingerprint(params.config);
 	const intervalMs = params.config.healthCheckIntervalMinutes * 6e4;
-	if (existing?.fingerprint === fingerprint && existing.repairComputerUseMcpChildren === params.repairComputerUseMcpChildren) return {
+	if (existing?.fingerprint === fingerprint) return {
 		started: false,
 		intervalMs,
 		reason: "already_started"
 	};
 	if (existing) clearComputerUseHealthMonitor(params.client, existing);
-	const repairComputerUseMcpChildren = params.repairComputerUseMcpChildren ?? (() => killStaleComputerUseMcpChildren({ ancestorPid: params.client.getTransportPid() }));
 	const monitor = {
 		fingerprint,
 		intervalMs,
-		repairComputerUseMcpChildren: params.repairComputerUseMcpChildren,
 		timer: setInterval(() => {
-			runCodexComputerUseHealthProbe(params.client, params.config, monitor, { repairComputerUseMcpChildren });
+			runCodexComputerUseHealthProbe(params.client, params.config, monitor);
 		}, intervalMs),
 		disposeCloseHandler: () => void 0,
 		running: false
@@ -6748,13 +6970,12 @@ function buildComputerUseHealthMonitorFingerprint(config) {
 		toolCallTimeoutMs: config.toolCallTimeoutMs
 	});
 }
-async function runCodexComputerUseHealthProbe(client, config, monitor, options) {
+async function runCodexComputerUseHealthProbe(client, config, monitor) {
 	if (monitor.running) return;
 	monitor.running = true;
 	try {
 		const { liveTest, repair } = await runCodexComputerUseLiveTest({
 			config,
-			repairComputerUseMcpChildren: options.repairComputerUseMcpChildren,
 			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, { timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs })
 		});
 		if (!liveTest.ok) {
@@ -6767,10 +6988,7 @@ async function runCodexComputerUseHealthProbe(client, config, monitor, options)
 			});
 			return;
 		}
-		if (repair?.killedPids.length) embeddedAgentLog.info("codex computer-use periodic health repaired stale children", {
-			mcpServerName: config.mcpServerName,
-			killedPids: repair.killedPids
-		});
+		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", {
 			mcpServerName: config.mcpServerName,
@@ -6865,6 +7083,7 @@ function createCodexPluginThreadConfigStartupProvider(params) {
 		build: async (buildOptions) => {
 			const config = await buildCodexPluginThreadConfigWithinDeadline({
 				...buildParams,
+				threadId: buildOptions?.threadId,
 				appCache: appCache ?? defaultCodexAppInventoryCache,
 				metadataCache,
 				failClosedOnTimeout: Boolean(params.scheduledRuntimeAuthority),
@@ -6897,7 +7116,7 @@ function isCodexPluginThreadConfigTimeoutError(error) {
 * Startup orchestration for Codex app-server attempts, including shared-client
 * leasing, plugin thread config, sandbox environment, and thread lifecycle binding.
 */
-const CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS = 3;
+const CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS = 3;
 const CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED = "CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED";
 /** True when a pre-write context restart must replay on the newly selected owner. */
 function isCodexContextRestartSelectionChangedError(error) {
@@ -7009,7 +7228,7 @@ async function startCodexAttemptThread(params) {
 								signal: startupAbandonController.signal
 							});
 						} catch (error) {
-							if (startupAbandonController.signal.aborted) throw error;
+							if (startupAbandonController.signal.aborted || isCodexAppServerStartSelectionChangedError(error)) throw error;
 							throw new AgentHarnessPreflightError(`Codex Computer Use readiness failed: ${formatErrorMessage(error)}`, {
 								cause: error,
 								scope: "harness"
@@ -7023,7 +7242,8 @@ async function startCodexAttemptThread(params) {
 							accountId: params.startupAuthAccountCacheKey,
 							envApiKeyFingerprint: params.startupEnvApiKeyCacheKey,
 							appServerVersion: activeStartupClient.getServerVersion(),
-							runtimeIdentity: startupRuntimeIdentity
+							runtimeIdentity: startupRuntimeIdentity,
+							desktopGenerationFingerprint: readCodexAppServerClientDesktopGenerationFingerprint(activeStartupClient)
 						});
 						const appServerRuntimeFingerprint = buildCodexAppServerRuntimeFingerprint({
 							appServer: params.appServer,
@@ -7127,6 +7347,7 @@ async function startCodexAttemptThread(params) {
 							finalConfigPatch: params.finalConfigPatch,
 							buildFinalConfigPatch: params.buildFinalConfigPatch,
 							nativeHookRelayGeneration: params.nativeHookRelayGeneration,
+							nativeHookRelayRequired: params.nativeHookRelayRequired,
 							nativeCodeModeEnabled: params.nativeToolSurfaceEnabled,
 							nativeProviderWebSearchSupport: params.nativeProviderWebSearchSupport,
 							nativeCodeModeOnlyEnabled: params.appServer.codeModeOnly,
@@ -7221,30 +7442,31 @@ async function startCodexAttemptThread(params) {
 						}
 					}
 				};
-				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS; attempt += 1) try {
+				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS; attempt += 1) try {
 					return await startupAttempt();
 				} catch (error) {
 					const selectionChanged = isCodexAppServerStartSelectionChangedError(error);
 					if (startupAbandoned || params.signal.aborted || !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
-					const failedClient = attemptedClient;
-					const refreshedSharedClient = selectionChanged ? retireSharedCodexAppServerClientIfCurrent(failedClient) : clearSharedCodexAppServerClientIfCurrent(failedClient);
-					if (startupClientForAbandonedRequestCleanup === failedClient) startupClientForAbandonedRequestCleanup = void 0;
-					if (attempt >= CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS) {
+					const refreshedSharedClient = selectionChanged ? retireSharedCodexAppServerClientIfCurrent(attemptedClient) : clearSharedCodexAppServerClientIfCurrent(attemptedClient);
+					if (startupClientForAbandonedRequestCleanup === attemptedClient) startupClientForAbandonedRequestCleanup = void 0;
+					if (attempt >= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS) {
 						embeddedAgentLog.warn(selectionChanged ? "codex app-server executable selection kept changing during startup; retries exhausted" : "codex app-server connection closed during startup; retries exhausted", {
 							attempt,
-							maxAttempts: CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS,
+							maxAttempts: CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS,
 							refreshedSharedClient,
 							error: formatErrorMessage(error)
 						});
 						throw error;
 					}
+					const retryDelayMs = selectionChanged ? 0 : 1e3 * 2 ** (attempt - 1);
 					embeddedAgentLog.warn(selectionChanged ? "codex app-server executable selection changed during startup; restarting app-server and retrying" : "codex app-server connection closed during startup; restarting app-server and retrying", {
 						attempt,
 						nextAttempt: attempt + 1,
-						maxAttempts: CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS,
+						maxAttempts: CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS,
 						refreshedSharedClient,
 						error: formatErrorMessage(error)
 					});
+					await sleepWithAbort(retryDelayMs, startupAbandonController.signal);
 				}
 				throw new Error("codex app-server startup retry loop exited unexpectedly");
 			}
@@ -7257,7 +7479,7 @@ async function startCodexAttemptThread(params) {
 			releaseSharedClientLease
 		};
 	} catch (error) {
-		if (params.signal.aborted || shouldClearSharedClientAfterStartupAbandon(error)) {
+		if (params.signal.aborted || isCodexAppServerStartupError(error)) {
 			releaseSharedClientLease?.();
 			releaseSharedClientLease = void 0;
 			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
@@ -7276,13 +7498,11 @@ async function startCodexAttemptThread(params) {
 		params.signal.removeEventListener("abort", abandonStartupAcquire);
 	}
 }
-function shouldClearSharedClientAfterStartupAbandon(error) {
-	return isCodexAppServerStartupError(error);
-}
 function shouldClearSharedClientAfterStartupRace(error) {
-	return shouldClearSharedClientAfterStartupAbandon(error) || isCodexAppServerRequestTimeoutError(error);
+	return isCodexAppServerStartupError(error) || isCodexAppServerRequestTimeoutError(error);
 }
 function shouldClearSharedClientAfterStartupFailure(params) {
+	if (isCodexAppServerOverloadError(params.error)) return false;
 	return isCodexAppServerBrokenPipeError(params.error) || !params.spawnedBy;
 }
 //#endregion
@@ -7296,6 +7516,7 @@ async function startCodexAttemptRuntime(resources) {
 	const developerInstructions = joinPresentSections(turnState.promptBuild.developerInstructions, attemptTools.scheduledConfiguredMcp?.diagnosticNotice);
 	const { params, attemptClientFactory, bindingStore, appServer, pluginConfig, computerUseConfig, startupClientAuthProfileId, runtimeArtifactRequest, startupPreparedAuth, agentDir, sessionAgentId, effectiveWorkspace, effectiveCwd, sandbox, runAbortController, usesSupervisionConnection, resolveReviewerPolicyContext, resolveRuntimeOptionsForCurrentBinding, startupAuthProfileId, startupAuthRequirement, abortFromUpstream } = connection;
 	let pluginAppServer = withCodexAppServerFastModeServiceTier(appServer, runtimeParams);
+	const loopDetectionEnabled = (sessionAgentId && params.config ? resolveAgentConfig$1(params.config, sessionAgentId)?.tools?.loopDetection?.enabled : void 0) ?? params.config?.tools?.loopDetection?.enabled ?? false;
 	try {
 		emitCodexAppServerEvent(params, {
 			stream: "codex_app_server.lifecycle",
@@ -7330,6 +7551,7 @@ async function startCodexAttemptRuntime(resources) {
 			developerInstructions,
 			agentWorkspaceDeveloperInstructions: context.agentWorkspaceDeveloperInstructions,
 			buildFinalConfigPatch: buildNativeHookRelayFinalConfigPatch,
+			nativeHookRelayRequired: connection.options.nativeHookRelay?.enabled !== false && params.pluginHarnessToolPolicyRestricted !== true && connection.nativeHookRelayEvents.includes("pre_tool_use") && (hasBeforeToolCallPolicy() || appServer.loopDetectionPreToolUseRelay && Boolean(connection.sandboxSessionKey) && loopDetectionEnabled),
 			bundleMcpThreadConfig,
 			configuredMcpOwnershipVersion: attemptTools.configuredMcpOwnershipVersion,
 			nativeToolSurfaceEnabled,
@@ -7436,7 +7658,7 @@ function isAuthorityResolutionOperationAbort(error, signal) {
 }
 async function prepareCodexAttemptTools(runtime) {
 	const { connection, bundleMcpThreadConfig, bundleManifestRegistry, runtimeParams, effectiveRuntimeModelId, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, hookChannelId, codexMcpToolOverrides, authenticatedScheduledMode, ownsScheduledConfiguredMcpSurface, canResolveScheduledConfiguredMcpCreatorAuthority } = runtime;
-	const { params, preDynamicStartupStages, mutable, startupAuthProfileId, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, sandbox, runAbortController, sessionAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
+	const { params, preDynamicStartupStages, mutable, startupAuthProfileId, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, sandbox, sessionPermissionPolicy, runAbortController, sessionAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
 	const preDynamicSummary = preDynamicStartupStages.snapshot();
 	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(preDynamicSummary)}`, {
 		runId: params.runId,
@@ -7479,6 +7701,7 @@ async function prepareCodexAttemptTools(runtime) {
 		...onCodexToolOutcome ? { onToolOutcome: onCodexToolOutcome } : {}
 	};
 	const computerContextEpoch = { value: 0 };
+	const runCleanups = [];
 	const cronCreatorToolAllowlist = [];
 	const cronCreatorToolAllowlistCaptureRef = {};
 	const scheduledAppAuthoritySourceRef = {};
@@ -7509,6 +7732,7 @@ async function prepareCodexAttemptTools(runtime) {
 		effectiveCwd,
 		sandboxSessionKey,
 		sandbox,
+		sessionPermissionPolicy,
 		nativeToolSurfaceEnabled,
 		nativeProviderWebSearchSupport,
 		runAbortController,
@@ -7539,6 +7763,7 @@ async function prepareCodexAttemptTools(runtime) {
 	};
 	const tools = await buildDynamicTools({
 		...commonToolParams,
+		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
 		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
 		cronCreatorToolAllowlistCaptureRef,
 		onPersistentWebSearchPolicyResolved: (allowed) => {
@@ -7759,6 +7984,7 @@ async function prepareCodexAttemptTools(runtime) {
 			dynamicToolParams,
 			compactionPlanState,
 			computerContextEpoch,
+			runCleanups,
 			toolBridge,
 			toolState,
 			toolOutcomeOrdinals,
@@ -8240,8 +8466,10 @@ function createCodexAttemptTurnWatchController(params) {
 	function scheduleAttemptIdleWatch() {
 		scheduleWatch("attempt", fireAttemptIdleTimeout, attemptLastProgressAt, attemptIdleTimeoutOverrideMs ?? turnAttemptIdleTimeoutMs, attemptIdleWatchArmed && !shouldPauseAttemptIdleWatch());
 	}
+	const terminalWorkIsActive = () => params.getActiveAppServerTurnRequests() > 0 || params.isTerminalTurnNotificationQueued() && params.getActiveFinalizationHookCount() > 0;
+	const terminalIdleTimeoutMs = () => params.isTerminalTurnNotificationQueued() && !terminalWorkIsActive() ? Math.min(TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS, turnTerminalIdleTimeoutMs) : turnTerminalIdleTimeoutMs;
 	function scheduleTerminalIdleWatch() {
-		scheduleWatch("terminal", fireTerminalIdleTimeout, completionLastActivityAt, turnTerminalIdleTimeoutMs, terminalIdleWatchArmed && params.getActiveAppServerTurnRequests() === 0);
+		scheduleWatch("terminal", fireTerminalIdleTimeout, completionLastActivityAt, terminalIdleTimeoutMs(), terminalIdleWatchArmed && (params.isTerminalTurnNotificationQueued() || params.getActiveAppServerTurnRequests() === 0));
 	}
 	function scheduleProgressWatches() {
 		scheduleAttemptIdleWatch();
@@ -8362,18 +8590,26 @@ function createCodexAttemptTurnWatchController(params) {
 		});
 	}
 	function fireTerminalIdleTimeout() {
-		if (params.isCompleted() || params.isTerminalTurnNotificationQueued() || params.signal.aborted || !terminalIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0) return;
+		if (params.isCompleted() || params.signal.aborted || !terminalIdleWatchArmed) return;
+		if (!params.isTerminalTurnNotificationQueued() && params.getActiveAppServerTurnRequests() > 0) {
+			scheduleTerminalIdleWatch();
+			return;
+		}
+		const timeoutMs = terminalIdleTimeoutMs();
 		const idleMs = Math.max(0, Date.now() - completionLastActivityAt);
-		if (idleMs < turnTerminalIdleTimeoutMs) {
+		if (idleMs < timeoutMs) {
 			scheduleTerminalIdleWatch();
 			return;
 		}
 		reportTimeout({
 			kind: "terminal",
 			idleMs,
-			timeoutMs: turnTerminalIdleTimeoutMs,
+			timeoutMs,
 			lastActivityReason: completionLastActivityReason,
-			details: completionLastActivityDetails
+			details: {
+				...completionLastActivityDetails,
+				terminalTurnNotificationQueued: params.isTerminalTurnNotificationQueued()
+			}
 		});
 	}
 	return {
@@ -8430,6 +8666,7 @@ function createCodexAttemptTurnWatchController(params) {
 			completionLastActivityReason = `notification:${method}`;
 			if (options?.details !== void 0) completionLastActivityDetails = options.details;
 			if (options?.attemptProgress) recordAttemptProgress(completionLastActivityReason, options);
+			if (params.isTerminalTurnNotificationQueued()) scheduleTerminalIdleWatch();
 		},
 		extendAttemptIdleWatch: (timeoutMs) => {
 			attemptIdleTimeoutOverrideMs = resolveWatchTimeoutMs(timeoutMs);
@@ -8452,6 +8689,7 @@ function createCodexAttemptTurnState(resources) {
 		latestStartupErrorNotification: void 0,
 		rateLimitsRevisionBeforeLastTurnStart: void 0,
 		completed: false,
+		abortCleanup: Promise.resolve(),
 		localCompletionRequested: false,
 		terminalTurnNotificationQueued: false,
 		sawCodexInterruptMarker: false,