@openclaw/codex 2026.9.6 → 2026.9.7

package/dist/.setup/{run-attempt-BHu11r7h.mjs → run-attempt-D8RZUOzY.mjs}

@@ -1,83 +1,95 @@
-import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-BoRei8Z4.mjs";
-import { i as matchesCodexNativeSubagentSubmissionBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, x as createCodexNativeSubagentHistoryOwner } from "./session-binding-record-BGoz8wOK.mjs";
-import { n as defineCodexBuildState } from "./build-state-C7EnDVgr.mjs";
-import { d as resolveCodexAppServerHomeDir, l as shouldAutoApproveCodexAppServerApprovals, n as hasCodexMcpToolApprovalOverrides, u as withMcpElicitationsApprovalPolicy, y as readCodexRequirementsToml } from "./config-security-BEReZ6go.mjs";
-import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-CcB9iPoq.mjs";
+import { n as readCodexRuntimeModelId } from "./model-runtime-BdqzOMkU.mjs";
+import { c as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-Cky2XJUw.mjs";
+import { g as createCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-DwkCzLvD.mjs";
 import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
-import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-BvaRs51b.mjs";
-import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-B2mpaI9D.mjs";
-import { h as retireSharedCodexAppServerClientIfCurrent } from "./session-catalog-events-Bj6j94E_.mjs";
-import { t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.mjs";
-import { o as formatCodexDisplayText } from "./command-formatters-Bmqvr9tO.mjs";
-import { n as waitForPromiseOrAbort, o as CodexAppServerRpcError, r as withAbortableTimeout } from "./timeout-C910MdAB.mjs";
+import { i as matchesCodexNativeSubagentSubmissionBinding, n as assertCodexBindingMayBeReplaced, v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
+import { n as defineCodexBuildState } from "./build-state-Da1_z0kd.mjs";
+import { c as shouldAutoApproveCodexAppServerApprovals, l as withMcpElicitationsApprovalPolicy, m as readCodexRequirementsToml, n as hasCodexMcpToolApprovalOverrides } from "./config-security-CE-FcGw9.mjs";
+import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-b088LyhT.mjs";
+import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
+import { t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-CzyWLTJt.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-Dbvq-QgB.mjs";
+import { d as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-lifecycle-DJIgqgMw.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-R3ckE3Co.mjs";
+import { t as isIncognitoSessionKey } from "./incognito-session-DWYapfwf.mjs";
+import { n as CodexAppServerRpcError } from "./rpc-error-BlD2vuzn.mjs";
+import { n as waitForPromiseOrAbort, r as withAbortableTimeout } from "./timeout-CXOfNoaX.mjs";
 import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.mjs";
-import { C as readItemString, D as readNullableString, E as readNonNegativeInteger, O as splitPlanText, S as readItem, _ as extractRawAssistantText, b as readCodexProviderRefusal, d as matchesCodexSnapshotTurn, f as shouldClearTerminalPresentationForNativeItem, y as readCodexErrorNotificationMessage } from "./event-projector-items-C6L_5ZiT.mjs";
-import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
-import { a as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-B2CsSdnV.mjs";
-import { i as resolveCodexBindingAppServerConnection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-ThoatDcb.mjs";
-import { n as resolveOpenClawExecPolicyForCodexAppServer, t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-BoTP_mrL.mjs";
-import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-CzM-94NC.mjs";
-import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BrqhSCf9.mjs";
-import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-WqZtZfXN.mjs";
-import { A as getCodexInferenceThread, B as prepareCodexWorkspaceReferences, K as readCodexRateLimitsRevision, P as ensureCodexAppServerClientRuntime, V as protectCodexAppServerLiveThread, X as resolveCodexAppServerAuthAccountCacheKey, Z as resolveCodexAppServerPreparedAuthHandoff, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, at as resolveCodexStartupTimeoutMs, c as getLeasedSharedCodexAppServerClient, et as CodexAppServerStartupError, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, i as clearSharedCodexAppServerClientIfCurrent, l as getSharedCodexAppServerClient, nt as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, ot as withCodexStartupTimeout, q as readRecentCodexRateLimits, s as createIsolatedCodexAppServerClient, tt as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, u as isCodexAppServerStartSelectionChangedError, v as retainSharedCodexAppServerClientIfCurrent, w as CodexThreadClientReplacementError } from "./shared-client-DA4VR4Eb.mjs";
-import { A as isMatchingDynamicToolTerminalDiagnostic, B as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS, C as readCodexDynamicToolCallParams, 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 assertCodexTurnStartResponse, T as readCodexTurnCompletedNotification, c as isCodexAppServerIndeterminateTransportError, i as isCodexAppServerApprovalRequest, j as resolveDynamicToolCallTimeoutMs, k as isDynamicToolTerminalDiagnosticEvent, m as CodexServerRequestResolvedError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-Cs08OXVQ.mjs";
-import { _ as CodexProjectionDiagnostics, d as shouldRetireCodexStartupClient, f as terminateCodexBackgroundTerminals, h as getCodexAppServerTurnRouter, m as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as retireUnsafeCodexTurnClientBestEffort, v as isCodexNotificationForTurn, y as readCodexNotificationThreadId } from "./attempt-client-cleanup-CEv1cKwF.mjs";
-import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-DhLWa_7K.mjs";
-import { a as isPendingOpenClawDynamicToolCompletionNotification, c as readCodexNotificationItem, d as updateActiveTurnItemIds, i as isCodexTurnAbortMarkerNotification, l as readNotificationItemId, o as isRawFunctionToolOutputCompletionNotification, r as codexExecutionToolName, s as isTerminalTurnStatus, t as CodexUsageProjection, u as readRawResponseToolCallId } from "./event-projector-usage-CnBS8Wa3.mjs";
-import { A as emitCodexNativePreToolUseFailureDiagnostic, C as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, Ct as shouldBuildCodexPluginThreadConfig, D as buildCodexNativeHookRelayDisabledConfig, E as buildCodexNativeHookRelayConfig, K as codexDynamicToolsFingerprint, M as resolveCodexNativeHookRelayTtlMs, N as scheduleCodexNativeHookRelayUnregister, R as hasCodexNativeToolCatalog, T as assertCodexNativeHookRelayAllowed, U as areCodexDynamicToolFingerprintsCompatible, X as fingerprintJsonObject, at as filterCodexDynamicTools, ft as resolveCodexDynamicToolsLoadingForRuntime, gt as buildCodexPluginThreadConfigTimeoutFallback, ht as buildCodexPluginThreadConfigInputFingerprint, j as resolveCodexNativeHookRelayEvents, k as createCodexNativeHookRelay, lt as isSystemAgentOnlyCodexDynamicToolAllowlist, m as buildDeveloperInstructions, mt as buildCodexPluginThreadConfig, p as resolveCodexWebSearchPlan, q as codexLegacyDynamicToolsFingerprint, v as resolveCodexAppServerThreadModelSelection, w as CodexManagedHooksOnlyError, xt as mergeCodexThreadConfigs, z as loadCodexNativeToolCatalog } from "./thread-requests-BLvGkP2R.mjs";
-import { A as resolveCodexContinuityProjectionMaxChars, C as buildCodexContinuityCalibration, D as projectContextEngineAssemblyForCodex, E as neutralizeCodexExplicitMentionSigils, O as resolveCodexContextEngineProjectionMaxChars, S as CodexContextAttachmentError, T as isCodexDurableCustomMessage, _ as readCodexMcpToolUiVisibility, a as buildTurnStartParams, b as isContextEngineBindingCompatible, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, g as readCodexMcpToolConnectorId, h as resolveScheduledCodexAppCreatorCaptureDecision, i as buildTurnCollaborationMode, k as resolveCodexContextEngineProjectionReserveTokens, l as buildLegacyScheduledCodexAppRecoveryPrompt, m as readCurrentCodexScheduledAppPolicy$1, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, p as intersectCodexPluginThreadConfigWithScheduledAuthority, s as startOrResumeThread, t as buildCodexHistoryProvenancePrefix, u as buildScheduledCodexAppAuthorityInputFingerprint, v as isCodexAppServerProfilerEnabled, w as fitCodexProjectedContextForTurnStart, x as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS, y as buildContextEngineBinding } from "./thread-lifecycle-B3mfz1TG.mjs";
-import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding } from "./session-binding-Cm0apEbd.mjs";
-import { n as CodexThreadPolicyHandoffError } from "./thread-policy-DGuQsuFC.mjs";
-import { r as retainCodexAppServerBindingSubscription, s as withExclusiveCodexAppServerThread, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DcTtAcXj.mjs";
-import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BtHDBp1G.mjs";
-import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-DUMbefVY.mjs";
+import { a as readCodexProviderRefusal, d as splitPlanText, i as readCodexErrorNotificationMessage, l as readNonNegativeInteger, n as extractRawAssistantText, s as readItem, u as readNullableString } from "./event-projector-values-DJSz8BTk.mjs";
+import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-fXkKbPVC.mjs";
+import { a as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BL9B5H0L.mjs";
+import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-DTtN1KrX.mjs";
+import { r as requestCodexAppServerClientJson, t as CodexAppServerScopedRequestRejectedError } from "./request-BHZ1nz8d.mjs";
+import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-DKhXquav.mjs";
+import { a as isCodexDurableCustomMessage, c as resolveCodexContextEngineProjectionMaxChars, i as fitCodexProjectedContextForTurnStart, l as resolveCodexContinuityProjectionMaxChars, n as CodexContextAttachmentError, o as neutralizeCodexExplicitMentionSigils, r as buildCodexContinuityCalibration, s as projectContextEngineAssemblyForCodex, t as CODEX_TURN_START_TEXT_INPUT_MAX_CHARS } from "./context-engine-projection-PezSESth.mjs";
+import { o as hasCodexMirrorOrigin, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-YSegaktH.mjs";
+import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-D83lJWHG.mjs";
+import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-B0okYl2D.mjs";
+import { E as isCodexContextRestartSelectionChangedError, H as prepareCodexWorkspaceReferences, I as ensureCodexAppServerClientRuntime, M as getCodexInferenceThreadQualification, U as protectCodexAppServerLiveThread, X as readRecentCodexRateLimits, Y as readCodexRateLimitsRevision, _ as retainSharedCodexAppServerClientIfCurrent, a as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, c as getLeasedSharedCodexAppServerClient, dt as TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS, et as resolveCodexAppServerAuthAccountCacheKey, f as readCodexAppServerClientDesktopGenerationFingerprint, h as releaseLeasedSharedCodexAppServerClient, ht as withCodexStartupTimeout, i as clearSharedCodexAppServerClientIfCurrent, j as getCodexInferenceThread, l as getSharedCodexAppServerClient, lt as CodexAppServerStartupError, mt as resolveCodexStartupTimeoutMs, s as createIsolatedCodexAppServerClient, tt as resolveCodexAppServerPreparedAuthHandoff, u as isCodexAppServerStartSelectionChangedError, ut as TURN_FINALIZE_DRAIN_ABORT_GRACE_MS, w as CodexThreadClientReplacementError, x as CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED } from "./shared-client-DqyTMYug.mjs";
+import { a as isCodexResponsesOAuthRun, r as isCodexResponsesOAuth } from "./responses-oauth-twnuTaAa.mjs";
+import { A as handleDynamicToolCallWithTimeout, E as readCodexTurnCompletedNotification, F as resolveTerminalDynamicToolBatchAction, I as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, L as shouldReleaseTurnAfterTerminalDynamicTool, M as isDynamicToolTerminalDiagnosticEvent, N as isMatchingDynamicToolTerminalDiagnostic, P as resolveDynamicToolCallTimeoutMs, R as toCodexDynamicToolProgressResponse, S as assertCodexTurnStartResponse, U as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS, c as isCodexAppServerIndeterminateTransportError, i as isCodexAppServerApprovalRequest, j as hasPendingDynamicToolTerminalDiagnostic, k as createCodexElicitationResponse, m as CodexServerRequestResolvedError, o as isCodexAppServerConnectionClosedError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, s as isCodexAppServerIndeterminateRequestCancellationError, w as readCodexDynamicToolCallParams, z as toCodexDynamicToolProtocolResponse } from "./client-N0JpgSzF.mjs";
+import { n as isCodexWebSocketOpenFailure } from "./transport-websocket-BTBE-LD9.mjs";
+import { M as matchesCodexSnapshotTurn, N as shouldClearTerminalPresentationForNativeItem, _ as CodexProjectionDiagnostics, d as shouldRetireCodexStartupClient, f as terminateCodexBackgroundTerminals, h as getCodexAppServerTurnRouter, k as itemName, m as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as retireUnsafeCodexTurnClientBestEffort, v as isCodexNotificationForTurn, y as readCodexNotificationThreadId } from "./attempt-client-cleanup-DOP-cW5j.mjs";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BLWz7stm.mjs";
+import { a as isRawFunctionToolOutputCompletionNotification, c as readNotificationItemId, i as isPendingOpenClawDynamicToolCompletionNotification, l as readRawResponseToolCallId, o as isTerminalTurnStatus, r as isCodexTurnAbortMarkerNotification, s as readCodexNotificationItem, t as CodexUsageProjection, u as updateActiveTurnItemIds } from "./event-projector-usage-03R0I2dM.mjs";
+import { n as listAllCodexAppServerModels } from "./models-DHXZtVVk.mjs";
+import { A as createCodexNativeHookRelay, B as loadCodexNativeToolCatalog, D as buildCodexNativeHookRelayConfig, E as assertCodexNativeHookRelayAllowed, K as codexDynamicToolsFingerprint, M as resolveCodexNativeHookRelayEvents, N as resolveCodexNativeHookRelayTtlMs, O as buildCodexNativeHookRelayDisabledConfig, P as scheduleCodexNativeHookRelayUnregister, St as mergeCodexThreadConfigs, T as CodexManagedHooksOnlyError, W as areCodexDynamicToolFingerprintsCompatible, X as fingerprintJsonObject, _t as buildCodexPluginThreadConfigTimeoutFallback, gt as buildCodexPluginThreadConfigInputFingerprint, h as buildDeveloperInstructions, ht as buildCodexPluginThreadConfig, ot as filterCodexDynamicTools, p as resolveCodexWebSearchPlan, pt as resolveCodexDynamicToolsLoadingForRuntime, q as codexLegacyDynamicToolsFingerprint, tt as stabilizeJsonValue, ut as isSystemAgentOnlyCodexDynamicToolAllowlist, w as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, wt as shouldBuildCodexPluginThreadConfig, x as joinPresentSections, y as resolveCodexAppServerThreadModelSelection, z as hasCodexNativeToolCatalog } from "./thread-requests-B_bRnMGN.mjs";
+import { _ as readCodexMcpToolUiVisibility, a as buildTurnStartParams, b as isContextEngineBindingCompatible, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, g as readCodexMcpToolConnectorId, h as resolveScheduledCodexAppCreatorCaptureDecision, i as buildTurnCollaborationMode, l as buildLegacyScheduledCodexAppRecoveryPrompt, m as readCurrentCodexScheduledAppPolicy, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, p as intersectCodexPluginThreadConfigWithScheduledAuthority, s as startOrResumeThread, t as buildCodexHistoryProvenancePrefix, u as buildScheduledCodexAppAuthorityInputFingerprint, v as isCodexAppServerProfilerEnabled, y as buildContextEngineBinding } from "./thread-lifecycle-DPflntEJ.mjs";
+import { a as resolveCodexRunSessionBindingAuthority, n as createCodexSessionGenerationSupersededError, o as resolveCodexSessionBinding } from "./session-binding-DGCYAfvD.mjs";
+import { a as CodexToolTranscriptProjection, b as sanitizeCodexAgentEventRecord, c as shouldEmitTranscriptToolProgress, i as emitCodexAgentEvent, p as requestPluginApprovalOutcome, r as CodexEventProjection, s as CodexToolProgressProjection, t as codexNativeSubagentMonitorRuntime, v as isCodexCommandBearingToolCall, x as sanitizeCodexToolArguments, y as resolveCodexToolProgressDetailMode } from "./native-subagent-monitor-Dpsmf2wz.mjs";
+import { n as CodexThreadPolicyHandoffError, s as restoreCodexThreadSkillsCatalogAfterCompaction } from "./thread-policy-DTd-DtkX.mjs";
+import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-roNP0l1c.mjs";
+import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-kxmCYsuF.mjs";
+import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-QXerDo3i.mjs";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.mjs";
 import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
-import { a as shouldKeepCodexSharedAbortOpen, i as runCodexAgentEndHook, n as ensureCodexWorkspaceDirOnce, o as withCodexAppServerFastModeServiceTier, r as estimateCodexAppServerProjectedTurnTokens, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-B7JbY4-F.mjs";
-import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-context-D96l9-ew.mjs";
-import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BsruvNrH.mjs";
-import { C as sanitizeCodexToolArguments, S as resolveCodexToolProgressDetailMode, b as inferCodexDynamicToolMeta, w as sanitizeCodexToolResponse, x as isCodexCommandBearingToolCall } from "./native-subagent-task-ids-wb8CKZGN.mjs";
-import { C as shouldEnableCodexAppServerNativeToolSurface, E as mapCodexAppServerRemoteWorkspacePath, S as resolveCodexSandboxEnvironmentSelection, T as shouldWarnCodexDynamicToolBuildStageSummary, _ as formatCodexDynamicToolBuildStageSummary, a as emitDynamicToolStartedDiagnostic, b as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as ensureCodexSandboxExecServerEnvironment, d as hasCodexNativeBackgroundProcesses, f as readBoundedCodexRemoteWorkspaceFile, g as disableCodexPluginThreadConfig, h as createCodexDynamicToolBuildStageTracker, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as buildDynamicTools, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as CodexNativeToolLifecycleProjector, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as CodexNativeProcessAuthority, v as resolveCodexAppServerExecutionCwd, w as shouldRequireCodexSandboxExecServerEnvironment, x as resolveCodexMessageToolProvider, y as resolveCodexAppServerHookChannelId } from "./dynamic-tools-BDXl-8Cw.mjs";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-BfE88FZ5.mjs";
-import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-C0MZzCuP.mjs";
-import { a as CodexToolProgressProjection, i as CodexToolTranscriptProjection, n as CodexEventProjection, o as shouldEmitTranscriptToolProgress, r as emitCodexAgentEvent, t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-D3filLY2.mjs";
-import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BI1QK_98.mjs";
-import { a as getCodexContextFileDisplayBasename, c as normalizeCodexContextFilePath, d as shouldInjectCodexOpenClawPromptContext, i as getCodexContextFileBasename, l as normalizeCodexDynamicToolName, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as getCodexWorkspaceMemoryToolNames, r as buildCodexWorkspaceBootstrapContext, s as isNonEmptyString$1 } from "./attempt-workspace-context-DUVEn_CS.mjs";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-fmwouT5I.mjs";
-import { a as runCodexComputerUseLiveTest, n as ensureCodexComputerUse, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-Ctmo83k_.mjs";
+import { a as shouldKeepCodexSharedAbortOpen, i as runCodexAgentEndHook, n as ensureCodexWorkspaceDirOnce, o as withCodexAppServerFastModeServiceTier, r as estimateCodexAppServerProjectedTurnTokens, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-C-6O3Exn.mjs";
+import { t as CODEX_INFERENCE_GENERATION_KEY } from "./inference-metadata-CgIf7sOx.mjs";
+import "./inference-context-D-9gWlTR.mjs";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-CigreO4K.mjs";
+import { C as readCodexRetainedBackgroundCommands, E as CodexNativeToolLifecycleProjector, S as hasCodexNativeBackgroundProcesses, T as mapCodexAppServerRemoteWorkspacePath, _ as shouldWarnCodexDynamicToolBuildStageSummary, a as emitDynamicToolStartedDiagnostic, b as createCodexNativePreToolUseFailureBuffer, c as buildDynamicTools, d as resolveCodexAppServerHookChannelId, f as resolveCodexExternalSandboxPolicyForOpenClawSandbox, g as shouldRequireCodexSandboxExecServerEnvironment, h as shouldEnableCodexAppServerNativeToolSurface, i as emitDynamicToolErrorDiagnostic, l as disableCodexPluginThreadConfig, m as resolveCodexSandboxEnvironmentSelection, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as resolveCodexMessageToolProvider, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as resolveCodexAppServerExecutionCwd, v as ensureCodexSandboxExecServerEnvironment, w as readBoundedCodexRemoteWorkspaceFile, x as CodexNativeProcessAuthority, y as releaseCodexSandboxExecServerEnvironment } from "./dynamic-tools-DzlsLUuS.mjs";
+import { a as resolveCodexAppServerForModelProvider, i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-Ci_fVX6y.mjs";
+import { a as getCodexContextFileDisplayBasename, c as normalizeCodexDynamicToolName, i as getCodexContextFileBasename, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as isNonEmptyString, r as buildCodexWorkspaceBootstrapContext, s as normalizeCodexContextFilePath } from "./attempt-workspace-context-C5HigshI.mjs";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-D4yj4rxf.mjs";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-CAxoF-X1.mjs";
+import { a as createComputerUseRequest, n as ensureCodexComputerUse, o as runCodexComputerUseLiveTest, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DsjsL1dr.mjs";
 import { asOptionalRecord, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { resolveAgentConfig, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { isPathStrictlyInside, readFileWindowFully, root } from "openclaw/plugin-sdk/file-access-runtime";
 import { addAbortListener } from "node:events";
+import { Type } from "typebox";
 import { truncateUtf16Safe, truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { createStageTimingTracker, formatStageTimings } from "openclaw/plugin-sdk/time-runtime";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, agentHarnessStructuredInput, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, HEARTBEAT_RESPONSE_TOOL_NAME, agentHarnessStructuredInput, applyEmbeddedAttemptToolsAllow, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, buildWatchedSessionsHarnessContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, normalizeHeartbeatToolResponse, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$2, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
+import { AgentHarnessProjectionSettlement, createAgentHarnessAttemptCancellation, createAgentHarnessAttemptDeadlineController, createAgentHarnessAttemptLifecycle, shouldIncludeAgentHarnessRuntimeContext } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
 import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
-import { acknowledgeInternalToolResult } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+import { acknowledgeInternalToolResult, createAgentHarnessToolExecutionRegistry } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { appendSessionYieldContext, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
-import { prepareAgentWorkspaceAttachments } from "openclaw/plugin-sdk/agent-workspace-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";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
 import { normalizeMediaReferenceForComparison, saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { stripInvisibleUnicode } from "openclaw/plugin-sdk/web-content-extractor";
+import { prepareAgentWorkspaceAttachments } from "openclaw/plugin-sdk/agent-workspace-runtime";
 import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
-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) {
-	const tracker = createCodexDynamicToolBuildStageTracker();
+	const tracker = createStageTimingTracker();
 	const profilerEnabled = isCodexAppServerProfilerEnabled(params.config);
 	const totalWarnMs = profilerEnabled ? 1e3 : 1e4;
 	const stageWarnMs = profilerEnabled ? 500 : 5e3;
@@ -87,7 +99,7 @@ function createCodexAttemptPreparationTiming(params) {
 		const slowTotal = outcome !== "completed" && summary.totalMs >= totalWarnMs;
 		const slowStage = outcome !== "ready" && (lastStage?.durationMs ?? 0) >= stageWarnMs;
 		if (!slowTotal && !slowStage) return;
-		embeddedAgentLog.warn(`codex app-server preparation timings runId=${params.runId} sessionId=${params.sessionId} stage=${stage} outcome=${outcome} totalMs=${summary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(summary)}`, {
+		embeddedAgentLog.warn(`codex app-server preparation timings runId=${params.runId} sessionId=${params.sessionId} stage=${stage} outcome=${outcome} totalMs=${summary.totalMs} stages=${formatStageTimings(summary.stages)}`, {
 			runId: params.runId,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -116,10 +128,6 @@ function createCodexAttemptPreparationTiming(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-steering.ts
-/**
-* Debounced steering queue for forwarding user messages to an active Codex
-* app-server turn.
-*/
 const CODEX_STEER_ALL_DEBOUNCE_MS = 500;
 var CodexSteeringAcceptedUnconfirmedError = class extends Error {
 	constructor(message, options) {
@@ -182,7 +190,7 @@ function createCodexSteeringQueue(params) {
 		params.signal.removeEventListener("abort", abortQueue);
 		clearBatchTimer();
 		batchedMessages = [];
-		for (const batch of dispatchedBatches.values()) for (const item of batch.items) acceptItem(item);
+		for (const batch of dispatchedBatches.values()) for (const item of batch) acceptItem(item);
 		dispatchedBatches.clear();
 		for (const item of pendingMessages) rejectItem(item, error);
 	};
@@ -191,7 +199,7 @@ function createCodexSteeringQueue(params) {
 		sealedError = /* @__PURE__ */ new Error("codex app-server steering queue admission sealed");
 		clearBatchTimer();
 		batchedMessages = [];
-		const dispatchedItems = new Set([...dispatchedBatches.values()].flatMap((batch) => batch.items));
+		const dispatchedItems = new Set([...dispatchedBatches.values()].flat());
 		for (const item of pendingMessages) if (!dispatchedItems.has(item)) rejectItem(item, sealedError);
 	};
 	const abortQueue = () => {
@@ -241,7 +249,7 @@ function createCodexSteeringQueue(params) {
 				if (liveItems.length === 0) return;
 			}
 			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-			dispatchedBatches.set(clientUserMessageId, { items: liveItems });
+			dispatchedBatches.set(clientUserMessageId, liveItems);
 			const request = {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
@@ -255,7 +263,7 @@ function createCodexSteeringQueue(params) {
 					assertActive();
 					liveItems = liveItems.filter(isCurrent);
 					request.input = liveItems.flatMap((item) => item.prepared.input);
-					dispatchedBatches.set(request.clientUserMessageId, { items: liveItems });
+					dispatchedBatches.set(request.clientUserMessageId, liveItems);
 					if (liveItems.length === 0) {
 						skippedRevokedBatch = true;
 						throw new Error("Codex steering batch has no authorized inputs");
@@ -290,19 +298,14 @@ function createCodexSteeringQueue(params) {
 		return send;
 	};
 	const createPendingMessage = (text, options, assertCurrent = () => {}) => {
-		let resolveDelivery;
-		let rejectDelivery;
-		const delivery = new Promise((resolve, reject) => {
-			resolveDelivery = resolve;
-			rejectDelivery = reject;
-		});
+		const { promise: delivery, resolve, reject } = createDeferred();
 		const item = {
 			...options,
 			assertCurrent,
 			acceptance: "open",
 			text,
-			resolve: resolveDelivery,
-			reject: rejectDelivery,
+			resolve,
+			reject,
 			settled: false
 		};
 		pendingMessages.add(item);
@@ -337,7 +340,7 @@ function createCodexSteeringQueue(params) {
 			const batch = dispatchedBatches.get(clientUserMessageId);
 			if (!batch) return false;
 			dispatchedBatches.delete(clientUserMessageId);
-			for (const item of batch.items) resolveItem(item);
+			for (const item of batch) resolveItem(item);
 			return true;
 		},
 		getAcceptedMessages: () => acceptedMessages.slice(),
@@ -573,11 +576,15 @@ var CodexAssistantProjection = class {
 			this.supersedeVisibleAnswerCandidate();
 			return;
 		}
+		for (const itemId of this.assistantItemOrder) if (!this.completedAssistantItemIds.has(itemId) && !this.isAsyncAssistantItem(itemId) && (this.isFinalAnswerAssistantItem(itemId) || this.isCommentaryAssistantItem(itemId))) {
+			if (itemId === this.visibleAnswerCandidateItemId) this.supersedeVisibleAnswerCandidate();
+			this.assistantTextByItem.delete(itemId);
+		}
 		const turnItems = turn.items ?? [];
 		const authoritativeIndex = turnItems.findLastIndex((item) => {
 			if (item.type !== "agentMessage" || typeof item.text !== "string" || item.text.trim().length === 0) return false;
-			const phase = readItemString(item, "phase");
-			return readItemString(item, "delivery") !== "async" && (phase === "final_answer" || phase === void 0);
+			const phase = readStringField(item, "phase");
+			return readStringField(item, "delivery") !== "async" && (phase === "final_answer" || phase === void 0);
 		});
 		const authoritative = authoritativeIndex >= 0 ? turnItems[authoritativeIndex] : void 0;
 		if (turnItems.slice(authoritativeIndex + 1).some(shouldClearTerminalPresentationForNativeItem) || authoritative?.id === this.latestTerminalAssistantCandidateItemId && this.latestTerminalAssistantCandidateSuperseded) {
@@ -620,9 +627,9 @@ var CodexAssistantProjection = class {
 	}
 	rememberAssistantPhase(item) {
 		if (item?.type !== "agentMessage") return;
-		const phase = readItemString(item, "phase");
+		const phase = readStringField(item, "phase");
 		if (phase) this.assistantPhaseByItem.set(item.id, phase);
-		const delivery = readItemString(item, "delivery");
+		const delivery = readStringField(item, "delivery");
 		if (delivery) this.assistantDeliveryByItem.set(item.id, delivery);
 		if (item.questions !== void 0) {
 			const questions = readCodexAsyncQuestions(item.questions);
@@ -831,17 +838,17 @@ var CodexGeneratedMediaProjection = class {
 	async recordNative(item) {
 		if (item?.type !== "imageGeneration") return;
 		this.itemIds.add(item.id);
-		const savedPath = readItemString(item, "savedPath")?.trim();
+		const savedPath = readStringField(item, "savedPath")?.trim();
 		if (savedPath) this.mediaByItemId.set(item.id, {
 			...this.mediaByItemId.get(item.id),
 			savedPath
 		});
-		const result = readItemString(item, "result");
+		const result = readStringField(item, "result");
 		if (result) {
 			await this.recordImage({
 				itemId: item.id,
 				result,
-				revisedPrompt: readItemString(item, "revisedPrompt"),
+				revisedPrompt: readStringField(item, "revisedPrompt"),
 				source: "native"
 			});
 			return;
@@ -866,7 +873,7 @@ var CodexGeneratedMediaProjection = class {
 					await this.recordImage({
 						itemId: item.id,
 						result: response.dataBase64,
-						revisedPrompt: readItemString(item, "revisedPrompt"),
+						revisedPrompt: readStringField(item, "revisedPrompt"),
 						source: "native"
 					});
 				} catch (error) {
@@ -1062,13 +1069,12 @@ var CodexReasoningProjection = class {
 	async handleTurnPlanUpdated(params, source = "codex-app-server") {
 		const explanation = readNullableString(params, "explanation");
 		const plan = Array.isArray(params.plan) ? params.plan.flatMap((entry) => {
-			if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
-			const record = entry;
-			const step = readStringField(record, "step");
+			if (!isJsonObject(entry)) return [];
+			const step = readStringField(entry, "step");
 			if (!step) return [];
 			return [{
 				step,
-				status: normalizePlanStepStatus(readStringField(record, "status"))
+				status: normalizePlanStepStatus(readStringField(entry, "status"))
 			}];
 		}) : void 0;
 		const planText = [explanation, ...(plan ?? []).map(({ step, status }) => `- [${status}] ${step}`)].filter((part) => Boolean(part)).join("\n");
@@ -1150,38 +1156,10 @@ function readReasoningSections(value) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-settlement.ts
-var CodexProjectionSettlement = class {
+var CodexProjectionSettlement = class extends AgentHarnessProjectionSettlement {
 	constructor(params, isActive) {
+		super(params, isActive, { label: "codex app-server" });
 		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;
@@ -1191,18 +1169,6 @@ var CodexProjectionSettlement = class {
 			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
@@ -1361,6 +1327,7 @@ var CodexTurnProjection = class {
 		this.threadId = threadId;
 		this.turnId = turnId;
 		this.options = options;
+		this.observedItemIds = /* @__PURE__ */ new Set();
 		this.activeItemIds = /* @__PURE__ */ new Set();
 		this.completedItemIds = /* @__PURE__ */ new Set();
 		this.activeCompactionItemIds = /* @__PURE__ */ new Set();
@@ -1404,11 +1371,17 @@ var CodexTurnProjection = class {
 		const { promptError: initialPromptError, promptErrorSource: initialPromptErrorSource, providerRefusal } = this.terminalFailure;
 		const upstreamUserText = this.options.upstreamUserText;
 		const turnTainted = this.settlement.turnTainted;
+		const observedItemCount = (/* @__PURE__ */ new Set([...this.observedItemIds, ...this.completedItemIds])).size;
 		const activeItemCount = this.activeItemIds.size;
 		const completedItemCount = this.completedItemIds.size;
 		const guardianReviewCount = this.eventProjection.guardianReviewCount;
 		const yieldDetected = options?.yieldDetected;
-		this.nativeToolLifecycleProjector.finalizeActive();
+		const retainedCommands = /* @__PURE__ */ new Map();
+		if (!aborted && !this.options.runAbortSignal?.aborted && completedTurn?.status === "completed" && !initialPromptError) {
+			const pending = this.nativeToolLifecycleProjector.pendingCommands();
+			for (const [id, processId] of options?.readRetainedNativeCommands?.() ?? []) if (pending.has(id) && (pending.get(id) === null || pending.get(id) === processId)) retainedCommands.set(id, processId);
+		}
+		this.nativeToolLifecycleProjector.finalizeActive(void 0, retainedCommands);
 		const assistantTexts = this.assistantProjection.collectAssistantTexts();
 		const asyncMessages = this.assistantProjection.collectAsyncMessages();
 		const commentaryMessages = this.assistantProjection.collectCommentaryMessages();
@@ -1424,6 +1397,7 @@ var CodexTurnProjection = class {
 		const hasDeliverableAssistantOnCompletedTurn = completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
 		const synthesizedMissingToolResultError = this.toolTranscriptProjection.synthesizeMissingToolResults({
 			synthesize: legacyFailClosed,
+			retainedCommands,
 			terminalDisposition: aborted ? "tool_error" : hasDeliverableAssistantOnCompletedTurn ? "diagnostic_only" : "prompt_error"
 		});
 		const storedMissingToolResultError = synthesizedMissingToolResultError ?? previousMissingToolResultError;
@@ -1504,7 +1478,7 @@ var CodexTurnProjection = class {
 				replaySafe: !hadPotentialSideEffects
 			},
 			itemLifecycle: {
-				startedCount: activeItemCount + completedItemCount,
+				startedCount: observedItemCount,
 				completedCount: completedItemCount,
 				activeCount: activeItemCount
 			},
@@ -1523,13 +1497,21 @@ var CodexTurnProjection = class {
 //#region extensions/codex/src/app-server/event-projector.ts
 const optedOutNotificationMethods = new Set(CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS);
 var CodexAppServerEventProjector = class extends CodexTurnProjection {
+	constructor(..._args) {
+		super(..._args);
+		this.compactionProgress = /* @__PURE__ */ new Map();
+	}
 	getCompletedTurnStatus() {
 		return this.completedTurn?.status;
 	}
+	getPendingNativeCommands() {
+		return !this.projectionClosed && !this.aborted && !this.options.runAbortSignal?.aborted && this.completedTurn?.status === "completed" && !this.terminalFailure.promptError ? this.nativeToolLifecycleProjector.pendingCommands() : /* @__PURE__ */ new Map();
+	}
 	/** 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.closeCompactionProgress();
 		this.projectionController.abort();
 		this.transcriptCheckpoint.abandon();
 		this.completedTurn = completed.turn;
@@ -1565,6 +1547,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	}
 	/** Fence delayed projections before the turn's final snapshot leaves its owner. */
 	closeProjection() {
+		this.closeCompactionProgress();
 		this.projectionController.abort();
 		return this.settlement.project("transcript/checkpoint", () => this.transcriptCheckpoint.flush(true));
 	}
@@ -1747,6 +1730,16 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	isCompacting() {
 		return this.activeCompactionItemIds.size > 0;
 	}
+	finishCompactionProgress(itemId, completed) {
+		if (this.compactionProgress.get(itemId) === "closed") return;
+		this.compactionProgress.set(itemId, "closed");
+		this.eventProjection.emitCompactionEnd(itemId, completed);
+	}
+	closeCompactionProgress() {
+		for (const itemId of this.activeCompactionItemIds) this.activeItemIds.delete(itemId);
+		this.activeCompactionItemIds.clear();
+		for (const [itemId, progress] of this.compactionProgress) if (progress === "open") this.finishCompactionProgress(itemId, this.completedItemIds.has(itemId));
+	}
 	isCompactionProjectionActive() {
 		return !this.projectionClosed && !this.aborted && !this.options.runAbortSignal?.aborted;
 	}
@@ -1754,20 +1747,26 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		const item = readItem(params.item);
 		if (item?.type === "agentMessage" && item.text) this.eventProjection.markSafetyBufferingAssistantStarted();
 		const itemId = item?.id ?? readStringField(params, "itemId");
+		if (itemId) this.observedItemIds.add(itemId);
+		if (item?.type === "contextCompaction" && itemId) {
+			if (this.completedTurn || this.activeCompactionItemIds.has(itemId) || this.completedItemIds.has(itemId) || this.compactionProgress.has(itemId)) return;
+			this.activeCompactionItemIds.add(itemId);
+		}
 		await this.assistantProjection.recordItemStarted(item, itemId);
+		if (this.projectionClosed || item?.type === "contextCompaction" && itemId && !this.activeCompactionItemIds.has(itemId)) return;
 		if (itemId) this.activeItemIds.add(itemId);
 		this.recordNativeToolOutcome(item);
 		if (item?.type === "contextCompaction" && itemId) {
-			if (!this.isCompactionProjectionActive()) return;
-			this.activeCompactionItemIds.add(itemId);
+			if (!this.isCompactionProjectionActive() || !this.activeCompactionItemIds.has(itemId)) return;
 			const messages = await this.toolTranscriptProjection.readMirroredSessionMessages(this.options.runAbortSignal);
-			if (!this.isCompactionProjectionActive()) return;
+			if (!this.isCompactionProjectionActive() || !this.activeCompactionItemIds.has(itemId)) return;
 			await runAgentHarnessBeforeCompactionHook({
 				sessionFile: this.params.sessionFile,
 				messages,
 				ctx: this.options.agentHookContext ?? {}
 			});
-			if (!this.isCompactionProjectionActive()) return;
+			if (!this.isCompactionProjectionActive() || !this.activeCompactionItemIds.has(itemId)) return;
+			this.compactionProgress.set(itemId, "open");
 			this.emitAgentEvent({
 				stream: "compaction",
 				data: {
@@ -1809,9 +1808,14 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		this.recordNativeToolOutcome(item);
 		this.nativeToolLifecycleProjector.clearTerminalPresentationForNativeItem(item);
 		if (itemId) {
+			this.observedItemIds.add(itemId);
 			this.activeItemIds.delete(itemId);
 			this.completedItemIds.add(itemId);
 		}
+		if (item?.type === "contextCompaction" && itemId) {
+			this.activeCompactionItemIds.delete(itemId);
+			this.completedCompactionCount += 1;
+		}
 		if (!this.asyncDeliveryProjection.allows(item, true)) return;
 		const asyncMessage = this.assistantProjection.recordItemCompleted(item, itemId, this.activeItemIds);
 		if (asyncMessage) await this.asyncDeliveryProjection.deliver(asyncMessage);
@@ -1821,8 +1825,6 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		if (this.projectionClosed) return;
 		if (item?.type === "contextCompaction" && itemId) {
 			if (!this.isCompactionProjectionActive()) return;
-			this.activeCompactionItemIds.delete(itemId);
-			this.completedCompactionCount += 1;
 			await this.options.onContextCompacted?.();
 			if (!this.isCompactionProjectionActive()) return;
 			const messages = await this.toolTranscriptProjection.readMirroredSessionMessages(this.options.runAbortSignal);
@@ -1845,7 +1847,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 				timestamp: this.transcriptCheckpoint.nextTimestamp()
 			});
 			if (!this.isCompactionProjectionActive()) return;
-			this.eventProjection.emitCompactionEnd(itemId, true);
+			this.finishCompactionProgress(itemId, true);
 		}
 		this.toolProgressProjection.recordToolMeta(item);
 		this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
@@ -1895,14 +1897,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 				promptErrorSource: compactionFailure ? "compaction" : "prompt"
 			});
 		}
-		if (compactionFailure) {
-			const failedCompactionItemIds = [...this.activeCompactionItemIds];
-			for (const itemId of failedCompactionItemIds) {
-				this.activeItemIds.delete(itemId);
-				this.activeCompactionItemIds.delete(itemId);
-				this.eventProjection.emitCompactionEnd(itemId, false);
-			}
-		}
+		this.closeCompactionProgress();
 		const turnItems = turn.items;
 		const unsettledAsyncDeliveries = this.asyncDeliveryProjection.pending();
 		const lastToolItem = turnItems.findLast((item) => matchesCodexSnapshotTurn(item, this.turnId) && (item.type === "dynamicToolCall" || shouldClearTerminalPresentationForNativeItem(item)));
@@ -1940,7 +1935,6 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		}
 		if (this.projectionClosed) return;
 		this.assistantProjection.finalizeAnswerCandidate(turn);
-		this.activeCompactionItemIds.clear();
 		await this.reasoningProjection.maybeEndReasoning();
 	}
 	async handleRawResponseItemCompleted(params) {
@@ -1965,9 +1959,6 @@ function readMcpAppResourceUri(item) {
 	const uri = normalizeOptionalString(appContext?.resourceUri) ?? normalizeOptionalString(item.mcpAppResourceUri);
 	return uri?.startsWith("ui://") ? uri : void 0;
 }
-function readMcpAppConnectorId(item) {
-	return normalizeOptionalString(asOptionalRecord(item.appContext)?.connectorId);
-}
 function readMcpToolResult(item) {
 	const result = asOptionalRecord(item.result);
 	if (!result || !Array.isArray(result.content)) return;
@@ -2071,7 +2062,7 @@ function createCodexNativeMcpAppResultDetailsPreparer(params) {
 		const serverName = normalizeOptionalString(item.server);
 		const toolName = normalizeOptionalString(item.tool);
 		const uiResourceUri = readMcpAppResourceUri(item);
-		const connectorId = readMcpAppConnectorId(item);
+		const connectorId = normalizeOptionalString(asOptionalRecord(item.appContext)?.connectorId);
 		const toolResult = readMcpToolResult(item);
 		if (!serverName || !toolName || !uiResourceUri || !toolResult) return;
 		if (serverName === CODEX_APPS_MCP_SERVER && !connectorId) return;
@@ -2134,8 +2125,7 @@ function canonicalizeNativeProgressCardInput(input) {
 var CodexCompactionPlanState = class {
 	record(event) {
 		if (event.stream !== "plan") return;
-		const plan = readBoundedPlan(event.data.explanation, event.data.steps);
-		this.latestPlan = plan;
+		this.latestPlan = readBoundedPlan(event.data.explanation, event.data.steps);
 	}
 	/** Retains markdown that migration-only plan events intentionally omit. */
 	recordProgressCardInput(value) {
@@ -2194,7 +2184,7 @@ function truncateUtf8(value, maxBytes) {
 function readPlanSteps(value) {
 	if (!Array.isArray(value)) return [];
 	return value.flatMap((entry) => {
-		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+		if (!isJsonObject(entry)) return [];
 		const { step, status } = entry;
 		if (typeof step !== "string" || !isPlanStatus(status)) return [];
 		return [{
@@ -2207,6 +2197,48 @@ function isPlanStatus(value) {
 	return value === "pending" || value === "in_progress" || value === "completed";
 }
 //#endregion
+//#region extensions/codex/src/app-server/run-attempt-compaction.ts
+/** Restore host-owned context after native compaction rebuilds a live thread. */
+async function restoreCodexAttemptCompactionContext(resources) {
+	const { state, prompt } = resources;
+	const { runtime, attemptTools } = prompt.context;
+	const { connection } = runtime;
+	const { params, runAbortController } = connection;
+	const { computerContextEpoch, compactionPlanState } = attemptTools;
+	const { client, thread } = state;
+	const assertCurrent = () => {
+		params.hostCapabilities.assertActive();
+		connection.assertCurrent();
+		thread.liveThreadOwnership?.assertCurrent();
+		if (state.thread !== thread || state.client !== client) throw new Error("Codex compaction thread ownership changed");
+	};
+	computerContextEpoch.value += 1;
+	delete computerContextEpoch.frameToolCallId;
+	delete computerContextEpoch.frameImageIdentity;
+	try {
+		await compactionPlanState.restore({
+			client,
+			threadId: thread.threadId,
+			timeoutMs: connection.appServer.requestTimeoutMs,
+			signal: runAbortController.signal
+		});
+	} catch (error) {
+		embeddedAgentLog.warn("failed to restore Codex plan state after compaction", {
+			runId: params.runId,
+			threadId: thread.threadId,
+			error: formatErrorMessage(error)
+		});
+	}
+	thread.liveThreadEphemeralPolicy = await restoreCodexThreadSkillsCatalogAfterCompaction({
+		client,
+		threadId: thread.threadId,
+		ephemeralPolicy: thread.liveThreadEphemeralPolicy,
+		timeoutMs: connection.appServer.requestTimeoutMs,
+		signal: runAbortController.signal,
+		assertCurrent
+	});
+}
+//#endregion
 //#region extensions/codex/src/app-server/user-input-bridge.ts
 /** Owns per-turn Codex request_user_input and ordinary MCP elicitation lifecycles. */
 const DEFAULT_USER_INPUT_TIMEOUT_MS = 9e5;
@@ -2262,10 +2294,13 @@ function createCodexUserInputBridge(params) {
 		async handleRequest(request, requestSignal) {
 			const requestParams = readUserInputParams(request.params);
 			if (!requestParams || requestParams.threadId !== params.threadId || requestParams.turnId !== params.turnId) return;
-			if (requestParams.questions.length === 0) return emptyUserInputResponse();
+			if (requestParams.questions.length === 0) return emptyAgentHarnessUserInputAnswers();
 			const timeoutMs = requestParams.isBlocking ? params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS : NONBLOCKING_USER_INPUT_TIMEOUT_MS;
-			const input = compileUserInputQuestions(requestParams.questions);
-			const cancelValue = emptyUserInputResponse();
+			const input = agentHarnessStructuredInput.compileQuestions({
+				questions: requestParams.questions,
+				intro: "Codex needs input:"
+			});
+			const cancelValue = emptyAgentHarnessUserInputAnswers();
 			return await enqueue({
 				cancelValue,
 				failureValue: cancelValue,
@@ -2318,12 +2353,6 @@ function createCodexUserInputBridge(params) {
 		}
 	};
 }
-function compileUserInputQuestions(questions) {
-	return agentHarnessStructuredInput.compileQuestions({
-		questions,
-		intro: "Codex needs input:"
-	});
-}
 function readUserInputParams(value) {
 	const snapshot = agentHarnessStructuredInput.snapshot(value);
 	if (!agentHarnessStructuredInput.isRecord(snapshot)) return;
@@ -2399,9 +2428,6 @@ function readOwnDataString(value, key) {
 function gatewayAnswersToCodexResponse(answers) {
 	return { answers: Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [questionId, { answers: values }])) };
 }
-function emptyUserInputResponse() {
-	return { ...emptyAgentHarnessUserInputAnswers() };
-}
 function declineElicitation(message) {
 	return createCodexElicitationResponse("decline", null, message ? { message } : null);
 }
@@ -2412,8 +2438,8 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	const { context, turnState } = prompt;
 	const { runtime, attemptTools, hookContext } = context;
 	const { connection } = runtime;
-	const { params, runAbortController, terminalState, abortExplicitly, abortFromUpstream, sessionAgentId, contextSessionKey, effectiveCwd } = connection;
-	const { dynamicToolParams, compactionPlanState, computerContextEpoch, toolBridge } = attemptTools;
+	const { params, runAbortController, terminalState, abortExplicitly, cancellation, sessionAgentId, contextSessionKey, effectiveCwd } = connection;
+	const { dynamicToolParams, toolBridge } = attemptTools;
 	const { state, completion, userInputBridgeRef, steeringQueueRef, deadlines, noteProgress, completeTurn, interruptTurn } = turnRuntime;
 	const { emitExecutionPhaseOnce, emitLifecycleStart, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const { enqueueNotification } = notifications;
@@ -2532,25 +2558,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		} } : {},
 		...prepareNativeMcpAppResultDetails ? { prepareNativeMcpAppResultDetails } : {},
 		upstreamUserText,
-		onContextCompacted: async () => {
-			computerContextEpoch.value += 1;
-			delete computerContextEpoch.frameToolCallId;
-			delete computerContextEpoch.frameImageIdentity;
-			try {
-				await compactionPlanState.restore({
-					client: resourceState.client,
-					threadId: resourceState.thread.threadId,
-					timeoutMs: connection.appServer.requestTimeoutMs,
-					signal: runAbortController.signal
-				});
-			} catch (error) {
-				embeddedAgentLog.warn("failed to restore Codex plan state after compaction", {
-					runId: params.runId,
-					threadId: resourceState.thread.threadId,
-					error: formatErrorMessage(error)
-				});
-			}
-		}
+		onContextCompacted: () => restoreCodexAttemptCompactionContext(resources)
 	});
 	const activeProjector = projectorRef.current;
 	let activationFailed = false;
@@ -2558,7 +2566,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		state.abortCleanup = interruptTurn(activeTurnId).then(async (confirmed) => {
 			if (!activationFailed && !terminalState.explicitCancellationObserved && !state.permissionChangeRestart && !state.timeout) return;
 			if (!confirmed) throw new Error(state.permissionChangeRestart ? "Permission change could not confirm the previous Codex turn stopped." : "Codex cancellation could not confirm the turn stopped; background terminals may still be running.");
-			if (resources.nativeProcessAuthority) await resources.nativeProcessAuthority.cancelTurn(resourceState.client, resourceState.thread.threadId, activeTurnId);
+			if (resources.nativeProcessAuthority?.requiresProcessAdmission) await resources.nativeProcessAuthority.cancelTurn(resourceState.client, resourceState.thread.threadId, activeTurnId);
 			else await terminateCodexBackgroundTerminals(resourceState.client, resourceState.thread.threadId);
 			if (state.permissionChangeRestart) state.permissionChangeRestart = "confirmed";
 		});
@@ -2626,16 +2634,14 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		signal: runAbortController.signal,
 		assertActive: assertSteeringActive,
 		prepareMessage: async (text, options, assertMessageCurrent) => {
-			const attachmentNote = await prepareAgentWorkspaceAttachments({
-				workspaceDir: params.workspaceDir,
+			const attachmentNote = await connection.prepareInputAttachments({
+				maxChars: Math.max(0, CODEX_TURN_START_TEXT_INPUT_MAX_CHARS - text.length - 2),
 				turn: {
-					config: params.config,
 					media: options.media,
-					timeoutMs: params.timeoutMs,
-					abortSignal: runAbortController.signal,
 					userTurnTranscriptRecorder: options.userTurnTranscriptRecorder
 				},
-				assertCurrent: assertMessageCurrent
+				assertCurrent: assertMessageCurrent,
+				signal: runAbortController.signal
 			});
 			const result = await detectAndLoadAgentHarnessPromptImages({
 				...imageContext,
@@ -2796,11 +2802,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		cancel: () => abortExplicitly("cancelled"),
 		abort: () => abortExplicitly("aborted")
 	};
-	const freezeRunTerminalOutcome = () => {
-		if (terminalState.terminalOutcomeFrozen) return;
-		terminalState.terminalOutcomeFrozen = true;
-		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
-	};
+	const freezeRunTerminalOutcome = cancellation.freezeTerminalOutcome;
 	const projectionReady = Promise.resolve().then(async () => {
 		runAbortController.signal.addEventListener("abort", abortListener, { once: true });
 		if (runAbortController.signal.aborted) abortListener();
@@ -2931,15 +2933,9 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 				kind: "clear",
 				threadId: resourceState.thread.threadId
 			}) : true;
-			if (!retainLiveThread) {
-				if (bindingReleased) {
-					if (!await releaseThreadSubscription()) {
-						if (params.oneShotCliRun) await runCleanupStep("codex-one-shot-unsubscribe", async () => {
-							throw new Error("Codex one-shot thread unsubscribe was not confirmed");
-						});
-					}
-				}
-			}
+			if (!retainLiveThread && bindingReleased && !await releaseThreadSubscription() && params.oneShotCliRun) await runCleanupStep("codex-one-shot-unsubscribe", async () => {
+				throw new Error("Codex one-shot thread unsubscribe was not confirmed");
+			});
 		}
 	} finally {
 		if (resourceState.thread.liveThreadOwnership) await runCleanupStep("codex-unsettled-subscription", async () => {
@@ -2977,6 +2973,13 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 }
 //#endregion
 //#region extensions/codex/src/app-server/session-binding-scope.ts
+/** Both read and write projections must leave retained assignment facts unchanged. */
+function projectAssignmentOwner(assignment, owner) {
+	return {
+		...assignment,
+		owner
+	};
+}
 /** Carries one prepared run identity through callers that rederive it from public params. */
 function scopeCodexRunBindingStore(params) {
 	const mapSessionIdentity = (identity) => identity.agentId === params.logicalIdentity.agentId && identity.sessionId === params.logicalIdentity.sessionId && identity.sessionKey?.trim() === params.logicalIdentity.sessionKey?.trim() ? params.physicalIdentity : identity;
@@ -2993,9 +2996,17 @@ function scopeCodexRunBindingStore(params) {
 		...params.bindingStore,
 		read: (identity) => params.bindingStore.read(mapIdentity(identity)),
 		...readMany ? { readMany: (identities) => readMany(identities.map(mapIdentity)) } : {},
+		readNativeSubagentAssignments: (identity, owner) => (params.bindingStore.readNativeSubagentAssignments?.(mapIdentity(identity), mapHistoryOwner(identity, owner)) ?? []).map((assignment) => projectAssignmentOwner(assignment, {
+			...assignment.owner,
+			sessionId: owner.sessionId
+		})),
 		readNativeSubagentSubmissions: (identity, owner) => params.bindingStore.readNativeSubagentSubmissions(mapIdentity(identity), mapHistoryOwner(identity, owner)),
 		hasOtherThreadOwner: (threadId, identity) => params.bindingStore.hasOtherThreadOwner(threadId, identity ? mapIdentity(identity) : void 0),
-		mutate: (identity, mutation, assertCurrent) => params.bindingStore.mutate(mapIdentity(identity), mutation.kind === "record-native-subagent-submission" || mutation.kind === "consume-native-subagent-submission" ? {
+		mutate: (identity, mutation, assertCurrent) => params.bindingStore.mutate(mapIdentity(identity), mutation.kind === "record-native-subagent-assignment" || mutation.kind === "consume-native-subagent-assignment" ? {
+			...mutation,
+			owner: mapHistoryOwner(identity, mutation.owner),
+			assignment: projectAssignmentOwner(mutation.assignment, mapHistoryOwner(identity, mutation.assignment.owner))
+		} : mutation.kind === "record-native-subagent-submission" || mutation.kind === "consume-native-subagent-submission" ? {
 			...mutation,
 			owner: mapHistoryOwner(identity, mutation.owner)
 		} : mutation, assertCurrent),
@@ -3257,7 +3268,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		offAnnounced: false,
 		resetAnnounced: false
 	};
-	const preDynamicStartupStages = createCodexDynamicToolBuildStageTracker();
+	const preDynamicStartupStages = createStageTimingTracker();
 	const runtimeArtifactRequest = params.captureRuntimeArtifact || params.expectedRuntimeArtifact ? params.expectedRuntimeArtifact ? { expected: params.expectedRuntimeArtifact } : {} : void 0;
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const requirementsToml = readCodexRequirementsToml({});
@@ -3301,10 +3312,19 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		...sandbox?.enabled || remoteExec ? void 0 : preparedEnvironment.localIdentityEnv,
 		...preparedEnvironment.localProcessEnv
 	} : void 0;
-	const shellEnvironment = preparedShellEnvironment && Object.keys(preparedShellEnvironment).length > 0 ? preparedShellEnvironment : void 0;
+	const baseShellEnvironment = 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;
+	let shellEnvironment = baseShellEnvironment;
+	let shellPathPrepend;
 	const withPreparedProcessEnv = (appServer) => {
 		assertLocalTargetSupported(appServer.start.transport !== "stdio" || Boolean(appServer.remoteWorkspaceRoot));
+		const localToolEnv = !sandbox?.enabled && !remoteExec && appServer.start.transport === "stdio" && !isCodexAppServerProxyLaunch(appServer.start.args) && !appServer.remoteWorkspaceRoot ? preparedEnvironment?.localToolEnv : void 0;
+		const hasLocalToolEnv = localToolEnv && Object.keys(localToolEnv).length > 0;
+		shellPathPrepend = hasLocalToolEnv ? preparedEnvironment?.localToolPathPrepend : void 0;
+		shellEnvironment = hasLocalToolEnv ? {
+			...baseShellEnvironment,
+			...localToolEnv
+		} : baseShellEnvironment;
 		return shellEnvironment ? {
 			...appServer,
 			start: {
@@ -3348,7 +3368,9 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			bindingIdentity = physicalIdentity;
 		}
 	}
-	const { binding: admittedBinding, assertCurrent } = await resolveCodexSessionBinding({
+	let modelExecution;
+	const assertModelExecutionCurrent = () => modelExecution?.assertCurrent();
+	const { binding: admittedBinding, assertCurrent: assertBindingCurrent } = await resolveCodexSessionBinding({
 		reclaimStale: true,
 		bindingStore,
 		identity: bindingIdentity,
@@ -3358,9 +3380,14 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		signal: params.abortSignal,
 		assertBinding: params.expectedSessionRuntimeOwnership ? (binding) => assertCodexSessionRuntimeOwnership(binding, params.expectedSessionRuntimeOwnership) : void 0
 	});
+	const assertCurrent = () => {
+		assertBindingCurrent();
+		assertModelExecutionCurrent();
+	};
 	let startupBinding = admittedBinding;
 	preDynamicStartupStages.mark("read-binding");
 	const usesSupervisionConnection = startupBinding?.connectionScope === "supervision";
+	if (usesSupervisionConnection && isCodexResponsesOAuthRun(params)) throw new Error("ChatGPT subscription sharing requires an OpenClaw-owned Codex session; detach from native supervision first.");
 	if (usesSupervisionConnection) activeContextEngine = void 0;
 	if (usesSupervisionConnection && pluginConfig.supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
 	const resolveRuntimeOptionsForBinding = async (binding, selection) => (await resolveCodexBindingAppServerConnection({
@@ -3472,13 +3499,9 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			},
 			agentDir
 		});
-		return {
-			session,
-			appServer: withPreparedProcessEnv(trusted)
-		};
+		return withPreparedProcessEnv(trusted);
 	};
-	let resolvedAppServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
-	let appServer = resolvedAppServer.appServer;
+	let appServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
 	preDynamicStartupStages.mark("app-server-policy");
 	preDynamicStartupStages.mark("native-hook-relay");
 	const terminalState = {
@@ -3488,28 +3511,32 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		terminalOutcomeFrozen: false,
 		sharedAbortAllowedAfterTerminalOutcome: false
 	};
-	const runAbortController = new AbortController();
-	let attemptAbortNotified = false;
-	const notifyAttemptAbort = () => {
-		if (attemptAbortNotified) return;
-		attemptAbortNotified = true;
-		params.onAttemptAbort?.();
-	};
-	const abortExplicitly = (reason) => {
-		if (terminalState.terminalOutcomeFrozen) {
-			if (terminalState.sharedAbortAllowedAfterTerminalOutcome) notifyAttemptAbort();
-			return;
-		}
-		notifyAttemptAbort();
-		terminalState.explicitCancellationObserved = true;
-		terminalState.explicitCancellationReason ??= reason;
-		runAbortController.abort(reason);
-	};
-	const abortFromUpstream = () => {
-		abortExplicitly(params.abortSignal?.reason ?? "upstream_abort");
+	const cancellation = createAgentHarnessAttemptCancellation({
+		upstreamSignal: params.abortSignal,
+		onAttemptAbort: () => params.onAttemptAbort?.(),
+		state: terminalState
+	});
+	const { controller: runAbortController, abortExplicitly } = cancellation;
+	let detachModelAbort;
+	const releaseModelExecution = () => {
+		detachModelAbort?.();
+		detachModelAbort = void 0;
+		modelExecution?.release();
+	};
+	const bindModelExecution = (model) => {
+		assertCurrent();
+		const bind = params.hostCapabilities.bindModelExecution;
+		if (!bind) throw new Error("Codex inference requires host model execution authority.");
+		const execution = bind(model);
+		releaseModelExecution();
+		modelExecution = execution;
+		if (!execution) return;
+		const abortModelExecution = () => abortExplicitly(execution.signal.reason);
+		execution.signal.addEventListener("abort", abortModelExecution, { once: true });
+		detachModelAbort = () => execution.signal.removeEventListener("abort", abortModelExecution);
+		if (execution.signal.aborted) abortModelExecution();
+		execution.assertCurrent();
 	};
-	if (params.abortSignal?.aborted) abortFromUpstream();
-	else params.abortSignal?.addEventListener("abort", abortFromUpstream, { once: true });
 	try {
 		const startupBindingBeforeRotation = startupBinding;
 		const startupBindingResolution = await rotateOversizedCodexAppServerStartupBinding({
@@ -3532,8 +3559,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 				modelProvider: reviewerPolicyContext.modelProvider,
 				model: reviewerPolicyContext.model
 			});
-			resolvedAppServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
-			appServer = resolvedAppServer.appServer;
+			appServer = resolveFinalAppServer(configuredAppServer, reviewerPolicyContext);
 		}
 		const sessionPermissionPolicy = resolveCodexEffectiveSessionPermissionPolicy({
 			appServer,
@@ -3556,11 +3582,44 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			pluginAppServer: appServer,
 			continuityCalibration: startupBindingBeforeRotation?.continuityCalibration
 		};
-		const resolveRuntimeOptionsForCurrentBinding = async (selection) => resolveFinalAppServer(await resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection).appServer;
+		const resolveRuntimeOptionsForCurrentBinding = async (selection) => resolveFinalAppServer(await resolveRuntimeOptionsForBinding(mutable.startupBinding, selection), selection);
 		assertCurrent();
 		return {
 			params,
+			prepareInputAttachments: async (request) => {
+				const assertPreparationCurrent = () => {
+					assertCurrent();
+					request.signal?.throwIfAborted();
+					request.assertCurrent();
+				};
+				assertPreparationCurrent();
+				if (request.turn) {
+					const remoteNote = await prepareAgentWorkspaceAttachments({
+						workspaceDir: params.workspaceDir,
+						turn: {
+							...request.turn,
+							config: params.config,
+							timeoutMs: params.timeoutMs,
+							abortSignal: request.signal
+						},
+						assertCurrent: assertPreparationCurrent
+					});
+					assertPreparationCurrent();
+					if (remoteNote) return remoteNote;
+				}
+				if (sandbox?.enabled || params.disableTools || params.toolsAllow?.length === 0 || params.toolExecutionAllow?.length === 0 || remoteExec || appServer.start.transport !== "stdio" || appServer.remoteWorkspaceRoot || params.permissionMode && params.permissionMode !== "full") return;
+				const note = await params.hostCapabilities.prepareInputAttachments?.({
+					...request,
+					placement: "local-host",
+					assertCurrent: assertPreparationCurrent
+				});
+				assertPreparationCurrent();
+				return note;
+			},
 			assertCurrent,
+			assertModelExecutionCurrent,
+			bindModelExecution,
+			releaseModelExecution,
 			options,
 			attemptStartedAt,
 			profilerEnabled,
@@ -3582,6 +3641,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			sandbox,
 			agentDir,
 			shellEnvironment,
+			shellPathPrepend,
 			disableLoginShell,
 			bindingIdentity,
 			bindingStore,
@@ -3600,7 +3660,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			runAbortController,
 			terminalState,
 			abortExplicitly,
-			abortFromUpstream,
+			cancellation,
 			resolveReviewerPolicyContext,
 			resolveRuntimeOptionsForCurrentBinding,
 			mutable,
@@ -3608,24 +3668,19 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			initialInactiveThreadBootstrapBindingForcedFreshStart
 		};
 	} catch (error) {
-		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
+		cancellation.dispose();
+		releaseModelExecution();
 		throw error;
 	}
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-context.ts
-/**
-* Builds Codex app-server prompt context,
-* system-prompt reports, and context-engine projection decisions.
-*/
-/** Reads mirrored Codex session history for harness hooks. */
 async function readMirroredSessionHistoryMessages(params) {
 	const { admission, signal, contextTokenBudget, ...target } = params;
 	const messages = await readCodexMirroredSessionHistoryMessages(target, admission, signal, contextTokenBudget);
 	if (!messages) embeddedAgentLog.warn("failed to read mirrored session history for codex harness hooks", { sessionFile: params.sessionFile });
 	return messages;
 }
-/** Reads a valid thread-bootstrap projection request from context-engine output. */
 function readContextEngineThreadBootstrapProjection(projection) {
 	if (projection?.mode !== "thread_bootstrap") return;
 	const epoch = projection.epoch?.trim();
@@ -3640,10 +3695,6 @@ function readContextEngineThreadBootstrapProjection(projection) {
 		...fingerprint ? { fingerprint } : {}
 	};
 }
-/**
-* Decides whether an existing Codex thread can reuse its context-engine
-* bootstrap projection or must be reprojected.
-*/
 function resolveContextEngineBootstrapProjectionDecision(params) {
 	const bindingProjection = params.startupBinding?.contextEngine?.projection;
 	if (!params.startupBinding?.threadId || !bindingProjection) return {
@@ -3670,10 +3721,6 @@ function resolveContextEngineBootstrapProjectionDecision(params) {
 		reason: "matching-thread-bootstrap-binding"
 	};
 }
-/**
-* Builds the prompt-size, bootstrap-file, skill, and tool-schema accounting
-* report for a Codex run.
-*/
 function buildCodexSystemPromptReport(params) {
 	const toolEntries = flattenCodexDynamicToolFunctions(params.tools).map(buildCodexToolReportEntry);
 	const schemaChars = toolEntries.reduce((sum, tool) => sum + tool.schemaChars, 0);
@@ -3718,26 +3765,22 @@ function buildCodexSystemPromptReport(params) {
 }
 function buildCodexSkillReportEntries(skillsPrompt) {
 	if (!skillsPrompt) return [];
-	return Array.from(skillsPrompt.matchAll(/<skill>[\s\S]*?<\/skill>/gi)).map((match) => match[0] ?? "").map((block) => ({
+	return Array.from(skillsPrompt.matchAll(/<skill>[\s\S]*?<\/skill>/gi), ([block]) => ({
 		name: block.match(/<name>\s*([^<]+?)\s*<\/name>/i)?.[1]?.trim() || "(unknown)",
 		blockChars: block.length
-	})).filter((entry) => entry.blockChars > 0);
+	}));
 }
 function buildCodexToolReportEntry(tool) {
 	const summary = tool.description.trim();
-	if (tool.deferLoading === true) return {
-		name: tool.name,
-		summaryChars: summary.length,
-		summaryHash: sha256Text(summary),
-		schemaChars: 0,
-		schemaHash: stableJsonHash(null),
-		propertiesCount: null
-	};
 	return {
 		name: tool.name,
 		summaryChars: summary.length,
 		summaryHash: sha256Text(summary),
-		...buildCodexToolSchemaStats(tool.inputSchema)
+		...tool.deferLoading === true ? {
+			schemaChars: 0,
+			schemaHash: stableJsonHash(null),
+			propertiesCount: null
+		} : buildCodexToolSchemaStats(tool.inputSchema)
 	};
 }
 function buildCodexToolSchemaStats(schema) {
@@ -3758,21 +3801,13 @@ function buildCodexToolSchemaStats(schema) {
 function sha256Text(value) {
 	return createHash("sha256").update(value).digest("hex");
 }
-function normalizeForStableHash(value) {
-	if (Array.isArray(value)) return value.map((entry) => normalizeForStableHash(entry));
-	if (value && typeof value === "object") {
-		const record = value;
-		return Object.fromEntries(Object.keys(record).toSorted((left, right) => left.localeCompare(right)).map((key) => [key, normalizeForStableHash(record[key])]));
-	}
-	return value;
-}
 function stableJsonHash(value) {
-	return sha256Text(JSON.stringify(normalizeForStableHash(value)) ?? "null");
+	return sha256Text(JSON.stringify(stabilizeJsonValue(value)) ?? "null");
 }
 function buildCodexBootstrapInjectionStats(params) {
 	const injectedIndex = indexCodexContextFileContent(params.injectedFiles);
 	const developerInstructionIndex = indexCodexContextFileContent(params.developerInstructionFiles ?? []);
-	const memoryToolRoutedPaths = new Set((params.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonBlankString(file.path)).filter(isNonEmptyString$1).map(normalizeCodexContextFilePath));
+	const memoryToolRoutedPaths = new Set((params.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonBlankString(file.path)).filter(isNonEmptyString).map(normalizeCodexContextFilePath));
 	return params.bootstrapFiles.map((file) => {
 		const fileName = readNonBlankString(file.name);
 		const pathValue = readNonBlankString(file.path) ?? fileName ?? "";
@@ -3819,28 +3854,19 @@ function indexCodexContextFileContent(files) {
 	};
 }
 function readCodexIndexedContextFileContent(index, pathValue, fileName) {
-	const pathContent = index.byPath.get(pathValue);
-	if (pathContent !== void 0) return pathContent;
-	if (fileName) {
-		const nameContent = index.byPath.get(fileName);
-		if (nameContent !== void 0) return nameContent;
-	}
 	const baseName = getCodexContextFileBasename(fileName ?? pathValue);
-	return baseName ? index.byBaseName.get(baseName) : void 0;
+	return index.byPath.get(pathValue) ?? (fileName ? index.byPath.get(fileName) : void 0) ?? (baseName ? index.byBaseName.get(baseName) : void 0);
 }
 function readPositiveNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
 }
-/**
-* Builds OpenClaw-provided workspace prompt context for the current Codex turn.
-*/
 function buildCodexOpenClawPromptContext(params) {
-	if (!shouldInjectCodexOpenClawPromptContext(params.params)) return;
+	if (!shouldIncludeAgentHarnessRuntimeContext(params.params)) return;
 	const sections = [params.workspacePromptContext?.trim() ? [
 		"## OpenClaw Workspace Context",
 		"",
 		params.workspacePromptContext.trim()
-	].join("\n") : void 0, params.watchedSessionsContext?.trim() || void 0].filter(isNonEmptyString$1);
+	].join("\n") : void 0, params.watchedSessionsContext?.trim() || void 0].filter(isNonEmptyString);
 	if (sections.length === 0) return;
 	return [
 		"OpenClaw runtime context for this turn:",
@@ -3856,7 +3882,7 @@ function buildCodexOpenClawPromptContext(params) {
 * keep refusing cross-session questions (openclaw#114797).
 */
 function buildCodexWatchedSessionsContext(params) {
-	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
+	if (!shouldIncludeAgentHarnessRuntimeContext(params.attempt)) return;
 	return buildWatchedSessionsHarnessContext({
 		config: params.attempt.config,
 		sessionKey: params.sessionKey,
@@ -3864,9 +3890,8 @@ function buildCodexWatchedSessionsContext(params) {
 		toolNames: flattenCodexDynamicToolFunctions(params.dynamicTools).map((tool) => normalizeCodexDynamicToolName(tool.name))
 	});
 }
-/** Renders loaded OpenClaw skill prompts as Codex collaboration instructions. */
-function renderCodexSkillsCollaborationInstructions(params) {
-	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
+function renderCodexSkillsInstructions(params) {
+	if (!shouldIncludeAgentHarnessRuntimeContext(params.attempt)) return;
 	return params.skillsPrompt?.trim() ? [
 		"## OpenClaw Skills",
 		"",
@@ -3921,59 +3946,15 @@ function splitLeadingCodexDeliveryHint(prompt) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/app-server/run-attempt-state.ts
-async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields, expected) {
-	const currentBinding = bindingStore.read(identity);
-	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
-	if (!expectedThreadId) return;
-	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
-		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
-			...fields,
-			boundThreadId: currentBinding.threadId
-		});
-		return;
-	}
-	if (expected || currentBinding?.connectionScope === "supervision") {
-		embeddedAgentLog.warn("codex app-server image payload error detected for native-owned thread; preserving binding", fields);
-		return;
-	}
-	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
-	await bindingStore.mutate(identity, {
-		kind: "clear",
-		threadId: expectedThreadId
-	});
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.length > 0;
-}
-function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
-	if (!params.contextEngineActive || params.thread.lifecycle.action !== "resumed") return false;
-	const message = formatErrorMessage(params.error);
-	return /ran out of room in the model'?s context window/iu.test(message) || /context window/iu.test(message) || /context length/iu.test(message) || /maximum context/iu.test(message) || /too many tokens/iu.test(message);
-}
-function isCodexActiveCompactTurnError(error) {
-	if (!(error instanceof CodexAppServerRpcError)) return false;
-	const data = isJsonObject(error.data) ? error.data : void 0;
-	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
-	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
-}
-function joinPresentSections(...sections) {
-	return sections.filter((section) => Boolean(section?.trim())).join("\n\n");
-}
-function prependCurrentInboundContext(prompt, context) {
-	const text = context?.text.trim();
-	return text ? [neutralizeCodexExplicitMentionSigils(text), prompt].filter(Boolean).join("\n\n") : prompt;
-}
-//#endregion
 //#region extensions/codex/src/app-server/run-attempt-context.ts
 async function prepareCodexAttemptContext(runtime, attemptTools) {
-	const { connection, runtimeParams, activeSessionId, activeSessionFile, buildActiveRunAttemptParams, effectiveContextWindowInfo, effectiveContextTokenBudget, effectiveRuntimeProviderId, effectiveRuntimeModelId, hookChannelId } = runtime;
+	const { connection, runtimeParams, effectiveContextWindowInfo, effectiveContextTokenBudget, effectiveRuntimeProviderId, effectiveRuntimeModelId, hookChannelId } = runtime;
 	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart, sandbox } = connection;
 	const { toolBridge } = attemptTools;
 	const activeTranscriptTarget = {
 		agentId: sessionAgentId,
-		sessionFile: activeSessionFile,
-		sessionId: activeSessionId,
+		sessionFile: runtimeParams.sessionFile,
+		sessionId: runtimeParams.sessionId,
 		sessionKey: contextSessionKey,
 		sessionTarget: params.sessionTarget
 	};
@@ -4022,7 +4003,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	};
 	const hookRunner = getAgentHarnessHookRunner();
 	const buildActiveContextEngineRuntimeContext = () => buildHarnessContextEngineRuntimeContext({
-		attempt: buildActiveRunAttemptParams(),
+		attempt: { ...runtimeParams },
 		workspaceDir: effectiveWorkspace,
 		cwd: effectiveCwd,
 		agentDir,
@@ -4034,9 +4015,9 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		await bootstrapHarnessContextEngine({
 			hadSessionFile: hadSessionTranscriptState,
 			contextEngine: activeContextEngine,
-			sessionId: activeSessionId,
+			sessionId: runtimeParams.sessionId,
 			sessionKey: contextSessionKey,
-			sessionFile: activeSessionFile,
+			sessionFile: runtimeParams.sessionFile,
 			sessionTarget: params.sessionTarget,
 			runtimeContext: buildActiveContextEngineRuntimeContext(),
 			transcriptReadFence: params.userTurnTranscriptRecorder?.getAdmissionReceipt(),
@@ -4053,7 +4034,6 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		historyState.messages = await readFencedHistory() ?? historyState.messages;
 	}
 	historyState.messages.push(...params.pluginRuntimeRefreshMessages ?? []);
-	const memoryToolNames = getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs);
 	const workspaceBootstrapContext = await buildCodexWorkspaceBootstrapContext({
 		params: runtimeParams,
 		agentWorkspaceDeveloperInstructions: connection.mutable.startupBinding?.agentWorkspaceDeveloperInstructions,
@@ -4062,11 +4042,15 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		effectiveWorkspace,
 		sessionKey: contextSessionKey,
 		sessionAgentId,
-		memoryToolNames,
+		tools: toolBridge.availableSpecs,
 		ringZeroActive: isHostScopedAgentToolActive("openclaw") && isSystemAgentOnlyCodexDynamicToolAllowlist(runtimeParams.toolsAllow),
 		sandboxed: sandbox?.enabled === true
 	});
 	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions;
+	const skillsInstructions = renderCodexSkillsInstructions({
+		attempt: runtimeParams,
+		skillsPrompt: params.skillsSnapshot?.prompt
+	});
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
 	const watchedSessionsContext = buildCodexWatchedSessionsContext({
 		attempt: runtimeParams,
@@ -4092,25 +4076,18 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		agentWorkspaceDeveloperInstructions,
 		baseDeveloperInstructions,
 		buildOpenClawPromptContext,
-		skillsCollaborationInstructions: renderCodexSkillsCollaborationInstructions({
-			attempt: runtimeParams,
-			skillsPrompt: params.skillsSnapshot?.prompt
-		}),
+		skillsInstructions,
 		promptState: {
 			promptText: params.prompt,
 			promptContextRange: void 0,
 			developerInstructions: baseDeveloperInstructions,
-			prePromptMessageCount: historyState.messages.length,
 			contextEngineProjection: void 0,
 			precomputedStaleBindingContinuityProjectionApplied: false,
 			staleBindingContinuityForcedFreshStart: false,
 			noEngineContinuityProjectionApplied: false,
 			inactiveThreadBootstrapBindingForcedFreshStart: initialInactiveThreadBootstrapBindingForcedFreshStart
 		},
-		codexContextProjectionMaxChars: resolveCodexContextEngineProjectionMaxChars({
-			contextTokenBudget: effectiveContextTokenBudget,
-			reserveTokens: resolveCodexContextEngineProjectionReserveTokens()
-		}),
+		codexContextProjectionMaxChars: resolveCodexContextEngineProjectionMaxChars({ contextTokenBudget: effectiveContextTokenBudget }),
 		codexContinuityProjectionMaxChars: resolveCodexContinuityProjectionMaxChars({
 			contextTokenBudget: effectiveContextTokenBudget,
 			calibration: connection.mutable.continuityCalibration
@@ -4119,23 +4096,6 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-diagnostics.ts
-/**
-* Diagnostic helpers for Codex app-server model calls and plugin-thread config
-* eligibility.
-*/
-/** Reads a tool schema field in either app-server or OpenClaw naming. */
-function readCodexDiagnosticToolParameters(tool) {
-	return tool.inputSchema ?? tool.parameters;
-}
-/** Builds compact diagnostic tool definitions for trusted private telemetry. */
-function buildCodexDiagnosticToolDefinitions(tools) {
-	return tools.map((tool) => ({
-		name: tool.name,
-		description: tool.description,
-		parameters: readCodexDiagnosticToolParameters(tool)
-	}));
-}
-/** Returns the serialized UTF-8 byte length for a JSON-compatible value. */
 function utf8JsonByteLength(value) {
 	try {
 		return Buffer.byteLength(JSON.stringify(value), "utf8");
@@ -4143,7 +4103,6 @@ function utf8JsonByteLength(value) {
 		return;
 	}
 }
-/** Builds a short namespaced fingerprint for sensitive log values. */
 function fingerprintCodexLogValue(namespace, value) {
 	const hash = createHash("sha256");
 	hash.update(namespace);
@@ -4151,10 +4110,6 @@ function fingerprintCodexLogValue(namespace, value) {
 	hash.update(value);
 	return `sha256:${hash.digest("hex").slice(0, 16)}`;
 }
-/**
-* Builds redacted diagnostics explaining whether plugin thread config was
-* eligible for a Codex app-server attempt.
-*/
 function buildCodexPluginThreadConfigEligibilityLogData(params) {
 	return {
 		sessionId: params.sessionId,
@@ -4171,27 +4126,38 @@ function buildCodexPluginThreadConfigEligibilityLogData(params) {
 		appServerCommandSource: params.appServer.start.commandSource
 	};
 }
-/**
-* Creates lifecycle emitters for trusted model-call diagnostics with optional
-* private payload capture.
-*/
 function createCodexModelCallDiagnosticEmitter(params) {
 	const now = params.now ?? (() => Date.now());
-	const toolDefinitions = params.capture.toolDefinitions ? buildCodexDiagnosticToolDefinitions(params.tools) : void 0;
+	const toolDefinitions = params.capture.toolDefinitions ? params.tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.inputSchema ?? tool.parameters
+	})) : void 0;
 	let startedAt = now();
 	let started = false;
 	let terminalEmitted = false;
 	let requestPayloadBytes;
 	const privateData = (modelContent) => modelContent && Object.keys(modelContent).length > 0 ? { modelContent } : void 0;
-	const buildContent = () => {
-		const modelContent = {
-			...params.capture.inputMessages ? { inputMessages: params.buildInputMessages() } : {},
-			...params.capture.systemPrompt ? { systemPrompt: params.buildSystemPrompt() } : {},
-			...toolDefinitions ? { toolDefinitions } : {}
-		};
-		return Object.keys(modelContent).length > 0 ? modelContent : void 0;
+	const buildContent = () => ({
+		...params.capture.inputMessages ? { inputMessages: params.buildInputMessages() } : {},
+		...params.capture.systemPrompt ? { systemPrompt: params.buildSystemPrompt() } : {},
+		...toolDefinitions ? { toolDefinitions } : {}
+	});
+	const emitTerminal = (type, outputMessages, fields = {}) => {
+		if (!started || terminalEmitted) return false;
+		terminalEmitted = true;
+		emitTrustedDiagnosticEventWithPrivateData({
+			type,
+			...params.baseFields,
+			durationMs: Math.max(0, now() - startedAt),
+			...fields,
+			...requestPayloadBytes !== void 0 ? { requestPayloadBytes } : {}
+		}, privateData({
+			...buildContent(),
+			...params.capture.outputMessages ? { outputMessages } : {}
+		}));
+		return true;
 	};
-	const requestPayloadBytesField = () => requestPayloadBytes !== void 0 ? { requestPayloadBytes } : {};
 	return {
 		setRequestPayloadBytes(bytes) {
 			requestPayloadBytes = bytes;
@@ -4205,37 +4171,16 @@ function createCodexModelCallDiagnosticEmitter(params) {
 			}, privateData(buildContent()));
 		},
 		emitCompleted(result) {
-			if (!started || terminalEmitted) return;
-			terminalEmitted = true;
-			emitTrustedDiagnosticEventWithPrivateData({
-				type: "model.call.completed",
-				...params.baseFields,
-				durationMs: Math.max(0, now() - startedAt),
-				...requestPayloadBytesField()
-			}, privateData({
-				...buildContent(),
-				...params.capture.outputMessages ? { outputMessages: result.lastAssistant ? [result.lastAssistant] : result.assistantTexts } : {}
-			}));
+			emitTerminal("model.call.completed", result.lastAssistant ? [result.lastAssistant] : result.assistantTexts);
 		},
 		emitError(error, fields = {}) {
-			if (!started || terminalEmitted) return;
-			terminalEmitted = true;
-			emitTrustedDiagnosticEventWithPrivateData({
-				type: "model.call.error",
-				...params.baseFields,
-				durationMs: Math.max(0, now() - startedAt),
+			if (emitTerminal("model.call.error", [], {
 				errorCategory: fields.failureKind ?? "error",
-				...fields.failureKind ? { failureKind: fields.failureKind } : {},
-				...requestPayloadBytesField()
-			}, privateData({
-				...buildContent(),
-				...params.capture.outputMessages ? { outputMessages: [] } : {}
-			}));
-			params.onErrorDiagnostic?.(error);
+				...fields.failureKind ? { failureKind: fields.failureKind } : {}
+			})) params.onErrorDiagnostic?.(error);
 		}
 	};
 }
-/** Classifies model-call failures into timeout/abort buckets for diagnostics. */
 function classifyCodexModelCallFailureKind(params) {
 	if (params.timedOut) return "timeout";
 	const errorMessage = params.error ? params.formatError(params.error).toLowerCase() : "";
@@ -4245,7 +4190,6 @@ function classifyCodexModelCallFailureKind(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-results.ts
-/** Joins terminal assistant text blocks into the final attempt answer. */
 function collectTerminalAssistantText(result) {
 	return result.assistantTexts.join("\n\n").trim();
 }
@@ -4258,14 +4202,12 @@ function buildCodexAppServerPromptTimeoutOutcome(timeout) {
 		livenessState: "abandoned"
 	};
 }
-/** Explains why an incomplete app-server turn cannot be safely replayed. */
 function resolveCodexAppServerReplayBlockedReason(result) {
 	if (result.replayMetadata.hadPotentialSideEffects) return "potential_side_effect";
 	if (result.assistantTexts.some((text) => text.trim().length > 0)) return "assistant_output";
 	if (result.toolMetas.length > 0 || result.clientToolCalls || result.lastToolError || result.didSendDeterministicApprovalPrompt) return "tool_activity";
 	if (result.itemLifecycle.startedCount > 0 || result.itemLifecycle.activeCount > 0) return "active_item";
 }
-/** Builds an attempt result for failures before the app-server turn starts. */
 function buildCodexTurnStartFailureResult(params) {
 	return {
 		terminal: attemptTerminal.normalize({
@@ -4296,7 +4238,6 @@ function buildCodexTurnStartFailureResult(params) {
 		systemPromptReport: params.systemPromptReport
 	};
 }
-/** Detects app-server errors caused by invalid image payload data. */
 function isInvalidCodexImagePayloadError(message) {
 	if (typeof message !== "string" || !message.trim()) return false;
 	const normalizedMessage = message.replace(/[_-]+/gu, " ");
@@ -4325,37 +4266,150 @@ async function settleReplyMedia(activeTurn, result, { state, settlementExpired }
 	if (signal.aborted) await state.abortCleanup;
 }
 //#endregion
-//#region extensions/codex/src/app-server/trajectory.ts
-/** Creates a trajectory recorder when the host exposes its capture capability. */
-function createCodexTrajectoryRecorder(params) {
-	if (!params.trajectory) return null;
-	const trajectory = params.trajectory;
-	return {
-		recordEvent: (type, data) => {
-			try {
-				trajectory.recordEvent(type, data);
-			} catch {}
-		},
-		flush: trajectory.flush
+//#region extensions/codex/src/app-server/run-attempt-settlement.ts
+async function beginCodexAttemptSettlement(resources, turnRuntime, notifications, activeTurn) {
+	const { state: resourceState } = resources;
+	const { connection } = resources.prompt.context.runtime;
+	const { params, runAbortController, appServer } = connection;
+	const { state, deadlines, settlementExpired } = turnRuntime;
+	const { drainNotificationQueue } = notifications;
+	const { activeProjector, activeTurnId } = activeTurn;
+	const drainGraceElapsed = createDeferred();
+	let settlementPhase = "active";
+	let drainGraceTimer;
+	const beginDrainGrace = () => {
+		if (settlementPhase !== "active" || drainGraceTimer) return;
+		drainGraceTimer = setTimeout(() => {
+			settlementPhase = "expired";
+			drainGraceElapsed.resolve();
+		}, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
+		drainGraceTimer.unref?.();
 	};
-}
-/** Records compiled prompt/tool context at the start of a Codex runtime attempt. */
-function recordCodexTrajectoryContext(recorder, params) {
-	if (!recorder) return;
-	recorder.recordEvent("context.compiled", {
-		systemPrompt: params.developerInstructions,
-		prompt: params.prompt ?? params.attempt.prompt,
-		imagesCount: params.attempt.images?.length ?? 0,
-		tools: toTrajectoryToolDefinitions(params.tools)
+	const abortListener = addAbortListener(runAbortController.signal, () => {
+		state.abortCleanup.then(beginDrainGrace, beginDrainGrace);
 	});
+	const closeProjection = () => {
+		state.projectionClosed = true;
+		return activeProjector.closeProjection();
+	};
+	const closeSettlement = () => {
+		if (settlementPhase === "closed") return;
+		settlementPhase = "closed";
+		abortListener[Symbol.dispose]();
+		clearTimeout(drainGraceTimer);
+		deadlines.dispose();
+	};
+	if (state.pluginRuntimeRefreshStop) await state.pluginRuntimeRefreshStop.catch(() => void 0);
+	let readRetainedNativeCommands;
+	return {
+		settlement: drainNotificationQueue().then(async () => {
+			const commands = activeProjector.getPendingNativeCommands();
+			if (commands.size > 0 && !params.oneShotCliRun && !state.pluginRuntimeRefreshStop) {
+				try {
+					const readCurrent = await readCodexRetainedBackgroundCommands({
+						client: resourceState.client,
+						threadId: resourceState.thread.threadId,
+						turnId: activeTurnId,
+						commands,
+						authority: resources.nativeProcessAuthority,
+						assertCurrent: connection.assertCurrent,
+						signal: runAbortController.signal,
+						timeoutMs: appServer.requestTimeoutMs
+					});
+					readRetainedNativeCommands = () => {
+						try {
+							return readCurrent();
+						} catch {
+							return /* @__PURE__ */ new Map();
+						}
+					};
+				} catch (error) {
+					embeddedAgentLog.debug("could not confirm retained native commands", {
+						threadId: resourceState.thread.threadId,
+						error: formatErrorMessage(error)
+					});
+				}
+				await drainNotificationQueue();
+			}
+			await closeProjection();
+			await activeProjector.settlement.drain();
+		}),
+		degradedSettlement: settlementExpired.then(() => {
+			beginDrainGrace();
+		}),
+		drainGraceElapsed,
+		closeProjection,
+		closeSettlement,
+		isActive: () => settlementPhase === "active",
+		readRetainedNativeCommands: () => readRetainedNativeCommands?.() ?? /* @__PURE__ */ new Map()
+	};
 }
-/** Records final Codex model completion metadata and assistant snapshots. */
-function recordCodexTrajectoryCompletion(recorder, params) {
-	if (!recorder) return;
-	const terminal = attemptTerminal.project(params.result.terminal);
-	recorder.recordEvent("model.completed", {
-		threadId: params.threadId,
-		turnId: params.turnId,
+//#endregion
+//#region extensions/codex/src/app-server/run-attempt-state.ts
+async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields, expected) {
+	const currentBinding = bindingStore.read(identity);
+	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
+	if (!expectedThreadId) return;
+	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
+		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
+			...fields,
+			boundThreadId: currentBinding.threadId
+		});
+		return;
+	}
+	if (expected || currentBinding?.connectionScope === "supervision") {
+		embeddedAgentLog.warn("codex app-server image payload error detected for native-owned thread; preserving binding", fields);
+		return;
+	}
+	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
+	await bindingStore.mutate(identity, {
+		kind: "clear",
+		threadId: expectedThreadId
+	});
+}
+function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
+	if (!params.contextEngineActive || params.thread.lifecycle.action !== "resumed") return false;
+	return /context (?:window|length)|maximum context|too many tokens/iu.test(formatErrorMessage(params.error));
+}
+function isCodexActiveCompactTurnError(error) {
+	if (!(error instanceof CodexAppServerRpcError)) return false;
+	const data = isJsonObject(error.data) ? error.data : void 0;
+	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
+	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
+}
+function prependCurrentInboundContext(prompt, context) {
+	const text = context?.text.trim();
+	return text ? [neutralizeCodexExplicitMentionSigils(text), prompt].filter(Boolean).join("\n\n") : prompt;
+}
+//#endregion
+//#region extensions/codex/src/app-server/trajectory.ts
+function createCodexTrajectoryRecorder(params) {
+	if (!params.trajectory) return null;
+	const trajectory = params.trajectory;
+	return {
+		recordEvent: (type, data) => {
+			try {
+				trajectory.recordEvent(type, data);
+			} catch {}
+		},
+		flush: trajectory.flush
+	};
+}
+function recordCodexTrajectoryContext(recorder, params) {
+	if (!recorder) return;
+	recorder.recordEvent("context.compiled", {
+		systemPrompt: params.developerInstructions,
+		prompt: params.prompt ?? params.attempt.prompt,
+		imagesCount: params.attempt.images?.length ?? 0,
+		tools: toTrajectoryToolDefinitions(params.tools)
+	});
+}
+function recordCodexTrajectoryCompletion(recorder, params) {
+	if (!recorder) return;
+	const terminal = attemptTerminal.project(params.result.terminal);
+	recorder.recordEvent("model.completed", {
+		threadId: params.threadId,
+		turnId: params.turnId,
 		timedOut: params.timedOut,
 		yieldDetected: params.yieldDetected ?? false,
 		aborted: terminal.aborted,
@@ -4378,7 +4432,6 @@ function toTrajectoryToolDefinitions(tools) {
 		}];
 	}).toSorted((left, right) => left.name.localeCompare(right.name));
 }
-/** Converts arbitrary prompt errors into trajectory-safe text. */
 function normalizeCodexTrajectoryError(value) {
 	if (!value) return null;
 	if (value instanceof Error) return value.message;
@@ -4395,7 +4448,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded } = resources;
 	const { context, systemPromptReport } = prompt;
 	const { runtime, attemptTools, activeTranscriptTarget, hookContext } = context;
-	const { hookContextWindowFields, hookRunner } = context;
+	const { hookRunner } = context;
 	const { connection, preparedAuthBinding } = runtime;
 	const { effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
 	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, agentDir, attemptStartedAt, startupAuthProfileId } = connection;
@@ -4411,45 +4464,12 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		assertCodexBindingMayBeReplaced(resourceState.thread, operation);
 		return true;
 	};
-	const { state, completion, deadlines, settlementExpired } = turnRuntime;
+	const { state, completion } = turnRuntime;
 	const { emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
-	const { drainNotificationQueue } = notifications;
-	const { codexModelCallDiagnostics } = requestRuntime;
+	const { codexModelCallDiagnostics, buildLlmOutputEvent } = requestRuntime;
 	const { activeTurnId, activeProjector, runtimeModelSelection, streamState, freezeRunTerminalOutcome, notifyUserMessagePersisted } = activeTurn;
 	await completion;
-	const drainGraceElapsed = createDeferred();
-	let settlementPhase = "active";
-	let drainGraceTimer;
-	const beginDrainGrace = () => {
-		if (settlementPhase !== "active" || drainGraceTimer) return;
-		drainGraceTimer = setTimeout(() => {
-			settlementPhase = "expired";
-			drainGraceElapsed.resolve();
-		}, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
-		drainGraceTimer.unref?.();
-	};
-	const abortListener = addAbortListener(runAbortController.signal, () => {
-		state.abortCleanup.then(beginDrainGrace, beginDrainGrace);
-	});
-	const closeProjection = () => {
-		state.projectionClosed = true;
-		return activeProjector.closeProjection();
-	};
-	const closeSettlement = () => {
-		if (settlementPhase === "closed") return;
-		settlementPhase = "closed";
-		abortListener[Symbol.dispose]();
-		clearTimeout(drainGraceTimer);
-		deadlines.dispose();
-	};
-	if (state.pluginRuntimeRefreshStop) await state.pluginRuntimeRefreshStop.catch(() => void 0);
-	const settlement = drainNotificationQueue().then(async () => {
-		await closeProjection();
-		await activeProjector.settlement.drain();
-	});
-	const degradedSettlement = settlementExpired.then(() => {
-		beginDrainGrace();
-	});
+	const { settlement, degradedSettlement, drainGraceElapsed, closeProjection, closeSettlement, isActive: isSettlementActive, readRetainedNativeCommands } = await beginCodexAttemptSettlement(resources, turnRuntime, notifications, activeTurn);
 	let projectionDrained = false;
 	try {
 		try {
@@ -4464,6 +4484,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		}
 		const result = activeProjector.buildResult(toolBridge.telemetry, {
 			yieldDetected: toolState.yieldDetected,
+			readRetainedNativeCommands,
 			steeringMessages: params.pluginRuntimeRefreshPending?.() ? turnRuntime.steeringQueueRef.current?.getAcceptedMessages() : void 0
 		});
 		const projectedTerminal = attemptTerminal.project(result.terminal);
@@ -4578,7 +4599,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			state.pendingSettlementStage = "transcript/mirror";
 			return codexTranscriptMirrorRuntime.mirrorBestEffort({
 				assertWriteCurrent: () => {
-					if (settlementPhase !== "active" || state.settlementWarning !== warning) throw new Error("Codex transcript settlement is no longer active");
+					if (!isSettlementActive() || state.settlementWarning !== warning) throw new Error("Codex transcript settlement is no longer active");
 					const current = projectTerminalOutcome();
 					if (current.finalAborted !== mirrorTerminal.finalAborted || current.effectiveTimedOut !== mirrorTerminal.effectiveTimedOut || current.finalPromptError !== mirrorTerminal.finalPromptError) throw new Error("Codex transcript terminal outcome changed before write");
 				},
@@ -4594,7 +4615,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			});
 		};
 		try {
-			if (projectionDrained && settlementPhase === "active" && !state.settlementWarning) mirrorOutcome = await Promise.race([
+			if (projectionDrained && isSettlementActive() && !state.settlementWarning) mirrorOutcome = await Promise.race([
 				mirrorFinal(),
 				drainGraceElapsed.promise.then(() => unavailableMirror),
 				degradedSettlement.then(() => unavailableMirror)
@@ -4619,7 +4640,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 						message: toolState.yieldMessage,
 						assertCurrent: () => {
 							connection.assertCurrent();
-							if (settlementPhase !== "active" || !projectTerminalOutcome().turnSucceeded) throw new Error("Codex yield settlement is no longer active");
+							if (!isSettlementActive() || !projectTerminalOutcome().turnSucceeded) throw new Error("Codex yield settlement is no longer active");
 						}
 					}),
 					drainGraceElapsed.promise,
@@ -4670,13 +4691,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		});
 		runAgentHarnessLlmOutputHook({
 			event: {
-				runId: params.runId,
-				sessionId: params.sessionId,
-				provider: usesSupervisionConnection ? resourceState.thread.modelProvider ?? effectiveRuntimeProviderId : params.provider,
-				model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId,
-				...hookContextWindowFields,
-				resolvedRef: usesSupervisionConnection ? `${resourceState.thread.modelProvider ?? effectiveRuntimeProviderId}/${resourceState.thread.model ?? effectiveRuntimeModelId}` : params.runtimePlan?.observability.resolvedRef ?? `${params.provider}/${params.modelId}`,
-				...!usesSupervisionConnection && params.runtimePlan?.observability.harnessId ? { harnessId: params.runtimePlan.observability.harnessId } : {},
+				...buildLlmOutputEvent(),
 				assistantTexts: result.assistantTexts,
 				...result.lastAssistant ? { lastAssistant: result.lastAssistant } : {},
 				...result.attemptUsage ? { usage: result.attemptUsage } : {}
@@ -4812,7 +4827,7 @@ function reportCodexExecutionNotification(params) {
 	}
 	if (notification.method !== "item/started") return;
 	const item = readCodexNotificationItem(notification.params);
-	const tool = item ? codexExecutionToolName(item) : void 0;
+	const tool = item ? itemName(item) : void 0;
 	if (!item || !tool) return;
 	params.emitExecutionPhaseOnce(`tool:${item.id}`, {
 		phase: "tool_execution_started",
@@ -4820,10 +4835,6 @@ function reportCodexExecutionNotification(params) {
 		itemId: item.id
 	});
 }
-/** Returns true when a notification ends the current app-server turn. */
-function isTerminalCodexTurnNotificationForTurn(params) {
-	return params.notification.method === "turn/completed" && isCodexNotificationForTurn(params.notification.params, params.threadId, params.turnId) && readCodexTurnCompletedNotification(params.notification.params) !== void 0;
-}
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-lifecycle-terminal.ts
 function buildCodexLifecycleTerminalMeta(input) {
@@ -4905,36 +4916,14 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		state.pendingTerminalDynamicToolRelease = value;
 		scheduleTerminalDynamicToolReleaseCheck();
 	};
-	const emitLifecycleStart = (model) => {
-		emitCodexAppServerEvent(params, {
-			stream: "lifecycle",
-			data: {
-				phase: "start",
-				startedAt: attemptStartedAt
-			}
-		});
-		emitCodexAppServerEvent(params, {
-			stream: "lifecycle",
-			data: {
-				phase: "model",
-				...model
-			}
-		});
-		state.lifecycleStarted = true;
-	};
-	const emitLifecycleTerminal = (data) => {
-		if (!state.lifecycleStarted || state.lifecycleTerminalEmitted || state.permissionChangeRestart || params.pluginRuntimeRefreshPending?.()) return;
-		emitCodexAppServerEvent(params, {
-			stream: "lifecycle",
-			data: {
-				startedAt: attemptStartedAt,
-				endedAt: Date.now(),
-				...data,
-				...params.deferTerminalLifecycle ? { phase: "finishing" } : {}
-			}
-		});
-		state.lifecycleTerminalEmitted = true;
-	};
+	const { emitLifecycleStart, emitLifecycleTerminal, emitExecutionPhaseOnce } = createAgentHarnessAttemptLifecycle({
+		attempt: params,
+		backend: "codex-app-server",
+		startedAtMs: attemptStartedAt,
+		state,
+		emitEvent: (event) => emitCodexAppServerEvent(params, event),
+		shouldSuppressTerminal: () => Boolean(state.permissionChangeRestart || params.pluginRuntimeRefreshPending?.())
+	});
 	const buildLifecycleTerminalMeta = (input) => {
 		const abortFields = input.aborted ? resolveAgentRunAbortLifecycleFields(runAbortController.signal) : void 0;
 		return buildCodexLifecycleTerminalMeta({
@@ -4942,17 +4931,6 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 			abortStopReason: abortFields?.stopReason
 		});
 	};
-	const executionPhaseKeys = /* @__PURE__ */ new Set();
-	const emitExecutionPhaseOnce = (key, info) => {
-		if (executionPhaseKeys.has(key)) return;
-		executionPhaseKeys.add(key);
-		params.onExecutionPhase?.({
-			provider: params.provider,
-			model: params.modelId,
-			backend: "codex-app-server",
-			...info
-		});
-	};
 	const reportExecutionNotification = (notification) => {
 		reportCodexExecutionNotification({
 			notification,
@@ -4990,18 +4968,15 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		fastModeAutoProgressState.offAnnounced = true;
 		await emitFastModeAutoProgress(next);
 	};
-	const maybeEmitFastModeAutoReset = async () => {
-		if (params.fastModeAuto !== true || !fastModeAutoProgressState.offAnnounced || fastModeAutoProgressState.resetAnnounced) return;
-		fastModeAutoProgressState.resetAnnounced = true;
-		await emitFastModeAutoProgress({
-			enabled: true,
-			elapsedSeconds: 0,
-			fastAutoOnSeconds: params.fastModeAutoOnSeconds
-		});
-	};
 	const maybeEmitFastModeAutoResetBestEffort = async () => {
 		try {
-			await maybeEmitFastModeAutoReset();
+			if (params.fastModeAuto !== true || !fastModeAutoProgressState.offAnnounced || fastModeAutoProgressState.resetAnnounced) return;
+			fastModeAutoProgressState.resetAnnounced = true;
+			await emitFastModeAutoProgress({
+				enabled: true,
+				elapsedSeconds: 0,
+				fastAutoOnSeconds: params.fastModeAutoOnSeconds
+			});
 		} catch (error) {
 			embeddedAgentLog.warn(`codex app-server fast mode auto reset progress failed: ${formatErrorMessage(error)}`);
 		}
@@ -5044,11 +5019,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			nativeItemObservers.delete(observe);
 		}
 	};
-	const isTerminalTurnNotificationForTurn = (notification, notificationTurnId) => isTerminalCodexTurnNotificationForTurn({
-		notification,
-		threadId: resourceState.thread.threadId,
-		turnId: notificationTurnId
-	});
+	const readTerminalTurn = (notification, notificationTurnId) => notification.method === "turn/completed" && isCodexNotificationForTurn(notification.params, resourceState.thread.threadId, notificationTurnId) ? readCodexTurnCompletedNotification(notification.params)?.turn : void 0;
 	const handleNotification = async (notification) => {
 		if (state.projectionClosed) return;
 		const projector = projectorRef.current;
@@ -5058,8 +5029,8 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			return;
 		}
 		const isCurrentTurn = isCodexNotificationForTurn(notification.params, resourceState.thread.threadId, turnId);
-		const isTerminal = isTerminalTurnNotificationForTurn(notification, turnId);
-		if ((state.timeout || state.localCompletionRequested) && isTerminal && readCodexTurnCompletedNotification(notification.params)?.turn.status === "interrupted") {
+		const completedTurn = readTerminalTurn(notification, turnId);
+		if ((state.timeout || state.localCompletionRequested) && completedTurn?.status === "interrupted") {
 			completeTurn();
 			return;
 		}
@@ -5076,7 +5047,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 				if (notification.method === "item/completed") {
 					if (activeTurnItemIds.size === 0) scheduleTerminalDynamicToolReleaseCheck();
 					const item = readCodexNotificationItem(notification.params);
-					if (item?.type === "dynamicToolCall" && typeof item.id === "string") {
+					if (item?.type === "dynamicToolCall") {
 						const response = await openClawDynamicToolExecutions.get({
 							threadId: resourceState.thread.threadId,
 							turnId,
@@ -5099,11 +5070,11 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			state.activeLocalProjections -= 1;
 			if (isCurrentTurn && notification.method === "item/completed") {
 				const item = readCodexNotificationItem(notification.params);
-				if (item?.type === "commandExecution" && typeof item.id === "string") pendingNativeCommandItems.delete(item.id);
+				if (item?.type === "commandExecution") pendingNativeCommandItems.delete(item.id);
 			}
 			for (const observe of nativeItemObservers) observe();
-			if (isTerminal) {
-				if ((readCodexTurnCompletedNotification(notification.params)?.turn)?.status === "interrupted" && state.sawCodexInterruptMarker) projector.markAborted();
+			if (completedTurn) {
+				if (completedTurn.status === "interrupted" && state.sawCodexInterruptMarker) projector.markAborted();
 				completeTurn();
 			}
 		}
@@ -5129,9 +5100,9 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 		const turnId = turnIdRef.current;
 		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;
+		const completedTurn = readTerminalTurn(notification, turnId);
+		if (completedTurn) {
+			projector.settlement.terminalReceipt = completedTurn;
 			state.terminalTurnNotificationQueued = true;
 			steeringQueueRef.current?.sealAdmission();
 			deadlines.beginSettlement(receivedAtMs);
@@ -5140,7 +5111,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 			const modelToolCallId = readRawResponseToolCallId(notification);
 			if (modelToolCallId) allocateCodexToolOutcomeOrdinal?.(modelToolCallId);
 			const nativeItem = readCodexNotificationItem(notification.params);
-			if (notification.method === "item/started" && nativeItem?.type === "commandExecution" && typeof nativeItem.id === "string") pendingNativeCommandItems.add(nativeItem.id);
+			if (notification.method === "item/started" && nativeItem?.type === "commandExecution") pendingNativeCommandItems.add(nativeItem.id);
 			if (nativeItem?.type === "webSearch") {
 				projector.settlement.turnTainted ||= notification.method === "item/completed";
 				projector.recordNativeToolOutcome(nativeItem);
@@ -5167,12 +5138,9 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-prompt.ts
-function isRestrictivePromptToolsAllow(toolsAllow) {
-	return toolsAllow !== void 0 && !toolsAllow.some((name) => name.trim() === "*");
-}
 async function prepareCodexAttemptPrompt(context) {
-	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, buildOpenClawPromptContext, skillsCollaborationInstructions, promptState, codexContextProjectionMaxChars, codexContinuityProjectionMaxChars } = context;
-	const { connection, buildActiveRunAttemptParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
+	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, buildOpenClawPromptContext, skillsInstructions, promptState, codexContextProjectionMaxChars, codexContinuityProjectionMaxChars } = context;
+	const { connection, runtimeParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
 	const { params, activeContextEngine, usesSupervisionConnection, mutable, isInactiveThreadBootstrapBinding, bindingStore, bindingIdentity, agentDir, appServer, contextSessionKey, effectiveWorkspace, sandbox } = connection;
 	const { toolBridge } = attemptTools;
 	const nativeHistoryProvenancePrefix = params.trigger === "user" ? buildCodexHistoryProvenancePrefix(params) : void 0;
@@ -5190,6 +5158,12 @@ async function prepareCodexAttemptPrompt(context) {
 		connection.assertCurrent();
 		connection.runAbortController.signal.throwIfAborted();
 	};
+	const inputAttachmentNote = await connection.prepareInputAttachments({
+		maxChars: Math.max(0, CODEX_TURN_START_TEXT_INPUT_MAX_CHARS - (nativeHistoryProvenancePrefix?.length ?? 0) - params.prompt.length - 2),
+		assertCurrent: assertProjectionCurrent,
+		signal: connection.runAbortController.signal
+	});
+	assertProjectionCurrent();
 	const admittedMessage = params.userTurnTranscriptRecorder?.message ?? await params.userTurnTranscriptRecorder?.resolveMessage();
 	assertProjectionCurrent();
 	const currentUserTurnIdempotencyKey = params.pluginRuntimeRefreshMessages ? void 0 : admittedMessage?.idempotencyKey;
@@ -5215,7 +5189,6 @@ async function prepareCodexAttemptPrompt(context) {
 	const applyContinuityProjection = async (messages) => {
 		const projection = await projectContextEngineAssemblyForCodex({
 			assembledMessages: messages,
-			originalHistoryMessages: historyState.messages,
 			prompt: params.prompt,
 			maxRenderedContextChars: codexContinuityProjectionMaxChars,
 			toolPayloadMode: params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
@@ -5226,107 +5199,97 @@ async function prepareCodexAttemptPrompt(context) {
 		contextImageGroups = projection.imageGroups ?? [];
 		promptState.promptText = projection.promptText;
 		promptState.promptContextRange = projection.promptContextRange;
-		promptState.prePromptMessageCount = projection.prePromptMessageCount;
 		promptState.noEngineContinuityProjectionApplied = true;
 	};
 	const applyActiveContextEngineProjection = async (decisionStartupBinding) => {
 		if (!activeContextEngine) return;
-		const assembled = await assembleHarnessContextEngine({
-			contextEngine: activeContextEngine,
-			sessionId: runtime.activeSessionId,
-			sessionKey: contextSessionKey,
-			messages: historyState.messages,
-			tokenBudget: effectiveContextTokenBudget,
-			availableTools: new Set(flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString)),
-			citationsMode: params.config?.memory?.citations,
-			sandboxed: sandbox?.enabled === true,
-			modelId: effectiveRuntimeModelId,
-			contextEngineHostSupport: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST,
-			providerId: effectiveRuntimeProviderId,
-			requestedModelId: usesSupervisionConnection ? void 0 : params.requestedModelId,
-			fallbackReason: usesSupervisionConnection ? void 0 : params.fallbackReason,
-			degradedReason: usesSupervisionConnection ? void 0 : params.degradedReason,
-			runtimeContext: buildActiveContextEngineRuntimeContext(),
-			transcriptReadFence: params.userTurnTranscriptRecorder?.getAdmissionReceipt(),
-			prompt: params.prompt
-		});
-		if (!assembled) throw new Error("context engine assemble returned no result");
-		const contextEngineProjection = readContextEngineThreadBootstrapProjection(assembled.contextProjection);
-		const projectionDecision = contextEngineProjection ? resolveContextEngineBootstrapProjectionDecision({
-			startupBinding: decisionStartupBinding,
-			expectedBinding: buildContextEngineBinding(buildActiveRunAttemptParams(), contextEngineProjection),
-			projection: contextEngineProjection,
-			dynamicToolsFingerprint: codexDynamicToolsFingerprint(toolBridge.specs),
-			legacyDynamicToolsFingerprint: codexLegacyDynamicToolsFingerprint(toolBridge.specs)
-		}) : {
-			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 || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
-			...projectionDecision.project ? { prepareFileContext } : {},
-			currentUserTurnIdempotencyKey
-		});
-		assertProjectionCurrent();
-		contextImageGroups = projectionDecision.project ? projection.imageGroups ?? [] : [];
-		const decisionBinding = decisionStartupBinding;
-		embeddedAgentLog.info("codex app-server context-engine projection decision", {
-			sessionId: params.sessionId,
-			sessionKey: contextSessionKey,
-			engineId: activeContextEngine.info.id,
-			mode: contextEngineProjection?.mode ?? assembled.contextProjection?.mode ?? "per_turn",
-			epoch: contextEngineProjection?.epoch,
-			fingerprint: contextEngineProjection?.fingerprint,
-			previousThreadId: decisionBinding?.threadId,
-			previousEpoch: decisionBinding?.contextEngine?.projection?.epoch,
-			previousFingerprint: decisionBinding?.contextEngine?.projection?.fingerprint,
-			projected: projectionDecision.project,
-			reason: projectionDecision.reason,
-			assembledMessages: assembled.messages.length,
-			originalHistoryMessages: historyState.messages.length,
-			projectedPromptChars: projection.promptText.length,
-			developerInstructionAdditionChars: projection.developerInstructionAddition?.length ?? 0
-		});
-		promptState.contextEngineProjection = contextEngineProjection;
-		promptState.promptText = projectionDecision.project ? projection.promptText : params.prompt;
-		promptState.promptContextRange = projectionDecision.project ? projection.promptContextRange : void 0;
-		promptState.developerInstructions = joinPresentSections(baseDeveloperInstructions, projection.developerInstructionAddition);
-		promptState.prePromptMessageCount = projection.prePromptMessageCount;
-	};
-	if (activeContextEngine) try {
-		await applyActiveContextEngineProjection(runtime.nativeToolSurfaceEnabled ? mutable.startupBinding : void 0);
-	} catch (assembleErr) {
-		if (assembleErr instanceof CodexContextAttachmentError || params.pluginRuntimeRefreshMessages) throw assembleErr;
-		assertProjectionCurrent();
-		embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
-	}
-	const codexModelInputHistoryMessages = [];
-	const admittedContent = admittedMessage?.content;
-	const currentUserMessage = admittedMessage ? typeof admittedContent === "string" ? admittedContent : (admittedContent ?? []).flatMap((part) => part.type === "text" ? [part.text] : []).join("\n") : params.pluginRuntimeRefreshMessages ? "" : params.prompt;
-	const buildPromptFromCurrentInputs = async () => {
-		return await resolveAgentHarnessBeforePromptBuildResult({
-			currentUserMessage,
-			currentUserMessageId: admittedMessage?.idempotencyKey,
-			prompt: prependCurrentInboundContext(promptState.promptText, params.currentInboundContext),
-			developerInstructions: { build: ({ toolsAllow }) => {
-				if (isRestrictivePromptToolsAllow(toolsAllow)) throw new Error("Codex app-server cannot enforce before_prompt_build toolsAllow; use the embedded or Copilot runtime for turn-scoped tool policy.");
-				return promptState.developerInstructions;
-			} },
-			messages: historyState.messages,
-			ctx: hookContext,
-			bootstrapContextRunKind: params.bootstrapContextRunKind,
-			toolAuthority: {
-				fingerprint: params.toolAuthorityFingerprint,
-				activeToolNames: () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString),
-				assertActive: connection.assertCurrent
-			}
-		});
+		try {
+			const assembled = await assembleHarnessContextEngine({
+				contextEngine: activeContextEngine,
+				sessionId: runtimeParams.sessionId,
+				sessionKey: contextSessionKey,
+				messages: historyState.messages,
+				tokenBudget: effectiveContextTokenBudget,
+				availableTools: new Set(flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString)),
+				citationsMode: params.config?.memory?.citations,
+				sandboxed: sandbox?.enabled === true,
+				modelId: effectiveRuntimeModelId,
+				contextEngineHostSupport: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST,
+				providerId: effectiveRuntimeProviderId,
+				requestedModelId: usesSupervisionConnection ? void 0 : params.requestedModelId,
+				fallbackReason: usesSupervisionConnection ? void 0 : params.fallbackReason,
+				degradedReason: usesSupervisionConnection ? void 0 : params.degradedReason,
+				runtimeContext: buildActiveContextEngineRuntimeContext(),
+				transcriptReadFence: params.userTurnTranscriptRecorder?.getAdmissionReceipt(),
+				prompt: params.prompt
+			});
+			if (!assembled) throw new Error("context engine assemble returned no result");
+			const contextEngineProjection = readContextEngineThreadBootstrapProjection(assembled.contextProjection);
+			const projectionDecision = contextEngineProjection ? resolveContextEngineBootstrapProjectionDecision({
+				startupBinding: decisionStartupBinding,
+				expectedBinding: buildContextEngineBinding({ ...runtimeParams }, contextEngineProjection),
+				projection: contextEngineProjection,
+				dynamicToolsFingerprint: codexDynamicToolsFingerprint(toolBridge.specs),
+				legacyDynamicToolsFingerprint: codexLegacyDynamicToolsFingerprint(toolBridge.specs)
+			}) : {
+				project: true,
+				reason: "per-turn-projection"
+			};
+			const projection = await projectContextEngineAssemblyForCodex({
+				assembledMessages: assembled.messages,
+				prompt: params.prompt,
+				systemPromptAddition: assembled.systemPromptAddition,
+				maxRenderedContextChars: codexContextProjectionMaxChars,
+				toolPayloadMode: contextEngineProjection || params.pluginRuntimeRefreshMessages || preserveForkedToolResults ? "preserve" : "elide",
+				...projectionDecision.project ? { prepareFileContext } : {},
+				currentUserTurnIdempotencyKey
+			});
+			assertProjectionCurrent();
+			contextImageGroups = projectionDecision.project ? projection.imageGroups ?? [] : [];
+			embeddedAgentLog.info("codex app-server context-engine projection decision", {
+				sessionId: params.sessionId,
+				sessionKey: contextSessionKey,
+				engineId: activeContextEngine.info.id,
+				mode: contextEngineProjection?.mode ?? assembled.contextProjection?.mode ?? "per_turn",
+				epoch: contextEngineProjection?.epoch,
+				fingerprint: contextEngineProjection?.fingerprint,
+				previousThreadId: decisionStartupBinding?.threadId,
+				previousEpoch: decisionStartupBinding?.contextEngine?.projection?.epoch,
+				previousFingerprint: decisionStartupBinding?.contextEngine?.projection?.fingerprint,
+				projected: projectionDecision.project,
+				reason: projectionDecision.reason,
+				assembledMessages: assembled.messages.length,
+				originalHistoryMessages: historyState.messages.length,
+				projectedPromptChars: projection.promptText.length,
+				developerInstructionAdditionChars: projection.developerInstructionAddition?.length ?? 0
+			});
+			promptState.contextEngineProjection = contextEngineProjection;
+			promptState.promptText = projectionDecision.project ? projection.promptText : params.prompt;
+			promptState.promptContextRange = projectionDecision.project ? projection.promptContextRange : void 0;
+			promptState.developerInstructions = joinPresentSections(baseDeveloperInstructions, projection.developerInstructionAddition);
+		} catch (assembleErr) {
+			if (assembleErr instanceof CodexContextAttachmentError || params.pluginRuntimeRefreshMessages) throw assembleErr;
+			assertProjectionCurrent();
+			embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
+		}
 	};
+	if (activeContextEngine) await applyActiveContextEngineProjection(runtime.nativeToolSurfaceEnabled ? mutable.startupBinding : void 0);
+	const buildPromptFromCurrentInputs = () => resolveAgentHarnessBeforePromptBuildResult({
+		currentUserMessage: admittedMessage ?? (params.pluginRuntimeRefreshMessages ? "" : params.prompt),
+		prompt: prependCurrentInboundContext(promptState.promptText, params.currentInboundContext),
+		developerInstructions: { build: ({ hasToolRestrictions }) => {
+			if (hasToolRestrictions) throw new Error("Codex app-server cannot enforce before_prompt_build toolsAllow; use the embedded or Copilot runtime for turn-scoped tool policy.");
+			return promptState.developerInstructions;
+		} },
+		messages: historyState.messages,
+		ctx: hookContext,
+		bootstrapContextRunKind: params.bootstrapContextRunKind,
+		toolAuthority: {
+			fingerprint: params.toolAuthorityFingerprint,
+			activeToolNames: () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString),
+			assertActive: connection.assertCurrent
+		}
+	});
 	const resolveShiftedPromptInputRange = (prompt, promptInputRange, turnPromptText) => {
 		if (!promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !turnPromptText.endsWith(prompt)) return;
 		const turnPromptOffset = turnPromptText.length - prompt.length;
@@ -5362,9 +5325,12 @@ async function prepareCodexAttemptPrompt(context) {
 			decoratedPrompt: turnPromptText
 		});
 		const imageOffset = projectedRanges && promptState.promptContextRange ? projectedRanges.contextRange.start - promptState.promptContextRange.start : void 0;
+		const inputLimit = CODEX_TURN_START_TEXT_INPUT_MAX_CHARS - (nativeHistoryProvenancePrefix?.length ?? 0);
+		const requiredInputChars = turnPromptText.length - (projectedRanges ? projectedRanges.contextRange.end - projectedRanges.contextRange.start : 0);
+		const attachmentNote = inputAttachmentNote && requiredInputChars + inputAttachmentNote.length + 2 <= inputLimit ? inputAttachmentNote : void 0;
 		const fitted = fitCodexProjectedContextForTurnStart({
 			promptText: turnPromptText,
-			maxChars: CODEX_TURN_START_TEXT_INPUT_MAX_CHARS - (nativeHistoryProvenancePrefix?.length ?? 0),
+			maxChars: inputLimit - (attachmentNote ? attachmentNote.length + 2 : 0),
 			contextRange: projectedRanges?.contextRange,
 			requestRange: projectedRanges?.requestRange,
 			preservedRange,
@@ -5375,7 +5341,7 @@ async function prepareCodexAttemptPrompt(context) {
 			}))
 		});
 		turnContextImageGroups = fitted.imageGroups ?? [];
-		return fitted.promptText;
+		return attachmentNote ? `${fitted.promptText}\n\n${attachmentNote}` : fitted.promptText;
 	};
 	const firstPromptBuild = await buildPromptFromCurrentInputs();
 	const turnState = {
@@ -5385,10 +5351,12 @@ async function prepareCodexAttemptPrompt(context) {
 	let parentLocalEgress = false;
 	const parentLocalContext = {
 		turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
-		skillsCollaborationInstructions,
 		memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
 	};
-	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, (parentLocalEgress ? buildCodexParentLocalInstructions(params, parentLocalContext) : buildTurnCollaborationMode(params, parentLocalContext).settings.developer_instructions) ?? void 0);
+	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, parentLocalEgress ? void 0 : skillsInstructions, (parentLocalEgress ? buildCodexParentLocalInstructions(params, {
+		...parentLocalContext,
+		skillsInstructions
+	}) : buildTurnCollaborationMode(params, parentLocalContext).settings.developer_instructions) ?? void 0);
 	const rebuildCodexPromptBuildFromCurrentProjection = async () => {
 		turnState.promptBuild = await buildPromptFromCurrentInputs();
 		turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild);
@@ -5472,13 +5440,7 @@ async function prepareCodexAttemptPrompt(context) {
 		if (promptState.staleBindingContinuityForcedFreshStart) await applyContinuityProjection(historyState.messages);
 		if (activeContextEngine) {
 			promptState.contextEngineProjection = void 0;
-			try {
-				await applyActiveContextEngineProjection(void 0);
-			} catch (assembleErr) {
-				if (assembleErr instanceof CodexContextAttachmentError || params.pluginRuntimeRefreshMessages) throw assembleErr;
-				assertProjectionCurrent();
-				embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
-			}
+			await applyActiveContextEngineProjection(void 0);
 		}
 		await rebuildCodexPromptBuildFromCurrentProjection();
 		embeddedAgentLog.info("codex app-server rebuilt turn prompt after native thread rotation", {
@@ -5497,7 +5459,7 @@ async function prepareCodexAttemptPrompt(context) {
 		developerInstructions: buildRenderedCodexDeveloperInstructions(),
 		workspaceBootstrapContext,
 		omitWorkspaceReferences,
-		skillsPrompt: skillsCollaborationInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
+		skillsPrompt: skillsInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
 		tools: toolBridge.availableSpecs
 	});
 	const systemPromptReport = buildSystemPromptReport();
@@ -5507,7 +5469,6 @@ async function prepareCodexAttemptPrompt(context) {
 		get contextImageGroups() {
 			return turnContextImageGroups;
 		},
-		codexModelInputHistoryMessages,
 		nativeHistoryProvenancePrefix,
 		turnState,
 		refreshWorkspaceReferences: (include) => {
@@ -5542,6 +5503,39 @@ function buildCodexHookRequester(params) {
 	return Object.keys(requester).length > 0 ? requester : void 0;
 }
 //#endregion
+//#region extensions/codex/src/app-server/native-subagent-assignment-store.ts
+function createNativeSubagentAssignmentStore(params) {
+	const { bindingStore, identity, owner } = params;
+	const assertCurrent = () => {
+		params.assertLifecycleCurrent?.();
+		const binding = bindingStore.read(identity);
+		if (!binding || !matchesCodexNativeSubagentSubmissionBinding(binding, owner)) throw new Error("Native assignment binding is no longer current.");
+	};
+	return {
+		assertCurrent,
+		read: () => {
+			assertCurrent();
+			return bindingStore.readNativeSubagentAssignments?.(identity, owner) ?? [];
+		},
+		record: (assignment, assertSourceCurrent) => bindingStore.mutate(identity, {
+			kind: "record-native-subagent-assignment",
+			owner,
+			assignment
+		}, () => {
+			assertCurrent();
+			assertSourceCurrent();
+		}),
+		consume: (assignment, assertSourceCurrent) => bindingStore.mutate(identity, {
+			kind: "consume-native-subagent-assignment",
+			owner,
+			assignment
+		}, () => {
+			assertCurrent();
+			assertSourceCurrent();
+		})
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-resources.ts
 function prepareCodexAttemptResources(prompt) {
 	const { context, turnState, buildRenderedCodexDeveloperInstructions } = prompt;
@@ -5549,6 +5543,13 @@ function prepareCodexAttemptResources(prompt) {
 	const { connection, hookChannelId } = runtime;
 	const { appServer, params, effectiveCwd, sessionAgentId, contextSessionKey, runAbortController, sandbox, options, nativeHookRelayEvents } = connection;
 	const { toolBridge } = attemptTools;
+	const modelAdmissionSource = runtime.nativeToolSurfaceEnabled ? params.hostCapabilities.retainSourceAuthority?.() : void 0;
+	let nativeModelAdmission;
+	try {
+		nativeModelAdmission = modelAdmissionSource ? modelAdmissionSource.modelPolicyRequired !== false ? "required" : options.nativeHookRelay?.enabled === false ? "disabled" : "optional" : void 0;
+	} finally {
+		modelAdmissionSource?.release();
+	}
 	let nativeProcessAuthorityReleased = false;
 	const releaseNativeProcessAuthority = () => {
 		if (!nativeProcessAuthorityReleased) {
@@ -5576,8 +5577,6 @@ function prepareCodexAttemptResources(prompt) {
 		nativeHookRelay: void 0,
 		nativeSubagentMonitor: void 0,
 		runtimeContinuationStarted: false,
-		nativePreToolUseFailureFallbackActive: false,
-		nativePreToolUseFailureFallbackTerminalReason: void 0,
 		releaseSharedClientLease: void 0,
 		startupClientUnsafe: false,
 		turnStartAttempted: false,
@@ -5590,29 +5589,14 @@ function prepareCodexAttemptResources(prompt) {
 		codexSandboxPolicy: void 0,
 		restartContextEngineCodexThread: void 0
 	};
-	const pendingNativePreToolUseFailures = [];
 	const projectorRef = {};
-	const emitNativePreToolUseFailure = (failure) => {
-		emitCodexNativePreToolUseFailureDiagnostic({
-			agentId: sessionAgentId,
-			sessionId: params.sessionId,
-			sessionKey: contextSessionKey,
-			runId: params.runId,
-			signal: runAbortController.signal,
-			failure,
-			...state.nativePreToolUseFailureFallbackActive ? { terminalReason: state.nativePreToolUseFailureFallbackTerminalReason ?? failure.disposition } : {}
-		});
-	};
-	const flushPendingNativePreToolUseFailures = () => {
-		for (const failure of pendingNativePreToolUseFailures.splice(0)) emitNativePreToolUseFailure(failure);
-	};
-	const activateNativePreToolUseFailureFallback = () => {
-		if (!state.nativePreToolUseFailureFallbackActive) {
-			state.nativePreToolUseFailureFallbackTerminalReason = runAbortController.signal.aborted ? resolveCodexToolAbortTerminalReason(runAbortController.signal) : void 0;
-			state.nativePreToolUseFailureFallbackActive = true;
-		}
-		flushPendingNativePreToolUseFailures();
-	};
+	const nativePreToolUseFailures = createCodexNativePreToolUseFailureBuffer({
+		agentId: sessionAgentId,
+		sessionId: params.sessionId,
+		sessionKey: contextSessionKey,
+		runId: params.runId,
+		signal: runAbortController.signal
+	});
 	const releaseSharedClientLeaseOnce = () => {
 		const release = state.releaseSharedClientLease;
 		if (!release) return;
@@ -5672,15 +5656,19 @@ function prepareCodexAttemptResources(prompt) {
 		}
 	});
 	let nativeSubagentMonitorSettlement;
+	let nativeSubagentMonitorGeneration = 0;
 	const unregisterNativeSubagentMonitor = async () => {
+		nativeSubagentMonitorGeneration += 1;
 		const registration = state.nativeSubagentMonitor;
 		state.nativeSubagentMonitor = void 0;
 		if (registration) nativeSubagentMonitorSettlement = registration.unregister();
 		await nativeSubagentMonitorSettlement;
 	};
 	const registerNativeSubagentMonitor = async (parentThreadId) => {
+		const { client, thread, nativeHookRelay, turnRoute } = state;
 		await unregisterNativeSubagentMonitor();
 		connection.assertCurrent();
+		const generation = ++nativeSubagentMonitorGeneration;
 		const sessionKey = params.sessionKey;
 		const storePath = params.sessionTarget?.storePath;
 		const parentSession = sessionKey && storePath ? getSessionEntry({
@@ -5694,22 +5682,25 @@ function prepareCodexAttemptResources(prompt) {
 			parentThreadId,
 			sessionId: params.sessionId,
 			...parentSession?.sessionId === params.sessionId ? { lifecycleRevision: parentSession.lifecycleRevision } : {},
-			binding: state.thread
+			binding: thread
 		});
 		const { bindingStore, bindingIdentity } = connection;
-		const submissionStore = historyOwner ? {
+		const assertParentSessionCurrent = () => {
+			if (historyOwner?.lifecycleRevision && sessionKey && storePath) {
+				if (getSessionEntry({
+					agentId: sessionAgentId,
+					sessionKey,
+					storePath,
+					readConsistency: "latest",
+					hydrateSkillPromptRefs: false
+				})?.lifecycleRevision !== historyOwner.lifecycleRevision) throw new Error("Native submission session lifecycle is no longer current.");
+			}
+		};
+		const submissionStore = historyOwner && thread.lifecycle.preserveExistingBinding !== true ? {
 			assertCurrent: () => {
 				const current = bindingStore.read(bindingIdentity);
 				if (!current || !matchesCodexNativeSubagentSubmissionBinding(current, historyOwner)) throw new Error("Native submission binding is no longer current.");
-				if (historyOwner.lifecycleRevision && sessionKey && storePath) {
-					if (getSessionEntry({
-						agentId: sessionAgentId,
-						sessionKey,
-						storePath,
-						readConsistency: "latest",
-						hydrateSkillPromptRefs: false
-					})?.lifecycleRevision !== historyOwner.lifecycleRevision) throw new Error("Native submission session lifecycle is no longer current.");
-				}
+				assertParentSessionCurrent();
 			},
 			read: () => bindingStore.readNativeSubagentSubmissions(bindingIdentity, historyOwner),
 			record: (receipt, assertCurrent) => bindingStore.mutate(bindingIdentity, {
@@ -5723,22 +5714,60 @@ function prepareCodexAttemptResources(prompt) {
 				receipt
 			}, assertCurrent)
 		} : void 0;
-		state.nativeSubagentMonitor = codexNativeSubagentMonitorRuntime.register({
-			client: state.client,
-			parentThreadId,
-			requesterSessionKey: params.sessionKey,
-			taskRuntimeScope: params.agentHarnessTaskRuntimeScope,
-			historyOwner,
-			submissionStore,
-			agentId: sessionAgentId,
-			retainClient: () => retainSharedCodexAppServerClientIfCurrent(state.client),
-			retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(state.client, protectedThreadId),
-			claimDirectChild: (childThreadId) => state.nativeHookRelay?.claimDirectChild(childThreadId),
-			rejectPendingDirectChild: (childThreadId, reason) => state.nativeHookRelay?.rejectPendingDirectChild(childThreadId, reason),
-			...params.sessionKey && params.agentHarnessTaskRuntimeScope ? { onDirectChildAccepted: () => {
-				state.runtimeContinuationStarted = true;
-			} } : {}
-		});
+		const assignmentStore = historyOwner && submissionStore ? createNativeSubagentAssignmentStore({
+			bindingStore,
+			identity: bindingIdentity,
+			owner: historyOwner,
+			assertLifecycleCurrent: () => submissionStore.assertCurrent()
+		}) : void 0;
+		const assertRegistrationCurrent = () => {
+			runAbortController.signal.throwIfAborted();
+			params.hostCapabilities.assertActive();
+			connection.assertCurrent();
+			if (submissionStore) submissionStore.assertCurrent();
+			else assertParentSessionCurrent();
+			thread.liveThreadOwnership?.assertCurrent();
+			if (generation !== nativeSubagentMonitorGeneration || state.client !== client || state.thread !== thread || state.nativeHookRelay !== nativeHookRelay || state.turnRoute !== turnRoute) throw new Error("Codex native subagent registration was superseded during setup");
+		};
+		const retainModelSource = params.hostCapabilities.retainSourceAuthority;
+		const modelSource = retainModelSource?.();
+		try {
+			const configurationQualification = getCodexInferenceThreadQualification(client, parentThreadId);
+			const registration = await codexNativeSubagentMonitorRuntime.register({
+				client,
+				parentThreadId,
+				...retainModelSource ? { modelSource } : {},
+				configurationQualification,
+				unqualifiedModelExecution: modelSource && !configurationQualification ? true : void 0,
+				onUnqualifiedModelCancelled: connection.abortExplicitly,
+				requesterSessionKey: params.sessionKey,
+				completionScope: params.agentHarnessCompletionScope,
+				historyOwner,
+				submissionStore,
+				assignmentStore,
+				agentId: sessionAgentId,
+				assertCurrent: assertRegistrationCurrent,
+				isTurnYielded: () => attemptTools.toolState.yieldDetected,
+				retainClient: () => retainSharedCodexAppServerClientIfCurrent(client),
+				retainParentThread: (protectedThreadId) => protectCodexAppServerLiveThread(client, protectedThreadId),
+				claimDirectChild: (childThreadId) => nativeHookRelay?.claimDirectChild(childThreadId),
+				rejectPendingDirectChild: (childThreadId, reason) => nativeHookRelay?.rejectPendingDirectChild(childThreadId, reason),
+				...params.sessionKey && params.agentHarnessCompletionScope ? { onDirectChildAccepted: () => {
+					state.runtimeContinuationStarted = true;
+				} } : {}
+			});
+			try {
+				await registration.ready;
+				assertRegistrationCurrent();
+				state.nativeSubagentMonitor = registration;
+			} catch (error) {
+				await registration.unregister();
+				throw error;
+			}
+		} catch (error) {
+			modelSource?.release();
+			throw error;
+		}
 	};
 	const releaseCurrentRoute = async () => {
 		state.releaseInferenceContext?.();
@@ -5804,7 +5833,7 @@ function prepareCodexAttemptResources(prompt) {
 		return released;
 	};
 	const cleanupBeforeActiveTurn = async () => {
-		await runCleanupStep("codex-pre-turn-hook-fallback", activateNativePreToolUseFailureFallback);
+		await runCleanupStep("codex-pre-turn-hook-fallback", () => nativePreToolUseFailures.activateFallback(runAbortController.signal.aborted));
 		await runCleanupStep("codex-pre-turn-subscription", async () => {
 			const { thread } = state;
 			if (!thread || subscriptionSettlement?.thread === thread || state.startupClientUnsafe) return;
@@ -5843,8 +5872,10 @@ function prepareCodexAttemptResources(prompt) {
 		previousRelay?.unregister();
 		await previousRelay?.drain();
 		connection.assertCurrent();
-		const requiresProcessAdmission = nativeProcessAuthority && runtime.nativeToolSurfaceEnabled;
-		const relayEvents = requiresProcessAdmission && !nativeHookRelayEvents.includes("pre_tool_use") ? [...nativeHookRelayEvents, "pre_tool_use"] : nativeHookRelayEvents;
+		const requiresProcessAdmission = nativeProcessAuthority?.requiresProcessAdmission && runtime.nativeToolSurfaceEnabled;
+		const requiresModelAdmission = nativeModelAdmission !== void 0 && decision.nativeModelInputTools !== void 0;
+		const requiresExecutionAdmission = requiresProcessAdmission || requiresModelAdmission;
+		const relayEvents = requiresExecutionAdmission && !nativeHookRelayEvents.includes("pre_tool_use") ? [...nativeHookRelayEvents, "pre_tool_use"] : nativeHookRelayEvents;
 		if (params.pluginHarnessToolPolicyRestricted === true) {
 			state.nativeHookRelay = void 0;
 			return {
@@ -5853,7 +5884,7 @@ function prepareCodexAttemptResources(prompt) {
 			};
 		}
 		state.nativeHookRelay = createCodexNativeHookRelay({
-			options: requiresProcessAdmission ? {
+			options: requiresExecutionAdmission ? {
 				...options.nativeHookRelay,
 				enabled: true
 			} : options.nativeHookRelay,
@@ -5887,12 +5918,17 @@ function prepareCodexAttemptResources(prompt) {
 				owner: nativeProcessAuthority,
 				client: () => state.client
 			} : void 0,
+			nativeModelAdmission: requiresModelAdmission ? {
+				client: () => state.client,
+				threadId: () => state.thread?.threadId,
+				tools: decision.nativeModelInputTools,
+				readQualification: (threadId) => getCodexInferenceThreadQualification(state.client, threadId)
+			} : void 0,
 			assertCurrent: connection.assertCurrent,
 			onPreToolUseFailure: (failure) => {
 				const projector = projectorRef.current;
 				if (projector) projector.recordNativeToolPreToolUseFailure(failure);
-				else if (state.nativePreToolUseFailureFallbackActive) emitNativePreToolUseFailure(failure);
-				else pendingNativePreToolUseFailures.push(failure);
+				else nativePreToolUseFailures.record(failure);
 			}
 		});
 		await state.nativeHookRelay?.prepareInvocation();
@@ -5906,7 +5942,7 @@ function prepareCodexAttemptResources(prompt) {
 			nativeHookRelayGeneration: state.nativeHookRelay?.generation
 		};
 	};
-	const nativeProcessAuthority = sandbox?.enabled && sandbox.backend && params.hostCapabilities.retainSourceAuthority ? new CodexNativeProcessAuthority(params.hostCapabilities, (error) => {
+	const nativeProcessAuthority = params.hostCapabilities.retainSourceAuthority ? new CodexNativeProcessAuthority(params.hostCapabilities, (error) => {
 		const message = formatErrorMessage(error);
 		embeddedAgentLog.warn("codex native background work remains unsettled", {
 			runId: params.runId,
@@ -5920,20 +5956,19 @@ function prepareCodexAttemptResources(prompt) {
 				error: message
 			}
 		});
-	}) : void 0;
+	}, Boolean(sandbox?.enabled && sandbox.backend)) : void 0;
 	return {
 		prompt,
 		trajectoryRecorder,
 		state,
 		projectorRef,
-		pendingNativePreToolUseFailures,
+		pendingNativePreToolUseFailures: nativePreToolUseFailures.pending,
+		nativeModelAdmission,
 		nativeProcessAuthority,
 		releaseNativeProcessAuthority,
 		markTrajectoryEndRecorded: () => {
 			state.trajectoryEndRecorded = true;
 		},
-		activateNativePreToolUseFailureFallback,
-		releaseSharedClientLeaseOnce,
 		releaseSharedClientLeaseAndRetireOneShotClient,
 		releaseSandboxExecEnvironment,
 		runCleanupStep,
@@ -5985,7 +6020,6 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 			await releaseCurrentRoute();
 			resourceState.turnRoute = resourceState.turnRouter.reserveThread({ threadId: resourceState.thread.threadId });
 		}
-		if (!resourceState.turnRoute) throw new Error("codex app-server turn route was not reserved");
 		if (!resourceState.routeActivated) {
 			if (!resourceState.nativeSubagentMonitor) await registerNativeSubagentMonitor(resourceState.thread.threadId);
 			resourceState.detachRouteAbort = attachRouteAbort(resourceState.turnRoute);
@@ -6088,13 +6122,6 @@ async function prepareCodexAttemptRuntime(connection) {
 		...legacyScheduledAppRecoveryPrompt ? { extraSystemPrompt: [params.extraSystemPrompt, legacyScheduledAppRecoveryPrompt].filter((value) => Boolean(value?.trim())).join("\n\n") } : {},
 		...startupAuthProfileId ? { authProfileId: startupAuthProfileId } : {}
 	};
-	const activeSessionId = params.sessionId;
-	const activeSessionFile = params.sessionFile;
-	const buildActiveRunAttemptParams = () => ({
-		...runtimeParams,
-		sessionId: activeSessionId,
-		sessionFile: activeSessionFile
-	});
 	const startupAuthAccountCacheKey = usesSupervisionConnection ? void 0 : startupPreparedAuth?.kind === "api-key" ? resolveCodexAppServerPreparedApiKeyCacheKey(startupPreparedAuth.apiKey) : startupPreparedAuth?.kind === "profile" ? startupPreparedAuth.snapshot?.secretFreeCacheKey : await resolveCodexAppServerAuthAccountCacheKey({
 		authProfileId: startupAuthProfileId,
 		authProfileStore: attemptAuthProfileStore,
@@ -6188,7 +6215,8 @@ async function prepareCodexAttemptRuntime(connection) {
 	});
 	const supervisedSearchFingerprint = usesSupervisionConnection && !mutable.startupBinding?.pendingSupervisionBranch ? mutable.startupBinding?.webSearchThreadConfigFingerprint : void 0;
 	let nativeProviderWebSearchSupport;
-	if (webSearchPlan.kind !== "native-hosted" || supervisedSearchFingerprint === fingerprintJsonObject(resolveCodexWebSearchPlan({ disableTools: true }).threadConfig)) nativeProviderWebSearchSupport = "unsupported";
+	if (isCodexResponsesOAuth(startupPreparedAuth)) nativeProviderWebSearchSupport = "supported";
+	else if (webSearchPlan.kind !== "native-hosted" || supervisedSearchFingerprint === fingerprintJsonObject(resolveCodexWebSearchPlan({ disableTools: true }).threadConfig)) nativeProviderWebSearchSupport = "unsupported";
 	else if (supervisedSearchFingerprint === fingerprintJsonObject(webSearchPlan.threadConfig)) nativeProviderWebSearchSupport = "supported";
 	else nativeProviderWebSearchSupport = await resolveCodexProviderWebSearchSupport({
 		clientFactory: attemptClientFactory,
@@ -6199,6 +6227,7 @@ async function prepareCodexAttemptRuntime(connection) {
 		config: params.config,
 		expectedNativeModelProvider: usesSupervisionConnection ? mutable.startupBinding?.modelProvider : void 0,
 		modelProviderOverride: usesSupervisionConnection ? void 0 : resolveCodexAppServerThreadModelSelection({
+			homeScope: appServer.start.homeScope,
 			provider: params.provider,
 			model: params.modelId,
 			binding: mutable.startupBinding,
@@ -6222,10 +6251,6 @@ async function prepareCodexAttemptRuntime(connection) {
 		connection,
 		preparedAuthBinding,
 		runtimeParams,
-		activeSessionId,
-		activeSessionFile,
-		buildActiveRunAttemptParams,
-		attemptAuthProfileStore,
 		effectiveContextWindowInfo,
 		effectiveContextTokenBudget,
 		effectiveRuntimeProviderId,
@@ -6263,7 +6288,7 @@ function recordCodexDynamicToolResult(projector, call, response, protocolRespons
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-tools.ts
 function toTranscriptToolResult(response) {
-	const sanitized = sanitizeCodexToolResponse(response);
+	const sanitized = sanitizeCodexAgentEventRecord({ ...response });
 	const contentItems = Array.isArray(sanitized.contentItems) ? sanitized.contentItems : [];
 	const result = {
 		...sanitized,
@@ -6299,32 +6324,6 @@ function formatUnsupportedCodexDynamicToolOutput(type) {
 	const rawType = typeof type === "string" ? type.replace(/\s+/g, " ").trim() : "";
 	return `[Unsupported Codex dynamic tool output: ${rawType ? truncateUtf16Safe(rawType, 80) : "unknown"}${rawType.length > 80 ? "..." : ""}]`;
 }
-function createCodexDynamicToolExecutionRegistry() {
-	const executions = /* @__PURE__ */ new Map();
-	const keyFor = (call) => JSON.stringify([
-		call.threadId,
-		call.turnId,
-		call.callId
-	]);
-	return {
-		get(call) {
-			return executions.get(keyFor(call));
-		},
-		claim(call, start) {
-			const existing = executions.get(keyFor(call));
-			if (existing) return {
-				execution: existing,
-				replayed: true
-			};
-			const execution = start();
-			executions.set(keyFor(call), execution);
-			return {
-				execution,
-				replayed: false
-			};
-		}
-	};
-}
 function resolveCodexDynamicToolDirectNames(params, registeredTools, hostSystemAgentActive = false) {
 	const names = [];
 	if (hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow)) names.push("openclaw");
@@ -6444,7 +6443,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				tool: call.tool,
 				toolCallId: call.callId
 			});
-			const toolMeta = inferCodexDynamicToolMeta(call, resolveCodexToolProgressDetailMode(params.toolProgressDetail));
+			const toolMeta = inferToolMetaFromArgs(call.tool, call.arguments, { detailMode: resolveCodexToolProgressDetailMode(params.toolProgressDetail) });
 			const toolArgs = sanitizeCodexToolArguments(call.arguments);
 			const commandBearing = isCodexCommandBearingToolCall(call.tool, toolArgs);
 			const shouldEmitDynamicToolProgress = shouldEmitTranscriptToolProgress(call.tool);
@@ -6480,26 +6479,24 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			});
 			setExecutionTimeoutMs?.(dynamicToolTimeoutMs);
 			const toolStartedAt = Date.now();
+			const diagnosticContext = {
+				call,
+				agentId: sessionAgentId,
+				runId: params.runId,
+				sessionId: params.sessionId,
+				sessionKey: params.sessionKey
+			};
 			let terminalDiagnosticObserved = false;
 			const unsubscribeToolDiagnosticObserver = onInternalDiagnosticEvent((event) => {
 				if (isDynamicToolTerminalDiagnosticEvent(event) && isMatchingDynamicToolTerminalDiagnostic({
-					event,
-					call,
-					runId: params.runId,
-					sessionId: params.sessionId,
-					sessionKey: params.sessionKey
+					...diagnosticContext,
+					event
 				})) terminalDiagnosticObserved = true;
 			}, { include: DYNAMIC_TOOL_TERMINAL_DIAGNOSTIC_TYPES });
 			try {
 				const { execution } = openClawDynamicToolExecutions.claim(call, async () => {
 					await projector?.transcriptCheckpoint.flush();
-					emitDynamicToolStartedDiagnostic({
-						call,
-						agentId: sessionAgentId,
-						runId: params.runId,
-						sessionId: params.sessionId,
-						sessionKey: params.sessionKey
-					});
+					emitDynamicToolStartedDiagnostic(diagnosticContext);
 					const response = await handleDynamicToolCallWithTimeout({
 						call,
 						toolBridge,
@@ -6581,18 +6578,9 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						data: activity
 					});
 				}
-				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic({
-					call,
-					runId: params.runId,
-					sessionId: params.sessionId,
-					sessionKey: params.sessionKey
-				})) emitDynamicToolTerminalDiagnostic({
+				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic(diagnosticContext)) emitDynamicToolTerminalDiagnostic({
+					...diagnosticContext,
 					response,
-					call,
-					agentId: sessionAgentId,
-					runId: params.runId,
-					sessionId: params.sessionId,
-					sessionKey: params.sessionKey,
 					durationMs: toolDurationMs
 				});
 				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
@@ -6610,17 +6598,8 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				return protocolResponse;
 			} catch (error) {
 				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
-				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic({
-					call,
-					runId: params.runId,
-					sessionId: params.sessionId,
-					sessionKey: params.sessionKey
-				})) emitDynamicToolErrorDiagnostic({
-					call,
-					agentId: sessionAgentId,
-					runId: params.runId,
-					sessionId: params.sessionId,
-					sessionKey: params.sessionKey,
+				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic(diagnosticContext)) emitDynamicToolErrorDiagnostic({
+					...diagnosticContext,
 					durationMs: Math.max(0, Date.now() - toolStartedAt)
 				});
 				await settlePluginRuntimeRefresh(turnId);
@@ -6643,11 +6622,11 @@ 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-CLZ8udh-.mjs");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-DDQ-HGXf.mjs");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
-	if (!runtimeArtifact || !matchesExpected || !await validateCodexAppServerRuntimeArtifact(runtimeArtifact, params.signal)) {
+	if (!runtimeArtifact || !matchesExpected || !await validateCodexAppServerRuntimeArtifact(runtimeArtifact, params.signal, params.startOptions)) {
 		retireSharedCodexAppServerClientIfCurrent(params.client);
 		throw new Error(expected ? "Codex app-server runtime artifact does not match verified inference" : "Codex app-server runtime artifact is unavailable or stale");
 	}
@@ -6676,7 +6655,6 @@ function startCodexComputerUseHealthMonitor(params) {
 	if (existing) clearComputerUseHealthMonitor(params.client, existing);
 	const monitor = {
 		fingerprint,
-		intervalMs,
 		timer: setInterval(() => {
 			runCodexComputerUseHealthProbe(params.client, params.config, monitor, params.tools);
 		}, intervalMs),
@@ -6712,9 +6690,9 @@ async function runCodexComputerUseHealthProbe(client, config, monitor, tools) {
 			client,
 			config,
 			tools,
-			request: async (method, requestParams, requestOptions) => await client.request(method, requestParams, {
-				timeoutMs: requestOptions?.timeoutMs ?? config.liveTestTimeoutMs,
-				...requestOptions?.signal ? { signal: requestOptions.signal } : {}
+			request: createComputerUseRequest({
+				client,
+				timeoutMs: config.liveTestTimeoutMs
 			})
 		});
 		if (!liveTest.ok) {
@@ -6756,8 +6734,8 @@ var CodexPluginThreadConfigDeadlineError = class extends Error {
 };
 /** Resolves the plugin policy state reused throughout app-server startup. */
 function resolveCodexPluginThreadConfigStartupPolicy(params) {
-	const pluginThreadConfigRequired = Boolean(params.scheduledRuntimeAuthority) || !params.nativeToolSurfaceEnabled || shouldBuildCodexPluginThreadConfig(params.pluginConfig);
-	const pluginThreadConfigPluginConfig = params.nativeToolSurfaceEnabled || params.scheduledRuntimeAuthority ? params.pluginConfig : disableCodexPluginThreadConfig(params.pluginConfig);
+	const pluginThreadConfigRequired = params.hostedAppsSupported === false || Boolean(params.scheduledRuntimeAuthority) || !params.nativeToolSurfaceEnabled || shouldBuildCodexPluginThreadConfig(params.pluginConfig);
+	const pluginThreadConfigPluginConfig = params.hostedAppsSupported !== false && (params.nativeToolSurfaceEnabled || params.scheduledRuntimeAuthority) ? params.pluginConfig : disableCodexPluginThreadConfig(params.pluginConfig);
 	const resolvedPluginPolicy = pluginThreadConfigRequired ? resolveCodexPluginsPolicy(pluginThreadConfigPluginConfig) : void 0;
 	return {
 		pluginThreadConfigRequired,
@@ -6771,10 +6749,10 @@ async function buildCodexPluginThreadConfigWithinDeadline(params) {
 	const { requestTimeoutMs, signal, request, failClosedOnTimeout, transform, ...buildParams } = params;
 	signal.throwIfAborted();
 	const timeoutMs = resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs);
-	const deadlineMs = Date.now() + timeoutMs;
+	const deadlineMs = performance.now() + timeoutMs;
 	let requestTimedOut = false;
 	const boundedRequest = async (method, requestParams) => {
-		const remainingTimeoutMs = deadlineMs - Date.now();
+		const remainingTimeoutMs = deadlineMs - performance.now();
 		if (requestTimedOut || remainingTimeoutMs <= 0) throw new CodexPluginThreadConfigDeadlineError();
 		try {
 			return await request(method, requestParams, {
@@ -6796,14 +6774,14 @@ async function buildCodexPluginThreadConfigWithinDeadline(params) {
 					request: boundedRequest
 				});
 				const result = transform ? await transform(config, boundedRequest) : config;
-				if (requestTimedOut || Date.now() >= deadlineMs) throw new CodexPluginThreadConfigDeadlineError();
+				if (requestTimedOut || performance.now() >= deadlineMs) throw new CodexPluginThreadConfigDeadlineError();
 				return result;
 			})(),
 			timeoutMessage: "Codex plugin thread config deadline elapsed",
 			createTimeoutError: () => new CodexPluginThreadConfigDeadlineError()
 		});
 	} catch (error) {
-		if (signal.aborted || !requestTimedOut && !isCodexPluginThreadConfigTimeoutError(error) && Date.now() < deadlineMs) throw error;
+		if (signal.aborted || !requestTimedOut && !isCodexPluginThreadConfigTimeoutError(error) && performance.now() < deadlineMs) throw error;
 		if (failClosedOnTimeout) throw new AgentHarnessPreflightError(`Codex app policy verification exceeded its ${timeoutMs} ms startup budget. No app tools were executed. Retry after Codex app inventory is responsive.`);
 		return buildCodexPluginThreadConfigTimeoutFallback({
 			pluginConfig: buildParams.pluginConfig,
@@ -6835,7 +6813,11 @@ function createCodexPluginThreadConfigStartupProvider(params) {
 				appCache: appCache ?? defaultCodexAppInventoryCache,
 				metadataCache,
 				failClosedOnTimeout: Boolean(params.scheduledRuntimeAuthority),
-				transform: params.scheduledRuntimeAuthority ? async (builtConfig, request) => intersectCodexPluginThreadConfigWithScheduledAuthority(builtConfig, params.scheduledRuntimeAuthority, await readCurrentCodexScheduledAppPolicy(request, params.configCwd, buildOptions?.threadId)) : void 0,
+				transform: params.scheduledRuntimeAuthority ? async (builtConfig, request) => intersectCodexPluginThreadConfigWithScheduledAuthority(builtConfig, params.scheduledRuntimeAuthority, await readCurrentCodexScheduledAppPolicy({
+					request,
+					configCwd: params.configCwd,
+					threadId: buildOptions?.threadId
+				})) : void 0,
 				request: (method, requestParams, options) => client.request(method, requestParams, options)
 			});
 			return params.scheduledRuntimeAuthority && params.inputFingerprint ? {
@@ -6845,13 +6827,6 @@ function createCodexPluginThreadConfigStartupProvider(params) {
 		}
 	};
 }
-async function readCurrentCodexScheduledAppPolicy(request, cwd, threadId) {
-	return await readCurrentCodexScheduledAppPolicy$1({
-		request,
-		configCwd: cwd,
-		threadId
-	});
-}
 function resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs) {
 	return Math.min(CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS, Math.max(CODEX_PLUGIN_THREAD_CONFIG_MIN_TIMEOUT_MS, Math.floor((Number.isFinite(requestTimeoutMs) && requestTimeoutMs > 0 ? requestTimeoutMs : CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS * CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR) / CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR)));
 }
@@ -6860,20 +6835,7 @@ function isCodexPluginThreadConfigTimeoutError(error) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/attempt-startup.ts
-/**
-* Startup orchestration for Codex app-server attempts, including shared-client
-* leasing, plugin thread config, sandbox environment, and thread lifecycle binding.
-*/
 const CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS = 3;
-const CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED = "CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED";
-/** True when a pre-write context restart must replay on the newly selected owner. */
-function isCodexContextRestartSelectionChangedError(error) {
-	return error instanceof Error && "code" in error && error.code === CODEX_APP_SERVER_CONTEXT_RESTART_SELECTION_CHANGED;
-}
-/**
-* Starts or resumes the Codex app-server thread and returns the resources the
-* run loop must later release.
-*/
 async function startCodexAttemptThread(params) {
 	let pluginAppServer = params.appServer;
 	const startupRuntimeAuthProfileId = params.startupPreparedAuth?.kind === "profile" ? params.startupPreparedAuth.profileId : params.startupAuthProfileId ?? void 0;
@@ -6902,6 +6864,7 @@ async function startCodexAttemptThread(params) {
 				const { pluginThreadConfigRequired, pluginThreadConfigPluginConfig, resolvedPluginPolicy, enabledPluginConfigKeys } = resolveCodexPluginThreadConfigStartupPolicy({
 					pluginConfig: params.pluginConfig,
 					nativeToolSurfaceEnabled: params.nativeToolSurfaceEnabled,
+					hostedAppsSupported: !isCodexResponsesOAuth(params.startupPreparedAuth),
 					scheduledRuntimeAuthority: params.buildAttemptParams().scheduledRuntimeAuthority
 				});
 				pluginAppServer = resolvedPluginPolicy?.enabled === true || params.computerUseConfig.enabled || params.nativeToolSurfaceEnabled && params.configuredMcpOwnershipVersion !== 1 && hasCodexMcpToolApprovalOverrides(params.config?.mcp?.servers, params.bundleMcpThreadConfig.userStaticServerNames, params.bundleMcpThreadConfig.configPatch?.mcp_servers) ? {
@@ -6954,6 +6917,7 @@ async function startCodexAttemptThread(params) {
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
 						const runtimeArtifact = await verifyStartupArtifact({
 							client: activeStartupClient,
+							startOptions: params.appServer.start,
 							request: params.runtimeArtifactRequest,
 							signal: startupAbandonController.signal
 						});
@@ -6961,21 +6925,28 @@ async function startCodexAttemptThread(params) {
 						ensureCodexAppServerClientRuntime(activeStartupClient, {
 							agentDir: params.agentDir,
 							authProfileId: startupRuntimeAuthProfileId,
-							authMode: params.startupPreparedAuth?.kind === "api-key" ? "prepared-api-key" : "profile",
+							authMode: params.startupPreparedAuth?.kind === "api-key" || isCodexResponsesOAuth(params.startupPreparedAuth) ? "prepared-api-key" : "profile",
 							authProfileStore: startupRuntimeAuthProfileStore ?? attemptParams.authProfileStore,
 							config: params.config
 						});
 						const turnRouter = getCodexAppServerTurnRouter(activeStartupClient);
 						let computerUseTools = [];
+						let computerUseConfig = params.computerUseConfig;
 						try {
-							computerUseTools = (await ensureCodexComputerUse({
+							const computerUseStatus = await ensureCodexComputerUse({
 								client: activeStartupClient,
 								pluginConfig: params.pluginConfig,
 								config: params.config,
 								agentDir: params.agentDir,
 								timeoutMs: params.appServer.requestTimeoutMs,
 								signal: startupAbandonController.signal
-							})).tools;
+							});
+							computerUseTools = computerUseStatus.tools;
+							computerUseConfig = {
+								...computerUseConfig,
+								pluginName: computerUseStatus.pluginName,
+								mcpServerName: computerUseStatus.mcpServerName
+							};
 						} catch (error) {
 							if (startupAbandonController.signal.aborted || isCodexAppServerStartSelectionChangedError(error)) throw error;
 							throw new AgentHarnessPreflightError(`Codex Computer Use readiness failed: ${formatErrorMessage(error)}`, {
@@ -7089,14 +7060,17 @@ async function startCodexAttemptThread(params) {
 							webSearchAllowed: params.webSearchAllowed,
 							appServer: pluginAppServer,
 							developerInstructions: params.developerInstructions,
+							skillsInstructions: params.skillsInstructions,
 							agentWorkspaceDeveloperInstructions: params.agentWorkspaceDeveloperInstructions,
 							config: threadConfig,
 							shellEnvironment: params.shellEnvironment,
+							shellPathPrepend: params.shellPathPrepend,
 							disableLoginShell: params.disableLoginShell,
 							finalConfigPatch: params.finalConfigPatch,
 							buildFinalConfigPatch: params.buildFinalConfigPatch,
 							nativeHookRelayGeneration: params.nativeHookRelayGeneration,
 							nativeHookRelayRequired: params.nativeHookRelayRequired,
+							nativeModelAdmission: params.nativeModelAdmission,
 							nativeCodeModeEnabled: params.nativeToolSurfaceEnabled,
 							nativeProviderWebSearchSupport: params.nativeProviderWebSearchSupport,
 							nativeCodeModeOnlyEnabled: params.appServer.codeModeOnly,
@@ -7138,7 +7112,7 @@ async function startCodexAttemptThread(params) {
 							startupSandboxEnvironmentAcquired = false;
 							startCodexComputerUseHealthMonitor({
 								client: activeStartupClient,
-								config: params.computerUseConfig,
+								config: computerUseConfig,
 								tools: computerUseTools
 							});
 							startupAttemptSucceeded = true;
@@ -7154,7 +7128,10 @@ async function startCodexAttemptThread(params) {
 								...runtimeArtifact ? { runtimeArtifact } : {},
 								restartContextEngineCodexThread: async () => {
 									try {
-										return await startOrResumeThread(buildThreadLifecycleParams(params.signal));
+										return await startOrResumeThread({
+											...buildThreadLifecycleParams(params.signal),
+											contextEngineProjection: void 0
+										});
 									} catch (error) {
 										if (!isCodexAppServerStartSelectionChangedError(error)) throw error;
 										retireSharedCodexAppServerClientIfCurrent(activeStartupClient);
@@ -7195,7 +7172,7 @@ async function startCodexAttemptThread(params) {
 				} catch (error) {
 					const selectionChanged = isCodexAppServerStartSelectionChangedError(error);
 					const clientRetired = error instanceof CodexThreadClientReplacementError;
-					if (startupAbandonController.signal.aborted || clientRetired && replacedSettledFailureClient || !clientRetired && !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
+					if (startupAbandonController.signal.aborted || isCodexWebSocketOpenFailure(error) || clientRetired && replacedSettledFailureClient || !clientRetired && !selectionChanged && !isCodexAppServerConnectionClosedError(error)) throw error;
 					replacedSettledFailureClient ||= clientRetired;
 					const refreshedSharedClient = clientRetired ? void 0 : selectionChanged ? retireSharedCodexAppServerClientIfCurrent(attemptedClient) : clearSharedCodexAppServerClientIfCurrent(attemptedClient);
 					if (startupClientForAbandonedRequestCleanup === attemptedClient) startupClientForAbandonedRequestCleanup = void 0;
@@ -7246,7 +7223,7 @@ async function startCodexAttemptRuntime(resources) {
 	const { prompt, state, trajectoryRecorder, startupTimeoutMs, buildNativeHookRelayFinalConfigPatch } = resources;
 	const { context, turnState, rebuildCodexTurnPromptTextFromCurrentProjection, applyNoContextEngineContinuityProjection } = prompt;
 	const { runtime, attemptTools, promptState } = context;
-	const { connection, runtimeParams, preparedAuthBinding, buildActiveRunAttemptParams, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
+	const { connection, runtimeParams, preparedAuthBinding, startupAuthAccountCacheKey, startupEnvApiKeyCacheKey, bundleMcpThreadConfig, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, effectiveRuntimeModelId, sandboxExecServerEnabled } = runtime;
 	const { toolBridge, toolState } = attemptTools;
 	const developerInstructions = joinPresentSections(turnState.promptBuild.developerInstructions, attemptTools.configuredMcp?.diagnosticNotice);
 	const { params, attemptClientFactory, bindingStore, appServer, pluginConfig, computerUseConfig, startupClientAuthProfileId, runtimeArtifactRequest, startupPreparedAuth, agentDir, sessionAgentId, effectiveWorkspace, effectiveCwd, sandbox, runAbortController, usesSupervisionConnection, resolveReviewerPolicyContext, resolveRuntimeOptionsForCurrentBinding, startupAuthProfileId, startupAuthRequirement } = connection;
@@ -7275,8 +7252,9 @@ async function startCodexAttemptRuntime(resources) {
 			agentDir,
 			config: params.config,
 			shellEnvironment: connection.shellEnvironment,
+			shellPathPrepend: connection.shellPathPrepend,
 			disableLoginShell: connection.disableLoginShell,
-			buildAttemptParams: buildActiveRunAttemptParams,
+			buildAttemptParams: () => ({ ...runtimeParams }),
 			...effectiveRuntimeModelId !== runtimeParams.modelId ? { runtimeModelId: effectiveRuntimeModelId } : {},
 			sessionAgentId,
 			effectiveWorkspace,
@@ -7285,9 +7263,11 @@ async function startCodexAttemptRuntime(resources) {
 			persistentWebSearchAllowed: toolState.persistentWebSearchAllowed,
 			webSearchAllowed: toolState.webSearchAllowed,
 			developerInstructions,
+			skillsInstructions: context.skillsInstructions,
 			agentWorkspaceDeveloperInstructions: context.agentWorkspaceDeveloperInstructions,
 			buildFinalConfigPatch: buildNativeHookRelayFinalConfigPatch,
-			nativeHookRelayRequired: Boolean(resources.nativeProcessAuthority && nativeToolSurfaceEnabled) || connection.options.nativeHookRelay?.enabled !== false && params.pluginHarnessToolPolicyRestricted !== true && connection.nativeHookRelayEvents.includes("pre_tool_use") && (hasBeforeToolCallPolicy() || appServer.loopDetectionPreToolUseRelay && Boolean(connection.sandboxSessionKey) && loopDetectionEnabled),
+			nativeModelAdmission: resources.nativeModelAdmission,
+			nativeHookRelayRequired: nativeToolSurfaceEnabled && params.pluginHarnessToolPolicyRestricted !== true && (resources.nativeProcessAuthority?.requiresProcessAdmission || resources.nativeModelAdmission === "required") || connection.options.nativeHookRelay?.enabled !== false && params.pluginHarnessToolPolicyRestricted !== true && connection.nativeHookRelayEvents.includes("pre_tool_use") && (hasBeforeToolCallPolicy() || appServer.loopDetectionPreToolUseRelay && Boolean(connection.sandboxSessionKey) && loopDetectionEnabled),
 			bundleMcpThreadConfig,
 			configuredMcpDynamicSurface: attemptTools.configuredMcp !== void 0,
 			configuredMcpOwnershipVersion: attemptTools.configuredMcpOwnershipVersion,
@@ -7378,6 +7358,53 @@ async function startCodexAttemptRuntime(resources) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/heartbeat-tool-fallback.ts
+const InactiveHeartbeatResponseParameters = Type.Object({}, { additionalProperties: true });
+function resolveInactiveCodexHeartbeatResponseDescriptor(params) {
+	if (params.registeredSpecs) {
+		const spec = flattenCodexDynamicToolFunctions(params.registeredSpecs).find((tool) => tool.name === HEARTBEAT_RESPONSE_TOOL_NAME);
+		return spec ? {
+			name: spec.name,
+			description: spec.description
+		} : void 0;
+	}
+	const descriptor = params.registeredTools.find((tool) => tool.name === HEARTBEAT_RESPONSE_TOOL_NAME);
+	return descriptor ? {
+		name: descriptor.name,
+		description: descriptor.description
+	} : void 0;
+}
+/** Keeps the thread-stable heartbeat endpoint executable on ordinary Codex turns. */
+function createInactiveCodexHeartbeatResponseTool(descriptor) {
+	if (descriptor.name !== HEARTBEAT_RESPONSE_TOOL_NAME) throw new Error(`Expected ${HEARTBEAT_RESPONSE_TOOL_NAME}, received ${descriptor.name}`);
+	return {
+		name: descriptor.name,
+		label: descriptor.name,
+		description: descriptor.description,
+		parameters: InactiveHeartbeatResponseParameters,
+		execute: async (_toolCallId, args) => {
+			const response = normalizeHeartbeatToolResponse(args);
+			if (!response) throw new Error("Invalid heartbeat response. Provide outcome, notify, and non-empty summary.");
+			if (response.notify) throw new Error("heartbeat_respond cannot send notifications outside a heartbeat turn");
+			return {
+				content: [{
+					type: "text",
+					text: "No heartbeat is active for this turn. Continue the current task and respond normally."
+				}],
+				details: {
+					status: "ignored",
+					reason: "non-heartbeat-turn"
+				}
+			};
+		}
+	};
+}
+function selectInactiveCodexHeartbeatResponseTool(params) {
+	if (params.disableTools) return;
+	const allowed = applyEmbeddedAttemptToolsAllow([createInactiveCodexHeartbeatResponseTool(params.descriptor)], params.toolsAllow);
+	return filterCodexDynamicTools(allowed, params.pluginConfig)[0];
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-tool-setup.ts
 function isAuthorityResolutionOperationAbort(error, signal) {
 	return signal?.aborted === true && error === signal.reason;
@@ -7386,7 +7413,7 @@ async function prepareCodexAttemptTools(runtime) {
 	const { connection, bundleMcpThreadConfig, bundleManifestRegistry, runtimeParams, effectiveRuntimeModelId, nativeToolSurfaceEnabled, nativeProviderWebSearchSupport, hookChannelId, codexMcpToolOverrides, authenticatedScheduledMode, configuredMcpSurface, canResolveScheduledConfiguredMcpCreatorAuthority } = runtime;
 	const { params, preDynamicStartupStages, mutable, resolvedWorkspace, effectiveWorkspace, effectiveCwd, sandboxSessionKey, contextSessionKey, sandbox, sessionPermissionPolicy, runAbortController, sessionAgentId, policyAgentId, pluginConfig, profilerEnabled, agentDir } = connection;
 	const preDynamicSummary = preDynamicStartupStages.snapshot();
-	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary, profilerEnabled)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(preDynamicSummary)}`, {
+	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary, profilerEnabled)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatStageTimings(preDynamicSummary.stages)}`, {
 		runId: params.runId,
 		sessionId: params.sessionId,
 		totalMs: preDynamicSummary.totalMs,
@@ -7441,7 +7468,7 @@ async function prepareCodexAttemptTools(runtime) {
 	} : void 0;
 	const scheduledCodexAppAuth = preparedChatgptAuth ?? configuredAppServerAuth;
 	const appPolicy = resolveCodexPluginsPolicy(pluginConfig);
-	const codexAppsMayBeVisible = appPolicy.enabled && (appPolicy.allowAllPlugins || appPolicy.pluginPolicies.some((entry) => entry.enabled));
+	const codexAppsMayBeVisible = !isCodexResponsesOAuth(connection.startupPreparedAuth) && appPolicy.enabled && (appPolicy.allowAllPlugins || appPolicy.pluginPolicies.some((entry) => entry.enabled));
 	const appCreatorCapture = resolveScheduledCodexAppCreatorCaptureDecision({
 		appsMayBeVisible: codexAppsMayBeVisible,
 		authenticatedScheduledMode,
@@ -7612,20 +7639,8 @@ async function prepareCodexAttemptTools(runtime) {
 		const reservedToolNames = [...tools.map((tool) => tool.name), ...registeredTools.map((tool) => tool.name)];
 		const turnSourceChannel = params.messageChannel ?? params.messageProvider;
 		const turnSourceTo = params.currentMessagingTarget ?? params.currentChannelId;
-		const requester = {
-			...turnSourceChannel ? { channel: turnSourceChannel } : {},
-			...params.agentAccountId ? { accountId: params.agentAccountId } : {},
-			...params.senderId ? { senderId: params.senderId } : {},
-			...params.senderIsOwner !== void 0 ? { senderIsOwner: params.senderIsOwner } : {},
-			...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
-		};
-		const hasRequester = Object.keys(requester).length > 0;
-		const requestInteractiveMcpApproval = async (approval) => {
-			const allowedDecisions = approval.mode === "prompt" ? ["allow-once", "deny"] : [
-				"allow-once",
-				"allow-always",
-				"deny"
-			];
+		const requester = buildCodexHookRequester(params);
+		const requestInteractiveMcpApproval = async (approval, allowedDecisions) => {
 			const outcome = await requestPluginApprovalOutcome({
 				hostCapabilities: params.hostCapabilities,
 				signal: approval.signal,
@@ -7642,57 +7657,39 @@ async function prepareCodexAttemptTools(runtime) {
 			});
 			if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
 		};
-		const requestRequesterMcpApproval = async (approval) => {
-			const outcome = await requestPluginApprovalOutcome({
-				hostCapabilities: params.hostCapabilities,
-				signal: approval.signal,
-				title: `Run MCP tool ${approval.serverName}/${approval.toolName}`,
-				description: `Codex approval mode "${approval.mode}" requires an operator decision before this MCP tool runs. ${formatMcpCodexApprovalRemedy(approval.serverName)}`,
-				allowedDecisions: ["allow-once", "deny"],
-				toolName: approval.safeToolName,
-				toolCallId: approval.toolCallId,
-				mcpTool: {
-					server: approval.serverName,
-					tool: approval.toolName
-				},
-				isMcpToolApprovalActive: approval.isActive
-			});
-			if (outcome !== "approved-once" && outcome !== "approved-session") throw new Error(`${approval.serverName}/${approval.toolName}: interactive Codex approval (${approval.mode}) was not granted: ${outcome}`);
-		};
-		configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
-			sessionId: params.sessionId,
-			sessionKey: params.sessionKey,
-			agentId: sessionAgentId,
+		const mcpOptions = {
 			workspaceDir: effectiveWorkspace,
 			agentDir: policyContext.agentDir,
 			cfg: params.config,
 			manifestRegistry: bundleManifestRegistry,
-			reservedToolNames,
 			toolsAllow: params.toolsAllow,
 			toolOverrides: codexMcpToolOverrides,
 			autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
-			projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
-			...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: requestInteractiveMcpApproval } : {},
 			policyContext,
 			warn: (message) => embeddedAgentLog.warn(message)
+		};
+		configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
+			...mcpOptions,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			agentId: sessionAgentId,
+			reservedToolNames,
+			projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
+			...configuredMcpSurface === "transient" ? { requestInteractiveCodexApproval: (approval) => requestInteractiveMcpApproval(approval, approval.mode === "prompt" ? ["allow-once", "deny"] : [
+				"allow-once",
+				"allow-always",
+				"deny"
+			]) } : {}
 		}) : void 0;
 		scopedMcpTools = authenticatedScheduledMode ? void 0 : await materializeRequesterScopedMcpToolsForHarnessRun({
+			...mcpOptions,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
-			workspaceDir: effectiveWorkspace,
-			agentDir: policyContext.agentDir,
-			cfg: params.config,
-			manifestRegistry: bundleManifestRegistry,
-			toolOverrides: codexMcpToolOverrides,
-			autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
-			requestInteractiveCodexApproval: requestRequesterMcpApproval,
+			requestInteractiveCodexApproval: (approval) => requestInteractiveMcpApproval(approval, ["allow-once", "deny"]),
 			requesterSenderId: params.senderId,
 			agentAccountId: params.agentAccountId,
 			messageChannel: params.messageChannel ?? params.messageProvider,
-			reservedToolNames: [...reservedToolNames, ...configuredMcp?.tools.map((tool) => tool.name) ?? []],
-			toolsAllow: params.toolsAllow,
-			policyContext,
-			warn: (message) => embeddedAgentLog.warn(message)
+			reservedToolNames: [...reservedToolNames, ...configuredMcp?.tools.map((tool) => tool.name) ?? []]
 		});
 		const scopedExecutable = filterCodexDynamicTools([...configuredMcp?.tools ?? [], ...scopedMcpTools?.tools ?? []], pluginConfig);
 		const scopedAdvertised = filterCodexDynamicTools([...configuredMcp?.tools ?? [], ...scopedMcpTools?.advertisedTools ?? []], pluginConfig);
@@ -7721,19 +7718,32 @@ async function prepareCodexAttemptTools(runtime) {
 			allocateToolOutcomeOrdinal: allocateCodexToolOutcomeOrdinal,
 			trigger: params.trigger,
 			approvalReviewerDeviceId: params.approvalReviewerDeviceId,
-			...hasRequester ? { requester } : {},
+			...requester ? { requester } : {},
 			...turnSourceChannel ? { turnSourceChannel } : {},
 			...turnSourceTo ? { turnSourceTo } : {},
 			...params.agentAccountId ? { turnSourceAccountId: params.agentAccountId } : {},
 			...params.currentThreadTs !== void 0 ? { turnSourceThreadId: params.currentThreadTs } : {}
 		};
+		const heartbeatFallbackDescriptor = resolveInactiveCodexHeartbeatResponseDescriptor({
+			registeredTools: registeredWithScopedMcp,
+			...nativeSpecs ? { registeredSpecs: nativeSpecs } : {}
+		});
+		const heartbeatFallbackTool = heartbeatFallbackDescriptor && supportsModelTools(params.model) ? selectInactiveCodexHeartbeatResponseTool({
+			descriptor: heartbeatFallbackDescriptor,
+			disableTools: params.disableTools,
+			toolsAllow: params.toolsAllow,
+			pluginConfig
+		}) : void 0;
+		const registeredFallbackTools = params.trigger === "heartbeat" || params.enableHeartbeatTool === true || params.forceHeartbeatTool === true || !heartbeatFallbackTool ? void 0 : params.hostCapabilities.bindToolSurface([heartbeatFallbackTool], { cwd: effectiveCwd ?? effectiveWorkspace });
 		const toolBridge = createCodexDynamicToolBridge({
 			tools: toolsWithScopedMcp,
 			registeredTools: registeredWithScopedMcp,
+			registeredFallbackTools,
 			registeredSpecs: nativeSpecs,
 			signal: runAbortController.signal,
 			computerContextEpoch,
-			loading: resolveCodexDynamicToolsLoadingForRuntime(pluginConfig, effectiveRuntimeModelId, { connectionClass: connection.appServer.connectionClass }),
+			functionToolsOnly: isCodexResponsesOAuth(connection.startupPreparedAuth),
+			loading: isCodexResponsesOAuth(connection.startupPreparedAuth) ? "direct" : resolveCodexDynamicToolsLoadingForRuntime(pluginConfig, effectiveRuntimeModelId, { connectionClass: connection.appServer.connectionClass }),
 			directToolNames: resolveCodexDynamicToolDirectNames(params, registeredWithScopedMcp, isHostScopedAgentToolActive("openclaw")),
 			hookContext
 		});
@@ -7757,19 +7767,11 @@ async function prepareCodexAttemptTools(runtime) {
 			try {
 				if (canResolveScheduledConfiguredMcpCreatorAuthority) try {
 					materialized = await materializeStaticMcpToolsForHarnessRun({
+						...mcpOptions,
 						sessionId: `cron-authority:${params.runId}`,
 						agentId: sessionAgentId,
-						workspaceDir: effectiveWorkspace,
-						agentDir: policyContext.agentDir,
-						cfg: params.config,
-						manifestRegistry: bundleManifestRegistry,
 						reservedToolNames: configuredMcp ? reservedToolNames : toolBridge.availableTools.map((tool) => tool.name),
-						toolsAllow: params.toolsAllow,
-						toolOverrides: codexMcpToolOverrides,
-						autoApproveCodexAppServerApprovals: shouldAutoApproveCodexAppServerApprovals(connection.appServer),
 						projectedMcpServers: bundleMcpThreadConfig.configPatch?.mcp_servers,
-						policyContext,
-						warn: (message) => embeddedAgentLog.warn(message),
 						retireSessionRuntimeAfterDispose: true
 					});
 				} catch (error) {
@@ -7798,9 +7800,7 @@ async function prepareCodexAttemptTools(runtime) {
 		};
 		return {
 			tools: toolsWithScopedMcp,
-			registeredTools: registeredWithScopedMcp,
 			requireExplicitMessageTarget,
-			scopedMcpTools,
 			configuredMcp,
 			disposeTools,
 			configuredMcpOwnershipVersion: configuredMcpSurface === "scheduled" ? 1 : void 0,
@@ -7813,7 +7813,6 @@ async function prepareCodexAttemptTools(runtime) {
 			toolState,
 			toolOutcomeOrdinals,
 			suppressedDynamicToolOutcomeOrdinals,
-			onCodexToolOutcome,
 			allocateCodexToolOutcomeOrdinal,
 			runtimeYieldCompletionClaim
 		};
@@ -7944,6 +7943,40 @@ async function prepareCodexProviderReviewContinuation(params) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/service-tier.ts
+/** Optional speed upgrades follow this turn's native model and authenticated client. */
+async function resolveCodexUltrafastServiceTier(params) {
+	if (!params.enabled || params.modelProvider !== "openai" && params.modelProvider !== "openclaw_token_sharing" || !params.model) return params.serviceTier;
+	params.signal.throwIfAborted();
+	params.assertCurrent();
+	const deadline = Date.now() + params.timeoutMs;
+	try {
+		const catalog = await listAllCodexAppServerModels({
+			includeHidden: true,
+			request: (request) => {
+				const timeoutMs = deadline - Date.now();
+				if (timeoutMs <= 0) throw new Error("Codex Ultrafast catalog deadline exceeded");
+				return requestCodexAppServerClientJson({
+					...request,
+					client: params.client,
+					signal: params.signal,
+					assertCurrent: params.assertCurrent,
+					timeoutMs,
+					config: params.config
+				});
+			}
+		});
+		params.signal.throwIfAborted();
+		params.assertCurrent();
+		return catalog.models.find((entry) => entry.model === params.model)?.serviceTiers?.includes("ultrafast") ? "ultrafast" : params.serviceTier;
+	} catch (error) {
+		params.signal.throwIfAborted();
+		params.assertCurrent();
+		if (error instanceof CodexAppServerScopedRequestRejectedError) throw error;
+		return params.serviceTier;
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-request.ts
 async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, waitForActiveNativeTurnCompletion) {
 	const { prompt, state: resourceState, releaseCurrentRoute } = resources;
@@ -7951,7 +7984,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 	const { runtime, attemptTools, hookContextWindowFields, workspaceBootstrapContext } = context;
 	const { connection, runtimeParams, effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
 	const { tools, toolBridge } = attemptTools;
-	const { params, usesSupervisionConnection, codexModelCallId, codexModelCallTrace, codexModelContentCapture, appServer, runAbortController } = connection;
+	const { params, sessionAgentId, usesSupervisionConnection, codexModelCallId, codexModelCallTrace, codexModelContentCapture, appServer, runAbortController } = connection;
 	const { state } = turnRuntime;
 	const explicitSkillInputs = await resolveCodexExplicitSkillInputs({
 		client: resourceState.client,
@@ -7959,18 +7992,22 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		selections: runtimeParams.explicitSkillSelections,
 		signal: runAbortController.signal
 	});
-	const buildCodexModelInputMessages = () => [...prompt.codexModelInputHistoryMessages, buildCodexUserPromptMessage({
+	const buildCodexModelInputMessages = () => [buildCodexUserPromptMessage({
 		...runtimeParams,
 		prompt: turnState.codexTurnPromptText
 	})];
+	const buildModelCallIdentity = () => ({
+		runId: params.runId,
+		sessionId: params.sessionId,
+		provider: usesSupervisionConnection ? resourceState.thread.modelProvider ?? effectiveRuntimeProviderId : params.provider,
+		model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId
+	});
 	const codexModelCallDiagnostics = createCodexModelCallDiagnosticEmitter({
 		baseFields: {
-			runId: params.runId,
+			...buildModelCallIdentity(),
+			agentId: sessionAgentId,
 			callId: codexModelCallId,
 			...params.sessionKey ? { sessionKey: params.sessionKey } : {},
-			sessionId: params.sessionId,
-			provider: usesSupervisionConnection ? resourceState.thread.modelProvider ?? effectiveRuntimeProviderId : params.provider,
-			model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId,
 			api: usesSupervisionConnection ? runtimeParams.model.api : params.model.api,
 			transport: appServer.start.transport,
 			observationUnit: "turn",
@@ -8004,15 +8041,16 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		const selectedThread = resourceState.thread;
 		const { threadId, liveThreadOwnership, model, modelProvider } = selectedThread;
 		const turnClient = resourceState.client;
+		const nativeModel = usesSupervisionConnection ? requireCodexSupervisionModelSelection(selectedThread) : void 0;
 		const assertTurnCurrent = () => {
 			connection.assertCurrent();
 			liveThreadOwnership?.assertCurrent();
 			if (resourceState.thread !== selectedThread || selectedThread.threadId !== threadId || selectedThread.liveThreadOwnership !== liveThreadOwnership || selectedThread.model !== model || selectedThread.modelProvider !== modelProvider) throw new Error("Codex native model or thread ownership changed during turn start.");
 		};
-		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, runtimeParams);
-		connection.mutable.pluginAppServer = turnAppServer;
+		const fastMode = typeof runtimeParams.fastMode === "function" ? runtimeParams.fastMode() : runtimeParams.fastMode;
+		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, { fastMode }, connection.appServer);
 		const references = prepareWorkspaceReferences();
-		const inferenceRoute = usesSupervisionConnection ? void 0 : getCodexInferenceThread(resourceState.client, resourceState.thread.threadId);
+		const inferenceRoute = getCodexInferenceThread(resourceState.client, resourceState.thread.threadId);
 		const turnStartParams = buildTurnStartParams(runtimeParams, {
 			threadId: resourceState.thread.threadId,
 			cwd: resourceState.codexExecutionCwd,
@@ -8029,7 +8067,6 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 				modelProvider: resourceState.thread.modelProvider
 			},
 			turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
-			skillsCollaborationInstructions: context.skillsCollaborationInstructions,
 			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
 			preserveNativeTurnSettings: usesSupervisionConnection,
 			parentLocalEgress: inferenceRoute !== void 0,
@@ -8037,15 +8074,51 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			requireExplicitMessageTarget: attemptTools.requireExplicitMessageTarget,
 			sessionStatusAvailable: toolBridge.availableTools.some((tool) => tool.name === "session_status")
 		});
+		const serviceTier = await resolveCodexUltrafastServiceTier({
+			enabled: turnAppServer.enableUltrafast === true && fastMode !== false,
+			serviceTier: turnStartParams.serviceTier,
+			model: turnStartParams.model ?? model,
+			modelProvider,
+			client: turnClient,
+			timeoutMs: Math.min(params.timeoutMs, 2500),
+			signal: runAbortController.signal,
+			assertCurrent: assertTurnCurrent,
+			config: params.config
+		});
+		assertTurnCurrent();
+		turnStartParams.serviceTier = serviceTier;
+		connection.mutable.pluginAppServer = {
+			...turnAppServer,
+			serviceTier
+		};
+		const authorizedModel = nativeModel ? {
+			provider: nativeModel.modelProvider,
+			model: nativeModel.model
+		} : effectiveRuntimeModelId === readCodexRuntimeModelId(params.model, params.modelId) ? {
+			provider: params.provider,
+			model: params.modelId
+		} : turnStartParams.model ? {
+			provider: modelProvider ?? params.provider,
+			model: turnStartParams.model
+		} : void 0;
+		connection.bindModelExecution(authorizedModel);
+		const nativeRequestModel = turnStartParams.model ?? model;
+		const modelMapping = authorizedModel && nativeRequestModel ? {
+			nativeModel: {
+				provider: modelProvider ?? params.provider,
+				model: nativeRequestModel
+			},
+			authorizedModel
+		} : void 0;
 		if (inferenceRoute) {
-			prompt.setParentLocalEgress();
+			if (!usesSupervisionConnection) prompt.setParentLocalEgress();
 			resourceState.releaseInferenceContext?.();
 			const inferenceThread = resourceState.thread;
 			const registration = inferenceRoute.context.register({
 				threadId: resourceState.thread.threadId,
-				text: buildCodexParentLocalInstructions(runtimeParams, {
+				text: usesSupervisionConnection ? "" : buildCodexParentLocalInstructions(runtimeParams, {
 					turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
-					skillsCollaborationInstructions: context.skillsCollaborationInstructions,
+					skillsInstructions: context.skillsInstructions,
 					memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
 				}) ?? "",
 				signal: runAbortController.signal,
@@ -8122,6 +8195,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			acceptedTurnId = startedTurn.turn.id;
 			resources.nativeProcessAuthority?.bindTurn(turnClient, threadId, acceptedTurnId);
 			assertTurnCurrent();
+			resourceState.nativeSubagentMonitor?.bindTurn(acceptedTurnId, modelMapping);
 			if (upstreamUserText.includes(workspaceBootstrapContext.promptContext ?? "")) references.accepted();
 			throwIfTurnStartAcceptedAfterAbort();
 			await continuation?.accept(acceptedTurnId);
@@ -8160,20 +8234,24 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 	}
 	prepareWorkspaceReferences();
 	const buildLlmInputEvent = () => ({
-		runId: params.runId,
-		sessionId: params.sessionId,
-		provider: usesSupervisionConnection ? resourceState.thread.modelProvider ?? effectiveRuntimeProviderId : params.provider,
-		model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId,
+		...buildModelCallIdentity(),
 		systemPrompt: buildRenderedCodexDeveloperInstructions(),
 		prompt: turnState.codexTurnPromptText,
-		historyMessages: prompt.codexModelInputHistoryMessages,
+		historyMessages: [],
 		imagesCount: prompt.contextImageGroups.reduce((count, group) => count + group.images.length, 0) + (params.images?.length ?? 0),
 		tools
 	});
+	const buildLlmOutputEvent = () => ({
+		...buildModelCallIdentity(),
+		...hookContextWindowFields,
+		resolvedRef: usesSupervisionConnection ? `${resourceState.thread.modelProvider ?? effectiveRuntimeProviderId}/${resourceState.thread.model ?? effectiveRuntimeModelId}` : params.runtimePlan?.observability.resolvedRef ?? `${params.provider}/${params.modelId}`,
+		...!usesSupervisionConnection && params.runtimePlan?.observability.harnessId ? { harnessId: params.runtimePlan.observability.harnessId } : {}
+	});
 	return {
 		codexModelCallDiagnostics,
 		startCodexTurn,
-		buildLlmInputEvent
+		buildLlmInputEvent,
+		buildLlmOutputEvent
 	};
 }
 //#endregion
@@ -8181,12 +8259,12 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 async function startCodexAttemptTurn(resources, turnRuntime, notifications, requestRuntime) {
 	const { prompt, state: resourceState, trajectoryRecorder, markTrajectoryEndRecorded } = resources;
 	const { context, turnState, systemPromptReport } = prompt;
-	const { runtime, historyState, hookContext, hookContextWindowFields, hookRunner } = context;
-	const { connection, runtimeParams, effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
-	const { params, usesSupervisionConnection, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, attemptStartedAt, startupAuthProfileId } = connection;
+	const { runtime, historyState, hookContext, hookRunner } = context;
+	const { connection, runtimeParams } = runtime;
+	const { params, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, attemptStartedAt, startupAuthProfileId } = connection;
 	const { state, turnIdRef } = turnRuntime;
 	const { waitForActiveNativeTurnCompletion } = notifications;
-	const { codexModelCallDiagnostics, startCodexTurn, buildLlmInputEvent } = requestRuntime;
+	const { codexModelCallDiagnostics, startCodexTurn, buildLlmInputEvent, buildLlmOutputEvent } = requestRuntime;
 	let started;
 	resourceState.turnStartAttempted = true;
 	try {
@@ -8229,27 +8307,12 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			if (!await bindingStore.mutate(bindingIdentity, {
 				kind: "clear",
 				threadId: resourceState.thread.threadId
-			})) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
+			}, connection.assertCurrent)) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
 				threadId: resourceState.thread.threadId,
 				error: formatErrorMessage(turnStartError)
 			});
 			else {
 				resourceState.thread = await resourceState.restartContextEngineCodexThread();
-				const retryBinding = bindingStore.read(bindingIdentity);
-				if (retryBinding && retryBinding.threadId === resourceState.thread.threadId && retryBinding.contextEngine?.projection) {
-					await bindingStore.mutate(bindingIdentity, {
-						kind: "patch",
-						threadId: retryBinding.threadId,
-						patch: { contextEngine: {
-							...retryBinding.contextEngine,
-							projection: void 0
-						} }
-					});
-					embeddedAgentLog.info("codex app-server cleared stale context-engine projection after overflow retry", {
-						threadId: resourceState.thread.threadId,
-						previousEpoch: retryBinding.contextEngine.projection.epoch
-					});
-				}
 				emitCodexAppServerEvent(params, {
 					stream: "codex_app_server.lifecycle",
 					data: {
@@ -8298,13 +8361,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			markTrajectoryEndRecorded();
 			runAgentHarnessLlmOutputHook({
 				event: {
-					runId: params.runId,
-					sessionId: params.sessionId,
-					provider: usesSupervisionConnection ? resourceState.thread.modelProvider ?? effectiveRuntimeProviderId : params.provider,
-					model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId,
-					...hookContextWindowFields,
-					resolvedRef: usesSupervisionConnection ? `${resourceState.thread.modelProvider ?? effectiveRuntimeProviderId}/${resourceState.thread.model ?? effectiveRuntimeModelId}` : params.runtimePlan?.observability.resolvedRef ?? `${params.provider}/${params.modelId}`,
-					...!usesSupervisionConnection && params.runtimePlan?.observability.harnessId ? { harnessId: params.runtimePlan.observability.harnessId } : {},
+					...buildLlmOutputEvent(),
 					assistantTexts: []
 				},
 				ctx: hookContext,
@@ -8373,63 +8430,9 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 		configCwd: connection.effectiveCwd
 	};
 	turnIdRef.current = started.turn.turn.id;
-	resourceState.nativeSubagentMonitor?.bindTurn(started.turn.turn.id);
 	return started;
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-deadlines.ts
-function createCodexAttemptDeadlineController(params) {
-	let deadline = { kind: "closed" };
-	let timer;
-	const armDeadline = (next) => {
-		clearTimeout(timer);
-		deadline = next;
-		const deadlineAtMs = next.startedAtMs + next.timeoutMs;
-		params.onDeadlineChanged?.({
-			kind: "bounded",
-			deadlineAtMs
-		});
-		timer = setTimeout(() => {
-			if (deadline !== next || params.signal.aborted) return;
-			deadline = { kind: "closed" };
-			params.onTimeout({
-				kind: next.kind,
-				elapsedMs: Math.max(0, Date.now() - next.startedAtMs),
-				timeoutMs: next.timeoutMs
-			});
-		}, resolveTimerTimeoutMs(Math.max(1, deadlineAtMs - Date.now()), 1));
-		timer.unref?.();
-	};
-	const dispose = () => {
-		deadline = { kind: "closed" };
-		clearTimeout(timer);
-		params.signal.removeEventListener("abort", dispose);
-	};
-	if (!params.signal.aborted) {
-		params.signal.addEventListener("abort", dispose, { once: true });
-		if (params.timeoutMs >= MAX_TIMER_TIMEOUT_MS) {
-			deadline = { kind: "unlimited" };
-			params.onDeadlineChanged?.({ kind: "unlimited" });
-		} else armDeadline({
-			kind: "execution",
-			startedAtMs: params.startedAtMs,
-			timeoutMs: params.timeoutMs
-		});
-	}
-	return {
-		ownsExecutionWait: () => deadline.kind === "unlimited" || deadline.kind === "execution" && Date.now() < deadline.startedAtMs + deadline.timeoutMs,
-		beginSettlement: (startedAtMs) => {
-			if (deadline.kind === "closed" || deadline.kind === "settlement") return;
-			armDeadline({
-				kind: "settlement",
-				startedAtMs,
-				timeoutMs: TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS
-			});
-		},
-		dispose
-	};
-}
-//#endregion
 //#region extensions/codex/src/app-server/run-attempt-turn-state.ts
 const CODEX_NATIVE_HOOK_RELAY_RENEW_INTERVAL_MS = 6e4;
 var CodexAttemptState = class {
@@ -8459,7 +8462,11 @@ function createCodexAttemptTurnState(resources) {
 	const { promise: completion, resolve: resolveCompletion } = createDeferred();
 	const settlementExpired = createDeferred();
 	const pendingOpenClawDynamicToolCompletionIds = /* @__PURE__ */ new Set();
-	const openClawDynamicToolExecutions = createCodexDynamicToolExecutionRegistry();
+	const openClawDynamicToolExecutions = createAgentHarnessToolExecutionRegistry((call) => [
+		call.threadId,
+		call.turnId,
+		call.callId
+	]);
 	const activeTurnItemIds = /* @__PURE__ */ new Set();
 	const turnIdRef = {};
 	const userInputBridgeRef = {};
@@ -8521,9 +8528,10 @@ function createCodexAttemptTurnState(resources) {
 			reason: `codex_app_server:${reason}`
 		});
 	};
-	const deadlines = createCodexAttemptDeadlineController({
+	const deadlines = createAgentHarnessAttemptDeadlineController({
 		startedAtMs: connection.attemptStartedAt,
 		timeoutMs: params.timeoutMs,
+		settlementTimeoutMs: TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS,
 		signal: runAbortController.signal,
 		onDeadlineChanged: params.onAttemptDeadlineChanged,
 		onTimeout: (timeout) => {
@@ -8572,7 +8580,6 @@ function createCodexAttemptTurnState(resources) {
 		steeringQueueRef,
 		completeTurn,
 		interruptTurn,
-		renewNativeHookRelayForTurnProgress,
 		noteProgress,
 		deadlines
 	};
@@ -8604,7 +8611,10 @@ async function runCodexAppServerAttempt(params, options) {
 					const turnRequest = await preparation.measure("turn-request", () => prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurrentThreadRoute, notifications.waitForActiveNativeTurnCompletion));
 					preparation.ready();
 					const turnStart = await startCodexAttemptTurn(resources, turnRuntime, notifications, turnRequest);
-					if ("result" in turnStart) return turnStart.result;
+					if ("result" in turnStart) {
+						connection.assertModelExecutionCurrent();
+						return turnStart.result;
+					}
 					const activeTurn = activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, turnStart);
 					activeTurnOwnsCleanup = true;
 					let finalizedResult;
@@ -8627,6 +8637,7 @@ async function runCodexAppServerAttempt(params, options) {
 						delete finalizedResult.settledTurnFinalizationContext;
 					}
 					if (resources.state.executionDisconnectError && !connection.terminalState.explicitCancellationObserved) throw resources.state.executionDisconnectError;
+					connection.assertModelExecutionCurrent();
 					return finalizedResult;
 				} finally {
 					turnRuntime.deadlines.dispose();
@@ -8638,7 +8649,8 @@ async function runCodexAppServerAttempt(params, options) {
 			await attemptTools.disposeTools(connection.runAbortController.signal.aborted ? "cancel" : "error");
 		}
 	} finally {
-		params.abortSignal?.removeEventListener("abort", connection.abortFromUpstream);
+		connection.cancellation.dispose();
+		connection.releaseModelExecution();
 	}
 }
 //#endregion