@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/{run-attempt-BzthFQSM.js → run-attempt-CvsAAGa0.js}

@@ -1,50 +1,65 @@
-import { l as sessionBindingIdentity } from "./session-binding-record-CyaXZvTe.js";
-import { A as resolveOpenClawExecPolicyForCodexAppServer, B as isJsonObject, D as isCodexSandboxExecServerEnabled, E as isCodexRemoteExecPlacementSandbox, M as resolveCodexAppServerHomeDir, O as readCodexPluginConfig, T as isCodexPairedNodeRemoteExecPlacementSandbox, d as shouldAutoApproveCodexAppServerApprovals, f as withMcpElicitationsApprovalPolicy, h as resolveCodexModelBackedReviewerPolicyContext, k as resolveCodexPluginsPolicy, l as hasCodexMcpToolApprovalOverrides, m as canUseCodexModelBackedApprovalsReviewerForModel, o as resolveCodexComputerUseConfig, r as resolveCodexAppServerHomeScope, y as readCodexRequirementsToml, z as flattenCodexDynamicToolFunctions } from "./config-CyapYSji.js";
-import { A as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, B as isCodexAppServerIndeterminateRequestCancellationError, Bt as resolveCodexAppServerAuthAccountCacheKey, F as withCodexStartupTimeout, Gt as resolveCodexAppServerPreparedApiKeyCacheKey, H as isCodexAppServerOverloadError, Ht as resolveCodexAppServerAuthProfileIdForAgent, I as getCodexAppServerClientInstanceId, It as readCodexRateLimitsRevision, K as resolveCodexAppServerClientInstanceId, Kt as resolveCodexAppServerPreparedAuthHandoff, L as isCodexAppServerApprovalRequest, Lt as readRecentCodexRateLimits, M as isCodexAppServerStartupError, P as resolveCodexStartupTimeoutMs, Pt as withAbortableTimeout, R as isCodexAppServerBrokenPipeError, Rt as rememberCodexRateLimitsRead, Tt as ensureCodexAppServerClientRuntime, V as isCodexAppServerIndeterminateTransportError, Vt as resolveCodexAppServerAuthProfileId, W as isCodexAppServerRequestTimeoutError, Wt as resolveCodexAppServerFallbackApiKeyCacheKey, _t as toCodexDynamicToolProgressResponse, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, ct as createCodexElicitationResponse, dt as isDynamicToolTerminalDiagnosticEvent, f as readCodexAppServerClientDesktopGenerationFingerprint, ft as isMatchingDynamicToolTerminalDiagnostic, gt as shouldReleaseTurnAfterTerminalDynamicTool, h as releaseLeasedSharedCodexAppServerClient, ht as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, i as clearSharedCodexAppServerClientIfCurrent, it as readCodexDynamicToolCallParams, j as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, k as CodexAppServerStartupError, kt as protectCodexAppServerLiveThread, l as getSharedCodexAppServerClient, lt as handleDynamicToolCallWithTimeout, mt as resolveTerminalDynamicToolBatchAction, ot as readCodexTurn, pt as resolveDynamicToolCallTimeoutMs, q as CodexAppServerRpcError, rt as assertCodexTurnStartResponse, s as createIsolatedCodexAppServerClient, st as readCodexTurnCompletedNotification, u as isCodexAppServerStartSelectionChangedError, ut as hasPendingDynamicToolTerminalDiagnostic, v as retainSharedCodexAppServerClientIfCurrent, vt as toCodexDynamicToolProtocolResponse, y as retireSharedCodexAppServerClientIfCurrent, yt as resolveCodexToolAbortTerminalReason, z as isCodexAppServerConnectionClosedError } from "./shared-client-CKhX2kFt.js";
-import { c as resolveCodexRunSessionBindingAuthority, l as resolveCodexSessionBinding, n as assertCodexBindingMayBeReplaced, r as createCodexSessionGenerationSupersededError, u as scopeCodexRunBindingStore } from "./session-binding-4Ki04sW-.js";
-import { E as itemStatus, F as readCodexProviderRefusal, H as readNullableString, L as readItem, M as extractRawAssistantText, O as matchesCodexSnapshotTurn, P as readCodexErrorNotificationMessage, R as readItemString, U as splitPlanText, V as readNonNegativeInteger, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, j as shouldSynthesizeToolProgressForItem, k as shouldClearTerminalPresentationForNativeItem, l as retireUnsafeCodexTurnClientBestEffort, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, u as terminateCodexBackgroundTerminals } from "./attempt-client-cleanup-Bp1ZOnk2.js";
-import { a as isCodexTurnAbortMarkerNotification, d as readNotificationItemId, f as readRawResponseToolCallId, l as isTerminalTurnStatus, o as isPendingOpenClawDynamicToolCompletionNotification, p as updateActiveTurnItemIds, r as codexExecutionToolName, s as isRawFunctionToolOutputCompletionNotification, t as CodexUsageProjection, u as readCodexNotificationItem } from "./event-projector-usage-ZqEVbAEY.js";
-import { c as defaultCodexAppInventoryCache, i as buildCodexPluginAppCacheKey, r as buildCodexAppServerRuntimeFingerprint } from "./thread-resume-BLgqkUc1.js";
-import { A as readCodexMcpToolConnectorId, B as emitCodexNativePreToolUseFailureDiagnostic, C as buildDeveloperInstructions, Ct as buildCodexPluginThreadConfigInputFingerprint, D as resolveCodexAppServerThreadModelSelection, Et as mergeCodexThreadConfigs, H as resolveCodexNativeHookRelayTtlMs, I as buildCodexNativeHookRelayConfig, L as buildCodexNativeHookRelayDisabledConfig, M as isCodexAppServerProfilerEnabled, Ot as shouldBuildCodexPluginThreadConfig, P as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, Pt as resolveRecoverableCodexPluginConfigKeys, S as resolveCodexWebSearchPlan, St as buildCodexPluginThreadConfig, U as scheduleCodexNativeHookRelayUnregister, V as resolveCodexNativeHookRelayEvents, X as loadCodexNativeToolCatalog, Y as hasCodexNativeToolCatalog, _t as neutralizeCodexExplicitMentionSigils, at as filterCodexDynamicTools, bt as resolveCodexContextEngineProjectionReserveTokens, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, ft as resolveCodexDynamicToolsLoadingForRuntime, gt as fitCodexProjectedContextForTurnStart, h as resolveScheduledCodexAppCreatorCaptureDecision, ht as buildCodexContinuityCalibration, i as buildCodexUserInput, j as readCodexMcpToolUiVisibility, l as buildLegacyScheduledCodexAppRecoveryPrompt, lt as isSystemAgentOnlyCodexDynamicToolAllowlist, m as readCurrentCodexScheduledAppPolicy$1, n as buildTurnCollaborationMode, nt as codexLegacyDynamicToolsFingerprint, p as intersectCodexPluginThreadConfigWithScheduledAuthority, pt as buildContextEngineBinding, r as buildTurnStartParams, s as startOrResumeThread, tt as codexDynamicToolsFingerprint, u as buildScheduledCodexAppAuthorityInputFingerprint, vt as projectContextEngineAssemblyForCodex, wt as buildCodexPluginThreadConfigTimeoutFallback, xt as resolveCodexContinuityProjectionMaxChars, yt as resolveCodexContextEngineProjectionMaxChars, z as createCodexNativeHookRelay } from "./thread-lifecycle-DPK30jad.js";
-import { l as isIncognitoSessionKey, r as retainCodexAppServerBindingSubscription } from "./thread-ownership-CbucAmmp.js";
-import { a as assertCodexSessionRuntimeOwnership, n as CodexThreadPolicyHandoffError, s as resolveCodexBindingAppServerConnection } from "./thread-policy-CTalhWFy.js";
-import { a as buildCodexUserPromptMessage, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-_njEB84z.js";
+import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-oL4Na1ZG.js";
+import { l as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-Bcvslnhf.js";
+import { n as defineCodexBuildState } from "./build-state-BCmg9-5p.js";
+import { b as readCodexRequirementsToml, c as hasCodexMcpToolApprovalOverrides, d as withMcpElicitationsApprovalPolicy, i as resolveCodexAppServerHomeScope, m as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig, u as shouldAutoApproveCodexAppServerApprovals } from "./config-options-CXMq1T-C.js";
+import { S as resolveCodexPluginsPolicy, a as flattenCodexDynamicToolFunctions, b as isCodexSandboxExecServerEnabled, o as isJsonObject, s as resolveCodexAppServerHomeDir, v as isCodexPairedNodeRemoteExecPlacementSandbox, x as readCodexPluginConfig, y as isCodexRemoteExecPlacementSandbox } from "./protocol-5bh1G-H7.js";
+import { A as isMatchingDynamicToolTerminalDiagnostic, D as handleDynamicToolCallWithTimeout, E as createCodexElicitationResponse, F as toCodexDynamicToolProgressResponse, I as toCodexDynamicToolProtocolResponse, L as resolveCodexToolAbortTerminalReason, M as resolveTerminalDynamicToolBatchAction, N as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, O as hasPendingDynamicToolTerminalDiagnostic, P as shouldReleaseTurnAfterTerminalDynamicTool, S as readCodexDynamicToolCallParams, T as readCodexTurnCompletedNotification, a as isCodexAppServerBrokenPipeError, c as isCodexAppServerIndeterminateTransportError, d as isCodexAppServerRequestTimeoutError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, l as isCodexAppServerOverloadError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError, w as readCodexTurn, x as assertCodexTurnStartResponse } from "./client-B57KWPQx.js";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, m as retireSharedCodexAppServerClientIfCurrent, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-7orQae_j.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CBMmWBr9.js";
+import { o as formatCodexDisplayText } from "./command-formatters-lxlkNZgU.js";
+import { t as CodexAppServerRpcError } from "./rpc-error-ttN_QjEm.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-8vx68WLH.js";
+import { D as splitPlanText, E as readNullableString, S as readItemString, T as readNonNegativeInteger, d as matchesCodexSnapshotTurn, f as shouldClearTerminalPresentationForNativeItem, g as extractRawAssistantText, v as readCodexErrorNotificationMessage, x as readItem, y as readCodexProviderRefusal } from "./event-projector-items-5VhsECCO.js";
 import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { a as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-Byl34PC-.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-B1mgvpP8.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-Fx_l4eNa.js";
-import { a as formatCodexDisplayText } from "./command-formatters-DSbGMXA0.js";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BaueHmSj.js";
-import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Ds_QVm-X.js";
+import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey, s as defaultCodexAppInventoryCache } from "./plugin-app-cache-key-d0eKxy7b.js";
+import { t as withAbortableTimeout } from "./timeout-BVw8aaM1.js";
+import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-oIORaQ5T.js";
+import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-DibE0krH.js";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-CWlKVccJ.js";
+import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-D3udKbIE.js";
+import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CwzO4_RG.js";
+import { A as CodexAppServerStartupError, F as resolveCodexStartupTimeoutMs, G as protectCodexAppServerLiveThread, I as withCodexStartupTimeout, M as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, N as isCodexAppServerStartupError, O as getCodexInferenceThread, Q as rememberCodexRateLimitsRead, W as prepareCodexWorkspaceReferences, X as readCodexRateLimitsRevision, Z as readRecentCodexRateLimits, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, et as resolveCodexAppServerAuthAccountCacheKey, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, j as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, l as getSharedCodexAppServerClient, s as createIsolatedCodexAppServerClient, tt as resolveCodexAppServerPreparedAuthHandoff, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent, z as ensureCodexAppServerClientRuntime } from "./shared-client-CscigXXL.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, f as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, g as readCodexNotificationThreadId, h as isCodexNotificationForTurn, l as retireUnsafeCodexTurnClientBestEffort, m as CodexProjectionDiagnostics, o as interruptCodexTurnAndWaitBestEffort, p as getCodexAppServerTurnRouter, r as CodexAppServerUnsafeSubscriptionError, u as terminateCodexBackgroundTerminals } from "./attempt-client-cleanup-DKHzbwt5.js";
+import { a as isRawFunctionToolOutputCompletionNotification, c as readNotificationItemId, i as isPendingOpenClawDynamicToolCompletionNotification, l as readRawResponseToolCallId, o as isTerminalTurnStatus, r as isCodexTurnAbortMarkerNotification, s as readCodexNotificationItem, t as codexExecutionToolName, u as updateActiveTurnItemIds } from "./attempt-notifications-C9XufG6l.js";
+import { t as CodexUsageProjection } from "./event-projector-usage-BfXmpOec.js";
+import { $ as codexDynamicToolsFingerprint, A as readCodexMcpToolConnectorId, B as createCodexNativeHookRelay, C as resolveCodexWebSearchPlan, Ct as buildCodexPluginThreadConfigInputFingerprint, Et as mergeCodexThreadConfigs, F as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, H as resolveCodexNativeHookRelayEvents, J as loadCodexNativeToolCatalog, L as buildCodexNativeHookRelayConfig, N as isCodexAppServerProfilerEnabled, O as resolveCodexAppServerThreadModelSelection, Ot as shouldBuildCodexPluginThreadConfig, R as buildCodexNativeHookRelayDisabledConfig, St as buildCodexPluginThreadConfig, U as resolveCodexNativeHookRelayTtlMs, V as emitCodexNativePreToolUseFailureDiagnostic, W as scheduleCodexNativeHookRelayUnregister, _t as neutralizeCodexExplicitMentionSigils, a as buildCodexUserInput, bt as resolveCodexContextEngineProjectionReserveTokens, c as startOrResumeThread, d as buildScheduledCodexAppAuthorityInputFingerprint, dt as buildContextEngineBinding, et as codexLegacyDynamicToolsFingerprint, f as buildScheduledCodexAppServerConnectionIdentity, g as resolveScheduledCodexAppCreatorCaptureDecision, gt as isCodexDurableCustomMessage, h as readCurrentCodexScheduledAppPolicy$1, ht as fitCodexProjectedContextForTurnStart, i as buildTurnStartParams, j as readCodexMcpToolUiVisibility, l as assertScheduledCodexAppAuthorityRuntime, m as intersectCodexPluginThreadConfigWithScheduledAuthority, mt as buildCodexContinuityCalibration, p as captureScheduledCodexAppAuthority, pt as CodexContextAttachmentError, q as hasCodexNativeToolCatalog, r as buildTurnCollaborationMode, rt as filterCodexDynamicTools, st as isSystemAgentOnlyCodexDynamicToolAllowlist, t as buildCodexParentLocalInstructions, u as buildLegacyScheduledCodexAppRecoveryPrompt, ut as resolveCodexDynamicToolsLoadingForRuntime, vt as projectContextEngineAssemblyForCodex, w as buildDeveloperInstructions, wt as buildCodexPluginThreadConfigTimeoutFallback, xt as resolveCodexContinuityProjectionMaxChars, yt as resolveCodexContextEngineProjectionMaxChars } from "./thread-lifecycle-DXl1-I6b.js";
+import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding, s as scopeCodexRunBindingStore } from "./session-binding-CI8UuilT.js";
+import { n as CodexThreadPolicyHandoffError } from "./thread-policy-BuEQfE0g.js";
+import { r as retainCodexAppServerBindingSubscription } from "./thread-ownership-BsDRTsyp.js";
+import { i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as promptSnapshot, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-C5CKgNy6.js";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.js";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-B9kp6iGC.js";
-import { C as shouldRequireCodexSandboxExecServerEnvironment, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeToolLifecycleProjector, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as readBoundedCodexRemoteWorkspaceFile, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-BwpvTxaX.js";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-BpG9Ltc5.js";
-import { a as CodexToolProgressProjection, c as isCodexCommandBearingToolCall, d as sanitizeCodexToolResponse, i as CodexToolTranscriptProjection, l as resolveCodexToolProgressDetailMode, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, s as inferCodexDynamicToolMeta, t as codexNativeSubagentMonitorRuntime, u as sanitizeCodexToolArguments } from "./native-subagent-monitor-B3bvQGcg.js";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-aQVdyL5g.js";
-import { a as getCodexWorkspaceMemoryToolNames, c as readContextEngineThreadBootstrapProjection, d as resolveCodexDeliveryHintPreservedInputRange, f as resolveContextEngineBootstrapProjectionDecision, i as buildCodexWorkspaceBootstrapContext, l as readMirroredSessionHistoryMessages, n as buildCodexSystemPromptReport, r as buildCodexWatchedSessionsContext, s as prependCodexOpenClawPromptContext, t as buildCodexOpenClawPromptContext, u as renderCodexSkillsCollaborationInstructions } from "./attempt-context-CSazkWns.js";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-BOM3Y1pl.js";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-BwCLTY_U.js";
+import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-context-Dr_mzvk4.js";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BmBM4qBV.js";
+import { _ as sanitizeCodexToolResponse, g as sanitizeCodexToolArguments, h as resolveCodexToolProgressDetailMode, m as isCodexCommandBearingToolCall, p as inferCodexDynamicToolMeta } from "./native-subagent-task-ids-BzTdT0Uw.js";
+import { n as createCodexNativeSubagentHistoryOwner } from "./native-subagent-history-owner-Pcp7JuVF.js";
+import { C as shouldRequireCodexSandboxExecServerEnvironment, S as shouldEnableCodexAppServerNativeToolSurface, _ as resolveCodexAppServerHookChannelId, a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeToolLifecycleProjector, f as buildDynamicTools, g as resolveCodexAppServerExecutionCwd, h as formatCodexDynamicToolBuildStageSummary, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as disableCodexPluginThreadConfig, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexDynamicToolBuildStageTracker, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as readBoundedCodexRemoteWorkspaceFile, v as resolveCodexExternalSandboxPolicyForOpenClawSandbox, w as shouldWarnCodexDynamicToolBuildStageSummary, x as resolveCodexSandboxEnvironmentSelection, y as resolveCodexMessageToolProvider } from "./dynamic-tools-CmN5RAip.js";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-BvCUL69A.js";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-Bz3FT8W5.js";
+import { a as CodexToolProgressProjection, i as CodexToolTranscriptProjection, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-fQ7eIXEf.js";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BBmXA8Eg.js";
+import { a as getCodexWorkspaceMemoryToolNames, c as readContextEngineThreadBootstrapProjection, d as resolveCodexDeliveryHintPreservedInputRange, f as resolveContextEngineBootstrapProjectionDecision, i as buildCodexWorkspaceBootstrapContext, l as readMirroredSessionHistoryMessages, n as buildCodexSystemPromptReport, r as buildCodexWatchedSessionsContext, s as prependCodexOpenClawPromptContext, t as buildCodexOpenClawPromptContext, u as renderCodexSkillsCollaborationInstructions } from "./attempt-context-D44yeDII.js";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-Du6gdUDd.js";
+import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-ClPJpRio.js";
 import { asOptionalRecord, normalizeOptionalString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { resolveAgentConfig, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
 import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import fs from "node:fs/promises";
 import path from "node:path";
+import fs from "node:fs/promises";
+import { addAbortListener } from "node:events";
+import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
+import { Buffer as Buffer$1 } from "node:buffer";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir as resolveAgentDir$1, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
-import { isDeepStrictEqual } from "node:util";
-import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$2 } from "openclaw/plugin-sdk/agent-runtime";
+import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessAttemptTerminal, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
-import { addAbortListener } from "node:events";
-import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
+import { isDeepStrictEqual } from "node:util";
+import { getSessionEntry, parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
-import { hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
-import { Buffer as Buffer$1 } from "node:buffer";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { appendSessionYieldContext, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
@@ -52,6 +67,7 @@ import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generat
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
 import { acknowledgeInternalToolResult } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 //#region extensions/codex/src/app-server/attempt-preparation-timing.ts
 /** Records startup before the native turn owns inference and tool execution. */
 function createCodexAttemptPreparationTiming(params) {
@@ -203,6 +219,12 @@ function createCodexSteeringQueue(params) {
 			}
 			liveItems = liveItems.filter(isCurrent);
 			if (liveItems.length === 0) return;
+			if (params.beforeSubmit) {
+				await params.beforeSubmit(liveItems);
+				assertActive();
+				liveItems = liveItems.filter(isCurrent);
+				if (liveItems.length === 0) return;
+			}
 			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
 			dispatchedBatches.set(clientUserMessageId, { items: liveItems });
 			const request = {
@@ -303,21 +325,8 @@ function createCodexSteeringQueue(params) {
 			const batch = dispatchedBatches.get(clientUserMessageId);
 			if (!batch) return false;
 			dispatchedBatches.delete(clientUserMessageId);
-			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);
-			}
+			for (const item of batch.items) resolveItem(item);
+			return true;
 		},
 		sealAdmission: sealQueueAdmission,
 		cancel: cancelQueue
@@ -328,6 +337,9 @@ function normalizeCodexSteerDebounceMs(value) {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : CODEX_STEER_ALL_DEBOUNCE_MS;
 }
 //#endregion
+//#region extensions/codex/src/app-server/attempt-terminal.ts
+const attemptTerminal = agentHarnessAttemptTerminal;
+//#endregion
 //#region extensions/codex/src/app-server/event-projector-assistant.ts
 var CodexAssistantProjection = class {
 	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp, checkpointCommentary) {
@@ -1078,8 +1090,61 @@ function reasoningMethodOrder(method) {
 	return method === "item/reasoning/summaryTextDelta" ? 0 : 1;
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-terminal.ts
-const attemptTerminal = agentHarnessAttemptTerminal;
+//#region extensions/codex/src/app-server/event-projector-settlement.ts
+var CodexProjectionSettlement = class {
+	constructor(params, isActive) {
+		this.turnTainted = false;
+		this.pending = /* @__PURE__ */ new Map();
+		const detach = (stage, callback) => callback ? (...args) => {
+			if (!isActive()) return;
+			const completion = createDeferred();
+			this.pending.set(completion.promise, stage);
+			const settled = () => {
+				this.pending.delete(completion.promise);
+				completion.resolve();
+			};
+			const failed = (error) => {
+				embeddedAgentLog.warn(`codex app-server ${stage} callback failed: ${String(error)}`);
+				settled();
+			};
+			try {
+				Promise.resolve(callback(...args)).then(settled, failed);
+			} catch (error) {
+				failed(error);
+			}
+		} : void 0;
+		this.params = {
+			...params,
+			onAssistantMessageStart: detach("onAssistantMessageStart", params.onAssistantMessageStart),
+			onPartialReply: detach("onPartialReply", params.onPartialReply),
+			onReasoningStream: detach("onReasoningStream", params.onReasoningStream),
+			onReasoningEnd: detach("onReasoningEnd", params.onReasoningEnd)
+		};
+	}
+	get pendingStage() {
+		return this.stage ?? this.pending.values().next().value;
+	}
+	get completedAnswer() {
+		const turn = this.terminalReceipt;
+		const answer = turn?.items?.findLast((item) => item.type === "agentMessage" && item.phase !== "commentary" && item.delivery !== "async" && typeof item.text === "string" && item.text.trim().length > 0);
+		return turn?.status === "completed" && answer ? {
+			turn,
+			answer
+		} : void 0;
+	}
+	async project(stage, project) {
+		const previous = this.stage;
+		this.stage = stage;
+		try {
+			return await project();
+		} finally {
+			this.stage = previous;
+		}
+	}
+	async drain() {
+		while (this.pending.size > 0) await Promise.all(this.pending.keys());
+	}
+};
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
 function buildCodexMessagesSnapshot(params) {
@@ -1094,7 +1159,10 @@ function buildCodexMessagesSnapshot(params) {
 		...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`));
+	if (params.lastAssistant) {
+		const assistant = applyCodexTranscriptTaint(params.lastAssistant, { tainted: params.turnTainted === true });
+		messages.push(attachCodexMirrorIdentity(assistant, `${params.turnId}:assistant`));
+	}
 	const taint = { tainted: false };
 	return messages.map((message) => projectAgentHarnessTranscriptMessageForDisplay({
 		hidden: params.runParams.trigger === "memory",
@@ -1125,116 +1193,6 @@ function buildCodexSteeringMessagesSnapshot(params) {
 	};
 }
 //#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 usage = input.usageProjection.usage;
-	const projectedUsage = input.aborted && usage ? {
-		...usage,
-		contextUsage: { state: "unavailable" }
-	} : usage;
-	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);
-	const synthesizedMissingToolResultError = input.toolTranscriptProjection.synthesizeMissingToolResults({
-		synthesize: legacyFailClosed,
-		terminalDisposition: input.aborted ? "tool_error" : hasDeliverableAssistantOnCompletedTurn ? "diagnostic_only" : "prompt_error"
-	});
-	const storedMissingToolResultError = synthesizedMissingToolResultError ?? input.synthesizedMissingToolResultError;
-	let promptErrorSource = input.promptErrorSource;
-	if (synthesizedMissingToolResultError) {
-		input.recordSynthesizedMissingToolResultError(synthesizedMissingToolResultError);
-		promptErrorSource = promptErrorSource ?? "prompt";
-	}
-	const assistantMessageOptions = {
-		tokenUsage: projectedUsage,
-		aborted: input.aborted,
-		promptError: input.promptError,
-		providerRefusal: input.providerRefusal
-	};
-	const lastAssistant = input.providerRefusal ? input.assistantProjection.createAssistantMessage("", assistantMessageOptions) : assistantTexts.length ? input.assistantProjection.createAssistantMessage(assistantTexts.join("\n\n"), assistantMessageOptions) : void 0;
-	const currentAttemptAssistant = input.providerRefusal ? lastAssistant : input.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
-	const messagesSnapshot = buildCodexMessagesSnapshot({
-		runParams: input.runParams,
-		turnId: input.turnId,
-		upstreamUserText: input.upstreamUserText,
-		reasoningText,
-		asyncMessages,
-		commentaryMessages,
-		toolMessages: input.toolTranscriptProjection.transcriptMessages,
-		lastAssistant
-	});
-	const turnFailed = input.completedTurn?.status === "failed";
-	const promptError = input.providerRefusal ? null : input.promptError ?? storedMissingToolResultError ?? (turnFailed ? input.completedTurn?.error?.message ?? "codex app-server turn failed" : null);
-	const agentHarnessResultClassification = input.providerRefusal ? void 0 : classifyAgentHarnessTerminalOutcome({
-		assistantTexts,
-		reasoningText,
-		planText,
-		promptError,
-		turnCompleted: Boolean(input.completedTurn)
-	});
-	const toolMetas = input.toolProgressProjection.toolMetas;
-	const hadPotentialSideEffects = input.toolTelemetry.didSendViaMessagingTool || Boolean(input.toolTelemetry.successfulCronAdds || input.toolTelemetry.acceptedSessionSpawns?.length) || input.generatedMediaProjection.hasGeneratedMedia() || input.toolProgressProjection.hasPotentialSideEffects;
-	const sentMediaUrls = new Set(input.toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
-	const toolAutoDeliveryMediaUrls = input.toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
-	const result = {
-		terminal: attemptTerminal.normalize({
-			aborted: input.aborted,
-			promptError,
-			promptErrorSource: promptError ? promptErrorSource || "prompt" : null
-		}),
-		sessionIdUsed: input.runParams.sessionId,
-		terminalTurnId: input.turnId,
-		...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
-		bootstrapPromptWarningSignaturesSeen: input.runParams.bootstrapPromptWarningSignaturesSeen,
-		bootstrapPromptWarningSignature: input.runParams.bootstrapPromptWarningSignature,
-		...input.usageProjection.modelIterations > 0 ? { modelIterations: input.usageProjection.modelIterations } : {},
-		messagesSnapshot,
-		assistantTexts,
-		toolMetas,
-		lastAssistant,
-		currentAttemptAssistant,
-		...input.toolProgressProjection.lastToolError ? { lastToolError: input.toolProgressProjection.lastToolError } : {},
-		didSendViaMessagingTool: input.toolTelemetry.didSendViaMessagingTool,
-		didDeliverSourceReplyViaMessageTool: input.toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
-		sourceReplyDelivered: input.toolTelemetry.sourceReplyDelivered,
-		messagingToolSentTexts: input.toolTelemetry.messagingToolSentTexts,
-		messagingToolSentMediaUrls: input.toolTelemetry.messagingToolSentMediaUrls,
-		messagingToolSentTargets: input.toolTelemetry.messagingToolSentTargets,
-		messagingToolSourceReplyPayloads: input.toolTelemetry.messagingToolSourceReplyPayloads ?? [],
-		heartbeatToolResponse: input.toolTelemetry.heartbeatToolResponse,
-		toolMediaUrls: input.generatedMediaProjection.buildToolMediaUrls(input.toolTelemetry),
-		hostOwnedToolMediaUrls: input.generatedMediaProjection.buildHostOwnedMediaUrls(input.toolTelemetry),
-		toolAudioAsVoice: input.toolTelemetry.toolAudioAsVoice,
-		successfulCronAdds: input.toolTelemetry.successfulCronAdds,
-		acceptedSessionSpawns: input.toolTelemetry.acceptedSessionSpawns,
-		cloudCodeAssistFormatError: false,
-		contextTokens: input.contextTokens,
-		contextTokensSource: input.contextTokensSource,
-		attemptUsage: projectedUsage,
-		...input.completedCompactionCount > 0 ? { compactionCount: input.completedCompactionCount } : {},
-		replayMetadata: {
-			hadPotentialSideEffects,
-			replaySafe: !hadPotentialSideEffects
-		},
-		itemLifecycle: {
-			startedCount: input.activeItemCount + input.completedItemCount,
-			completedCount: input.completedItemCount,
-			activeCount: input.activeItemCount
-		},
-		yieldDetected: input.yieldDetected || false,
-		didSendDeterministicApprovalPrompt: input.guardianReviewCount > 0 ? false : void 0
-	};
-	const transferTtsProvenance = resolveCodexTtsProvenanceTransfer(input.runParams.hostCapabilities);
-	for (const toolResult of input.toolTelemetry.coreTtsToolResults ?? []) transferTtsProvenance?.(toolResult, result, toolAutoDeliveryMediaUrls ?? []);
-	return result;
-}
-//#endregion
 //#region extensions/codex/src/app-server/usage-limit-error.ts
 /**
 * Enriches Codex usage-limit failures with current rate-limit information and
@@ -1251,7 +1209,7 @@ function resolveCodexPromptError(source) {
 	const usageLimitMessage = formatCodexUsageLimitErrorMessage(source);
 	if (usageLimitMessage) return new CodexUsageLimitPromptError(usageLimitMessage);
 	const info = source.codexErrorInfo;
-	let status = info === "serverOverloaded" ? 503 : info === "internalServerError" ? 500 : void 0;
+	let status = info === "rateLimitExceeded" ? 429 : info === "serverOverloaded" ? 503 : info === "internalServerError" ? 500 : void 0;
 	if (isJsonObject(info)) for (const variant of [
 		"httpConnectionFailed",
 		"responseStreamConnectionFailed",
@@ -1423,6 +1381,7 @@ var CodexTranscriptCheckpoint = class {
 		this.writing = Promise.resolve();
 		this.tainted = false;
 		this.closed = false;
+		this.abandoned = false;
 		this.nextTimestamp = () => {
 			this.lastTimestamp = Math.max(Date.now(), this.lastTimestamp + 1);
 			return this.lastTimestamp;
@@ -1442,6 +1401,10 @@ var CodexTranscriptCheckpoint = class {
 			if (this.params.sessionTarget && !this.closed) this.pending.push(entry);
 		};
 	}
+	abandon() {
+		this.closed = this.abandoned = true;
+		this.pending.length = 0;
+	}
 	flush(close = false) {
 		if (this.closed) return this.writing;
 		this.closed = close;
@@ -1459,6 +1422,9 @@ var CodexTranscriptCheckpoint = class {
 			});
 			try {
 				await codexTranscriptMirrorRuntime.mirror({
+					assertWriteCurrent: () => {
+						if (this.abandoned) throw new Error("Codex transcript checkpoint was retired before write");
+					},
 					...this.params.sessionTarget,
 					sessionId: this.params.sessionId,
 					cwd: this.params.workspaceDir,
@@ -1482,8 +1448,9 @@ var CodexTranscriptCheckpoint = class {
 	}
 };
 //#endregion
-//#region extensions/codex/src/app-server/event-projector.ts
-var CodexAppServerEventProjector = class {
+//#region extensions/codex/src/app-server/event-projector-result.ts
+/** Owns per-turn projection state and builds results from the same state. */
+var CodexTurnProjection = class {
 	constructor(params, threadId, turnId, options = {}) {
 		this.params = params;
 		this.threadId = threadId;
@@ -1492,13 +1459,14 @@ var CodexAppServerEventProjector = class {
 		this.activeItemIds = /* @__PURE__ */ new Set();
 		this.completedItemIds = /* @__PURE__ */ new Set();
 		this.activeCompactionItemIds = /* @__PURE__ */ new Set();
-		this.projectionClosed = false;
+		this.projectionController = new AbortController();
 		this.settledTurnFailureFinalizationAllowed = false;
 		this.terminalFailure = new CodexTerminalFailureProjection();
 		this.synthesizedMissingToolResultError = null;
 		this.aborted = false;
 		this.usageProjection = new CodexUsageProjection();
 		this.completedCompactionCount = 0;
+		this.settlement = new CodexProjectionSettlement(params, () => !this.projectionClosed);
 		this.transcriptCheckpoint = new CodexTranscriptCheckpoint(params, threadId, turnId);
 		this.asyncDeliveryProjection = new CodexAsyncDeliveryProjection(params, threadId, turnId, options);
 		this.contextTokens = options.initialContextTokens;
@@ -1509,7 +1477,7 @@ var CodexAppServerEventProjector = class {
 			remoteWorkspaceRoot: options.remoteWorkspaceRoot,
 			readFile: options.readRemoteWorkspaceFile,
 			requestTimeoutMs: options.remoteWorkspaceRequestTimeoutMs,
-			signal: options.runAbortSignal
+			signal: options.runAbortSignal ? AbortSignal.any([options.runAbortSignal, this.projectionController.signal]) : this.projectionController.signal
 		});
 		this.toolProgressProjection = new CodexToolProgressProjection(params);
 		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, this.transcriptCheckpoint.nextTimestamp, {
@@ -1519,12 +1487,151 @@ var CodexAppServerEventProjector = class {
 			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.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
-		this.reasoningProjection = new CodexReasoningProjection(params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
+		this.assistantProjection = new CodexAssistantProjection(this.settlement.params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
+		this.reasoningProjection = new CodexReasoningProjection(this.settlement.params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
+	}
+	get projectionClosed() {
+		return this.projectionController.signal.aborted;
+	}
+	buildResult(toolTelemetry, options) {
+		this.eventProjection.flushPendingGuardianWarning();
+		const { params: runParams, turnId, completedTurn, aborted, contextTokens, contextTokensSource, completedCompactionCount, synthesizedMissingToolResultError: previousMissingToolResultError } = this;
+		const { promptError: initialPromptError, promptErrorSource: initialPromptErrorSource, providerRefusal } = this.terminalFailure;
+		const upstreamUserText = this.options.upstreamUserText;
+		const turnTainted = this.settlement.turnTainted;
+		const activeItemCount = this.activeItemIds.size;
+		const completedItemCount = this.completedItemIds.size;
+		const guardianReviewCount = this.eventProjection.guardianReviewCount;
+		const yieldDetected = options?.yieldDetected;
+		this.nativeToolLifecycleProjector.finalizeActive();
+		const assistantTexts = this.assistantProjection.collectAssistantTexts();
+		const asyncMessages = this.assistantProjection.collectAsyncMessages();
+		const commentaryMessages = this.assistantProjection.collectCommentaryMessages();
+		const reasoningText = this.reasoningProjection.reasoningText();
+		const planText = this.reasoningProjection.planText();
+		const usage = this.usageProjection.usage;
+		const projectedUsage = aborted && usage ? {
+			...usage,
+			contextUsage: { state: "unavailable" }
+		} : usage;
+		const hasAssistantItemText = this.assistantProjection.hasAssistantItemTextForSynthesis();
+		const legacyFailClosed = !completedTurn || completedTurn.status !== "completed" || hasAssistantItemText;
+		const hasDeliverableAssistantOnCompletedTurn = completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
+		const synthesizedMissingToolResultError = this.toolTranscriptProjection.synthesizeMissingToolResults({
+			synthesize: legacyFailClosed,
+			terminalDisposition: aborted ? "tool_error" : hasDeliverableAssistantOnCompletedTurn ? "diagnostic_only" : "prompt_error"
+		});
+		const storedMissingToolResultError = synthesizedMissingToolResultError ?? previousMissingToolResultError;
+		let promptErrorSource = initialPromptErrorSource;
+		if (synthesizedMissingToolResultError) {
+			this.synthesizedMissingToolResultError = synthesizedMissingToolResultError;
+			promptErrorSource = promptErrorSource ?? "prompt";
+		}
+		const assistantMessageOptions = {
+			tokenUsage: projectedUsage,
+			aborted,
+			promptError: initialPromptError,
+			providerRefusal
+		};
+		const lastAssistant = providerRefusal ? this.assistantProjection.createAssistantMessage("", assistantMessageOptions) : assistantTexts.length ? this.assistantProjection.createAssistantMessage(assistantTexts.join("\n\n"), assistantMessageOptions) : void 0;
+		const currentAttemptAssistant = providerRefusal ? lastAssistant : this.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
+		const messagesSnapshot = buildCodexMessagesSnapshot({
+			runParams,
+			turnId,
+			upstreamUserText,
+			reasoningText,
+			asyncMessages,
+			commentaryMessages,
+			toolMessages: this.toolTranscriptProjection.transcriptMessages,
+			lastAssistant,
+			turnTainted
+		});
+		const turnFailed = completedTurn?.status === "failed";
+		const promptError = providerRefusal ? null : initialPromptError ?? storedMissingToolResultError ?? (turnFailed ? completedTurn?.error?.message ?? "codex app-server turn failed" : null);
+		const agentHarnessResultClassification = providerRefusal ? void 0 : classifyAgentHarnessTerminalOutcome({
+			assistantTexts,
+			reasoningText,
+			planText,
+			promptError,
+			turnCompleted: Boolean(completedTurn)
+		});
+		const toolMetas = this.toolProgressProjection.toolMetas;
+		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || Boolean(toolTelemetry.successfulCronAdds || toolTelemetry.acceptedSessionSpawns?.length) || this.generatedMediaProjection.hasGeneratedMedia() || this.toolProgressProjection.hasPotentialSideEffects;
+		const sentMediaUrls = new Set(toolTelemetry.messagingToolSentMediaUrls.map((url) => url.trim()));
+		const toolAutoDeliveryMediaUrls = toolTelemetry.toolAutoDeliveryMediaUrls?.filter((url) => !sentMediaUrls.has(url.trim()));
+		const result = {
+			terminal: attemptTerminal.normalize({
+				aborted,
+				promptError,
+				promptErrorSource: promptError ? promptErrorSource || "prompt" : null
+			}),
+			sessionIdUsed: runParams.sessionId,
+			terminalTurnId: turnId,
+			...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
+			bootstrapPromptWarningSignaturesSeen: runParams.bootstrapPromptWarningSignaturesSeen,
+			bootstrapPromptWarningSignature: runParams.bootstrapPromptWarningSignature,
+			...this.usageProjection.modelIterations > 0 ? { modelIterations: this.usageProjection.modelIterations } : {},
+			messagesSnapshot,
+			assistantTexts,
+			toolMetas,
+			lastAssistant,
+			currentAttemptAssistant,
+			...this.toolProgressProjection.lastToolError ? { lastToolError: this.toolProgressProjection.lastToolError } : {},
+			didSendViaMessagingTool: toolTelemetry.didSendViaMessagingTool,
+			didDeliverSourceReplyViaMessageTool: toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
+			sourceReplyDelivered: toolTelemetry.sourceReplyDelivered,
+			messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,
+			messagingToolSentMediaUrls: toolTelemetry.messagingToolSentMediaUrls,
+			messagingToolSentTargets: toolTelemetry.messagingToolSentTargets,
+			messagingToolSourceReplyPayloads: toolTelemetry.messagingToolSourceReplyPayloads ?? [],
+			heartbeatToolResponse: toolTelemetry.heartbeatToolResponse,
+			toolMediaUrls: this.generatedMediaProjection.buildToolMediaUrls(toolTelemetry),
+			hostOwnedToolMediaUrls: this.generatedMediaProjection.buildHostOwnedMediaUrls(toolTelemetry),
+			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
+			successfulCronAdds: toolTelemetry.successfulCronAdds,
+			acceptedSessionSpawns: toolTelemetry.acceptedSessionSpawns,
+			cloudCodeAssistFormatError: false,
+			contextTokens,
+			contextTokensSource,
+			attemptUsage: projectedUsage,
+			...completedCompactionCount > 0 ? { compactionCount: completedCompactionCount } : {},
+			replayMetadata: {
+				hadPotentialSideEffects,
+				replaySafe: !hadPotentialSideEffects
+			},
+			itemLifecycle: {
+				startedCount: activeItemCount + completedItemCount,
+				completedCount: completedItemCount,
+				activeCount: activeItemCount
+			},
+			yieldDetected: yieldDetected || false,
+			didSendDeterministicApprovalPrompt: guardianReviewCount > 0 ? false : void 0
+		};
+		const transferTtsProvenance = resolveCodexTtsProvenanceTransfer(runParams.hostCapabilities);
+		for (const toolResult of toolTelemetry.coreTtsToolResults ?? []) transferTtsProvenance?.(toolResult, result, toolAutoDeliveryMediaUrls ?? []);
+		return result;
+	}
+	emitAgentEvent(event) {
+		if (!this.projectionClosed) emitCodexAgentEvent(this.params, event);
 	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/event-projector.ts
+var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
 	}
+	/** Native completion owns the answer independently of unfinished host projection. */
+	recoverCompletedAnswer() {
+		const completed = this.settlement.completedAnswer;
+		if (!completed || this.aborted || this.terminalFailure.promptError) return false;
+		this.projectionController.abort();
+		this.transcriptCheckpoint.abandon();
+		this.completedTurn = completed.turn;
+		this.assistantProjection.recordSnapshotItem(completed.answer);
+		this.assistantProjection.finalizeAnswerCandidate(completed.turn);
+		return true;
+	}
 	getActiveMcpToolCall(serverName) {
 		if (this.projectionClosed || this.aborted) return;
 		return this.nativeToolLifecycleProjector.getActiveMcpToolCall(serverName);
@@ -1553,8 +1660,8 @@ var CodexAppServerEventProjector = class {
 	}
 	/** Fence delayed projections before the turn's final snapshot leaves its owner. */
 	closeProjection() {
-		this.projectionClosed = true;
-		return this.transcriptCheckpoint.flush(true);
+		this.projectionController.abort();
+		return this.settlement.project("transcript/checkpoint", () => this.transcriptCheckpoint.flush(true));
 	}
 	/** Resolves the shared model-order position for a native tool item. */
 	recordNativeToolOutcome(item) {
@@ -1596,11 +1703,9 @@ var CodexAppServerEventProjector = class {
 				break;
 			case "item/started":
 				await this.handleItemStarted(params);
-				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/completed":
 				await this.handleItemCompleted(params);
-				await this.transcriptCheckpoint.flush();
 				break;
 			case "item/commandExecution/outputDelta":
 				this.toolProgressProjection.handleOutputDelta(params, "bash");
@@ -1643,20 +1748,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": {
 				this.usageProjection.invalidateContext();
-				if (params.willRetry === true) break;
+				if (params.willRetry === true) {
+					this.eventProjection.handleRetry(params);
+					break;
+				}
 				const codexErrorInfo = isJsonObject(params.error) ? params.error.codexErrorInfo : void 0;
-				const message = readCodexErrorNotificationMessage(params);
 				const compactionFailure = codexErrorInfo === "other" && this.isCompacting();
 				this.settledTurnFailureFinalizationAllowed = codexErrorInfo === "serverOverloaded" || compactionFailure;
 				this.terminalFailure.record({
-					message,
+					message: readCodexErrorNotificationMessage(params),
 					codexErrorInfo,
 					rateLimits: this.options.readRecentRateLimits?.(),
 					fallbackMessage: "codex app-server error",
@@ -1677,47 +1783,23 @@ var CodexAppServerEventProjector = class {
 			case "model/safetyBuffering/updated": break;
 			default: this.diagnostics.warnUnknownEvent(notification, params);
 		}
-	}
-	buildResult(toolTelemetry, options) {
-		this.eventProjection.flushPendingGuardianWarning();
-		return buildCodexAttemptResult({
-			runParams: this.params,
-			turnId: this.turnId,
-			upstreamUserText: this.options.upstreamUserText,
-			completedTurn: this.completedTurn,
-			promptError: this.terminalFailure.promptError,
-			promptErrorSource: this.terminalFailure.promptErrorSource,
-			providerRefusal: this.terminalFailure.providerRefusal,
-			synthesizedMissingToolResultError: this.synthesizedMissingToolResultError,
-			recordSynthesizedMissingToolResultError: (error) => {
-				this.synthesizedMissingToolResultError = error;
-				this.terminalFailure.promptErrorSource ??= "prompt";
-			},
-			aborted: this.aborted,
-			contextTokens: this.contextTokens,
-			contextTokensSource: this.contextTokensSource,
-			completedCompactionCount: this.completedCompactionCount,
-			activeItemCount: this.activeItemIds.size,
-			completedItemCount: this.completedItemIds.size,
-			guardianReviewCount: this.eventProjection.guardianReviewCount,
-			toolTelemetry,
-			yieldDetected: options?.yieldDetected,
-			nativeToolLifecycleProjection: this.nativeToolLifecycleProjector,
-			assistantProjection: this.assistantProjection,
-			reasoningProjection: this.reasoningProjection,
-			usageProjection: this.usageProjection,
-			toolTranscriptProjection: this.toolTranscriptProjection,
-			toolProgressProjection: this.toolProgressProjection,
-			generatedMediaProjection: this.generatedMediaProjection
-		});
+		if (!this.projectionClosed && [
+			"item/started",
+			"item/completed",
+			"rawResponseItem/completed"
+		].includes(notification.method)) await this.settlement.project("transcript/checkpoint", () => this.transcriptCheckpoint.flush());
 	}
 	recordDynamicToolCall(params) {
 		this.toolTranscriptProjection.recordDynamicToolCall(params);
 	}
 	/** 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 : [] };
+		const update = projectProgressCardChannelUpdate(params);
+		if (update) {
+			const projected = {
+				plan: update.steps,
+				...update.explanation ? { explanation: update.explanation } : {}
+			};
 			await this.reasoningProjection.handleTurnPlanUpdated(projected, "openclaw");
 		}
 	}
@@ -1805,7 +1887,7 @@ var CodexAppServerEventProjector = class {
 		if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 		if (this.projectionClosed) return;
 		this.reasoningProjection.recordItem(item);
-		await this.generatedMediaProjection.recordNative(item);
+		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
 		if (this.projectionClosed) return;
 		if (item?.type === "contextCompaction" && itemId) {
 			if (!this.isCompactionProjectionActive()) return;
@@ -1897,11 +1979,16 @@ var CodexAppServerEventProjector = class {
 			if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
 			if (this.projectionClosed) return;
 			this.reasoningProjection.recordItem(item);
-			await this.generatedMediaProjection.recordNative(item);
+			await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordNative(item));
 			if (this.projectionClosed) return;
 			this.toolProgressProjection.recordToolMeta(item);
 			this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
-			await this.emitSnapshotOnlyNativeToolProgress(item);
+			await this.eventProjection.emitSnapshotOnlyNativeToolProgress({
+				item,
+				activeItemIds: this.activeItemIds,
+				completedItemIds: this.completedItemIds,
+				isActive: () => !this.projectionClosed
+			});
 			if (this.projectionClosed) return;
 			this.toolTranscriptProjection.recordNativeToolCall(item);
 			const details = await this.toolTranscriptProjection.prepareNativeToolResultDetails(item);
@@ -1921,39 +2008,12 @@ var CodexAppServerEventProjector = class {
 		this.activeCompactionItemIds.clear();
 		await this.reasoningProjection.maybeEndReasoning();
 	}
-	async emitSnapshotOnlyNativeToolProgress(item) {
-		if (!shouldSynthesizeToolProgressForItem(item) || !matchesCodexSnapshotTurn(item, this.turnId) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
-		if (!this.activeItemIds.has(item.id)) {
-			this.eventProjection.emitStandardItemEvent({
-				phase: "start",
-				item
-			});
-			await this.eventProjection.emitNormalizedToolItemEvent({
-				phase: "start",
-				item
-			});
-		}
-		if (this.projectionClosed) return;
-		this.activeItemIds.delete(item.id);
-		this.eventProjection.emitStandardItemEvent({
-			phase: "end",
-			item
-		});
-		await this.eventProjection.emitNormalizedToolItemEvent({
-			phase: "result",
-			item
-		});
-		this.completedItemIds.add(item.id);
-	}
 	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
 		this.toolTranscriptProjection.recordRawNativeToolItem(item);
 		this.assistantProjection.handleRawResponseItemCompleted(item, this.activeItemIds);
-		await this.generatedMediaProjection.recordRaw(item);
-	}
-	emitAgentEvent(event) {
-		if (!this.projectionClosed) emitCodexAgentEvent(this.params, event);
+		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordRaw(item));
 	}
 	isHookNotificationForCurrentThread(params) {
 		const threadId = readStringField(params, "threadId");
@@ -2064,6 +2124,7 @@ function createNativeMcpRuntime(params) {
 		listResourceTemplates: async (serverName) => {
 			return { resourceTemplates: (await loadStatuses()).find((entry) => entry.name === serverName)?.resourceTemplates ?? [] };
 		},
+		joinCleanup: async () => {},
 		dispose: async () => {}
 	};
 	return runtime;
@@ -2301,9 +2362,9 @@ function createCodexUserInputBridge(params) {
 			});
 		},
 		async handleElicitationRequest(request) {
-			if (readRawOwnString(request.params, "threadId") !== params.threadId) return;
+			if (readOwnDataString(request.params, "threadId") !== params.threadId) return;
 			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params);
-			if (requestSnapshot === void 0) {
+			if (!agentHarnessStructuredInput.isRecord(requestSnapshot)) {
 				const cancelValue = createCodexElicitationResponse("cancel");
 				return await enqueue({
 					requestId: request.id,
@@ -2319,10 +2380,10 @@ function createCodexUserInputBridge(params) {
 					}
 				});
 			}
-			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DMkeki8d.js");
+			if (readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
+			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.js");
 			const compiled = compileCodexOrdinaryElicitation({
-				value: requestSnapshot,
-				threadId: params.threadId,
+				snapshot: requestSnapshot,
 				turnId: params.turnId
 			});
 			if (compiled.kind === "ignored") return;
@@ -2348,7 +2409,7 @@ function createCodexUserInputBridge(params) {
 		handleNotification(notification) {
 			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;
+			if (requestId === void 0 || readOwnDataString(notification.params, "threadId") !== params.threadId) return;
 			const job = jobs.find((candidate) => typeof candidate.requestId === typeof requestId && candidate.requestId === requestId);
 			if (job) cancelJob(job);
 		},
@@ -2427,11 +2488,7 @@ function readArray(record, key, maximum) {
 	const value = readValue(record, key);
 	return Array.isArray(value) && value.length <= maximum ? value : void 0;
 }
-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) {
+function readOwnDataString(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;
@@ -2576,6 +2633,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		}
 	});
 	if (isTerminalTurnStatus(turn.turn.status)) {
+		projectorRef.current.settlement.terminalReceipt = turn.turn;
 		state.terminalTurnNotificationQueued = true;
 		deadlines.beginSettlement(Date.now());
 	}
@@ -2677,13 +2735,15 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			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) => {
+		beforeSubmit: async (items) => {
 			const transcriptItems = items.filter((item) => item.isInboundUserMessage === true || item.userTurnTranscriptRecorder !== void 0);
 			if (transcriptItems.length === 0) return;
 			await promptMirrorPromise;
+			assertSteeringActive();
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
 			if (params.sessionTarget && messages.length > 0) {
 				await codexTranscriptMirrorRuntime.mirror({
+					assertCurrent: assertSteeringActive,
 					agentId: sessionAgentId,
 					sessionKey: contextSessionKey,
 					sessionId: params.sessionId,
@@ -2695,13 +2755,15 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 					runMirrorIdentityPrefix: `${activeTurnId}:`,
 					config: params.config
 				});
+				assertSteeringActive();
 				activeProjector.markSteeringTranscriptPersisted();
 			}
 			for (const item of transcriptItems) {
 				const recorder = item.userTurnTranscriptRecorder;
 				if (!recorder) continue;
+				assertSteeringActive();
 				await recorder.persistApproved();
-				if (!recorder.hasPersisted()) throw new Error("Codex consumed steering before its user turn was persisted");
+				if (!recorder.hasPersisted()) throw new Error("Codex steering requires a persisted user turn before submission");
 			}
 		}
 	});
@@ -2721,6 +2783,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 				kind: authorityKind,
 				assertCurrent: injectionGuard(assertCurrent)
 			},
+			sourceRecorder: optionsLocal.userTurnTranscriptRecorder,
 			persist: optionsLocal.userTurnTranscriptRecorder ? async () => {
 				await optionsLocal.userTurnTranscriptRecorder?.persistApproved();
 			} : void 0
@@ -2800,7 +2863,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		abort: () => abortExplicitly("aborted")
 	};
 	params.replyOperation?.attachBackend(handle);
-	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile);
+	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile, sessionAgentId);
 	const freezeRunTerminalOutcome = () => {
 		if (terminalState.terminalOutcomeFrozen) return;
 		terminalState.terminalOutcomeFrozen = true;
@@ -2832,12 +2895,16 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	const { maybeEmitFastModeAutoResetBestEffort, emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, abortListener, handle, freezeRunTerminalOutcome } = activeTurn;
+	resourceState.releaseInferenceContext?.();
+	resourceState.releaseInferenceContext = void 0;
 	prompt.context.attemptTools.scheduledAppAuthoritySourceRef.current = void 0;
 	freezeRunTerminalOutcome();
 	const projectionClose = state.projectionClosed ? void 0 : activeTurn.activeProjector.closeProjection();
 	state.projectionClosed = true;
 	const checkpointCleanup = projectionClose ? runCleanupStep("codex-transcript-checkpoint", () => projectionClose) : void 0;
-	await state.abortCleanup.catch(() => void 0);
+	if (params.oneShotCliRun) await runCleanupStep("codex-abort-cleanup", () => state.abortCleanup);
+	else await state.abortCleanup?.catch(() => {});
+	if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-terminals", () => terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId, true));
 	try {
 		steeringQueueRef.current?.cancel();
 		if (params.isFinalFallbackAttempt !== false) await maybeEmitFastModeAutoResetBestEffort();
@@ -2858,8 +2925,8 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			aborted: runAbortController.signal.aborted && !state.clientClosedAbort
 		});
 		await runCleanupStep("codex-trajectory-flush", () => trajectoryRecorder?.flush());
-		const retainLiveIncognitoThread = (terminalState.turnSucceeded || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
-		const retainLiveThread = ((retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.turnSucceeded && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint) && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) ? bindingStore.read(bindingIdentity)?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
+		const retainLiveIncognitoThread = (terminalState.settledTurnStatus === "completed" || state.permissionChangeRestart === "confirmed" && !params.abortSignal?.aborted) && isIncognitoSessionKey(params.sessionKey);
+		const retainLiveThread = ((retainLiveIncognitoThread && resourceState.thread.liveThreadEphemeralPolicy !== void 0 || terminalState.settledTurnStatus !== void 0 && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint) && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) ? bindingStore.read(bindingIdentity)?.threadId === resourceState.thread.threadId && await bindingStore.withLease(bindingIdentity, async () => {
 			if (bindingStore.read(bindingIdentity)?.threadId !== resourceState.thread.threadId) return false;
 			return await retainCodexAppServerBindingSubscription(resourceState.client, resourceState.thread.threadId, {
 				release: resourceState.thread.liveThreadOwnership?.release,
@@ -2877,16 +2944,22 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 				if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
 					threadId: resourceState.thread.threadId,
 					timeoutMs: 5e3
-				})) await closeCodexStartupClientBestEffort(resourceState.client);
+				})) {
+					await closeCodexStartupClientBestEffort(resourceState.client);
+					if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-unsubscribe", async () => {
+						throw new Error("Codex one-shot thread unsubscribe was not confirmed");
+					});
+				}
 			}
 		}
 	} finally {
 		await runCleanupStep("codex-user-input-cancel", () => userInputBridgeRef.current?.cancelPending());
 		await runCleanupStep("codex-turn-deadline-clear", () => deadlines.dispose());
 		await runCleanupStep("codex-dynamic-tool-cleanup", async () => {
-			const cleanupReason = terminalState.turnSucceeded ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
+			const cleanupReason = terminalState.settledTurnStatus === "completed" ? "completion" : state.timeout ? "timeout" : runAbortController.signal.aborted ? "cancel" : "error";
 			const cleanups = prompt.context.attemptTools.runCleanups.splice(0);
-			await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)));
+			const errors = (await Promise.allSettled(cleanups.map(async (cleanup) => await cleanup(cleanupReason)))).filter((result) => result.status === "rejected");
+			if (params.oneShotCliRun && errors.length) throw new AggregateError(errors.map((result) => result.reason), "Codex tool cleanup failed");
 		});
 		await runCleanupStep("codex-route-release", releaseCurrentRoute);
 		await checkpointCleanup;
@@ -2895,7 +2968,7 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		resourceState.nativeHookRelay = void 0;
 		await runCleanupStep("codex-native-hook-relay-release", () => {
 			if (!nativeHookRelay) return;
-			if (state.shouldDelayNativeHookRelayUnregister) scheduleCodexNativeHookRelayUnregister({
+			if (state.shouldDelayNativeHookRelayUnregister && !params.oneShotCliRun) scheduleCodexNativeHookRelayUnregister({
 				relay: nativeHookRelay,
 				hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
 			});
@@ -3326,11 +3399,11 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		config: params.config,
 		agentId: policyAgentId
 	});
-	const agentDir = params.agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId);
+	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
 	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
 	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
 	const assertLocalTargetSupported = (unsupported) => {
-		if (preparedEnvironment?.localProcessEnv && unsupported) throw new Error("This runtime cannot target the diagnosed local installation. Use the saved prompt with a suggested external or manual handoff on this machine.");
+		if (preparedEnvironment?.localProcessEnv && unsupported) throw new Error("This runtime cannot target the diagnosed local installation. Use an owned local Codex stdio process, or use the saved prompt with a suggested external or manual handoff on this machine.");
 	};
 	assertLocalTargetSupported(sandbox?.enabled === true || remoteExec);
 	const preparedShellEnvironment = preparedEnvironment ? {
@@ -3341,7 +3414,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const shellEnvironment = preparedShellEnvironment && Object.keys(preparedShellEnvironment).length > 0 ? preparedShellEnvironment : void 0;
 	const disableLoginShell = remoteExec || preparedEnvironment?.localProcessEnv !== void 0 || preparedEnvironment?.managedLocalIdentity === true || preparedEnvironment !== void 0 && Object.keys(preparedEnvironment.credentialScrubEnv).length > 0;
 	const withPreparedProcessEnv = (appServer) => {
-		assertLocalTargetSupported(appServer.start.transport === "websocket" || Boolean(appServer.remoteWorkspaceRoot));
+		assertLocalTargetSupported(appServer.start.transport !== "stdio" || Boolean(appServer.remoteWorkspaceRoot));
 		return shellEnvironment ? {
 			...appServer,
 			start: {
@@ -3518,7 +3591,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	preDynamicStartupStages.mark("app-server-policy");
 	preDynamicStartupStages.mark("native-hook-relay");
 	const terminalState = {
-		turnSucceeded: false,
+		settledTurnStatus: void 0,
 		explicitCancellationObserved: false,
 		explicitCancellationReason: void 0,
 		terminalOutcomeFrozen: false,
@@ -3730,7 +3803,12 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		sessionKey: contextSessionKey,
 		sessionId: params.sessionId,
 		workspaceDir: params.workspaceDir,
+		...!usesSupervisionConnection && connection.mutable.startupBinding?.preserveNativeModel !== true ? {
+			modelProviderId: params.provider,
+			modelId: params.modelId
+		} : {},
 		trigger: params.trigger,
+		inputProvenance: params.inputProvenance,
 		...buildAgentHookContextChannelFields({
 			sessionKey: contextSessionKey,
 			messageChannel: params.messageChannel,
@@ -3789,6 +3867,17 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	});
 	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions ? connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions ?? workspaceBootstrapContext.threadDeveloperInstructions : void 0;
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
+	const watchedSessionsContext = buildCodexWatchedSessionsContext({
+		attempt: runtimeParams,
+		dynamicTools: toolBridge.availableSpecs,
+		sessionKey: contextSessionKey,
+		sandboxed: sandbox?.enabled === true
+	});
+	const buildOpenClawPromptContext = (includeWorkspaceReferences) => buildCodexOpenClawPromptContext({
+		params: runtimeParams,
+		workspacePromptContext: includeWorkspaceReferences ? workspaceBootstrapContext.promptContext : void 0,
+		watchedSessionsContext
+	});
 	return {
 		runtime,
 		attemptTools,
@@ -3801,16 +3890,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		workspaceBootstrapContext,
 		agentWorkspaceDeveloperInstructions,
 		baseDeveloperInstructions,
-		openClawPromptContext: buildCodexOpenClawPromptContext({
-			params: runtimeParams,
-			workspacePromptContext: workspaceBootstrapContext.promptContext,
-			watchedSessionsContext: buildCodexWatchedSessionsContext({
-				attempt: runtimeParams,
-				dynamicTools: toolBridge.availableSpecs,
-				sessionKey: contextSessionKey,
-				sandboxed: sandbox?.enabled === true
-			})
-		}),
+		buildOpenClawPromptContext,
 		skillsCollaborationInstructions: renderCodexSkillsCollaborationInstructions({
 			attempt: runtimeParams,
 			skillsPrompt: params.skillsSnapshot?.prompt
@@ -4057,6 +4137,7 @@ function recordCodexTrajectoryCompletion(recorder, params) {
 		yieldDetected: params.yieldDetected ?? false,
 		aborted: terminal.aborted,
 		promptError: normalizeCodexTrajectoryError(terminal.promptError),
+		...terminal.settlementWarning ? { settlementWarning: terminal.settlementWarning } : {},
 		usage: params.result.attemptUsage,
 		assistantTexts: params.result.assistantTexts,
 		messagesSnapshot: params.result.messagesSnapshot
@@ -4107,25 +4188,25 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		assertCodexBindingMayBeReplaced(resourceState.thread, operation);
 		return true;
 	};
-	const { state, completion, deadlines } = turnRuntime;
+	const { state, completion, deadlines, settlementExpired } = turnRuntime;
 	const { emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { drainNotificationQueue } = notifications;
 	const { codexModelCallDiagnostics } = requestRuntime;
 	const { activeTurnId, activeProjector, runtimeModelSelection, streamState, freezeRunTerminalOutcome, notifyUserMessagePersisted } = activeTurn;
 	await completion;
-	const abortGraceElapsed = createDeferred();
+	const drainGraceElapsed = createDeferred();
 	let settlementPhase = "active";
-	let abortGraceTimer;
-	const beginAbortGrace = () => {
-		if (settlementPhase !== "active") return;
-		abortGraceTimer = setTimeout(() => {
+	let drainGraceTimer;
+	const beginDrainGrace = () => {
+		if (settlementPhase !== "active" || drainGraceTimer) return;
+		drainGraceTimer = setTimeout(() => {
 			settlementPhase = "expired";
-			abortGraceElapsed.resolve();
+			drainGraceElapsed.resolve();
 		}, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
-		abortGraceTimer.unref?.();
+		drainGraceTimer.unref?.();
 	};
 	const abortListener = addAbortListener(runAbortController.signal, () => {
-		state.abortCleanup.then(beginAbortGrace, beginAbortGrace);
+		state.abortCleanup.then(beginDrainGrace, beginDrainGrace);
 	});
 	const closeProjection = () => {
 		state.projectionClosed = true;
@@ -4135,14 +4216,24 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		if (settlementPhase === "closed") return;
 		settlementPhase = "closed";
 		abortListener[Symbol.dispose]();
-		clearTimeout(abortGraceTimer);
+		clearTimeout(drainGraceTimer);
 		deadlines.dispose();
 	};
-	const settlement = drainNotificationQueue().then(closeProjection);
+	const settlement = drainNotificationQueue().then(async () => {
+		await closeProjection();
+		await activeProjector.settlement.drain();
+	});
+	const degradedSettlement = settlementExpired.then(() => {
+		beginDrainGrace();
+	});
 	let projectionDrained = false;
 	try {
 		try {
-			projectionDrained = await Promise.race([settlement.then(() => true), abortGraceElapsed.promise.then(() => false)]);
+			projectionDrained = await Promise.race([
+				settlement.then(() => true),
+				drainGraceElapsed.promise.then(() => false),
+				degradedSettlement.then(() => false)
+			]);
 			if (runAbortController.signal.aborted) await state.abortCleanup;
 		} finally {
 			if (!state.projectionClosed) await resources.runCleanupStep("codex-transcript-checkpoint", closeProjection);
@@ -4150,7 +4241,8 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected: toolState.yieldDetected });
 		const projectedTerminal = attemptTerminal.project(result.terminal);
 		const isFinalAborted = () => terminalState.explicitCancellationObserved || !resourceState.executionDisconnectError && (projectedTerminal.aborted || runAbortController.signal.aborted && !state.clientClosedAbort);
-		let enrichedPromptError = resourceState.executionDisconnectError ?? state.clientClosedPromptError ?? (state.timeout?.kind === "settlement" ? "codex app-server terminal settlement timed out" : state.timeout?.kind === "execution" ? "codex app-server execution budget timed out" : projectedTerminal.promptError);
+		const currentPromptError = (fallback) => resourceState.executionDisconnectError ?? state.clientClosedPromptError ?? (state.timeout ? `codex app-server ${state.timeout.kind === "execution" ? "execution budget" : "terminal settlement"} timed out` : fallback);
+		let enrichedPromptError = currentPromptError(projectedTerminal.promptError);
 		const enrichedPromptErrorMessage = typeof enrichedPromptError === "string" ? enrichedPromptError : enrichedPromptError instanceof Error ? enrichedPromptError.message : enrichedPromptError ? formatErrorMessage(enrichedPromptError) : void 0;
 		if (isInvalidCodexImagePayloadError(enrichedPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 			phase: "turn_completed",
@@ -4194,7 +4286,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		const projectTerminalOutcome = () => {
 			const effectiveTimedOut = state.timeout !== void 0;
 			const clientClosedPromptErrorForFinal = state.clientClosedPromptError;
-			const finalPromptError = resourceState.executionDisconnectError ?? clientClosedPromptErrorForFinal ?? (state.timeout?.kind === "settlement" ? "codex app-server terminal settlement timed out" : state.timeout?.kind === "execution" ? "codex app-server execution budget timed out" : enrichedPromptError);
+			const finalPromptError = currentPromptError(enrichedPromptError);
 			const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : projectedTerminal.promptErrorSource;
 			const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : state.timeout?.kind === "settlement" ? "turn_settlement_timeout" : void 0;
 			const replayBlockedReason = codexAppServerFailureKind ? resolveCodexAppServerReplayBlockedReason(result) : void 0;
@@ -4220,6 +4312,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			if (toolBridge.telemetry.messagingToolSentTargets.some((target) => target.sourceReplyFinal === true)) result.agentHarnessResultClassification = void 0;
 			const attemptSucceeded = turnSucceeded && result.agentHarnessResultClassification === void 0;
 			result.terminal = attemptTerminal.normalize({
+				settlementWarning: state.settlementWarning,
 				timedOut: effectiveTimedOut,
 				aborted: finalAborted,
 				promptError: finalPromptError,
@@ -4246,20 +4339,24 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 				completedTurnStatus
 			};
 		};
-		const mirrorTerminal = projectTerminalOutcome();
+		projectTerminalOutcome();
 		const unavailableMirror = {
 			assistantTranscriptOwned: false,
 			mirroredMessages: []
 		};
 		let mirrorOutcome = unavailableMirror;
-		try {
-			if (projectionDrained && settlementPhase === "active") mirrorOutcome = await Promise.race([codexTranscriptMirrorRuntime.mirrorBestEffort({
+		const mirrorFinal = () => {
+			const warning = state.settlementWarning;
+			const mirrorTerminal = projectTerminalOutcome();
+			state.pendingSettlementStage = "transcript/mirror";
+			return codexTranscriptMirrorRuntime.mirrorBestEffort({
 				assertWriteCurrent: () => {
-					if (settlementPhase !== "active") throw new Error("Codex transcript settlement is no longer active");
+					if (settlementPhase !== "active" || state.settlementWarning !== warning) throw new Error("Codex transcript settlement is no longer active");
 					const current = projectTerminalOutcome();
 					if (current.finalAborted !== mirrorTerminal.finalAborted || current.effectiveTimedOut !== mirrorTerminal.effectiveTimedOut || current.finalPromptError !== mirrorTerminal.finalPromptError) throw new Error("Codex transcript terminal outcome changed before write");
 				},
 				params,
+				settlementWarning: warning,
 				agentId: sessionAgentId,
 				notifyUserMessagePersisted,
 				result,
@@ -4267,13 +4364,47 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 				cwd: effectiveCwd,
 				threadId: resourceState.thread.threadId,
 				turnId: activeTurnId
-			}), abortGraceElapsed.promise.then(() => unavailableMirror)]);
+			});
+		};
+		try {
+			if (projectionDrained && settlementPhase === "active" && !state.settlementWarning) mirrorOutcome = await Promise.race([
+				mirrorFinal(),
+				drainGraceElapsed.promise.then(() => unavailableMirror),
+				degradedSettlement.then(() => unavailableMirror)
+			]);
+			if (state.settlementWarning && !runAbortController.signal.aborted) {
+				mirrorOutcome = await Promise.race([mirrorFinal(), drainGraceElapsed.promise.then(() => unavailableMirror)]);
+				if (mirrorOutcome === unavailableMirror) trajectoryRecorder?.recordEvent("turn.settlement_persistence_unavailable", {
+					pendingStage: "transcript/mirror",
+					threadId: resourceState.thread.threadId,
+					turnId: activeTurnId
+				});
+			}
+			if (toolState.yieldMessage && projectTerminalOutcome().turnSucceeded) {
+				state.pendingSettlementStage = "transcript/yield-context";
+				await Promise.race([
+					appendSessionYieldContext({
+						...activeTranscriptTarget.sessionTarget,
+						agentId: activeTranscriptTarget.agentId,
+						sessionId: activeTranscriptTarget.sessionId,
+						sessionKey: activeTranscriptTarget.sessionKey,
+						config: params.config,
+						message: toolState.yieldMessage,
+						assertCurrent: () => {
+							connection.assertCurrent();
+							if (settlementPhase !== "active" || !projectTerminalOutcome().turnSucceeded) throw new Error("Codex yield settlement is no longer active");
+						}
+					}),
+					drainGraceElapsed.promise,
+					degradedSettlement
+				]);
+			}
 			if (runAbortController.signal.aborted) await state.abortCleanup;
 		} finally {
 			closeSettlement();
 		}
 		const { effectiveTimedOut, finalPromptError, codexAppServerFailure, promptTimeoutOutcome, finalAborted, turnSucceeded, attemptSucceeded, completedTurnStatus } = projectTerminalOutcome();
-		terminalState.turnSucceeded = turnSucceeded;
+		terminalState.settledTurnStatus = turnSucceeded ? "completed" : completedTurnStatus === "failed" && !finalAborted && !effectiveTimedOut && !state.clientClosedPromptError && !resourceState.executionDisconnectError ? "failed" : void 0;
 		terminalState.sharedAbortAllowedAfterTerminalOutcome = shouldKeepCodexSharedAbortOpen({
 			trigger: params.trigger,
 			result,
@@ -4326,7 +4457,9 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			ctx: hookContext,
 			hookRunner
 		});
+		const providerRefusal = result.currentAttemptAssistant?.diagnostics?.some((diagnostic) => diagnostic.type === "provider_refusal");
 		await runCodexAgentEndHook(params, {
+			skillExperienceReviewSource: providerRefusal ? void 0 : terminalAnchor,
 			event: {
 				messages: result.messagesSnapshot,
 				success: !finalAborted && !finalPromptError,
@@ -4350,7 +4483,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			hookRunner
 		});
 		state.shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
-		if (state.shouldDelayNativeHookRelayUnregister) try {
+		if (turnSucceeded && !runAbortController.signal.aborted) try {
 			const continuityCalibration = context.promptState.noEngineContinuityProjectionApplied ? buildCodexContinuityCalibration({
 				promptChars: prompt.turnState.codexTurnPromptText.length,
 				inputTokens: result.attemptUsage?.contextUsage?.state === "available" ? result.attemptUsage.contextUsage.promptTokens ?? 0 : 0
@@ -4699,7 +4832,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 						});
 						if (response && !state.projectionClosed && !runAbortController.signal.aborted && turnIdRef.current === turnId && item.success === response.success && isDeepStrictEqual(item.contentItems, response.contentItems)) acknowledgeInternalToolResult(response);
 					}
-					if (item?.type === "userMessage" && typeof item.clientId === "string") await steeringQueueRef.current?.confirmConsumed(item.clientId);
+					if (item?.type === "userMessage" && typeof item.clientId === "string") steeringQueueRef.current?.confirmConsumed(item.clientId);
 				}
 				if (isCodexTurnAbortMarkerNotification(notification, { currentPromptTexts: [turnState.codexTurnPromptText] })) state.sawCodexInterruptMarker = true;
 			}
@@ -4740,6 +4873,8 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		if (!projector || !turnId || state.projectionClosed) return;
 		projector.recordMcpToolCallReceipt(notification);
 		if (isTerminalTurnNotificationForTurn(notification, turnId)) {
+			const completed = readCodexTurnCompletedNotification(notification.params);
+			if (completed) projector.settlement.terminalReceipt = completed.turn;
 			state.terminalTurnNotificationQueued = true;
 			steeringQueueRef.current?.sealAdmission();
 			deadlines.beginSettlement(receivedAtMs);
@@ -4748,7 +4883,10 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			const modelToolCallId = readRawResponseToolCallId(notification);
 			if (modelToolCallId) allocateCodexToolOutcomeOrdinal?.(modelToolCallId);
 			const nativeItem = readCodexNotificationItem(notification.params);
-			if (nativeItem?.type === "webSearch") projector.recordNativeToolOutcome(nativeItem);
+			if (nativeItem?.type === "webSearch") {
+				projector.settlement.turnTainted ||= notification.method === "item/completed";
+				projector.recordNativeToolOutcome(nativeItem);
+			}
 		}
 	};
 	const enqueueNotification = async (notification, scope) => {
@@ -4775,17 +4913,47 @@ 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, codexContinuityProjectionMaxChars } = context;
+	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, buildOpenClawPromptContext, 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;
-	const applyFreshThreadContinuityProjection = () => {
-		const projection = projectContextEngineAssemblyForCodex({
-			assembledMessages: historyState.messages,
+	let contextImages = [];
+	const currentUserTurnIdempotencyKey = params.userTurnTranscriptRecorder?.message?.idempotencyKey;
+	const assertProjectionCurrent = () => {
+		params.hostCapabilities.assertActive();
+		connection.assertCurrent();
+		connection.runAbortController.signal.throwIfAborted();
+	};
+	const prepareFileContext = async (message, maxChars) => {
+		const prepare = params.hostCapabilities.prepareContextMedia;
+		if (!prepare) {
+			const media = asOptionalRecord(Reflect.get(message, "__openclaw"))?.media;
+			if (Array.isArray(media) && media.length || message.role === "user" && Array.isArray(message.content) && message.content.some((part) => part.type === "image")) throw new CodexContextAttachmentError("Saved attachments require a newer OpenClaw host. Update the Gateway and Codex plugin together, then retry.");
+			return { images: [] };
+		}
+		try {
+			const files = await prepare({
+				message,
+				maxChars
+			});
+			assertProjectionCurrent();
+			return files;
+		} catch (error) {
+			assertProjectionCurrent();
+			throw new CodexContextAttachmentError("Saved attachment preparation failed. Retry the request after checking the attachment source.", { cause: error });
+		}
+	};
+	const applyContinuityProjection = async (messages) => {
+		const projection = await projectContextEngineAssemblyForCodex({
+			assembledMessages: messages,
 			originalHistoryMessages: historyState.messages,
 			prompt: params.prompt,
-			maxRenderedContextChars: codexContinuityProjectionMaxChars
+			maxRenderedContextChars: codexContinuityProjectionMaxChars,
+			prepareFileContext,
+			currentUserTurnIdempotencyKey
 		});
+		assertProjectionCurrent();
+		contextImages = projection.images ?? [];
 		promptState.promptText = projection.promptText;
 		promptState.promptContextRange = projection.promptContextRange;
 		promptState.prePromptMessageCount = projection.prePromptMessageCount;
@@ -4814,14 +4982,6 @@ async function prepareCodexAttemptPrompt(context) {
 		});
 		if (!assembled) throw new Error("context engine assemble returned no result");
 		const contextEngineProjection = readContextEngineThreadBootstrapProjection(assembled.contextProjection);
-		const projection = projectContextEngineAssemblyForCodex({
-			assembledMessages: assembled.messages,
-			originalHistoryMessages: historyState.messages,
-			prompt: params.prompt,
-			systemPromptAddition: assembled.systemPromptAddition,
-			maxRenderedContextChars: codexContextProjectionMaxChars,
-			toolPayloadMode: contextEngineProjection ? "preserve" : "elide"
-		});
 		const projectionDecision = contextEngineProjection ? resolveContextEngineBootstrapProjectionDecision({
 			startupBinding: decisionStartupBinding,
 			expectedBinding: buildContextEngineBinding(buildActiveRunAttemptParams(), contextEngineProjection),
@@ -4832,6 +4992,18 @@ async function prepareCodexAttemptPrompt(context) {
 			project: true,
 			reason: "per-turn-projection"
 		};
+		const projection = await projectContextEngineAssemblyForCodex({
+			assembledMessages: assembled.messages,
+			originalHistoryMessages: historyState.messages,
+			prompt: params.prompt,
+			systemPromptAddition: assembled.systemPromptAddition,
+			maxRenderedContextChars: codexContextProjectionMaxChars,
+			toolPayloadMode: contextEngineProjection ? "preserve" : "elide",
+			...projectionDecision.project ? { prepareFileContext } : {},
+			currentUserTurnIdempotencyKey
+		});
+		assertProjectionCurrent();
+		contextImages = projectionDecision.project ? projection.images ?? [] : [];
 		const decisionBinding = decisionStartupBinding;
 		embeddedAgentLog.info("codex app-server context-engine projection decision", {
 			sessionId: params.sessionId,
@@ -4859,6 +5031,8 @@ async function prepareCodexAttemptPrompt(context) {
 	if (activeContextEngine) try {
 		await applyActiveContextEngineProjection(runtime.nativeToolSurfaceEnabled ? mutable.startupBinding : void 0);
 	} catch (assembleErr) {
+		if (assembleErr instanceof CodexContextAttachmentError) throw assembleErr;
+		assertProjectionCurrent();
 		embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 	}
 	const codexModelInputHistoryMessages = [];
@@ -4905,8 +5079,8 @@ async function prepareCodexAttemptPrompt(context) {
 			}
 		};
 	};
-	const decorateCodexTurnPromptText = (promptBuildResult) => {
-		const turnPromptText = prependCodexOpenClawPromptContext(promptBuildResult.prompt, openClawPromptContext, { preservePromptWithoutContext: params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron" });
+	const decorateCodexTurnPromptText = (promptBuildResult, includeWorkspaceReferences = true) => {
+		const turnPromptText = prependCodexOpenClawPromptContext(promptBuildResult.prompt, buildOpenClawPromptContext(includeWorkspaceReferences), { preservePromptWithoutContext: params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron" });
 		const projectedRanges = resolveShiftedPromptContextRange(promptBuildResult.prompt, promptBuildResult.promptInputRange, turnPromptText);
 		const preservedRange = resolveShiftedPromptInputRange(promptBuildResult.prompt, promptBuildResult.promptInputRange, turnPromptText) ?? resolveCodexDeliveryHintPreservedInputRange({
 			prompt: promptBuildResult.prompt,
@@ -4925,11 +5099,13 @@ async function prepareCodexAttemptPrompt(context) {
 		promptBuild: firstPromptBuild,
 		codexTurnPromptText: decorateCodexTurnPromptText(firstPromptBuild)
 	};
-	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, buildTurnCollaborationMode(params, {
+	let parentLocalEgress = false;
+	const parentLocalContext = {
 		turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
 		skillsCollaborationInstructions,
 		memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
-	}).settings.developer_instructions ?? void 0);
+	};
+	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, (parentLocalEgress ? buildCodexParentLocalInstructions(params, parentLocalContext) : buildTurnCollaborationMode(params, parentLocalContext).settings.developer_instructions) ?? void 0);
 	const rebuildCodexPromptBuildFromCurrentProjection = async () => {
 		turnState.promptBuild = await buildPromptFromCurrentInputs();
 		turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild);
@@ -4946,28 +5122,19 @@ async function prepareCodexAttemptPrompt(context) {
 	const selectNewerVisibleHistoryAfterBinding = (binding) => {
 		const cutoff = Date.parse(binding.historyCoveredThrough ?? "");
 		return historyState.messages.filter((message) => {
-			if (message.role !== "user" && message.role !== "assistant") return false;
+			if (message.role !== "user" && message.role !== "assistant" && !isCodexDurableCustomMessage(message)) return false;
 			const mirrorIdentity = readMirrorIdentity(message);
 			const timestamp = typeof message.timestamp === "number" ? message.timestamp : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
 			return !("idempotencyKey" in message && typeof message.idempotencyKey === "string" && message.idempotencyKey.startsWith("codex-app-server:")) && !hasCodexMirrorOrigin(message) && !mirrorIdentity?.startsWith("codex-app-server:") && Number.isFinite(timestamp) && timestamp > (Number.isFinite(cutoff) ? cutoff : 0);
 		});
 	};
-	const applyResumeStaleBindingContinuityProjection = (binding) => {
+	const applyResumeStaleBindingContinuityProjection = async (binding) => {
 		const newerVisibleMessages = selectNewerVisibleHistoryAfterBinding(binding);
 		if (newerVisibleMessages.length === 0) return false;
-		const projection = projectContextEngineAssemblyForCodex({
-			assembledMessages: newerVisibleMessages,
-			originalHistoryMessages: historyState.messages,
-			prompt: params.prompt,
-			maxRenderedContextChars: codexContinuityProjectionMaxChars
-		});
-		promptState.promptText = projection.promptText;
-		promptState.promptContextRange = projection.promptContextRange;
-		promptState.prePromptMessageCount = projection.prePromptMessageCount;
-		promptState.noEngineContinuityProjectionApplied = true;
+		await applyContinuityProjection(newerVisibleMessages);
 		return true;
 	};
-	const precomputeNoContextEngineStaleBindingProjection = () => {
+	const precomputeNoContextEngineStaleBindingProjection = async () => {
 		promptState.precomputedStaleBindingContinuityProjectionApplied = false;
 		promptState.staleBindingContinuityForcedFreshStart = false;
 		const binding = mutable.startupBinding;
@@ -4976,24 +5143,24 @@ async function prepareCodexAttemptPrompt(context) {
 			promptState.inactiveThreadBootstrapBindingForcedFreshStart = true;
 			return false;
 		}
-		const projected = applyResumeStaleBindingContinuityProjection(binding);
+		const projected = await applyResumeStaleBindingContinuityProjection(binding);
 		promptState.precomputedStaleBindingContinuityProjectionApplied = projected;
 		return projected;
 	};
-	const applyNoContextEngineContinuityProjection = (action, binding) => {
-		const hasContinuity = historyState.messages.some((message) => message.role === "user" || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
+	const applyNoContextEngineContinuityProjection = async (action, binding) => {
+		const hasContinuity = historyState.messages.some((message) => message.role === "user" || isCodexDurableCustomMessage(message) || action === "started" && (message.role === "compactionSummary" || message.role === "branchSummary"));
 		if (activeContextEngine || !hasContinuity) return false;
 		if (action === "resumed" && promptState.precomputedStaleBindingContinuityProjectionApplied) return true;
 		if (action === "started" && promptState.staleBindingContinuityForcedFreshStart) return true;
 		if (action === "started" && promptState.inactiveThreadBootstrapBindingForcedFreshStart) return false;
 		if (action === "resumed" && binding) return applyResumeStaleBindingContinuityProjection(binding);
 		if (action === "started") {
-			applyFreshThreadContinuityProjection();
+			await applyContinuityProjection(historyState.messages);
 			return true;
 		}
 		return false;
 	};
-	if (precomputeNoContextEngineStaleBindingProjection()) await rebuildCodexPromptBuildFromCurrentProjection();
+	if (await precomputeNoContextEngineStaleBindingProjection()) await rebuildCodexPromptBuildFromCurrentProjection();
 	const rotateStartupBindingForProjectedTurn = async () => {
 		const binding = mutable.startupBinding;
 		if (!binding?.threadId) return;
@@ -5020,12 +5187,14 @@ async function prepareCodexAttemptPrompt(context) {
 		if (mutable.startupBinding?.threadId) return;
 		promptState.inactiveThreadBootstrapBindingForcedFreshStart = hadInactiveThreadBootstrapBinding;
 		promptState.staleBindingContinuityForcedFreshStart = promptState.precomputedStaleBindingContinuityProjectionApplied && !promptState.inactiveThreadBootstrapBindingForcedFreshStart;
-		if (promptState.staleBindingContinuityForcedFreshStart) applyFreshThreadContinuityProjection();
+		if (promptState.staleBindingContinuityForcedFreshStart) await applyContinuityProjection(historyState.messages);
 		if (activeContextEngine) {
 			promptState.contextEngineProjection = void 0;
 			try {
 				await applyActiveContextEngineProjection(void 0);
 			} catch (assembleErr) {
+				if (assembleErr instanceof CodexContextAttachmentError) throw assembleErr;
+				assertProjectionCurrent();
 				embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 			}
 		}
@@ -5039,22 +5208,40 @@ async function prepareCodexAttemptPrompt(context) {
 		});
 	};
 	await rotateStartupBindingForProjectedTurn();
+	const buildSystemPromptReport = (omitWorkspaceReferences = false) => buildCodexSystemPromptReport({
+		attempt: params,
+		sessionKey: contextSessionKey,
+		workspaceDir: effectiveWorkspace,
+		developerInstructions: buildRenderedCodexDeveloperInstructions(),
+		workspaceBootstrapContext,
+		omitWorkspaceReferences,
+		skillsPrompt: skillsCollaborationInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
+		tools: toolBridge.availableSpecs
+	});
+	const systemPromptReport = buildSystemPromptReport();
+	let workspaceReferencesIncluded = true;
 	return {
 		context,
+		get contextImages() {
+			return contextImages;
+		},
 		codexModelInputHistoryMessages,
 		turnState,
+		refreshWorkspaceReferences: (include) => {
+			turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild, include);
+			if (include !== workspaceReferencesIncluded) {
+				Object.assign(systemPromptReport, buildSystemPromptReport(!include));
+				workspaceReferencesIncluded = include;
+			}
+		},
+		setParentLocalEgress: () => {
+			parentLocalEgress = true;
+			Object.assign(systemPromptReport, buildSystemPromptReport(!workspaceReferencesIncluded));
+		},
 		buildRenderedCodexDeveloperInstructions,
 		rebuildCodexTurnPromptTextFromCurrentProjection,
 		applyNoContextEngineContinuityProjection,
-		systemPromptReport: buildCodexSystemPromptReport({
-			attempt: params,
-			sessionKey: contextSessionKey,
-			workspaceDir: effectiveWorkspace,
-			developerInstructions: buildRenderedCodexDeveloperInstructions(),
-			workspaceBootstrapContext,
-			skillsPrompt: skillsCollaborationInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
-			tools: toolBridge.availableSpecs
-		})
+		systemPromptReport
 	};
 }
 //#endregion
@@ -5106,6 +5293,7 @@ function prepareCodexAttemptResources(prompt) {
 		sharedCodexClientRetiredForOneShotCleanup: false,
 		sandboxExecEnvironment: void 0,
 		executionDisconnectError: void 0,
+		releaseInferenceContext: void 0,
 		codexEnvironmentSelection: void 0,
 		codexExecutionCwd: effectiveCwd,
 		codexSandboxPolicy: void 0,
@@ -5153,10 +5341,11 @@ function prepareCodexAttemptResources(prompt) {
 			closed: retired.closed,
 			matchedSharedClient: retired.found
 		});
-		if (retired.closed) await state.client.closeAndWait({
+		const result = retired.closed ? await state.client.closeAndWait({
 			exitTimeoutMs: 2e3,
 			forceKillDelayMs: 250
-		});
+		}) : void 0;
+		if (params.oneShotCliRun && result?.cleanup !== "closed") throw new Error("Codex one-shot client cleanup could not be confirmed");
 	};
 	const releaseSandboxExecEnvironment = async () => {
 		if (state.sandboxExecEnvironment) {
@@ -5170,10 +5359,13 @@ function prepareCodexAttemptResources(prompt) {
 			await releaseSandboxExecEnvironment();
 			const ownedClient = state.releaseSharedClientLease ? state.client : void 0;
 			releaseSharedClientLeaseOnce();
-			await ownedClient?.closeAndWait({
-				exitTimeoutMs: 2e3,
-				forceKillDelayMs: 250
-			});
+			if (ownedClient) {
+				const result = await ownedClient.closeAndWait({
+					exitTimeoutMs: 2e3,
+					forceKillDelayMs: 250
+				});
+				if (params.oneShotCliRun && result.cleanup !== "closed") throw new Error("Codex isolated client cleanup could not be confirmed");
+			}
 			return;
 		}
 		releaseSharedClientLeaseOnce();
@@ -5194,11 +5386,26 @@ function prepareCodexAttemptResources(prompt) {
 	};
 	const registerNativeSubagentMonitor = (parentThreadId) => {
 		unregisterNativeSubagentMonitor();
+		const sessionKey = params.sessionKey;
+		const storePath = params.sessionTarget?.storePath;
+		const parentSession = sessionKey && storePath ? getSessionEntry({
+			agentId: sessionAgentId,
+			sessionKey,
+			storePath,
+			readConsistency: "latest",
+			hydrateSkillPromptRefs: false
+		}) : void 0;
 		state.nativeSubagentMonitor = codexNativeSubagentMonitorRuntime.register({
 			client: state.client,
 			parentThreadId,
 			requesterSessionKey: params.sessionKey,
 			taskRuntimeScope: params.agentHarnessTaskRuntimeScope,
+			historyOwner: createCodexNativeSubagentHistoryOwner({
+				parentThreadId,
+				sessionId: params.sessionId,
+				...parentSession?.sessionId === params.sessionId ? { lifecycleRevision: parentSession.lifecycleRevision } : {},
+				binding: state.thread
+			}),
 			agentId: sessionAgentId,
 			retainClient: () => retainSharedCodexAppServerClientIfCurrent(state.client),
 			retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(state.client, protectedThreadId),
@@ -5210,6 +5417,8 @@ function prepareCodexAttemptResources(prompt) {
 		});
 	};
 	const releaseCurrentRoute = () => {
+		state.releaseInferenceContext?.();
+		state.releaseInferenceContext = void 0;
 		state.detachRouteAbort();
 		state.detachRouteAbort = () => void 0;
 		state.turnRoute?.release();
@@ -5646,10 +5855,10 @@ function createCodexDynamicToolExecutionRegistry() {
 		}
 	};
 }
-function resolveCodexDynamicToolDirectNames(params, hostSystemAgentActive = false) {
+function resolveCodexDynamicToolDirectNames(params, registeredTools, hostSystemAgentActive = false) {
 	const names = [];
 	if (hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow)) names.push("openclaw");
-	if (params.sourceReplyDeliveryMode === "message_tool_only") names.push("message");
+	if (registeredTools.some((tool) => tool.name === "message")) names.push("message");
 	return names;
 }
 //#endregion
@@ -5922,7 +6131,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 //#region extensions/codex/src/app-server/attempt-runtime-artifact.ts
 async function verifyStartupArtifact(params) {
 	if (!params.request) return;
-	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Bh_gf6-t.js");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-BJ0rXBZ_.js");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -5934,12 +6143,7 @@ async function verifyStartupArtifact(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/computer-use-health.ts
-const COMPUTER_USE_HEALTH_MONITOR_STATE = Symbol.for("openclaw.codexComputerUseHealthMonitorState");
-function getComputerUseHealthMonitorState() {
-	const globalState = globalThis;
-	globalState[COMPUTER_USE_HEALTH_MONITOR_STATE] ??= { monitors: /* @__PURE__ */ new WeakMap() };
-	return globalState[COMPUTER_USE_HEALTH_MONITOR_STATE];
-}
+const getComputerUseHealthMonitorState = defineCodexBuildState("openclaw.codexComputerUseHealthMonitorState", () => ({ monitors: /* @__PURE__ */ new WeakMap() }));
 function startCodexComputerUseHealthMonitor(params) {
 	const state = getComputerUseHealthMonitorState();
 	const existing = state.monitors.get(params.client);
@@ -6516,7 +6720,7 @@ function shouldRetireCodexStartupClient(error, spawnedBy, signal) {
 //#region extensions/codex/src/app-server/run-attempt-start.ts
 async function startCodexAttemptRuntime(resources) {
 	const { prompt, state, trajectoryRecorder, activateNativePreToolUseFailureFallback, releaseSandboxExecEnvironment, releaseSharedClientLeaseAndRetireOneShotClient, releaseCurrentRoute, runCleanupStep, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
-	const { context, turnState, buildRenderedCodexDeveloperInstructions, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
+	const { context, turnState, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
 	const { runtime, attemptTools, promptState } = context;
 	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
 	const { toolBridge, toolState } = attemptTools;
@@ -6634,7 +6838,7 @@ async function startCodexAttemptRuntime(resources) {
 				clientId: state.client.getInstanceId()
 			}
 		});
-		if (applyNoContextEngineContinuityProjection(state.thread.lifecycle.action, state.thread)) await rebuildCodexTurnPromptTextFromCurrentProjection();
+		if (await applyNoContextEngineContinuityProjection(state.thread.lifecycle.action, state.thread)) await rebuildCodexTurnPromptTextFromCurrentProjection();
 		trajectoryRecorder?.recordEvent("session.started", {
 			sessionFile: params.sessionFile,
 			threadId: state.thread.threadId,
@@ -6642,13 +6846,6 @@ async function startCodexAttemptRuntime(resources) {
 			workspaceDir: effectiveWorkspace,
 			toolCount: flattenCodexDynamicToolFunctions(toolBridge.specs).length
 		});
-		recordCodexTrajectoryContext(trajectoryRecorder, {
-			attempt: params,
-			cwd: effectiveCwd,
-			developerInstructions: joinPresentSections(buildRenderedCodexDeveloperInstructions(), attemptTools.configuredMcp?.diagnosticNotice),
-			prompt: turnState.codexTurnPromptText,
-			tools: toolBridge.availableSpecs
-		});
 		connection.mutable.pluginAppServer = pluginAppServer;
 	} catch (error) {
 		await runCleanupStep("codex-start-failure-hook-fallback", activateNativePreToolUseFailureFallback);
@@ -6758,8 +6955,9 @@ async function prepareCodexAttemptTools(runtime) {
 		pluginConfig,
 		profilerEnabled,
 		...params.cronCreatorAuthorityUnavailableReason === "queued-local-operator" && bundleMcpThreadConfig.staticServerNames.length > 0 ? { cronCreatorAuthorityUnavailableReason: "queued-local-operator-configured-mcp" } : {},
-		onYieldDetected: (acknowledgment) => {
+		onYieldDetected: (message, acknowledgment) => {
 			toolState.yieldDetected = true;
+			toolState.yieldMessage = message;
 			toolState.yieldAcknowledgment = acknowledgment;
 		},
 		claimYieldCompletion: () => runtimeYieldCompletionClaim.current?.() ?? false,
@@ -6806,9 +7004,13 @@ async function prepareCodexAttemptTools(runtime) {
 			releaseLeasedSharedCodexAppServerClient(client);
 		}
 	}
+	let requireExplicitMessageTarget;
 	const tools = await buildDynamicTools({
 		...commonToolParams,
 		registerRunCleanup: (cleanup) => runCleanups.push(cleanup),
+		onMessageToolTargetResolved: (required) => {
+			requireExplicitMessageTarget = required;
+		},
 		cronCreatorToolAllowlistRef: cronCreatorToolAllowlist,
 		cronCreatorToolAllowlistCaptureRef,
 		onPersistentWebSearchPolicyResolved: (allowed) => {
@@ -6831,7 +7033,7 @@ async function prepareCodexAttemptTools(runtime) {
 		sessionId: params.sessionId,
 		runId: params.runId,
 		agentId: policyAgentId,
-		agentDir: agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId),
+		agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
 		agentAccountId: params.agentAccountId,
 		messageProvider: params.messageProvider ?? params.messageChannel,
 		messageChannel: params.messageChannel,
@@ -6981,7 +7183,7 @@ async function prepareCodexAttemptTools(runtime) {
 			signal: runAbortController.signal,
 			computerContextEpoch,
 			loading: resolveCodexDynamicToolsLoadingForRuntime(pluginConfig, effectiveRuntimeModelId, { connectionClass: connection.appServer.connectionClass }),
-			directToolNames: resolveCodexDynamicToolDirectNames(params, isHostScopedAgentToolActive("openclaw")),
+			directToolNames: resolveCodexDynamicToolDirectNames(params, registeredWithScopedMcp, isHostScopedAgentToolActive("openclaw")),
 			hookContext
 		});
 		const captureCronCreatorToolAllowlist = async () => {
@@ -7046,6 +7248,7 @@ async function prepareCodexAttemptTools(runtime) {
 		return {
 			tools: toolsWithScopedMcp,
 			registeredTools: registeredWithScopedMcp,
+			requireExplicitMessageTarget,
 			scopedMcpTools,
 			configuredMcp,
 			disposeMcpTools,
@@ -7148,12 +7351,23 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		error.name = "AbortError";
 		throw error;
 	};
+	const prepareWorkspaceReferences = () => {
+		const references = prepareCodexWorkspaceReferences(resourceState.client, resourceState.thread.threadId, workspaceBootstrapContext.promptContext);
+		prompt.refreshWorkspaceReferences(references.include);
+		return references;
+	};
 	const startCodexTurn = async () => {
 		const activeTurnRoute = await ensureCurrentThreadRoute();
 		assertCodexSessionRuntimeOwnership(resourceState.thread, params.expectedSessionRuntimeOwnership);
 		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, runtimeParams);
 		connection.mutable.pluginAppServer = turnAppServer;
-		const turnStartParams = buildTurnStartParams(runtimeParams, {
+		const references = prepareWorkspaceReferences();
+		const referencesRetained = turnState.codexTurnPromptText.includes(workspaceBootstrapContext.promptContext ?? "");
+		const inferenceRoute = usesSupervisionConnection ? void 0 : getCodexInferenceThread(resourceState.client, resourceState.thread.threadId);
+		const turnStartParams = buildTurnStartParams({
+			...runtimeParams,
+			images: [...prompt.contextImages, ...runtimeParams.images ?? []]
+		}, {
 			threadId: resourceState.thread.threadId,
 			cwd: resourceState.codexExecutionCwd,
 			appServer: turnAppServer,
@@ -7170,9 +7384,57 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			skillsCollaborationInstructions: context.skillsCollaborationInstructions,
 			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
 			preserveNativeTurnSettings: usesSupervisionConnection,
+			parentLocalEgress: inferenceRoute !== void 0,
+			messageToolAvailable: toolBridge.availableTools.some((tool) => tool.name === "message"),
+			requireExplicitMessageTarget: attemptTools.requireExplicitMessageTarget,
 			sessionStatusAvailable: toolBridge.availableTools.some((tool) => tool.name === "session_status")
 		});
+		if (inferenceRoute) {
+			prompt.setParentLocalEgress();
+			resourceState.releaseInferenceContext?.();
+			const inferenceThread = resourceState.thread;
+			const registration = inferenceRoute.context.register({
+				threadId: resourceState.thread.threadId,
+				text: buildCodexParentLocalInstructions(runtimeParams, {
+					turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
+					skillsCollaborationInstructions: context.skillsCollaborationInstructions,
+					memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
+				}) ?? "",
+				signal: runAbortController.signal,
+				assertCurrent: () => {
+					params.hostCapabilities.assertActive();
+					connection.assertCurrent();
+					if (resourceState.thread !== inferenceThread || getCodexInferenceThread(resourceState.client, inferenceThread.threadId) !== inferenceRoute) throw new Error("Codex inference thread ownership changed");
+					inferenceThread.liveThreadOwnership?.assertCurrent();
+				}
+			});
+			resourceState.releaseInferenceContext = registration.release;
+			turnStartParams.responsesapiClientMetadata = {
+				...turnStartParams.responsesapiClientMetadata,
+				[CODEX_INFERENCE_GENERATION_KEY]: registration.generation
+			};
+		} else if (!usesSupervisionConnection) {
+			embeddedAgentLog.warn("Codex parent-local egress workaround is unavailable for this connection or native network profile; legacy collaboration delivery is not guaranteed.");
+			prompt.systemPromptReport.source = "estimate";
+			prompt.systemPromptReport.injectedWorkspaceFiles = prompt.systemPromptReport.injectedWorkspaceFiles.map((file) => [
+				"SOUL.MD",
+				"IDENTITY.MD",
+				"USER.MD"
+			].includes(file.name.toUpperCase()) ? {
+				...file,
+				injectionStatus: "native_unverified",
+				injectedChars: null,
+				truncated: null
+			} : file);
+		}
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
+		recordCodexTrajectoryContext(resources.trajectoryRecorder, {
+			attempt: params,
+			cwd: connection.effectiveCwd,
+			developerInstructions: joinPresentSections(buildRenderedCodexDeveloperInstructions(), attemptTools.configuredMcp?.diagnosticNotice),
+			prompt: turnState.codexTurnPromptText,
+			tools: toolBridge.availableSpecs
+		});
 		state.latestStartupErrorNotification = void 0;
 		state.rateLimitsRevisionBeforeLastTurnStart = readCodexRateLimitsRevision(resourceState.client);
 		activeTurnRoute.armTurn();
@@ -7196,6 +7458,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			}));
 			acceptedTurnId = startedTurn.turn.id;
 			connection.assertCurrent();
+			if (referencesRetained) references.accepted();
 			throwIfTurnStartAcceptedAfterAbort();
 			return startedTurn;
 		} catch (error) {
@@ -7224,6 +7487,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		if (await waitForActiveNativeTurnCompletion()) await resourceState.turnRoute?.drain();
 		else if (!runAbortController.signal.aborted) embeddedAgentLog.warn("codex app-server active native turn did not complete before turn/start wait timed out", { threadId: resourceState.thread.threadId });
 	}
+	prepareWorkspaceReferences();
 	const buildLlmInputEvent = () => ({
 		runId: params.runId,
 		sessionId: params.sessionId,
@@ -7232,7 +7496,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		systemPrompt: buildRenderedCodexDeveloperInstructions(),
 		prompt: turnState.codexTurnPromptText,
 		historyMessages: prompt.codexModelInputHistoryMessages,
-		imagesCount: params.images?.length ?? 0,
+		imagesCount: prompt.contextImages.length + (params.images?.length ?? 0),
 		tools
 	});
 	return {
@@ -7541,6 +7805,8 @@ function createCodexAttemptTurnState(resources) {
 		terminalTurnNotificationQueued: false,
 		sawCodexInterruptMarker: false,
 		timeout: void 0,
+		settlementWarning: void 0,
+		pendingSettlementStage: void 0,
 		clientClosedPromptError: void 0,
 		clientClosedDiagnostic: void 0,
 		clientClosedAbort: false,
@@ -7556,6 +7822,7 @@ function createCodexAttemptTurnState(resources) {
 		currentTurnHadNonTerminalDynamicToolResult: false
 	};
 	const { promise: completion, resolve: resolveCompletion } = createDeferred();
+	const settlementExpired = createDeferred();
 	const pendingOpenClawDynamicToolCompletionIds = /* @__PURE__ */ new Set();
 	const openClawDynamicToolExecutions = createCodexDynamicToolExecutionRegistry();
 	const activeTurnItemIds = /* @__PURE__ */ new Set();
@@ -7616,13 +7883,32 @@ function createCodexAttemptTurnState(resources) {
 		signal: runAbortController.signal,
 		onDeadlineChanged: params.onAttemptDeadlineChanged,
 		onTimeout: (timeout) => {
+			const pendingStage = state.pendingSettlementStage ?? projectorRef.current?.settlement.pendingStage ?? "notification_queue";
+			if (timeout.kind === "settlement" && projectorRef.current?.recoverCompletedAnswer()) {
+				state.settlementWarning = {
+					pendingStage,
+					elapsedMs: timeout.elapsedMs,
+					timeoutMs: timeout.timeoutMs
+				};
+				state.projectionClosed = true;
+				trajectoryRecorder?.recordEvent("turn.settlement_warning", {
+					threadId: resourceState.thread.threadId,
+					turnId: turnIdRef.current,
+					...state.settlementWarning
+				});
+				embeddedAgentLog.warn("codex app-server retaining completed answer after settlement expiry", state.settlementWarning);
+				completeTurn();
+				settlementExpired.resolve();
+				return;
+			}
 			state.timeout = timeout;
 			projectorRef.current?.markTimedOut();
 			const error = /* @__PURE__ */ new Error(timeout.kind === "execution" ? "codex app-server execution budget timed out" : "codex app-server terminal settlement timed out");
 			const fields = {
 				threadId: resourceState.thread.threadId,
 				turnId: turnIdRef.current,
-				...timeout
+				...timeout,
+				pendingStage
 			};
 			trajectoryRecorder?.recordEvent(`turn.${timeout.kind}_timeout`, fields);
 			embeddedAgentLog.warn(error.message, fields);
@@ -7633,6 +7919,7 @@ function createCodexAttemptTurnState(resources) {
 	return {
 		state,
 		completion,
+		settlementExpired: settlementExpired.promise,
 		pendingOpenClawDynamicToolCompletionIds,
 		openClawDynamicToolExecutions,
 		activeTurnItemIds,