@openclaw/codex 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{run-attempt-dYJhjZrp.mjs → run-attempt-BLDZeYLD.mjs}

@@ -1,60 +1,63 @@
 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 { g as createCodexNativeSubagentHistoryOwner } from "./native-subagent-pending-assignments-BDqhOdJp.mjs";
 import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.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-DIQ5O_-S.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 { i as matchesCodexNativeSubagentSubmissionBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-BZB8RgcF.mjs";
+import { n as defineCodexBuildState } from "./build-state-CqQnsg7T.mjs";
+import { c as shouldAutoApproveCodexAppServerApprovals, f as readCodexRequirementsToml, l as withMcpElicitationsApprovalPolicy, n as hasCodexMcpToolApprovalOverrides } from "./config-security-KAPScztc.mjs";
+import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, f as resolveCodexPluginsPolicy, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-BQq-CHTF.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-Dnps4W4_.mjs";
-import { d as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-lifecycle-7xgtlo15.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 { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext, o as resolveCodexComputerUseConfig } from "./config-options-HG_Rr3W_.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey, w as retireSharedCodexAppServerClientIfCurrent } from "./auth-cache-key-CGm0UJOr.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-DV3DHhdr.mjs";
+import { a as codexPrewriteRejectionCause, i as CodexAppServerScopedRequestRejectedError, r as CodexAppServerRpcError } from "./rpc-error-hmWM21RB.mjs";
+import { n as waitForPromiseOrAbort } from "./timeout-CXOfNoaX.mjs";
 import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.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 { i as readCodexProviderRefusal, n as extractRawAssistantText, o as readItem, r as readCodexErrorNotificationMessage, s as readNullableString } from "./event-projector-values-DTqZHizf.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-BZOfsSXW.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 { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection, t as assertCodexSessionRuntimeOwnership } from "./binding-connection-C-08ez1w.mjs";
+import { n as requestCodexAppServerClientJson } from "./request-jSbhc1sg.mjs";
+import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-0Gxk3_eq.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, u as resolveProjectionPromptBudgetTokens } from "./context-engine-projection-CsgYSQhW.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-CJCTeFpQ.mjs";
+import { t as readCodexMirroredSessionHistoryMessages } from "./session-history-BogBHKLk.mjs";
+import { i as resolveCodexAppServerAuthProfileIdForAgent, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CgHQ8Vot.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-qhyYWbew.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-qyUBJlGZ.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-B-S7ngS_.mjs";
-import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BLWz7stm.mjs";
+import { A as resolveTerminalDynamicToolBatchAction, D as isDynamicToolTerminalDiagnosticEvent, E as hasPendingDynamicToolTerminalDiagnostic, H as resolveCodexAppServerClientInstanceId, M as toCodexDynamicToolProgressResponse, N as toCodexDynamicToolProtocolResponse, O as isMatchingDynamicToolTerminalDiagnostic, T as handleDynamicToolCallWithTimeout, _ as assertCodexTurnStartResponse, a as isCodexAppServerIndeterminateRequestCancellationError, i as isCodexAppServerConnectionClosedError, j as shouldReleaseTurnAfterTerminalDynamicTool, k as resolveDynamicToolCallTimeoutMs, l as CodexServerRequestResolvedError, o as isCodexAppServerIndeterminateTransportError, r as isCodexAppServerApprovalRequest, w as createCodexElicitationResponse, x as readCodexTurnCompletedNotification, y as readCodexDynamicToolCallParams, z as CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS } from "./client-C8lgBOoO.mjs";
+import { n as isCodexWebSocketOpenFailure } from "./transport-websocket-zqJ0Cmtn.mjs";
+import { a as isCodexNotificationForTurn, b as shouldClearTerminalPresentationForNativeItem, g as itemName, i as CodexProjectionDiagnostics, n as getCodexAppServerTurnRouter, o as readCodexNotificationThreadId, t as CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS, y as matchesCodexSnapshotTurn } from "./turn-router-sS69wYnI.mjs";
+import { d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnAndWaitBestEffort, u as shouldRetireCodexStartupClient } from "./attempt-client-cleanup-BH0hW2xU.mjs";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BoMwpuPN.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-DfLmPV0k.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-OWGOiDaV.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-_bAbjedG.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-BwkQXf9e.mjs";
-import { n as CodexThreadPolicyHandoffError, s as restoreCodexThreadSkillsCatalogAfterCompaction } from "./thread-policy-gNPzzpVp.mjs";
-import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-B6pPt21M.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-wSMQkbpV.mjs";
+import { n as listAllCodexAppServerModels } from "./models-DSseKSMg.mjs";
+import { B as hasCodexNativeToolCatalog, Ct as mergeCodexThreadConfigs, D as assertCodexNativeHookRelayAllowed, E as CodexManagedHooksOnlyError, F as scheduleCodexNativeHookRelayUnregister, G as areCodexDynamicToolFingerprintsCompatible, J as codexLegacyDynamicToolsFingerprint, N as resolveCodexNativeHookRelayEvents, O as buildCodexNativeHookRelayConfig, P as resolveCodexNativeHookRelayTtlMs, S as joinPresentSections, T as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, V as loadCodexNativeToolCatalog, Z as fingerprintJsonObject, _t as buildCodexPluginThreadConfigInputFingerprint, b as resolveCodexAppServerThreadModelSelection, dt as isSystemAgentOnlyCodexDynamicToolAllowlist, g as buildDeveloperInstructions, j as createCodexNativeHookRelay, k as buildCodexNativeHookRelayDisabledConfig, l as isCodexNativeDelegationDisabledForRun, m as resolveCodexWebSearchPlan, mt as resolveCodexDynamicToolsLoadingForRuntime, nt as stabilizeJsonValue, q as codexDynamicToolsFingerprint, st as filterCodexDynamicTools } from "./thread-requests-CL1e8Wmx.mjs";
+import { _ as buildContextEngineBinding, a as buildTurnStartParams, c as assertScheduledCodexAppAuthorityRuntime, d as buildScheduledCodexAppServerConnectionIdentity, f as captureScheduledCodexAppAuthority, g as isCodexAppServerProfilerEnabled, h as resolveScheduledCodexAppCreatorCaptureDecision, i as buildTurnCollaborationMode, l as buildLegacyScheduledCodexAppRecoveryPrompt, n as buildCodexParentLocalInstructions, o as buildCodexUserInput, s as startOrResumeThread, t as buildCodexHistoryProvenancePrefix, u as buildScheduledCodexAppAuthorityInputFingerprint, v as isContextEngineBindingCompatible } from "./thread-lifecycle-Cbz_7ySv.mjs";
+import { o as createCodexSessionGenerationSupersededError, r as resolveCodexSessionBinding, s as resolveCodexRunSessionBindingAuthority, t as clearCodexBindingForClient } from "./session-binding-Ce7BqiPN.mjs";
+import { a as CodexToolTranscriptProjection, c as shouldEmitTranscriptToolProgress, d as resolveCodexToolProgressDetailMode, f as sanitizeCodexAgentEventRecord, i as emitCodexAgentEvent, p as sanitizeCodexToolArguments, r as CodexEventProjection, s as CodexToolProgressProjection, t as codexNativeSubagentMonitorRuntime, u as isCodexCommandBearingToolCall } from "./native-subagent-monitor-BUYOUp9X.mjs";
+import { a as requestPluginApprovalOutcome } from "./plugin-approval-roundtrip-CuahdPLC.mjs";
+import { n as CodexThreadPolicyHandoffError, s as restoreCodexThreadInstructionsAfterCompaction } from "./thread-policy-DoNxbhqt.mjs";
+import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DwuSrt3s.mjs";
+import { a as resolveCodexPromptError, i as refreshCodexUsageLimitPromptError, n as formatCodexTurnStartUsageLimitError, r as markCodexAuthProfileBlockedFromRateLimits, t as CodexUsageLimitPromptError } from "./usage-limit-error-GbT-5NcW.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-C-6O3Exn.mjs";
+import { a as runCodexAgentEndHook, i as reportCodexBackgroundCleanupFailure, n as ensureCodexWorkspaceDirOnce, o as shouldKeepCodexSharedAbortOpen, r as estimateCodexAppServerProjectedTurnTokens, s as withCodexAppServerFastModeServiceTier, t as emitCodexAppServerEvent } from "./run-attempt-lifecycle-BuZgVbDA.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-MV_1dj-3.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-Db2sY5cZ.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-BJ5Z_olH.mjs";
-import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-D4yj4rxf.mjs";
-import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-DG5qbsUZ.mjs";
-import { a as createComputerUseRequest, n as ensureCodexComputerUse, o as runCodexComputerUseLiveTest, t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-BRwtRct9.mjs";
-import { asOptionalRecord, normalizeOptionalString, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { i as createAssistantReasoningMessage, n as createAssistantCommentaryMessage, r as createAssistantMessage, t as createAssistantAsyncMessage } from "./event-projector-assistant-message-BN7CNUB5.mjs";
+import { a as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as shouldEnableCodexAppServerNativeToolSurface, i as resolveCodexAppServerHookChannelId, l as shouldRequireCodexSandboxExecServerEnvironment, o as resolveCodexMessageToolProvider, p as mapCodexAppServerRemoteWorkspacePath, r as resolveCodexAppServerExecutionCwd, s as resolveCodexSandboxEnvironmentSelection, t as buildDynamicTools, u as shouldWarnCodexDynamicToolBuildStageSummary } from "./dynamic-tool-build-C8xGEXmR.mjs";
+import { n as resolveCodexPluginThreadConfigStartupPolicy, t as createCodexPluginThreadConfigStartupProvider } from "./plugin-thread-config-deadline-B8LGaZNW.mjs";
+import { i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy } from "./session-permission-policy-BxIUJ0Zd.mjs";
+import { r as prepareCodexNativeMcpFormResourceContext, t as createCodexNativeMcpAppResultDetailsPreparer } from "./native-mcp-app-CqcPVmhH.mjs";
+import { a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, d as CodexNativeProcessAuthority, f as readCodexRetainedBackgroundCommands, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as CodexNativeToolLifecycleProjector, n as projectCodexExecutableDynamicTools, o as emitDynamicToolTerminalDiagnostic, p as createCodexRemoteWorkspaceFileReader, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as createCodexNativePreToolUseFailureBuffer } from "./dynamic-tools-DyERJnR6.mjs";
+import { c as promptSnapshot, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as buildResolvedCodexUserPromptMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BfLRARNL.mjs";
+import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-Bg4FZw1f.mjs";
+import { a as getCodexContextFileDisplayBasename, i as getCodexContextFileBasename, n as CODEX_NATIVE_PROJECT_DOC_BASENAMES, o as isNonEmptyString, r as buildCodexWorkspaceBootstrapContext, s as normalizeCodexContextFilePath } from "./attempt-workspace-context-BY0jprWJ.mjs";
+import { n as captureCodexSettledTurnFinalizationContext } from "./settled-turn-context-BZsMjkIO.mjs";
+import { t as resolveCodexProviderWebSearchSupport } from "./provider-capabilities-D68Whix6.mjs";
+import { a as runCodexComputerUseLiveTest, i as createComputerUseRequest, t as ensureCodexComputerUse } from "./computer-use-BBN9y326.mjs";
+import { asOptionalRecord, normalizeLowercaseStringOrEmpty, 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";
@@ -63,25 +66,28 @@ 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 { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 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, 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 { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, HEARTBEAT_RESPONSE_TOOL_NAME, agentHarnessStructuredInput, applyEmbeddedAttemptToolsAllow, assembleHarnessContextEngine, assertContextEngineHostSupport, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedForegroundPromptContext, buildHarnessContextEngineRuntimeContext, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, emptyAgentHarnessUserInputAnswers, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, hasBeforeToolCallPolicy, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, normalizeHeartbeatToolResponse, prepareWatchedSessionsHarnessContext, projectAgentHarnessTranscriptMessageForDisplay, projectAgentToolActivity, projectProgressCardChannelUpdate, resolveAgentDir as resolveAgentDir$1, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveAttemptFsWorkspaceOnly, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { resolveAgentDir as resolveAgentDir$2 } from "openclaw/plugin-sdk/agent-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, createAgentHarnessToolExecutionRegistry } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { acknowledgeInternalToolResult, createAgentHarnessToolExecutionRegistry } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+import { createNativeSessionBindingAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
 import { captureFinalCodexCronCreatorToolAllowlist, formatMcpCodexApprovalRemedy, materializeStaticMcpToolsForHarnessRun, resolveCodexMcpToolOverridesForAgent, resolveCodexTtsProvenanceTransfer } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { appendSessionYieldContext, hasPromptImageInput } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
 import { isSilentReplyPayloadText } from "openclaw/plugin-sdk/reply-chunking";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
+import { estimateBase64DecodedBytes } from "openclaw/plugin-sdk/media-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";
@@ -175,6 +181,7 @@ function createCodexSteeringQueue(params) {
 		acceptItem(item);
 		item.settled = true;
 		pendingMessages.delete(item);
+		item.onQueueSettled?.();
 		item.resolve();
 	};
 	const rejectItem = (item, error) => {
@@ -182,6 +189,7 @@ function createCodexSteeringQueue(params) {
 		item.settled = true;
 		pendingMessages.delete(item);
 		reportItemAcceptance(item, false);
+		item.onQueueSettled?.();
 		item.reject(item.acceptance === "accepted" ? new CodexSteeringAcceptedUnconfirmedError("Codex accepted steering but did not confirm transcript consumption", { cause: error }) : error);
 	};
 	const closeQueue = (error) => {
@@ -249,7 +257,7 @@ function createCodexSteeringQueue(params) {
 				if (liveItems.length === 0) return;
 			}
 			clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-			dispatchedBatches.set(clientUserMessageId, liveItems);
+			if (!params.withCurrent) dispatchedBatches.set(clientUserMessageId, liveItems);
 			const request = {
 				threadId: params.threadId,
 				expectedTurnId: params.turnId,
@@ -259,6 +267,8 @@ function createCodexSteeringQueue(params) {
 			await params.client.request("turn/steer", request, {
 				timeoutMs: params.requestTimeoutMs,
 				signal: params.signal,
+				...params.withCurrent ? { withCurrent: params.withCurrent } : {},
+				onIngressRejected: () => dispatchedBatches.delete(request.clientUserMessageId),
 				assertCurrent: () => {
 					assertActive();
 					liveItems = liveItems.filter(isCurrent);
@@ -279,7 +289,11 @@ function createCodexSteeringQueue(params) {
 			throw error;
 		}
 	};
-	const enqueueSend = (items) => {
+	const flushBatch = () => {
+		clearBatchTimer();
+		const items = batchedMessages;
+		batchedMessages = [];
+		if (items.length === 0) return sendChain;
 		const send = sendChain.then(() => sendBatch(items));
 		sendChain = send;
 		send.catch((error) => {
@@ -288,32 +302,6 @@ function createCodexSteeringQueue(params) {
 		});
 		return send;
 	};
-	const flushBatch = () => {
-		clearBatchTimer();
-		const items = batchedMessages;
-		batchedMessages = [];
-		if (items.length === 0) return sendChain;
-		const send = enqueueSend(items);
-		send.catch(() => void 0);
-		return send;
-	};
-	const createPendingMessage = (text, options, assertCurrent = () => {}) => {
-		const { promise: delivery, resolve, reject } = createDeferred();
-		const item = {
-			...options,
-			assertCurrent,
-			acceptance: "open",
-			text,
-			resolve,
-			reject,
-			settled: false
-		};
-		pendingMessages.add(item);
-		return {
-			item,
-			delivery
-		};
-	};
 	params.signal.addEventListener("abort", abortQueue, { once: true });
 	if (params.signal.aborted) abortQueue();
 	return {
@@ -323,9 +311,20 @@ function createCodexSteeringQueue(params) {
 				assertCurrent();
 			} catch (error) {
 				options?.onQueueAccepted?.(false);
+				options?.onQueueSettled?.();
 				throw error;
 			}
-			const { item, delivery } = createPendingMessage(text, options, assertCurrent);
+			const { promise: delivery, resolve, reject } = createDeferred();
+			const item = {
+				...options,
+				assertCurrent,
+				acceptance: "open",
+				text,
+				resolve,
+				reject,
+				settled: false
+			};
+			pendingMessages.add(item);
 			batchedMessages.push(item);
 			clearBatchTimer();
 			const debounceMs = normalizeCodexSteerDebounceMs(options?.debounceMs);
@@ -523,7 +522,7 @@ var CodexAssistantProjection = class {
 		if (this.persistedAssistantBoundary) return [];
 		const recoveredAudible = this.collectPersistableAssistantTexts(0).filter((text) => !isSilentReplyPayloadText(text));
 		if (recoveredAudible.length > 0) return recoveredAudible.slice(-1);
-		const recovered = this.resolveFinalAssistantTextItem()?.text;
+		const recovered = this.resolveFinalAssistantText();
 		return recovered ? [recovered] : [];
 	}
 	collectCommentaryMessages() {
@@ -600,13 +599,7 @@ var CodexAssistantProjection = class {
 		this.emitAnswerCandidate(itemId, "selected");
 	}
 	hasAssistantItemTextForSynthesis() {
-		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
-			const itemId = this.assistantItemOrder[i];
-			if (!itemId || this.isNonTerminalAssistantItem(itemId)) continue;
-			const text = this.assistantTextByItem.get(itemId);
-			if (text && text.length > 0) return true;
-		}
-		return false;
+		return this.assistantItemOrder.some((itemId) => Boolean(itemId) && !this.isNonTerminalAssistantItem(itemId) && Boolean(this.assistantTextByItem.get(itemId)));
 	}
 	createCurrentAttemptAssistantMessage(options) {
 		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
@@ -717,16 +710,13 @@ var CodexAssistantProjection = class {
 		this.terminalAssistantCandidateEarlierActiveItemIds.clear();
 		this.supersedeVisibleAnswerCandidate();
 	}
-	resolveFinalAssistantTextItem() {
+	resolveFinalAssistantText() {
 		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
 			const itemId = this.assistantItemOrder[i];
 			if (!itemId) continue;
 			const text = this.assistantTextByItem.get(itemId)?.trim();
 			if (this.isNonTerminalAssistantItem(itemId)) continue;
-			if (text && !this.isToolProgressEchoText(itemId, text)) return {
-				itemId,
-				text
-			};
+			if (text && !this.isToolProgressEchoText(itemId, text)) return text;
 		}
 	}
 	collectPersistableAssistantTexts(minIndex) {
@@ -860,19 +850,19 @@ var CodexGeneratedMediaProjection = class {
 					return;
 				}
 				try {
-					const response = await this.remote.readFile({
+					const bytes = await this.remote.readFile({
 						path: savedPath,
 						maxBytes: resolveGeneratedMediaMaxBytes(this.config, "image"),
 						signal: this.remote.signal,
 						timeoutMs: this.remote.requestTimeoutMs
 					});
-					if (!response || typeof response.dataBase64 !== "string" || !response.dataBase64) {
+					if (!bytes.length) {
 						embeddedAgentLog.warn("codex remote image file returned no inline bytes", { itemId: item.id });
 						return;
 					}
 					await this.recordImage({
 						itemId: item.id,
-						result: response.dataBase64,
+						result: bytes.toString("base64"),
 						revisedPrompt: readStringField(item, "revisedPrompt"),
 						source: "native"
 					});
@@ -884,8 +874,9 @@ var CodexGeneratedMediaProjection = class {
 				}
 				return;
 			}
-			this.recordUrl({
-				itemId: item.id,
+			const existing = this.mediaByItemId.get(item.id);
+			if (!existing?.mediaUrl) this.mediaByItemId.set(item.id, {
+				...existing,
 				mediaUrl: savedPath
 			});
 		}
@@ -922,7 +913,7 @@ var CodexGeneratedMediaProjection = class {
 	async materializeImage(params) {
 		const maxBytes = resolveGeneratedMediaMaxBytes(this.config, "image");
 		const estimatedDecodedBytes = estimateBase64DecodedBytes(params.result);
-		if (estimatedDecodedBytes !== void 0 && estimatedDecodedBytes > maxBytes) {
+		if (estimatedDecodedBytes > maxBytes) {
 			embeddedAgentLog.warn(`codex app-server ${params.source} image generation result exceeds media limit`, {
 				itemId: params.itemId,
 				estimatedDecodedBytes,
@@ -941,10 +932,9 @@ var CodexGeneratedMediaProjection = class {
 		try {
 			const saved = await saveMediaBuffer(asset.buffer, asset.mimeType, GENERATED_IMAGE_MEDIA_SUBDIR, maxBytes, asset.fileName);
 			this.gatewayMaterializedItemIds.add(params.itemId);
-			this.recordUrl({
-				itemId: params.itemId,
-				mediaUrl: saved.path,
-				replaceExisting: true
+			this.mediaByItemId.set(params.itemId, {
+				...this.mediaByItemId.get(params.itemId),
+				mediaUrl: saved.path
 			});
 		} catch (error) {
 			embeddedAgentLog.warn(`codex app-server ${params.source} image generation result save failed`, {
@@ -990,38 +980,7 @@ var CodexGeneratedMediaProjection = class {
 			})
 		};
 	}
-	recordUrl(params) {
-		const existing = this.mediaByItemId.get(params.itemId);
-		if (existing?.mediaUrl && params.replaceExisting !== true) {
-			this.itemIds.add(params.itemId);
-			return;
-		}
-		this.mediaByItemId.set(params.itemId, {
-			...existing,
-			mediaUrl: params.mediaUrl
-		});
-		this.itemIds.add(params.itemId);
-	}
 };
-function estimateBase64DecodedBytes(base64) {
-	let nonWhitespaceLength = 0;
-	let previousCode = -1;
-	let lastCode = -1;
-	for (let i = 0; i < base64.length; i += 1) {
-		const code = base64.charCodeAt(i);
-		if (isBase64WhitespaceCode(code)) continue;
-		nonWhitespaceLength += 1;
-		previousCode = lastCode;
-		lastCode = code;
-	}
-	if (nonWhitespaceLength === 0) return;
-	const equalsCode = "=".charCodeAt(0);
-	const padding = lastCode === equalsCode ? previousCode === equalsCode ? 2 : 1 : 0;
-	return Math.max(0, Math.floor(nonWhitespaceLength * 3 / 4) - padding);
-}
-function isBase64WhitespaceCode(code) {
-	return code === 32 || code === 9 || code === 10 || code === 13;
-}
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-reasoning.ts
 var CodexReasoningProjection = class {
@@ -1044,7 +1003,8 @@ var CodexReasoningProjection = class {
 			content: /* @__PURE__ */ new Map()
 		};
 		this.reasoningTextByItem.set(itemId, item);
-		const groupIndex = method === "item/reasoning/textDelta" ? readNonNegativeInteger(params, "contentIndex") ?? 0 : readNonNegativeInteger(params, "summaryIndex") ?? 0;
+		const index = params[method === "item/reasoning/textDelta" ? "contentIndex" : "summaryIndex"];
+		const groupIndex = typeof index === "number" && Number.isInteger(index) && index >= 0 ? index : 0;
 		const sections = method === "item/reasoning/textDelta" ? item.content : item.summary;
 		sections.set(groupIndex, `${sections.get(groupIndex) ?? ""}${delta}`);
 		await this.params.onReasoningStream?.({
@@ -1056,15 +1016,7 @@ var CodexReasoningProjection = class {
 		const itemId = readStringField(params, "itemId") ?? "plan";
 		const delta = readStringField(params, "delta") ?? "";
 		if (!delta) return;
-		const text = `${this.planTextByItem.get(itemId) ?? ""}${delta}`;
-		this.planTextByItem.set(itemId, text);
-		this.emitPlanUpdate({
-			explanation: void 0,
-			steps: splitPlanText(text).map((step) => ({
-				step,
-				status: "pending"
-			}))
-		});
+		this.recordPlanText(itemId, `${this.planTextByItem.get(itemId) ?? ""}${delta}`);
 	}
 	async handleTurnPlanUpdated(params, source = "codex-app-server") {
 		const explanation = readNullableString(params, "explanation");
@@ -1106,16 +1058,7 @@ var CodexReasoningProjection = class {
 			}
 			return;
 		}
-		if (item?.type === "plan" && typeof item.text === "string" && item.text) {
-			this.planTextByItem.set(item.id, item.text);
-			this.emitPlanUpdate({
-				explanation: void 0,
-				steps: splitPlanText(item.text).map((step) => ({
-					step,
-					status: "pending"
-				}))
-			});
-		}
+		if (item?.type === "plan" && typeof item.text === "string" && item.text) this.recordPlanText(item.id, item.text);
 	}
 	async maybeEndReasoning() {
 		if (!this.reasoningStarted || this.reasoningEnded) return;
@@ -1128,6 +1071,13 @@ var CodexReasoningProjection = class {
 	planText() {
 		return this.turnPlanText ?? [...this.planTextByItem.values()].filter((text) => text.trim().length > 0).join("\n\n");
 	}
+	recordPlanText(itemId, text) {
+		this.planTextByItem.set(itemId, text);
+		this.emitPlanUpdate({ steps: text.split(/\r?\n/).map((line) => line.trim().replace(/^[-*]\s+/, "")).filter((line) => line.length > 0).map((step) => ({
+			step,
+			status: "pending"
+		})) });
+	}
 	emitPlanUpdate(params, source = "codex-app-server") {
 		if (!params.explanation && params.steps === void 0) return;
 		this.emitAgentEvent({
@@ -1238,6 +1188,136 @@ var CodexTerminalFailureProjection = class {
 	}
 };
 //#endregion
+//#region extensions/codex/src/app-server/event-projector-tool-search-evidence.ts
+const MAX_RETAINED_SEARCHES = 16;
+const MAX_RETAINED_DYNAMIC_CALLS = 32;
+const MAX_DISCOVERED_TOOLS = 32;
+const MAX_ID_CHARS = 256;
+const MAX_NAME_CHARS = 128;
+function readBoundedString(value, maxChars) {
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	if (!normalized) return;
+	return normalized.slice(0, maxChars);
+}
+function trimOldest(map, maxSize) {
+	while (map.size > maxSize) {
+		const oldest = map.keys().next().value;
+		if (oldest === void 0) return;
+		map.delete(oldest);
+	}
+}
+function collectToolRefs(values, output, seen, inheritedNamespace) {
+	if (!Array.isArray(values)) return false;
+	let truncated = false;
+	for (const value of values) {
+		if (!isJsonObject(value)) continue;
+		const type = readBoundedString(value.type, MAX_NAME_CHARS);
+		const name = readBoundedString(value.name, MAX_NAME_CHARS);
+		if (type === "namespace" && name) {
+			truncated = collectToolRefs(value.tools, output, seen, name) || truncated;
+			continue;
+		}
+		if (type !== "function" || !name) continue;
+		const namespace = readBoundedString(value.namespace, MAX_NAME_CHARS) ?? inheritedNamespace;
+		const key = `${namespace ?? ""}\u0000${name}`;
+		if (seen.has(key)) continue;
+		if (output.length >= MAX_DISCOVERED_TOOLS) {
+			truncated = true;
+			continue;
+		}
+		seen.add(key);
+		output.push({
+			...namespace ? { namespace } : {},
+			name
+		});
+	}
+	return truncated;
+}
+/** Private-QA projection of searchable discovery receipts; never enters chat history. */
+var CodexToolSearchEvidenceProjection = class {
+	constructor(recorder, threadId, turnId) {
+		this.recorder = recorder;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.calls = /* @__PURE__ */ new Map();
+		this.outputs = /* @__PURE__ */ new Map();
+		this.dynamicCalls = /* @__PURE__ */ new Map();
+	}
+	recordRawResponseItem(item) {
+		const type = readBoundedString(item.type, MAX_NAME_CHARS);
+		const callId = readBoundedString(item.call_id, MAX_ID_CHARS);
+		if (!callId) return;
+		if (type === "tool_search_call") {
+			const execution = readBoundedString(item.execution, MAX_NAME_CHARS);
+			const status = readBoundedString(item.status, MAX_NAME_CHARS);
+			this.calls.set(callId, {
+				callId,
+				...execution ? { execution } : {},
+				...status ? { status } : {}
+			});
+			trimOldest(this.calls, MAX_RETAINED_SEARCHES);
+			return;
+		}
+		if (type !== "tool_search_output") return;
+		const call = this.calls.get(callId);
+		if (!call) return;
+		const tools = [];
+		const truncated = collectToolRefs(item.tools, tools, /* @__PURE__ */ new Set());
+		const execution = readBoundedString(item.execution, MAX_NAME_CHARS);
+		const status = readBoundedString(item.status, MAX_NAME_CHARS);
+		this.outputs.set(callId, {
+			call,
+			...execution ? { execution } : {},
+			...status ? { status } : {},
+			tools,
+			truncated
+		});
+		trimOldest(this.outputs, MAX_RETAINED_SEARCHES);
+	}
+	recordDynamicToolCall(params) {
+		const callId = readBoundedString(params.callId, MAX_ID_CHARS);
+		const tool = readBoundedString(params.tool, MAX_NAME_CHARS);
+		const requestedNamespace = readBoundedString(params.namespace, MAX_NAME_CHARS);
+		if (!callId || !tool || !requestedNamespace || requestedNamespace !== params.namespace) return;
+		const search = [...this.outputs.values()].toReversed().find((candidate) => candidate.tools.some((ref) => ref.name === tool && ref.namespace === requestedNamespace));
+		if (!search) return;
+		this.dynamicCalls.set(callId, {
+			search,
+			namespace: requestedNamespace,
+			tool
+		});
+		trimOldest(this.dynamicCalls, MAX_RETAINED_DYNAMIC_CALLS);
+	}
+	recordDynamicToolResult(params) {
+		const callId = readBoundedString(params.callId, MAX_ID_CHARS);
+		const tool = readBoundedString(params.tool, MAX_NAME_CHARS);
+		if (!callId || !tool) return;
+		const link = this.dynamicCalls.get(callId);
+		if (!link || link.tool !== tool) return;
+		this.dynamicCalls.delete(callId);
+		this.recorder.recordEvent("tool.search.discovery", {
+			threadId: this.threadId,
+			turnId: this.turnId,
+			search: {
+				callId: link.search.call.callId,
+				...link.search.call.execution ? { callExecution: link.search.call.execution } : {},
+				...link.search.call.status ? { callStatus: link.search.call.status } : {},
+				...link.search.execution ? { outputExecution: link.search.execution } : {},
+				...link.search.status ? { outputStatus: link.search.status } : {},
+				tools: link.search.tools,
+				...link.search.truncated ? { truncated: true } : {}
+			},
+			target: {
+				callId,
+				namespace: link.namespace,
+				name: tool,
+				success: params.success
+			}
+		});
+	}
+};
+//#endregion
 //#region extensions/codex/src/app-server/transcript-checkpoint.ts
 /** Commits completed work in receipt order without waiting for the enclosing turn. */
 var CodexTranscriptCheckpoint = class {
@@ -1358,6 +1438,7 @@ var CodexTurnProjection = class {
 			trajectoryRecorder: options.trajectoryRecorder,
 			checkpointMessage: this.transcriptCheckpoint.enqueue
 		});
+		this.toolSearchEvidenceProjection = options.trajectoryRecorder && process.env.OPENCLAW_BUILD_PRIVATE_QA === "1" ? new CodexToolSearchEvidenceProjection(options.trajectoryRecorder, threadId, turnId) : void 0;
 		this.eventProjection = new CodexEventProjection(params.provider, threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
 		this.assistantProjection = new CodexAssistantProjection(this.settlement.params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), this.transcriptCheckpoint.nextTimestamp, this.transcriptCheckpoint.enqueueCommentary);
 		this.reasoningProjection = new CodexReasoningProjection(this.settlement.params, (event) => this.emitAgentEvent(event), options.onNativePlanUpdate);
@@ -1699,6 +1780,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		});
 	}
 	recordDynamicToolCall(params) {
+		this.toolSearchEvidenceProjection?.recordDynamicToolCall(params);
 		this.toolTranscriptProjection.recordDynamicToolCall(params);
 	}
 	/** Projects a successful OpenClaw progress_card call through the native plan stream. */
@@ -1714,6 +1796,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		}
 	}
 	recordDynamicToolResult(params) {
+		this.toolSearchEvidenceProjection?.recordDynamicToolResult(params);
 		this.toolProgressProjection.recordDynamicToolResult(params);
 		const source = this.options.resolveDynamicToolResultContentSource?.(params.tool);
 		this.toolTranscriptProjection.recordDynamicToolResult(params, source);
@@ -1941,6 +2024,7 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
 		if (item.role === "assistant" && extractRawAssistantText(item)) this.eventProjection.markSafetyBufferingAssistantStarted();
+		this.toolSearchEvidenceProjection?.recordRawResponseItem(item);
 		this.toolTranscriptProjection.recordRawNativeToolItem(item);
 		this.assistantProjection.handleRawResponseItemCompleted(item, this.activeItemIds);
 		await this.settlement.project("media_projection", () => this.generatedMediaProjection.recordRaw(item));
@@ -1952,145 +2036,6 @@ var CodexAppServerEventProjector = class extends CodexTurnProjection {
 	}
 };
 //#endregion
-//#region extensions/codex/src/app-server/native-mcp-app.ts
-const CODEX_APPS_MCP_SERVER = "codex_apps";
-function readMcpAppResourceUri(item) {
-	const appContext = asOptionalRecord(item.appContext);
-	const uri = normalizeOptionalString(appContext?.resourceUri) ?? normalizeOptionalString(item.mcpAppResourceUri);
-	return uri?.startsWith("ui://") ? uri : void 0;
-}
-function readMcpToolResult(item) {
-	const result = asOptionalRecord(item.result);
-	if (!result || !Array.isArray(result.content)) return;
-	const resultMeta = asOptionalRecord(result["_meta"]);
-	return {
-		content: result.content,
-		...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {},
-		...result.isError === true ? { isError: true } : {},
-		...resultMeta ? { _meta: resultMeta } : {}
-	};
-}
-function statusTools(status) {
-	return Object.entries(status.tools).map(([name, value]) => Object.assign({}, asOptionalRecord(value) ?? {}, { name }));
-}
-function createNativeMcpRuntime(params) {
-	let catalog = null;
-	let statuses;
-	const createdAt = Date.now();
-	const loadStatuses = async () => {
-		if (statuses) return statuses;
-		statuses = (await params.client.request("mcpServerStatus/list", {
-			threadId: params.threadId,
-			detail: "full"
-		})).data;
-		return statuses;
-	};
-	const getCatalog = async () => {
-		if (catalog) return catalog;
-		const loaded = await loadStatuses();
-		catalog = {
-			version: 1,
-			generatedAt: Date.now(),
-			servers: Object.fromEntries(loaded.map((status) => [status.name, {
-				serverName: status.name,
-				launchSummary: "Codex native MCP connection",
-				toolCount: Object.keys(status.tools).length
-			}])),
-			tools: loaded.flatMap((status) => statusTools(status).map((tool) => {
-				const uiVisibility = readCodexMcpToolUiVisibility(tool);
-				return Object.assign({
-					serverName: status.name,
-					safeServerName: status.name,
-					toolName: String(tool.name),
-					inputSchema: asOptionalRecord(tool.inputSchema) ?? { type: "object" },
-					fallbackDescription: normalizeOptionalString(tool.description) ?? String(tool.name)
-				}, uiVisibility ? { uiVisibility } : {});
-			}))
-		};
-		return catalog;
-	};
-	const runtime = {
-		sessionId: params.attempt.sessionId,
-		sessionKey: params.attempt.sessionKey,
-		workspaceDir: params.attempt.workspaceDir,
-		configFingerprint: `${getCodexAppServerClientInstanceId(params.client)}:${params.threadId}`,
-		mcpAppsEnabled: true,
-		createdAt,
-		lastUsedAt: createdAt,
-		acquireLease: () => retainSharedCodexAppServerClientIfCurrent(params.client) ?? (() => {}),
-		getCatalog,
-		peekCatalog: () => catalog,
-		markUsed: () => {
-			runtime.lastUsedAt = Date.now();
-		},
-		callTool: async (serverName, toolName, input) => await params.client.request("mcpServer/tool/call", {
-			threadId: params.threadId,
-			server: serverName,
-			tool: toolName,
-			arguments: asOptionalRecord(input) ?? {}
-		}),
-		listTools: async (serverName) => {
-			const status = (await loadStatuses()).find((entry) => entry.name === serverName);
-			return { tools: status ? statusTools(status) : [] };
-		},
-		readResource: async (serverName, uri) => {
-			const isCodexAppsServer = serverName === CODEX_APPS_MCP_SERVER;
-			const response = await params.client.request("mcpServer/resource/read", {
-				threadId: params.threadId,
-				...isCodexAppsServer ? { originCallId: params.originCallId } : {},
-				server: serverName,
-				uri,
-				...params.connectorId ? { connectorId: params.connectorId } : {}
-			});
-			if (isCodexAppsServer && response.originCallId !== params.originCallId) throw new Error(`Codex MCP resource response originCallId mismatch: expected ${params.originCallId}, received ${response.originCallId}`);
-			return response;
-		},
-		listResources: async (serverName) => {
-			return { resources: (await loadStatuses()).find((entry) => entry.name === serverName)?.resources ?? [] };
-		},
-		listResourceTemplates: async (serverName) => {
-			return { resourceTemplates: (await loadStatuses()).find((entry) => entry.name === serverName)?.resourceTemplates ?? [] };
-		},
-		joinCleanup: async () => {},
-		dispose: async () => {}
-	};
-	return runtime;
-}
-function createCodexNativeMcpAppResultDetailsPreparer(params) {
-	if (params.attempt.config?.mcp?.apps?.enabled !== true) return;
-	return async (item) => {
-		const serverName = normalizeOptionalString(item.server);
-		const toolName = normalizeOptionalString(item.tool);
-		const uiResourceUri = readMcpAppResourceUri(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;
-		const runtime = createNativeMcpRuntime({
-			...params,
-			originCallId: item.id,
-			...connectorId ? { connectorId } : {}
-		});
-		const tools = (await runtime.listTools?.(serverName))?.tools ?? [];
-		const allowedAppToolNames = new Set(tools.filter((tool) => {
-			const uiVisibility = readCodexMcpToolUiVisibility(tool);
-			return (uiVisibility === void 0 || uiVisibility.includes("app")) && (serverName !== CODEX_APPS_MCP_SERVER || readCodexMcpToolConnectorId(tool) === connectorId);
-		}).map((tool) => tool.name));
-		if (!allowedAppToolNames.has(toolName)) return;
-		return await prepareHarnessNativeMcpAppPreview({
-			runtime,
-			serverName,
-			toolName,
-			uiResourceUri,
-			toolCallId: item.id,
-			toolInput: item.arguments ?? {},
-			toolResult,
-			allowedAppToolNames,
-			...toolResult["_meta"] !== void 0 ? { resultMetaState: "unavailable" } : {}
-		});
-	};
-}
-//#endregion
 //#region extensions/codex/src/app-server/plan-compaction-state.ts
 const RESTORED_PLAN_PREAMBLE = "OpenClaw restored the session progress card after context compaction. This is application state, not a new user request. Continue the current task and call progress_card whenever the status meaningfully changes.";
 const PROGRESS_CARD_MAX_STEPS = 50;
@@ -2229,13 +2174,14 @@ async function restoreCodexAttemptCompactionContext(resources) {
 			error: formatErrorMessage(error)
 		});
 	}
-	thread.liveThreadEphemeralPolicy = await restoreCodexThreadSkillsCatalogAfterCompaction({
+	thread.liveThreadEphemeralPolicy = await restoreCodexThreadInstructionsAfterCompaction({
 		client,
 		threadId: thread.threadId,
 		ephemeralPolicy: thread.liveThreadEphemeralPolicy,
 		timeoutMs: connection.appServer.requestTimeoutMs,
 		signal: runAbortController.signal,
-		assertCurrent
+		assertCurrent,
+		withCurrent: connection.withCurrent
 	});
 }
 //#endregion
@@ -2317,9 +2263,10 @@ function createCodexUserInputBridge(params) {
 		},
 		async handleElicitationRequest(request, requestSignal) {
 			if (readOwnDataString(request.params, "threadId") !== params.threadId) return;
-			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params);
+			const mode = readOwnDataString(request.params, "mode");
+			const requestSnapshot = agentHarnessStructuredInput.snapshot(request.params, { richForm: mode === "openaiForm" || mode === "openai/form" });
 			if (agentHarnessStructuredInput.isRecord(requestSnapshot) && readOwnDataString(requestSnapshot, "threadId") !== params.threadId) return;
-			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-DPoK8F7w.mjs");
+			const { compileCodexOrdinaryElicitation } = await import("./elicitation-input-r9axtppm.mjs");
 			const compiled = agentHarnessStructuredInput.isRecord(requestSnapshot) ? compileCodexOrdinaryElicitation({
 				snapshot: requestSnapshot,
 				turnId: params.turnId
@@ -2337,13 +2284,29 @@ function createCodexUserInputBridge(params) {
 				cancelValue,
 				failureValue: declineElicitation("OpenClaw could not handle this elicitation."),
 				run: async (signal) => {
-					const result = await execute(compiled.input, timeoutMs, signal);
-					if (result.status === "answered") {
-						const content = compiled.input.kind === "ready" && compiled.input.plan.kind === "url" ? null : result.content;
-						return createCodexElicitationResponse("accept", content);
+					const resource = params.prepareResourceContext && agentHarnessStructuredInput.isRecord(requestSnapshot) && hasResourceInput(requestSnapshot) ? await params.prepareResourceContext({
+						requestId: request.id,
+						snapshot: requestSnapshot,
+						signal
+					}) : void 0;
+					try {
+						signal.throwIfAborted();
+						const withResources = resource && agentHarnessStructuredInput.isRecord(requestSnapshot) ? compileCodexOrdinaryElicitation({
+							snapshot: requestSnapshot,
+							turnId: params.turnId,
+							resourceContext: resource.context
+						}) : compiled;
+						if (withResources.kind === "ignored") return cancelValue;
+						const result = await execute(withResources.input, timeoutMs, signal);
+						if (result.status === "answered") {
+							const content = compiled.input.kind === "ready" && compiled.input.plan.kind === "url" ? null : result.content;
+							return createCodexElicitationResponse("accept", content);
+						}
+						if (result.status === "declined" || result.status === "unsupported") return declineElicitation(result.message);
+						return cancelValue;
+					} finally {
+						await resource?.dispose();
 					}
-					if (result.status === "declined" || result.status === "unsupported") return declineElicitation(result.message);
-					return cancelValue;
 				}
 			}, requestSignal);
 		},
@@ -2431,6 +2394,11 @@ function gatewayAnswersToCodexResponse(answers) {
 function declineElicitation(message) {
 	return createCodexElicitationResponse("decline", null, message ? { message } : null);
 }
+function hasResourceInput(snapshot) {
+	const schema = snapshot.requestedSchema;
+	const properties = agentHarnessStructuredInput.isRecord(schema) ? schema.properties : void 0;
+	return agentHarnessStructuredInput.isRecord(properties) && Object.values(properties).some((field) => agentHarnessStructuredInput.isRecord(field) && Object.hasOwn(field, "x-openai-input"));
+}
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-active-turn.ts
 function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notifications, { turn, upstreamUserText }) {
@@ -2462,28 +2430,22 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 	} : dynamicToolParams;
 	const hostPrepareReplyMedia = params.hostCapabilities.prepareReplyMedia;
 	const remoteWorkspaceRoot = connection.appServer.remoteWorkspaceRoot;
-	const replyMediaClient = resourceState.client;
+	const readRemoteWorkspaceFile = createCodexRemoteWorkspaceFileReader(resourceState.client, connection.authority);
 	const prepareReplyMedia = hostPrepareReplyMedia && remoteWorkspaceRoot ? async (content, transferSignal) => hostPrepareReplyMedia({
 		...content,
 		workspaceRoot: remoteWorkspaceRoot,
 		signal: runAbortController.signal,
-		readWorkspaceFile: async (relativePath, { maxBytes, signal }) => {
-			connection.assertCurrent();
-			const file = await readBoundedCodexRemoteWorkspaceFile({
-				client: replyMediaClient,
-				path: mapCodexAppServerRemoteWorkspacePath({
-					value: path.resolve(params.workspaceDir, relativePath),
-					localWorkspaceRoot: params.workspaceDir,
-					remoteWorkspaceRoot
-				}),
-				workspaceRoot: remoteWorkspaceRoot,
-				maxBytes,
-				signal: transferSignal ? AbortSignal.any([signal, transferSignal]) : signal,
-				timeoutMs: connection.appServer.requestTimeoutMs
-			});
-			connection.assertCurrent();
-			return Buffer.from(file.dataBase64, "base64");
-		}
+		readWorkspaceFile: (relativePath, { maxBytes, signal }) => readRemoteWorkspaceFile({
+			path: mapCodexAppServerRemoteWorkspacePath({
+				value: path.resolve(params.workspaceDir, relativePath),
+				localWorkspaceRoot: params.workspaceDir,
+				remoteWorkspaceRoot
+			}),
+			workspaceRoot: remoteWorkspaceRoot,
+			maxBytes,
+			signal: transferSignal ? AbortSignal.any([signal, transferSignal]) : signal,
+			timeoutMs: connection.appServer.requestTimeoutMs
+		})
 	}) : void 0;
 	const progressCardTool = toolBridge.availableTools.find((tool) => tool.name === "progress_card");
 	let nativePlanUpdateOrdinal = 0;
@@ -2533,13 +2495,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		runAbortSignal: runAbortController.signal,
 		remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
 		remoteWorkspaceRequestTimeoutMs: connection.appServer.requestTimeoutMs,
-		readRemoteWorkspaceFile: ({ path: remotePath, maxBytes, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
-			client: resourceState.client,
-			path: remotePath,
-			maxBytes,
-			signal,
-			timeoutMs
-		}),
+		readRemoteWorkspaceFile,
 		trajectoryRecorder,
 		resolveDynamicToolResultContentSource: toolBridge.resultContentSourceForTool,
 		onNativeToolResultRecorded: maybeAnnounceFastModeAutoOff,
@@ -2633,6 +2589,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		requestTimeoutMs: connection.appServer.requestTimeoutMs,
 		signal: runAbortController.signal,
 		assertActive: assertSteeringActive,
+		withCurrent: connection.withCurrent,
 		prepareMessage: async (text, options, assertMessageCurrent) => {
 			const attachmentNote = await connection.prepareInputAttachments({
 				maxChars: Math.max(0, CODEX_TURN_START_TEXT_INPUT_MAX_CHARS - text.length - 2),
@@ -2683,7 +2640,10 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			const messages = activeProjector.buildSteeringTranscriptPrefix();
 			if (params.sessionTarget && messages.length > 0) {
 				await codexTranscriptMirrorRuntime.mirror({
-					assertCurrent: assertSteeringActive,
+					assertCurrent: () => {
+						connection.assertLegacyCurrent();
+						assertSteeringActive();
+					},
 					agentId: sessionAgentId,
 					sessionKey: contextSessionKey,
 					sessionId: params.sessionId,
@@ -2741,6 +2701,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		const canClaim = injectionGuard(assertCurrent);
 		if (await claimPendingUserInputAnswer(text, optionsLocal, assertCurrent, authorityKind)) {
 			optionsLocal?.onQueueAccepted?.(true);
+			optionsLocal?.onQueueSettled?.();
 			return;
 		}
 		if (optionsLocal?.isInboundUserMessage === true && hasPromptImageInput(optionsLocal)) {
@@ -2775,6 +2736,7 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 		runId: params.runId,
 		startedAtMs: params.startedAtMs,
 		toolAuthorityFingerprint: params.toolAuthorityFingerprint,
+		supportsCrossProfileSteering: isCodexNativeDelegationDisabledForRun(params) || resourceState.nativeSpawnAdmissionInstalled,
 		permissionChangeOwner: params.permissionChange?.owner,
 		applyPermissionMode: async (mode, revokeApprovals) => {
 			if (!params.permissionChange || terminalState.terminalOutcomeFrozen || params.abortSignal?.aborted || !state.permissionChangeRestart && (state.completed || runAbortController.signal.aborted)) return false;
@@ -2810,6 +2772,13 @@ function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notificatio
 			emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
 			userInputBridgeRef.current = createCodexUserInputBridge({
 				paramsForRun: params,
+				prepareResourceContext: (request) => prepareCodexNativeMcpFormResourceContext({
+					client: resourceState.client,
+					threadId: resourceState.thread.threadId,
+					attempt: params,
+					request,
+					readOrigin: (serverName) => activeProjector.getActiveMcpToolCall(serverName)
+				}),
 				onOrdinaryResponse: (response) => activeProjector.recordUserInputResponse(response),
 				threadId: resourceState.thread.threadId,
 				turnId: activeTurnId,
@@ -2922,17 +2891,14 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 			run: () => bindingStore.withLease(bindingIdentity, async () => {
 				if (!isSameCodexAppServerThreadOwner(bindingStore.read(bindingIdentity), resourceState.thread)) throw new Error("Codex plugin refresh lost its managed thread binding.");
 				if (!await releaseThreadSubscription(connection.assertCurrent)) throw new Error("Plugin reload could not release the previous Codex thread.");
-				if (!await bindingStore.mutate(bindingIdentity, {
-					kind: "clear",
-					threadId: resourceState.thread.threadId
-				}, connection.assertCurrent)) throw new Error("Codex plugin refresh lost its managed thread binding.");
+				if (!await clearCodexBindingForClient(bindingStore, bindingIdentity, resourceState.thread, connection.authority)) throw new Error("Codex plugin refresh lost its managed thread binding.");
+			}, {
+				assertCurrent: connection.assertCurrent,
+				authority: connection.authority
 			})
 		});
 		else {
-			const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveThread ? await bindingStore.mutate(bindingIdentity, {
-				kind: "clear",
-				threadId: resourceState.thread.threadId
-			}) : true;
+			const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveThread ? await resources.clearThreadBinding() : true;
 			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");
 			});
@@ -2973,13 +2939,6 @@ 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;
@@ -2991,40 +2950,40 @@ function scopeCodexRunBindingStore(params) {
 			sessionId: mapped.sessionId
 		} : owner;
 	};
-	const readMany = params.bindingStore.readMany?.bind(params.bindingStore);
 	return {
 		...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, {
+		readMany: (identities) => params.bindingStore.readMany(identities.map(mapIdentity)),
+		readNativeSubagentAssignments: (identity, owner) => (params.bindingStore.readNativeSubagentAssignments?.(mapIdentity(identity), mapHistoryOwner(identity, owner)) ?? []).map((assignment) => Object.assign({}, assignment, { owner: {
 			...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-assignment" || mutation.kind === "consume-native-subagent-assignment" ? {
+		mutate: (identity, mutation, assertCurrent, authority) => 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))
+			assignment: {
+				...mutation.assignment,
+				owner: 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),
+		} : mutation, assertCurrent, authority),
 		prepareSessionGenerationReclaim: (identity) => params.bindingStore.prepareSessionGenerationReclaim(mapSessionIdentity(identity)),
-		adoptSessionGeneration: (identity, expectedPreviousSessionId, assertCurrent) => params.bindingStore.adoptSessionGeneration(mapSessionIdentity(identity), expectedPreviousSessionId, assertCurrent),
+		adoptSessionGeneration: (identity, expectedPreviousSessionId, assertCurrent, authority) => params.bindingStore.adoptSessionGeneration(mapSessionIdentity(identity), expectedPreviousSessionId, assertCurrent, authority),
 		resetSessionGeneration: (identity) => params.bindingStore.resetSessionGeneration(mapSessionIdentity(identity)),
 		retireSessionGeneration: (identity) => params.bindingStore.retireSessionGeneration(mapSessionIdentity(identity)),
 		withSessionDeletion: (identity, assertCurrent, run) => params.bindingStore.withSessionDeletion(mapSessionIdentity(identity), assertCurrent, run),
 		withThreadArchiveFence: (run) => params.bindingStore.withThreadArchiveFence(run),
-		withLease: (identity, run) => params.bindingStore.withLease(mapIdentity(identity), run)
+		withLease: (identity, run, options) => params.bindingStore.withLease(mapIdentity(identity), run, options)
 	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/startup-binding.ts
 const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
 const CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS = 2e4;
-const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_TOKENS = 8e3;
-const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_RATIO = .5;
 const CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES = 65536;
 const CODEX_APP_SERVER_BYTE_UNITS = {
 	b: 1,
@@ -3076,10 +3035,7 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 		}];
 	} catch {}
 	const files = [];
-	const visited = /* @__PURE__ */ new Set();
-	for (const root of roots) {
-		if (visited.has(root)) continue;
-		visited.add(root);
+	for (const root of new Set(roots)) {
 		const stack = [root];
 		while (stack.length > 0) {
 			const dir = stack.pop();
@@ -3172,32 +3128,36 @@ function readCodexAppServerRolloutTokenSnapshotLine(line) {
 		return;
 	}
 }
-function readCompactionConfig(config) {
-	return isJsonObject(config?.agents?.defaults?.compaction) ? config.agents.defaults.compaction : void 0;
-}
 function resolveCodexAppServerNativeThreadTokenFuse(params) {
 	const projectedTurnTokens = typeof params.projectedTurnTokens === "number" && Number.isFinite(params.projectedTurnTokens) && params.projectedTurnTokens > 0 ? Math.floor(params.projectedTurnTokens) : 0;
 	const contextWindow = params.modelContextWindow ?? CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS;
-	const minPromptBudget = Math.min(CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_TOKENS, Math.max(1, Math.floor(contextWindow * CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_RATIO)));
-	const effectiveReserveTokens = Math.min(params.reserveTokens, Math.max(0, contextWindow - minPromptBudget));
-	return Math.max(1, contextWindow - effectiveReserveTokens - projectedTurnTokens);
-}
-function maxFiniteNumber(values) {
-	const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value));
-	if (nums.length === 0) return;
-	return Math.max(...nums);
+	const promptBudget = resolveProjectionPromptBudgetTokens({
+		contextTokenBudget: contextWindow,
+		reserveTokens: params.reserveTokens
+	});
+	return Math.max(1, promptBudget - projectedTurnTokens);
 }
-function hasContextEngineThreadBootstrapProjection(binding) {
-	return binding.contextEngine?.projection?.mode === "thread_bootstrap";
+function maxDefinedNumber(values) {
+	const nums = values.filter((value) => value !== void 0);
+	return nums.length ? Math.max(...nums) : void 0;
 }
 /** Clears and drops a binding when the native Codex thread is too large to resume safely. */
 async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const binding = params.binding;
 	if (!binding?.threadId) return { binding };
 	if (binding.connectionScope === "supervision") return { binding };
+	const clearBinding = async () => {
+		if (!await params.bindingStore.mutate(params.identity, {
+			kind: "clear",
+			threadId: binding.threadId,
+			clientId: binding.clientId
+		}, params.assertCurrent, params.authority)) throw new Error("Codex startup binding changed during rotation; retry with its current owner.");
+		return { binding: void 0 };
+	};
 	const rolloutFiles = await listCodexAppServerRolloutFilesForThread(params.agentDir, binding.threadId, params.codexHome, binding.rolloutPath);
-	const maxBytes = parseCodexAppServerByteLimit(readCompactionConfig(params.config)?.maxActiveTranscriptBytes);
-	if (maxBytes !== void 0 && params.contextEngineActive === true && hasContextEngineThreadBootstrapProjection(binding)) embeddedAgentLog.debug("codex app-server deferring native transcript byte guard for context-engine thread bootstrap", {
+	const compaction = params.config?.agents?.defaults?.compaction;
+	const maxBytes = parseCodexAppServerByteLimit(compaction?.maxActiveTranscriptBytes);
+	if (maxBytes !== void 0 && params.contextEngineActive === true && binding.contextEngine?.projection?.mode === "thread_bootstrap") embeddedAgentLog.debug("codex app-server deferring native transcript byte guard for context-engine thread bootstrap", {
 		threadId: binding.threadId,
 		engineId: binding.contextEngine?.engineId,
 		epoch: binding.contextEngine?.projection?.epoch,
@@ -3218,16 +3178,12 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 					bytes: file.bytes
 				}))
 			});
-			await params.bindingStore.mutate(params.identity, {
-				kind: "clear",
-				threadId: binding.threadId
-			}, params.assertCurrent);
-			return { binding: void 0 };
+			return await clearBinding();
 		}
 	}
 	const nativeTokenSnapshots = await Promise.all(rolloutFiles.map(async (file) => readCodexAppServerRolloutTokenSnapshot(file.path, file.handle)));
-	const nativeTokens = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.totalTokens));
-	const nativeModelContextWindow = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.modelContextWindow));
+	const nativeTokens = maxDefinedNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.totalTokens));
+	const nativeModelContextWindow = maxDefinedNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.modelContextWindow));
 	const reserveTokens = CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
 	const maxTokens = resolveCodexAppServerNativeThreadTokenFuse({
 		modelContextWindow: nativeModelContextWindow,
@@ -3244,11 +3200,7 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 			reserveTokens,
 			projectedTurnTokens: params.projectedTurnTokens
 		});
-		await params.bindingStore.mutate(params.identity, {
-			kind: "clear",
-			threadId: binding.threadId
-		}, params.assertCurrent);
-		return { binding: void 0 };
+		return await clearBinding();
 	}
 	return {
 		binding,
@@ -3300,7 +3252,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		config: params.config,
 		agentId: policyAgentId
 	});
-	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
+	const agentDir = params.agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId);
 	const preparedEnvironment = params.hostCapabilities.preparedEnvironment?.();
 	const remoteExec = isCodexRemoteExecPlacementSandbox(sandbox);
 	const assertLocalTargetSupported = (unsupported) => {
@@ -3347,7 +3299,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	let activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
 	const isInactiveThreadBootstrapBinding = (binding) => !activeContextEngine && binding?.contextEngine?.projection?.mode === "thread_bootstrap";
 	if (bindingIdentity.kind === "session" && bindingIdentity.sessionKey) {
-		const authority = resolveCodexRunSessionBindingAuthority({
+		const authority = await resolveCodexRunSessionBindingAuthority({
 			identity: bindingIdentity,
 			config: params.config,
 			storePath: params.sessionTarget?.storePath
@@ -3370,7 +3322,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	}
 	let modelExecution;
 	const assertModelExecutionCurrent = () => modelExecution?.assertCurrent();
-	const { binding: admittedBinding, assertCurrent: assertBindingCurrent } = await resolveCodexSessionBinding({
+	const { binding: admittedBinding, authority: bindingAuthority } = await resolveCodexSessionBinding({
 		reclaimStale: true,
 		bindingStore,
 		identity: bindingIdentity,
@@ -3381,9 +3333,10 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		assertBinding: params.expectedSessionRuntimeOwnership ? (binding) => assertCodexSessionRuntimeOwnership(binding, params.expectedSessionRuntimeOwnership) : void 0
 	});
 	const assertCurrent = () => {
-		assertBindingCurrent();
+		bindingAuthority.assertCurrent();
 		assertModelExecutionCurrent();
 	};
+	const authority = createNativeSessionBindingAuthority(bindingAuthority.lineage, assertCurrent);
 	let startupBinding = admittedBinding;
 	preDynamicStartupStages.mark("read-binding");
 	const usesSupervisionConnection = startupBinding?.connectionScope === "supervision";
@@ -3541,6 +3494,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		const startupBindingBeforeRotation = startupBinding;
 		const startupBindingResolution = await rotateOversizedCodexAppServerStartupBinding({
 			assertCurrent,
+			authority,
 			binding: startupBinding,
 			bindingStore,
 			identity: bindingIdentity,
@@ -3617,6 +3571,9 @@ async function prepareCodexAttemptConnection({ params, options }) {
 				return note;
 			},
 			assertCurrent,
+			authority,
+			withCurrent: authority.withCurrent,
+			assertLegacyCurrent: authority.assertLegacyCurrent,
 			assertModelExecutionCurrent,
 			bindModelExecution,
 			releaseModelExecution,
@@ -3747,7 +3704,8 @@ function buildCodexSystemPromptReport(params) {
 			bootstrapFiles: params.workspaceBootstrapContext.bootstrapFiles,
 			injectedFiles: params.workspaceBootstrapContext.promptContextFiles ?? [],
 			omitReferenceFiles: params.omitWorkspaceReferences,
-			developerInstructionFiles: [...params.workspaceBootstrapContext.threadDeveloperInstructionFiles ?? [], ...params.workspaceBootstrapContext.turnScopedDeveloperInstructionFiles ?? []],
+			omitPersonalProfiles: !params.parentLocalEgress,
+			developerInstructionFiles: [...params.workspaceBootstrapContext.threadDeveloperInstructionFiles ?? [], ...params.workspaceBootstrapContext.personaFiles ?? []],
 			memoryToolRoutedBootstrapFiles: params.workspaceBootstrapContext.memoryToolRoutedBootstrapFiles ?? [],
 			memoryToolRouted: params.workspaceBootstrapContext.memoryToolRouted === true
 		}),
@@ -3825,7 +3783,7 @@ function buildCodexBootstrapInjectionStats(params) {
 			injectedChars: null,
 			truncated: null
 		};
-		const omitted = memoryToolRoutedFile || params.omitReferenceFiles && readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) !== void 0;
+		const omitted = params.omitPersonalProfiles && file.personalUser === true || memoryToolRoutedFile || params.omitReferenceFiles && readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) !== void 0;
 		const injectedChars = omitted ? 0 : injected?.length ?? 0;
 		const truncated = omitted ? false : !file.missing && injectedChars < rawChars;
 		return {
@@ -3881,22 +3839,29 @@ function buildCodexOpenClawPromptContext(params) {
 * Sessions section must be re-surfaced here or Codex-backed main sessions
 * keep refusing cross-session questions (openclaw#114797).
 */
-function buildCodexWatchedSessionsContext(params) {
+async function prepareCodexWatchedSessionsContext(params) {
 	if (!shouldIncludeAgentHarnessRuntimeContext(params.attempt)) return;
-	return buildWatchedSessionsHarnessContext({
+	return prepareWatchedSessionsHarnessContext({
 		config: params.attempt.config,
 		sessionKey: params.sessionKey,
 		sandboxed: params.sandboxed,
-		toolNames: flattenCodexDynamicToolFunctions(params.dynamicTools).map((tool) => normalizeCodexDynamicToolName(tool.name))
+		assertCurrent: params.assertCurrent,
+		toolNames: flattenCodexDynamicToolFunctions(params.dynamicTools).map((tool) => normalizeLowercaseStringOrEmpty(tool.name))
 	});
 }
 function renderCodexSkillsInstructions(params) {
 	if (!shouldIncludeAgentHarnessRuntimeContext(params.attempt)) return;
-	return params.skillsPrompt?.trim() ? [
+	const names = new Set(flattenCodexDynamicToolFunctions(params.dynamicTools ?? []).map((tool) => normalizeLowercaseStringOrEmpty(tool.name)));
+	const prompt = params.skillsPrompt?.trim();
+	const search = names.has("skills_search");
+	const read = names.has("skills_read");
+	if (!prompt && !search) return;
+	return [
 		"## OpenClaw Skills",
-		"",
-		params.skillsPrompt.trim()
-	].join("\n") : void 0;
+		...search ? ["The directory is bounded. Use OpenClaw's skills_search tool to find relevant installed skills omitted from it. Search does not install skills."] : [],
+		...read ? ["Use OpenClaw's skills_read tool with an exact name for complete instructions; a known name does not require search first."] : [],
+		...prompt ? [prompt] : []
+	].join("\n");
 }
 /**
 * Prepends OpenClaw context while preserving leading delivery metadata as
@@ -3967,8 +3932,10 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 			...transcriptReadFence ? { admission: transcriptReadFence } : {}
 		});
 		connection.runAbortController.signal.throwIfAborted();
-		connection.assertCurrent();
-		return messages;
+		return await connection.withCurrent(() => {
+			connection.assertCurrent();
+			return messages;
+		});
 	};
 	const historyState = { messages: !activeContextEngine && initialStartupBindingHadInactiveThreadBootstrap ? [] : await readFencedHistory() ?? [] };
 	const hadSessionTranscriptState = historyState.messages.length > 0;
@@ -3999,6 +3966,8 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 			agentAccountId: params.agentAccountId
 		}),
 		channelContext: params.channelContext,
+		...params.memoryAudience ? { memoryAudience: params.memoryAudience } : {},
+		sandboxed: sandbox?.enabled === true,
 		...hookContextWindowFields
 	};
 	const hookRunner = getAgentHarnessHookRunner();
@@ -4049,14 +4018,20 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 	const agentWorkspaceDeveloperInstructions = workspaceBootstrapContext.threadDeveloperInstructions;
 	const skillsInstructions = renderCodexSkillsInstructions({
 		attempt: runtimeParams,
-		skillsPrompt: params.skillsSnapshot?.prompt
+		skillsPrompt: params.skillsSnapshot?.prompt,
+		dynamicTools: toolBridge.availableSpecs
 	});
+	const refreshableInstructions = joinPresentSections(skillsInstructions, workspaceBootstrapContext.sharedPersonaInstructions, workspaceBootstrapContext.memoryInstructions) || void 0;
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), agentWorkspaceDeveloperInstructions);
-	const watchedSessionsContext = buildCodexWatchedSessionsContext({
+	const watchedSessionsContext = await prepareCodexWatchedSessionsContext({
 		attempt: runtimeParams,
 		dynamicTools: toolBridge.availableSpecs,
 		sessionKey: contextSessionKey,
-		sandboxed: sandbox?.enabled === true
+		sandboxed: sandbox?.enabled === true,
+		assertCurrent: () => {
+			connection.runAbortController.signal.throwIfAborted();
+			connection.assertCurrent();
+		}
 	});
 	const buildOpenClawPromptContext = (includeWorkspaceReferences) => buildCodexOpenClawPromptContext({
 		params: runtimeParams,
@@ -4077,6 +4052,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		baseDeveloperInstructions,
 		buildOpenClawPromptContext,
 		skillsInstructions,
+		refreshableInstructions,
 		promptState: {
 			promptText: params.prompt,
 			promptContextRange: void 0,
@@ -4281,6 +4257,7 @@ async function beginCodexAttemptSettlement(resources, turnRuntime, notifications
 		if (settlementPhase !== "active" || drainGraceTimer) return;
 		drainGraceTimer = setTimeout(() => {
 			settlementPhase = "expired";
+			resourceState.nativeSettlementExpired = true;
 			drainGraceElapsed.resolve();
 		}, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS);
 		drainGraceTimer.unref?.();
@@ -4346,25 +4323,26 @@ async function beginCodexAttemptSettlement(resources, turnRuntime, notifications
 }
 //#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
+function canClearCodexBindingForRecovery(thread, expectedSessionRuntimeOwnership, operation) {
+	if (expectedSessionRuntimeOwnership) {
+		embeddedAgentLog.warn("codex app-server preserved native binding instead of recovery rotation", {
+			threadId: thread.threadId,
+			operation
 		});
-		return;
+		return false;
 	}
-	if (expected || currentBinding?.connectionScope === "supervision") {
+	assertCodexBindingMayBeReplaced(thread, operation);
+	return true;
+}
+async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields, authority, expected) {
+	if (expected) {
 		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
+	const cleared = await clearCodexBindingForClient(bindingStore, identity, fields, authority);
+	embeddedAgentLog.warn("codex app-server image payload recovery completed", {
+		...fields,
+		bindingCleared: cleared
 	});
 }
 function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
@@ -4383,9 +4361,8 @@ function prependCurrentInboundContext(prompt, context) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
-function createCodexTrajectoryRecorder(params) {
-	if (!params.trajectory) return null;
-	const trajectory = params.trajectory;
+function createCodexTrajectoryRecorder(trajectory) {
+	if (!trajectory) return null;
 	return {
 		recordEvent: (type, data) => {
 			try {
@@ -4453,17 +4430,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const { effectiveRuntimeProviderId, effectiveRuntimeModelId } = runtime;
 	const { params, terminalState, runAbortController, activeContextEngine, bindingStore, bindingIdentity, appServer, usesSupervisionConnection, sessionAgentId, contextSessionKey, effectiveCwd, agentDir, attemptStartedAt, startupAuthProfileId } = connection;
 	const { toolBridge, toolState } = attemptTools;
-	const canClearBindingForRecovery = (operation) => {
-		if (params.expectedSessionRuntimeOwnership) {
-			embeddedAgentLog.warn("codex app-server preserved native binding instead of recovery rotation", {
-				threadId: resourceState.thread.threadId,
-				operation
-			});
-			return false;
-		}
-		assertCodexBindingMayBeReplaced(resourceState.thread, operation);
-		return true;
-	};
+	const canClearBindingForRecovery = (operation) => canClearCodexBindingForRecovery(resourceState.thread, Boolean(params.expectedSessionRuntimeOwnership), operation);
 	const { state, completion } = turnRuntime;
 	const { emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { codexModelCallDiagnostics, buildLlmOutputEvent } = requestRuntime;
@@ -4495,9 +4462,10 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		if (isInvalidCodexImagePayloadError(enrichedPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 			phase: "turn_completed",
 			threadId: resourceState.thread.threadId,
+			clientId: resourceState.thread.clientId,
 			turnId: activeTurnId,
 			error: enrichedPromptErrorMessage
-		}, params.expectedSessionRuntimeOwnership);
+		}, connection.authority, params.expectedSessionRuntimeOwnership);
 		if (resourceState.thread.connectionScope !== "supervision" && shouldUseFreshCodexThreadAfterContextEngineOverflow({
 			error: enrichedPromptError,
 			contextEngineActive: Boolean(activeContextEngine),
@@ -4508,10 +4476,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 				turnId: activeTurnId,
 				error: enrichedPromptErrorMessage
 			});
-			await bindingStore.mutate(bindingIdentity, {
-				kind: "clear",
-				threadId: resourceState.thread.threadId
-			});
+			await clearCodexBindingForClient(bindingStore, bindingIdentity, resourceState.thread, connection.authority);
 		}
 		const refreshedUsageLimitPromptError = await refreshCodexUsageLimitPromptError({
 			client: resourceState.client,
@@ -4639,7 +4604,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 						config: params.config,
 						message: toolState.yieldMessage,
 						assertCurrent: () => {
-							connection.assertCurrent();
+							connection.assertLegacyCurrent();
 							if (!isSettlementActive() || !projectTerminalOutcome().turnSucceeded) throw new Error("Codex yield settlement is no longer active");
 						}
 					}),
@@ -4672,7 +4637,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		else if (finalPromptError) codexModelCallDiagnostics.emitError(finalPromptError);
 		else codexModelCallDiagnostics.emitCompleted(result);
 		const { assistantTranscriptOwned, assistantTranscriptIdempotencyKey, terminalAnchor } = mirrorOutcome;
-		const settledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed) ? (!usesSupervisionConnection ? await captureCodexSettledTurnFinalizationContext({
+		const settledTurnFinalizationContext = result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult") && (!finalPromptError || activeProjector.settledTurnFailureFinalizationAllowed) ? (!usesSupervisionConnection && !resourceState.nativeSettlementExpired ? await captureCodexSettledTurnFinalizationContext({
 			...activeTranscriptTarget,
 			model: resourceState.thread.model,
 			modelProvider: resourceState.thread.modelProvider,
@@ -4681,7 +4646,8 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			settledMessages: result.messagesSnapshot,
 			turnId: activeTurnId,
 			signal: params.abortSignal,
-			assertActive: connection.assertCurrent
+			assertActive: connection.assertCurrent,
+			withCurrent: connection.withCurrent
 		}) : void 0) ?? Object.freeze({ source: "unavailable" }) : void 0;
 		if (settledTurnFinalizationContext?.source === "unavailable") embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
 			runId: params.runId,
@@ -4725,7 +4691,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			hookRunner
 		});
 		state.shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
-		if (turnSucceeded && !runAbortController.signal.aborted && !state.pluginRuntimeRefreshStop) try {
+		if (turnSucceeded && !runAbortController.signal.aborted && !state.pluginRuntimeRefreshStop && !resourceState.nativeSettlementExpired) try {
 			const continuityCalibration = context.promptState.noEngineContinuityProjectionApplied ? buildCodexContinuityCalibration({
 				promptChars: prompt.turnState.codexTurnPromptText.length,
 				inputTokens: result.attemptUsage?.contextUsage?.state === "available" ? result.attemptUsage.contextUsage.promptTokens ?? 0 : 0
@@ -4733,18 +4699,16 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			await bindingStore.mutate(bindingIdentity, {
 				kind: "patch",
 				threadId: resourceState.thread.threadId,
+				clientId: resourceState.thread.clientId,
 				patch: {
 					historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
 					...continuityCalibration ? { continuityCalibration } : {}
 				}
-			}, connection.assertCurrent);
+			}, connection.assertCurrent, connection.authority);
 		} catch (error) {
 			if (resourceState.thread.connectionScope === "supervision") throw error;
 			if (canClearBindingForRecovery("clearing native coverage after a completed turn")) {
-				if (!await bindingStore.mutate(bindingIdentity, {
-					kind: "clear",
-					threadId: resourceState.thread.threadId
-				}, connection.assertCurrent)) throw error;
+				if (!await clearCodexBindingForClient(bindingStore, bindingIdentity, resourceState.thread, connection.authority)) throw error;
 				embeddedAgentLog.warn("codex app-server binding coverage update failed after completed turn; cleared stale binding", {
 					threadId: resourceState.thread.threadId,
 					turnId: activeTurnId,
@@ -4753,7 +4717,6 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			}
 		}
 		recordCodexTrajectoryCompletion(trajectoryRecorder, {
-			attempt: params,
 			result,
 			threadId: resourceState.thread.threadId,
 			turnId: activeTurnId,
@@ -4813,29 +4776,6 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	}
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-notification-state.ts
-/** Emits coarse execution phases exactly once from app-server notifications. */
-function reportCodexExecutionNotification(params) {
-	const { notification } = params;
-	if (notification.method === "turn/started") {
-		params.emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
-		return;
-	}
-	if (notification.method === "item/agentMessage/delta") {
-		params.emitExecutionPhaseOnce("assistant_output_started", { phase: "assistant_output_started" });
-		return;
-	}
-	if (notification.method !== "item/started") return;
-	const item = readCodexNotificationItem(notification.params);
-	const tool = item ? itemName(item) : void 0;
-	if (!item || !tool) return;
-	params.emitExecutionPhaseOnce(`tool:${item.id}`, {
-		phase: "tool_execution_started",
-		tool,
-		itemId: item.id
-	});
-}
-//#endregion
 //#region extensions/codex/src/app-server/run-attempt-lifecycle-terminal.ts
 function buildCodexLifecycleTerminalMeta(input) {
 	if (input.timedOut || input.abortStopReason === "timeout") return {
@@ -4932,9 +4872,21 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 		});
 	};
 	const reportExecutionNotification = (notification) => {
-		reportCodexExecutionNotification({
-			notification,
-			emitExecutionPhaseOnce
+		if (notification.method === "turn/started") {
+			emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
+			return;
+		}
+		if (notification.method === "item/agentMessage/delta") {
+			emitExecutionPhaseOnce("assistant_output_started", { phase: "assistant_output_started" });
+			return;
+		}
+		if (notification.method !== "item/started") return;
+		const item = readCodexNotificationItem(notification.params);
+		const tool = item ? itemName(item) : void 0;
+		if (item && tool) emitExecutionPhaseOnce(`tool:${item.id}`, {
+			phase: "tool_execution_started",
+			tool,
+			itemId: item.id
 		});
 	};
 	const emitFastModeAutoProgress = async (payload) => {
@@ -5139,7 +5091,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-prompt.ts
 async function prepareCodexAttemptPrompt(context) {
-	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, buildOpenClawPromptContext, skillsInstructions, promptState, codexContextProjectionMaxChars, codexContinuityProjectionMaxChars } = context;
+	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, buildActiveContextEngineRuntimeContext, baseDeveloperInstructions, buildOpenClawPromptContext, skillsInstructions, refreshableInstructions, 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;
@@ -5287,46 +5239,43 @@ async function prepareCodexAttemptPrompt(context) {
 		toolAuthority: {
 			fingerprint: params.toolAuthorityFingerprint,
 			activeToolNames: () => flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString),
-			assertActive: connection.assertCurrent
+			assertActive: connection.assertLegacyCurrent
 		}
 	});
-	const resolveShiftedPromptInputRange = (prompt, promptInputRange, turnPromptText) => {
-		if (!promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !turnPromptText.endsWith(prompt)) return;
+	const resolveShiftedPromptRanges = (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;
-		return {
+		const inputRange = {
 			start: turnPromptOffset + promptInputRange.start,
 			end: turnPromptOffset + promptInputRange.end
 		};
-	};
-	const resolveShiftedPromptContextRange = (prompt, promptInputRange, turnPromptText) => {
-		const promptTextInputOffset = promptInputRange ? promptInputRange.end - promptState.promptText.length : void 0;
-		if (!promptState.promptContextRange || !promptInputRange || promptTextInputOffset === void 0 || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || promptTextInputOffset < promptInputRange.start || prompt.slice(promptTextInputOffset, promptInputRange.end) !== promptState.promptText || !turnPromptText.endsWith(prompt)) return;
-		const promptTextOffset = prompt.endsWith(promptState.promptText) ? prompt.length - promptState.promptText.length : promptTextInputOffset;
-		if (promptTextOffset < 0) return;
-		const turnPromptOffset = turnPromptText.length - prompt.length + promptTextOffset;
+		const promptTextInputOffset = promptInputRange.end - promptState.promptText.length;
+		if (!promptState.promptContextRange || promptTextInputOffset < promptInputRange.start || prompt.slice(promptTextInputOffset, promptInputRange.end) !== promptState.promptText) return { inputRange };
+		const contextOffset = turnPromptOffset + (prompt.endsWith(promptState.promptText) ? prompt.length - promptState.promptText.length : promptTextInputOffset);
 		const contextRange = {
-			start: turnPromptOffset + promptState.promptContextRange.start,
-			end: turnPromptOffset + promptState.promptContextRange.end
+			start: contextOffset + promptState.promptContextRange.start,
+			end: contextOffset + promptState.promptContextRange.end
 		};
 		return {
+			inputRange,
 			contextRange,
 			requestRange: {
 				start: contextRange.end,
-				end: turnPromptOffset + promptState.promptText.length
+				end: contextOffset + promptState.promptText.length
 			}
 		};
 	};
 	const decorateCodexTurnPromptText = (promptBuildResult, includeWorkspaceReferences = true) => {
 		const turnPromptText = prependCodexOpenClawPromptContext(promptBuildResult.prompt, buildOpenClawPromptContext(includeWorkspaceReferences), { preservePromptWithoutContext: params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron" });
-		const projectedRanges = resolveShiftedPromptContextRange(promptBuildResult.prompt, promptBuildResult.promptInputRange, turnPromptText);
-		const preservedRange = resolveShiftedPromptInputRange(promptBuildResult.prompt, promptBuildResult.promptInputRange, turnPromptText) ?? resolveCodexDeliveryHintPreservedInputRange({
+		const projectedRanges = resolveShiftedPromptRanges(promptBuildResult.prompt, promptBuildResult.promptInputRange, turnPromptText);
+		const preservedRange = projectedRanges.inputRange ?? resolveCodexDeliveryHintPreservedInputRange({
 			prompt: promptBuildResult.prompt,
 			promptInputRange: promptBuildResult.promptInputRange,
 			decoratedPrompt: turnPromptText
 		});
-		const imageOffset = projectedRanges && promptState.promptContextRange ? projectedRanges.contextRange.start - promptState.promptContextRange.start : void 0;
+		const imageOffset = projectedRanges.contextRange && 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 requiredInputChars = turnPromptText.length - (projectedRanges.contextRange ? projectedRanges.contextRange.end - projectedRanges.contextRange.start : 0);
 		const attachmentNote = inputAttachmentNote && requiredInputChars + inputAttachmentNote.length + 2 <= inputLimit ? inputAttachmentNote : void 0;
 		const fitted = fitCodexProjectedContextForTurnStart({
 			promptText: turnPromptText,
@@ -5350,13 +5299,13 @@ async function prepareCodexAttemptPrompt(context) {
 	};
 	let parentLocalEgress = false;
 	const parentLocalContext = {
-		turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
-		memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
+		personaInstructions: workspaceBootstrapContext.personaInstructions,
+		memoryInstructions: workspaceBootstrapContext.memoryInstructions
 	};
-	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, parentLocalEgress ? void 0 : skillsInstructions, (parentLocalEgress ? buildCodexParentLocalInstructions(params, {
+	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, parentLocalEgress ? void 0 : refreshableInstructions, (parentLocalEgress ? buildCodexParentLocalInstructions(params, {
 		...parentLocalContext,
 		skillsInstructions
-	}) : buildTurnCollaborationMode(params, parentLocalContext).settings.developer_instructions) ?? void 0);
+	}) : buildTurnCollaborationMode(params).settings.developer_instructions) ?? void 0);
 	const rebuildCodexPromptBuildFromCurrentProjection = async () => {
 		turnState.promptBuild = await buildPromptFromCurrentInputs();
 		turnState.codexTurnPromptText = decorateCodexTurnPromptText(turnState.promptBuild);
@@ -5419,6 +5368,7 @@ async function prepareCodexAttemptPrompt(context) {
 		const hadInactiveThreadBootstrapBinding = isInactiveThreadBootstrapBinding(binding);
 		const startupBindingResolution = await rotateOversizedCodexAppServerStartupBinding({
 			assertCurrent: connection.assertCurrent,
+			authority: connection.authority,
 			binding,
 			bindingStore,
 			identity: bindingIdentity,
@@ -5459,6 +5409,7 @@ async function prepareCodexAttemptPrompt(context) {
 		developerInstructions: buildRenderedCodexDeveloperInstructions(),
 		workspaceBootstrapContext,
 		omitWorkspaceReferences,
+		parentLocalEgress,
 		skillsPrompt: skillsInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
 		tools: toolBridge.availableSpecs
 	});
@@ -5538,11 +5489,10 @@ function createNativeSubagentAssignmentStore(params) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-resources.ts
 function prepareCodexAttemptResources(prompt) {
-	const { context, turnState, buildRenderedCodexDeveloperInstructions } = prompt;
+	const { context } = prompt;
 	const { runtime, attemptTools } = context;
 	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 {
@@ -5551,20 +5501,18 @@ function prepareCodexAttemptResources(prompt) {
 		modelAdmissionSource?.release();
 	}
 	let nativeProcessAuthorityReleased = false;
+	const cleanupAuthority = createNativeSessionBindingAuthority(connection.authority.lineage, () => {
+		params.hostCapabilities.assertActive();
+		if (nativeProcessAuthorityReleased) throw new Error("Codex attempt cleanup authority has ended");
+	});
+	const clearThreadBinding = () => clearCodexBindingForClient(connection.bindingStore, connection.bindingIdentity, state.thread, cleanupAuthority);
 	const releaseNativeProcessAuthority = () => {
 		if (!nativeProcessAuthorityReleased) {
 			nativeProcessAuthorityReleased = true;
 			nativeProcessAuthority?.release();
 		}
 	};
-	const trajectoryRecorder = createCodexTrajectoryRecorder({
-		attempt: params,
-		cwd: effectiveCwd,
-		developerInstructions: buildRenderedCodexDeveloperInstructions(),
-		prompt: turnState.codexTurnPromptText,
-		trajectory: params.hostCapabilities.trajectory,
-		tools: toolBridge.availableSpecs
-	});
+	const trajectoryRecorder = createCodexTrajectoryRecorder(params.hostCapabilities.trajectory);
 	const state = {
 		client: void 0,
 		thread: void 0,
@@ -5575,11 +5523,13 @@ function prepareCodexAttemptResources(prompt) {
 		detachRouteAbort: (() => void 0),
 		trajectoryEndRecorded: false,
 		nativeHookRelay: void 0,
+		nativeSpawnAdmissionInstalled: false,
 		nativeSubagentMonitor: void 0,
 		runtimeContinuationStarted: false,
 		releaseSharedClientLease: void 0,
 		startupClientUnsafe: false,
 		turnStartAttempted: false,
+		nativeSettlementExpired: false,
 		sharedCodexClientRetiredForOneShotCleanup: false,
 		sandboxExecEnvironment: void 0,
 		executionDisconnectError: void 0,
@@ -5785,24 +5735,39 @@ function prepareCodexAttemptResources(prompt) {
 		if (subscriptionSettlement?.thread === thread) return subscriptionSettlement.retained;
 		if (!thread || thread.clientId !== resolveCodexAppServerClientInstanceId(client)) return false;
 		const { bindingStore, bindingIdentity } = connection;
+		if (state.nativeSettlementExpired) return false;
 		const retained = await bindingStore.withLease(bindingIdentity, async () => {
-			if (!isSameCodexAppServerThreadOwner(bindingStore.read(bindingIdentity), thread)) return false;
-			try {
-				if (!state.turnStartAttempted) runAbortController.signal.throwIfAborted();
-				if (!hasCodexNativeBackgroundProcesses(client, thread.threadId)) {
+			if (state.nativeSettlementExpired) return false;
+			let publicationStarted = false;
+			let pending;
+			const publish = (rowFailure) => {
+				publicationStarted = true;
+				if (state.nativeSettlementExpired || thread.clientId !== resolveCodexAppServerClientInstanceId(client) || !isSameCodexAppServerThreadOwner(bindingStore.read(bindingIdentity), thread)) return;
+				if (!nativeProcessAuthority?.hasCurrentProcesses(client, thread.threadId)) {
+					if (rowFailure) throw rowFailure.error;
 					params.hostCapabilities.assertActive();
 					connection.assertCurrent();
 				}
+				if (!state.turnStartAttempted) runAbortController.signal.throwIfAborted();
 				thread.liveThreadOwnership?.assertCurrent();
-			} catch {
-				return false;
+				pending = retainCodexAppServerBindingSubscription(client, thread.threadId, {
+					release: thread.liveThreadOwnership?.release,
+					configFingerprint: thread.liveThreadConfigFingerprint,
+					serviceTier: state.turnStartAttempted ? connection.mutable.pluginAppServer.serviceTier : thread.liveThreadOwnership?.serviceTier,
+					ephemeralPolicy: thread.liveThreadEphemeralPolicy
+				});
+			};
+			if (nativeProcessAuthority?.hasCurrentProcesses(client, thread.threadId)) publish();
+			else try {
+				await connection.withCurrent(() => publish());
+			} catch (error) {
+				if (publicationStarted) {
+					await pending;
+					throw error;
+				}
+				publish({ error });
 			}
-			return await retainCodexAppServerBindingSubscription(client, thread.threadId, {
-				release: thread.liveThreadOwnership?.release,
-				configFingerprint: thread.liveThreadConfigFingerprint,
-				serviceTier: state.turnStartAttempted ? connection.mutable.pluginAppServer.serviceTier : thread.liveThreadOwnership?.serviceTier,
-				ephemeralPolicy: thread.liveThreadEphemeralPolicy
-			});
+			return pending ? await pending : false;
 		});
 		if (retained) subscriptionSettlement = {
 			thread,
@@ -5818,16 +5783,21 @@ function prepareCodexAttemptResources(prompt) {
 			retained: false
 		};
 		if (thread.liveThreadOwnership) try {
-			await thread.liveThreadOwnership.release(thread.threadId, assertCurrent);
+			await thread.liveThreadOwnership.release(thread.threadId);
 			return true;
 		} catch (error) {
 			await closeCodexStartupClientBestEffort(client);
 			throw error;
 		}
+		if (state.nativeSettlementExpired) {
+			await closeCodexStartupClientBestEffort(client);
+			return false;
+		}
 		const released = await unsubscribeCodexThreadBestEffort(client, {
 			threadId: thread.threadId,
 			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-			assertCurrent
+			assertCurrent,
+			withCurrent: cleanupAuthority.withCurrent
 		});
 		if (!released) await closeCodexStartupClientBestEffort(client);
 		return released;
@@ -5841,11 +5811,10 @@ function prepareCodexAttemptResources(prompt) {
 			try {
 				retained = Boolean(!state.turnStartAttempted && !runAbortController.signal.aborted && params.cleanupBundleMcpOnRunEnd !== true && thread.liveThreadOwnership && await retainThreadSubscription());
 			} finally {
-				if (!retained) {
-					if (!isIncognitoSessionKey(params.sessionKey) || await connection.bindingStore.mutate(connection.bindingIdentity, {
-						kind: "clear",
-						threadId: thread.threadId
-					})) await releaseThreadSubscription();
+				if (!retained) try {
+					if (!isIncognitoSessionKey(params.sessionKey) || await clearThreadBinding()) await releaseThreadSubscription();
+				} finally {
+					if (thread.liveThreadOwnership) await releaseThreadSubscription();
 				}
 			}
 		});
@@ -5868,6 +5837,7 @@ function prepareCodexAttemptResources(prompt) {
 	const requesterChannel = params.messageChannel ?? params.messageProvider;
 	const requester = buildCodexHookRequester(params);
 	const buildNativeHookRelayFinalConfigPatch = async (decision) => {
+		state.nativeSpawnAdmissionInstalled = false;
 		const previousRelay = state.nativeHookRelay;
 		previousRelay?.unregister();
 		await previousRelay?.drain();
@@ -5924,7 +5894,7 @@ function prepareCodexAttemptResources(prompt) {
 				tools: decision.nativeModelInputTools,
 				readQualification: (threadId) => getCodexInferenceThreadQualification(state.client, threadId)
 			} : void 0,
-			assertCurrent: connection.assertCurrent,
+			assertCurrent: connection.assertLegacyCurrent,
 			onPreToolUseFailure: (failure) => {
 				const projector = projectorRef.current;
 				if (projector) projector.recordNativeToolPreToolUseFailure(failure);
@@ -5933,6 +5903,13 @@ function prepareCodexAttemptResources(prompt) {
 		});
 		await state.nativeHookRelay?.prepareInvocation();
 		connection.assertCurrent();
+		state.nativeSpawnAdmissionInstalled = Boolean(state.nativeHookRelay && requiresModelAdmission && decision.nativeModelInputTools?.includes("spawn_agent") && params.hostCapabilities.assertNativeSubagentSpawnAllowed);
+		if (!state.nativeSpawnAdmissionInstalled && !isCodexNativeDelegationDisabledForRun(params)) try {
+			params.hostCapabilities.assertNativeSubagentSpawnAllowed?.();
+		} catch (cause) {
+			if (!(cause instanceof Error) || !cause.message.startsWith("Several people have steered this turn:")) throw cause;
+			throw new Error("Several people have steered this turn, and this Codex setup cannot run native sub-agents safely for more than one person without native hook admission. Send the request again as a new message so it runs as its own turn.", { cause });
+		}
 		return {
 			configPatch: state.nativeHookRelay ? buildCodexNativeHookRelayConfig({
 				relay: state.nativeHookRelay,
@@ -5942,21 +5919,7 @@ function prepareCodexAttemptResources(prompt) {
 			nativeHookRelayGeneration: state.nativeHookRelay?.generation
 		};
 	};
-	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,
-			sessionId: params.sessionId,
-			error: message
-		});
-		emitCodexAppServerEvent(params, {
-			stream: "codex_app_server.lifecycle",
-			data: {
-				phase: "background_cleanup_failed",
-				error: message
-			}
-		});
-	}, Boolean(sandbox?.enabled && sandbox.backend)) : void 0;
+	const nativeProcessAuthority = params.hostCapabilities.retainSourceAuthority ? new CodexNativeProcessAuthority(params.hostCapabilities, (error) => reportCodexBackgroundCleanupFailure(params, error), Boolean(sandbox?.enabled && sandbox.backend)) : void 0;
 	return {
 		prompt,
 		trajectoryRecorder,
@@ -5974,6 +5937,7 @@ function prepareCodexAttemptResources(prompt) {
 		runCleanupStep,
 		registerNativeSubagentMonitor,
 		releaseCurrentRoute,
+		clearThreadBinding,
 		retainThreadSubscription,
 		releaseThreadSubscription,
 		cleanupBeforeActiveTurn,
@@ -6043,7 +6007,7 @@ function prewarmCodexAttemptClient(params) {
 	const { appServer, attemptClientFactory, options, pluginConfig, runtimeArtifactRequest, startupAuthRequirement, startupClientAuthProfileId, startupPreparedAuth, agentDir, params: runParams, runAbortController } = connection;
 	if (options.clientFactory || attemptClientFactory !== getLeasedSharedCodexAppServerClient || runtimeArtifactRequest) return;
 	getSharedCodexAppServerClient({
-		assertCurrent: connection.assertCurrent,
+		assertCurrent: connection.assertLegacyCurrent,
 		startOptions: appServer.start,
 		pluginConfig,
 		...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
@@ -6066,10 +6030,6 @@ function canResolveScheduledConfiguredMcpCreatorAuthority(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-runtime.ts
-function resolveCodexAttemptBundleManifestRegistry(preparedModelRuntime) {
-	const metadataSnapshot = preparedModelRuntime?.metadataSnapshot;
-	return metadataSnapshot?.pluginIds === void 0 ? metadataSnapshot?.manifestRegistry : void 0;
-}
 async function prepareCodexAttemptRuntime(connection) {
 	const { params, pluginConfig, usesSupervisionConnection, appServer, startupAuthProfileId, startupPreparedAuth, startupClientAuthProfileId, agentDir, preDynamicStartupStages, effectiveWorkspace, contextSessionKey, sandboxSessionKey, sessionAgentId, policyAgentId, sandbox, attemptClientFactory, runAbortController, activeContextEngine, mutable } = connection;
 	const preparedAuthBinding = !usesSupervisionConnection && appServer.start.homeScope !== "user" && startupAuthProfileId ? await prepareCodexAppServerAuthBinding({
@@ -6134,13 +6094,14 @@ async function prepareCodexAttemptRuntime(connection) {
 		agentId: sessionAgentId,
 		toolOverrides: params.toolOverrides
 	});
-	const bundleManifestRegistry = resolveCodexAttemptBundleManifestRegistry(params.preparedModelRuntime);
+	const metadataSnapshot = params.preparedModelRuntime?.metadataSnapshot;
+	const bundleManifestRegistry = metadataSnapshot?.pluginIds === void 0 ? metadataSnapshot?.manifestRegistry : void 0;
 	const bundleMcpThreadConfig = await loadCodexBundleMcpThreadConfig({
 		workspaceDir: effectiveWorkspace,
 		agentId: sessionAgentId,
 		cfg: params.config,
 		toolsEnabled: usesSupervisionConnection || supportsModelTools(params.model),
-		disableTools: params.disableTools,
+		disableTools: params.disableTools || params.requireWorkspaceOnly === true,
 		toolsAllow: params.toolsAllow,
 		manifestRegistry: bundleManifestRegistry,
 		toolOverrides: codexMcpToolOverrides
@@ -6206,7 +6167,7 @@ async function prepareCodexAttemptRuntime(connection) {
 			else releaseLeasedSharedCodexAppServerClient(client);
 		}
 	}
-	const configuredMcpSurface = scheduledConfiguredMcpSurface ? "scheduled" : !nativeToolSurfaceEnabled && bundleMcpThreadConfig.staticServerNames.length > 0 ? "transient" : void 0;
+	const configuredMcpSurface = params.requireWorkspaceOnly === true ? void 0 : scheduledConfiguredMcpSurface ? "scheduled" : !nativeToolSurfaceEnabled && bundleMcpThreadConfig.staticServerNames.length > 0 ? "transient" : void 0;
 	preDynamicStartupStages.mark("native-tool-surface");
 	const webSearchPlan = resolveCodexWebSearchPlan({
 		config: params.config,
@@ -6435,6 +6396,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 			});
 			projector?.recordDynamicToolCall({
 				callId: call.callId,
+				namespace: call.namespace,
 				tool: call.tool,
 				arguments: call.arguments
 			});
@@ -6590,7 +6552,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					response,
 					durationMs: toolDurationMs
 				});
-				else if (!shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response)) scheduleTerminalDynamicToolReleaseCheck();
+				else if (response.asyncStarted === true) scheduleTerminalDynamicToolReleaseCheck();
 				else {
 					state.currentTurnHadNonTerminalDynamicToolResult = true;
 					state.pendingTerminalDynamicToolRelease = void 0;
@@ -6622,7 +6584,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 //#region extensions/codex/src/app-server/attempt-runtime-artifact.ts
 async function verifyStartupArtifact(params) {
 	if (!params.request) return;
-	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-DDQ-HGXf.mjs");
+	const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CUTOOnKw.mjs");
 	const runtimeArtifact = readCodexAppServerClientRuntimeArtifact(params.client);
 	const expected = params.request.expected;
 	const matchesExpected = !expected || runtimeArtifact?.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint;
@@ -6645,7 +6607,14 @@ function startCodexComputerUseHealthMonitor(params) {
 			reason: params.config.enabled ? "health_disabled" : "disabled"
 		};
 	}
-	const fingerprint = buildComputerUseHealthMonitorFingerprint(params.config, params.tools);
+	const fingerprint = JSON.stringify({
+		autoRepair: params.config.autoRepair,
+		healthCheckIntervalMinutes: params.config.healthCheckIntervalMinutes,
+		liveTestTimeoutMs: params.config.liveTestTimeoutMs,
+		mcpServerName: params.config.mcpServerName,
+		toolCallTimeoutMs: params.config.toolCallTimeoutMs,
+		tools: params.tools?.toSorted()
+	});
 	const intervalMs = params.config.healthCheckIntervalMinutes * 6e4;
 	if (existing?.fingerprint === fingerprint) return {
 		started: false,
@@ -6672,16 +6641,6 @@ function startCodexComputerUseHealthMonitor(params) {
 		intervalMs
 	};
 }
-function buildComputerUseHealthMonitorFingerprint(config, tools) {
-	return JSON.stringify({
-		autoRepair: config.autoRepair,
-		healthCheckIntervalMinutes: config.healthCheckIntervalMinutes,
-		liveTestTimeoutMs: config.liveTestTimeoutMs,
-		mcpServerName: config.mcpServerName,
-		toolCallTimeoutMs: config.toolCallTimeoutMs,
-		tools: tools?.toSorted()
-	});
-}
 async function runCodexComputerUseHealthProbe(client, config, monitor, tools) {
 	if (monitor.running) return;
 	monitor.running = true;
@@ -6721,121 +6680,12 @@ function clearComputerUseHealthMonitor(client, monitor) {
 	getComputerUseHealthMonitorState().monitors.delete(client);
 }
 //#endregion
-//#region extensions/codex/src/app-server/plugin-thread-config-deadline.ts
-/** Enforces one bounded startup budget across Codex plugin config discovery. */
-const CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS = 6e4;
-const CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR = 4;
-const CODEX_PLUGIN_THREAD_CONFIG_MIN_TIMEOUT_MS = 100;
-var CodexPluginThreadConfigDeadlineError = class extends Error {
-	constructor() {
-		super("Codex plugin thread config deadline elapsed");
-		this.name = "CodexPluginThreadConfigDeadlineError";
-	}
-};
-/** Resolves the plugin policy state reused throughout app-server startup. */
-function resolveCodexPluginThreadConfigStartupPolicy(params) {
-	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,
-		pluginThreadConfigPluginConfig,
-		resolvedPluginPolicy,
-		enabledPluginConfigKeys: resolvedPluginPolicy ? resolvedPluginPolicy.pluginPolicies.filter((plugin) => plugin.enabled).map((plugin) => plugin.configKey).toSorted() : void 0
-	};
-}
-/** Builds plugin config without allowing sequential RPC timeouts to consume the turn. */
-async function buildCodexPluginThreadConfigWithinDeadline(params) {
-	const { requestTimeoutMs, signal, request, failClosedOnTimeout, transform, ...buildParams } = params;
-	signal.throwIfAborted();
-	const timeoutMs = resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs);
-	const deadlineMs = performance.now() + timeoutMs;
-	let requestTimedOut = false;
-	const boundedRequest = async (method, requestParams) => {
-		const remainingTimeoutMs = deadlineMs - performance.now();
-		if (requestTimedOut || remainingTimeoutMs <= 0) throw new CodexPluginThreadConfigDeadlineError();
-		try {
-			return await request(method, requestParams, {
-				timeoutMs: remainingTimeoutMs,
-				signal
-			});
-		} catch (error) {
-			requestTimedOut ||= isCodexPluginThreadConfigTimeoutError(error);
-			throw error;
-		}
-	};
-	try {
-		return await withAbortableTimeout({
-			signal,
-			timeoutMs,
-			promise: (async () => {
-				const config = await buildCodexPluginThreadConfig({
-					...buildParams,
-					request: boundedRequest
-				});
-				const result = transform ? await transform(config, boundedRequest) : config;
-				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) && 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,
-			appCacheKey: buildParams.appCacheKey,
-			message: `Codex plugin discovery exceeded its ${timeoutMs} ms startup budget; plugin apps were disabled for this turn.`
-		});
-	}
-}
-/** Creates the recovery metadata and bounded builder used by thread startup. */
-function createCodexPluginThreadConfigStartupProvider(params) {
-	const { client, policy, inputFingerprint, enabledPluginConfigKeys, appCache, metadataCache: configuredMetadataCache, ...buildParams } = params;
-	const metadataCache = configuredMetadataCache ?? defaultCodexPluginMetadataCache;
-	return {
-		enabled: true,
-		requiresCurrentPolicyCheck: Boolean(policy?.enabled || params.scheduledRuntimeAuthority),
-		inputFingerprint,
-		enabledPluginConfigKeys,
-		accountAppRecoveryEnabled: policy?.allowAllPlugins,
-		recoverablePluginConfigKeys: policy ? resolveRecoverableCodexPluginConfigKeys({
-			policy,
-			metadataCache,
-			appCacheKey: params.appCacheKey,
-			configCwd: params.configCwd
-		}) : void 0,
-		build: async (buildOptions) => {
-			const config = await buildCodexPluginThreadConfigWithinDeadline({
-				...buildParams,
-				threadId: buildOptions?.threadId,
-				appCache: appCache ?? defaultCodexAppInventoryCache,
-				metadataCache,
-				failClosedOnTimeout: Boolean(params.scheduledRuntimeAuthority),
-				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 ? {
-				...config,
-				inputFingerprint: params.inputFingerprint
-			} : config;
-		}
-	};
-}
-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)));
-}
-function isCodexPluginThreadConfigTimeoutError(error) {
-	return error instanceof CodexPluginThreadConfigDeadlineError || error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_LOCAL_REQUEST_CANCELLED" && error.message.endsWith(" timed out");
-}
-//#endregion
 //#region extensions/codex/src/app-server/attempt-startup.ts
 const CODEX_APP_SERVER_STARTUP_MAX_ATTEMPTS = 3;
+/**
+* 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;
@@ -6882,7 +6732,10 @@ async function startCodexAttemptThread(params) {
 						params.assertCurrent?.();
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
 						startupClient = await params.attemptClientFactory({
-							assertCurrent: params.assertCurrent,
+							assertCurrent: () => {
+								params.assertCurrent?.();
+								params.authority?.assertLegacyCurrent();
+							},
 							startOptions: params.appServer.start,
 							pluginConfig: params.pluginConfig,
 							...params.startupPreparedAuth ? { preparedAuth: params.startupPreparedAuth } : { authProfileId: params.startupAuthProfileId },
@@ -7050,6 +6903,7 @@ async function startCodexAttemptThread(params) {
 							reserveResumeThread,
 							bindingStore: params.bindingStore,
 							assertCurrent: params.assertCurrent,
+							authority: params.authority,
 							params: params.buildAttemptParams(),
 							runtimeModelId: params.runtimeModelId,
 							agentId: params.sessionAgentId,
@@ -7060,7 +6914,7 @@ async function startCodexAttemptThread(params) {
 							webSearchAllowed: params.webSearchAllowed,
 							appServer: pluginAppServer,
 							developerInstructions: params.developerInstructions,
-							skillsInstructions: params.skillsInstructions,
+							refreshableInstructions: params.refreshableInstructions,
 							agentWorkspaceDeveloperInstructions: params.agentWorkspaceDeveloperInstructions,
 							config: threadConfig,
 							shellEnvironment: params.shellEnvironment,
@@ -7236,6 +7090,7 @@ async function startCodexAttemptRuntime(resources) {
 		});
 		const startupResult = await startCodexAttemptThread({
 			assertCurrent: connection.assertCurrent,
+			authority: connection.authority,
 			attemptClientFactory,
 			bindingStore,
 			runtime: connection.options.runtime,
@@ -7263,11 +7118,11 @@ async function startCodexAttemptRuntime(resources) {
 			persistentWebSearchAllowed: toolState.persistentWebSearchAllowed,
 			webSearchAllowed: toolState.webSearchAllowed,
 			developerInstructions,
-			skillsInstructions: context.skillsInstructions,
+			refreshableInstructions: context.refreshableInstructions,
 			agentWorkspaceDeveloperInstructions: context.agentWorkspaceDeveloperInstructions,
 			buildFinalConfigPatch: buildNativeHookRelayFinalConfigPatch,
 			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),
+			nativeHookRelayRequired: params.requireWorkspaceOnly !== true && (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,
@@ -7296,14 +7151,7 @@ async function startCodexAttemptRuntime(resources) {
 		state.restartContextEngineCodexThread = startupResult.restartContextEngineCodexThread;
 		await attemptTools.captureCronCreatorToolAllowlist();
 		pluginAppServer = startupResult.pluginAppServer;
-		toolBridge.setRemoteWorkspaceFileReader?.(({ path, maxBytes, workspaceRoot, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
-			client: startupResult.client,
-			path,
-			maxBytes,
-			workspaceRoot,
-			signal,
-			timeoutMs
-		}));
+		toolBridge.setRemoteWorkspaceFileReader?.(createCodexRemoteWorkspaceFileReader(startupResult.client, connection.authority));
 		if (usesSupervisionConnection && (state.thread.connectionScope !== "supervision" || state.thread.supervisionSourceThreadId !== connection.mutable.startupBinding?.supervisionSourceThreadId)) throw new Error("Codex supervised thread lost its private connection ownership");
 		if (state.thread.lifecycle.action === "started" || state.thread.lifecycle.action === "forked") {
 			const activePolicy = resolveReviewerPolicyContext(state.thread);
@@ -7361,14 +7209,7 @@ async function startCodexAttemptRuntime(resources) {
 //#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);
+	const descriptor = (params.registeredSpecs ? flattenCodexDynamicToolFunctions(params.registeredSpecs) : params.registeredTools).find((tool) => tool.name === HEARTBEAT_RESPONSE_TOOL_NAME);
 	return descriptor ? {
 		name: descriptor.name,
 		description: descriptor.description
@@ -7406,9 +7247,6 @@ function selectInactiveCodexHeartbeatResponseTool(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-tool-setup.ts
-function isAuthorityResolutionOperationAbort(error, signal) {
-	return signal?.aborted === true && error === signal.reason;
-}
 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;
@@ -7518,7 +7356,7 @@ async function prepareCodexAttemptTools(runtime) {
 			const pending = resolveCreatorAuthorityImpl(options);
 			creatorAuthorityPromise = pending;
 			pending.catch((error) => {
-				if (creatorAuthorityPromise === pending && isAuthorityResolutionOperationAbort(error, options?.signal)) creatorAuthorityPromise = void 0;
+				if (creatorAuthorityPromise === pending && options?.signal?.aborted === true && error === options.signal.reason) creatorAuthorityPromise = void 0;
 			});
 			return pending;
 		} } : {}
@@ -7528,7 +7366,7 @@ async function prepareCodexAttemptTools(runtime) {
 		runAbortController.signal.throwIfAborted();
 		connection.assertCurrent();
 		const client = await connection.attemptClientFactory({
-			assertCurrent: connection.assertCurrent,
+			assertCurrent: connection.assertLegacyCurrent,
 			startOptions: connection.appServer.start,
 			authProfileId: connection.startupClientAuthProfileId,
 			agentDir,
@@ -7538,6 +7376,7 @@ async function prepareCodexAttemptTools(runtime) {
 		try {
 			nativeSpecs = await loadCodexNativeToolCatalog({
 				client,
+				authority: connection.authority,
 				binding: mutable.startupBinding,
 				appServer: connection.appServer,
 				agentDir,
@@ -7602,7 +7441,7 @@ async function prepareCodexAttemptTools(runtime) {
 			sessionId: params.sessionId,
 			runId: params.runId,
 			agentId: policyAgentId,
-			agentDir: agentDir ?? resolveAgentDir$2(params.config ?? {}, sessionAgentId),
+			agentDir: agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId),
 			agentAccountId: params.agentAccountId,
 			messageProvider: params.messageProvider ?? params.messageChannel,
 			messageChannel: params.messageChannel,
@@ -7668,7 +7507,7 @@ async function prepareCodexAttemptTools(runtime) {
 			policyContext,
 			warn: (message) => embeddedAgentLog.warn(message)
 		};
-		configuredMcp = configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
+		configuredMcp = params.requireWorkspaceOnly !== true && configuredMcpSurface ? await materializeStaticMcpToolsForHarnessRun({
 			...mcpOptions,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -7681,7 +7520,7 @@ async function prepareCodexAttemptTools(runtime) {
 				"deny"
 			]) } : {}
 		}) : void 0;
-		scopedMcpTools = authenticatedScheduledMode ? void 0 : await materializeRequesterScopedMcpToolsForHarnessRun({
+		scopedMcpTools = authenticatedScheduledMode || params.requireWorkspaceOnly === true ? void 0 : await materializeRequesterScopedMcpToolsForHarnessRun({
 			...mcpOptions,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -7944,7 +7783,7 @@ 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. */
+/** Validate an explicit Ultrafast selection against this turn's native model and client. */
 async function resolveCodexUltrafastServiceTier(params) {
 	if (!params.enabled || params.modelProvider !== "openai" && params.modelProvider !== "openclaw_token_sharing" || !params.model) return params.serviceTier;
 	params.signal.throwIfAborted();
@@ -8045,7 +7884,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		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.");
+			if (resourceState.client !== turnClient || 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 fastMode = typeof runtimeParams.fastMode === "function" ? runtimeParams.fastMode() : runtimeParams.fastMode;
 		const turnAppServer = withCodexAppServerFastModeServiceTier(connection.mutable.pluginAppServer, { fastMode }, connection.appServer);
@@ -8066,8 +7905,6 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 				model: resourceState.thread.model,
 				modelProvider: resourceState.thread.modelProvider
 			},
-			turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
-			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
 			preserveNativeTurnSettings: usesSupervisionConnection,
 			parentLocalEgress: inferenceRoute !== void 0,
 			messageToolAvailable: toolBridge.availableTools.some((tool) => tool.name === "message"),
@@ -8075,7 +7912,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			sessionStatusAvailable: toolBridge.availableTools.some((tool) => tool.name === "session_status")
 		});
 		const serviceTier = await resolveCodexUltrafastServiceTier({
-			enabled: turnAppServer.enableUltrafast === true && fastMode !== false,
+			enabled: fastMode === "ultrafast" && turnAppServer.enableUltrafast !== false,
 			serviceTier: turnStartParams.serviceTier,
 			model: turnStartParams.model ?? model,
 			modelProvider,
@@ -8117,14 +7954,14 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			const registration = inferenceRoute.context.register({
 				threadId: resourceState.thread.threadId,
 				text: usesSupervisionConnection ? "" : buildCodexParentLocalInstructions(runtimeParams, {
-					turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
+					personaInstructions: workspaceBootstrapContext.personaInstructions,
 					skillsInstructions: context.skillsInstructions,
-					memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
+					memoryInstructions: workspaceBootstrapContext.memoryInstructions
 				}) ?? "",
 				signal: runAbortController.signal,
 				assertCurrent: () => {
 					params.hostCapabilities.assertActive();
-					connection.assertCurrent();
+					connection.assertLegacyCurrent();
 					if (resourceState.thread !== inferenceThread || getCodexInferenceThread(resourceState.client, inferenceThread.threadId) !== inferenceRoute) throw new Error("Codex inference thread ownership changed");
 					inferenceThread.liveThreadOwnership?.assertCurrent();
 				}
@@ -8134,20 +7971,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 				...turnStartParams.responsesapiClientMetadata,
 				[CODEX_INFERENCE_GENERATION_KEY]: registration.generation
 			};
-		} else if (!usesSupervisionConnection) {
-			embeddedAgentLog.warn("Codex parent-local egress workaround is unavailable for this connection or native network profile; legacy collaboration delivery is not guaranteed.");
-			prompt.systemPromptReport.source = "estimate";
-			prompt.systemPromptReport.injectedWorkspaceFiles = prompt.systemPromptReport.injectedWorkspaceFiles.map((file) => [
-				"SOUL.MD",
-				"IDENTITY.MD",
-				"USER.MD"
-			].includes(file.name.toUpperCase()) ? {
-				...file,
-				injectionStatus: "native_unverified",
-				injectedChars: null,
-				truncated: null
-			} : file);
-		}
+		} else if (workspaceBootstrapContext.personaFiles?.some((file) => file.personalUser)) embeddedAgentLog.warn("Personal USER.md was omitted: this Codex connection has no parent-only inference relay. Shared workspace persona is still delivered.");
 		const continuation = await prepareCodexProviderReviewContinuation({
 			acknowledgment: params.providerReviewAcknowledgment,
 			client: resourceState.client,
@@ -8162,7 +7986,6 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
 		recordCodexTrajectoryContext(resources.trajectoryRecorder, {
 			attempt: params,
-			cwd: connection.effectiveCwd,
 			developerInstructions: joinPresentSections(buildRenderedCodexDeveloperInstructions(), attemptTools.configuredMcp?.diagnosticNotice),
 			prompt: turnState.codexTurnPromptText,
 			tools: toolBridge.availableSpecs
@@ -8187,6 +8010,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			const startedTurn = assertCodexTurnStartResponse(await turnClient.request("turn/start", turnStartParams, {
 				timeoutMs: params.timeoutMs,
 				signal: runAbortController.signal,
+				withCurrent: connection.withCurrent,
 				assertCurrent: () => {
 					assertTurnCurrent();
 					continuation?.dispatch();
@@ -8304,10 +8128,7 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				threadId: resourceState.thread.threadId,
 				error: formatErrorMessage(turnStartError)
 			});
-			if (!await bindingStore.mutate(bindingIdentity, {
-				kind: "clear",
-				threadId: resourceState.thread.threadId
-			}, connection.assertCurrent)) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
+			if (!await clearCodexBindingForClient(bindingStore, bindingIdentity, resourceState.thread, connection.authority)) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
 				threadId: resourceState.thread.threadId,
 				error: formatErrorMessage(turnStartError)
 			});
@@ -8342,8 +8163,9 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 			if (!params.providerReviewAcknowledgment && isInvalidCodexImagePayloadError(message)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 				phase: "turn_start",
 				threadId: resourceState.thread.threadId,
+				clientId: resourceState.thread.clientId,
 				error: message
-			}, params.expectedSessionRuntimeOwnership);
+			}, connection.authority, params.expectedSessionRuntimeOwnership);
 			emitCodexAppServerEvent(params, {
 				stream: "codex_app_server.lifecycle",
 				data: {
@@ -8587,6 +8409,7 @@ function createCodexAttemptTurnState(resources) {
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt.ts
 async function runCodexAppServerAttempt(params, options) {
+	if (params.requireWorkspaceOnly === true && (params.disableTools === true || typeof params.hostCapabilities?.createToolSurface !== "function")) throw new Error("Codex required-root execution requires an enabled host-mediated tool surface");
 	const preparation = createCodexAttemptPreparationTiming(params);
 	const connection = await preparation.measure("connection", () => prepareCodexAttemptConnection({
 		params,
@@ -8626,6 +8449,7 @@ async function runCodexAppServerAttempt(params, options) {
 							await cleanupCodexAttempt(resources, turnRuntime, lifecycle, turnRequest, activeTurn);
 						}
 					} catch (error) {
+						connection.assertModelExecutionCurrent();
 						if (!finalizedResult || !turnRuntime.state.pluginRuntimeRefreshStop) throw error;
 						const original = attemptTerminal.project(finalizedResult.terminal).promptError;
 						finalizedResult.terminal = attemptTerminal.merge(finalizedResult.terminal, {
@@ -8648,6 +8472,8 @@ async function runCodexAppServerAttempt(params, options) {
 		} finally {
 			await attemptTools.disposeTools(connection.runAbortController.signal.aborted ? "cancel" : "error");
 		}
+	} catch (error) {
+		throw codexPrewriteRejectionCause(error);
 	} finally {
 		connection.cancellation.dispose();
 		connection.releaseModelExecution();