@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

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

@@ -1,42 +1,51 @@
-import { C as isCodexRemoteExecPlacementSandbox, E as resolveCodexPluginsPolicy, M as isCodexAppServerApprovalPolicyAllowedByRequirements, N as resolveOpenClawExecPolicyForCodexAppServer, S as withMcpElicitationsApprovalPolicy, T as readCodexPluginConfig, c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, h as resolveCodexAppServerHomeScope, i as createCodexSessionGenerationSupersededError, j as resolveCodexModelBackedReviewerPolicyContext, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore, v as resolveCodexComputerUseConfig, w as isCodexSandboxExecServerEnabled, x as shouldAutoApproveCodexAppServerApprovals } from "./session-binding-DPxIvMgE.js";
-import { $ as resolveCodexAppServerAuthProfileId, A as isCodexAppServerApprovalRequest, C as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, D as resolveCodexTurnTerminalIdleTimeoutMs, E as resolveCodexTurnCompletionIdleTimeoutMs, G as protectCodexAppServerLiveThread, H as ensureCodexAppServerClientRuntime, I as isCodexAppServerRequestTimeoutError, M as isCodexAppServerConnectionClosedError, N as isCodexAppServerIndeterminateRequestCancellationError, O as withCodexStartupTimeout, P as isCodexAppServerIndeterminateTransportError, Q as resolveCodexAppServerAuthAccountCacheKey, R as resolveCodexAppServerClientInstanceId, T as resolveCodexTurnAssistantCompletionIdleTimeoutMs, X as readRecentCodexRateLimits, Y as readCodexRateLimitsRevision, Z as rememberCodexRateLimitsRead, a as getLeasedSharedCodexAppServerClient, b as CodexAppServerStartupError, ct as isJsonObject, et as resolveCodexAppServerAuthProfileIdForAgent, f as retainSharedCodexAppServerClientIfCurrent, g as withAbortableTimeout, j as isCodexAppServerBrokenPipeError, k as getCodexAppServerClientInstanceId, l as releaseLeasedSharedCodexAppServerClient, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, nt as resolveCodexAppServerPreparedApiKeyCacheKey, o as getSharedCodexAppServerClient, p as retireSharedCodexAppServerClientIfCurrent, q as retainCodexAppServerLiveThread, rt as resolveCodexAppServerPreparedAuthHandoff, s as isCodexAppServerStartSelectionChangedError, st as flattenCodexDynamicToolFunctions, t as clearSharedCodexAppServerClientIfCurrent, tt as resolveCodexAppServerFallbackApiKeyCacheKey, ut as resolveCodexAppServerHomeDir, w as resolveCodexStartupTimeoutMs, x as isCodexAppServerStartupError, y as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.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-DMLXUfa8.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-e5huIQWu.js";
-import { l as readCodexTurn, o as assertCodexTurnStartResponse, s as readCodexDynamicToolCallParams, u as readCodexTurnCompletedNotification } from "./protocol-validators-B4F7L8Rf.js";
-import { i as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-C3H2CVp6.js";
-import { A as resolveCodexDynamicToolsLoadingForRuntime, B as buildCodexPluginThreadConfigInputFingerprint, C as codexLegacyDynamicToolsFingerprint, D as isSystemAgentOnlyCodexDynamicToolAllowlist, F as projectContextEngineAssemblyForCodex, G as shouldBuildCodexPluginThreadConfig, I as resolveCodexContextEngineProjectionMaxChars, L as resolveCodexContextEngineProjectionReserveTokens, M as isContextEngineBindingCompatible, N as fitCodexProjectedContextForTurnStart, P as neutralizeCodexExplicitMentionSigils, R as buildCodexPluginAppsConfigPatchFromPolicyContext, S as codexDynamicToolsFingerprint, U as buildPluginAppPolicyContext, V as buildCodexPluginThreadConfigTimeoutFallback, W as mergeCodexThreadConfigs, Z as resolveRecoverableCodexPluginConfigKeys, _ as resolveCodexAppServerThreadModelSelection, a as isCodexAppServerProfilerEnabled, f as resolveCodexWebSearchPlan, i as startOrResumeThread, j as buildContextEngineBinding, n as buildTurnStartParams, p as buildDeveloperInstructions, r as buildCodexUserInput, t as buildTurnCollaborationMode, w as filterCodexDynamicTools, x as areCodexDynamicToolFingerprintsCompatible, z as buildCodexPluginThreadConfig } from "./thread-lifecycle-Bu1BTDXr.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-ClRBije0.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-B9gGgnJS.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-CybGI1oz.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-DZXmOL8-.js";
-import { r as formatCodexDisplayText } from "./command-formatters-B1AEz8ZA.js";
-import { n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-zcBDc1JU.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-I5Bo-AsX.js";
-import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-B4FfbcCg.js";
-import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-B_2mnqhb.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-DyTGmTUx.js";
-import { A as buildCodexNativeHookRelayDisabledConfig, B as resolveDynamicToolCallTimeoutMs, C as shouldWarnCodexDynamicToolBuildStageSummary, E as CodexNativeToolLifecycleProjector, F as scheduleCodexNativeHookRelayUnregister, G as toCodexDynamicToolProtocolResponse, H as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, I as handleDynamicToolCallWithTimeout, K as resolveCodexToolAbortTerminalReason, L as hasPendingDynamicToolTerminalDiagnostic, M as emitCodexNativePreToolUseFailureDiagnostic, N as resolveCodexNativeHookRelayEvents, O as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, P as resolveCodexNativeHookRelayTtlMs, R as isDynamicToolTerminalDiagnosticEvent, S as shouldRequireCodexSandboxExecServerEnvironment, T as readBoundedCodexRemoteWorkspaceFile, U as shouldReleaseTurnAfterTerminalDynamicTool, V as resolveTerminalDynamicToolBatchAction, W as toCodexDynamicToolProgressResponse, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, b as resolveCodexSandboxEnvironmentSelection, c as resolveCodexProviderWebSearchSupport, d as releaseCodexSandboxExecServerEnvironment, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, j as createCodexNativeHookRelay, k as buildCodexNativeHookRelayConfig, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as handleCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as ensureCodexSandboxExecServerEnvironment, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, x as shouldEnableCodexAppServerNativeToolSurface, y as resolveCodexMessageToolProvider, z as isMatchingDynamicToolTerminalDiagnostic } from "./dynamic-tools-BVdyWkUD.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, o as killStaleComputerUseMcpChildren, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-CNJPj4_b.js";
+import { C as isCodexRemoteExecPlacementSandbox, D as resolveOpenClawExecPolicyForCodexAppServer, E as resolveCodexPluginsPolicy, P as resolveCodexAppServerHomeDir, S as isCodexPairedNodeRemoteExecPlacementSandbox, T as readCodexPluginConfig, d as withMcpElicitationsApprovalPolicy, m as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig, p as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveCodexAppServerHomeScope, u as shouldAutoApproveCodexAppServerApprovals, v as readCodexRequirementsToml, w as isCodexSandboxExecServerEnabled } from "./config-Cxw3Cl3k.js";
+import { $ as CodexAppServerRpcError, A as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, B as resolveCodexTurnTerminalIdleTimeoutMs, Dt as readCodexRateLimitsRevision, Ft as resolveCodexAppServerFallbackApiKeyCacheKey, G as isCodexAppServerConnectionClosedError, H as getCodexAppServerClientInstanceId, Ht as isJsonObject, I as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, It as resolveCodexAppServerPreparedApiKeyCacheKey, J as isCodexAppServerOverloadError, K as isCodexAppServerIndeterminateRequestCancellationError, L as resolveCodexStartupTimeoutMs, Lt as resolveCodexAppServerPreparedAuthHandoff, M as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, Mt as resolveCodexAppServerAuthProfileId, N as TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS, Nt as resolveCodexAppServerAuthProfileIdForAgent, Ot as readRecentCodexRateLimits, P as isCodexAppServerStartupError, Q as resolveCodexAppServerClientInstanceId, R as resolveCodexTurnAssistantCompletionIdleTimeoutMs, Tt as withAbortableTimeout, U as isCodexAppServerApprovalRequest, V as withCodexStartupTimeout, Vt as flattenCodexDynamicToolFunctions, W as isCodexAppServerBrokenPipeError, X as isCodexAppServerRequestTimeoutError, _t as ensureCodexAppServerClientRuntime, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as resolveDynamicToolCallTimeoutMs, c as getLeasedSharedCodexAppServerClient, ct as shouldReleaseTurnAfterTerminalDynamicTool, dt as resolveCodexToolAbortTerminalReason, et as createCodexElicitationResponse, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, it as isMatchingDynamicToolTerminalDiagnostic, j as CodexAppServerStartupError, jt as resolveCodexAppServerAuthAccountCacheKey, kt as rememberCodexRateLimitsRead, l as getSharedCodexAppServerClient, lt as toCodexDynamicToolProgressResponse, nt as hasPendingDynamicToolTerminalDiagnostic, ot as resolveTerminalDynamicToolBatchAction, q as isCodexAppServerIndeterminateTransportError, rt as isDynamicToolTerminalDiagnosticEvent, s as createIsolatedCodexAppServerClient, st as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, tt as handleDynamicToolCallWithTimeout, u as isCodexAppServerStartSelectionChangedError, ut as toCodexDynamicToolProtocolResponse, v as retainSharedCodexAppServerClientIfCurrent, xt as protectCodexAppServerLiveThread, y as retireSharedCodexAppServerClientIfCurrent, z as resolveCodexTurnCompletionIdleTimeoutMs } from "./shared-client-kNkljY-R.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, i as createCodexSessionGenerationSupersededError, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore } from "./session-binding-q2WSTVmC.js";
+import { c as assertCodexTurnStartResponse, d as readCodexTurn, f as readCodexTurnCompletedNotification, l as readCodexDynamicToolCallParams } from "./protocol-validators-Bg5rpNxk.js";
+import { B as readNonNegativeInteger, D as itemStatus, E as itemName, H as splitPlanText, I as readItem, L as readItemString, M as extractRawAssistantText, P as readCodexErrorNotificationMessage, V as readNullableString, _ as readCodexNotificationThreadId, a as closeCodexStartupClientBestEffort, d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, g as isCodexNotificationForTurn, h as CodexProjectionDiagnostics, j as shouldSynthesizeToolProgressForItem, k as shouldClearTerminalPresentationForNativeItem, l as retireCodexAppServerClientAfterTimedOutTurn, m as getCodexAppServerTurnRouter, o as interruptCodexTurnAndWaitBestEffort, p as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-CVPvp9dL.js";
+import { C as readRawResponseToolCallId, E as updateActiveTurnItemIds, S as readNotificationItemId, T as updateActiveCompletionBlockerItemIds, _ as isReasoningItemCompletionNotification, a as codexExecutionToolName, b as isTerminalTurnStatus, c as isAssistantCompletionReleaseNotification, d as isNativeToolProgressNotification, f as isPendingOpenClawDynamicToolCompletionNotification, g as isRawToolOutputCompletionNotification, h as isRawReasoningCompletionNotification, l as isCodexTurnAbortMarkerNotification, m as isRawFunctionToolOutputCompletionNotification, o as describeNotificationActivity, p as isRawAssistantProgressNotification, r as projectCodexThreadUsageUpdate, s as isAssistantCommentaryCompletionNotification, t as CodexResponseCompletionProjection, u as isFileChangePatchUpdatedNotification, v as isReasoningProgressNotification, w as shouldDisarmAssistantCompletionIdleWatch, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-D3PHFFXh.js";
+import { i as buildCodexPluginAppCacheKey, r as buildCodexAppServerRuntimeFingerprint, s as defaultCodexAppInventoryCache } from "./thread-resume-DF54hagX.js";
+import { $ as resolveCodexContinuityProjectionMaxChars, B as isMessageOnlyCodexSourceReply, D as resolveCodexAppServerThreadModelSelection, F as codexDynamicToolsFingerprint, G as buildContextEngineBinding, I as codexLegacyDynamicToolsFingerprint, J as fitCodexProjectedContextForTurnStart, K as isContextEngineBindingCompatible, L as filterCodexDynamicTools, P as areCodexDynamicToolFingerprintsCompatible, Q as resolveCodexContextEngineProjectionReserveTokens, S as buildDeveloperInstructions, V as isSystemAgentOnlyCodexDynamicToolAllowlist, W as resolveCodexDynamicToolsLoadingForRuntime, X as projectContextEngineAssemblyForCodex, Y as neutralizeCodexExplicitMentionSigils, Z as resolveCodexContextEngineProjectionMaxChars, a as isCodexAppServerProfilerEnabled, at as buildPluginAppPolicyContext, c as buildCodexNativeHookRelayConfig, d as emitCodexNativePreToolUseFailureDiagnostic, et as buildCodexPluginAppsConfigPatchFromPolicyContext, f as resolveCodexNativeHookRelayEvents, i as startOrResumeThread, l as buildCodexNativeHookRelayDisabledConfig, m as scheduleCodexNativeHookRelayUnregister, n as buildTurnStartParams, nt as buildCodexPluginThreadConfigInputFingerprint, ot as mergeCodexThreadConfigs, p as resolveCodexNativeHookRelayTtlMs, pt as resolveRecoverableCodexPluginConfigKeys, q as buildCodexContinuityCalibration, r as buildCodexUserInput, rt as buildCodexPluginThreadConfigTimeoutFallback, s as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, st as shouldBuildCodexPluginThreadConfig, t as buildTurnCollaborationMode, tt as buildCodexPluginThreadConfig, u as createCodexNativeHookRelay, x as resolveCodexWebSearchPlan } from "./thread-lifecycle-Ss-uwnC4.js";
+import { l as isIncognitoSessionKey, r as retainCodexAppServerBindingSubscription } from "./thread-ownership-CeYBqg_4.js";
+import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
+import { a as buildCodexUserPromptMessage, i as mirrorPromptAtTurnStartBestEffort, l as readCodexMirrorSourceFingerprint, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, s as applyCodexTranscriptTaint, t as codexTranscriptMirrorRuntime, u as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-CkEQIna-.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-CGm_94eL.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-hFtzt2Up.js";
+import { r as formatCodexDisplayText } from "./command-formatters-C54Yg3eA.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-gLm40Vtq.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-CCQFs8lf.js";
+import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Ds_QVm-X.js";
+import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-BOeJf7yo.js";
+import { i as createAssistantMirrorMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-C5-Ds8mA.js";
+import { a as readCodexMirroredSessionHistoryMessages, c as inferCodexDynamicToolMeta, d as sanitizeCodexToolArguments, f as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as isCodexCommandBearingToolCall, n as CodexEventProjection, o as CodexToolProgressProjection, r as emitCodexAgentEvent, s as shouldEmitTranscriptToolProgress, t as codexNativeSubagentMonitorRuntime, u as resolveCodexToolProgressDetailMode } from "./native-subagent-monitor-CwFyoylz.js";
+import { C as shouldRequireCodexSandboxExecServerEnvironment, D as CodexNativeToolLifecycleProjector, E as readBoundedCodexRemoteWorkspaceFile, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as resolveCodexProviderWebSearchSupport, d as releaseCodexSandboxExecServerEnvironment, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as ensureCodexSandboxExecServerEnvironment, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-BFoUcRdx.js";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-CulOABwu.js";
 import { asBoolean, asFiniteNumber, asOptionalRecord, hasNonEmptyString, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, getBeforeToolCallPolicyDiagnosticState, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessGatewayQuestion, 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 { 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 { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { captureFinalCodexCronCreatorToolAllowlist, materializeStaticMcpToolsForScheduledHarnessRun, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { addAbortListener } from "node:events";
+import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
+import { captureFinalCodexCronCreatorToolAllowlist, materializeStaticMcpToolsForScheduledHarnessRun, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { prepareMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
+import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
-import { root } from "openclaw/plugin-sdk/file-access-runtime";
+import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
 import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
 //#region extensions/codex/src/app-server/attempt-steering.ts
 /**
@@ -63,6 +72,12 @@ function createCodexSteeringQueue(params) {
 	let sendChain = Promise.resolve();
 	let sealedError;
 	let closedError;
+	const assertActive = () => {
+		const unavailableError = closedError ?? sealedError;
+		if (unavailableError) throw unavailableError;
+		params.signal.throwIfAborted();
+		params.assertActive();
+	};
 	const clearBatchTimer = () => {
 		if (batchTimer) {
 			clearTimeout(batchTimer);
@@ -115,19 +130,20 @@ function createCodexSteeringQueue(params) {
 	const sendBatch = async (items) => {
 		const liveItems = items.filter((item) => !item.settled);
 		if (liveItems.length === 0) return;
-		const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-		if (unavailableError) {
-			for (const item of liveItems) rejectItem(item, unavailableError);
-			throw unavailableError;
-		}
-		const clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-		const batch = { items: liveItems };
-		dispatchedBatches.set(clientUserMessageId, batch);
+		let clientUserMessageId;
 		try {
+			assertActive();
+			const input = [];
+			for (const item of liveItems) {
+				input.push(...await params.prepareMessage(item.text, item));
+				assertActive();
+			}
+			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
+			dispatchedBatches.set(clientUserMessageId, { items: liveItems });
 			await params.client.request("turn/steer", {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
-				input: liveItems.flatMap((item) => buildCodexUserInput(item.text, item.images)),
+				input,
 				clientUserMessageId
 			}, {
 				timeoutMs: params.requestTimeoutMs,
@@ -135,8 +151,8 @@ function createCodexSteeringQueue(params) {
 			});
 			for (const item of liveItems) reportItemAcceptance(item, true);
 		} catch (error) {
-			dispatchedBatches.delete(clientUserMessageId);
-			const acceptedUnconfirmed = isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error);
+			if (clientUserMessageId) dispatchedBatches.delete(clientUserMessageId);
+			const acceptedUnconfirmed = clientUserMessageId !== void 0 && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error));
 			for (const item of liveItems) {
 				if (acceptedUnconfirmed) reportItemAcceptance(item, true);
 				rejectItem(item, error);
@@ -170,10 +186,9 @@ function createCodexSteeringQueue(params) {
 			rejectDelivery = reject;
 		});
 		const item = {
+			...options,
 			acceptance: "open",
 			text,
-			images: options?.images,
-			onQueueAccepted: options?.onQueueAccepted,
 			resolve: resolveDelivery,
 			reject: rejectDelivery,
 			settled: false
@@ -188,23 +203,11 @@ function createCodexSteeringQueue(params) {
 	if (params.signal.aborted) abortQueue();
 	return {
 		async queue(text, options) {
-			const unavailableError = closedError ?? sealedError ?? (params.signal.aborted ? /* @__PURE__ */ new Error("codex app-server steering queue aborted") : void 0);
-			if (unavailableError) {
+			try {
+				assertActive();
+			} catch (error) {
 				options?.onQueueAccepted?.(false);
-				throw unavailableError;
-			}
-			const pendingUserInput = options?.isInboundUserMessage === true ? params.claimPendingUserInput() : void 0;
-			if (pendingUserInput) {
-				if (!options?.images?.length) {
-					const answered = pendingUserInput.answer(text);
-					options?.onQueueAccepted?.(answered);
-					if (!answered) throw new Error("codex pending user input rejected the answer");
-					return;
-				}
-				flushBatch().catch(() => void 0);
-				const { item, delivery } = createPendingMessage(text, options);
-				await Promise.all([enqueueSend([item]).finally(() => pendingUserInput.cancel()), delivery]);
-				return;
+				throw error;
 			}
 			const { item, delivery } = createPendingMessage(text, options);
 			batchedMessages.push(item);
@@ -221,8 +224,21 @@ function createCodexSteeringQueue(params) {
 			const batch = dispatchedBatches.get(clientUserMessageId);
 			if (!batch) return false;
 			dispatchedBatches.delete(clientUserMessageId);
-			for (const item of batch.items) resolveItem(item);
-			return true;
+			for (const item of batch.items) reportItemAcceptance(item, true);
+			const resolveBatch = () => {
+				for (const item of batch.items) resolveItem(item);
+				return true;
+			};
+			const rejectBatch = (error) => {
+				for (const item of batch.items) rejectItem(item, error);
+				return true;
+			};
+			if (!params.beforeConfirmConsumed) return resolveBatch();
+			try {
+				return params.beforeConfirmConsumed(batch.items).then(resolveBatch, rejectBatch);
+			} catch (error) {
+				return rejectBatch(error);
+			}
 		},
 		sealAdmission: sealQueueAdmission,
 		cancel: cancelQueue
@@ -235,15 +251,17 @@ function normalizeCodexSteerDebounceMs(value) {
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
-	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp) {
+	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
 		this.params = params;
 		this.emitAgentEvent = emitAgentEvent;
 		this.matchesToolProgressEcho = matchesToolProgressEcho;
 		this.nextTranscriptTimestamp = nextTranscriptTimestamp;
+		this.checkpointCommentary = checkpointCommentary;
 		this.assistantTextByItem = /* @__PURE__ */ new Map();
 		this.assistantItemOrder = [];
 		this.assistantTimestampByItem = /* @__PURE__ */ new Map();
 		this.assistantPhaseByItem = /* @__PURE__ */ new Map();
+		this.assistantDeliveryByItem = /* @__PURE__ */ new Map();
 		this.latestTerminalAssistantCandidateSuperseded = false;
 		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
 		this.terminalAssistantCandidateEarlierActiveItemIds = /* @__PURE__ */ new Set();
@@ -253,6 +271,10 @@ var CodexAssistantProjection = class {
 		this.rawPromotedAssistantItemIds = /* @__PURE__ */ new Set();
 		this.assistantStarted = false;
 		this.streamedPartialAssistantItemReplaceable = false;
+		this.persistableAssistantBarrier = 0;
+		this.persistedAssistantBoundary = false;
+		this.persistableAssistantBarrierItemIds = /* @__PURE__ */ new Set();
+		this.completedAssistantItemIds = /* @__PURE__ */ new Set();
 	}
 	hasCompletedTerminalAssistantText(completedItemIds) {
 		const latestCompletedItemId = this.latestCompletedTerminalAssistantItemId;
@@ -284,7 +306,8 @@ var CodexAssistantProjection = class {
 		if (!delta) return;
 		if (itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		const isCommentary = this.isCommentaryAssistantItem(itemId);
-		if (!isCommentary && itemId !== this.latestTerminalAssistantCandidateItemId) this.markTerminalAssistantCandidateSupersededBy();
+		const isAsync = this.isAsyncAssistantItem(itemId);
+		if (!isCommentary && !isAsync && itemId !== this.latestTerminalAssistantCandidateItemId) this.markTerminalAssistantCandidateSupersededBy();
 		if (!this.assistantStarted) {
 			this.assistantStarted = true;
 			await this.params.onAssistantMessageStart?.();
@@ -292,6 +315,7 @@ var CodexAssistantProjection = class {
 		this.rememberAssistantItem(itemId);
 		const text = `${this.assistantTextByItem.get(itemId) ?? ""}${delta}`;
 		this.assistantTextByItem.set(itemId, text);
+		if (isAsync) return;
 		if (isCommentary) {
 			this.emitCommentaryProgress({
 				itemId,
@@ -322,23 +346,26 @@ var CodexAssistantProjection = class {
 		if (knownFinalAnswer && !replaceable) await this.params.onPartialReply?.(streamPayload);
 	}
 	recordItemStarted(item, itemId) {
-		if (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		this.noteNativeWorkBarrier(item);
 		this.rememberAssistantPhase(item);
+		if (item?.type === "agentMessage" && itemId && !this.isNonTerminalAssistantItem(itemId) && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		if (item?.type === "agentMessage" && 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 (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
-		if (itemId) this.latestCompletedItemId = itemId;
+		if (itemId && item?.type === "agentMessage") this.completedAssistantItemIds.add(itemId);
+		this.noteNativeWorkBarrier(item);
 		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;
 		}
@@ -351,14 +378,17 @@ var CodexAssistantProjection = class {
 					text: item.text
 				});
 				this.pendingRawCommentaryEchoes += 1;
-			} else if (item.text && this.isFinalAnswerAssistantItem(item.id)) this.emitAnswerCandidate(item.id, "candidate");
+			} else if (item.text && !this.isAsyncAssistantItem(item.id) && this.isFinalAnswerAssistantItem(item.id)) this.emitAnswerCandidate(item.id, "candidate");
+			return this.createAsyncDelivery(item.id);
 		}
 	}
 	recordSnapshotItem(item) {
+		if (item.type === "agentMessage") this.completedAssistantItemIds.add(item.id);
 		this.rememberAssistantPhase(item);
 		if (item.type === "agentMessage" && typeof item.text === "string") {
 			this.rememberAssistantItem(item.id);
 			this.assistantTextByItem.set(item.id, item.text);
+			return this.createAsyncDelivery(item.id);
 		}
 	}
 	handleRawResponseItemCompleted(item, activeItemIds) {
@@ -392,6 +422,7 @@ var CodexAssistantProjection = class {
 		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && activeItemIds.size === 0;
 		if (text && phase !== "commentary" && candidateWasSupersededBeforeRaw && itemId !== this.streamedPartialAssistantItemId && !isIdlessTerminalAssistantAfterCompletedWork) return;
 		if (phase) this.assistantPhaseByItem.set(itemId, phase);
+		this.completedAssistantItemIds.add(itemId);
 		this.rememberAssistantItem(itemId);
 		this.assistantTextByItem.set(itemId, text);
 		if (!text) return;
@@ -403,21 +434,64 @@ var CodexAssistantProjection = class {
 		else this.markLatestTerminalAssistantCandidate(itemId, activeItemIds, { canReleaseAfterToolHandoff: isIdlessTerminalAssistantAfterCompletedWork });
 	}
 	collectAssistantTexts() {
-		const finalText = this.resolveFinalAssistantTextItem()?.text;
-		return finalText ? [finalText] : [];
+		const afterHandoff = this.collectPersistableAssistantTexts(this.persistableAssistantBarrier);
+		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;
+		return recovered ? [recovered] : [];
 	}
 	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();
@@ -427,7 +501,7 @@ var CodexAssistantProjection = class {
 		const authoritativeIndex = turnItems.findLastIndex((item) => {
 			if (item.type !== "agentMessage" || typeof item.text !== "string" || item.text.trim().length === 0) return false;
 			const phase = readItemString(item, "phase");
-			return phase === "final_answer" || phase === void 0;
+			return readItemString(item, "delivery") !== "async" && (phase === "final_answer" || phase === void 0);
 		});
 		const authoritative = authoritativeIndex >= 0 ? turnItems[authoritativeIndex] : void 0;
 		if (turnItems.slice(authoritativeIndex + 1).some(shouldClearTerminalPresentationForNativeItem) || authoritative?.id === this.latestTerminalAssistantCandidateItemId && this.latestTerminalAssistantCandidateSuperseded) {
@@ -445,7 +519,7 @@ var CodexAssistantProjection = class {
 	hasAssistantItemTextForSynthesis() {
 		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
 			const itemId = this.assistantItemOrder[i];
-			if (!itemId || this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			if (!itemId || this.isNonTerminalAssistantItem(itemId)) continue;
 			const text = this.assistantTextByItem.get(itemId);
 			if (text && text.length > 0) return true;
 		}
@@ -454,7 +528,7 @@ var CodexAssistantProjection = class {
 	createCurrentAttemptAssistantMessage(options) {
 		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
 			const itemId = this.assistantItemOrder[i];
-			if (!itemId || this.isCommentaryAssistantItem(itemId) || !this.assistantTextByItem.has(itemId)) continue;
+			if (!itemId || this.isNonTerminalAssistantItem(itemId) || !this.assistantTextByItem.has(itemId)) continue;
 			const text = this.assistantTextByItem.get(itemId) ?? "";
 			const normalizedText = text.trim();
 			if (normalizedText && this.isToolProgressEchoText(itemId, normalizedText)) continue;
@@ -475,10 +549,18 @@ var CodexAssistantProjection = class {
 		if (item?.type !== "agentMessage") return;
 		const phase = readItemString(item, "phase");
 		if (phase) this.assistantPhaseByItem.set(item.id, phase);
+		const delivery = readItemString(item, "delivery");
+		if (delivery) this.assistantDeliveryByItem.set(item.id, delivery);
 	}
 	isCommentaryAssistantItem(itemId) {
 		return this.assistantPhaseByItem.get(itemId) === "commentary";
 	}
+	isAsyncAssistantItem(itemId) {
+		return this.assistantDeliveryByItem.get(itemId) === "async";
+	}
+	isNonTerminalAssistantItem(itemId) {
+		return this.isCommentaryAssistantItem(itemId) || this.isAsyncAssistantItem(itemId);
+	}
 	isFinalAnswerAssistantItem(itemId) {
 		return this.assistantPhaseByItem.get(itemId) === "final_answer";
 	}
@@ -486,7 +568,7 @@ var CodexAssistantProjection = class {
 		return this.assistantPhaseByItem.get(itemId) === "final_answer";
 	}
 	emitCommentaryProgress(params) {
-		const progressText = params.text.replace(/\s+/g, " ").trim();
+		const progressText = params.text.trim();
 		if (!progressText || this.lastCommentaryProgressTextByItem.get(params.itemId) === progressText) return;
 		this.lastCommentaryProgressTextByItem.set(params.itemId, progressText);
 		this.emitAgentEvent({
@@ -553,22 +635,104 @@ 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
 			};
 		}
 	}
+	collectPersistableAssistantTexts(minIndex) {
+		let texts = [];
+		let replaceable = false;
+		for (let index = minIndex; index < this.assistantItemOrder.length; index += 1) {
+			const itemId = this.assistantItemOrder[index];
+			if (!itemId || this.isNonTerminalAssistantItem(itemId)) continue;
+			const text = this.assistantTextByItem.get(itemId)?.trim();
+			if (!text || this.isToolProgressEchoText(itemId, text)) continue;
+			if (isSilentReplyPayloadText(text)) {
+				texts.push(text);
+				continue;
+			}
+			const isTerminalFinal = this.assistantPhaseByItem.get(itemId) === "final_answer";
+			if (!isTerminalFinal || replaceable) {
+				texts = [text];
+				replaceable = !isTerminalFinal;
+				continue;
+			}
+			texts.push(text);
+		}
+		return texts;
+	}
+	noteNativeWorkBarrier(item) {
+		if (!item || !shouldAdvancePersistableAssistantBarrier(item)) return;
+		if (item.id && this.persistableAssistantBarrierItemIds.has(item.id)) return;
+		if (item.id) this.persistableAssistantBarrierItemIds.add(item.id);
+		this.persistableAssistantBarrier = this.assistantItemOrder.length;
+	}
 	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);
 	}
 };
+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";
@@ -739,9 +903,10 @@ function isBase64WhitespaceCode(code) {
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-reasoning.ts
 var CodexReasoningProjection = class {
-	constructor(params, emitAgentEvent) {
+	constructor(params, emitAgentEvent, onNativePlanUpdate) {
 		this.params = params;
 		this.emitAgentEvent = emitAgentEvent;
+		this.onNativePlanUpdate = onNativePlanUpdate;
 		this.reasoningTextByGroup = /* @__PURE__ */ new Map();
 		this.reasoningItemOrder = /* @__PURE__ */ new Map();
 		this.planTextByItem = /* @__PURE__ */ new Map();
@@ -782,7 +947,7 @@ var CodexReasoningProjection = class {
 			}))
 		});
 	}
-	handleTurnPlanUpdated(params, source = "codex-app-server") {
+	async handleTurnPlanUpdated(params, source = "codex-app-server") {
 		const explanation = readNullableString(params, "explanation");
 		const plan = Array.isArray(params.plan) ? params.plan.flatMap((entry) => {
 			if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
@@ -796,6 +961,10 @@ var CodexReasoningProjection = class {
 		}) : void 0;
 		const planText = [explanation, ...(plan ?? []).map(({ step, status }) => `- [${status}] ${step}`)].filter((part) => Boolean(part)).join("\n");
 		if (planText) this.turnPlanText = planText;
+		if (source === "codex-app-server" && plan) await this.onNativePlanUpdate?.({
+			...typeof explanation === "string" ? { markdown: explanation } : {},
+			steps: plan
+		});
 		this.emitPlanUpdate({
 			explanation,
 			steps: plan
@@ -825,7 +994,7 @@ var CodexReasoningProjection = class {
 		return this.turnPlanText ?? [...this.planTextByItem.values()].filter((text) => text.trim().length > 0).join("\n\n");
 	}
 	emitPlanUpdate(params, source = "codex-app-server") {
-		if (!params.explanation && (!params.steps || params.steps.length === 0)) return;
+		if (!params.explanation && params.steps === void 0) return;
 		this.emitAgentEvent({
 			stream: "plan",
 			data: {
@@ -833,7 +1002,7 @@ var CodexReasoningProjection = class {
 				title: "Plan updated",
 				source,
 				...params.explanation ? { explanation: params.explanation } : {},
-				...params.steps && params.steps.length > 0 ? { steps: params.steps } : {}
+				...params.steps ? { steps: params.steps } : {}
 			}
 		});
 	}
@@ -858,50 +1027,64 @@ function reasoningMethodOrder(method) {
 const attemptTerminal = agentHarnessAttemptTerminal;
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
-function readTurnTaintMetadata(message) {
-	const metadata = message["__openclaw"];
-	return metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : 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();
-	const completedUsage = input.responseCompletions.usage ?? input.tokenUsage;
-	const projectedUsage = input.aborted ? input.tokenUsage : completedUsage;
+	const unavailableThreadUsage = input.tokenUsage ? {
+		...input.tokenUsage,
+		contextUsage: { state: "unavailable" }
+	} : void 0;
+	const completedUsage = input.responseCompletions.usage ?? (input.responseCompletions.modelIterations > 0 ? unavailableThreadUsage : input.tokenUsage);
+	const projectedUsage = input.aborted ? unavailableThreadUsage : completedUsage;
 	const hasAssistantItemText = input.assistantProjection.hasAssistantItemTextForSynthesis();
 	const legacyFailClosed = !input.completedTurn || input.completedTurn.status !== "completed" || hasAssistantItemText;
 	const hasDeliverableAssistantOnCompletedTurn = input.completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
@@ -927,7 +1110,7 @@ function buildCodexAttemptResult(input) {
 		turnId: input.turnId,
 		upstreamUserText: input.upstreamUserText,
 		reasoningText,
-		planText,
+		asyncMessages,
 		commentaryMessages,
 		toolMessages: input.toolTranscriptProjection.transcriptMessages,
 		lastAssistant,
@@ -976,6 +1159,7 @@ function buildCodexAttemptResult(input) {
 		acceptedSessionSpawns: input.toolTelemetry.acceptedSessionSpawns,
 		cloudCodeAssistFormatError: false,
 		contextTokens: input.contextTokens,
+		contextTokensSource: input.contextTokensSource,
 		attemptUsage: projectedUsage,
 		...input.completedCompactionCount > 0 ? { compactionCount: input.completedCompactionCount } : {},
 		replayMetadata: {
@@ -992,6 +1176,78 @@ function buildCodexAttemptResult(input) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/transcript-checkpoint.ts
+/** Commits completed work in receipt order without waiting for the enclosing turn. */
+var CodexTranscriptCheckpoint = class {
+	constructor(params, threadId, turnId) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.pending = [];
+		this.commentaryItemIds = /* @__PURE__ */ new Set();
+		this.lastTimestamp = 0;
+		this.writing = Promise.resolve();
+		this.tainted = false;
+		this.closed = false;
+		this.nextTimestamp = () => {
+			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
+			return this.lastTimestamp;
+		};
+		this.enqueueCommentary = (itemId, entry) => {
+			if (this.params.config?.ui?.prefs?.chatPersistCommentary === false || this.commentaryItemIds.has(itemId)) return;
+			this.commentaryItemIds.add(itemId);
+			this.enqueue({
+				...entry,
+				read: () => {
+					const message = entry.read();
+					return message ? attachCodexMirrorIdentity(message, `${this.turnId}:commentary:${itemId}`) : void 0;
+				}
+			});
+		};
+		this.enqueue = (entry) => {
+			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
+		};
+	}
+	flush(close = false) {
+		if (this.closed) return this.writing;
+		this.closed = close;
+		this.writing = this.writing.then(async () => {
+			const blocked = close ? -1 : this.pending.findIndex((entry) => entry.ready?.() === false);
+			const count = blocked < 0 ? this.pending.length : blocked;
+			if (count === 0) return;
+			const taint = { tainted: this.tainted };
+			const messages = this.pending.slice(0, count).flatMap((entry) => {
+				const message = entry.read();
+				return message ? [projectAgentHarnessTranscriptMessageForDisplay({
+					hidden: this.params.trigger === "memory",
+					message: applyCodexTranscriptTaint(message, taint)
+				})] : [];
+			});
+			try {
+				await codexTranscriptMirrorRuntime.mirror({
+					...this.params.sessionTarget,
+					sessionId: this.params.sessionId,
+					cwd: this.params.workspaceDir,
+					messages,
+					idempotencyScope: `codex-app-server:${this.threadId}`,
+					runId: this.params.runId,
+					runMirrorIdentityPrefix: `${this.turnId}:`,
+					config: this.params.config
+				});
+				this.pending.splice(0, count);
+				this.tainted = taint.tainted;
+			} catch (error) {
+				embeddedAgentLog.warn("failed to checkpoint codex app-server transcript", {
+					runId: this.params.runId,
+					sessionId: this.params.sessionId,
+					error: formatErrorMessage(error)
+				});
+			}
+		});
+		return this.writing;
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/usage-limit-error.ts
 /**
 * Enriches Codex usage-limit failures with current rate-limit information and
@@ -1146,8 +1402,10 @@ 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);
 		this.nativeToolLifecycleProjector = new CodexNativeToolLifecycleProjector(params, threadId, turnId, { runAbortSignal: options.runAbortSignal });
 		this.generatedMediaProjection = new CodexGeneratedMediaProjection(params.config, {
@@ -1157,22 +1415,38 @@ 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.reasoningProjection = new CodexReasoningProjection(params, (event) => this.emitAgentEvent(event));
-	}
-	nextTranscriptTimestamp() {
-		this.lastTranscriptTimestamp = Math.max(Date.now(), this.lastTranscriptTimestamp + 1);
-		return this.lastTranscriptTimestamp;
+		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);
 	}
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
 	}
+	buildSteeringTranscriptPrefix() {
+		const snapshot = buildCodexSteeringMessagesSnapshot({
+			runParams: this.params,
+			turnId: this.turnId,
+			upstreamUserText: this.options.upstreamUserText,
+			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);
 	}
@@ -1199,8 +1473,9 @@ var CodexAppServerEventProjector = class {
 		const ordinal = this.params.allocateToolOutcomeOrdinal?.(item.id);
 		if (ordinal !== void 0) this.nativeToolOutcomeOrdinals.set(item.id, ordinal);
 	}
-	recordNativeToolApprovalFailure(toolCallId, disposition) {
+	recordNativeToolApprovalFailure(toolCallId, disposition, approvalKind) {
 		this.nativeToolLifecycleProjector.recordApprovalFailureDisposition(toolCallId, disposition);
+		if (disposition === "timed_out" && approvalKind) this.toolProgressProjection.approvalTimeoutKinds.set(toolCallId, approvalKind);
 	}
 	recordNativeToolPreToolUseFailure(failure) {
 		this.nativeToolLifecycleProjector.recordPreToolUseFailure(failure);
@@ -1210,9 +1485,11 @@ 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);
 		this.assistantProjection.handleNotification(notification.method, params);
 		switch (notification.method) {
@@ -1227,13 +1504,15 @@ var CodexAppServerEventProjector = class {
 				this.reasoningProjection.handlePlanDelta(params);
 				break;
 			case "turn/plan/updated":
-				this.reasoningProjection.handleTurnPlanUpdated(params);
+				await this.reasoningProjection.handleTurnPlanUpdated(params);
 				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");
@@ -1242,18 +1521,28 @@ 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);
 				break;
 			case "thread/tokenUsage/updated":
 				projectCodexThreadUsageUpdate(params, this.tokenUsage, (usage) => this.tokenUsage = usage, (data) => {
-					this.contextTokens = data.modelContextWindow ?? this.contextTokens;
+					if (data.modelContextWindow !== void 0) {
+						this.contextTokens = data.modelContextWindow;
+						this.contextTokensSource = this.params.authoredContextTokenCap === void 0 ? "runtime" : "runtime-configured";
+					}
 					this.emitAgentEvent({
-						stream: "codex_app_server.usage",
+						stream: "usage",
 						data
 					});
 				});
@@ -1266,14 +1555,21 @@ var CodexAppServerEventProjector = class {
 				break;
 			case "rawResponseItem/completed":
 				await this.handleRawResponseItemCompleted(params);
+				await this.transcriptCheckpoint.flush();
+				break;
+			case "model/rerouted":
+				this.eventProjection.handleModelRerouted(params);
 				break;
-			case "error":
+			case "error": {
 				this.responseCompletions.clear();
 				if (params.willRetry === true) break;
-				this.settledTurnFailureFinalizationAllowed = (isJsonObject(params.error) ? params.error.codexErrorInfo : void 0) === "serverOverloaded";
+				const codexErrorInfo = isJsonObject(params.error) ? params.error.codexErrorInfo : void 0;
+				const compactionFailure = codexErrorInfo === "other" && this.isCompacting();
+				this.settledTurnFailureFinalizationAllowed = codexErrorInfo === "serverOverloaded" || compactionFailure;
 				this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
-				this.promptErrorSource = "prompt";
+				this.promptErrorSource = compactionFailure ? "compaction" : "prompt";
 				break;
+			}
 			case "thread/compacted":
 			case "turn/started":
 			case "turn/diff/updated":
@@ -1282,7 +1578,6 @@ var CodexAppServerEventProjector = class {
 			case "item/fileChange/outputDelta":
 			case "item/fileChange/patchUpdated":
 			case "item/mcpToolCall/progress":
-			case "model/rerouted":
 			case "model/verification":
 			case "turn/moderationMetadata":
 			case "model/safetyBuffering/updated": break;
@@ -1292,6 +1587,7 @@ var CodexAppServerEventProjector = class {
 		}
 	}
 	buildResult(toolTelemetry, options) {
+		this.eventProjection.flushPendingGuardianWarning();
 		return buildCodexAttemptResult({
 			runParams: this.params,
 			turnId: this.turnId,
@@ -1307,6 +1603,7 @@ var CodexAppServerEventProjector = class {
 			aborted: this.aborted,
 			tokenUsage: this.tokenUsage,
 			contextTokens: this.contextTokens,
+			contextTokensSource: this.contextTokensSource,
 			completedCompactionCount: this.completedCompactionCount,
 			activeItemCount: this.activeItemIds.size,
 			completedItemCount: this.completedItemIds.size,
@@ -1325,9 +1622,12 @@ var CodexAppServerEventProjector = class {
 	recordDynamicToolCall(params) {
 		this.toolTranscriptProjection.recordDynamicToolCall(params);
 	}
-	/** Projects a successful OpenClaw update_plan call through the native plan stream. */
-	recordDynamicPlanUpdate(params) {
-		if (isJsonObject(params)) this.reasoningProjection.handleTurnPlanUpdated(params, "openclaw");
+	/** Projects a successful OpenClaw progress_card call through the native plan stream. */
+	async recordDynamicProgressCardUpdate(params) {
+		if (isJsonObject(params)) {
+			const projected = { plan: Array.isArray(params.plan) ? params.plan : [] };
+			await this.reasoningProjection.handleTurnPlanUpdated(projected, "openclaw");
+		}
 	}
 	recordDynamicToolResult(params) {
 		this.toolProgressProjection.recordDynamicToolResult(params);
@@ -1409,13 +1709,15 @@ 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) {
 			this.activeCompactionItemIds.delete(itemId);
 			this.completedCompactionCount += 1;
-			this.options.onContextCompacted?.();
+			await this.options.onContextCompacted?.();
 			await runAgentHarnessAfterCompactionHook({
 				sessionFile: this.params.sessionFile,
 				messages: await this.toolTranscriptProjection.readMirroredSessionMessages(),
@@ -1431,17 +1733,17 @@ var CodexAppServerEventProjector = class {
 					channelId: this.params.messageChannel ?? this.params.messageProvider ?? void 0
 				}
 			});
-			this.emitAgentEvent({
-				stream: "compaction",
-				data: {
-					phase: "end",
-					backend: "codex-app-server",
-					completed: true,
-					threadId: this.threadId,
-					turnId: this.turnId,
-					itemId
-				}
+			await persistCodexContextCompactionActivity({
+				sessionTarget: this.params.sessionTarget,
+				config: this.params.config,
+				cwd: this.params.workspaceDir,
+				runId: this.params.runId,
+				threadId: this.threadId,
+				turnId: this.turnId,
+				itemId,
+				timestamp: this.transcriptCheckpoint.nextTimestamp()
 			});
+			this.eventProjection.emitCompactionEnd(itemId, true);
 		}
 		this.toolProgressProjection.recordToolMeta(item);
 		this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
@@ -1470,7 +1772,8 @@ var CodexAppServerEventProjector = class {
 		const turn = readCodexTurn(params.turn);
 		if (!turn || turn.id !== this.turnId) return;
 		this.completedTurn = turn;
-		this.settledTurnFailureFinalizationAllowed = turn.status === "failed" && turn.error?.codexErrorInfo === "serverOverloaded";
+		const compactionFailure = turn.status === "failed" && (this.promptErrorSource === "compaction" || turn.error?.codexErrorInfo === "other" && this.isCompacting());
+		this.settledTurnFailureFinalizationAllowed = turn.status === "failed" && (turn.error?.codexErrorInfo === "serverOverloaded" || compactionFailure);
 		if (turn.status !== "completed") this.responseCompletions.clear();
 		if (turn.status === "failed") {
 			const usageLimitMessage = formatCodexUsageLimitErrorMessage({
@@ -1479,9 +1782,18 @@ var CodexAppServerEventProjector = class {
 				rateLimits: this.options.readRecentRateLimits?.()
 			});
 			this.promptError = usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : turn.error?.message ?? "codex app-server turn failed";
-			this.promptErrorSource = "prompt";
+			this.promptErrorSource = compactionFailure ? "compaction" : "prompt";
+		}
+		if (compactionFailure) {
+			const failedCompactionItemIds = [...this.activeCompactionItemIds];
+			for (const itemId of failedCompactionItemIds) {
+				this.activeItemIds.delete(itemId);
+				this.activeCompactionItemIds.delete(itemId);
+				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;
@@ -1492,8 +1804,10 @@ var CodexAppServerEventProjector = class {
 			}
 		}
 		for (const item of turnItems) {
+			if (!this.asyncDeliveryProjection.allows(item)) continue;
 			this.diagnostics.warnUnknownItemStatus(item);
-			this.assistantProjection.recordSnapshotItem(item);
+			const asyncMessage = this.assistantProjection.recordSnapshotItem(item);
+			if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 			this.reasoningProjection.recordItem(item);
 			await this.generatedMediaProjection.recordNative(item);
 			this.toolProgressProjection.recordToolMeta(item);
@@ -1505,6 +1819,8 @@ var CodexAppServerEventProjector = class {
 			this.toolProgressProjection.emitToolResultSummary(item);
 			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();
@@ -1566,24 +1882,7 @@ var CodexAppServerEventProjector = class {
 		return usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : readCodexErrorNotificationMessage(params);
 	}
 	emitAgentEvent(event) {
-		try {
-			emitAgentEvent({
-				runId: this.params.runId,
-				stream: event.stream,
-				data: event.data,
-				...this.params.sessionKey ? { sessionKey: this.params.sessionKey } : {}
-			});
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
-		}
-		try {
-			const maybePromise = this.params.onAgentEvent?.(event);
-			Promise.resolve(maybePromise).catch((error) => {
-				embeddedAgentLog.debug("codex app-server agent event handler rejected", { error });
-			});
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
-		}
+		emitCodexAgentEvent(this.params, event);
 	}
 	isHookNotificationForCurrentThread(params) {
 		const threadId = readStringField(params, "threadId");
@@ -1592,11 +1891,28 @@ var CodexAppServerEventProjector = class {
 	}
 };
 //#endregion
+//#region extensions/codex/src/app-server/mcp-tool-metadata.ts
+/** Hosted app ownership is authoritative only on metadata supplied by Codex. */
+function readCodexMcpToolConnectorId(tool) {
+	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
+	return normalizeOptionalString(metadata?.connector_id) ?? normalizeOptionalString(metadata?.connectorId);
+}
+/** Preserve MCP App visibility so model-only tools cannot become widget authority. */
+function readCodexMcpToolUiVisibility(tool) {
+	const visibility = asOptionalRecord(asOptionalRecord(asOptionalRecord(tool)?.["_meta"])?.ui)?.visibility;
+	if (!Array.isArray(visibility)) return;
+	return [...new Set(visibility.filter((value) => value === "app" || value === "model"))].toSorted();
+}
+//#endregion
 //#region extensions/codex/src/app-server/native-mcp-app.ts
+const CODEX_APPS_MCP_SERVER$1 = "codex_apps";
 function readMcpAppResourceUri(item) {
 	const uri = normalizeOptionalString(asOptionalRecord(item.appContext)?.resourceUri) ?? normalizeOptionalString(item.mcpAppResourceUri);
 	return uri?.startsWith("ui://") ? uri : void 0;
 }
+function readMcpAppConnectorId(item) {
+	return normalizeOptionalString(asOptionalRecord(item.appContext)?.connectorId);
+}
 function readMcpToolResult(item) {
 	const result = asOptionalRecord(item.result);
 	if (!result || !Array.isArray(result.content)) return;
@@ -1634,13 +1950,16 @@ function createNativeMcpRuntime(params) {
 				launchSummary: "Codex native MCP connection",
 				toolCount: Object.keys(status.tools).length
 			}])),
-			tools: loaded.flatMap((status) => statusTools(status).map((tool) => ({
-				serverName: status.name,
-				safeServerName: status.name,
-				toolName: String(tool.name),
-				inputSchema: asOptionalRecord(tool.inputSchema) ?? { type: "object" },
-				fallbackDescription: normalizeOptionalString(tool.description) ?? String(tool.name)
-			})))
+			tools: loaded.flatMap((status) => statusTools(status).map((tool) => {
+				const uiVisibility = readCodexMcpToolUiVisibility(tool);
+				return Object.assign({
+					serverName: status.name,
+					safeServerName: status.name,
+					toolName: String(tool.name),
+					inputSchema: asOptionalRecord(tool.inputSchema) ?? { type: "object" },
+					fallbackDescription: normalizeOptionalString(tool.description) ?? String(tool.name)
+				}, uiVisibility ? { uiVisibility } : {});
+			}))
 		};
 		return catalog;
 	};
@@ -1668,11 +1987,18 @@ function createNativeMcpRuntime(params) {
 			const status = (await loadStatuses()).find((entry) => entry.name === serverName);
 			return { tools: status ? statusTools(status) : [] };
 		},
-		readResource: async (serverName, uri) => await params.client.request("mcpServer/resource/read", {
-			threadId: params.threadId,
-			server: serverName,
-			uri
-		}),
+		readResource: async (serverName, uri) => {
+			const isCodexAppsServer = serverName === CODEX_APPS_MCP_SERVER$1;
+			const response = await params.client.request("mcpServer/resource/read", {
+				threadId: params.threadId,
+				...isCodexAppsServer ? { originCallId: params.originCallId } : {},
+				server: serverName,
+				uri,
+				...params.connectorId ? { connectorId: params.connectorId } : {}
+			});
+			if (isCodexAppsServer && response.originCallId !== params.originCallId) throw new Error(`Codex MCP resource response originCallId mismatch: expected ${params.originCallId}, received ${response.originCallId}`);
+			return response;
+		},
 		listResources: async (serverName) => {
 			return { resources: (await loadStatuses()).find((entry) => entry.name === serverName)?.resources ?? [] };
 		},
@@ -1685,15 +2011,25 @@ function createNativeMcpRuntime(params) {
 }
 function createCodexNativeMcpAppResultDetailsPreparer(params) {
 	if (params.attempt.config?.mcp?.apps?.enabled !== true) return;
-	const runtime = createNativeMcpRuntime(params);
 	return async (item) => {
 		const serverName = normalizeOptionalString(item.server);
 		const toolName = normalizeOptionalString(item.tool);
 		const uiResourceUri = readMcpAppResourceUri(item);
+		const connectorId = readMcpAppConnectorId(item);
 		const toolResult = readMcpToolResult(item);
 		if (!serverName || !toolName || !uiResourceUri || !toolResult) return;
-		const allowedAppToolNames = new Set((await runtime.getCatalog()).tools.filter((tool) => tool.serverName === serverName).map((tool) => tool.toolName));
-		if (allowedAppToolNames.size === 0) return;
+		if (serverName === CODEX_APPS_MCP_SERVER$1 && !connectorId) return;
+		const runtime = createNativeMcpRuntime({
+			...params,
+			originCallId: item.id,
+			...connectorId ? { connectorId } : {}
+		});
+		const tools = (await runtime.listTools?.(serverName))?.tools ?? [];
+		const allowedAppToolNames = new Set(tools.filter((tool) => {
+			const uiVisibility = readCodexMcpToolUiVisibility(tool);
+			return (uiVisibility === void 0 || uiVisibility.includes("app")) && (serverName !== CODEX_APPS_MCP_SERVER$1 || readCodexMcpToolConnectorId(tool) === connectorId);
+		}).map((tool) => tool.name));
+		if (!allowedAppToolNames.has(toolName)) return;
 		return await prepareHarnessNativeMcpAppPreview({
 			runtime,
 			serverName,
@@ -1708,184 +2044,347 @@ function createCodexNativeMcpAppResultDetailsPreparer(params) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/plan-compaction-state.ts
+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 RESTORED_PLAN_TRUNCATION_SUFFIX = "…";
+function canonicalizeNativeProgressCardInput(input) {
+	const markdown = input.markdown === void 0 ? void 0 : truncateUtf8(stripInvisibleUnicode(input.markdown), PROGRESS_CARD_MAX_UTF8_BYTES);
+	const plan = [];
+	let hasInProgressStep = false;
+	for (const step of input.steps.slice(0, PROGRESS_CARD_MAX_STEPS)) {
+		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;
+		plan.push({
+			step: text,
+			status
+		});
+	}
+	return {
+		...markdown !== void 0 ? { markdown } : {},
+		plan
+	};
+}
+/** Retains the latest projected plan so Codex compaction cannot discard it. */
+var CodexCompactionPlanState = class {
+	record(event) {
+		if (event.stream !== "plan") return;
+		const plan = readBoundedPlan(event.data.explanation, event.data.steps);
+		this.latestPlan = plan;
+	}
+	/** Retains markdown that migration-only plan events intentionally omit. */
+	recordProgressCardInput(value) {
+		if (!isJsonObject(value)) return;
+		this.latestPlan = readBoundedPlan(value.markdown, value.plan);
+	}
+	async restore(params) {
+		if (!this.latestPlan) return;
+		await params.client.request("thread/inject_items", {
+			threadId: params.threadId,
+			items: [{
+				type: "message",
+				role: "user",
+				content: [{
+					type: "input_text",
+					text: `${RESTORED_PLAN_PREAMBLE}\n${serializePlan(this.latestPlan)}`
+				}]
+			}]
+		}, {
+			timeoutMs: params.timeoutMs,
+			signal: params.signal
+		});
+	}
+};
+function readBoundedPlan(markdownValue, stepsValue) {
+	const canonical = canonicalizeNativeProgressCardInput({
+		...typeof markdownValue === "string" ? { markdown: markdownValue } : {},
+		steps: readPlanSteps(stepsValue)
+	});
+	const markdown = canonical.markdown === void 0 ? void 0 : truncateUtf8(canonical.markdown, RESTORED_PLAN_MAX_MARKDOWN_BYTES);
+	const steps = [];
+	for (const step of canonical.plan) {
+		const candidate = {
+			...markdown?.trim() ? { markdown } : {},
+			steps: [...steps, step]
+		};
+		if (Buffer$1.byteLength(serializePlan(candidate), "utf8") > RESTORED_PLAN_MAX_PAYLOAD_BYTES) break;
+		steps.push(step);
+	}
+	return markdown?.trim() || steps.length > 0 ? {
+		...markdown?.trim() ? { markdown } : {},
+		steps
+	} : void 0;
+}
+function serializePlan(plan) {
+	return JSON.stringify({
+		markdown: plan.markdown,
+		plan: plan.steps
+	});
+}
+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}`;
+}
+function readPlanSteps(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry) => {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+		const { step, status } = entry;
+		if (typeof step !== "string" || !isPlanStatus(status)) return [];
+		return [{
+			step,
+			status
+		}];
+	});
+}
+function isPlanStatus(value) {
+	return value === "pending" || value === "in_progress" || value === "completed";
+}
+//#endregion
 //#region extensions/codex/src/app-server/user-input-bridge.ts
-/** Bridges Codex request_user_input calls to gateway questions and secret text prompts. */
+/** Owns per-turn Codex request_user_input and ordinary MCP elicitation lifecycles. */
 const DEFAULT_USER_INPUT_TIMEOUT_MS = 15 * 6e4;
 const NONBLOCKING_USER_INPUT_TIMEOUT_MS = 12e4;
-/** Creates a per-turn bridge for pending Codex user-input requests. */
+const MAX_USER_INPUT_QUESTIONS = 3;
+const MAX_USER_INPUT_OPTIONS = 4;
+const MAX_USER_INPUT_ID = 256;
+const MAX_USER_INPUT_HEADER = 64;
+const MAX_USER_INPUT_TEXT = 4096;
+/** Creates the single per-turn owner for Codex operator input. */
 function createCodexUserInputBridge(params) {
-	let sensitiveInput;
-	let pendingGateway;
 	const gatewayCall = params.gatewayCall ?? callGatewayTool;
-	const resolveSecret = (value) => {
-		const current = sensitiveInput;
-		if (!current) return;
-		sensitiveInput = void 0;
-		current.cleanup();
-		current.resolve(value);
-	};
-	const resolveSecretIfCurrent = (current, value) => {
-		if (sensitiveInput !== current) return false;
-		resolveSecret(value);
-		return true;
+	const jobs = [];
+	let activeCompletion;
+	const inputSessionKey = params.paramsForRun.sessionKey ?? params.paramsForRun.sessionId;
+	const pump = () => {
+		const job = jobs[0];
+		if (activeCompletion || !job) return;
+		activeCompletion = job.run(job.abort.signal).catch((error) => {
+			embeddedAgentLog.warn("failed to bridge codex operator input", { error });
+			return job.abort.signal.aborted ? job.cancelValue : job.failureValue;
+		}).then((value) => {
+			job.resolve(job.abort.signal.aborted ? job.cancelValue : value ?? job.failureValue);
+		}).finally(() => {
+			if (jobs[0] === job) jobs.shift();
+			activeCompletion = void 0;
+			pump();
+		});
 	};
-	const cancelGateway = () => {
-		pendingGateway?.abort.abort(/* @__PURE__ */ new Error("Codex user input request cancelled"));
+	const enqueue = (definition) => {
+		if (params.signal?.aborted) return Promise.resolve(definition.cancelValue);
+		return new Promise((resolve) => {
+			jobs.push({
+				...definition,
+				resolve
+			});
+			pump();
+		});
 	};
+	const cancelJob = (job) => {
+		const index = jobs.indexOf(job);
+		if (index < 0) return;
+		if (index === 0) {
+			job.abort.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
+			return;
+		}
+		jobs.splice(index, 1);
+		job.resolve(job.cancelValue);
+	};
+	const cancelPending = async () => {
+		const pendingCompletion = activeCompletion;
+		const queuedJobs = jobs.splice(1);
+		for (const job of queuedJobs) job.resolve(job.cancelValue);
+		jobs[0]?.abort.abort(/* @__PURE__ */ new Error("Codex operator input request cancelled"));
+		await pendingCompletion;
+	};
+	const execute = (input, timeoutMs, signal) => agentHarnessStructuredInput.run({
+		input,
+		sessionKey: inputSessionKey,
+		agentId: params.paramsForRun.agentId,
+		runId: params.paramsForRun.runId,
+		timeoutMs,
+		gatewayCall,
+		delivery: params.paramsForRun,
+		signal,
+		promptOptions: {
+			formatText: formatCodexDisplayText,
+			unsupportedIntro: "Codex input request could not be shown:",
+			urlIntro: "Codex needs confirmation:"
+		}
+	});
+	params.signal?.addEventListener("abort", () => void cancelPending(), { once: true });
 	return {
 		async handleRequest(request) {
 			const requestParams = readUserInputParams(request.params);
-			if (!requestParams) return;
-			if (requestParams.threadId !== params.threadId || requestParams.turnId !== params.turnId) return;
+			if (!requestParams || requestParams.threadId !== params.threadId || requestParams.turnId !== params.turnId) return;
 			if (requestParams.questions.length === 0) return emptyUserInputResponse();
-			resolveSecret(emptyUserInputResponse());
-			cancelGateway();
-			if (requestParams.questions.some((question) => question.isSecret)) return new Promise((resolve) => {
-				const abortListener = () => resolveSecret(emptyUserInputResponse());
-				const timeout = requestParams.isBlocking ? void 0 : setTimeout(() => resolveSecret(emptyUserInputResponse()), NONBLOCKING_USER_INPUT_TIMEOUT_MS);
-				timeout?.unref?.();
-				const cleanup = () => {
-					params.signal?.removeEventListener("abort", abortListener);
-					if (timeout) clearTimeout(timeout);
-				};
-				const current = {
-					requestId: request.id,
-					threadId: requestParams.threadId,
-					questions: requestParams.questions,
-					claimed: false,
-					resolve,
-					cleanup
-				};
-				sensitiveInput = current;
-				params.signal?.addEventListener("abort", abortListener, { once: true });
-				if (params.signal?.aborted) {
-					resolveSecret(emptyUserInputResponse());
-					return;
+			const timeoutMs = requestParams.isBlocking ? params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS : NONBLOCKING_USER_INPUT_TIMEOUT_MS;
+			const input = compileUserInputQuestions(requestParams.questions);
+			const cancelValue = emptyUserInputResponse();
+			return await enqueue({
+				requestId: request.id,
+				abort: new AbortController(),
+				cancelValue,
+				failureValue: cancelValue,
+				run: async (signal) => {
+					const result = await execute(input, timeoutMs, signal);
+					return result.status === "answered" ? gatewayAnswersToCodexResponse(result.answers) : cancelValue;
 				}
-				deliverAgentHarnessUserInputPrompt(params.paramsForRun, requestParams.questions, {
-					formatText: formatCodexDisplayText,
-					intro: "Codex needs input:"
-				}).catch((error) => {
-					embeddedAgentLog.warn("failed to deliver secret codex user input prompt", { error });
-					resolveSecretIfCurrent(current, emptyUserInputResponse());
-				});
 			});
-			const abort = new AbortController();
-			const abortFromRun = () => abort.abort(params.signal?.reason);
-			params.signal?.addEventListener("abort", abortFromRun, { once: true });
-			if (params.signal?.aborted) abortFromRun();
-			pendingGateway = {
-				requestId: request.id,
-				threadId: requestParams.threadId,
-				abort
-			};
-			try {
-				const result = await runAgentHarnessGatewayQuestion({
-					questions: requestParams.questions,
-					sessionKey: params.paramsForRun.sessionKey ?? params.paramsForRun.sessionId,
-					agentId: params.paramsForRun.agentId,
-					runId: params.paramsForRun.runId,
-					timeoutMs: requestParams.isBlocking ? params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS : NONBLOCKING_USER_INPUT_TIMEOUT_MS,
-					gatewayCall,
-					delivery: params.paramsForRun,
-					promptOptions: {
-						formatText: formatCodexDisplayText,
-						intro: "Codex needs input:"
-					},
-					signal: abort.signal
+		},
+		async handleElicitationRequest(request) {
+			if (readRawOwnString(request.params, "threadId") !== params.threadId) return;
+			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params);
+			if (requestSnapshot === void 0) {
+				const cancelValue = createCodexElicitationResponse("cancel");
+				return await enqueue({
+					requestId: request.id,
+					abort: new AbortController(),
+					cancelValue,
+					failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
+					run: async (signal) => {
+						const result = await execute({
+							kind: "unsupported",
+							message: "OpenClaw declined a malformed or over-limit MCP elicitation request."
+						}, params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS, signal);
+						return result.status === "unsupported" ? declineElicitation(result.message) : cancelValue;
+					}
 				});
-				return result.status === "answered" ? gatewayAnswersToCodexResponse(result.answers.answers) : emptyUserInputResponse();
-			} catch (error) {
-				embeddedAgentLog.warn("failed to bridge codex user input through gateway", { error });
-				return emptyUserInputResponse();
-			} finally {
-				params.signal?.removeEventListener("abort", abortFromRun);
-				if (pendingGateway?.abort === abort) pendingGateway = void 0;
 			}
-		},
-		claimPendingRequest() {
-			const current = sensitiveInput;
-			if (!current || current.claimed) return;
-			current.claimed = true;
-			return {
-				answer: (text) => resolveSecretIfCurrent(current, buildUserInputResponse(current.questions, text)),
-				cancel: () => resolveSecretIfCurrent(current, emptyUserInputResponse())
-			};
+			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DMkeki8d.js");
+			const compiled = compileCodexOrdinaryElicitation({
+				value: requestSnapshot,
+				threadId: params.threadId,
+				turnId: params.turnId
+			});
+			if (compiled.kind === "ignored") return;
+			const cancelValue = createCodexElicitationResponse("cancel");
+			const timeoutMs = params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS;
+			return await enqueue({
+				requestId: request.id,
+				abort: new AbortController(),
+				cancelValue,
+				failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
+				run: async (signal) => {
+					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 === "declined") return declineElicitation(result.message);
+					if (result.status === "unsupported") return declineElicitation(result.message);
+					return cancelValue;
+				}
+			});
 		},
 		handleNotification(notification) {
-			if (notification.method !== "serverRequest/resolved") return;
-			const notificationParams = isJsonObject(notification.params) ? notification.params : void 0;
-			const requestId = notificationParams ? readRequestId(notificationParams) : void 0;
-			if (!notificationParams || requestId === void 0) return;
-			if (sensitiveInput && readStringField(notificationParams, "threadId") === sensitiveInput.threadId && String(requestId) === String(sensitiveInput.requestId)) resolveSecret(emptyUserInputResponse());
-			if (pendingGateway && readStringField(notificationParams, "threadId") === pendingGateway.threadId && String(requestId) === String(pendingGateway.requestId)) pendingGateway.abort.abort(/* @__PURE__ */ new Error("Codex server request resolved"));
+			if (notification.method !== "serverRequest/resolved" || !isJsonObject(notification.params)) return;
+			const requestId = readRequestId(notification.params);
+			if (requestId === void 0 || readOwnString(notification.params, "threadId") !== params.threadId) return;
+			const job = jobs.find((candidate) => typeof candidate.requestId === typeof requestId && candidate.requestId === requestId);
+			if (job) cancelJob(job);
 		},
-		cancelPending() {
-			resolveSecret(emptyUserInputResponse());
-			cancelGateway();
-		}
+		cancelPending
 	};
 }
+function compileUserInputQuestions(questions) {
+	return agentHarnessStructuredInput.compileQuestions({
+		questions,
+		intro: "Codex needs input:"
+	});
+}
 function readUserInputParams(value) {
-	if (!isJsonObject(value)) return;
-	const threadId = readStringField(value, "threadId");
-	const turnId = readStringField(value, "turnId");
-	const itemId = readStringField(value, "itemId");
-	const questionsRaw = value.questions;
-	if (!threadId || !turnId || !itemId || !Array.isArray(questionsRaw)) return;
+	const snapshot = agentHarnessStructuredInput.snapshot(value);
+	if (!agentHarnessStructuredInput.isRecord(snapshot)) return;
+	const threadId = readBoundedUserInputText(snapshot, "threadId", MAX_USER_INPUT_ID);
+	const turnId = readBoundedUserInputText(snapshot, "turnId", MAX_USER_INPUT_ID);
+	const itemId = readBoundedUserInputText(snapshot, "itemId", MAX_USER_INPUT_ID);
+	const questions = readArray(snapshot, "questions", MAX_USER_INPUT_QUESTIONS);
+	if (!threadId || !turnId || !itemId || !questions) return;
+	const parsed = [];
+	for (const questionValue of questions) {
+		const question = readQuestion(questionValue);
+		if (!question) return;
+		parsed.push(question);
+	}
 	return {
 		threadId,
 		turnId,
-		itemId,
-		questions: questionsRaw.map((rawQuestion) => {
-			const question = readQuestion(rawQuestion);
-			if (question && isJsonObject(rawQuestion) && rawQuestion.multiSelect === true) question.multiSelect = true;
-			return question;
-		}).filter((question) => Boolean(question)),
-		isBlocking: value.isBlocking !== false
+		questions: parsed,
+		isBlocking: readValue(snapshot, "isBlocking") !== false
 	};
 }
 function readQuestion(value) {
-	if (!isJsonObject(value)) return;
-	const id = readStringField(value, "id");
-	const header = readStringField(value, "header");
-	const question = readStringField(value, "question");
+	if (!agentHarnessStructuredInput.isRecord(value)) return;
+	const id = readBoundedUserInputText(value, "id", MAX_USER_INPUT_ID);
+	const header = readBoundedUserInputText(value, "header", MAX_USER_INPUT_HEADER);
+	const question = readBoundedUserInputText(value, "question", MAX_USER_INPUT_TEXT);
 	if (!id || !header || !question) return;
+	const options = readOptions(readValue(value, "options"));
+	if (options === void 0) return;
 	return {
 		id,
 		header,
 		question,
-		isOther: value.isOther === true,
-		isSecret: value.isSecret === true,
-		options: readOptions(value.options)
+		isOther: readValue(value, "isOther") === true,
+		isSecret: readValue(value, "isSecret") === true,
+		...readValue(value, "multiSelect") === true ? { multiSelect: true } : {},
+		options
 	};
 }
 function readOptions(value) {
-	if (!Array.isArray(value)) return null;
-	const options = value.map(readOption).filter((option) => Boolean(option));
-	return options.length > 0 ? options : null;
-}
-function readOption(value) {
-	if (!isJsonObject(value)) return;
-	const label = readStringField(value, "label");
-	const description = readStringField(value, "description") ?? "";
-	return label ? {
-		label,
-		description
-	} : void 0;
+	if (value === void 0 || value === null) return null;
+	if (!Array.isArray(value) || value.length > MAX_USER_INPUT_OPTIONS) return;
+	const options = [];
+	for (const entry of value) {
+		if (!agentHarnessStructuredInput.isRecord(entry)) return;
+		const label = readBoundedUserInputText(entry, "label", MAX_USER_INPUT_ID);
+		const description = readBoundedUserInputText(entry, "description", MAX_USER_INPUT_TEXT, true);
+		if (!label) return;
+		options.push({
+			label,
+			...description ? { description } : {}
+		});
+	}
+	return options;
+}
+function readValue(record, key) {
+	return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+function readBoundedUserInputText(record, key, maximum, allowEmpty = false) {
+	const value = readValue(record, key);
+	return typeof value === "string" && value.length <= maximum && (allowEmpty || value.length > 0) ? value : void 0;
+}
+function readArray(record, key, maximum) {
+	const value = readValue(record, key);
+	return Array.isArray(value) && value.length <= maximum ? value : void 0;
 }
-function buildUserInputResponse(questions, inputText) {
-	return buildAgentHarnessUserInputAnswers(questions, inputText);
+function readOwnString(record, key) {
+	const descriptor = Object.getOwnPropertyDescriptor(record, key);
+	return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
+}
+function readRawOwnString(value, key) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	const descriptor = Object.getOwnPropertyDescriptor(value, key);
+	return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
+}
+function readRequestId(record) {
+	const descriptor = Object.getOwnPropertyDescriptor(record, "requestId");
+	const value = descriptor && "value" in descriptor ? descriptor.value : void 0;
+	return typeof value === "string" || typeof value === "number" ? value : void 0;
 }
 function gatewayAnswersToCodexResponse(answers) {
 	return { answers: Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [questionId, { answers: values }])) };
 }
 function emptyUserInputResponse() {
-	return emptyAgentHarnessUserInputAnswers();
+	return { ...emptyAgentHarnessUserInputAnswers() };
 }
-function readRequestId(record) {
-	const value = record.requestId;
-	return typeof value === "string" || typeof value === "number" ? value : void 0;
+function declineElicitation(message) {
+	return createCodexElicitationResponse("decline", null, message ? { message } : null);
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-active-turn.ts
@@ -1894,12 +2393,14 @@ 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, effectiveCwd } = connection;
-	const { dynamicToolParams, computerContextEpoch, toolBridge } = attemptTools;
+	const { params, runAbortController, terminalState, abortExplicitly, abortFromUpstream, bindingStore, bindingIdentity, sessionAgentId, sandboxSessionKey, contextSessionKey, effectiveCwd } = connection;
+	const { dynamicToolParams, compactionPlanState, computerContextEpoch, toolBridge } = attemptTools;
 	const { state, userInputBridgeRef, steeringQueueRef, turnWatches, completeTurn, interruptTurn } = turnRuntime;
 	const { emitExecutionPhaseOnce, emitLifecycleStart, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const { enqueueNotification } = notifications;
 	const activeTurnId = turn.turn.id;
+	const progressCardTool = toolBridge.availableTools.find((tool) => tool.name === "progress_card");
+	let nativePlanUpdateOrdinal = 0;
 	const prepareNativeMcpAppResultDetails = createCodexNativeMcpAppResultDetailsPreparer({
 		client: resourceState.client,
 		threadId: resourceState.thread.threadId,
@@ -1934,6 +2435,16 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	}, resourceState.thread.threadId, activeTurnId, {
 		initialContextTokens: connection.mutable.startupContextTokens,
 		nativePostToolUseRelayEnabled: resourceState.nativeHookRelay?.allowedEvents.includes("post_tool_use") === true && resourceState.nativeHookRelay.shouldRelayEvent("post_tool_use"),
+		asyncUserMessageAllowed: params.disableTools !== true && (params.toolsAllow === void 0 || toolBridge.availableTools.some((tool) => tool.name === "message")),
+		onAsyncDelivery: async (delivery) => {
+			return await codexTranscriptMirrorRuntime.deliverAsyncMessageBestEffort({
+				params: dynamicToolParams,
+				cwd: effectiveCwd,
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				...delivery
+			});
+		},
 		readRecentRateLimits: () => readRecentCodexRateLimits(resourceState.client),
 		runAbortSignal: runAbortController.signal,
 		remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
@@ -1948,12 +2459,39 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		trajectoryRecorder,
 		resolveDynamicToolResultContentSource: toolBridge.resultContentSourceForTool,
 		onNativeToolResultRecorded: maybeAnnounceFastModeAutoOff,
+		...progressCardTool ? { onNativePlanUpdate: async (update) => {
+			nativePlanUpdateOrdinal += 1;
+			try {
+				const input = canonicalizeNativeProgressCardInput(update);
+				await progressCardTool.execute(`codex-native-plan:${activeTurnId}:${nativePlanUpdateOrdinal}`, input, runAbortController.signal);
+			} catch (error) {
+				embeddedAgentLog.warn("failed to persist native Codex plan to progress card", {
+					runId: params.runId,
+					threadId: resourceState.thread.threadId,
+					error: formatErrorMessage(error)
+				});
+			}
+		} } : {},
 		...prepareNativeMcpAppResultDetails ? { prepareNativeMcpAppResultDetails } : {},
 		upstreamUserText: turnState.codexTurnPromptText,
-		onContextCompacted: () => {
+		onContextCompacted: async () => {
 			computerContextEpoch.value += 1;
 			delete computerContextEpoch.frameToolCallId;
 			delete computerContextEpoch.frameImageIdentity;
+			try {
+				await compactionPlanState.restore({
+					client: resourceState.client,
+					threadId: resourceState.thread.threadId,
+					timeoutMs: connection.appServer.requestTimeoutMs,
+					signal: runAbortController.signal
+				});
+			} catch (error) {
+				embeddedAgentLog.warn("failed to restore Codex plan state after compaction", {
+					runId: params.runId,
+					threadId: resourceState.thread.threadId,
+					error: formatErrorMessage(error)
+				});
+			}
 		}
 	});
 	if (isTerminalTurnStatus(turn.turn.status)) state.terminalTurnNotificationQueued = true;
@@ -1964,6 +2502,18 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	turnWatches.armAttemptIdleWatch();
 	turnWatches.touchActivity("turn:start", { attemptProgress: true });
 	for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
+	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
+	const promptMirrorPromise = mirrorPromptAtTurnStartBestEffort({
+		params,
+		agentId: sessionAgentId,
+		notifyUserMessagePersisted,
+		sessionKey: sandboxSessionKey,
+		cwd: effectiveCwd,
+		threadId: resourceState.thread.threadId,
+		turnId: activeTurnId,
+		upstreamUserText: turnState.codexTurnPromptText
+	});
+	await promptMirrorPromise;
 	if (resourceState.turnRoute) try {
 		await resourceState.turnRoute.bindTurn(activeTurnId);
 	} catch (error) {
@@ -1974,28 +2524,91 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			throw error;
 		}
 	}
-	if (!state.completed && isTerminalTurnStatus(turn.turn.status)) await enqueueNotification({
-		method: "turn/completed",
-		params: {
+	if (!state.completed && isTerminalTurnStatus(turn.turn.status)) {
+		if (!isJsonObject(turn.turn)) throw new Error("Codex turn completion payload is not a JSON object");
+		await enqueueNotification({
+			method: "turn/completed",
+			params: {
+				threadId: resourceState.thread.threadId,
+				turnId: activeTurnId,
+				turn: turn.turn
+			}
+		}, {
 			threadId: resourceState.thread.threadId,
-			turnId: activeTurnId,
-			turn: turn.turn
-		}
-	}, {
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId
+			turnId: activeTurnId
+		});
+	}
+	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,
-		claimPendingUserInput: () => userInputBridgeRef.current?.claimPendingRequest(),
-		signal: runAbortController.signal
+		signal: runAbortController.signal,
+		assertActive: assertSteeringActive,
+		prepareMessage: async (text, options) => {
+			const result = await detectAndLoadAgentHarnessPromptImages({
+				...imageContext,
+				prompt: text,
+				existingImages: options.images,
+				imageOrder: options.imageOrder,
+				media: options.media,
+				userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
+			});
+			if (result.failedMediaCount) throw new Error(`failed to hydrate ${result.failedMediaCount} structured image attachment(s) for Codex steering`);
+			return buildCodexUserInput(text, result.images);
+		},
+		beforeConfirmConsumed: async (items) => {
+			const inboundItems = items.filter((item) => item.isInboundUserMessage === true);
+			if (inboundItems.length === 0) return;
+			await promptMirrorPromise;
+			const messages = activeProjector.buildSteeringTranscriptPrefix();
+			if (params.sessionTarget && messages.length > 0) {
+				await codexTranscriptMirrorRuntime.mirror({
+					agentId: sessionAgentId,
+					sessionKey: contextSessionKey,
+					sessionId: params.sessionId,
+					storePath: params.sessionTarget.storePath,
+					cwd: effectiveCwd,
+					messages,
+					idempotencyScope: `codex-app-server:${resourceState.thread.threadId}`,
+					runId: params.runId,
+					runMirrorIdentityPrefix: `${activeTurnId}:`,
+					config: params.config
+				});
+				activeProjector.markSteeringTranscriptPersisted();
+			}
+			for (const item of inboundItems) {
+				const recorder = item.userTurnTranscriptRecorder;
+				if (!recorder) continue;
+				await recorder.persistApproved();
+				if (!recorder.hasPersisted()) throw new Error("Codex consumed steering before its user turn was persisted");
+			}
+		}
 	});
 	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,
@@ -2009,14 +2622,17 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		resolvedBy
 	});
 	const queueMessage = async (text, optionsLocal) => {
-		const isInboundUserMessage = optionsLocal?.isInboundUserMessage === true;
 		if (await claimPendingUserInputAnswer(text, optionsLocal)) {
 			optionsLocal?.onQueueAccepted?.(true);
 			return;
-		} else if (isInboundUserMessage && optionsLocal?.images?.length) try {
-			await cancelPendingUserInput("image-reply");
-		} catch (error) {
-			embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
+		}
+		if (optionsLocal?.isInboundUserMessage === true && hasPromptImageInput(optionsLocal)) {
+			assertSteeringActive();
+			try {
+				await cancelPendingUserInput("image-reply");
+			} catch (error) {
+				embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
+			}
 		}
 		try {
 			await activeSteeringQueue.queue(text, optionsLocal);
@@ -2031,6 +2647,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const handle = {
 		kind: "embedded",
 		runId: params.runId,
+		startedAtMs: params.startedAtMs,
 		toolAuthorityFingerprint: params.toolAuthorityFingerprint,
 		claimPendingUserInputAnswer,
 		cancelPendingUserInput,
@@ -2045,7 +2662,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		isAbortable: () => !terminalState.terminalOutcomeFrozen || terminalState.sharedAbortAllowedAfterTerminalOutcome,
 		isCompacting: () => projectorRef.current?.isCompacting() ?? false,
 		supportsTranscriptCommitWait: true,
-		supportsQueueMessageImages: true,
+		supportsQueueMessageImages: params.model.input.includes("image"),
 		sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
 		taskSuggestionDeliveryMode: params.taskSuggestionDeliveryMode,
 		cancel: () => abortExplicitly("cancelled"),
@@ -2058,17 +2675,6 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		terminalState.terminalOutcomeFrozen = true;
 		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 	};
-	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
-	mirrorPromptAtTurnStartBestEffort({
-		params,
-		agentId: sessionAgentId,
-		notifyUserMessagePersisted,
-		sessionKey: sandboxSessionKey,
-		cwd: effectiveCwd,
-		threadId: resourceState.thread.threadId,
-		turnId: activeTurnId,
-		upstreamUserText: turnState.codexTurnPromptText
-	});
 	const abortListener = () => {
 		if (state.timedOut) {
 			(async () => {
@@ -2085,7 +2691,15 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			})().finally(completeTurn);
 			return;
 		}
-		interruptTurn(activeTurnId).finally(completeTurn);
+		const interrupted = interruptTurn(activeTurnId);
+		if (terminalState.explicitCancellationObserved) state.abortCleanup = interrupted.then(async (confirmed) => {
+			if (!confirmed) throw new Error("Codex cancellation could not confirm the turn stopped; background terminals may still be running.");
+			await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
+		});
+		(terminalState.explicitCancellationObserved ? state.abortCleanup : interrupted).then(completeTurn, (error) => {
+			embeddedAgentLog.warn("codex app-server cancellation cleanup failed", { error });
+			completeTurn();
+		});
 	};
 	runAbortController.signal.addEventListener("abort", abortListener, { once: true });
 	if (runAbortController.signal.aborted) abortListener();
@@ -2110,6 +2724,8 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, abortListener, handle, freezeRunTerminalOutcome } = activeTurn;
 	prompt.context.attemptTools.scheduledAppAuthoritySourceRef.current = void 0;
+	freezeRunTerminalOutcome();
+	await state.abortCleanup.catch(() => void 0);
 	try {
 		steeringQueueRef.current?.cancel();
 		if (params.isFinalFallbackAttempt !== false) await maybeEmitFastModeAutoResetBestEffort();
@@ -2133,15 +2749,11 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		const retainLiveIncognitoThread = terminalState.turnSucceeded && isIncognitoSessionKey(params.sessionKey);
 		const retainedPersistentThread = terminalState.turnSucceeded && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint ? (await bindingStore.read(bindingIdentity))?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
 			if ((await bindingStore.read(bindingIdentity))?.threadId !== resourceState.thread.threadId) return false;
-			return await retainCodexAppServerLiveThread(resourceState.client, resourceState.thread.threadId, resourceState.thread.liveThreadOwnership?.release ?? (async (threadId) => {
-				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
-					threadId,
-					timeoutMs: 5e3
-				})) {
-					await closeCodexStartupClientBestEffort(resourceState.client);
-					throw new CodexAppServerUnsafeSubscriptionError(`Codex retained thread subscription could not be released: ${threadId}`);
-				}
-			}), resourceState.thread.liveThreadConfigFingerprint, connection.mutable.pluginAppServer.serviceTier);
+			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
+				release: resourceState.thread.liveThreadOwnership?.release,
+				configFingerprint: resourceState.thread.liveThreadConfigFingerprint,
+				serviceTier: connection.mutable.pluginAppServer.serviceTier
+			});
 		}) : false;
 		const retainLiveThread = retainLiveIncognitoThread || retainedPersistentThread;
 		const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveIncognitoThread ? await bindingStore.mutate(bindingIdentity, {
@@ -2159,7 +2771,13 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	} finally {
 		await runCleanupStep("codex-user-input-cancel", () => userInputBridgeRef.current?.cancelPending());
 		await runCleanupStep("codex-turn-watch-clear", () => turnWatches.clearAllTimers());
+		await runCleanupStep("codex-dynamic-tool-cleanup", async () => {
+			const cleanupReason = terminalState.turnSucceeded ? "completion" : state.timedOut ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
+			const cleanups = prompt.context.attemptTools.runCleanups.splice(0);
+			await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)));
+		});
 		await runCleanupStep("codex-route-release", releaseCurrentRoute);
+		await runCleanupStep("codex-transcript-checkpoint", () => activeTurn.activeProjector.transcriptCheckpoint.flush(true));
 		await runCleanupStep("codex-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		const nativeHookRelay = resourceState.nativeHookRelay;
 		resourceState.nativeHookRelay = void 0;
@@ -2178,12 +2796,12 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			runAbortController.signal.removeEventListener("abort", abortListener);
 		});
 		await runCleanupStep("codex-steering-cancel", () => steeringQueueRef.current?.cancel());
-		await runCleanupStep("codex-terminal-freeze", freezeRunTerminalOutcome);
 		await runCleanupStep("codex-reply-backend-detach", () => params.replyOperation?.detachBackend(handle));
 		await runCleanupStep("codex-active-run-clear", () => {
 			clearActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile);
 		});
 	}
+	await state.abortCleanup;
 }
 //#endregion
 //#region extensions/codex/src/app-server/workspace-dir-cache.ts
@@ -2295,10 +2913,7 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 		path.join(resolvedAgentDir, "agent", "codex-home", "sessions"),
 		path.join(path.dirname(resolvedAgentDir), "codex-home", "sessions")
 	];
-	const rolloutRoot = rolloutPath ? roots.find((root) => {
-		const relativePath = path.relative(root, rolloutPath);
-		return relativePath !== "" && relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
-	}) : void 0;
+	const rolloutRoot = rolloutPath ? roots.find((root) => isPathStrictlyInside(root, rolloutPath)) : void 0;
 	if (rolloutPath && rolloutRoot && path.isAbsolute(rolloutPath) && path.extname(rolloutPath) === ".jsonl" && path.basename(rolloutPath).includes(threadId)) try {
 		const opened = await (await root(rolloutRoot, {
 			hardlinks: "reject",
@@ -2555,14 +3170,6 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-connection.ts
-function applyStoredBindingPermissions(params) {
-	if (params.execPolicyTouched || params.binding?.connectionScope === "supervision") return params.appServer;
-	return {
-		...params.appServer,
-		approvalPolicy: params.binding?.approvalPolicy ?? params.appServer.approvalPolicy,
-		sandbox: params.binding?.sandbox ?? params.appServer.sandbox
-	};
-}
 async function prepareCodexAttemptConnection({ params, options }) {
 	const attemptStartedAt = Date.now();
 	const profilerEnabled = isCodexAppServerProfilerEnabled(params.config);
@@ -2575,16 +3182,15 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		resetAnnounced: false
 	};
 	const preDynamicStartupStages = createCodexDynamicToolBuildStageTracker({ enabled: profilerEnabled });
-	const attemptClientFactory = options.clientFactory ?? getLeasedSharedCodexAppServerClient;
 	const runtimeArtifactRequest = params.captureRuntimeArtifact || params.expectedRuntimeArtifact ? params.expectedRuntimeArtifact ? { expected: params.expectedRuntimeArtifact } : {} : void 0;
 	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 beforeToolCallPolicy = getBeforeToolCallPolicyDiagnosticState();
 	preDynamicStartupStages.mark("config");
 	const resolvedWorkspace = resolveUserPath(params.workspaceDir);
 	await ensureCodexWorkspaceDirOnce(resolvedWorkspace);
@@ -2596,14 +3202,36 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		sessionKey: sandboxSessionKey,
 		workspaceDir: resolvedWorkspace
 	});
+	const attemptClientFactory = options.clientFactory ?? (isCodexPairedNodeRemoteExecPlacementSandbox(sandbox) ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient);
 	preDynamicStartupStages.mark("sandbox");
 	const execPolicy = resolveOpenClawExecPolicyForCodexAppServer({
+		permissionMode: params.permissionMode,
 		execOverrides: params.execOverrides,
-		approvals: loadExecApprovals(),
+		approvals: params.permissionMode === "full" ? void 0 : loadExecApprovals(),
 		config: params.config,
 		agentId: sessionAgentId
 	});
 	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
+	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
+	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
+	const preparedShellEnvironment = preparedEnvironment ? {
+		...preparedEnvironment.credentialScrubEnv,
+		...!remoteExec ? preparedEnvironment.localIdentityEnv : void 0
+	} : 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 withPreparedProcessEnv = (appServer) => {
+		return shellEnvironment ? {
+			...appServer,
+			start: {
+				...appServer.start,
+				env: {
+					...appServer.start.env,
+					...shellEnvironment
+				}
+			}
+		} : appServer;
+	};
 	let bindingIdentity = sessionBindingIdentity({
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
@@ -2650,21 +3278,20 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const usesSupervisionConnection = startupBinding?.connectionScope === "supervision";
 	if (usesSupervisionConnection) activeContextEngine = void 0;
 	if (usesSupervisionConnection && pluginConfig.supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
-	const resolveRuntimeOptionsForBinding = (selection) => applyStoredBindingPermissions({
-		appServer: resolveCodexBindingAppServerConnection({
-			binding: startupBinding,
-			pluginConfig,
-			execPolicy,
-			modelProvider: selection.modelProvider,
-			model: selection.model,
-			config: params.config,
-			agentDir,
-			openClawSandboxActive: sandbox?.enabled === true
-		}).appServer,
-		binding: startupBinding,
-		execPolicyTouched: execPolicy.touched
-	});
+	const resolveRuntimeOptionsForBinding = (binding, selection) => resolveCodexBindingAppServerConnection({
+		binding,
+		pluginConfig,
+		execPolicy,
+		modelProvider: selection.modelProvider,
+		model: selection.model,
+		config: params.config,
+		agentDir,
+		requirementsToml,
+		openClawSandboxActive: sandbox?.enabled === true,
+		sessionPermissionMode: params.permissionMode
+	}).appServer;
 	const initialStartupBindingHadInactiveThreadBootstrap = isInactiveThreadBootstrapBinding(startupBinding);
+	const appServerHomeScope = resolveCodexAppServerHomeScope({ appServer: pluginConfig.appServer });
 	const preparedAuthRoute = usesSupervisionConnection ? void 0 : params.runtimePlan?.auth.modelRoute;
 	const startupAuthProfileCandidate = usesSupervisionConnection ? void 0 : preparedAuthRoute ? params.runtimePlan?.auth.forwardedAuthProfileId : params.runtimePlan?.auth.forwardedAuthProfileId ?? params.authProfileId ?? startupBinding?.authProfileId;
 	const resolvedStartupAuthProfileId = usesSupervisionConnection ? void 0 : preparedAuthRoute ? startupAuthProfileCandidate : params.authProfileStore ? resolveCodexAppServerAuthProfileId({
@@ -2686,13 +3313,13 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		authProfileId: resolvedStartupAuthProfileId,
 		authProfileStore: params.authProfileStore,
 		agentDir,
-		homeScope: resolveCodexAppServerHomeScope({ appServer: pluginConfig.appServer }),
+		homeScope: appServerHomeScope,
 		requirePreparedAuth: isCodexRemoteExecPlacementSandbox(sandbox),
 		config: params.config,
 		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a forwarded OpenAI OAuth or token profile.",
 		subscriptionProfileUnusableError: "Prepared Codex subscription auth profile is unusable."
 	});
-	const startupClientAuthProfileId = usesSupervisionConnection || startupPreparedAuth?.kind === "api-key" ? null : startupAuthProfileId;
+	const startupClientAuthProfileId = usesSupervisionConnection || appServerHomeScope === "user" || startupPreparedAuth?.kind === "api-key" ? null : startupAuthProfileId;
 	const resolveReviewerPolicyContext = (binding) => {
 		const nativeModelOwned = binding?.preserveNativeModel === true;
 		return resolveCodexModelBackedReviewerPolicyContext({
@@ -2705,41 +3332,67 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	};
 	let reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
 	preDynamicStartupStages.mark("auth-profile");
-	let configuredAppServer = resolveRuntimeOptionsForBinding({
+	let configuredAppServer = resolveRuntimeOptionsForBinding(startupBinding, {
 		modelProvider: reviewerPolicyContext.modelProvider,
 		model: reviewerPolicyContext.model
 	});
 	const effectiveWorkspace = sandbox?.enabled ? sandbox.workspaceAccess === "rw" ? resolvedWorkspace : sandbox.workspaceDir : resolvedWorkspace;
 	const requestedCwd = params.cwd ? resolveUserPath(params.cwd) : void 0;
 	if (sandbox?.enabled && requestedCwd && requestedCwd !== resolvedWorkspace) throw new Error("cwd override is not supported for sandboxed Codex app-server runs; omit cwd or use the agent workspace as cwd");
-	const effectiveCwd = sandbox?.enabled ? effectiveWorkspace : requestedCwd ?? effectiveWorkspace;
+	const sessionPermissionCwd = resolveCodexSessionPermissionCwd({
+		permissionMode: params.permissionMode,
+		sessionRoot: params.sessionRoot,
+		defaultRoot: effectiveWorkspace,
+		requestedCwd,
+		fallbackCwd: effectiveWorkspace
+	});
+	const effectiveCwd = sandbox?.enabled ? effectiveWorkspace : sessionPermissionCwd;
 	if (effectiveWorkspace !== resolvedWorkspace) await ensureCodexWorkspaceDirOnce(effectiveWorkspace);
 	preDynamicStartupStages.mark("effective-workspace");
-	const shouldPromoteApprovalPolicy = beforeToolCallPolicy.hasBeforeToolCallHook || beforeToolCallPolicy.trustedToolPolicies.length > 0;
-	const resolvePolicyAppServer = () => resolveCodexAppServerForOpenClawToolPolicy({
-		appServer: configuredAppServer,
+	const applySessionPermissionPolicy = (appServer, selection) => applyCodexSessionPermissionPolicy({
+		appServer,
+		permissionMode: params.permissionMode,
+		sessionRoot: params.sessionRoot,
+		defaultRoot: effectiveWorkspace,
 		pluginConfig,
-		env: process.env,
-		shouldPromote: shouldPromoteApprovalPolicy,
-		execPolicy,
-		canUseUntrustedApprovalPolicy: shouldPromoteApprovalPolicy && configuredAppServer.approvalPolicy === "never" && (configuredAppServer.start.transport !== "stdio" || isCodexAppServerApprovalPolicyAllowedByRequirements("untrusted"))
-	});
-	let policyAppServer = resolvePolicyAppServer();
-	let appServer = resolveCodexAppServerForModelProvider({
-		appServer: policyAppServer,
-		provider: reviewerPolicyContext.modelProvider,
-		model: reviewerPolicyContext.model,
-		config: params.config,
-		env: process.env,
-		agentDir
-	});
-	let approvalPolicyPromotedForOpenClawToolPolicy = configuredAppServer.approvalPolicy === "never" && appServer.approvalPolicy === "untrusted";
-	if (approvalPolicyPromotedForOpenClawToolPolicy) embeddedAgentLog.info("codex app-server approval policy promoted for OpenClaw tool policy", {
-		from: "never",
-		to: "untrusted",
-		beforeToolCallHook: beforeToolCallPolicy.hasBeforeToolCallHook,
-		trustedToolPolicies: beforeToolCallPolicy.trustedToolPolicies
+		canUseAutoReview: canUseCodexModelBackedApprovalsReviewerForModel({
+			modelProvider: selection.modelProvider,
+			model: selection.model,
+			config: params.config,
+			env: {
+				...process.env,
+				...appServer.start.env,
+				...shellEnvironment
+			},
+			agentDir,
+			homeScope: appServer.start.homeScope,
+			codexArgs: appServer.start.args
+		}),
+		requirementsToml,
+		policyLocked: startupBinding?.connectionScope === "supervision",
+		execMode: execPolicy.mode
 	});
+	const resolveFinalAppServer = (configured, selection) => {
+		const session = applySessionPermissionPolicy(configured, selection);
+		const trusted = resolveCodexAppServerForModelProvider({
+			appServer: session,
+			provider: selection.modelProvider,
+			model: selection.model,
+			config: params.config,
+			env: {
+				...process.env,
+				...session.start.env,
+				...shellEnvironment
+			},
+			agentDir
+		});
+		return {
+			session,
+			appServer: withPreparedProcessEnv(trusted)
+		};
+	};
+	let resolvedAppServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
+	let appServer = resolvedAppServer.appServer;
 	preDynamicStartupStages.mark("app-server-policy");
 	preDynamicStartupStages.mark("native-hook-relay");
 	const terminalState = {
@@ -2787,20 +3440,23 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	preDynamicStartupStages.mark("rotate-binding");
 	if (startupBinding !== startupBindingBeforeRotation) {
 		reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
-		configuredAppServer = resolveRuntimeOptionsForBinding({
+		configuredAppServer = resolveRuntimeOptionsForBinding(startupBinding, {
 			modelProvider: reviewerPolicyContext.modelProvider,
 			model: reviewerPolicyContext.model
 		});
-		policyAppServer = resolvePolicyAppServer();
-		appServer = resolveCodexAppServerForModelProvider({
-			appServer: policyAppServer,
-			provider: reviewerPolicyContext.modelProvider,
-			model: reviewerPolicyContext.model,
-			config: params.config,
-			env: process.env,
-			agentDir
-		});
-		approvalPolicyPromotedForOpenClawToolPolicy = configuredAppServer.approvalPolicy === "never" && appServer.approvalPolicy === "untrusted";
+		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,
@@ -2809,22 +3465,10 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const mutable = {
 		startupBinding,
 		startupContextTokens: startupBindingResolution.startupContextTokens,
-		pluginAppServer: appServer
+		pluginAppServer: appServer,
+		continuityCalibration: startupBindingBeforeRotation?.continuityCalibration
 	};
-	const resolveRuntimeOptionsForCurrentBinding = (selection) => applyStoredBindingPermissions({
-		appServer: resolveCodexBindingAppServerConnection({
-			binding: mutable.startupBinding,
-			pluginConfig,
-			execPolicy,
-			modelProvider: selection.modelProvider,
-			model: selection.model,
-			config: params.config,
-			agentDir,
-			openClawSandboxActive: sandbox?.enabled === true
-		}).appServer,
-		binding: mutable.startupBinding,
-		execPolicyTouched: execPolicy.touched
-	});
+	const resolveRuntimeOptionsForCurrentBinding = (selection) => resolveFinalAppServer(resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection).appServer;
 	return {
 		params,
 		options,
@@ -2846,6 +3490,8 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		contextSessionKey,
 		sandbox,
 		agentDir,
+		shellEnvironment,
+		disableLoginShell,
 		bindingIdentity,
 		bindingStore,
 		activeContextEngine,
@@ -2858,7 +3504,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		effectiveWorkspace,
 		effectiveCwd,
 		appServer,
-		approvalPolicyPromotedForOpenClawToolPolicy,
+		sessionPermissionPolicy,
 		nativeHookRelayEvents,
 		runAbortController,
 		terminalState,
@@ -2951,10 +3597,12 @@ function resolveContextEngineBootstrapProjectionDecision(params) {
 */
 async function buildCodexWorkspaceBootstrapContext(params) {
 	try {
+		const inheritsAgentWorkspace = (params.executionWorkspace ?? params.resolvedWorkspace) !== params.resolvedWorkspace;
+		const promptWorkspace = inheritsAgentWorkspace ? params.resolvedWorkspace : params.effectiveWorkspace;
 		const memoryToolsAvailable = params.memoryToolNames.length > 0 && canRouteCodexWorkspaceMemoryThroughTools({
 			config: params.params.config,
 			agentId: params.params.agentId ?? params.sessionAgentId,
-			workspaceDir: params.effectiveWorkspace
+			workspaceDir: inheritsAgentWorkspace ? params.resolvedWorkspace : params.effectiveWorkspace
 		});
 		const bootstrapFiles = await resolveBootstrapFilesForRun({
 			workspaceDir: params.resolvedWorkspace,
@@ -2974,7 +3622,7 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 		const memoryReferenceFiles = memoryToolRoutedBootstrapFiles.map((file) => remapCodexContextFilePath({
 			file: toCodexEmbeddedContextFile(file),
 			sourceWorkspaceDir: params.resolvedWorkspace,
-			targetWorkspaceDir: params.effectiveWorkspace
+			targetWorkspaceDir: promptWorkspace
 		}));
 		const contextFiles = buildBootstrapContextForFiles(memoryToolsAvailable ? bootstrapFiles.filter((file) => !isCodexWorkspaceRootMemoryBootstrapFile({
 			file,
@@ -2986,23 +3634,33 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 		}).map((file) => remapCodexContextFilePath({
 			file,
 			sourceWorkspaceDir: params.resolvedWorkspace,
-			targetWorkspaceDir: params.effectiveWorkspace
+			targetWorkspaceDir: promptWorkspace
 		}));
 		const promptContextFiles = selectCodexWorkspacePromptContextFiles(contextFiles, {
 			excludeMemory: memoryToolsAvailable,
 			memoryWorkspaceDir: params.effectiveWorkspace
 		});
-		const turnScopedDeveloperInstructionFiles = shouldInjectCodexOpenClawPromptContext(params.params) ? selectCodexWorkspaceTurnScopedDeveloperInstructionFiles(contextFiles) : [];
+		const injectOpenClawContext = shouldInjectCodexOpenClawPromptContext(params.params);
+		const restrictedProjectDocNeedsOpenClawCarrier = params.params.pluginHarnessToolPolicyRestricted === true && !params.params.disableTools && !isMessageOnlyCodexSourceReply(params.params) && params.params.bootstrapContextMode !== "lightweight";
+		const threadDeveloperInstructionFiles = injectOpenClawContext && !params.ringZeroActive && (inheritsAgentWorkspace || restrictedProjectDocNeedsOpenClawCarrier) ? selectCodexWorkspaceAgentProjectInstructionFiles(contextFiles, params.resolvedWorkspace) : [];
+		const turnScopedDeveloperInstructionFiles = injectOpenClawContext ? selectCodexWorkspaceTurnScopedDeveloperInstructionFiles(contextFiles) : [];
 		return {
 			bootstrapFiles,
 			contextFiles,
+			inheritsAgentWorkspace,
 			promptContextFiles,
+			threadDeveloperInstructionFiles,
 			turnScopedDeveloperInstructionFiles,
 			memoryReferenceFiles,
 			memoryToolRoutedBootstrapFiles,
 			memoryToolNames: [...params.memoryToolNames],
 			memoryToolRouted: memoryToolsAvailable,
 			promptContext: renderCodexWorkspaceBootstrapPromptContext(promptContextFiles),
+			threadDeveloperInstructions: renderCodexWorkspaceDeveloperInstructions({
+				files: threadDeveloperInstructionFiles,
+				header: "## OpenClaw Agent Workspace Instructions",
+				preamble: "OpenClaw loaded this bounded snapshot from the configured agent workspace."
+			}),
 			turnScopedDeveloperInstructions: renderCodexWorkspaceCollaborationDeveloperInstructions(turnScopedDeveloperInstructionFiles),
 			memoryCollaborationInstructions: shouldInjectCodexOpenClawPromptContext(params.params) ? await renderCodexWorkspaceMemoryCollaborationInstructions({
 				files: memoryReferenceFiles,
@@ -3018,7 +3676,8 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 		embeddedAgentLog.warn("failed to load codex workspace bootstrap instructions", { error });
 		return {
 			bootstrapFiles: [],
-			contextFiles: []
+			contextFiles: [],
+			inheritsAgentWorkspace: false
 		};
 	}
 }
@@ -3051,7 +3710,7 @@ function buildCodexSystemPromptReport(params) {
 		injectedWorkspaceFiles: buildCodexBootstrapInjectionStats({
 			bootstrapFiles: params.workspaceBootstrapContext.bootstrapFiles,
 			injectedFiles: params.workspaceBootstrapContext.promptContextFiles ?? [],
-			developerInstructionFiles: params.workspaceBootstrapContext.turnScopedDeveloperInstructionFiles ?? [],
+			developerInstructionFiles: [...params.workspaceBootstrapContext.threadDeveloperInstructionFiles ?? [], ...params.workspaceBootstrapContext.turnScopedDeveloperInstructionFiles ?? []],
 			memoryToolRoutedBootstrapFiles: params.workspaceBootstrapContext.memoryToolRoutedBootstrapFiles ?? [],
 			memoryToolRouted: params.workspaceBootstrapContext.memoryToolRouted === true
 		}),
@@ -3132,12 +3791,17 @@ function buildCodexBootstrapInjectionStats(params) {
 		const rawChars = file.missing ? 0 : (file.content ?? "").trimEnd().length;
 		const memoryToolRoutedFile = baseName === CODEX_MEMORY_CONTEXT_BASENAME && params.memoryToolRouted === true && memoryToolRoutedPaths.has(normalizeCodexContextFilePath(pathValue));
 		const injected = memoryToolRoutedFile ? void 0 : readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) ?? readCodexIndexedContextFileContent(developerInstructionIndex, pathValue, fileName);
-		let injectedChars = memoryToolRoutedFile ? 0 : injected?.length ?? 0;
-		let truncated = memoryToolRoutedFile ? false : !file.missing && injectedChars < rawChars;
-		if (injected === void 0 && CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName)) {
-			injectedChars = rawChars;
-			truncated = false;
-		}
+		if (!file.missing && injected === void 0 && CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName)) return {
+			name: displayName,
+			path: pathValue,
+			missing: false,
+			rawChars,
+			injectionStatus: "native_unverified",
+			injectedChars: null,
+			truncated: null
+		};
+		const injectedChars = memoryToolRoutedFile ? 0 : injected?.length ?? 0;
+		const truncated = memoryToolRoutedFile ? false : !file.missing && injectedChars < rawChars;
 		return {
 			name: displayName,
 			path: pathValue,
@@ -3272,7 +3936,7 @@ function renderCodexWorkspaceBootstrapPromptContext(contextFiles) {
 	const files = contextFiles;
 	if (files.length === 0) return;
 	const lines = [
-		"OpenClaw loaded these user-editable workspace files for the current turn. Codex loads AGENTS.md natively. SOUL.md, IDENTITY.md, and USER.md are provided as turn-scoped collaboration instructions so native Codex subagents do not inherit them. Those files are not repeated here.",
+		"OpenClaw loaded these user-editable workspace files for the current turn. Codex loads project-local AGENTS.md natively. When execution uses another folder, OpenClaw supplies the agent workspace AGENTS.md as thread-level developer instructions. SOUL.md, IDENTITY.md, and USER.md remain turn-scoped collaboration instructions. Those files are not repeated here.",
 		"",
 		"# Project Context",
 		"",
@@ -3295,6 +3959,10 @@ function selectCodexWorkspacePromptContextFiles(contextFiles, options = {}) {
 function selectCodexWorkspaceTurnScopedDeveloperInstructionFiles(contextFiles) {
 	return selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES);
 }
+function selectCodexWorkspaceAgentProjectInstructionFiles(contextFiles, agentWorkspaceDir) {
+	const agentProjectDocPath = path.join(path.resolve(agentWorkspaceDir), "AGENTS.md");
+	return selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, CODEX_NATIVE_PROJECT_DOC_BASENAMES).filter((file) => path.resolve(file.path) === agentProjectDocPath);
+}
 function selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, basenames) {
 	return contextFiles.filter((file) => {
 		const baseName = getCodexContextFileBasename(file.path);
@@ -3439,23 +4107,120 @@ function compareCodexContextFiles(left, right) {
 	if (leftBase !== rightBase) return leftBase.localeCompare(rightBase);
 	return leftPath.localeCompare(rightPath);
 }
-function compareCodexBootstrapFiles(left, right) {
-	return compareCodexContextFiles(toCodexEmbeddedContextFile(left), toCodexEmbeddedContextFile(right));
+function compareCodexBootstrapFiles(left, right) {
+	return compareCodexContextFiles(toCodexEmbeddedContextFile(left), toCodexEmbeddedContextFile(right));
+}
+function normalizeCodexContextFilePath(filePath) {
+	return filePath.trim().replaceAll("\\", "/").toLowerCase();
+}
+function getCodexContextFileDisplayBasename(filePath) {
+	return filePath.trim().replaceAll("\\", "/").split("/").pop()?.trim() ?? "";
+}
+function getCodexContextFileBasename(filePath) {
+	return normalizeCodexContextFilePath(filePath).split("/").pop() ?? "";
+}
+function normalizeCodexDynamicToolName(name) {
+	return name.trim().toLowerCase();
+}
+function isNonEmptyString$1(value) {
+	return typeof value === "string" && value.length > 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/run-attempt-state.ts
+async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields) {
+	const currentBinding = await bindingStore.read(identity);
+	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
+	if (!expectedThreadId) return;
+	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
+		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
+			...fields,
+			boundThreadId: currentBinding.threadId
+		});
+		return;
+	}
+	if (currentBinding?.connectionScope === "supervision") {
+		embeddedAgentLog.warn("codex app-server image payload error detected for supervised thread; preserving native binding", fields);
+		return;
+	}
+	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
+	await bindingStore.mutate(identity, {
+		kind: "clear",
+		threadId: expectedThreadId
+	});
+}
+async function markCodexAppServerBindingCoveredThroughTurn(params) {
+	await params.bindingStore.mutate(params.identity, {
+		kind: "patch",
+		threadId: params.threadId,
+		patch: {
+			historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
+			...params.continuityCalibration ? { continuityCalibration: params.continuityCalibration } : {}
+		}
+	});
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
 }
-function normalizeCodexContextFilePath(filePath) {
-	return filePath.trim().replaceAll("\\", "/").toLowerCase();
+function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
+	if (!params.contextEngineActive || params.thread.lifecycle.action !== "resumed") return false;
+	const message = formatErrorMessage(params.error);
+	return /ran out of room in the model'?s context window/iu.test(message) || /context window/iu.test(message) || /context length/iu.test(message) || /maximum context/iu.test(message) || /too many tokens/iu.test(message);
 }
-function getCodexContextFileDisplayBasename(filePath) {
-	return filePath.trim().replaceAll("\\", "/").split("/").pop()?.trim() ?? "";
+function isCodexActiveCompactTurnError(error) {
+	if (!(error instanceof CodexAppServerRpcError)) return false;
+	const data = isJsonObject(error.data) ? error.data : void 0;
+	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
+	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
 }
-function getCodexContextFileBasename(filePath) {
-	return normalizeCodexContextFilePath(filePath).split("/").pop() ?? "";
+function readCodexFinalizationHookNotification(notification, threadId, turnId) {
+	if (notification.method !== "hook/started" && notification.method !== "hook/completed") return;
+	const params = isJsonObject(notification.params) ? notification.params : void 0;
+	const run = params && isJsonObject(params.run) ? params.run : void 0;
+	if (params?.threadId !== threadId || params.turnId !== turnId || run?.eventName !== "stop" && run?.eventName !== "subagentStop" || typeof run.id !== "string" || !run.id) return;
+	if (notification.method === "hook/started") return {
+		phase: "started",
+		runId: run.id
+	};
+	return {
+		phase: "completed",
+		runId: run.id,
+		status: typeof run.status === "string" ? run.status : void 0
+	};
 }
-function normalizeCodexDynamicToolName(name) {
-	return name.trim().toLowerCase();
+function joinPresentSections(...sections) {
+	return sections.filter((section) => Boolean(section?.trim())).join("\n\n");
 }
-function isNonEmptyString$1(value) {
-	return typeof value === "string" && value.length > 0;
+function prependCurrentInboundContext(prompt, context) {
+	const text = context?.text.trim();
+	return text ? [neutralizeCodexExplicitMentionSigils(text), prompt].filter(Boolean).join("\n\n") : prompt;
+}
+function buildCodexAppServerTimeoutDiagnostics(params) {
+	const readNonBlankDetailString = (key) => {
+		const value = params.details?.[key];
+		return hasNonEmptyString(value) ? value : void 0;
+	};
+	const activeAppServerTurnRequests = asFiniteNumber(params.details?.activeAppServerTurnRequests);
+	const activeTurnItemCount = asFiniteNumber(params.details?.activeTurnItemCount);
+	const terminalTurnNotificationQueued = asBoolean(params.details?.terminalTurnNotificationQueued);
+	const completionIdleWatchArmed = asBoolean(params.details?.completionIdleWatchArmed);
+	const assistantCompletionIdleWatchArmed = asBoolean(params.details?.assistantCompletionIdleWatchArmed);
+	const terminalIdleWatchArmed = asBoolean(params.details?.terminalIdleWatchArmed);
+	return {
+		...params.idleMs !== void 0 ? { idleMs: params.idleMs } : {},
+		...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
+		...params.lastActivityReason ? { lastActivityReason: params.lastActivityReason } : {},
+		...readNonBlankDetailString("lastNotificationMethod") ? { lastNotificationMethod: readNonBlankDetailString("lastNotificationMethod") } : {},
+		...readNonBlankDetailString("lastNotificationItemId") ? { lastNotificationItemId: readNonBlankDetailString("lastNotificationItemId") } : {},
+		...readNonBlankDetailString("lastNotificationItemType") ? { lastNotificationItemType: readNonBlankDetailString("lastNotificationItemType") } : {},
+		...readNonBlankDetailString("lastNotificationItemRole") ? { lastNotificationItemRole: readNonBlankDetailString("lastNotificationItemRole") } : {},
+		...readNonBlankDetailString("lastAssistantTextPreview") ? { lastAssistantTextPreview: readNonBlankDetailString("lastAssistantTextPreview") } : {},
+		...activeAppServerTurnRequests !== void 0 ? { activeAppServerTurnRequests } : {},
+		...activeTurnItemCount !== void 0 ? { activeTurnItemCount } : {},
+		...terminalTurnNotificationQueued !== void 0 ? { terminalTurnNotificationQueued } : {},
+		...completionIdleWatchArmed !== void 0 ? { completionIdleWatchArmed } : {},
+		...assistantCompletionIdleWatchArmed !== void 0 ? { assistantCompletionIdleWatchArmed } : {},
+		...terminalIdleWatchArmed !== void 0 ? { terminalIdleWatchArmed } : {}
+	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-context.ts
@@ -3527,16 +4292,20 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		});
 		historyState.messages = await readFencedHistory() ?? historyState.messages;
 	}
+	const memoryToolNames = getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs);
 	const workspaceBootstrapContext = await buildCodexWorkspaceBootstrapContext({
 		params: runtimeParams,
-		resolvedWorkspace,
+		resolvedWorkspace: runtimeParams.bootstrapWorkspaceDir ?? resolvedWorkspace,
+		executionWorkspace: resolvedWorkspace,
 		effectiveWorkspace,
 		sessionKey: contextSessionKey,
 		sessionAgentId,
-		memoryToolNames: getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs),
+		memoryToolNames,
+		ringZeroActive: isHostScopedAgentToolActive("openclaw") && isSystemAgentOnlyCodexDynamicToolAllowlist(runtimeParams.toolsAllow),
 		sandboxed: sandbox?.enabled === true
 	});
-	const baseDeveloperInstructions = buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs });
+	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions ? connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions ?? workspaceBootstrapContext.threadDeveloperInstructions : void 0;
+	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
 	return {
 		runtime,
 		attemptTools,
@@ -3547,6 +4316,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		hookRunner,
 		buildActiveContextEngineRuntimeContext,
 		workspaceBootstrapContext,
+		agentWorkspaceDeveloperInstructions,
 		baseDeveloperInstructions,
 		openClawPromptContext: buildCodexOpenClawPromptContext({
 			params: runtimeParams,
@@ -3570,11 +4340,16 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 			contextEngineProjection: void 0,
 			precomputedStaleBindingContinuityProjectionApplied: false,
 			staleBindingContinuityForcedFreshStart: false,
+			noEngineContinuityProjectionApplied: false,
 			inactiveThreadBootstrapBindingForcedFreshStart: initialInactiveThreadBootstrapBindingForcedFreshStart
 		},
 		codexContextProjectionMaxChars: resolveCodexContextEngineProjectionMaxChars({
 			contextTokenBudget: effectiveContextTokenBudget,
 			reserveTokens: resolveCodexContextEngineProjectionReserveTokens()
+		}),
+		codexContinuityProjectionMaxChars: resolveCodexContinuityProjectionMaxChars({
+			contextTokenBudget: effectiveContextTokenBudget,
+			calibration: connection.mutable.continuityCalibration
 		})
 	};
 }
@@ -3785,105 +4560,6 @@ function isInvalidCodexImagePayloadError(message) {
 	return /\b(?:invalid|malformed)\b[\s\S]{0,120}\b(?:image|image url|base64)\b/iu.test(normalizedMessage) || /\b(?:image|image url|base64)\b[\s\S]{0,120}\b(?:invalid|malformed)\b/iu.test(normalizedMessage);
 }
 //#endregion
-//#region extensions/codex/src/app-server/run-attempt-state.ts
-async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields) {
-	const currentBinding = await bindingStore.read(identity);
-	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
-	if (!expectedThreadId) return;
-	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
-		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
-			...fields,
-			boundThreadId: currentBinding.threadId
-		});
-		return;
-	}
-	if (currentBinding?.connectionScope === "supervision") {
-		embeddedAgentLog.warn("codex app-server image payload error detected for supervised thread; preserving native binding", fields);
-		return;
-	}
-	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
-	await bindingStore.mutate(identity, {
-		kind: "clear",
-		threadId: expectedThreadId
-	});
-}
-async function markCodexAppServerBindingCoveredThroughTurn(params) {
-	await params.bindingStore.mutate(params.identity, {
-		kind: "patch",
-		threadId: params.threadId,
-		patch: { historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString() }
-	});
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.length > 0;
-}
-function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
-	if (!params.contextEngineActive || params.thread.lifecycle.action !== "resumed") return false;
-	const message = formatErrorMessage(params.error);
-	return /ran out of room in the model'?s context window/iu.test(message) || /context window/iu.test(message) || /context length/iu.test(message) || /maximum context/iu.test(message) || /too many tokens/iu.test(message);
-}
-function isCodexActiveCompactTurnError(error) {
-	if (!(error instanceof CodexAppServerRpcError)) return false;
-	const data = isJsonObject(error.data) ? error.data : void 0;
-	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
-	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
-}
-function readCodexFinalizationHookNotification(notification, threadId, turnId) {
-	if (notification.method !== "hook/started" && notification.method !== "hook/completed") return;
-	const params = isJsonObject(notification.params) ? notification.params : void 0;
-	const run = params && isJsonObject(params.run) ? params.run : void 0;
-	if (params?.threadId !== threadId || params.turnId !== turnId || run?.eventName !== "stop" && run?.eventName !== "subagentStop" || typeof run.id !== "string" || !run.id) return;
-	if (notification.method === "hook/started") return {
-		phase: "started",
-		runId: run.id
-	};
-	return {
-		phase: "completed",
-		runId: run.id,
-		status: typeof run.status === "string" ? run.status : void 0
-	};
-}
-function joinPresentSections(...sections) {
-	return sections.filter((section) => Boolean(section?.trim())).join("\n\n");
-}
-function prependCurrentInboundContext(prompt, context) {
-	const text = context?.text.trim();
-	return text ? [neutralizeCodexExplicitMentionSigils(text), prompt].filter(Boolean).join("\n\n") : prompt;
-}
-function waitForCodexNotificationDispatchTurn() {
-	return new Promise((resolve) => {
-		setImmediate(resolve);
-	});
-}
-function buildCodexAppServerTimeoutDiagnostics(params) {
-	const readNonBlankDetailString = (key) => {
-		const value = params.details?.[key];
-		return hasNonEmptyString(value) ? value : void 0;
-	};
-	const activeAppServerTurnRequests = asFiniteNumber(params.details?.activeAppServerTurnRequests);
-	const activeTurnItemCount = asFiniteNumber(params.details?.activeTurnItemCount);
-	const terminalTurnNotificationQueued = asBoolean(params.details?.terminalTurnNotificationQueued);
-	const completionIdleWatchArmed = asBoolean(params.details?.completionIdleWatchArmed);
-	const assistantCompletionIdleWatchArmed = asBoolean(params.details?.assistantCompletionIdleWatchArmed);
-	const terminalIdleWatchArmed = asBoolean(params.details?.terminalIdleWatchArmed);
-	return {
-		...params.idleMs !== void 0 ? { idleMs: params.idleMs } : {},
-		...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
-		...params.lastActivityReason ? { lastActivityReason: params.lastActivityReason } : {},
-		...readNonBlankDetailString("lastNotificationMethod") ? { lastNotificationMethod: readNonBlankDetailString("lastNotificationMethod") } : {},
-		...readNonBlankDetailString("lastNotificationItemId") ? { lastNotificationItemId: readNonBlankDetailString("lastNotificationItemId") } : {},
-		...readNonBlankDetailString("lastNotificationItemType") ? { lastNotificationItemType: readNonBlankDetailString("lastNotificationItemType") } : {},
-		...readNonBlankDetailString("lastNotificationItemRole") ? { lastNotificationItemRole: readNonBlankDetailString("lastNotificationItemRole") } : {},
-		...readNonBlankDetailString("lastAssistantTextPreview") ? { lastAssistantTextPreview: readNonBlankDetailString("lastAssistantTextPreview") } : {},
-		...activeAppServerTurnRequests !== void 0 ? { activeAppServerTurnRequests } : {},
-		...activeTurnItemCount !== void 0 ? { activeTurnItemCount } : {},
-		...terminalTurnNotificationQueued !== void 0 ? { terminalTurnNotificationQueued } : {},
-		...completionIdleWatchArmed !== void 0 ? { completionIdleWatchArmed } : {},
-		...assistantCompletionIdleWatchArmed !== void 0 ? { assistantCompletionIdleWatchArmed } : {},
-		...terminalIdleWatchArmed !== void 0 ? { terminalIdleWatchArmed } : {}
-	};
-}
-//#endregion
 //#region extensions/codex/src/app-server/settled-turn-context.ts
 function collectUniqueMessageIdentities(messages) {
 	const identities = /* @__PURE__ */ new Map();
@@ -3973,100 +4649,17 @@ async function captureCodexSettledTurnFinalizationContext(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
-const SENSITIVE_FIELD_RE = /(?:authorization|cookie|credential|key|password|passwd|secret|token)/iu;
-const PRIVATE_PAYLOAD_FIELD_RE = /(?:image|screenshot|attachment|fileData|dataUri)/iu;
-const AUTHORIZATION_VALUE_RE = /\b(Bearer|Basic)\s+[A-Za-z0-9+/._~=-]{8,}/giu;
-const JWT_VALUE_RE = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/gu;
-const COOKIE_PAIR_RE = /\b([A-Za-z][A-Za-z0-9_.-]{1,64})=([A-Za-z0-9+/._~%=-]{16,})(?=;|\s|$)/gu;
-const TRAJECTORY_RUNTIME_EVENT_MAX_BYTES = 256 * 1024;
-const TRAJECTORY_RUNTIME_OVERSIZE_PRESERVED_DATA_KEYS = ["usage", "promptCache"];
-function boundedTrajectoryEvent(event) {
-	const line = JSON.stringify(event);
-	const bytes = Buffer.byteLength(line, "utf8");
-	if (bytes <= TRAJECTORY_RUNTIME_EVENT_MAX_BYTES) return event;
-	const originalData = event.data && typeof event.data === "object" && !Array.isArray(event.data) ? event.data : {};
-	const originalDataKeys = Object.keys(originalData);
-	const preservedDataKeys = /* @__PURE__ */ new Set();
-	const baseData = {
-		truncated: true,
-		originalBytes: bytes,
-		limitBytes: TRAJECTORY_RUNTIME_EVENT_MAX_BYTES,
-		reason: "trajectory-event-size-limit"
-	};
-	const buildTruncatedEvent = (includeDroppedFields) => {
-		const data = { ...baseData };
-		for (const key of TRAJECTORY_RUNTIME_OVERSIZE_PRESERVED_DATA_KEYS) if (preservedDataKeys.has(key)) data[key] = originalData[key];
-		if (includeDroppedFields) {
-			const droppedFields = originalDataKeys.filter((key) => !preservedDataKeys.has(key));
-			if (droppedFields.length > 0) data.droppedFields = droppedFields;
-		}
-		const truncatedEvent = {
-			...event,
-			data
-		};
-		const truncated = JSON.stringify(truncatedEvent);
-		if (Buffer.byteLength(truncated, "utf8") <= TRAJECTORY_RUNTIME_EVENT_MAX_BYTES) return truncatedEvent;
-	};
-	let best = buildTruncatedEvent(true) ?? buildTruncatedEvent(false);
-	if (!best) return;
-	for (const key of TRAJECTORY_RUNTIME_OVERSIZE_PRESERVED_DATA_KEYS) {
-		if (!Object.hasOwn(originalData, key)) continue;
-		preservedDataKeys.add(key);
-		const next = buildTruncatedEvent(true) ?? buildTruncatedEvent(false);
-		if (next) {
-			best = next;
-			continue;
-		}
-		preservedDataKeys.delete(key);
-	}
-	return best;
-}
-function createCodexHostTrajectorySink(params) {
-	return {
-		write: (event) => {
-			params.recorder.recordEvent(event.type, event.data);
-		},
-		flush: async () => {
-			await params.recorder.flush();
-		}
-	};
-}
-/** Creates a trajectory recorder when trajectory capture is enabled for the environment. */
+/** Creates a trajectory recorder when the host exposes its capture capability. */
 function createCodexTrajectoryRecorder(params) {
-	if (!parseTrajectoryEnabled(params.env ?? process.env)) return null;
-	if (!params.trajectoryRecorder) {
-		params.warn?.("codex trajectory capture requires the SQLite host recorder", {
-			sessionId: params.attempt.sessionId,
-			reason: "sqlite-recorder-unavailable"
-		});
-		return null;
-	}
-	const sink = createCodexHostTrajectorySink({ recorder: params.trajectoryRecorder });
-	let seq = 0;
-	const attribution = resolveCodexLocalRuntimeAttribution(params.attempt);
+	if (!params.trajectory) return null;
+	const trajectory = params.trajectory;
 	return {
 		recordEvent: (type, data) => {
-			const event = boundedTrajectoryEvent({
-				traceSchema: "openclaw-trajectory",
-				schemaVersion: 1,
-				traceId: params.attempt.sessionId,
-				source: "runtime",
-				type,
-				ts: (/* @__PURE__ */ new Date()).toISOString(),
-				seq: seq += 1,
-				sourceSeq: seq,
-				sessionId: params.attempt.sessionId,
-				sessionKey: params.attempt.sessionKey,
-				runId: params.attempt.runId,
-				workspaceDir: params.cwd,
-				provider: attribution.provider,
-				modelId: params.attempt.modelId,
-				modelApi: attribution.api,
-				data: data ? sanitizeValue(data) : void 0
-			});
-			if (event) sink.write(event);
+			try {
+				trajectory.recordEvent(type, data);
+			} catch {}
 		},
-		flush: sink.flush
+		flush: trajectory.flush
 	};
 }
 /** Records compiled prompt/tool context at the start of a Codex runtime attempt. */
@@ -4095,12 +4688,6 @@ function recordCodexTrajectoryCompletion(recorder, params) {
 		messagesSnapshot: params.result.messagesSnapshot
 	});
 }
-function parseTrajectoryEnabled(env) {
-	const value = env.OPENCLAW_TRAJECTORY?.trim().toLowerCase();
-	if (value === "1" || value === "true" || value === "yes" || value === "on") return true;
-	if (value === "0" || value === "false" || value === "no" || value === "off") return false;
-	return true;
-}
 function toTrajectoryToolDefinitions(tools) {
 	if (!tools || tools.length === 0) return;
 	return flattenCodexDynamicToolFunctions(tools).flatMap((tool) => {
@@ -4109,31 +4696,10 @@ function toTrajectoryToolDefinitions(tools) {
 		return [{
 			name,
 			description: tool.description,
-			parameters: sanitizeValue(tool.inputSchema)
+			parameters: tool.inputSchema
 		}];
 	}).toSorted((left, right) => left.name.localeCompare(right.name));
 }
-function sanitizeValue(value, depth = 0, key = "") {
-	if (value == null || typeof value === "boolean" || typeof value === "number") return value;
-	if (typeof value === "string") {
-		if (SENSITIVE_FIELD_RE.test(key)) return "<redacted>";
-		if (value.startsWith("data:") && value.length > 256) return `<redacted data-uri ${value.slice(0, value.indexOf(",")).length} chars>`;
-		if (PRIVATE_PAYLOAD_FIELD_RE.test(key) && value.length > 256) return "<redacted payload>";
-		const redacted = redactSensitiveString(value);
-		return redacted.length > 2e4 ? `${truncateUtf16Safe(redacted, 2e4)}…` : redacted;
-	}
-	if (depth >= 6) return "<truncated>";
-	if (Array.isArray(value)) return value.slice(0, 100).map((entry) => sanitizeValue(entry, depth + 1, key));
-	if (typeof value === "object") {
-		const next = {};
-		for (const [keyLocal, child] of Object.entries(value).slice(0, 100)) next[keyLocal] = sanitizeValue(child, depth + 1, keyLocal);
-		return next;
-	}
-	return JSON.stringify(value);
-}
-function redactSensitiveString(value) {
-	return value.replace(AUTHORIZATION_VALUE_RE, "$1 <redacted>").replace(JWT_VALUE_RE, "<redacted-jwt>").replace(COOKIE_PAIR_RE, "$1=<redacted>");
-}
 /** Converts arbitrary prompt errors into trajectory-safe text. */
 function normalizeCodexTrajectoryError(value) {
 	if (!value) return null;
@@ -4154,7 +4720,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { hookContextWindowFields, hookRunner } = context;
 	const { connection, preparedAuthBinding } = runtime;
 	const { effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
-	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, attemptStartedAt, startupAuthProfileId } = connection;
+	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, agentDir, attemptStartedAt, startupAuthProfileId } = connection;
 	const { toolBridge, toolState } = attemptTools;
 	const { state, completion, pendingOpenClawDynamicToolCompletionIds, activeTurnItemIds, activeCompletionBlockerItemIds, activeFinalizationHookRunIds, turnWatches } = turnRuntime;
 	const { emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
@@ -4162,7 +4728,20 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, activeProjector, streamState, freezeRunTerminalOutcome, notifyUserMessagePersisted } = activeTurn;
 	await completion;
-	await drainNotificationQueue();
+	await state.abortCleanup;
+	const drain = drainNotificationQueue();
+	const abortGraceElapsed = createDeferred();
+	let abortGraceTimer;
+	const abortListener = addAbortListener(runAbortController.signal, () => {
+		abortGraceTimer = setTimeout(() => abortGraceElapsed.resolve(), TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
+		abortGraceTimer.unref?.();
+	});
+	try {
+		await Promise.race([drain, abortGraceElapsed.promise]);
+	} finally {
+		abortListener[Symbol.dispose]();
+		clearTimeout(abortGraceTimer);
+	}
 	const hasQuiescentCompletedAssistant = activeProjector.hasCompletedTerminalAssistantText() && state.activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && activeFinalizationHookRunIds.size === 0 && state.unsettledFinalizationHookCount === 0 && state.rejectedFinalizationHookAssistant === void 0;
 	const hasRecoverableCompletedAssistant = !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && turnWatches.isAssistantCompletionIdleWatchArmed() && hasQuiescentCompletedAssistant;
 	const recoveredTurnWatchTimeout = state.turnCompletionIdleTimedOut && !terminalState.explicitCancellationObserved && hasRecoverableCompletedAssistant && activeProjector.recoverCompletedTerminalAssistantAfterTurnWatchTimeout();
@@ -4186,9 +4765,9 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const projectedTerminal = attemptTerminal.project(result.terminal);
 	const effectiveTimedOut = state.timedOut && !recoveredTurnWatchTimeout;
 	const effectiveTurnCompletionIdleTimedOut = state.turnCompletionIdleTimedOut && !recoveredTurnWatchTimeout;
-	const isFinalAborted = () => projectedTerminal.aborted || terminalState.explicitCancellationObserved || runAbortController.signal.aborted && !state.clientClosedAbort && !recoveredTurnWatchTimeout;
+	const isFinalAborted = () => terminalState.explicitCancellationObserved || !resourceState.executionDisconnectError && (projectedTerminal.aborted || runAbortController.signal.aborted && !state.clientClosedAbort && !recoveredTurnWatchTimeout);
 	const clientClosedPromptErrorForFinal = state.clientClosedPromptError && hasRecoverableCompletedAssistant ? void 0 : state.clientClosedPromptError;
-	let finalPromptError = clientClosedPromptErrorForFinal ?? (effectiveTurnCompletionIdleTimedOut ? state.turnCompletionIdleTimeoutMessage : effectiveTimedOut ? "codex app-server attempt timed out" : projectedTerminal.promptError);
+	let finalPromptError = resourceState.executionDisconnectError ?? clientClosedPromptErrorForFinal ?? (effectiveTurnCompletionIdleTimedOut ? state.turnCompletionIdleTimeoutMessage : effectiveTimedOut ? "codex app-server attempt timed out" : projectedTerminal.promptError);
 	const finalPromptErrorMessage = typeof finalPromptError === "string" ? finalPromptError : finalPromptError instanceof Error ? finalPromptError.message : finalPromptError ? formatErrorMessage(finalPromptError) : void 0;
 	if (isInvalidCodexImagePayloadError(finalPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 		phase: "turn_completed",
@@ -4229,6 +4808,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		authProfileId: startupAuthProfileId,
 		rateLimits: readRecentCodexRateLimits(resourceState.client)
 	});
+	finalPromptError = resourceState.executionDisconnectError ?? finalPromptError;
 	const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : projectedTerminal.promptErrorSource;
 	const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : effectiveTurnCompletionIdleTimedOut ? "turn_completion_idle_timeout" : void 0;
 	const replayBlockedReason = codexAppServerFailureKind ? resolveCodexAppServerReplayBlockedReason(result) : void 0;
@@ -4332,20 +4912,11 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			modelIterations: result.modelIterations ?? 0,
 			skillWorkshopAvailable: flattenCodexDynamicToolFunctions(attemptTools.toolBridge.availableSpecs).some((tool) => tool.name === "skill_workshop"),
 			compacted: (result.compactionCount ?? 0) > 0,
-			messageChannel: params.messageChannel,
-			messageProvider: params.messageProvider,
-			chatType: params.chatType,
-			agentAccountId: params.agentAccountId,
-			groupId: params.groupId,
-			groupChannel: params.groupChannel,
-			groupSpace: params.groupSpace,
-			memberRoleIds: params.memberRoleIds,
-			spawnedBy: params.spawnedBy,
 			senderId: params.senderId ?? void 0,
-			senderName: params.senderName,
-			senderUsername: params.senderUsername,
-			senderE164: params.senderE164,
-			senderIsOwner: params.senderIsOwner
+			foregroundPromptContext: buildEmbeddedForegroundPromptContext({
+				...params,
+				agentId: sessionAgentId
+			}, agentDir)
 		},
 		hookRunner
 	});
@@ -4354,7 +4925,11 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		await markCodexAppServerBindingCoveredThroughTurn({
 			bindingStore,
 			identity: bindingIdentity,
-			threadId: resourceState.thread.threadId
+			threadId: resourceState.thread.threadId,
+			continuityCalibration: context.promptState.noEngineContinuityProjectionApplied ? buildCodexContinuityCalibration({
+				promptChars: prompt.turnState.codexTurnPromptText.length,
+				inputTokens: (result.attemptUsage?.input ?? 0) + (result.attemptUsage?.cacheRead ?? 0) + (result.attemptUsage?.cacheWrite ?? 0)
+			}) : void 0
 		});
 	} catch (error) {
 		if (resourceState.thread.connectionScope === "supervision") throw error;
@@ -4407,6 +4982,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	});
 	const finalizedResult = {
 		...result,
+		...toolState.yieldAcknowledgment ? { yieldAcknowledgment: toolState.yieldAcknowledgment } : {},
 		terminal: attemptTerminal.normalize({
 			timedOut: effectiveTimedOut,
 			aborted: finalAborted,
@@ -4420,6 +4996,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		...terminalAnchor ? { contextEngineTerminalAnchor: terminalAnchor } : {},
 		...settledTurnFinalizationContext ? { settledTurnFinalizationContext } : {},
 		...resourceState.runtimeArtifact ? { runtimeArtifact: resourceState.runtimeArtifact } : {},
+		...resourceState.runtimeContinuationStarted ? { runtimeContinuationStarted: true } : {},
 		...!finalAborted && !effectiveTimedOut && !finalPromptError && preparedAuthBinding ? { authBindingFingerprint: preparedAuthBinding.fingerprint } : {},
 		systemPromptReport
 	};
@@ -4764,7 +5341,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		state.turnCrossedToolHandoff = notificationState.turnCrossedToolHandoff;
 		if (notificationState.isCurrentTurnNotification && notification.method === "item/completed") {
 			const item = readCodexNotificationItem(notification.params);
-			if (item?.type === "userMessage" && typeof item.clientId === "string") steeringQueue?.confirmConsumed(item.clientId);
+			if (item?.type === "userMessage" && typeof item.clientId === "string") await steeringQueue?.confirmConsumed(item.clientId);
 		}
 		if (notificationState.isTurnAbortMarker) state.sawCodexInterruptMarker = true;
 		const hookNotification = readCodexFinalizationHookNotification(notification, resourceState.thread.threadId, turnId);
@@ -4775,7 +5352,6 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		}
 		if (notificationState.isTurnTerminal) state.terminalTurnNotificationQueued = true;
 		try {
-			await waitForCodexNotificationDispatchTurn();
 			await projector.handleNotification(notification);
 			const canRelease = isAssistantCompletionReleaseNotification(notification, state.turnCrossedToolHandoff) || notificationState.isCurrentTurnNotification && state.turnCrossedToolHandoff && notification.method === "rawResponseItem/completed" && projector.canReleaseLatestTerminalAssistantAfterToolHandoff();
 			if (notificationState.isCurrentTurnNotification && canRelease) {
@@ -4871,11 +5447,12 @@ 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() === "*");
 }
 async function prepareCodexAttemptPrompt(context) {
-	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, openClawPromptContext, skillsCollaborationInstructions, promptState, codexContextProjectionMaxChars } = context;
+	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, openClawPromptContext, skillsCollaborationInstructions, promptState, codexContextProjectionMaxChars, codexContinuityProjectionMaxChars } = context;
 	const { connection, buildActiveRunAttemptParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
 	const { params, activeContextEngine, usesSupervisionConnection, mutable, isInactiveThreadBootstrapBinding, bindingStore, bindingIdentity, agentDir, appServer, contextSessionKey, effectiveWorkspace, sandbox } = connection;
 	const { toolBridge } = attemptTools;
@@ -4884,11 +5461,12 @@ async function prepareCodexAttemptPrompt(context) {
 			assembledMessages: historyState.messages,
 			originalHistoryMessages: historyState.messages,
 			prompt: params.prompt,
-			maxRenderedContextChars: codexContextProjectionMaxChars
+			maxRenderedContextChars: codexContinuityProjectionMaxChars
 		});
 		promptState.promptText = projection.promptText;
 		promptState.promptContextRange = projection.promptContextRange;
 		promptState.prePromptMessageCount = projection.prePromptMessageCount;
+		promptState.noEngineContinuityProjectionApplied = true;
 	};
 	const applyActiveContextEngineProjection = async (decisionStartupBinding) => {
 		if (!activeContextEngine) return;
@@ -4962,15 +5540,21 @@ async function prepareCodexAttemptPrompt(context) {
 	}
 	const codexModelInputHistoryMessages = [];
 	const buildPromptFromCurrentInputs = async () => {
-		const result = await resolveAgentHarnessBeforePromptBuildResult({
+		return await resolveAgentHarnessBeforePromptBuildResult({
 			prompt: prependCurrentInboundContext(promptState.promptText, params.currentInboundContext),
-			developerInstructions: promptState.developerInstructions,
+			developerInstructions: { build: ({ toolsAllow }) => {
+				if (isRestrictivePromptToolsAllow(toolsAllow)) throw new Error("Codex app-server cannot enforce before_prompt_build toolsAllow; use the embedded or Copilot runtime for turn-scoped tool policy.");
+				return promptState.developerInstructions;
+			} },
 			messages: structuredClone(historyState.messages),
 			ctx: hookContext,
-			bootstrapContextRunKind: params.bootstrapContextRunKind
+			bootstrapContextRunKind: params.bootstrapContextRunKind,
+			toolAuthority: {
+				fingerprint: params.toolAuthorityFingerprint,
+				activeToolNames: () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString),
+				assertActive: params.hostCapabilities.assertActive
+			}
 		});
-		if (isRestrictivePromptToolsAllow(result.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 result;
 	};
 	const resolveShiftedPromptInputRange = (prompt, promptInputRange, turnPromptText) => {
 		if (!promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !turnPromptText.endsWith(prompt)) return;
@@ -5040,12 +5624,11 @@ 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 record = message;
-			const meta = record["__openclaw"];
+			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 timestamp = typeof message.timestamp === "number" ? message.timestamp : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
-			return !(typeof record.idempotencyKey === "string" && record.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:")) && mirrorOrigin !== "codex-app-server" && !(typeof mirrorIdentity === "string" && mirrorIdentity.startsWith("codex-app-server:")) && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
 		});
 	};
 	const applyResumeStaleBindingContinuityProjection = (binding) => {
@@ -5055,11 +5638,12 @@ async function prepareCodexAttemptPrompt(context) {
 			assembledMessages: newerVisibleMessages,
 			originalHistoryMessages: historyState.messages,
 			prompt: params.prompt,
-			maxRenderedContextChars: codexContextProjectionMaxChars
+			maxRenderedContextChars: codexContinuityProjectionMaxChars
 		});
 		promptState.promptText = projection.promptText;
 		promptState.promptContextRange = projection.promptContextRange;
 		promptState.prePromptMessageCount = projection.prePromptMessageCount;
+		promptState.noEngineContinuityProjectionApplied = true;
 		return true;
 	};
 	const precomputeNoContextEngineStaleBindingProjection = () => {
@@ -5171,15 +5755,13 @@ function prepareCodexAttemptResources(prompt) {
 	const { connection, hookChannelId } = runtime;
 	const { appServer, params, effectiveCwd, sessionAgentId, sandboxSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
 	const { toolBridge } = attemptTools;
-	const hostTrajectoryRecorder = params.trajectoryRecorder;
 	const trajectoryRecorder = createCodexTrajectoryRecorder({
 		attempt: params,
 		cwd: effectiveCwd,
 		developerInstructions: buildRenderedCodexDeveloperInstructions(),
 		prompt: turnState.codexTurnPromptText,
-		trajectoryRecorder: hostTrajectoryRecorder,
-		tools: toolBridge.availableSpecs,
-		warn: (message, fields) => embeddedAgentLog.warn(message, fields)
+		trajectory: params.hostCapabilities.trajectory,
+		tools: toolBridge.availableSpecs
 	});
 	const state = {
 		client: void 0,
@@ -5192,12 +5774,14 @@ function prepareCodexAttemptResources(prompt) {
 		trajectoryEndRecorded: false,
 		nativeHookRelay: void 0,
 		nativeSubagentMonitor: void 0,
+		runtimeContinuationStarted: false,
 		nativePreToolUseFailureFallbackActive: false,
 		nativePreToolUseFailureFallbackTerminalReason: void 0,
 		releaseSharedClientLease: void 0,
 		startupClientUnsafe: false,
 		sharedCodexClientRetiredForOneShotCleanup: false,
-		sandboxExecEnvironmentAcquired: false,
+		sandboxExecEnvironment: void 0,
+		executionDisconnectError: void 0,
 		codexEnvironmentSelection: void 0,
 		codexExecutionCwd: effectiveCwd,
 		codexSandboxPolicy: void 0,
@@ -5236,7 +5820,7 @@ function prepareCodexAttemptResources(prompt) {
 		if (params.cleanupBundleMcpOnRunEnd !== true || state.sharedCodexClientRetiredForOneShotCleanup) return;
 		state.sharedCodexClientRetiredForOneShotCleanup = true;
 		const retired = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(state.client);
-		embeddedAgentLog.info("codex app-server one-shot cleanup checked shared client retirement", {
+		embeddedAgentLog.debug("codex app-server one-shot cleanup checked shared client retirement", {
 			runId: params.runId,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -5250,16 +5834,27 @@ function prepareCodexAttemptResources(prompt) {
 			forceKillDelayMs: 250
 		});
 	};
+	const releaseSandboxExecEnvironment = async () => {
+		if (state.sandboxExecEnvironment) {
+			const environment = state.sandboxExecEnvironment;
+			state.sandboxExecEnvironment = void 0;
+			await releaseCodexSandboxExecServerEnvironment(sandbox, environment);
+		}
+	};
 	const releaseSharedClientLeaseAndRetireOneShotClient = async () => {
+		if (connection.attemptClientFactory === createIsolatedCodexAppServerClient) {
+			await releaseSandboxExecEnvironment();
+			const ownedClient = state.releaseSharedClientLease ? state.client : void 0;
+			releaseSharedClientLeaseOnce();
+			await ownedClient?.closeAndWait({
+				exitTimeoutMs: 2e3,
+				forceKillDelayMs: 250
+			});
+			return;
+		}
 		releaseSharedClientLeaseOnce();
 		await retireSharedCodexClientForOneShotCleanup();
 	};
-	const releaseSandboxExecEnvironment = async () => {
-		if (state.sandboxExecEnvironmentAcquired) {
-			state.sandboxExecEnvironmentAcquired = false;
-			await releaseCodexSandboxExecServerEnvironment(sandbox);
-		}
-	};
 	const runCleanupStep = (step, operation) => runAgentCleanupStep({
 		runId: params.runId,
 		sessionId: params.sessionId,
@@ -5284,7 +5879,10 @@ function prepareCodexAttemptResources(prompt) {
 			retainClient: () => retainSharedCodexAppServerClientIfCurrent(state.client),
 			retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(state.client, protectedThreadId),
 			claimDirectChild: (childThreadId) => state.nativeHookRelay?.claimDirectChild(childThreadId),
-			rejectPendingDirectChild: (childThreadId, reason) => state.nativeHookRelay?.rejectPendingDirectChild(childThreadId, reason)
+			rejectPendingDirectChild: (childThreadId, reason) => state.nativeHookRelay?.rejectPendingDirectChild(childThreadId, reason),
+			...params.sessionKey && params.agentHarnessTaskRuntimeScope ? { onDirectChildAccepted: () => {
+				state.runtimeContinuationStarted = true;
+			} } : {}
 		});
 	};
 	const releaseCurrentRoute = () => {
@@ -5347,8 +5945,7 @@ function prepareCodexAttemptResources(prompt) {
 			configPatch: state.nativeHookRelay ? buildCodexNativeHookRelayConfig({
 				relay: state.nativeHookRelay,
 				events: nativeHookRelayEvents,
-				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec,
-				loopDetectionPreToolUseRelay: appServer.loopDetectionPreToolUseRelay
+				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
 			}) : options.nativeHookRelay?.enabled === false ? buildCodexNativeHookRelayDisabledConfig() : void 0,
 			nativeHookRelayGeneration: state.nativeHookRelay?.generation
 		};
@@ -5480,10 +6077,6 @@ function resolveScheduledCodexAppCreatorCaptureDecision(params) {
 		...unavailableReason ? { unavailableReason } : {}
 	};
 }
-function readConnectorId(tool) {
-	const meta = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
-	return normalizeOptionalString(meta?.connector_id) ?? normalizeOptionalString(meta?.connectorId);
-}
 function normalizeApprovalMode(value) {
 	return value === "allow" || value === "deny" || value === "auto" || value === "ask" ? value : void 0;
 }
@@ -5550,7 +6143,7 @@ async function readCodexScheduledAppToolNamesByApp(params) {
 			if (!isJsonObject(status) || !isJsonObject(status.tools)) throw new Error("Codex scheduled app inventory contained an invalid server status");
 			if (status.name !== CODEX_APPS_MCP_SERVER) continue;
 			for (const [toolName, tool] of Object.entries(status.tools)) {
-				const connectorId = readConnectorId(tool);
+				const connectorId = readCodexMcpToolConnectorId(tool);
 				if (connectorId) {
 					const names = toolNamesByApp.get(connectorId) ?? /* @__PURE__ */ new Set();
 					names.add(toolName);
@@ -5783,8 +6376,8 @@ async function prepareCodexAttemptRuntime(connection) {
 	const effectiveContextWindowInfo = usesSupervisionConnection ? void 0 : params.contextWindowInfo;
 	const effectiveContextTokenBudget = usesSupervisionConnection ? void 0 : params.contextTokenBudget;
 	const effectiveRuntimeProviderId = usesSupervisionConnection ? mutable.startupBinding?.modelProvider ?? "codex" : params.provider;
-	const effectiveRuntimeModelId = usesSupervisionConnection ? mutable.startupBinding?.model ?? "codex-native" : params.modelId;
-	const { authProfileId: _outerAuthProfileId, contextWindowInfo: _outerContextWindowInfo, contextTokenBudget: _outerContextTokenBudget, model: _outerModel, modelId: _outerModelId, provider: _outerProvider, runtimePlan: _outerRuntimePlan, requestedModelId: _outerRequestedModelId, fallbackReason: _outerFallbackReason, degradedReason: _outerDegradedReason, thinkLevel: _outerThinkLevel, fastMode: _outerFastMode, ...paramsWithoutOuterNativeOwnership } = params;
+	const effectiveRuntimeModelId = usesSupervisionConnection ? mutable.startupBinding?.model ?? "codex-native" : connection.options.runtimeModelId ?? params.modelId;
+	const { authProfileId: _outerAuthProfileId, authoredContextTokenCap: _outerAuthoredContextTokenCap, contextWindowInfo: _outerContextWindowInfo, contextTokenBudget: _outerContextTokenBudget, model: _outerModel, modelId: _outerModelId, provider: _outerProvider, runtimePlan: _outerRuntimePlan, requestedModelId: _outerRequestedModelId, fallbackReason: _outerFallbackReason, degradedReason: _outerDegradedReason, thinkLevel: _outerThinkLevel, fastMode: _outerFastMode, ...paramsWithoutOuterNativeOwnership } = params;
 	const supervisedRuntimeModel = {
 		id: effectiveRuntimeModelId,
 		name: effectiveRuntimeModelId,
@@ -6017,18 +6610,23 @@ function resolveCodexDynamicToolDirectNames(params, hostSystemAgentActive = fals
 	const names = [];
 	if (hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow)) names.push("openclaw");
 	if (params.sourceReplyDeliveryMode === "message_tool_only") names.push("message");
-	if (params.pluginHarnessToolPolicyRestricted === true) names.push("update_plan");
+	names.push("progress_card");
 	return names;
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-server-requests.ts
+const DYNAMIC_TOOL_TERMINAL_DIAGNOSTIC_TYPES = [
+	"tool.execution.completed",
+	"tool.execution.error",
+	"tool.execution.blocked"
+];
 function createCodexAttemptServerRequestController(resources, turnRuntime, lifecycle) {
 	const { prompt, state: resourceState, projectorRef, trajectoryRecorder } = resources;
 	const { context } = prompt;
 	const { runtime, attemptTools } = context;
 	const { connection } = runtime;
-	const { params, computerUseConfig, runAbortController, appServer, approvalPolicyPromotedForOpenClawToolPolicy, sessionAgentId } = connection;
-	const { toolBridge, toolOutcomeOrdinals, suppressedDynamicToolOutcomeOrdinals, allocateCodexToolOutcomeOrdinal } = attemptTools;
+	const { params, computerUseConfig, runAbortController, appServer, sessionAgentId } = connection;
+	const { compactionPlanState, toolBridge, toolOutcomeOrdinals, suppressedDynamicToolOutcomeOrdinals, allocateCodexToolOutcomeOrdinal } = attemptTools;
 	const { state, turnIdRef, userInputBridgeRef, openClawDynamicToolExecutions, pendingOpenClawDynamicToolCompletionIds, postToolRawAssistantCompletionIdleTimeoutMs, turnWatches } = turnRuntime;
 	const { emitExecutionPhaseOnce, scheduleTurnReleaseAfterTerminalDynamicTool, scheduleTerminalDynamicToolReleaseCheck } = lifecycle;
 	const handleServerRequest = async (request, scope, requestSignal = new AbortController().signal) => {
@@ -6054,7 +6652,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					armCompletionWatchOnResponse = true;
 					markCurrentTurnRequestProgress();
 				}
-				return await handleCodexAppServerElicitationRequest({
+				const approvalResult = await routeCodexAppServerElicitationRequest({
 					requestParams: request.params,
 					paramsForRun: params,
 					threadId: resourceState.thread.threadId,
@@ -6063,6 +6661,11 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					...computerUseConfig.enabled ? { computerUseMcpServerName: computerUseConfig.mcpServerName } : {},
 					signal
 				});
+				if (approvalResult.kind === "handled") return approvalResult.response;
+				return await userInputBridgeRef.current?.handleElicitationRequest({
+					id: request.id,
+					params: request.params
+				});
 			}
 			if (request.method === "item/tool/requestUserInput") {
 				if (scope.turnId === turnId) {
@@ -6088,9 +6691,8 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						turnId,
 						nativeHookRelay: resourceState.nativeHookRelay,
 						autoApprove: shouldAutoApproveCodexAppServerApprovals(appServer),
-						autoApproveOpenClawToolPolicy: approvalPolicyPromotedForOpenClawToolPolicy,
 						signal,
-						onNativeToolFailureDisposition: (itemId, disposition) => projector?.recordNativeToolApprovalFailure(itemId, disposition)
+						onNativeToolFailureDisposition: (itemId, disposition, approvalKind) => projector?.recordNativeToolApprovalFailure(itemId, disposition, approvalKind)
 					});
 				}
 				return;
@@ -6126,13 +6728,6 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				tool: call.tool,
 				toolCallId: call.callId
 			});
-			emitDynamicToolStartedDiagnostic({
-				call,
-				agentId: sessionAgentId,
-				runId: params.runId,
-				sessionId: params.sessionId,
-				sessionKey: params.sessionKey
-			});
 			const toolMeta = inferCodexDynamicToolMeta(call, resolveCodexToolProgressDetailMode(params.toolProgressDetail));
 			const toolArgs = sanitizeCodexToolArguments(call.arguments);
 			const commandBearing = isCodexCommandBearingToolCall(call.tool, toolArgs);
@@ -6142,6 +6737,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				data: {
 					phase: "start",
 					name: call.tool,
+					itemId: call.callId,
 					toolCallId: call.callId,
 					...toolMeta ? { meta: toolMeta } : {},
 					...toolArgs ? { args: toolArgs } : {},
@@ -6162,30 +6758,43 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					sessionId: params.sessionId,
 					sessionKey: params.sessionKey
 				})) terminalDiagnosticObserved = true;
-			});
+			}, { include: DYNAMIC_TOOL_TERMINAL_DIAGNOSTIC_TYPES });
 			try {
-				const { execution } = openClawDynamicToolExecutions.claim(call, () => handleDynamicToolCallWithTimeout({
-					call,
-					toolBridge,
-					signal,
-					timeoutMs: dynamicToolTimeoutMs,
-					toolMeta,
-					toolCallOrdinal,
-					onAgentToolResult: params.onAgentToolResult,
-					observeToolTerminal: params.observeToolTerminal,
-					onFallbackSelected: () => {
-						if (toolCallOrdinal !== void 0) suppressedDynamicToolOutcomeOrdinals.add(toolCallOrdinal);
-					},
-					onTimeout: () => {
-						trajectoryRecorder?.recordEvent("tool.timeout", {
-							threadId: call.threadId,
-							turnId: call.turnId,
-							toolCallId: call.callId,
-							name: call.tool,
-							timeoutMs: dynamicToolTimeoutMs
-						});
-					}
-				}));
+				const { execution } = openClawDynamicToolExecutions.claim(call, async () => {
+					await projector?.transcriptCheckpoint.flush();
+					emitDynamicToolStartedDiagnostic({
+						call,
+						agentId: sessionAgentId,
+						runId: params.runId,
+						sessionId: params.sessionId,
+						sessionKey: params.sessionKey
+					});
+					const response = await handleDynamicToolCallWithTimeout({
+						call,
+						toolBridge,
+						signal,
+						timeoutMs: dynamicToolTimeoutMs,
+						toolMeta,
+						toolCallOrdinal,
+						onAgentToolResult: params.onAgentToolResult,
+						observeToolTerminal: params.observeToolTerminal,
+						onFallbackSelected: () => {
+							if (toolCallOrdinal !== void 0) suppressedDynamicToolOutcomeOrdinals.add(toolCallOrdinal);
+						},
+						onTimeout: () => {
+							trajectoryRecorder?.recordEvent("tool.timeout", {
+								threadId: call.threadId,
+								turnId: call.turnId,
+								toolCallId: call.callId,
+								name: call.tool,
+								timeoutMs: dynamicToolTimeoutMs
+							});
+						}
+					});
+					recordCodexDynamicToolResult(projector, call, response, toCodexDynamicToolProtocolResponse(response));
+					await projector?.transcriptCheckpoint.flush();
+					return response;
+				});
 				const response = await execution;
 				const protocolResponse = toCodexDynamicToolProtocolResponse(response);
 				if (!protocolResponse.success && toolCallOrdinal !== void 0) {
@@ -6208,8 +6817,11 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					success: protocolResponse.success,
 					contentItems: protocolResponse.contentItems
 				});
-				recordCodexDynamicToolResult(projector, call, response, protocolResponse);
-				if (protocolResponse.success && call.tool === "update_plan") projector?.recordDynamicPlanUpdate(response.executedArguments ?? call.arguments);
+				if (protocolResponse.success && call.tool === "progress_card") {
+					const progressCardInput = response.executedArguments ?? call.arguments;
+					await projector?.recordDynamicProgressCardUpdate(progressCardInput);
+					compactionPlanState.recordProgressCardInput(progressCardInput);
+				}
 				if (shouldEmitDynamicToolProgress) {
 					const progressResponse = toCodexDynamicToolProgressResponse(response, protocolResponse);
 					emitCodexAppServerEvent(params, {
@@ -6217,6 +6829,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						data: {
 							phase: "result",
 							name: call.tool,
+							itemId: call.callId,
 							toolCallId: call.callId,
 							...toolMeta ? { meta: toolMeta } : {},
 							...commandBearing ? { commandBearing: true } : {},
@@ -6289,6 +6902,20 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 	return { handleServerRequest };
 }
 //#endregion
+//#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-DeBvleJw.js");
+	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
+	const expected = params.request.expected;
+	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
+	if (!runtimeArtifact || !matchesExpected || !await validateCodexAppServerRuntimeArtifact(runtimeArtifact, params.signal)) {
+		retireSharedCodexAppServerClientIfCurrent(params.client);
+		throw new Error(expected ? "Codex app-server runtime artifact does not match verified inference" : "Codex app-server runtime artifact is unavailable or stale");
+	}
+	return runtimeArtifact;
+}
+//#endregion
 //#region extensions/codex/src/app-server/computer-use-health.ts
 const COMPUTER_USE_HEALTH_MONITOR_STATE = Symbol.for("openclaw.codexComputerUseHealthMonitorState");
 function getComputerUseHealthMonitorState() {
@@ -6308,19 +6935,17 @@ function startCodexComputerUseHealthMonitor(params) {
 	}
 	const fingerprint = buildComputerUseHealthMonitorFingerprint(params.config);
 	const intervalMs = params.config.healthCheckIntervalMinutes * 6e4;
-	if (existing?.fingerprint === fingerprint && existing.repairComputerUseMcpChildren === params.repairComputerUseMcpChildren) return {
+	if (existing?.fingerprint === fingerprint) return {
 		started: false,
 		intervalMs,
 		reason: "already_started"
 	};
 	if (existing) clearComputerUseHealthMonitor(params.client, existing);
-	const repairComputerUseMcpChildren = params.repairComputerUseMcpChildren ?? (() => killStaleComputerUseMcpChildren({ ancestorPid: params.client.getTransportPid() }));
 	const monitor = {
 		fingerprint,
 		intervalMs,
-		repairComputerUseMcpChildren: params.repairComputerUseMcpChildren,
 		timer: setInterval(() => {
-			runCodexComputerUseHealthProbe(params.client, params.config, monitor, { repairComputerUseMcpChildren });
+			runCodexComputerUseHealthProbe(params.client, params.config, monitor);
 		}, intervalMs),
 		disposeCloseHandler: () => void 0,
 		running: false
@@ -6345,13 +6970,12 @@ function buildComputerUseHealthMonitorFingerprint(config) {
 		toolCallTimeoutMs: config.toolCallTimeoutMs
 	});
 }
-async function runCodexComputerUseHealthProbe(client, config, monitor, options) {
+async function runCodexComputerUseHealthProbe(client, config, monitor) {
 	if (monitor.running) return;
 	monitor.running = true;
 	try {
 		const { liveTest, repair } = await runCodexComputerUseLiveTest({
 			config,
-			repairComputerUseMcpChildren: options.repairComputerUseMcpChildren,
 			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, { timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs })
 		});
 		if (!liveTest.ok) {
@@ -6364,10 +6988,7 @@ async function runCodexComputerUseHealthProbe(client, config, monitor, options)
 			});
 			return;
 		}
-		if (repair?.killedPids.length) embeddedAgentLog.info("codex computer-use periodic health repaired stale children", {
-			mcpServerName: config.mcpServerName,
-			killedPids: repair.killedPids
-		});
+		if (repair?.attempted && repair.warnings.length === 0) embeddedAgentLog.info("codex computer-use periodic health reloaded MCP servers", { mcpServerName: config.mcpServerName });
 	} catch (error) {
 		embeddedAgentLog.warn("codex computer-use periodic health probe crashed", {
 			mcpServerName: config.mcpServerName,
@@ -6462,6 +7083,7 @@ function createCodexPluginThreadConfigStartupProvider(params) {
 		build: async (buildOptions) => {
 			const config = await buildCodexPluginThreadConfigWithinDeadline({
 				...buildParams,
+				threadId: buildOptions?.threadId,
 				appCache: appCache ?? defaultCodexAppInventoryCache,
 				metadataCache,
 				failClosedOnTimeout: Boolean(params.scheduledRuntimeAuthority),
@@ -6494,7 +7116,7 @@ function isCodexPluginThreadConfigTimeoutError(error) {
 * Startup orchestration for Codex app-server attempts, including shared-client
 * leasing, plugin thread config, sandbox environment, and thread lifecycle binding.
 */
-const CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS = 3;
+const CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS = 3;
 const CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED = "CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED";
 /** True when a pre-write context restart must replay on the newly selected owner. */
 function isCodexContextRestartSelectionChangedError(error) {
@@ -6575,24 +7197,19 @@ async function startCodexAttemptThread(params) {
 						startupClientLease = () => {
 							if (startupClientLeaseReleased) return;
 							startupClientLeaseReleased = true;
-							releaseLeasedSharedCodexAppServerClient(activeStartupClient);
+							if (params.attemptClientFactory === createIsolatedCodexAppServerClient) activeStartupClient.close();
+							else releaseLeasedSharedCodexAppServerClient(activeStartupClient);
 						};
 						releaseSharedClientLease = startupClientLease;
 						attemptedClient = activeStartupClient;
 						startupClientForAbandonedRequestCleanup = activeStartupClient;
 						if (startupAbandoned) throw new CodexAppServerStartupError("timed_out");
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
-						let runtimeArtifact;
-						if (params.runtimeArtifactRequest) {
-							const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-BVSPdd6g.js");
-							runtimeArtifact = readCodexAppServerClientRuntimeArtifact(activeStartupClient);
-							const expected = params.runtimeArtifactRequest.expected;
-							const matchesExpected = !expected || Boolean(runtimeArtifact && runtimeArtifact.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint);
-							if (!runtimeArtifact || !matchesExpected || !await validateCodexAppServerRuntimeArtifact(runtimeArtifact, startupAbandonController.signal)) {
-								retireSharedCodexAppServerClientIfCurrent(activeStartupClient);
-								throw new Error(expected ? "Codex app-server runtime artifact does not match verified inference" : "Codex app-server runtime artifact is unavailable or stale");
-							}
-						}
+						const runtimeArtifact = await verifyStartupArtifact({
+							client: activeStartupClient,
+							request: params.runtimeArtifactRequest,
+							signal: startupAbandonController.signal
+						});
 						ensureCodexAppServerClientRuntime(activeStartupClient, {
 							agentDir: params.agentDir,
 							authProfileId: startupRuntimeAuthProfileId,
@@ -6611,7 +7228,7 @@ async function startCodexAttemptThread(params) {
 								signal: startupAbandonController.signal
 							});
 						} catch (error) {
-							if (startupAbandonController.signal.aborted) throw error;
+							if (startupAbandonController.signal.aborted || isCodexAppServerStartSelectionChangedError(error)) throw error;
 							throw new AgentHarnessPreflightError(`Codex Computer Use readiness failed: ${formatErrorMessage(error)}`, {
 								cause: error,
 								scope: "harness"
@@ -6625,7 +7242,8 @@ async function startCodexAttemptThread(params) {
 							accountId: params.startupAuthAccountCacheKey,
 							envApiKeyFingerprint: params.startupEnvApiKeyCacheKey,
 							appServerVersion: activeStartupClient.getServerVersion(),
-							runtimeIdentity: startupRuntimeIdentity
+							runtimeIdentity: startupRuntimeIdentity,
+							desktopGenerationFingerprint: readCodexAppServerClientDesktopGenerationFingerprint(activeStartupClient)
 						});
 						const appServerRuntimeFingerprint = buildCodexAppServerRuntimeFingerprint({
 							appServer: params.appServer,
@@ -6652,7 +7270,7 @@ async function startCodexAttemptThread(params) {
 						const releaseStartupSandboxEnvironment = async () => {
 							if (startupSandboxEnvironmentAcquired) {
 								startupSandboxEnvironmentAcquired = false;
-								await releaseCodexSandboxExecServerEnvironment(params.sandbox);
+								await releaseCodexSandboxExecServerEnvironment(params.sandbox, startupSandboxEnvironment);
 							}
 						};
 						releaseStartupResourcesOnTimeout = releaseStartupSandboxEnvironment;
@@ -6665,9 +7283,11 @@ async function startCodexAttemptThread(params) {
 							startupSandboxEnvironment = sandboxEnvironmentRequired ? await ensureCodexSandboxExecServerEnvironment({
 								client: activeStartupClient,
 								sandbox: params.sandbox ?? null,
+								runtime: params.runtime,
 								appServerStartOptions: params.appServer.start,
 								timeoutMs: params.appServer.requestTimeoutMs,
-								signal: startupAbandonController.signal
+								signal: AbortSignal.any([params.signal, startupAbandonController.signal]),
+								onExecutionDisconnect: params.onExecutionDisconnect
 							}) : void 0;
 							startupSandboxEnvironmentAcquired = Boolean(startupSandboxEnvironment);
 							if (startupAbandonController.signal.aborted) {
@@ -6711,17 +7331,23 @@ async function startCodexAttemptThread(params) {
 							reserveResumeThread,
 							bindingStore: params.bindingStore,
 							params: params.buildAttemptParams(),
+							runtimeModelId: params.runtimeModelId,
 							agentId: params.sessionAgentId,
+							agentDir: params.agentDir,
 							cwd: startupExecutionCwd,
 							dynamicTools: params.dynamicTools,
 							persistentWebSearchAllowed: params.persistentWebSearchAllowed,
 							webSearchAllowed: params.webSearchAllowed,
 							appServer: pluginAppServer,
 							developerInstructions: params.developerInstructions,
+							agentWorkspaceDeveloperInstructions: params.agentWorkspaceDeveloperInstructions,
 							config: threadConfig,
+							shellEnvironment: params.shellEnvironment,
+							disableLoginShell: params.disableLoginShell,
 							finalConfigPatch: params.finalConfigPatch,
 							buildFinalConfigPatch: params.buildFinalConfigPatch,
 							nativeHookRelayGeneration: params.nativeHookRelayGeneration,
+							nativeHookRelayRequired: params.nativeHookRelayRequired,
 							nativeCodeModeEnabled: params.nativeToolSurfaceEnabled,
 							nativeProviderWebSearchSupport: params.nativeProviderWebSearchSupport,
 							nativeCodeModeOnlyEnabled: params.appServer.codeModeOnly,
@@ -6816,30 +7442,31 @@ async function startCodexAttemptThread(params) {
 						}
 					}
 				};
-				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS; attempt += 1) try {
+				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS; attempt += 1) try {
 					return await startupAttempt();
 				} catch (error) {
 					const selectionChanged = isCodexAppServerStartSelectionChangedError(error);
 					if (startupAbandoned || params.signal.aborted || !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
-					const failedClient = attemptedClient;
-					const refreshedSharedClient = selectionChanged ? retireSharedCodexAppServerClientIfCurrent(failedClient) : clearSharedCodexAppServerClientIfCurrent(failedClient);
-					if (startupClientForAbandonedRequestCleanup === failedClient) startupClientForAbandonedRequestCleanup = void 0;
-					if (attempt >= CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS) {
+					const refreshedSharedClient = selectionChanged ? retireSharedCodexAppServerClientIfCurrent(attemptedClient) : clearSharedCodexAppServerClientIfCurrent(attemptedClient);
+					if (startupClientForAbandonedRequestCleanup === attemptedClient) startupClientForAbandonedRequestCleanup = void 0;
+					if (attempt >= CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS) {
 						embeddedAgentLog.warn(selectionChanged ? "codex app-server executable selection kept changing during startup; retries exhausted" : "codex app-server connection closed during startup; retries exhausted", {
 							attempt,
-							maxAttempts: CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS,
+							maxAttempts: CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS,
 							refreshedSharedClient,
 							error: formatErrorMessage(error)
 						});
 						throw error;
 					}
+					const retryDelayMs = selectionChanged ? 0 : 1e3 * 2 ** (attempt - 1);
 					embeddedAgentLog.warn(selectionChanged ? "codex app-server executable selection changed during startup; restarting app-server and retrying" : "codex app-server connection closed during startup; restarting app-server and retrying", {
 						attempt,
 						nextAttempt: attempt + 1,
-						maxAttempts: CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS,
+						maxAttempts: CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS,
 						refreshedSharedClient,
 						error: formatErrorMessage(error)
 					});
+					await sleepWithAbort(retryDelayMs, startupAbandonController.signal);
 				}
 				throw new Error("codex app-server startup retry loop exited unexpectedly");
 			}
@@ -6852,7 +7479,7 @@ async function startCodexAttemptThread(params) {
 			releaseSharedClientLease
 		};
 	} catch (error) {
-		if (params.signal.aborted || shouldClearSharedClientAfterStartupAbandon(error)) {
+		if (params.signal.aborted || isCodexAppServerStartupError(error)) {
 			releaseSharedClientLease?.();
 			releaseSharedClientLease = void 0;
 			await closeCodexStartupClientBestEffort(startupClientForAbandonedRequestCleanup);
@@ -6871,13 +7498,11 @@ async function startCodexAttemptThread(params) {
 		params.signal.removeEventListener("abort", abandonStartupAcquire);
 	}
 }
-function shouldClearSharedClientAfterStartupAbandon(error) {
-	return isCodexAppServerStartupError(error);
-}
 function shouldClearSharedClientAfterStartupRace(error) {
-	return shouldClearSharedClientAfterStartupAbandon(error) || isCodexAppServerRequestTimeoutError(error);
+	return isCodexAppServerStartupError(error) || isCodexAppServerRequestTimeoutError(error);
 }
 function shouldClearSharedClientAfterStartupFailure(params) {
+	if (isCodexAppServerOverloadError(params.error)) return false;
 	return isCodexAppServerBrokenPipeError(params.error) || !params.spawnedBy;
 }
 //#endregion
@@ -6886,11 +7511,12 @@ async function startCodexAttemptRuntime(resources) {
 	const { prompt, state, trajectoryRecorder, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseAndRetireOneShotClient, releaseCurrentRoute, runCleanupStep, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
 	const { context, turnState, buildRenderedCodexDeveloperInstructions, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
 	const { runtime, attemptTools, promptState } = context;
-	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, sandboxExecServerEnabled } = runtime;
+	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
 	const { toolBridge, toolState } = attemptTools;
 	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",
@@ -6899,6 +7525,7 @@ async function startCodexAttemptRuntime(resources) {
 		const startupResult = await startCodexAttemptThread({
 			attemptClientFactory,
 			bindingStore,
+			runtime: connection.options.runtime,
 			appServer: pluginAppServer,
 			pluginConfig,
 			computerUseConfig,
@@ -6911,7 +7538,10 @@ async function startCodexAttemptRuntime(resources) {
 			startupEnvApiKeyCacheKey,
 			agentDir,
 			config: params.config,
+			shellEnvironment: connection.shellEnvironment,
+			disableLoginShell: connection.disableLoginShell,
 			buildAttemptParams: buildActiveRunAttemptParams,
+			...effectiveRuntimeModelId !== runtimeParams.modelId ? { runtimeModelId: effectiveRuntimeModelId } : {},
 			sessionAgentId,
 			effectiveWorkspace,
 			effectiveCwd,
@@ -6919,7 +7549,9 @@ async function startCodexAttemptRuntime(resources) {
 			persistentWebSearchAllowed: toolState.persistentWebSearchAllowed,
 			webSearchAllowed: toolState.webSearchAllowed,
 			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,
@@ -6930,6 +7562,11 @@ async function startCodexAttemptRuntime(resources) {
 			startupTimeoutMs,
 			signal: runAbortController.signal,
 			onStartupTimeout: () => runAbortController.abort("codex_startup_timeout"),
+			onExecutionDisconnect: (error) => {
+				state.executionDisconnectError = error;
+				embeddedAgentLog.warn(error.message);
+				runAbortController.abort("client_closed");
+			},
 			spawnedBy: params.spawnedBy
 		});
 		state.client = startupResult.client;
@@ -6937,7 +7574,7 @@ async function startCodexAttemptRuntime(resources) {
 		state.runtimeArtifact = startupResult.runtimeArtifact;
 		state.turnRouter = startupResult.turnRouter;
 		state.turnRoute = startupResult.turnRoute;
-		state.sandboxExecEnvironmentAcquired = Boolean(startupResult.sandboxEnvironment);
+		state.sandboxExecEnvironment = startupResult.sandboxEnvironment;
 		state.releaseSharedClientLease = startupResult.releaseSharedClientLease;
 		state.restartContextEngineCodexThread = startupResult.restartContextEngineCodexThread;
 		pluginAppServer = startupResult.pluginAppServer;
@@ -7011,7 +7648,7 @@ async function startCodexAttemptRuntime(resources) {
 		await runCleanupStep("codex-start-failure-sandbox-release", releaseSandboxExecEnvironment);
 		await runCleanupStep("codex-start-failure-shared-client-release", releaseSharedClientLeaseAndRetireOneShotClient);
 		await runCleanupStep("codex-start-failure-abort-listener", () => params.abortSignal?.removeEventListener("abort", abortFromUpstream));
-		throw error;
+		throw state.executionDisconnectError ?? error;
 	}
 }
 //#endregion
@@ -7021,7 +7658,7 @@ function isAuthorityResolutionOperationAbort(error, signal) {
 }
 async function prepareCodexAttemptTools(runtime) {
 	const { connection, bundleMcpThreadConfig, bundleManifestRegistry, runtimeParams, effectiveRuntimeModelId, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, hookChannelId, codexMcpToolOverrides, authenticatedScheduledMode, ownsScheduledConfiguredMcpSurface, canResolveScheduledConfiguredMcpCreatorAuthority } = runtime;
-	const { params, preDynamicStartupStages, mutable, startupAuthProfileId, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, sandbox, runAbortController, sessionAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
+	const { params, preDynamicStartupStages, mutable, startupAuthProfileId, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, sandbox, sessionPermissionPolicy, runAbortController, sessionAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
 	const preDynamicSummary = preDynamicStartupStages.snapshot();
 	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(preDynamicSummary)}`, {
 		runId: params.runId,
@@ -7035,6 +7672,7 @@ async function prepareCodexAttemptTools(runtime) {
 	});
 	const toolState = {
 		yieldDetected: false,
+		yieldAcknowledgment: void 0,
 		persistentWebSearchAllowed: void 0,
 		webSearchAllowed: false
 	};
@@ -7052,12 +7690,18 @@ async function prepareCodexAttemptTools(runtime) {
 		if (toolCallId) toolOutcomeOrdinals.set(toolCallId, ordinal);
 		return ordinal;
 	} : void 0;
-	const dynamicToolParams = allocateCodexToolOutcomeOrdinal || onCodexToolOutcome ? {
+	const compactionPlanState = new CodexCompactionPlanState();
+	const dynamicToolParams = {
 		...runtimeParams,
+		onAgentEvent: (event) => {
+			compactionPlanState.record(event);
+			return runtimeParams.onAgentEvent?.(event);
+		},
 		...allocateCodexToolOutcomeOrdinal ? { allocateToolOutcomeOrdinal: allocateCodexToolOutcomeOrdinal } : {},
 		...onCodexToolOutcome ? { onToolOutcome: onCodexToolOutcome } : {}
-	} : runtimeParams;
+	};
 	const computerContextEpoch = { value: 0 };
+	const runCleanups = [];
 	const cronCreatorToolAllowlist = [];
 	const cronCreatorToolAllowlistCaptureRef = {};
 	const scheduledAppAuthoritySourceRef = {};
@@ -7080,6 +7724,7 @@ async function prepareCodexAttemptTools(runtime) {
 	let toolBridge;
 	let creatorAuthorityPromise;
 	let resolveCreatorAuthorityImpl;
+	const runtimeYieldCompletionClaim = {};
 	const commonToolParams = {
 		params: dynamicToolParams,
 		resolvedWorkspace,
@@ -7087,6 +7732,7 @@ async function prepareCodexAttemptTools(runtime) {
 		effectiveCwd,
 		sandboxSessionKey,
 		sandbox,
+		sessionPermissionPolicy,
 		nativeToolSurfaceEnabled,
 		nativeProviderWebSearchSupport,
 		runAbortController,
@@ -7094,9 +7740,11 @@ async function prepareCodexAttemptTools(runtime) {
 		pluginConfig,
 		profilerEnabled,
 		...params.cronCreatorAuthorityUnavailableReason === "queued-local-operator" && bundleMcpThreadConfig.staticServerNames.length > 0 ? { cronCreatorAuthorityUnavailableReason: "queued-local-operator-configured-mcp" } : {},
-		onYieldDetected: () => {
+		onYieldDetected: (acknowledgment) => {
 			toolState.yieldDetected = true;
+			toolState.yieldAcknowledgment = acknowledgment;
 		},
+		claimYieldCompletion: () => runtimeYieldCompletionClaim.current?.() ?? false,
 		onCodexAppServerEvent: (event) => {
 			emitCodexAppServerEvent(params, event);
 		},
@@ -7115,6 +7763,7 @@ async function prepareCodexAttemptTools(runtime) {
 	};
 	const tools = await buildDynamicTools({
 		...commonToolParams,
+		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
 		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
 		cronCreatorToolAllowlistCaptureRef,
 		onPersistentWebSearchPolicyResolved: (allowed) => {
@@ -7333,13 +7982,16 @@ async function prepareCodexAttemptTools(runtime) {
 			cronCreatorToolAllowlistCaptureRef,
 			scheduledAppAuthoritySourceRef,
 			dynamicToolParams,
+			compactionPlanState,
 			computerContextEpoch,
+			runCleanups,
 			toolBridge,
 			toolState,
 			toolOutcomeOrdinals,
 			suppressedDynamicToolOutcomeOrdinals,
 			onCodexToolOutcome,
-			allocateCodexToolOutcomeOrdinal
+			allocateCodexToolOutcomeOrdinal,
+			runtimeYieldCompletionClaim
 		};
 	} catch (error) {
 		await scopedMcpTools?.dispose();
@@ -7457,7 +8109,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			data: {
 				phase: "turn_starting",
 				threadId: resourceState.thread.threadId,
-				model: turnStartParams.model,
+				model: params.modelId,
 				effort: turnStartParams.effort,
 				collaborationEffort: turnStartParams.collaborationMode?.settings.reasoning_effort,
 				serviceTier: turnStartParams.serviceTier
@@ -7814,8 +8466,10 @@ function createCodexAttemptTurnWatchController(params) {
 	function scheduleAttemptIdleWatch() {
 		scheduleWatch("attempt", fireAttemptIdleTimeout, attemptLastProgressAt, attemptIdleTimeoutOverrideMs ?? turnAttemptIdleTimeoutMs, attemptIdleWatchArmed && !shouldPauseAttemptIdleWatch());
 	}
+	const terminalWorkIsActive = () => params.getActiveAppServerTurnRequests() > 0 || params.isTerminalTurnNotificationQueued() && params.getActiveFinalizationHookCount() > 0;
+	const terminalIdleTimeoutMs = () => params.isTerminalTurnNotificationQueued() && !terminalWorkIsActive() ? Math.min(TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS, turnTerminalIdleTimeoutMs) : turnTerminalIdleTimeoutMs;
 	function scheduleTerminalIdleWatch() {
-		scheduleWatch("terminal", fireTerminalIdleTimeout, completionLastActivityAt, turnTerminalIdleTimeoutMs, terminalIdleWatchArmed && params.getActiveAppServerTurnRequests() === 0);
+		scheduleWatch("terminal", fireTerminalIdleTimeout, completionLastActivityAt, terminalIdleTimeoutMs(), terminalIdleWatchArmed && (params.isTerminalTurnNotificationQueued() || params.getActiveAppServerTurnRequests() === 0));
 	}
 	function scheduleProgressWatches() {
 		scheduleAttemptIdleWatch();
@@ -7936,18 +8590,26 @@ function createCodexAttemptTurnWatchController(params) {
 		});
 	}
 	function fireTerminalIdleTimeout() {
-		if (params.isCompleted() || params.isTerminalTurnNotificationQueued() || params.signal.aborted || !terminalIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0) return;
+		if (params.isCompleted() || params.signal.aborted || !terminalIdleWatchArmed) return;
+		if (!params.isTerminalTurnNotificationQueued() && params.getActiveAppServerTurnRequests() > 0) {
+			scheduleTerminalIdleWatch();
+			return;
+		}
+		const timeoutMs = terminalIdleTimeoutMs();
 		const idleMs = Math.max(0, Date.now() - completionLastActivityAt);
-		if (idleMs < turnTerminalIdleTimeoutMs) {
+		if (idleMs < timeoutMs) {
 			scheduleTerminalIdleWatch();
 			return;
 		}
 		reportTimeout({
 			kind: "terminal",
 			idleMs,
-			timeoutMs: turnTerminalIdleTimeoutMs,
+			timeoutMs,
 			lastActivityReason: completionLastActivityReason,
-			details: completionLastActivityDetails
+			details: {
+				...completionLastActivityDetails,
+				terminalTurnNotificationQueued: params.isTerminalTurnNotificationQueued()
+			}
 		});
 	}
 	return {
@@ -8004,6 +8666,7 @@ function createCodexAttemptTurnWatchController(params) {
 			completionLastActivityReason = `notification:${method}`;
 			if (options?.details !== void 0) completionLastActivityDetails = options.details;
 			if (options?.attemptProgress) recordAttemptProgress(completionLastActivityReason, options);
+			if (params.isTerminalTurnNotificationQueued()) scheduleTerminalIdleWatch();
 		},
 		extendAttemptIdleWatch: (timeoutMs) => {
 			attemptIdleTimeoutOverrideMs = resolveWatchTimeoutMs(timeoutMs);
@@ -8026,6 +8689,7 @@ function createCodexAttemptTurnState(resources) {
 		latestStartupErrorNotification: void 0,
 		rateLimitsRevisionBeforeLastTurnStart: void 0,
 		completed: false,
+		abortCleanup: Promise.resolve(),
 		localCompletionRequested: false,
 		terminalTurnNotificationQueued: false,
 		sawCodexInterruptMarker: false,
@@ -8179,11 +8843,14 @@ function createCodexAttemptTurnState(resources) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt.ts
 async function runCodexAppServerAttempt(params, options) {
-	const runtime = await prepareCodexAttemptRuntime(await prepareCodexAttemptConnection({
+	const connection = await prepareCodexAttemptConnection({
 		params,
 		options
-	}));
-	const resources = prepareCodexAttemptResources(await prepareCodexAttemptPrompt(await prepareCodexAttemptContext(runtime, await prepareCodexAttemptTools(runtime))));
+	});
+	const runtime = await prepareCodexAttemptRuntime(connection);
+	const attemptTools = await prepareCodexAttemptTools(runtime);
+	const resources = prepareCodexAttemptResources(await prepareCodexAttemptPrompt(await prepareCodexAttemptContext(runtime, attemptTools)));
+	attemptTools.runtimeYieldCompletionClaim.current = () => resources.state.nativeHookRelay?.hasClaimedDirectChild() ?? false;
 	await startCodexAttemptRuntime(resources);
 	const turnRuntime = createCodexAttemptTurnState(resources);
 	const lifecycle = createCodexAttemptLifecycleController(resources, turnRuntime);
@@ -8193,11 +8860,14 @@ async function runCodexAppServerAttempt(params, options) {
 	const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
 	if ("result" in turnStart) return turnStart.result;
 	const activeTurn = await activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart.turn);
+	let finalizedResult;
 	try {
-		return await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
+		finalizedResult = await finalizeCodexAttempt(resources, turnRuntime, lifecycle, notifications, turnRequest, activeTurn);
 	} finally {
 		await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
 	}
+	if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
+	return finalizedResult;
 }
 //#endregion
 export { runCodexAppServerAttempt };