@openclaw/codex 2026.8.1-beta.3 → 2026.8.2

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

@@ -1,42 +1,48 @@
-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 { 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 { 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-CcYL77O6.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-B1tT5U6r.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, i as createCodexSessionGenerationSupersededError, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore } from "./session-binding-D0zinCP1.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-CpVfwctT.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-B2r5vhWH.js";
+import { i as buildCodexPluginAppCacheKey, r as buildCodexAppServerRuntimeFingerprint, s as defaultCodexAppInventoryCache } from "./thread-resume-BFt1-ZDa.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-CGGKP720.js";
+import { l as isIncognitoSessionKey, r as retainCodexAppServerBindingSubscription } from "./thread-ownership-RkaoZCmQ.js";
+import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
+import { a as buildCodexUserPromptMessage, i as mirrorPromptAtTurnStartBestEffort, l as hasCodexMirrorOrigin, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, s as applyCodexTranscriptTaint, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-1ep4XjzF.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-D6m_TdVy.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-BqHEHXQJ.js";
+import { r as formatCodexDisplayText } from "./command-formatters--UToCokS.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-ScnAyG90.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-CF7BmrDk.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 CodexToolProgressProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as resolveCodexToolProgressDetailMode, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, s as inferCodexDynamicToolMeta, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexToolArguments } from "./native-subagent-monitor-vXYUZH37.js";
+import { n as readCodexMirroredSessionHistoryMessages } from "./session-history-C5J1AKzG.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-BmeXjwNZ.js";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-Bk3IUwod.js";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DQQm4gWT.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, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { prepareMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
@@ -68,6 +74,12 @@ function createCodexSteeringQueue(params) {
 	let sendChain = Promise.resolve();
 	let sealedError;
 	let closedError;
+	const assertActive = () => {
+		const unavailableError = closedError ?? sealedError;
+		if (unavailableError) throw unavailableError;
+		params.signal.throwIfAborted();
+		params.assertActive();
+	};
 	const clearBatchTimer = () => {
 		if (batchTimer) {
 			clearTimeout(batchTimer);
@@ -120,19 +132,20 @@ function createCodexSteeringQueue(params) {
 	const sendBatch = async (items) => {
 		const liveItems = items.filter((item) => !item.settled);
 		if (liveItems.length === 0) return;
-		const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-		if (unavailableError) {
-			for (const item of liveItems) rejectItem(item, unavailableError);
-			throw unavailableError;
-		}
-		const clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-		const batch = { items: liveItems };
-		dispatchedBatches.set(clientUserMessageId, batch);
+		let clientUserMessageId;
 		try {
+			assertActive();
+			const input = [];
+			for (const item of liveItems) {
+				input.push(...await params.prepareMessage(item.text, item));
+				assertActive();
+			}
+			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
+			dispatchedBatches.set(clientUserMessageId, { items: liveItems });
 			await params.client.request("turn/steer", {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
-				input: liveItems.flatMap((item) => buildCodexUserInput(item.text, item.images)),
+				input,
 				clientUserMessageId
 			}, {
 				timeoutMs: params.requestTimeoutMs,
@@ -140,8 +153,8 @@ function createCodexSteeringQueue(params) {
 			});
 			for (const item of liveItems) reportItemAcceptance(item, true);
 		} catch (error) {
-			dispatchedBatches.delete(clientUserMessageId);
-			const acceptedUnconfirmed = isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error);
+			if (clientUserMessageId) dispatchedBatches.delete(clientUserMessageId);
+			const acceptedUnconfirmed = clientUserMessageId !== void 0 && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error));
 			for (const item of liveItems) {
 				if (acceptedUnconfirmed) reportItemAcceptance(item, true);
 				rejectItem(item, error);
@@ -175,15 +188,12 @@ function createCodexSteeringQueue(params) {
 			rejectDelivery = reject;
 		});
 		const item = {
+			...options,
 			acceptance: "open",
 			text,
-			images: options?.images,
-			isInboundUserMessage: options?.isInboundUserMessage,
-			onQueueAccepted: options?.onQueueAccepted,
 			resolve: resolveDelivery,
 			reject: rejectDelivery,
-			settled: false,
-			userTurnTranscriptRecorder: options?.userTurnTranscriptRecorder
+			settled: false
 		};
 		pendingMessages.add(item);
 		return {
@@ -195,10 +205,11 @@ function createCodexSteeringQueue(params) {
 	if (params.signal.aborted) abortQueue();
 	return {
 		async queue(text, options) {
-			const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-			if (unavailableError) {
+			try {
+				assertActive();
+			} catch (error) {
 				options?.onQueueAccepted?.(false);
-				throw unavailableError;
+				throw error;
 			}
 			const { item, delivery } = createPendingMessage(text, options);
 			batchedMessages.push(item);
@@ -242,15 +253,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 +274,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 +308,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 +317,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 +349,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 +380,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 +424,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 +440,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 +448,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 +503,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 +521,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 +530,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 +551,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 +570,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 +637,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 +649,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 +673,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 +702,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 +1029,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 +1112,7 @@ function buildCodexAttemptResult(input) {
 		turnId: input.turnId,
 		upstreamUserText: input.upstreamUserText,
 		reasoningText,
-		planText,
+		asyncMessages,
 		commentaryMessages,
 		toolMessages: input.toolTranscriptProjection.transcriptMessages,
 		lastAssistant,
@@ -1001,7 +1129,9 @@ function buildCodexAttemptResult(input) {
 	});
 	const toolMetas = input.toolProgressProjection.toolMetas;
 	const hadPotentialSideEffects = input.toolTelemetry.didSendViaMessagingTool || Boolean(input.toolTelemetry.successfulCronAdds || input.toolTelemetry.acceptedSessionSpawns?.length) || input.generatedMediaProjection.hasGeneratedMedia() || input.toolProgressProjection.hasPotentialSideEffects;
-	return {
+	const sentMediaUrls = new Set(input.toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
+	const toolAutoDeliveryMediaUrls = input.toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
+	const result = {
 		terminal: attemptTerminal.normalize({
 			aborted: input.aborted,
 			promptError,
@@ -1048,8 +1178,83 @@ function buildCodexAttemptResult(input) {
 		yieldDetected: input.yieldDetected || false,
 		didSendDeterministicApprovalPrompt: input.guardianReviewCount > 0 ? false : void 0
 	};
+	const transferTtsProvenance = resolveCodexTtsProvenanceTransfer(input.runParams.hostCapabilities);
+	for (const toolResult of input.toolTelemetry.coreTtsToolResults ?? []) transferTtsProvenance?.(toolResult, result, toolAutoDeliveryMediaUrls ?? []);
+	return result;
 }
 //#endregion
+//#region extensions/codex/src/app-server/transcript-checkpoint.ts
+/** Commits completed work in receipt order without waiting for the enclosing turn. */
+var CodexTranscriptCheckpoint = class {
+	constructor(params, threadId, turnId) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.pending = [];
+		this.commentaryItemIds = /* @__PURE__ */ new Set();
+		this.lastTimestamp = 0;
+		this.writing = Promise.resolve();
+		this.tainted = false;
+		this.closed = false;
+		this.nextTimestamp = () => {
+			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
+			return this.lastTimestamp;
+		};
+		this.enqueueCommentary = (itemId, entry) => {
+			if (this.params.config?.ui?.prefs?.chatPersistCommentary === false || this.commentaryItemIds.has(itemId)) return;
+			this.commentaryItemIds.add(itemId);
+			this.enqueue({
+				...entry,
+				read: () => {
+					const message = entry.read();
+					return message ? attachCodexMirrorIdentity(message, `${this.turnId}:commentary:${itemId}`) : void 0;
+				}
+			});
+		};
+		this.enqueue = (entry) => {
+			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
+		};
+	}
+	flush(close = false) {
+		if (this.closed) return this.writing;
+		this.closed = close;
+		this.writing = this.writing.then(async () => {
+			const blocked = close ? -1 : this.pending.findIndex((entry) => entry.ready?.() === false);
+			const count = blocked < 0 ? this.pending.length : blocked;
+			if (count === 0) return;
+			const taint = { tainted: this.tainted };
+			const messages = this.pending.slice(0, count).flatMap((entry) => {
+				const message = entry.read();
+				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
+					hidden: this.params.trigger === "memory",
+					message: applyCodexTranscriptTaint(message, taint)
+				})] : [];
+			});
+			try {
+				await codexTranscriptMirrorRuntime.mirror({
+					...this.params.sessionTarget,
+					sessionId: this.params.sessionId,
+					cwd: this.params.workspaceDir,
+					messages,
+					idempotencyScope: `codex-app-server:${this.threadId}`,
+					runId: this.params.runId,
+					runMirrorIdentityPrefix: `${this.turnId}:`,
+					config: this.params.config
+				});
+				this.pending.splice(0, count);
+				this.tainted = taint.tainted;
+			} catch (error) {
+				embeddedAgentLog.warn("failed to checkpoint codex app-server transcript", {
+					runId: this.params.runId,
+					sessionId: this.params.sessionId,
+					error: formatErrorMessage(error)
+				});
+			}
+		});
+		return this.writing;
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/usage-limit-error.ts
 /**
 * Enriches Codex usage-limit failures with current rate-limit information and
@@ -1204,7 +1409,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 +1422,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 +1492,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 +1515,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 +1528,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 +1549,7 @@ var CodexAppServerEventProjector = class {
 						this.contextTokensSource = this.params.authoredContextTokenCap === void 0 ? "runtime" : "runtime-configured";
 					}
 					this.emitAgentEvent({
-						stream: "codex_app_server.usage",
+						stream: "usage",
 						data
 					});
 				});
@@ -1340,10 +1558,14 @@ var CodexAppServerEventProjector = class {
 				await this.handleTurnCompleted(params);
 				break;
 			case "rawResponse/completed":
-				this.responseCompletions.record(params);
+				this.responseCompletions.record(params, this.params.hostCapabilities.reportOutputTokens);
 				break;
 			case "rawResponseItem/completed":
 				await this.handleRawResponseItemCompleted(params);
+				await this.transcriptCheckpoint.flush();
+				break;
+			case "model/rerouted":
+				this.eventProjection.handleModelRerouted(params);
 				break;
 			case "error": {
 				this.responseCompletions.clear();
@@ -1363,13 +1585,10 @@ 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;
-			default:
-				this.diagnostics.warnUnknownEvent(notification, params);
-				break;
+			default: this.diagnostics.warnUnknownEvent(notification, params);
 		}
 	}
 	buildResult(toolTelemetry, options) {
@@ -1495,7 +1714,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 +1746,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 +1794,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 +1809,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 +1825,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 +1887,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 +1896,30 @@ 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 metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
+	const visibility = asOptionalRecord(metadata?.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);
+	const appContext = asOptionalRecord(item.appContext);
+	const uri = normalizeOptionalString(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 +1957,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 +1994,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 +2018,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,
@@ -1821,9 +2055,9 @@ function createCodexNativeMcpAppResultDetailsPreparer(params) {
 const RESTORED_PLAN_PREAMBLE = "OpenClaw restored the session progress card after context compaction. This is application state, not a new user request. Continue the current task and call progress_card whenever the status meaningfully changes.";
 const PROGRESS_CARD_MAX_STEPS = 50;
 const PROGRESS_CARD_MAX_STEP_UTF8_BYTES = 512;
-const PROGRESS_CARD_MAX_UTF8_BYTES = 8 * 1024;
-const RESTORED_PLAN_MAX_MARKDOWN_BYTES = 2 * 1024;
-const RESTORED_PLAN_MAX_PAYLOAD_BYTES = 32 * 1024;
+const PROGRESS_CARD_MAX_UTF8_BYTES = 8192;
+const RESTORED_PLAN_MAX_MARKDOWN_BYTES = 2048;
+const RESTORED_PLAN_MAX_PAYLOAD_BYTES = 32768;
 const RESTORED_PLAN_TRUNCATION_SUFFIX = "…";
 function canonicalizeNativeProgressCardInput(input) {
 	const markdown = input.markdown === void 0 ? void 0 : truncateUtf8(stripInvisibleUnicode(input.markdown), PROGRESS_CARD_MAX_UTF8_BYTES);
@@ -1833,8 +2067,10 @@ function canonicalizeNativeProgressCardInput(input) {
 		const text = truncateUtf8(stripInvisibleUnicode(step.step), PROGRESS_CARD_MAX_STEP_UTF8_BYTES);
 		if (!text.trim()) continue;
 		let status = step.status;
-		if (status === "in_progress") if (hasInProgressStep) status = "pending";
-		else hasInProgressStep = true;
+		if (status === "in_progress") {
+			if (hasInProgressStep) status = "pending";
+			else hasInProgressStep = true;
+		}
 		plan.push({
 			step: text,
 			status
@@ -1903,7 +2139,8 @@ function serializePlan(plan) {
 }
 function truncateUtf8(value, maxBytes) {
 	if (Buffer$1.byteLength(value, "utf8") <= maxBytes) return value;
-	return `${truncateUtf8Prefix(value, maxBytes - Buffer$1.byteLength(RESTORED_PLAN_TRUNCATION_SUFFIX, "utf8"))}${RESTORED_PLAN_TRUNCATION_SUFFIX}`;
+	const suffixBytes = Buffer$1.byteLength(RESTORED_PLAN_TRUNCATION_SUFFIX, "utf8");
+	return `${truncateUtf8Prefix(value, maxBytes - suffixBytes)}${RESTORED_PLAN_TRUNCATION_SUFFIX}`;
 }
 function readPlanSteps(value) {
 	if (!Array.isArray(value)) return [];
@@ -1923,7 +2160,7 @@ function isPlanStatus(value) {
 //#endregion
 //#region extensions/codex/src/app-server/user-input-bridge.ts
 /** Owns per-turn Codex request_user_input and ordinary MCP elicitation lifecycles. */
-const DEFAULT_USER_INPUT_TIMEOUT_MS = 15 * 6e4;
+const DEFAULT_USER_INPUT_TIMEOUT_MS = 9e5;
 const NONBLOCKING_USER_INPUT_TIMEOUT_MS = 12e4;
 const MAX_USER_INPUT_QUESTIONS = 3;
 const MAX_USER_INPUT_OPTIONS = 4;
@@ -2047,7 +2284,10 @@ function createCodexUserInputBridge(params) {
 				failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
 				run: async (signal) => {
 					const result = await execute(compiled.input, timeoutMs, signal);
-					if (result.status === "answered") return createCodexElicitationResponse("accept", compiled.input.kind === "ready" && compiled.input.plan.kind === "url" ? null : result.content);
+					if (result.status === "answered") {
+						const content = compiled.input.kind === "ready" && compiled.input.plan.kind === "url" ? null : result.content;
+						return createCodexElicitationResponse("accept", content);
+					}
 					if (result.status === "declined") return declineElicitation(result.message);
 					if (result.status === "unsupported") return declineElicitation(result.message);
 					return cancelValue;
@@ -2166,7 +2406,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const { context, turnState } = prompt;
 	const { runtime, attemptTools } = context;
 	const { connection } = runtime;
-	const { params, runAbortController, terminalState, abortExplicitly, abortFromUpstream, bindingStore, bindingIdentity, sessionAgentId, sandboxSessionKey, contextSessionKey, effectiveCwd } = connection;
+	const { params, runAbortController, terminalState, abortExplicitly, abortFromUpstream, bindingStore, bindingIdentity, sessionAgentId, contextSessionKey, effectiveCwd } = connection;
 	const { dynamicToolParams, compactionPlanState, computerContextEpoch, toolBridge } = attemptTools;
 	const { state, userInputBridgeRef, steeringQueueRef, turnWatches, completeTurn, interruptTurn } = turnRuntime;
 	const { emitExecutionPhaseOnce, emitLifecycleStart, maybeAnnounceFastModeAutoOff } = lifecycle;
@@ -2208,6 +2448,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 +2515,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: contextSessionKey,
+		cwd: effectiveCwd,
+		threadId: resourceState.thread.threadId,
+		turnId: activeTurnId,
+		upstreamUserText: turnState.codexTurnPromptText
+	});
+	await promptMirrorPromise;
 	if (resourceState.turnRoute) try {
 		await resourceState.turnRoute.bindTurn(activeTurnId);
 	} catch (error) {
@@ -2289,41 +2551,66 @@ 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;
+			const transcriptItems = items.filter((item) => item.isInboundUserMessage === true || item.userTurnTranscriptRecorder !== void 0);
+			if (transcriptItems.length === 0) return;
 			await promptMirrorPromise;
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
-			if (params.sessionTarget && messages.length > 0) 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
-			});
-			for (const item of inboundItems) {
+			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 transcriptItems) {
 				const recorder = item.userTurnTranscriptRecorder;
 				if (!recorder) continue;
 				await recorder.persistApproved();
@@ -2333,7 +2620,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 +2635,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,7 +2660,17 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const handle = {
 		kind: "embedded",
 		runId: params.runId,
+		startedAtMs: params.startedAtMs,
 		toolAuthorityFingerprint: params.toolAuthorityFingerprint,
+		permissionChangeOwner: params.permissionChange?.owner,
+		applyPermissionMode: async (mode, revokeApprovals) => {
+			if (!params.permissionChange || terminalState.terminalOutcomeFrozen || params.abortSignal?.aborted || !state.permissionChangeRestart && (state.completed || runAbortController.signal.aborted)) return false;
+			const applied = params.permissionChange.request(mode);
+			state.permissionChangeRestart ??= "requested";
+			runAbortController.abort("permission-change");
+			revokeApprovals();
+			return await applied;
+		},
 		claimPendingUserInputAnswer,
 		cancelPendingUserInput,
 		queueMessage,
@@ -2383,7 +2684,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,10 +2713,23 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			})().finally(completeTurn);
 			return;
 		}
-		interruptTurn(activeTurnId).finally(completeTurn);
+		state.abortCleanup = interruptTurn(activeTurnId).then(async (confirmed) => {
+			if (!terminalState.explicitCancellationObserved && !state.permissionChangeRestart) return;
+			if (!confirmed) throw new Error(state.permissionChangeRestart ? "Permission change could not confirm the previous Codex turn stopped." : "Codex cancellation could not confirm the turn stopped; background terminals may still be running.");
+			await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
+			if (state.permissionChangeRestart) state.permissionChangeRestart = "confirmed";
+		});
+		state.abortCleanup.then(completeTurn, (error) => {
+			embeddedAgentLog.warn("codex app-server cancellation cleanup failed", { error });
+			completeTurn();
+		});
 	};
 	runAbortController.signal.addEventListener("abort", abortListener, { once: true });
 	if (runAbortController.signal.aborted) abortListener();
+	else if (params.permissionChange && !params.permissionChange.applied()) {
+		state.permissionChangeRestart = "requested";
+		runAbortController.abort("permission-change");
+	}
 	return {
 		activeTurnId,
 		activeProjector,
@@ -2437,6 +2751,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();
@@ -2457,18 +2773,14 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			aborted: runAbortController.signal.aborted && !state.clientClosedAbort
 		});
 		await runCleanupStep("codex-trajectory-flush", () => trajectoryRecorder?.flush());
-		const retainLiveIncognitoThread = terminalState.turnSucceeded && isIncognitoSessionKey(params.sessionKey);
+		const retainLiveIncognitoThread = (terminalState.turnSucceeded || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && 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 +2798,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 +2823,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,125 +2897,26 @@ 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;
 const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_TOKENS = 8e3;
 const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_RATIO = .5;
-const CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES = 64 * 1024;
+const CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES = 65536;
 const CODEX_APP_SERVER_BYTE_UNITS = {
 	b: 1,
 	k: 1024,
 	kb: 1024,
 	kib: 1024,
-	m: 1024 * 1024,
-	mb: 1024 * 1024,
-	mib: 1024 * 1024,
-	g: 1024 * 1024 * 1024,
-	gb: 1024 * 1024 * 1024,
-	gib: 1024 * 1024 * 1024,
-	t: 1024 * 1024 * 1024 * 1024,
-	tb: 1024 * 1024 * 1024 * 1024,
-	tib: 1024 * 1024 * 1024 * 1024
+	m: 1048576,
+	mb: 1048576,
+	mib: 1048576,
+	g: 1073741824,
+	gb: 1073741824,
+	gib: 1073741824,
+	t: 1099511627776,
+	tb: 1099511627776,
+	tib: 1099511627776
 };
 const codexSessionRecordCache = /* @__PURE__ */ new Map();
 function parseCodexAppServerByteLimit(value) {
@@ -2994,11 +3213,12 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const requirementsToml = readCodexRequirementsToml({});
 	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
-	const { sessionAgentId } = resolveSessionAgentIds({
+	const { sessionAgentId } = resolveSessionAgentIdsStrict({
 		sessionKey: params.sessionKey,
 		config: params.config,
 		agentId: params.agentId
 	});
+	const policyAgentId = params.sandboxAgentId ?? sessionAgentId;
 	preDynamicStartupStages.mark("config");
 	const resolvedWorkspace = resolveUserPath(params.workspaceDir);
 	await ensureCodexWorkspaceDirOnce(resolvedWorkspace);
@@ -3007,6 +3227,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const contextSessionKey = params.sessionKey?.trim() || sandboxSessionKey;
 	const sandbox = params.sandbox !== void 0 ? params.sandbox : await resolveSandboxContext({
 		config: params.config,
+		agentId: params.sandboxAgentId,
 		sessionKey: sandboxSessionKey,
 		workspaceDir: resolvedWorkspace
 	});
@@ -3017,18 +3238,24 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		execOverrides: params.execOverrides,
 		approvals: params.permissionMode === "full" ? void 0 : loadExecApprovals(),
 		config: params.config,
-		agentId: sessionAgentId
+		agentId: policyAgentId
 	});
 	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
 	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
 	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
+	const assertLocalTargetSupported = (unsupported) => {
+		if (preparedEnvironment?.localProcessEnv && unsupported) throw new Error("This runtime cannot target the diagnosed local installation. Use the saved prompt with a suggested external or manual handoff on this machine.");
+	};
+	assertLocalTargetSupported(sandbox?.enabled === true || remoteExec);
 	const preparedShellEnvironment = preparedEnvironment ? {
 		...preparedEnvironment.credentialScrubEnv,
-		...!remoteExec ? preparedEnvironment.localIdentityEnv : void 0
+		...!remoteExec ? preparedEnvironment.localIdentityEnv : void 0,
+		...preparedEnvironment.localProcessEnv
 	} : void 0;
 	const shellEnvironment = preparedShellEnvironment && Object.keys(preparedShellEnvironment).length > 0 ? preparedShellEnvironment : void 0;
-	const disableLoginShell = remoteExec || preparedEnvironment?.managedLocalIdentity === true || preparedEnvironment !== void 0 && Object.keys(preparedEnvironment.credentialScrubEnv).length > 0;
+	const disableLoginShell = remoteExec || preparedEnvironment?.localProcessEnv !== void 0 || preparedEnvironment?.managedLocalIdentity === true || preparedEnvironment !== void 0 && Object.keys(preparedEnvironment.credentialScrubEnv).length > 0;
 	const withPreparedProcessEnv = (appServer) => {
+		assertLocalTargetSupported(appServer.start.transport === "websocket" || Boolean(appServer.remoteWorkspaceRoot));
 		return shellEnvironment ? {
 			...appServer,
 			start: {
@@ -3150,6 +3377,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const sessionPermissionCwd = resolveCodexSessionPermissionCwd({
 		permissionMode: params.permissionMode,
 		sessionRoot: params.sessionRoot,
+		defaultRoot: effectiveWorkspace,
 		requestedCwd,
 		fallbackCwd: effectiveWorkspace
 	});
@@ -3160,14 +3388,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 +3414,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 +3482,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
@@ -3271,6 +3520,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		pluginConfig,
 		computerUseConfig,
 		sessionAgentId,
+		policyAgentId,
 		resolvedWorkspace,
 		sandboxSessionKey,
 		contextSessionKey,
@@ -3290,6 +3540,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		effectiveWorkspace,
 		effectiveCwd,
 		appServer,
+		sessionPermissionPolicy,
 		nativeHookRelayEvents,
 		runAbortController,
 		terminalState,
@@ -3327,7 +3578,7 @@ const CODEX_BOOTSTRAP_CONTEXT_ORDER = /* @__PURE__ */ new Map([
 /** Reads mirrored Codex session history for harness hooks. */
 async function readMirroredSessionHistoryMessages(params) {
 	const { admission, ...target } = params;
-	const messages = await readCodexMirroredSessionHistoryMessages(target, admission);
+	const messages = await readCodexMirroredSessionHistoryMessages(target, admission, "model-context");
 	if (!messages) embeddedAgentLog.warn("failed to read mirrored session history for codex harness hooks", { sessionFile: params.sessionFile });
 	return messages;
 }
@@ -3813,8 +4064,9 @@ async function renderCodexWorkspaceMemoryCollaborationInstructions(params) {
 	return sections.length > 0 ? sections.join("\n\n") : void 0;
 }
 async function renderCodexMemoryRecallInstructions(params) {
+	const availableTools = new Set(params.toolNames);
 	const memoryPrompt = await prepareMemorySystemPromptAddition({
-		availableTools: new Set(params.toolNames),
+		availableTools,
 		citationsMode: params.citationsMode,
 		agentId: params.agentId,
 		agentSessionKey: params.agentSessionKey,
@@ -4011,7 +4263,7 @@ function buildCodexAppServerTimeoutDiagnostics(params) {
 //#region extensions/codex/src/app-server/run-attempt-context.ts
 async function prepareCodexAttemptContext(runtime, attemptTools) {
 	const { connection, runtimeParams, activeSessionId, activeSessionFile, buildActiveRunAttemptParams, effectiveContextWindowInfo, effectiveContextTokenBudget, effectiveRuntimeProviderId, effectiveRuntimeModelId, hookChannelId } = runtime;
-	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, sandboxSessionKey, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart, sandbox } = connection;
+	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart, sandbox } = connection;
 	const { toolBridge } = attemptTools;
 	const activeTranscriptTarget = {
 		agentId: sessionAgentId,
@@ -4037,7 +4289,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	const hookContext = {
 		runId: params.runId,
 		agentId: sessionAgentId,
-		sessionKey: sandboxSessionKey,
+		sessionKey: contextSessionKey,
 		sessionId: params.sessionId,
 		workspaceDir: params.workspaceDir,
 		messageProvider: params.messageProvider ?? void 0,
@@ -4345,101 +4597,17 @@ function isInvalidCodexImagePayloadError(message) {
 	return /\b(?:invalid|malformed)\b[\s\S]{0,120}\b(?:image|image url|base64)\b/iu.test(normalizedMessage) || /\b(?:image|image url|base64)\b[\s\S]{0,120}\b(?:invalid|malformed)\b/iu.test(normalizedMessage);
 }
 //#endregion
-//#region extensions/codex/src/app-server/settled-turn-context.ts
-function collectUniqueMessageIdentities(messages) {
-	const identities = /* @__PURE__ */ new Map();
-	for (const [index, message] of messages.entries()) {
-		const identity = readMirrorIdentity(message);
-		if (!identity) continue;
-		if (identities.has(identity)) return;
-		identities.set(identity, index);
-	}
-	return identities;
-}
-function adoptPersistedHostPrompt(params) {
-	const promptIdentity = `${params.turnId}:prompt`;
-	if (params.mirroredMessages.some((message) => readMirrorIdentity(message) === promptIdentity)) return params;
-	const sourcePrompt = params.settledMessages[0];
-	const sourceKey = sourcePrompt?.idempotencyKey;
-	if (sourcePrompt?.role !== "user" || readMirrorIdentity(sourcePrompt) !== promptIdentity || typeof sourceKey !== "string" || sourceKey.trim().length === 0) return params;
-	const matches = params.historyMessages.flatMap((message, index) => message.role === "user" && message.idempotencyKey === sourceKey ? [{
-		index,
-		message
-	}] : []);
-	const persistedPrompt = matches.length === 1 ? matches[0] : void 0;
-	const persistedMetadata = persistedPrompt?.message;
-	if (!persistedPrompt || readMirrorIdentity(persistedPrompt.message) !== void 0 || readCodexMirrorSourceFingerprint(persistedPrompt.message) !== void 0 || persistedMetadata?.["__openclaw"]?.mirrorOrigin === "codex-app-server") return params;
-	const sourceUpstreamText = readUpstreamUserText(sourcePrompt);
-	const persistedUpstreamText = readUpstreamUserText(persistedPrompt.message);
-	if (persistedUpstreamText !== void 0 && persistedUpstreamText !== sourceUpstreamText) return params;
-	let logicalPrompt = attachCodexMirrorIdentity(persistedPrompt.message, promptIdentity);
-	if (sourceUpstreamText !== void 0) logicalPrompt = attachUpstreamUserText(logicalPrompt, sourceUpstreamText);
-	if (serializeCodexMirrorSourceEvidence(logicalPrompt) !== serializeCodexMirrorSourceEvidence(sourcePrompt)) return params;
-	const historyMessages = [...params.historyMessages];
-	historyMessages[persistedPrompt.index] = logicalPrompt;
-	return {
-		historyMessages,
-		mirroredMessages: [logicalPrompt, ...params.mirroredMessages]
-	};
-}
-/** Freezes one complete active transcript branch through the settled tool-result boundary. */
-function buildCodexSettledTurnFinalizationContext(params) {
-	const { historyMessages, mirroredMessages } = adoptPersistedHostPrompt(params);
-	const boundaryMessage = params.settledMessages.findLast((message) => message.role === "toolResult");
-	const boundaryIdentity = boundaryMessage ? readMirrorIdentity(boundaryMessage) : void 0;
-	if (!boundaryMessage || !boundaryIdentity || !boundaryIdentity.startsWith(`${params.turnId}:tool:`)) return;
-	const settledBoundaryIndex = params.settledMessages.indexOf(boundaryMessage);
-	const requiredIdentities = params.settledMessages.slice(0, settledBoundaryIndex + 1).map(readMirrorIdentity);
-	if (requiredIdentities.length === 0 || requiredIdentities.some((identity) => !identity) || new Set(requiredIdentities).size !== requiredIdentities.length || !requiredIdentities.includes(`${params.turnId}:prompt`)) return;
-	const historyIdentities = collectUniqueMessageIdentities(historyMessages);
-	const mirroredIdentities = collectUniqueMessageIdentities(mirroredMessages);
-	if (!historyIdentities || !mirroredIdentities) return;
-	const mirroredBoundaryIndex = mirroredIdentities.get(boundaryIdentity);
-	if (mirroredBoundaryIndex === void 0) return;
-	const mirroredThroughBoundary = mirroredMessages.slice(0, mirroredBoundaryIndex + 1);
-	if (mirroredThroughBoundary.length !== requiredIdentities.length || mirroredThroughBoundary.some((message, index) => readMirrorIdentity(message) !== requiredIdentities[index])) return;
-	const historyBoundaryIndex = historyIdentities.get(boundaryIdentity);
-	if (historyBoundaryIndex === void 0) return;
-	let previousHistoryIndex = -1;
-	for (const mirroredMessage of mirroredThroughBoundary) {
-		const identity = readMirrorIdentity(mirroredMessage);
-		const historyIndex = identity ? historyIdentities.get(identity) : void 0;
-		const historyMessage = historyIndex === void 0 ? void 0 : historyMessages[historyIndex];
-		if (historyIndex === void 0 || historyIndex <= previousHistoryIndex || historyIndex > historyBoundaryIndex || !historyMessage || serializeCodexMirrorSourceEvidence(historyMessage) !== serializeCodexMirrorSourceEvidence(mirroredMessage)) return;
-		previousHistoryIndex = historyIndex;
-	}
-	return {
-		source: "openclaw-transcript",
-		messages: Object.freeze(structuredClone(params.historyMessages.slice(0, historyBoundaryIndex + 1)))
-	};
-}
-/** Reads and freezes the current active transcript branch after mirroring has settled. */
-async function captureCodexSettledTurnFinalizationContext(params) {
-	try {
-		const historyMessages = await readCodexMirroredSessionHistoryMessages(params);
-		if (!historyMessages) return;
-		return buildCodexSettledTurnFinalizationContext({
-			historyMessages,
-			mirroredMessages: params.mirroredMessages,
-			settledMessages: params.settledMessages,
-			turnId: params.turnId
-		});
-	} catch (error) {
-		embeddedAgentLog.warn("codex settled-turn finalization context capture failed", {
-			error: formatErrorMessage(error),
-			turnId: params.turnId
-		});
-		return;
-	}
-}
-//#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
 /** Creates a trajectory recorder when the host exposes its capture capability. */
 function createCodexTrajectoryRecorder(params) {
 	if (!params.trajectory) return null;
 	const trajectory = params.trajectory;
 	return {
-		recordEvent: trajectory.recordEvent,
+		recordEvent: (type, data) => {
+			try {
+				trajectory.recordEvent(type, data);
+			} catch {}
+		},
 		flush: trajectory.flush
 	};
 }
@@ -4501,7 +4669,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 +4677,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();
@@ -4638,14 +4819,13 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		turnId: activeTurnId
 	});
 	const { assistantTranscriptOwned, assistantTranscriptIdempotencyKey, terminalAnchor } = mirrorOutcome;
-	const shouldCaptureSettledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed);
-	const settledTurnFinalizationContext = shouldCaptureSettledTurnFinalizationContext ? await captureCodexSettledTurnFinalizationContext({
+	const settledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed) ? await captureCodexSettledTurnFinalizationContext({
 		...activeTranscriptTarget,
 		mirroredMessages: mirrorOutcome.mirroredMessages,
 		settledMessages: result.messagesSnapshot,
 		turnId: activeTurnId
-	}) : void 0;
-	if (shouldCaptureSettledTurnFinalizationContext && !settledTurnFinalizationContext) embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
+	}) ?? Object.freeze({ source: "unavailable" }) : void 0;
+	if (settledTurnFinalizationContext?.source === "unavailable") embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
 		threadId: resourceState.thread.threadId,
 		turnId: activeTurnId
 	});
@@ -4680,20 +4860,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
 	});
@@ -4757,8 +4928,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			yielded: toolState.yieldDetected
 		})
 	});
-	const finalizedResult = {
-		...result,
+	const finalizedResult = Object.assign(result, {
 		...toolState.yieldAcknowledgment ? { yieldAcknowledgment: toolState.yieldAcknowledgment } : {},
 		terminal: attemptTerminal.normalize({
 			timedOut: effectiveTimedOut,
@@ -4776,7 +4946,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		...resourceState.runtimeContinuationStarted ? { runtimeContinuationStarted: true } : {},
 		...!finalAborted && !effectiveTimedOut && !finalPromptError && preparedAuthBinding ? { authBindingFingerprint: preparedAuthBinding.fingerprint } : {},
 		systemPromptReport
-	};
+	});
 	if (turnSucceeded && toolState.yieldDetected && !runAbortController.signal.aborted) resourceState.nativeHookRelay?.authorizeRetentionAfterSuccessfulYield();
 	return finalizedResult;
 }
@@ -4860,9 +5030,10 @@ function applyCodexTurnNotificationState(params) {
 	else if (shouldArmNoToolPostProgressReplyWatch || shouldArmNoToolPostRawProgressReplyWatch) armPostProgressReplyWatch();
 	else if (trackedDynamicToolCompletion) armPostToolContinuationWatch();
 	else if (unblockedAssistantCompletionRelease) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
-	else if (shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) if (shouldUsePostToolContinuationWatch) armPostToolContinuationWatch();
-	else turnWatches.armCompletionIdleWatch();
-	else if (rawResponseItemCompletedWithNoActiveItems) turnWatches.armCompletionIdleWatch();
+	else if (shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) {
+		if (shouldUsePostToolContinuationWatch) armPostToolContinuationWatch();
+		else turnWatches.armCompletionIdleWatch();
+	} else if (rawResponseItemCompletedWithNoActiveItems) turnWatches.armCompletionIdleWatch();
 	else if (isCurrentTurnNotification && rawToolOutputCompletion) armPostToolContinuationWatch();
 	else if (isCurrentTurnNotification && shouldDisarmAssistantCompletionIdleWatch(notification)) turnWatches.disarmAssistantCompletionIdleWatch();
 	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolProgressNeedsTerminalGuard && !postToolPatchUpdateNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmNoToolPostProgressReplyWatch && !shouldArmNoToolPostRawProgressReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
@@ -4976,7 +5147,7 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		state.lifecycleStarted = true;
 	};
 	const emitLifecycleTerminal = (data) => {
-		if (!state.lifecycleStarted || state.lifecycleTerminalEmitted) return;
+		if (!state.lifecycleStarted || state.lifecycleTerminalEmitted || state.permissionChangeRestart) return;
 		emitCodexAppServerEvent(params, {
 			stream: "lifecycle",
 			data: {
@@ -5224,7 +5395,6 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-prompt.ts
-const CODEX_META_KEY = "__openclaw";
 function isRestrictivePromptToolsAllow(toolsAllow) {
 	return toolsAllow !== void 0 && !toolsAllow.some((name) => name.trim() === "*");
 }
@@ -5323,7 +5493,7 @@ async function prepareCodexAttemptPrompt(context) {
 				if (isRestrictivePromptToolsAllow(toolsAllow)) throw new Error("Codex app-server cannot enforce before_prompt_build toolsAllow; use the embedded or Copilot runtime for turn-scoped tool policy.");
 				return promptState.developerInstructions;
 			} },
-			messages: structuredClone(historyState.messages),
+			messages: historyState.messages,
 			ctx: hookContext,
 			bootstrapContextRunKind: params.bootstrapContextRunKind,
 			toolAuthority: {
@@ -5401,11 +5571,9 @@ async function prepareCodexAttemptPrompt(context) {
 		const cutoff = Date.parse(binding.historyCoveredThrough ?? "");
 		return historyState.messages.filter((message) => {
 			if (message.role !== "user" && message.role !== "assistant") return false;
-			const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
-			const mirrorIdentity = meta && typeof meta === "object" && !Array.isArray(meta) ? meta.mirrorIdentity : void 0;
-			const mirrorOrigin = meta && typeof meta === "object" && !Array.isArray(meta) ? meta.mirrorOrigin : void 0;
+			const mirrorIdentity = readMirrorIdentity(message);
 			const timestamp = typeof message.timestamp === "number" ? message.timestamp : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
-			return !("idempotencyKey" in message && typeof message.idempotencyKey === "string" && message.idempotencyKey.startsWith("codex-app-server:")) && mirrorOrigin !== "codex-app-server" && !(typeof mirrorIdentity === "string" && mirrorIdentity.startsWith("codex-app-server:")) && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
+			return !("idempotencyKey" in message && typeof message.idempotencyKey === "string" && message.idempotencyKey.startsWith("codex-app-server:")) && !hasCodexMirrorOrigin(message) && !mirrorIdentity?.startsWith("codex-app-server:") && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
 		});
 	};
 	const applyResumeStaleBindingContinuityProjection = (binding) => {
@@ -5437,7 +5605,8 @@ async function prepareCodexAttemptPrompt(context) {
 		return projected;
 	};
 	const applyNoContextEngineContinuityProjection = (action, binding) => {
-		if (activeContextEngine || !historyState.messages.some((message) => message.role === "user")) return false;
+		const hasContinuity = historyState.messages.some((message) => message.role === "user" || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
+		if (activeContextEngine || !hasContinuity) return false;
 		if (action === "resumed" && promptState.precomputedStaleBindingContinuityProjectionApplied) return true;
 		if (action === "started" && promptState.staleBindingContinuityForcedFreshStart) return true;
 		if (action === "started" && promptState.inactiveThreadBootstrapBindingForcedFreshStart) return false;
@@ -5530,7 +5699,7 @@ function prepareCodexAttemptResources(prompt) {
 	const { context, turnState, buildRenderedCodexDeveloperInstructions } = prompt;
 	const { runtime, attemptTools } = context;
 	const { connection, hookChannelId } = runtime;
-	const { appServer, params, effectiveCwd, sessionAgentId, sandboxSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
+	const { appServer, params, effectiveCwd, sessionAgentId, contextSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
 	const { toolBridge } = attemptTools;
 	const trajectoryRecorder = createCodexTrajectoryRecorder({
 		attempt: params,
@@ -5570,7 +5739,7 @@ function prepareCodexAttemptResources(prompt) {
 		emitCodexNativePreToolUseFailureDiagnostic({
 			agentId: sessionAgentId,
 			sessionId: params.sessionId,
-			sessionKey: sandboxSessionKey,
+			sessionKey: contextSessionKey,
 			runId: params.runId,
 			signal: runAbortController.signal,
 			failure,
@@ -5692,7 +5861,7 @@ function prepareCodexAttemptResources(prompt) {
 			events: nativeHookRelayEvents,
 			agentId: sessionAgentId,
 			sessionId: params.sessionId,
-			sessionKey: sandboxSessionKey,
+			sessionKey: contextSessionKey,
 			config: params.config,
 			runId: params.runId,
 			channelId: hookChannelId,
@@ -5854,10 +6023,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 +6089,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);
@@ -5953,7 +6118,8 @@ async function readCurrentCodexScheduledAppPolicy$1(params) {
 	};
 }
 function readToolApprovalMode(config, appId, toolName, fallback = "auto") {
-	return normalizeAppToolApprovalMode(asOptionalRecord(asOptionalRecord(asOptionalRecord(asOptionalRecord(config.apps)?.[appId])?.tools)?.[toolName])?.approval_mode) ?? fallback;
+	const app = asOptionalRecord(asOptionalRecord(config.apps)?.[appId]);
+	return normalizeAppToolApprovalMode(asOptionalRecord(asOptionalRecord(app?.tools)?.[toolName])?.approval_mode) ?? fallback;
 }
 /** Captures only apps callable on the exact active Codex client/thread. */
 async function captureScheduledCodexAppAuthority(params) {
@@ -6071,7 +6237,8 @@ function intersectCodexPluginThreadConfigWithScheduledAuthority(config, authorit
 			destructiveApprovalMode: stricterApprovalMode(defaultApprovalMode(current), captured.destructiveApprovalMode)
 		};
 	}
-	const policyContext = buildPluginAppPolicyContext(apps, Object.fromEntries(Object.entries(config.policyContext.pluginAppIds).map(([key, ids]) => [key, ids.filter((id) => Object.hasOwn(apps, id))]).filter(([, ids]) => ids.length > 0)));
+	const pluginAppIds = Object.fromEntries(Object.entries(config.policyContext.pluginAppIds).map(([key, ids]) => [key, ids.filter((id) => Object.hasOwn(apps, id))]).filter(([, ids]) => ids.length > 0));
+	const policyContext = buildPluginAppPolicyContext(apps, pluginAppIds);
 	const configPatch = buildCodexPluginAppsConfigPatchFromPolicyContext(policyContext);
 	const appsPatch = asOptionalRecord(configPatch.apps);
 	for (const [appId, captured] of capturedById) {
@@ -6140,7 +6307,7 @@ function resolveCodexAttemptBundleManifestRegistry(preparedModelRuntime) {
 	return metadataSnapshot?.pluginIds === void 0 ? metadataSnapshot?.manifestRegistry : void 0;
 }
 async function prepareCodexAttemptRuntime(connection) {
-	const { params, pluginConfig, usesSupervisionConnection, appServer, startupAuthProfileId, startupPreparedAuth, startupClientAuthProfileId, agentDir, preDynamicStartupStages, effectiveWorkspace, contextSessionKey, sandboxSessionKey, sessionAgentId, sandbox, attemptClientFactory, runAbortController, activeContextEngine, mutable } = connection;
+	const { params, pluginConfig, usesSupervisionConnection, appServer, startupAuthProfileId, startupPreparedAuth, startupClientAuthProfileId, agentDir, preDynamicStartupStages, effectiveWorkspace, contextSessionKey, sandboxSessionKey, sessionAgentId, policyAgentId, sandbox, attemptClientFactory, runAbortController, activeContextEngine, mutable } = connection;
 	const preparedAuthBinding = !usesSupervisionConnection && appServer.start.homeScope !== "user" && startupAuthProfileId ? await prepareCodexAppServerAuthBinding({
 		authProfileId: startupAuthProfileId,
 		authProfileStore: params.authProfileStore,
@@ -6244,7 +6411,7 @@ async function prepareCodexAttemptRuntime(connection) {
 	preDynamicStartupStages.mark("bundle-mcp");
 	const sandboxExecServerEnabled = isCodexSandboxExecServerEnabled(pluginConfig, sandbox);
 	const nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(runtimeParams, sandbox, {
-		agentId: sessionAgentId,
+		agentId: policyAgentId,
 		runtimeSessionKey: sandboxSessionKey,
 		sandboxExecServerEnabled
 	});
@@ -6518,6 +6685,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 +6708,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 +6717,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						sessionId: params.sessionId,
 						sessionKey: params.sessionKey
 					});
-					return handleDynamicToolCallWithTimeout({
+					const response = await handleDynamicToolCallWithTimeout({
 						call,
 						toolBridge,
 						signal,
@@ -6570,6 +6739,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 +6765,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 +6777,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 +6853,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-D9pYp4zL.js");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6711,19 +6883,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 +6918,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 +6936,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 +7031,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 +7064,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 +7176,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 +7190,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 +7295,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 +7390,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 +7427,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 +7446,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 +7464,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 +7499,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,
@@ -7367,11 +7537,12 @@ async function startCodexAttemptRuntime(resources) {
 		if (usesSupervisionConnection && (state.thread.connectionScope !== "supervision" || state.thread.supervisionSourceThreadId !== connection.mutable.startupBinding?.supervisionSourceThreadId)) throw new Error("Codex supervised thread lost its private connection ownership");
 		if (state.thread.lifecycle.action === "started" || state.thread.lifecycle.action === "forked") {
 			const activePolicy = resolveReviewerPolicyContext(state.thread);
+			const activeConfig = resolveRuntimeOptionsForCurrentBinding({
+				modelProvider: activePolicy.modelProvider,
+				model: activePolicy.model
+			});
 			const activeAppServer = resolveCodexAppServerForModelProvider({
-				appServer: resolveRuntimeOptionsForCurrentBinding({
-					modelProvider: activePolicy.modelProvider,
-					model: activePolicy.model
-				}),
+				appServer: activeConfig,
 				provider: activePolicy.modelProvider,
 				model: activePolicy.model,
 				config: params.config,
@@ -7436,7 +7607,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, contextSessionKey, sandbox, sessionPermissionPolicy, runAbortController, sessionAgentId, policyAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
 	const preDynamicSummary = preDynamicStartupStages.snapshot();
 	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(preDynamicSummary)}`, {
 		runId: params.runId,
@@ -7479,6 +7650,7 @@ async function prepareCodexAttemptTools(runtime) {
 		...onCodexToolOutcome ? { onToolOutcome: onCodexToolOutcome } : {}
 	};
 	const computerContextEpoch = { value: 0 };
+	const runCleanups = [];
 	const cronCreatorToolAllowlist = [];
 	const cronCreatorToolAllowlistCaptureRef = {};
 	const scheduledAppAuthoritySourceRef = {};
@@ -7509,10 +7681,12 @@ async function prepareCodexAttemptTools(runtime) {
 		effectiveCwd,
 		sandboxSessionKey,
 		sandbox,
+		sessionPermissionPolicy,
 		nativeToolSurfaceEnabled,
 		nativeProviderWebSearchSupport,
 		runAbortController,
 		sessionAgentId,
+		policyAgentId,
 		pluginConfig,
 		profilerEnabled,
 		...params.cronCreatorAuthorityUnavailableReason === "queued-local-operator" && bundleMcpThreadConfig.staticServerNames.length > 0 ? { cronCreatorAuthorityUnavailableReason: "queued-local-operator-configured-mcp" } : {},
@@ -7539,6 +7713,7 @@ async function prepareCodexAttemptTools(runtime) {
 	};
 	const tools = await buildDynamicTools({
 		...commonToolParams,
+		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
 		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
 		cronCreatorToolAllowlistCaptureRef,
 		onPersistentWebSearchPolicyResolved: (allowed) => {
@@ -7560,7 +7735,7 @@ async function prepareCodexAttemptTools(runtime) {
 		runSessionKey: params.sessionKey && params.sessionKey !== sandboxSessionKey ? params.sessionKey : void 0,
 		sessionId: params.sessionId,
 		runId: params.runId,
-		agentId: sessionAgentId,
+		agentId: policyAgentId,
 		agentDir: agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId),
 		agentAccountId: params.agentAccountId,
 		messageProvider: params.messageProvider ?? params.messageChannel,
@@ -7650,7 +7825,7 @@ async function prepareCodexAttemptTools(runtime) {
 			remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
 			remoteWorkspaceRequestTimeoutMs: connection.appServer.requestTimeoutMs,
 			sessionId: params.sessionId,
-			sessionKey: sandboxSessionKey,
+			sessionKey: contextSessionKey,
 			runId: params.runId,
 			channelId: hookChannelId,
 			currentChannelProvider: resolveCodexMessageToolProvider(params),
@@ -7759,6 +7934,7 @@ async function prepareCodexAttemptTools(runtime) {
 			dynamicToolParams,
 			compactionPlanState,
 			computerContextEpoch,
+			runCleanups,
 			toolBridge,
 			toolState,
 			toolOutcomeOrdinals,
@@ -8240,8 +8416,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 +8540,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 +8616,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 +8639,8 @@ function createCodexAttemptTurnState(resources) {
 		latestStartupErrorNotification: void 0,
 		rateLimitsRevisionBeforeLastTurnStart: void 0,
 		completed: false,
+		abortCleanup: Promise.resolve(),
+		permissionChangeRestart: void 0,
 		localCompletionRequested: false,
 		terminalTurnNotificationQueued: false,
 		sawCodexInterruptMarker: false,