@openclaw/codex 2026.7.2-beta.5 → 2026.7.2-beta.7

package/dist/{run-attempt-C5GTPJOE.js → run-attempt-CY9WlDLc.js}

@@ -1,37 +1,36 @@
-import { $ as withCodexStartupTimeout, A as rememberCodexRateLimitsRead, B as flattenCodexDynamicToolFunctions, D as ensureCodexAppServerClientRuntime, F as resolveCodexAppServerPreparedApiKeyCacheKey, G as CodexAppServerStartupError, I as resolveCodexAppServerPreparedAuthHandoff, J as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, K as isCodexAppServerStartupError, M as resolveCodexAppServerAuthProfileId, N as resolveCodexAppServerAuthProfileIdForAgent, O as readCodexRateLimitsRevision, P as resolveCodexAppServerFallbackApiKeyCacheKey, Q as resolveCodexTurnTerminalIdleTimeoutMs, T as isCodexAppServerRequestTimeoutError, U as resolveCodexAppServerHomeDir, V as isJsonObject, W as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, X as resolveCodexTurnAssistantCompletionIdleTimeoutMs, Y as resolveCodexStartupTimeoutMs, Z as resolveCodexTurnCompletionIdleTimeoutMs, _ as CodexAppServerRpcError, a as getLeasedSharedCodexAppServerClient, b as isCodexAppServerBrokenPipeError, d as retainSharedCodexAppServerClientIfCurrent, f as retireSharedCodexAppServerClientIfCurrent, j as resolveCodexAppServerAuthAccountCacheKey, k as readRecentCodexRateLimits, l as releaseLeasedSharedCodexAppServerClient, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, o as getSharedCodexAppServerClient, s as isCodexAppServerStartSelectionChangedError, t as clearSharedCodexAppServerClientIfCurrent, v as getCodexAppServerClientInstanceId, x as isCodexAppServerConnectionClosedError, y as isCodexAppServerApprovalRequest } from "./shared-client-BVKE40c-.js";
-import { C as isCodexAppServerApprovalPolicyAllowedByRequirements, D as resolveOpenClawExecPolicyForCodexAppServer, E as resolveCodexPluginsPolicy, S as resolveCodexModelBackedReviewerPolicyContext, T as readCodexPluginConfig, c as reclaimCurrentCodexSessionGeneration, h as resolveCodexComputerUseConfig, i as createCodexSessionGenerationSupersededError, l as sessionBindingIdentity, v as shouldAutoApproveCodexAppServerApprovals, w as isCodexSandboxExecServerEnabled, y as withMcpElicitationsApprovalPolicy } from "./session-binding-DlVQ-Pxs.js";
-import { a as closeCodexStartupClientBestEffort, l as retireCodexAppServerClientAfterTimedOutTurn, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, u as unsubscribeCodexThreadBestEffort } from "./attempt-client-cleanup-Ia52yRWc.js";
-import { S as updateActiveTurnItemIds, _ as readCodexNotificationItem, a as isCodexTurnAbortMarkerNotification, b as shouldDisarmAssistantCompletionIdleWatch, c as isPendingOpenClawDynamicToolCompletionNotification, d as isRawReasoningCompletionNotification, f as isRawToolOutputCompletionNotification, g as isTerminalTurnStatus, h as isRetryableErrorNotification, i as isAssistantCompletionReleaseNotification, l as isRawAssistantProgressNotification, m as isReasoningProgressNotification, n as describeNotificationActivity, o as isFileChangePatchUpdatedNotification, p as isReasoningItemCompletionNotification, r as isAssistantCommentaryCompletionNotification, s as isNativeToolProgressNotification, t as codexExecutionToolName, u as isRawFunctionToolOutputCompletionNotification, v as readNotificationItemId, x as updateActiveCompletionBlockerItemIds, y as readRawResponseToolCallId } from "./attempt-notifications-CMR2_fmR.js";
-import { $ as readHookOutputEntries, B as resolveCodexContextEngineProjectionReserveTokens, F as buildContextEngineBinding, G as mergeCodexThreadConfigs, H as buildCodexPluginThreadConfig, I as isContextEngineBindingCompatible, K as shouldBuildCodexPluginThreadConfig, L as fitCodexProjectedContextForTurnStart, M as areCodexDynamicToolFingerprintsCompatible, N as codexDynamicToolsFingerprint, O as isSystemAgentOnlyCodexDynamicToolAllowlist, P as codexLegacyDynamicToolsFingerprint, Q as readCodexErrorNotificationMessage, R as projectContextEngineAssemblyForCodex, T as filterCodexDynamicTools, U as buildCodexPluginThreadConfigInputFingerprint, W as buildCodexPluginThreadConfigTimeoutFallback, X as extractRawAssistantText, Y as resolveRecoverableCodexPluginConfigKeys, Z as normalizeNonEmptyString, a as sanitizeCodexHistoryImagePayloads, at as readNullableString$1, b as resolveCodexAppServerThreadModelSelection, ct as splitPlanText, et as readItem, g as buildDeveloperInstructions, h as resolveCodexWebSearchPlan, it as readNonNegativeInteger, j as resolveCodexDynamicToolsLoadingForRuntime, n as buildTurnStartParams, nt as readNonEmptyString$1, ot as readNumber, r as buildCodexUserInput, rt as readNonEmptyStringArray, s as startOrResumeThread, st as readString$6, t as buildTurnCollaborationMode, tt as readItemString, w as isCodexAppServerProfilerEnabled, z as resolveCodexContextEngineProjectionMaxChars } from "./thread-lifecycle-DRg_FdzC.js";
-import { n as projectCodexThreadUsageUpdate, t as normalizeCodexResponseTokenUsage } from "./event-projector-usage-tvgb1NCX.js";
-import { a as assertCodexTurnStartResponse, l as readCodexTurn, o as readCodexDynamicToolCallParams, u as readCodexTurnCompletedNotification } from "./protocol-validators-Dm4eXZmt.js";
-import { i as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-DSXX-rXO.js";
+import { $ as resolveCodexTurnAssistantCompletionIdleTimeoutMs, A as retainCodexAppServerLiveThread, D as resolveCodexAppServerClientInstanceId, E as isCodexAppServerRequestTimeoutError, F as resolveCodexAppServerAuthProfileId, I as resolveCodexAppServerAuthProfileIdForAgent, J as CodexAppServerStartupError, K as resolveCodexAppServerHomeDir, L as resolveCodexAppServerFallbackApiKeyCacheKey, M as readRecentCodexRateLimits, N as rememberCodexRateLimitsRead, P as resolveCodexAppServerAuthAccountCacheKey, Q as resolveCodexStartupTimeoutMs, R as resolveCodexAppServerPreparedApiKeyCacheKey, S as isCodexAppServerConnectionClosedError, U as flattenCodexDynamicToolFunctions, W as isJsonObject, Y as isCodexAppServerStartupError, Z as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, a as getLeasedSharedCodexAppServerClient, b as isCodexAppServerApprovalRequest, et as resolveCodexTurnCompletionIdleTimeoutMs, f as retainSharedCodexAppServerClientIfCurrent, j as readCodexRateLimitsRevision, k as ensureCodexAppServerClientRuntime, l as releaseLeasedSharedCodexAppServerClient, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, nt as withCodexStartupTimeout, o as getSharedCodexAppServerClient, p as retireSharedCodexAppServerClientIfCurrent, q as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, s as isCodexAppServerStartSelectionChangedError, t as clearSharedCodexAppServerClientIfCurrent, tt as resolveCodexTurnTerminalIdleTimeoutMs, v as CodexAppServerRpcError, x as isCodexAppServerBrokenPipeError, y as getCodexAppServerClientInstanceId, z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-DTbvH-XV.js";
+import { A as resolveOpenClawExecPolicyForCodexAppServer, D as isCodexSandboxExecServerEnabled, E as isCodexAppServerApprovalPolicyAllowedByRequirements, O as readCodexPluginConfig, S as withMcpElicitationsApprovalPolicy, T as resolveCodexModelBackedReviewerPolicyContext, c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, h as resolveCodexAppServerHomeScope, i as createCodexSessionGenerationSupersededError, k as resolveCodexPluginsPolicy, l as resolveCodexRunSessionBindingAuthority, u as scopeCodexRunBindingStore, v as resolveCodexComputerUseConfig, x as shouldAutoApproveCodexAppServerApprovals } from "./session-binding-BXpo9ymA.js";
+import { $ as readCodexErrorNotificationMessage, B as resolveCodexContextEngineProjectionReserveTokens, F as buildContextEngineBinding, G as mergeCodexThreadConfigs, H as buildCodexPluginThreadConfig, I as isContextEngineBindingCompatible, K as shouldBuildCodexPluginThreadConfig, L as fitCodexProjectedContextForTurnStart, M as areCodexDynamicToolFingerprintsCompatible, N as codexDynamicToolsFingerprint, O as isSystemAgentOnlyCodexDynamicToolAllowlist, P as codexLegacyDynamicToolsFingerprint, Q as normalizeNonEmptyString, R as projectContextEngineAssemblyForCodex, T as filterCodexDynamicTools, U as buildCodexPluginThreadConfigInputFingerprint, W as buildCodexPluginThreadConfigTimeoutFallback, X as resolveRecoverableCodexPluginConfigKeys, Z as extractRawAssistantText, _ as buildDeveloperInstructions, _t as unsubscribeCodexThreadBestEffort, a as sanitizeCodexHistoryImagePayloads, at as readNonNegativeInteger, c as isCodexAppServerProfilerEnabled, ct as readString$6, dt as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, et as readHookOutputEntries, ft as CodexAppServerUnsafeSubscriptionError, g as resolveCodexWebSearchPlan, gt as retireCodexAppServerClientAfterTimedOutTurn, ht as interruptCodexTurnBestEffort, it as readNonEmptyStringArray, j as resolveCodexDynamicToolsLoadingForRuntime, lt as splitPlanText, n as buildTurnStartParams, nt as readItemString, ot as readNullableString$1, pt as closeCodexStartupClientBestEffort, r as buildCodexUserInput, rt as readNonEmptyString$1, s as startOrResumeThread, st as readNumber, t as buildTurnCollaborationMode, tt as readItem, ut as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, x as resolveCodexAppServerThreadModelSelection, z as resolveCodexContextEngineProjectionMaxChars } from "./thread-lifecycle-DF53ogiA.js";
+import { S as updateActiveTurnItemIds, _ as readCodexNotificationItem, a as isCodexTurnAbortMarkerNotification, b as shouldDisarmAssistantCompletionIdleWatch, c as isPendingOpenClawDynamicToolCompletionNotification, d as isRawReasoningCompletionNotification, f as isRawToolOutputCompletionNotification, g as isTerminalTurnStatus, h as isRetryableErrorNotification, i as isAssistantCompletionReleaseNotification, l as isRawAssistantProgressNotification, m as isReasoningProgressNotification, n as describeNotificationActivity, o as isFileChangePatchUpdatedNotification, p as isReasoningItemCompletionNotification, r as isAssistantCommentaryCompletionNotification, s as isNativeToolProgressNotification, t as codexExecutionToolName, u as isRawFunctionToolOutputCompletionNotification, v as readNotificationItemId, x as updateActiveCompletionBlockerItemIds, y as readRawResponseToolCallId } from "./attempt-notifications-AP-a-Q5k.js";
+import { r as projectCodexThreadUsageUpdate, t as CodexResponseCompletionProjection } from "./event-projector-usage-Xp4AlR2k.js";
+import { C as readCodexTurnCompletedNotification, S as readCodexTurn, d as attachCodexMirrorIdentity, f as readMirrorIdentity, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as promptSnapshot, t as codexTranscriptMirrorRuntime, u as serializeCodexMirrorSourceEvidence, v as assertCodexTurnStartResponse, y as readCodexDynamicToolCallParams } from "./transcript-mirror-DzsdNCf5.js";
+import { i as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-DztPafOA.js";
 import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
-import { d as attachCodexMirrorIdentity, f as readMirrorIdentity, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as promptSnapshot, t as codexTranscriptMirrorRuntime, u as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-uKA-A4tB.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-BHRSI6Cn.js";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-S_PXs0ul.js";
-import { r as formatCodexDisplayText } from "./command-formatters-ico4ZFnk.js";
-import { n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BmDgseo_.js";
-import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId, t as isCodexNotificationForTurn } from "./notification-correlation-Bj_Ak_jI.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-BFDTVYr4.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CU-gVCCS.js";
+import { r as formatCodexDisplayText } from "./command-formatters-C336eRVS.js";
+import { n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BSaO2JIT.js";
+import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId, t as isCodexNotificationForTurn } from "./notification-correlation-CU6_AnOb.js";
 import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-B4FfbcCg.js";
 import { i as resolveCodexLocalRuntimeAttribution, n as createAssistantMessage, r as createAssistantMirrorMessage, t as createAssistantCommentaryMessage } from "./event-projector-assistant-message-DTgnPPVF.js";
-import { $ as shouldSynthesizeToolProgressForItem, A as resolveCodexNativeHookRelayEvents, B as shouldReleaseTurnAfterTerminalDynamicTool, C as CodexNativeToolLifecycleProjector, D as buildCodexNativeHookRelayDisabledConfig, E as buildCodexNativeHookRelayConfig, F as isDynamicToolTerminalDiagnosticEvent, G as isNonSuccessItemStatus, H as toCodexDynamicToolProtocolResponse, I as isMatchingDynamicToolTerminalDiagnostic, J as itemName, K as isSideEffectingNativeToolItem, L as resolveDynamicToolCallTimeoutMs, M as scheduleCodexNativeHookRelayUnregister, N as handleDynamicToolCallWithTimeout, O as createCodexNativeHookRelay, P as hasPendingDynamicToolTerminalDiagnostic, Q as shouldRecordNativeToolTranscript, R as resolveTerminalDynamicToolBatchAction, T as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, U as resolveCodexToolAbortTerminalReason, V as toCodexDynamicToolProgressResponse, W as isMutatingNativeToolItem, X as itemTitle, Y as itemStatus, Z as shouldClearTerminalPresentationForNativeItem, _ as resolveCodexMessageToolProvider, a as emitDynamicToolStartedDiagnostic, b as shouldRequireCodexSandboxExecServerEnvironment, d as createCodexDynamicToolBuildStageTracker, et as unknownItemStatus, f as disableCodexPluginThreadConfig, g as resolveCodexExternalSandboxPolicyForOpenClawSandbox, h as resolveCodexAppServerHookChannelId, i as emitDynamicToolErrorDiagnostic, j as resolveCodexNativeHookRelayTtlMs, k as emitCodexNativePreToolUseFailureDiagnostic, l as settleCodexSourceReplyFinality, m as resolveCodexAppServerExecutionCwd, n as handleCodexAppServerApprovalRequest, o as emitDynamicToolTerminalDiagnostic, p as formatCodexDynamicToolBuildStageSummary, q as itemKind, r as handleCodexAppServerElicitationRequest, s as resolveCodexProviderWebSearchSupport, t as createCodexDynamicToolBridge, u as buildDynamicTools, v as resolveCodexSandboxEnvironmentSelection, x as shouldWarnCodexDynamicToolBuildStageSummary, y as shouldEnableCodexAppServerNativeToolSurface, z as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult } from "./dynamic-tools-LIt9ojep.js";
-import { a as runCodexComputerUseLiveTest, r as killStaleComputerUseMcpChildren, t as ensureCodexComputerUse } from "./computer-use-BjGylO-E.js";
+import { $ as shouldClearTerminalPresentationForNativeItem, A as createCodexNativeHookRelay, B as resolveTerminalDynamicToolBatchAction, D as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, F as handleDynamicToolCallWithTimeout, G as resolveCodexToolAbortTerminalReason, H as shouldReleaseTurnAfterTerminalDynamicTool, I as hasPendingDynamicToolTerminalDiagnostic, J as isSideEffectingNativeToolItem, K as isMutatingNativeToolItem, L as isDynamicToolTerminalDiagnosticEvent, M as resolveCodexNativeHookRelayEvents, N as resolveCodexNativeHookRelayTtlMs, O as buildCodexNativeHookRelayConfig, P as scheduleCodexNativeHookRelayUnregister, Q as itemTitle, R as isMatchingDynamicToolTerminalDiagnostic, S as shouldWarnCodexDynamicToolBuildStageSummary, T as CodexNativeToolLifecycleProjector, U as toCodexDynamicToolProgressResponse, V as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, W as toCodexDynamicToolProtocolResponse, X as itemName, Y as itemKind, Z as itemStatus, _ as resolveCodexExternalSandboxPolicyForOpenClawSandbox, a as emitDynamicToolStartedDiagnostic, b as shouldEnableCodexAppServerNativeToolSurface, d as buildDynamicTools, et as shouldRecordNativeToolTranscript, f as createCodexDynamicToolBuildStageTracker, g as resolveCodexAppServerHookChannelId, h as resolveCodexAppServerExecutionCwd, i as emitDynamicToolErrorDiagnostic, j as emitCodexNativePreToolUseFailureDiagnostic, k as buildCodexNativeHookRelayDisabledConfig, l as buildCodexHookRequester, m as formatCodexDynamicToolBuildStageSummary, n as handleCodexAppServerApprovalRequest, nt as unknownItemStatus, o as emitDynamicToolTerminalDiagnostic, p as disableCodexPluginThreadConfig, q as isNonSuccessItemStatus, r as handleCodexAppServerElicitationRequest, s as resolveCodexProviderWebSearchSupport, t as createCodexDynamicToolBridge, tt as shouldSynthesizeToolProgressForItem, u as settleCodexSourceReplyFinality, v as resolveCodexMessageToolProvider, w as readBoundedCodexRemoteWorkspaceFile, x as shouldRequireCodexSandboxExecServerEnvironment, y as resolveCodexSandboxEnvironmentSelection, z as resolveDynamicToolCallTimeoutMs } from "./dynamic-tools-D2gYkSBO.js";
+import { a as killStaleComputerUseMcpChildren, i as runCodexComputerUseLiveTest, t as ensureCodexComputerUse } from "./computer-use-CYEc8U3w.js";
 import fs from "node:fs/promises";
 import path, { posix } from "node:path";
 import { asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, TOOL_PROGRESS_OUTPUT_MAX_CHARS, agentHarnessAttemptTerminal, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, finalizeHarnessContextEngineTurn, formatErrorMessage, formatFastModeAutoProgressText, formatToolAggregate, formatToolProgressOutput, getAgentHarnessHookRunner, getBeforeToolCallPolicyDiagnosticState, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessGatewayQuestion, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, TOOL_PROGRESS_OUTPUT_MAX_CHARS, agentHarnessAttemptTerminal, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, buildWatchedSessionsHarnessContext, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, finalizeHarnessContextEngineTurn, formatErrorMessage, formatFastModeAutoProgressText, formatToolAggregate, formatToolProgressOutput, getAgentHarnessHookRunner, getBeforeToolCallPolicyDiagnosticState, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessGatewayQuestion, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash, randomUUID } from "node:crypto";
 import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { asFiniteNumber, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { listSessionEntries, parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
+import { SsrFBlockedError, isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
+import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
 import { spawn } from "node:child_process";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { once } from "node:events";
 import { isIP } from "node:net";
 import { WebSocketServer } from "ws";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { redactSensitiveFieldValue, redactSensitiveText, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { readSessionTranscriptEvents } from "openclaw/plugin-sdk/session-transcript-runtime";
@@ -41,9 +40,9 @@ import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
 import { createAgentHarnessTaskRuntime, deliverAgentHarnessTaskCompletion, isDurableAgentHarnessCompletionDelivery } from "openclaw/plugin-sdk/agent-harness-task-runtime";
-import { SsrFBlockedError, isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
 //#region extensions/codex/src/app-server/attempt-steering.ts
 /**
 * Debounced steering queue for forwarding user messages to an active Codex
@@ -394,7 +393,11 @@ var CodexAssistantProjection = class {
 			return;
 		}
 		const turnItems = turn.items ?? [];
-		const authoritativeIndex = turnItems.findLastIndex((item) => item.type === "agentMessage" && readItemString(item, "phase") === "final_answer" && typeof item.text === "string" && item.text.trim().length > 0);
+		const authoritativeIndex = turnItems.findLastIndex((item) => {
+			if (item.type !== "agentMessage" || typeof item.text !== "string" || item.text.trim().length === 0) return false;
+			const phase = readItemString(item, "phase");
+			return phase === "final_answer" || phase === void 0;
+		});
 		const authoritative = authoritativeIndex >= 0 ? turnItems[authoritativeIndex] : void 0;
 		if (turnItems.slice(authoritativeIndex + 1).some(shouldClearTerminalPresentationForNativeItem) || authoritative?.id === this.latestTerminalAssistantCandidateItemId && this.latestTerminalAssistantCandidateSuperseded) {
 			this.supersedeVisibleAnswerCandidate();
@@ -1282,13 +1285,6 @@ var CodexToolProgressProjection = class {
 function isMissingFileError(error) {
 	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 }
-function selectPreferredSessionKey(matches, sessionId) {
-	const structural = matches.filter(({ sessionKey }) => sessionKey === sessionId || sessionKey.endsWith(`:${sessionId}`));
-	const candidates = structural.length > 0 ? structural : matches;
-	if (candidates.length === 1) return candidates[0]?.sessionKey;
-	const sorted = candidates.toSorted((left, right) => (right.entry.updatedAt ?? 0) - (left.entry.updatedAt ?? 0));
-	return (sorted[0]?.entry.updatedAt ?? 0) > (sorted[1]?.entry.updatedAt ?? 0) ? sorted[0]?.sessionKey : void 0;
-}
 /** Returns sanitized session-context messages for a Codex mirrored session file. */
 async function readCodexMirroredSessionHistoryMessages(target) {
 	try {
@@ -1323,16 +1319,19 @@ async function readCodexMirroredSessionEntries(target) {
 }
 function resolveSqliteMarkerSessionKey(target, marker) {
 	const explicitSessionKey = target.sessionKey?.trim();
-	const entries = listSessionEntries({
+	if (explicitSessionKey) {
+		const explicitEntry = getSessionEntry({
+			agentId: marker.agentId,
+			sessionKey: explicitSessionKey,
+			storePath: marker.storePath
+		});
+		if (explicitEntry) return explicitEntry.sessionId === marker.sessionId ? explicitSessionKey : void 0;
+	}
+	return resolveTranscriptSessionKeyBySessionId({
 		agentId: marker.agentId,
-		readOnly: true,
+		sessionId: marker.sessionId,
 		storePath: marker.storePath
 	});
-	if (explicitSessionKey) {
-		const explicitEntry = entries.find(({ sessionKey }) => sessionKey === explicitSessionKey);
-		if (explicitEntry) return explicitEntry.entry.sessionId === marker.sessionId ? explicitSessionKey : void 0;
-	}
-	return selectPreferredSessionKey(entries.filter(({ entry }) => entry.sessionId === marker.sessionId), marker.sessionId);
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-tool-transcript.ts
@@ -1351,6 +1350,35 @@ const ZERO_USAGE = {
 	}
 };
 const MISSING_TOOL_RESULT_ERROR = "OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.";
+const NATIVE_PATCH_REJECTION_RE = /^\s*patch rejected:\s*writing outside of the project;\s*rejected by user approval settings\s*$/iu;
+const CODE_MODE_NATIVE_PATCH_SOURCE_RE = /^\s*(?:\/\/[^\r\n]*\r?\n\s*)?(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*await\s+tools\.apply_patch\(\s*("(?:\\[\s\S]|[^"\\])*")\s*\)\s*;?\s*text\(\s*\1\s*\)\s*;?\s*$/u;
+const CODE_MODE_NATIVE_PATCH_RESULT_RE = /^\s*Script (completed|failed)\s*\r?\nWall time\s+\d+(?:\.\d+)?\s+seconds\s*\r?\nOutput:\s*([\s\S]*?)\s*$/iu;
+function readCodeModeNativePatchInput(source) {
+	if (typeof source !== "string") return;
+	const match = CODE_MODE_NATIVE_PATCH_SOURCE_RE.exec(source);
+	if (!match?.[2]) return;
+	try {
+		const patch = JSON.parse(match[2]);
+		return typeof patch === "string" && /^\*\*\* Begin Patch\r?\n[\s\S]*\r?\n\*\*\* End Patch(?:\r?\n)?$/u.test(patch) ? patch : void 0;
+	} catch {
+		return;
+	}
+}
+function readInterceptedNativePatchInput(command) {
+	if (typeof command !== "string") return;
+	const lines = command.replace(/\r\n?/gu, "\n").split("\n");
+	const patchStart = lines.indexOf("*** Begin Patch");
+	const invocation = /^[\t ]*(?:cd[\t ]+(?:'([^'\n]+)'|([A-Za-z0-9_./-]+))[\t ]+&&[\t ]+)?apply_patch[\t ]*<<-?[\t ]*'([^'\n]+)'[\t ]*$/u.exec(lines[0] ?? "");
+	if (!invocation || patchStart !== 1) return;
+	const patchEnd = lines.indexOf("*** End Patch", patchStart + 1);
+	const cwd = invocation[1] ?? invocation[2];
+	const delimiter = invocation[3];
+	if (patchEnd < 0 || lines[patchEnd + 1] !== delimiter || lines.slice(patchEnd + 2).some((line) => line.trim().length > 0)) return;
+	return {
+		input: `${lines.slice(patchStart, patchEnd + 1).join("\n")}\n`,
+		...cwd ? { cwd } : {}
+	};
+}
 var CodexToolTranscriptProjection = class {
 	constructor(params, threadId, turnId, progress, nextTranscriptTimestamp, options = {}) {
 		this.params = params;
@@ -1370,6 +1398,8 @@ var CodexToolTranscriptProjection = class {
 		this.afterToolCallObservedItemIds = /* @__PURE__ */ new Set();
 		this.nativeMcpAppResultDetails = /* @__PURE__ */ new Map();
 		this.nativeMcpAppResultDetailsAttempted = /* @__PURE__ */ new Set();
+		this.rawNativeToolOutputByCallId = /* @__PURE__ */ new Map();
+		this.codeModeNativePatchInputsByCallId = /* @__PURE__ */ new Map();
 	}
 	get transcriptMessages() {
 		return this.messages;
@@ -1381,13 +1411,14 @@ var CodexToolTranscriptProjection = class {
 			arguments: sanitizeCodexToolArguments(params.arguments)
 		});
 	}
-	recordDynamicToolResult(params) {
+	recordDynamicToolResult(params, resultContentSource) {
 		this.recordToolResult({
 			id: params.callId,
 			name: params.tool,
 			text: collectDynamicToolContentText(params.contentItems),
 			isError: !params.success,
-			details: params.details
+			details: params.details,
+			...resultContentSource ? { resultContentSource } : {}
 		});
 	}
 	recordNativeToolCall(item) {
@@ -1405,10 +1436,91 @@ var CodexToolTranscriptProjection = class {
 		if (name) this.recordToolResult({
 			id: item.id,
 			name,
-			text: itemTranscriptResultText(item, this.progress.outputTextByItem),
+			text: this.rawNativeToolOutputByCallId.get(item.id) ?? itemTranscriptResultText(item, this.progress.outputTextByItem),
 			isError: isNonSuccessItemStatus(itemStatus(item)),
-			details
-		});
+			details,
+			...item.type === "webSearch" ? { resultContentSource: "network" } : {}
+		});
+	}
+	recordRawNativeToolItem(item) {
+		const type = typeof item.type === "string" ? item.type : void 0;
+		const callId = typeof item.call_id === "string" ? item.call_id : typeof item.callId === "string" ? item.callId : void 0;
+		if (!callId) return;
+		if ((type === "custom_tool_call" || type === "function_call") && (item.name === "apply_patch" || item.name === "exec_command" || item.name === "exec")) {
+			let args;
+			if (type === "custom_tool_call" && item.name === "apply_patch" && typeof item.input === "string") args = { input: item.input };
+			else if (type === "custom_tool_call" && item.name === "exec") {
+				const input = readCodeModeNativePatchInput(item.input);
+				if (input) this.codeModeNativePatchInputsByCallId.set(callId, input);
+				return;
+			} else if (type === "function_call" && typeof item.arguments === "string") try {
+				const parsed = JSON.parse(item.arguments);
+				if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+					const parsedArguments = parsed;
+					if (item.name === "apply_patch") args = parsedArguments;
+					else {
+						const patch = readInterceptedNativePatchInput(typeof parsedArguments.cmd === "string" ? parsedArguments.cmd : typeof parsedArguments.command === "string" ? parsedArguments.command : void 0);
+						if (patch) {
+							const workdir = typeof parsedArguments.workdir === "string" ? parsedArguments.workdir : typeof parsedArguments.cwd === "string" ? parsedArguments.cwd : void 0;
+							const cwd = patch.cwd ? workdir && !path.isAbsolute(patch.cwd) ? path.join(workdir, patch.cwd) : patch.cwd : workdir;
+							args = {
+								input: patch.input,
+								...cwd ? { cwd } : {}
+							};
+						}
+					}
+				}
+			} catch {
+				return;
+			}
+			if (args) this.recordToolCall({
+				id: callId,
+				name: "apply_patch",
+				arguments: args
+			});
+			return;
+		}
+		if (type !== "custom_tool_call_output" && type !== "function_call_output" || this.namesById.get(callId) !== "apply_patch" && !this.codeModeNativePatchInputsByCallId.has(callId)) return;
+		const text = typeof item.output === "string" ? item.output : Array.isArray(item.output) ? collectDynamicToolContentText(item.output) : "";
+		if (!text.trim()) return;
+		const codeModePatchInput = this.codeModeNativePatchInputsByCallId.get(callId);
+		if (codeModePatchInput) {
+			this.codeModeNativePatchInputsByCallId.delete(callId);
+			const execution = CODE_MODE_NATIVE_PATCH_RESULT_RE.exec(text);
+			if (execution?.[1]?.toLowerCase() === "completed" && execution[2]?.trim() === "{}") return;
+			if (execution?.[1]?.toLowerCase() === "failed") {
+				const failure = execution[2]?.replace(/^Script error:\s*/iu, "").trim() || text;
+				this.recordToolCall({
+					id: callId,
+					name: "apply_patch",
+					arguments: { input: codeModePatchInput }
+				});
+				this.recordToolResult({
+					id: callId,
+					name: "apply_patch",
+					text: failure,
+					isError: true
+				});
+			}
+			return;
+		}
+		this.rawNativeToolOutputByCallId.set(callId, text);
+		const result = this.messages.find((message) => message.role === "toolResult" && message.toolCallId === callId);
+		if (!result) {
+			if (NATIVE_PATCH_REJECTION_RE.test(text)) this.recordToolResult({
+				id: callId,
+				name: "apply_patch",
+				text,
+				isError: true
+			});
+			return;
+		}
+		result.content = this.createToolResultMessage({
+			id: callId,
+			name: "apply_patch",
+			text,
+			isError: result.isError === true
+		}).content;
 	}
 	async recordNativeToolResultWithDetails(item) {
 		this.recordNativeToolResult(item, await this.prepareNativeMcpAppResultDetails(item));
@@ -1525,10 +1637,11 @@ var CodexToolTranscriptProjection = class {
 				output: text
 			});
 		}
-		if (!params.recordPromptError) {
+		if (params.terminalDisposition === "tool_error") {
 			this.recordMissingToolError(missingTranscriptIds, missingTrajectoryIds);
 			return;
 		}
+		if (params.terminalDisposition === "diagnostic_only") return;
 		const missingCount = (/* @__PURE__ */ new Set([...missingTranscriptIds, ...missingTrajectoryIds])).size;
 		return missingCount === 1 ? MISSING_TOOL_RESULT_ERROR : `${MISSING_TOOL_RESULT_ERROR} missingToolResultCount=${missingCount}`;
 	}
@@ -1615,6 +1728,7 @@ var CodexToolTranscriptProjection = class {
 				text
 			}],
 			...params.details !== void 0 ? { details: params.details } : {},
+			...params.resultContentSource ? { __openclaw: { resultContentSource: params.resultContentSource } } : {},
 			timestamp: this.nextTranscriptTimestamp()
 		};
 	}
@@ -1774,56 +1888,127 @@ var CodexEventProjection = class {
 //#region extensions/codex/src/app-server/event-projector-media.ts
 const GENERATED_IMAGE_MEDIA_SUBDIR = "tool-image-generation";
 var CodexGeneratedMediaProjection = class {
-	constructor(config) {
+	constructor(config, remote) {
 		this.config = config;
+		this.remote = remote;
 		this.itemIds = /* @__PURE__ */ new Set();
 		this.urlsByItemId = /* @__PURE__ */ new Map();
+		this.gatewayMaterializedItemIds = /* @__PURE__ */ new Set();
+		this.pendingMaterializationsByItemId = /* @__PURE__ */ new Map();
 	}
 	hasGeneratedMedia() {
 		return this.itemIds.size > 0;
 	}
-	recordNative(item) {
+	async recordNative(item) {
 		if (item?.type !== "imageGeneration") return;
+		this.itemIds.add(item.id);
+		const result = readItemString(item, "result");
+		if (result) {
+			await this.recordImage({
+				itemId: item.id,
+				result,
+				revisedPrompt: readItemString(item, "revisedPrompt"),
+				source: "native"
+			});
+			return;
+		}
 		const savedPath = readItemString(item, "savedPath")?.trim();
-		if (savedPath) this.recordUrl({
-			itemId: item.id,
-			mediaUrl: savedPath
-		});
+		if (savedPath) {
+			if (this.remote?.remoteWorkspaceRoot) {
+				if (!this.remote.readFile) {
+					embeddedAgentLog.warn("codex remote image has no app-server file transfer", { itemId: item.id });
+					return;
+				}
+				try {
+					const response = 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) {
+						embeddedAgentLog.warn("codex remote image file returned no inline bytes", { itemId: item.id });
+						return;
+					}
+					await this.recordImage({
+						itemId: item.id,
+						result: response.dataBase64,
+						revisedPrompt: readItemString(item, "revisedPrompt"),
+						source: "native"
+					});
+				} catch (error) {
+					embeddedAgentLog.warn("codex app-server remote image file read failed", {
+						itemId: item.id,
+						error
+					});
+				}
+				return;
+			}
+			this.recordUrl({
+				itemId: item.id,
+				mediaUrl: savedPath
+			});
+		}
 	}
 	async recordRaw(item) {
 		if (readString$6(item, "type") !== "image_generation_call") return;
 		const result = readString$6(item, "result");
 		if (!result) return;
 		const itemId = readString$6(item, "id") ?? `raw-image-${this.itemIds.size}`;
-		this.itemIds.add(itemId);
+		await this.recordImage({
+			itemId,
+			result,
+			revisedPrompt: readString$6(item, "revised_prompt") ?? readString$6(item, "revisedPrompt"),
+			source: "raw"
+		});
+	}
+	async recordImage(params) {
+		this.itemIds.add(params.itemId);
+		if (this.gatewayMaterializedItemIds.has(params.itemId)) return;
+		let pending = this.pendingMaterializationsByItemId.get(params.itemId);
+		while (pending) {
+			await pending;
+			if (this.gatewayMaterializedItemIds.has(params.itemId)) return;
+			pending = this.pendingMaterializationsByItemId.get(params.itemId);
+		}
+		const materialization = this.materializeImage(params);
+		this.pendingMaterializationsByItemId.set(params.itemId, materialization);
+		try {
+			await materialization;
+		} finally {
+			if (this.pendingMaterializationsByItemId.get(params.itemId) === materialization) this.pendingMaterializationsByItemId.delete(params.itemId);
+		}
+	}
+	async materializeImage(params) {
 		const maxBytes = resolveGeneratedMediaMaxBytes(this.config, "image");
-		const estimatedDecodedBytes = estimateBase64DecodedBytes(result);
+		const estimatedDecodedBytes = estimateBase64DecodedBytes(params.result);
 		if (estimatedDecodedBytes !== void 0 && estimatedDecodedBytes > maxBytes) {
-			embeddedAgentLog.warn("codex app-server raw image generation result exceeds media limit", {
-				itemId,
+			embeddedAgentLog.warn(`codex app-server ${params.source} image generation result exceeds media limit`, {
+				itemId: params.itemId,
 				estimatedDecodedBytes,
 				maxBytes
 			});
 			return;
 		}
 		const asset = generatedImageAssetFromBase64({
-			base64: result,
+			base64: params.result,
 			index: this.itemIds.size,
-			revisedPrompt: readString$6(item, "revised_prompt") ?? readString$6(item, "revisedPrompt"),
+			revisedPrompt: params.revisedPrompt,
 			fileNamePrefix: "codex-image-generation",
 			sniffMimeType: true
 		});
 		if (!asset) return;
 		try {
 			const saved = await saveMediaBuffer(asset.buffer, asset.mimeType, GENERATED_IMAGE_MEDIA_SUBDIR, maxBytes, asset.fileName);
+			this.gatewayMaterializedItemIds.add(params.itemId);
 			this.recordUrl({
-				itemId,
+				itemId: params.itemId,
 				mediaUrl: saved.path,
 				replaceExisting: true
 			});
 		} catch (error) {
-			embeddedAgentLog.warn("codex app-server raw image generation result save failed", {
-				itemId,
+			embeddedAgentLog.warn(`codex app-server ${params.source} image generation result save failed`, {
+				itemId: params.itemId,
 				error
 			});
 		}
@@ -1985,6 +2170,28 @@ function reasoningMethodOrder(method) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-snapshot.ts
+function readTurnTaintMetadata(message) {
+	const metadata = message["__openclaw"];
+	return metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : void 0;
+}
+function applyStickyTurnTaint(messages) {
+	let tainted = false;
+	return messages.map((message) => {
+		if (message.role === "user") {
+			tainted = false;
+			return message;
+		}
+		const metadata = readTurnTaintMetadata(message);
+		tainted ||= metadata?.turnTainted === true || metadata?.resultContentSource === "network";
+		return message.role === "assistant" && tainted ? {
+			...message,
+			__openclaw: {
+				...metadata,
+				turnTainted: true
+			}
+		} : message;
+	});
+}
 function buildCodexMessagesSnapshot(params) {
 	const messages = promptSnapshot(params.runParams, params.turnId, params.upstreamUserText);
 	if (params.reasoningText) messages.push(attachCodexMirrorIdentity(params.createAssistantMirrorMessage("Codex reasoning", params.reasoningText), `${params.turnId}:reasoning`));
@@ -1992,7 +2199,7 @@ function buildCodexMessagesSnapshot(params) {
 	const visibleWorkMessages = [...params.runParams.config?.ui?.prefs?.chatPersistCommentary === false ? [] : params.commentaryMessages.map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:commentary:${itemId}`)), ...params.toolMessages].toSorted((left, right) => (asDateTimestampMs(left.timestamp) ?? 0) - (asDateTimestampMs(right.timestamp) ?? 0));
 	messages.push(...visibleWorkMessages);
 	if (params.lastAssistant) messages.push(attachCodexMirrorIdentity(params.lastAssistant, `${params.turnId}:assistant`));
-	return messages.map((message) => projectAgentHarnessTranscriptMessageForDisplay({
+	return applyStickyTurnTaint(messages).map((message) => projectAgentHarnessTranscriptMessageForDisplay({
 		hidden: params.runParams.trigger === "memory",
 		message
 	}));
@@ -2153,11 +2360,17 @@ var CodexAppServerEventProjector = class {
 		this.promptErrorSource = null;
 		this.synthesizedMissingToolResultError = null;
 		this.aborted = false;
+		this.responseCompletions = new CodexResponseCompletionProjection();
 		this.completedCompactionCount = 0;
 		this.lastTranscriptTimestamp = 0;
 		this.diagnostics = new CodexProjectionDiagnostics(threadId, turnId);
 		this.nativeToolLifecycleProjector = new CodexNativeToolLifecycleProjector(params, threadId, turnId, { runAbortSignal: options.runAbortSignal });
-		this.generatedMediaProjection = new CodexGeneratedMediaProjection(params.config);
+		this.generatedMediaProjection = new CodexGeneratedMediaProjection(params.config, {
+			remoteWorkspaceRoot: options.remoteWorkspaceRoot,
+			readFile: options.readRemoteWorkspaceFile,
+			requestTimeoutMs: options.remoteWorkspaceRequestTimeoutMs,
+			signal: options.runAbortSignal
+		});
 		this.toolProgressProjection = new CodexToolProgressProjection(params);
 		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, () => this.nextTranscriptTimestamp(), {
 			nativePostToolUseRelayEnabled: options.nativePostToolUseRelayEnabled,
@@ -2260,13 +2473,13 @@ var CodexAppServerEventProjector = class {
 				await this.handleTurnCompleted(params);
 				break;
 			case "rawResponse/completed":
-				this.handleRawResponseCompleted(params);
+				this.responseCompletions.record(params);
 				break;
 			case "rawResponseItem/completed":
 				await this.handleRawResponseItemCompleted(params);
 				break;
 			case "error":
-				this.responseUsage = void 0;
+				this.responseCompletions.clear();
 				if (params.willRetry === true) break;
 				this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
 				this.promptErrorSource = "prompt";
@@ -2294,13 +2507,14 @@ var CodexAppServerEventProjector = class {
 		const commentaryMessages = this.assistantProjection.collectCommentaryMessages();
 		const reasoningText = this.reasoningProjection.reasoningText();
 		const planText = this.reasoningProjection.planText();
-		const projectedUsage = this.aborted ? this.tokenUsage : this.responseUsage ?? this.tokenUsage;
+		const completedUsage = this.responseCompletions.usage ?? this.tokenUsage;
+		const projectedUsage = this.aborted ? this.tokenUsage : completedUsage;
 		const hasAssistantItemText = this.assistantProjection.hasAssistantItemTextForSynthesis();
 		const legacyFailClosed = !this.completedTurn || this.completedTurn.status !== "completed" || hasAssistantItemText;
 		const hasDeliverableAssistantOnCompletedTurn = this.completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
 		const synthesizedMissingToolResultError = this.toolTranscriptProjection.synthesizeMissingToolResults({
 			synthesize: legacyFailClosed,
-			recordPromptError: legacyFailClosed && !hasDeliverableAssistantOnCompletedTurn && !this.aborted
+			terminalDisposition: this.aborted ? "tool_error" : hasDeliverableAssistantOnCompletedTurn ? "diagnostic_only" : "prompt_error"
 		});
 		if (synthesizedMissingToolResultError) {
 			this.synthesizedMissingToolResultError = synthesizedMissingToolResultError;
@@ -2345,6 +2559,7 @@ var CodexAppServerEventProjector = class {
 			...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
 			bootstrapPromptWarningSignaturesSeen: this.params.bootstrapPromptWarningSignaturesSeen,
 			bootstrapPromptWarningSignature: this.params.bootstrapPromptWarningSignature,
+			...this.responseCompletions.modelIterations > 0 ? { modelIterations: this.responseCompletions.modelIterations } : {},
 			messagesSnapshot,
 			assistantTexts,
 			toolMetas,
@@ -2383,7 +2598,8 @@ var CodexAppServerEventProjector = class {
 	}
 	recordDynamicToolResult(params) {
 		this.toolProgressProjection.recordDynamicToolResult(params);
-		this.toolTranscriptProjection.recordDynamicToolResult(params);
+		const source = this.options.resolveDynamicToolResultContentSource?.(params.tool);
+		this.toolTranscriptProjection.recordDynamicToolResult(params, source);
 	}
 	markTimedOut() {
 		this.aborted = true;
@@ -2392,7 +2608,7 @@ var CodexAppServerEventProjector = class {
 	}
 	markAborted() {
 		this.aborted = true;
-		this.responseUsage = void 0;
+		this.responseCompletions.clear();
 	}
 	isCompacting() {
 		return this.activeCompactionItemIds.size > 0;
@@ -2462,7 +2678,7 @@ var CodexAppServerEventProjector = class {
 		}
 		this.assistantProjection.recordItemCompleted(item, itemId, this.activeItemIds);
 		this.reasoningProjection.recordItem(item);
-		this.generatedMediaProjection.recordNative(item);
+		await this.generatedMediaProjection.recordNative(item);
 		if (item?.type === "contextCompaction" && itemId) {
 			this.activeCompactionItemIds.delete(itemId);
 			this.completedCompactionCount += 1;
@@ -2517,15 +2733,11 @@ var CodexAppServerEventProjector = class {
 			}
 		});
 	}
-	handleRawResponseCompleted(params) {
-		const usage = isJsonObject(params.usage) ? params.usage : void 0;
-		this.responseUsage = usage ? normalizeCodexResponseTokenUsage(usage) : void 0;
-	}
 	async handleTurnCompleted(params) {
 		const turn = readCodexTurn(params.turn);
 		if (!turn || turn.id !== this.turnId) return;
 		this.completedTurn = turn;
-		if (turn.status !== "completed") this.responseUsage = void 0;
+		if (turn.status !== "completed") this.responseCompletions.clear();
 		if (turn.status === "failed") {
 			const usageLimitMessage = formatCodexUsageLimitErrorMessage({
 				message: turn.error?.message,
@@ -2549,7 +2761,7 @@ var CodexAppServerEventProjector = class {
 			this.diagnostics.warnUnknownItemStatus(item);
 			this.assistantProjection.recordSnapshotItem(item);
 			this.reasoningProjection.recordItem(item);
-			this.generatedMediaProjection.recordNative(item);
+			await this.generatedMediaProjection.recordNative(item);
 			this.toolProgressProjection.recordToolMeta(item);
 			this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
 			await this.emitSnapshotOnlyNativeToolProgress(item);
@@ -2593,6 +2805,7 @@ var CodexAppServerEventProjector = class {
 	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
 		if (!item) return;
+		this.toolTranscriptProjection.recordRawNativeToolItem(item);
 		this.assistantProjection.handleRawResponseItemCompleted(item, this.activeItemIds);
 		await this.generatedMediaProjection.recordRaw(item);
 	}
@@ -2958,7 +3171,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const { runtime, attemptTools } = context;
 	const { connection } = runtime;
 	const { params, runAbortController, terminalState, abortExplicitly, abortFromUpstream, bindingStore, bindingIdentity, sessionAgentId, sandboxSessionKey, effectiveCwd } = connection;
-	const { dynamicToolParams, computerContextEpoch } = attemptTools;
+	const { dynamicToolParams, computerContextEpoch, toolBridge } = attemptTools;
 	const { state, userInputBridgeRef, steeringQueueRef, turnWatches } = turnRuntime;
 	const { emitExecutionPhaseOnce, emitLifecycleStart, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const { enqueueNotification } = notifications;
@@ -2998,7 +3211,17 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		nativePostToolUseRelayEnabled: resourceState.nativeHookRelay?.allowedEvents.includes("post_tool_use") === true && resourceState.nativeHookRelay.shouldRelayEvent("post_tool_use"),
 		readRecentRateLimits: () => readRecentCodexRateLimits(resourceState.client),
 		runAbortSignal: runAbortController.signal,
+		remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
+		remoteWorkspaceRequestTimeoutMs: connection.appServer.requestTimeoutMs,
+		readRemoteWorkspaceFile: ({ path, maxBytes, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
+			client: resourceState.client,
+			path,
+			maxBytes,
+			signal,
+			timeoutMs
+		}),
 		trajectoryRecorder,
+		resolveDynamicToolResultContentSource: toolBridge.resultContentSourceForTool,
 		onNativeToolResultRecorded: maybeAnnounceFastModeAutoOff,
 		...prepareNativeMcpAppResultDetails ? { prepareNativeMcpAppResultDetails } : {},
 		upstreamUserText: turnState.codexTurnPromptText,
@@ -3164,15 +3387,27 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 	});
 	if (!state.timedOut && !runAbortController.signal.aborted) await steeringQueueRef.current?.flushPending();
 	const retainLiveIncognitoThread = terminalState.turnSucceeded && isIncognitoSessionKey(params.sessionKey);
+	const retainedPersistentThread = terminalState.turnSucceeded && !isIncognitoSessionKey(params.sessionKey) && params.cleanupBundleMcpOnRunEnd !== true && !params.contextEngine && resourceState.thread.liveThreadConfigFingerprint !== void 0 && resourceState.thread.clientId === resolveCodexAppServerClientInstanceId(resourceState.client) && resourceState.thread.preserveNativeModel !== true && resourceState.thread.connectionScope !== "supervision" && !resourceState.thread.ringZeroConfigFingerprint && !resourceState.thread.contextEngine ? await retainCodexAppServerLiveThread(resourceState.client, resourceState.thread.threadId, async (previousThreadId) => {
+		if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
+			threadId: previousThreadId,
+			timeoutMs: 5e3
+		})) {
+			await closeCodexStartupClientBestEffort(resourceState.client);
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex retained thread subscription could not be released: ${previousThreadId}`);
+		}
+	}, resourceState.thread.liveThreadConfigFingerprint) : void 0;
+	const retainLiveThread = retainLiveIncognitoThread || retainedPersistentThread !== void 0;
 	const bindingReleased = isIncognitoSessionKey(params.sessionKey) && !retainLiveIncognitoThread ? await bindingStore.mutate(bindingIdentity, {
 		kind: "clear",
 		threadId: resourceState.thread.threadId
 	}) : true;
-	if (!state.timedOut && !retainLiveIncognitoThread) {
-		if (bindingReleased) await unsubscribeCodexThreadBestEffort(resourceState.client, {
-			threadId: resourceState.thread.threadId,
-			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
-		});
+	if (!state.timedOut && !retainLiveThread) {
+		if (bindingReleased) {
+			if (!await unsubscribeCodexThreadBestEffort(resourceState.client, {
+				threadId: resourceState.thread.threadId,
+				timeoutMs: 5e3
+			})) await closeCodexStartupClientBestEffort(resourceState.client);
+		}
 	}
 	userInputBridgeRef.current?.cancelPending();
 	turnWatches.clearAllTimers();
@@ -3230,14 +3465,7 @@ function estimateCodexAppServerProjectedTurnTokens(params) {
 }
 async function ensureCodexWorkspaceDirOnce(workspaceDir) {
 	const normalized = path.resolve(workspaceDir);
-	if (codexWorkspaceDirCache.has(normalized)) {
-		try {
-			if ((await fs.stat(normalized)).isDirectory()) return;
-		} catch (error) {
-			if ((typeof error === "object" && error ? error.code : void 0) !== "ENOENT") throw error;
-		}
-		codexWorkspaceDirCache.delete(normalized);
-	}
+	if (codexWorkspaceDirCache.has(normalized)) return;
 	await fs.mkdir(normalized, { recursive: true });
 	codexWorkspaceDirCache.add(normalized);
 }
@@ -3278,6 +3506,7 @@ const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
 const CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS = 2e4;
 const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_TOKENS = 8e3;
 const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_RATIO = .5;
+const CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES = 64 * 1024;
 const CODEX_APP_SERVER_BYTE_UNITS = {
 	b: 1,
 	k: 1024,
@@ -3306,7 +3535,7 @@ function parseCodexAppServerByteLimit(value) {
 	if (multiplier === void 0) return;
 	return Math.max(1, Math.round(amount * multiplier));
 }
-async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codexHome) {
+async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codexHome, rolloutPath) {
 	const resolvedAgentDir = path.resolve(agentDir);
 	const resolvedCodexHome = codexHome?.trim() ? path.resolve(codexHome) : resolveCodexAppServerHomeDir(resolvedAgentDir);
 	const roots = [
@@ -3315,6 +3544,22 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 		path.join(resolvedAgentDir, "agent", "codex-home", "sessions"),
 		path.join(path.dirname(resolvedAgentDir), "codex-home", "sessions")
 	];
+	const rolloutRoot = rolloutPath ? roots.find((root) => {
+		const relativePath = path.relative(root, rolloutPath);
+		return relativePath !== "" && relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
+	}) : void 0;
+	if (rolloutPath && rolloutRoot && path.isAbsolute(rolloutPath) && path.extname(rolloutPath) === ".jsonl" && path.basename(rolloutPath).includes(threadId)) try {
+		const opened = await (await root(rolloutRoot, {
+			hardlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER,
+			symlinks: "reject"
+		})).open(path.relative(rolloutRoot, rolloutPath));
+		return [{
+			path: opened.realPath,
+			bytes: opened.stat.size,
+			handle: opened.handle
+		}];
+	} catch {}
 	const files = [];
 	const visited = /* @__PURE__ */ new Set();
 	for (const root of roots) {
@@ -3393,23 +3638,48 @@ async function readCodexSessionRecordForSessionFile(sessionFile) {
 function isSqliteSessionFileMarker(sessionFile) {
 	return parseSqliteSessionFileMarker(sessionFile) !== void 0;
 }
-async function readCodexAppServerRolloutTokenSnapshot(file) {
-	let handle;
-	try {
+async function readCodexAppServerRolloutTokenSnapshot(file, openedHandle) {
+	let handle = openedHandle;
+	if (!handle) try {
 		handle = await fs.open(file, "r");
 	} catch {
 		return;
 	}
 	let snapshot;
 	try {
-		for await (const line of handle.readLines()) {
+		let position = (await handle.stat()).size;
+		const partialLineFragments = [];
+		const applySnapshotLine = (line) => {
 			const lineSnapshot = readCodexAppServerRolloutTokenSnapshotLine(line);
-			if (lineSnapshot !== void 0) {
-				snapshot ??= {};
-				if (lineSnapshot.totalTokens !== void 0) snapshot.totalTokens = lineSnapshot.totalTokens;
-				if (lineSnapshot.modelContextWindow !== void 0) snapshot.modelContextWindow = lineSnapshot.modelContextWindow;
+			if (lineSnapshot === void 0) return false;
+			snapshot ??= {};
+			snapshot.totalTokens ??= lineSnapshot.totalTokens;
+			snapshot.modelContextWindow ??= lineSnapshot.modelContextWindow;
+			return snapshot.totalTokens !== void 0 && snapshot.modelContextWindow !== void 0;
+		};
+		while (position > 0) {
+			const bytesToRead = Math.min(position, CODEX_APP_SERVER_ROLLOUT_TAIL_READ_BYTES);
+			const nextPosition = position - bytesToRead;
+			const chunk = Buffer.allocUnsafe(bytesToRead);
+			let bytesRead = 0;
+			while (bytesRead < bytesToRead) {
+				const result = await handle.read(chunk, bytesRead, bytesToRead - bytesRead, nextPosition + bytesRead);
+				if (result.bytesRead === 0) return snapshot;
+				bytesRead += result.bytesRead;
+			}
+			let lineEnd = bytesRead;
+			for (let index = bytesRead - 1; index >= 0; index -= 1) {
+				if (chunk[index] !== 10) continue;
+				const lineFragment = chunk.subarray(index + 1, lineEnd);
+				const line = partialLineFragments.length === 0 ? lineFragment.toString("utf8") : Buffer.concat([lineFragment, ...partialLineFragments.toReversed()]).toString("utf8");
+				partialLineFragments.length = 0;
+				if (applySnapshotLine(line)) return snapshot;
+				lineEnd = index;
 			}
+			if (lineEnd > 0) partialLineFragments.push(chunk.subarray(0, lineEnd));
+			position = nextPosition;
 		}
+		if (partialLineFragments.length > 0) applySnapshotLine(Buffer.concat(partialLineFragments.toReversed()).toString("utf8"));
 	} finally {
 		await handle.close();
 	}
@@ -3467,31 +3737,36 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 	if (!binding?.threadId) return binding;
 	if (binding.connectionScope === "supervision") return binding;
 	const sessionRecord = await readCodexSessionRecordForSessionFile(params.sessionFile);
-	const rolloutFiles = await listCodexAppServerRolloutFilesForThread(params.agentDir, binding.threadId, params.codexHome);
-	const compaction = readCompactionConfig(params.config);
-	const shouldDeferByteGuard = compaction?.truncateAfterCompaction === true && params.contextEngineActive === true && hasContextEngineThreadBootstrapProjection(binding);
-	if (compaction?.truncateAfterCompaction === true && !shouldDeferByteGuard) {
-		const maxBytes = parseCodexAppServerByteLimit(compaction.maxActiveTranscriptBytes);
-		if (maxBytes !== void 0) {
-			const oversizedFiles = rolloutFiles.filter((file) => file.bytes >= maxBytes);
-			if (oversizedFiles.length > 0) {
-				embeddedAgentLog.warn("codex app-server native transcript exceeded active byte limit; starting a fresh thread", {
-					threadId: binding.threadId,
-					maxBytes,
-					files: oversizedFiles.map((file) => ({
-						path: file.path,
-						bytes: file.bytes
-					}))
-				});
-				await params.bindingStore.mutate(params.identity, {
-					kind: "clear",
-					threadId: binding.threadId
-				});
-				return;
-			}
+	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", {
+		threadId: binding.threadId,
+		engineId: binding.contextEngine?.engineId,
+		epoch: binding.contextEngine?.projection?.epoch,
+		fingerprint: binding.contextEngine?.projection?.fingerprint
+	});
+	else if (maxBytes !== void 0) {
+		const oversizedFiles = rolloutFiles.filter((file) => file.bytes >= maxBytes);
+		if (oversizedFiles.length > 0) {
+			await Promise.all(rolloutFiles.map(async (file) => {
+				await file.handle?.close();
+			}));
+			embeddedAgentLog.warn("codex app-server native transcript exceeded active byte limit; starting a fresh thread", {
+				threadId: binding.threadId,
+				maxBytes,
+				files: oversizedFiles.map((file) => ({
+					path: file.path,
+					bytes: file.bytes
+				}))
+			});
+			await params.bindingStore.mutate(params.identity, {
+				kind: "clear",
+				threadId: binding.threadId
+			});
+			return;
 		}
 	}
-	const nativeTokenSnapshots = await Promise.all(rolloutFiles.map(async (file) => readCodexAppServerRolloutTokenSnapshot(file.path)));
+	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 sessionModelContextWindow = typeof sessionRecord?.contextTokens === "number" && Number.isFinite(sessionRecord.contextTokens) && sessionRecord.contextTokens > 0 ? Math.floor(sessionRecord.contextTokens) : void 0;
@@ -3521,16 +3796,6 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 		});
 		return;
 	}
-	if (compaction?.truncateAfterCompaction !== true) return binding;
-	if (shouldDeferByteGuard) {
-		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,
-			fingerprint: binding.contextEngine?.projection?.fingerprint
-		});
-		return binding;
-	}
 	return binding;
 }
 //#endregion
@@ -3584,22 +3849,45 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		agentId: sessionAgentId
 	});
 	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
-	const bindingIdentity = sessionBindingIdentity({
+	let bindingIdentity = sessionBindingIdentity({
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
 		agentId: params.agentId,
 		config: params.config
 	});
-	const bindingStore = options.bindingStore;
+	let bindingStore = options.bindingStore;
 	preDynamicStartupStages.mark("session-agent");
 	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 && (params.sessionTarget?.storePath || params.config?.session?.store)) {
+		const authority = resolveCodexRunSessionBindingAuthority({
+			identity: bindingIdentity,
+			config: params.config,
+			storePath: params.sessionTarget?.storePath
+		});
+		if (authority === "superseded") throw createCodexSessionGenerationSupersededError(bindingIdentity.sessionId);
+		if (authority === "ephemeral") {
+			const logicalIdentity = bindingIdentity;
+			const physicalIdentity = {
+				kind: "session",
+				agentId: bindingIdentity.agentId,
+				sessionId: bindingIdentity.sessionId
+			};
+			bindingStore = scopeCodexRunBindingStore({
+				bindingStore,
+				logicalIdentity,
+				physicalIdentity
+			});
+			bindingIdentity = physicalIdentity;
+		}
+	}
 	let startupBinding = await bindingStore.read(bindingIdentity);
 	if (!startupBinding && bindingIdentity.kind === "session" && bindingIdentity.sessionKey) {
 		if (!await reclaimCurrentCodexSessionGeneration({
 			bindingStore,
 			identity: bindingIdentity,
-			config: params.config
+			config: params.config,
+			storePath: params.sessionTarget?.storePath
 		})) throw createCodexSessionGenerationSupersededError(bindingIdentity.sessionId);
 		startupBinding = await bindingStore.read(bindingIdentity);
 	}
@@ -3643,7 +3931,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		authProfileId: resolvedStartupAuthProfileId,
 		authProfileStore: params.authProfileStore,
 		agentDir,
-		...pluginConfig.appServer?.homeScope ? { homeScope: pluginConfig.appServer.homeScope } : {},
+		homeScope: resolveCodexAppServerHomeScope({ appServer: pluginConfig.appServer }),
 		config: params.config,
 		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a forwarded OpenAI OAuth or token profile.",
 		subscriptionProfileUnusableError: "Prepared Codex subscription auth profile is unusable."
@@ -3669,15 +3957,16 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const requestedCwd = params.cwd ? resolveUserPath(params.cwd) : void 0;
 	if (sandbox?.enabled && requestedCwd && requestedCwd !== resolvedWorkspace) throw new Error("cwd override is not supported for sandboxed Codex app-server runs; omit cwd or use the agent workspace as cwd");
 	const effectiveCwd = sandbox?.enabled ? effectiveWorkspace : requestedCwd ?? effectiveWorkspace;
-	await ensureCodexWorkspaceDirOnce(effectiveWorkspace);
+	if (effectiveWorkspace !== resolvedWorkspace) await ensureCodexWorkspaceDirOnce(effectiveWorkspace);
 	preDynamicStartupStages.mark("effective-workspace");
+	const shouldPromoteApprovalPolicy = beforeToolCallPolicy.hasBeforeToolCallHook || beforeToolCallPolicy.trustedToolPolicies.length > 0;
 	const resolvePolicyAppServer = () => resolveCodexAppServerForOpenClawToolPolicy({
 		appServer: configuredAppServer,
 		pluginConfig,
 		env: process.env,
-		shouldPromote: beforeToolCallPolicy.hasBeforeToolCallHook || beforeToolCallPolicy.trustedToolPolicies.length > 0,
+		shouldPromote: shouldPromoteApprovalPolicy,
 		execPolicy,
-		canUseUntrustedApprovalPolicy: configuredAppServer.start.transport !== "stdio" || isCodexAppServerApprovalPolicyAllowedByRequirements("untrusted")
+		canUseUntrustedApprovalPolicy: shouldPromoteApprovalPolicy && configuredAppServer.approvalPolicy === "never" && (configuredAppServer.start.transport !== "stdio" || isCodexAppServerApprovalPolicyAllowedByRequirements("untrusted"))
 	});
 	let policyAppServer = resolvePolicyAppServer();
 	let appServer = resolveCodexAppServerForModelProvider({
@@ -3688,7 +3977,8 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		env: process.env,
 		agentDir
 	});
-	if (configuredAppServer.approvalPolicy === "never" && appServer.approvalPolicy === "untrusted") embeddedAgentLog.info("codex app-server approval policy promoted for OpenClaw tool policy", {
+	let approvalPolicyPromotedForOpenClawToolPolicy = configuredAppServer.approvalPolicy === "never" && appServer.approvalPolicy === "untrusted";
+	if (approvalPolicyPromotedForOpenClawToolPolicy) embeddedAgentLog.info("codex app-server approval policy promoted for OpenClaw tool policy", {
 		from: "never",
 		to: "untrusted",
 		beforeToolCallHook: beforeToolCallPolicy.hasBeforeToolCallHook,
@@ -3725,6 +4015,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	};
 	if (params.abortSignal?.aborted) abortFromUpstream();
 	else params.abortSignal?.addEventListener("abort", abortFromUpstream, { once: true });
+	const startupBindingBeforeRotation = startupBinding;
 	startupBinding = await rotateOversizedCodexAppServerStartupBinding({
 		binding: startupBinding,
 		bindingStore,
@@ -3737,20 +4028,23 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	});
 	const initialInactiveThreadBootstrapBindingForcedFreshStart = initialStartupBindingHadInactiveThreadBootstrap && !startupBinding?.threadId;
 	preDynamicStartupStages.mark("rotate-binding");
-	reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
-	configuredAppServer = resolveRuntimeOptionsForBinding({
-		modelProvider: reviewerPolicyContext.modelProvider,
-		model: reviewerPolicyContext.model
-	});
-	policyAppServer = resolvePolicyAppServer();
-	appServer = resolveCodexAppServerForModelProvider({
-		appServer: policyAppServer,
-		provider: reviewerPolicyContext.modelProvider,
-		model: reviewerPolicyContext.model,
-		config: params.config,
-		env: process.env,
-		agentDir
-	});
+	if (startupBinding !== startupBindingBeforeRotation) {
+		reviewerPolicyContext = resolveReviewerPolicyContext(startupBinding);
+		configuredAppServer = resolveRuntimeOptionsForBinding({
+			modelProvider: reviewerPolicyContext.modelProvider,
+			model: reviewerPolicyContext.model
+		});
+		policyAppServer = resolvePolicyAppServer();
+		appServer = resolveCodexAppServerForModelProvider({
+			appServer: policyAppServer,
+			provider: reviewerPolicyContext.modelProvider,
+			model: reviewerPolicyContext.model,
+			config: params.config,
+			env: process.env,
+			agentDir
+		});
+		approvalPolicyPromotedForOpenClawToolPolicy = configuredAppServer.approvalPolicy === "never" && appServer.approvalPolicy === "untrusted";
+	}
 	const nativeHookRelayEvents = resolveCodexNativeHookRelayEvents({
 		configuredEvents: options.nativeHookRelay?.events,
 		appServer
@@ -3806,6 +4100,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		effectiveWorkspace,
 		effectiveCwd,
 		appServer,
+		approvalPolicyPromotedForOpenClawToolPolicy,
 		nativeHookRelayEvents,
 		runAbortController,
 		terminalState,
@@ -4133,7 +4428,7 @@ function buildCodexOpenClawPromptContext(params) {
 		"## OpenClaw Workspace Context",
 		"",
 		params.workspacePromptContext.trim()
-	].join("\n") : void 0].filter(isNonEmptyString$1);
+	].join("\n") : void 0, params.watchedSessionsContext?.trim() || void 0].filter(isNonEmptyString$1);
 	if (sections.length === 0) return;
 	return [
 		"OpenClaw runtime context for this turn:",
@@ -4142,6 +4437,21 @@ function buildCodexOpenClawPromptContext(params) {
 		...sections
 	].join("\n");
 }
+/**
+* Renders the watched-sessions block for the Codex per-turn runtime context.
+* Codex builds its own instruction layers, so the embedded prompt's Watched
+* Sessions section must be re-surfaced here or Codex-backed main sessions
+* keep refusing cross-session questions (openclaw#114797).
+*/
+function buildCodexWatchedSessionsContext(params) {
+	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
+	return buildWatchedSessionsHarnessContext({
+		config: params.attempt.config,
+		sessionKey: params.sessionKey,
+		sandboxed: params.sandboxed,
+		toolNames: flattenCodexDynamicToolFunctions(params.dynamicTools).map((tool) => normalizeCodexDynamicToolName(tool.name))
+	});
+}
 function shouldInjectCodexOpenClawPromptContext(params) {
 	return !(params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron");
 }
@@ -4475,7 +4785,13 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		baseDeveloperInstructions,
 		openClawPromptContext: buildCodexOpenClawPromptContext({
 			params: runtimeParams,
-			workspacePromptContext: workspaceBootstrapContext.promptContext
+			workspacePromptContext: workspaceBootstrapContext.promptContext,
+			watchedSessionsContext: buildCodexWatchedSessionsContext({
+				attempt: runtimeParams,
+				dynamicTools: toolBridge.availableSpecs,
+				sessionKey: contextSessionKey,
+				sandboxed: sandbox?.enabled === true
+			})
 		}),
 		skillsCollaborationInstructions: renderCodexSkillsCollaborationInstructions({
 			attempt: runtimeParams,
@@ -4928,14 +5244,6 @@ function createCodexHostTrajectorySink(params) {
 /** Creates a trajectory recorder when trajectory capture is enabled for the environment. */
 function createCodexTrajectoryRecorder(params) {
 	if (!parseTrajectoryEnabled(params.env ?? process.env)) return null;
-	const sqliteMarker = parseSqliteSessionFileMarker(params.trajectorySessionFile ?? params.attempt.sessionFile);
-	if (!sqliteMarker || sqliteMarker.sessionId !== params.attempt.sessionId) {
-		params.warn?.("codex trajectory capture requires a matching SQLite session target", {
-			sessionId: params.attempt.sessionId,
-			reason: sqliteMarker ? "session-id-mismatch" : "non-sqlite-session-target"
-		});
-		return null;
-	}
 	if (!params.trajectoryRecorder) {
 		params.warn?.("codex trajectory capture requires the SQLite host recorder", {
 			sessionId: params.attempt.sessionId,
@@ -5265,7 +5573,29 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 			...finalPromptError ? { error: formatErrorMessage(finalPromptError) } : {},
 			durationMs: Date.now() - attemptStartedAt
 		},
-		ctx: hookContext,
+		ctx: {
+			...hookContext,
+			modelProviderId: resourceState.thread.modelProvider ?? effectiveRuntimeProviderId,
+			modelId: resourceState.thread.model ?? effectiveRuntimeModelId,
+			authProfileId: resourceState.thread.authProfileId ?? startupAuthProfileId,
+			modelIterations: result.modelIterations ?? 0,
+			skillWorkshopAvailable: flattenCodexDynamicToolFunctions(attemptTools.toolBridge.availableSpecs).some((tool) => tool.name === "skill_workshop"),
+			compacted: (result.compactionCount ?? 0) > 0,
+			messageChannel: params.messageChannel,
+			messageProvider: params.messageProvider,
+			chatType: params.chatType,
+			agentAccountId: params.agentAccountId,
+			groupId: params.groupId,
+			groupChannel: params.groupChannel,
+			groupSpace: params.groupSpace,
+			memberRoleIds: params.memberRoleIds,
+			spawnedBy: params.spawnedBy,
+			senderId: params.senderId ?? void 0,
+			senderName: params.senderName,
+			senderUsername: params.senderUsername,
+			senderE164: params.senderE164,
+			senderIsOwner: params.senderIsOwner
+		},
 		hookRunner
 	});
 	state.shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
@@ -6154,6 +6484,9 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-prompt.ts
+function isRestrictivePromptToolsAllow(toolsAllow) {
+	return toolsAllow !== void 0 && !toolsAllow.some((name) => name.trim() === "*");
+}
 async function prepareCodexAttemptPrompt(context) {
 	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, baseDeveloperInstructions, openClawPromptContext, skillsCollaborationInstructions, promptState, codexContextProjectionMaxChars } = context;
 	const { connection, buildActiveRunAttemptParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
@@ -6239,13 +6572,17 @@ async function prepareCodexAttemptPrompt(context) {
 		embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 	}
 	const codexModelInputHistoryMessages = [];
-	const buildPromptFromCurrentInputs = () => resolveAgentHarnessBeforePromptBuildResult({
-		prompt: prependCurrentInboundContext(promptState.promptText, params.currentInboundContext),
-		developerInstructions: promptState.developerInstructions,
-		messages: structuredClone(historyState.messages),
-		ctx: hookContext,
-		bootstrapContextRunKind: params.bootstrapContextRunKind
-	});
+	const buildPromptFromCurrentInputs = async () => {
+		const result = await resolveAgentHarnessBeforePromptBuildResult({
+			prompt: prependCurrentInboundContext(promptState.promptText, params.currentInboundContext),
+			developerInstructions: promptState.developerInstructions,
+			messages: structuredClone(historyState.messages),
+			ctx: hookContext,
+			bootstrapContextRunKind: params.bootstrapContextRunKind
+		});
+		if (isRestrictivePromptToolsAllow(result.toolsAllow)) throw new Error("Codex app-server cannot enforce before_prompt_build toolsAllow; use the embedded or Copilot runtime for turn-scoped tool policy.");
+		return result;
+	};
 	const resolveShiftedPromptInputRange = (prompt, promptInputRange, turnPromptText) => {
 		if (!promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !turnPromptText.endsWith(prompt)) return;
 		const turnPromptOffset = turnPromptText.length - prompt.length;
@@ -7914,8 +8251,10 @@ const sandboxExecServerRegistry = {
 };
 //#endregion
 //#region extensions/codex/src/app-server/sandbox-exec-server/json-rpc.ts
-/** JSON-RPC error code used when a sandbox exec-server method is unknown. */
+/** JSON-RPC error code used when a sandbox filesystem resource does not exist. */
 const JSON_RPC_NOT_FOUND = -32004;
+/** JSON-RPC error code used when a sandbox exec-server method is unsupported. */
+const JSON_RPC_METHOD_NOT_FOUND = -32601;
 /** Protocol-level error carrying the JSON-RPC error code to send to the client. */
 var JsonRpcProtocolError = class extends Error {
 	constructor(code, message) {
@@ -8247,6 +8586,101 @@ function requireFsBridge(execServer) {
 * with OpenClaw sandbox policy checks before every bridge operation.
 */
 const CODEX_SANDBOX_EXEC_SERVER_MAX_READ_FILE_BYTES = 512 * 1024 * 1024;
+const CODEX_SANDBOX_EXEC_SERVER_MAX_OPEN_FILE_READS = 128;
+const CODEX_SANDBOX_EXEC_SERVER_MAX_BUFFERED_FILE_READ_BYTES = 64 * 1024 * 1024;
+const CODEX_SANDBOX_EXEC_SERVER_MAX_READ_BLOCK_BYTES = 1024 * 1024;
+const CODEX_SANDBOX_EXEC_SERVER_MAX_FILE_READ_HANDLE_ID_BYTES = 32;
+/** Opens a policy-checked sandbox file under a bounded, connection-owned handle. */
+async function openFile(execServer, handles, params) {
+	const record = requireObject(params, "fs/open params");
+	const handleId = requireFileReadHandleId(record.handleId);
+	if (handles.closed) throw new JsonRpcProtocolError(JSON_RPC_NOT_FOUND, `unknown file read handle \`${handleId}\``);
+	if (handles.has(handleId)) throw new JsonRpcProtocolError(-32600, `file read handle \`${handleId}\` already exists`);
+	if (handles.size >= CODEX_SANDBOX_EXEC_SERVER_MAX_OPEN_FILE_READS) throw new JsonRpcProtocolError(-32600, `at most ${CODEX_SANDBOX_EXEC_SERVER_MAX_OPEN_FILE_READS} file reads may be open per connection`);
+	const filePath = resolveExecServerPath(requireString(record.path, "path"), "read path");
+	assertFsSandboxAccess(execServer, record, [{
+		path: filePath,
+		access: "read"
+	}]);
+	const fsBridge = requireFsBridge(execServer);
+	const handle = {
+		abortController: new AbortController(),
+		closeRequested: false,
+		reservedBytes: 0
+	};
+	handles.set(handleId, handle);
+	try {
+		const stat = await fsBridge.stat({
+			filePath,
+			signal: handle.abortController.signal
+		});
+		if (handles.get(handleId) !== handle || handle.closeRequested || handles.closed) throw new JsonRpcProtocolError(JSON_RPC_NOT_FOUND, `unknown file read handle \`${handleId}\``);
+		if (!stat) throw new JsonRpcProtocolError(JSON_RPC_NOT_FOUND, "file not found");
+		if (stat.type !== "file") throw new JsonRpcProtocolError(-32600, "file read handle requires a regular file");
+		if (!Number.isSafeInteger(stat.size) || stat.size < 0) throw new JsonRpcProtocolError(-32600, "file size must be a non-negative safe integer");
+		if (stat.size > CODEX_SANDBOX_EXEC_SERVER_MAX_BUFFERED_FILE_READ_BYTES - bufferedFileReadBytes(handles)) throw new JsonRpcProtocolError(-32600, "sandbox file read exceeds the per-connection buffered file limit");
+		handle.reservedBytes = stat.size;
+		const data = await fsBridge.readFile({
+			filePath,
+			maxBytes: handle.reservedBytes,
+			signal: handle.abortController.signal
+		});
+		if (handles.get(handleId) !== handle || handle.closeRequested || handles.closed) throw new JsonRpcProtocolError(JSON_RPC_NOT_FOUND, `unknown file read handle \`${handleId}\``);
+		if (data.byteLength > handle.reservedBytes) throw new JsonRpcProtocolError(-32600, "sandbox file read exceeds the per-connection buffered file limit");
+		handle.reservedBytes = data.byteLength;
+		handle.data = data;
+		return { handleId };
+	} catch (error) {
+		if (handles.get(handleId) === handle) handles.delete(handleId);
+		throw error;
+	}
+}
+/** Reads a bounded base64 block from a handle belonging to this connection. */
+function readFileBlock(handles, params) {
+	const record = requireObject(params, "fs/readBlock params");
+	const handleId = requireFileReadHandleId(record.handleId);
+	const handle = handles.get(handleId);
+	if (!handle?.data) throw new JsonRpcProtocolError(JSON_RPC_NOT_FOUND, `unknown file read handle \`${handleId}\``);
+	const offset = requireNumber(record.offset, "offset");
+	const length = requireNumber(record.len, "len");
+	if (!Number.isSafeInteger(offset) || offset < 0) throw new JsonRpcProtocolError(-32600, "file read offset must be a non-negative safe integer");
+	if (!Number.isSafeInteger(length) || length < 1 || length > CODEX_SANDBOX_EXEC_SERVER_MAX_READ_BLOCK_BYTES) throw new JsonRpcProtocolError(-32600, `file read block length must be between 1 and ${CODEX_SANDBOX_EXEC_SERVER_MAX_READ_BLOCK_BYTES}`);
+	const chunk = handle.data.subarray(offset, Math.min(offset + length, handle.data.byteLength));
+	return {
+		chunk: chunk.toString("base64"),
+		eof: offset + chunk.byteLength >= handle.data.byteLength
+	};
+}
+/** Closes one connection-owned file handle; repeated closes are harmless. */
+function closeFile(handles, params) {
+	closeFileReadHandle(handles, requireFileReadHandleId(requireObject(params, "fs/close params").handleId));
+	return {};
+}
+/** Cancels a disconnected socket without releasing unsettled read reservations. */
+function closeAllFileReads(handles) {
+	handles.closed = true;
+	for (const handleId of handles.keys()) closeFileReadHandle(handles, handleId);
+}
+function closeFileReadHandle(handles, handleId) {
+	const handle = handles.get(handleId);
+	if (!handle) return;
+	handle.closeRequested = true;
+	if (handle.data !== void 0) {
+		handles.delete(handleId);
+		return;
+	}
+	handle.abortController.abort();
+}
+function bufferedFileReadBytes(handles) {
+	let total = 0;
+	for (const handle of handles.values()) total += handle.reservedBytes;
+	return total;
+}
+function requireFileReadHandleId(value) {
+	const handleId = requireString(value, "handleId");
+	if (Buffer.byteLength(handleId, "utf8") > CODEX_SANDBOX_EXEC_SERVER_MAX_FILE_READ_HANDLE_ID_BYTES) throw new JsonRpcProtocolError(-32600, `file read handle ID must not exceed ${CODEX_SANDBOX_EXEC_SERVER_MAX_FILE_READ_HANDLE_ID_BYTES} bytes`);
+	return handleId;
+}
 /** Reads a sandbox file as base64 after read-policy and size checks. */
 async function readFile(execServer, params) {
 	const record = requireObject(params, "fs/readFile params");
@@ -8259,7 +8693,10 @@ async function readFile(execServer, params) {
 	const stat = await fsBridge.stat({ filePath });
 	if (!stat) throw new JsonRpcProtocolError(JSON_RPC_NOT_FOUND, "file not found");
 	assertSandboxFileReadWithinLimit(stat);
-	return { dataBase64: (await fsBridge.readFile({ filePath })).toString("base64") };
+	return { dataBase64: (await fsBridge.readFile({
+		filePath,
+		maxBytes: CODEX_SANDBOX_EXEC_SERVER_MAX_READ_FILE_BYTES
+	})).toString("base64") };
 }
 /** Writes base64 data to an existing sandbox directory after write-policy checks. */
 async function writeFile(execServer, params) {
@@ -8408,7 +8845,10 @@ async function copySandboxPath(execServer, params) {
 		return;
 	}
 	assertSandboxFileReadWithinLimit(sourceStat);
-	const data = await fsBridge.readFile({ filePath: params.sourcePath });
+	const data = await fsBridge.readFile({
+		filePath: params.sourcePath,
+		maxBytes: CODEX_SANDBOX_EXEC_SERVER_MAX_READ_FILE_BYTES
+	});
 	await fsBridge.writeFile({
 		filePath: params.destinationPath,
 		data,
@@ -8423,6 +8863,7 @@ function metadataResponse(stat) {
 		isDirectory: stat?.type === "directory",
 		isFile: stat?.type === "file",
 		isSymlink: false,
+		size: stat?.size ?? 0,
 		createdAtMs: 0,
 		modifiedAtMs: stat?.mtimeMs ?? 0
 	};
@@ -9284,19 +9725,21 @@ function isAuthorizedExecServerRequest(execServer, request) {
 }
 function handleConnection(execServer, socket) {
 	const processes = /* @__PURE__ */ new Map();
+	const fileReads = /* @__PURE__ */ new Map();
 	socket.on("message", (data) => {
-		handleMessage(execServer, processes, socket, data).catch((error) => {
+		handleMessage(execServer, processes, fileReads, socket, data).catch((error) => {
 			embeddedAgentLog.warn("codex sandbox exec-server message failed", { error });
 		});
 	});
 	socket.on("close", () => {
+		closeAllFileReads(fileReads);
 		for (const process of processes.values()) process.abortController.abort();
 	});
 }
 function handleExecServerSocketError(error) {
 	embeddedAgentLog.debug("codex sandbox exec-server websocket failed", { error });
 }
-async function handleMessage(execServer, processes, socket, data) {
+async function handleMessage(execServer, processes, fileReads, socket, data) {
 	const request = parseRequest(data);
 	if (!request.method) {
 		sendError(socket, request.id, -32600, "Invalid Request");
@@ -9308,7 +9751,7 @@ async function handleMessage(execServer, processes, socket, data) {
 		return;
 	}
 	try {
-		const result = await dispatchRequest(execServer, processes, socket, {
+		const result = await dispatchRequest(execServer, processes, fileReads, socket, {
 			...request,
 			method
 		});
@@ -9317,13 +9760,25 @@ async function handleMessage(execServer, processes, socket, data) {
 		sendError(socket, request.id, error instanceof JsonRpcProtocolError ? error.code : -32603, error instanceof Error ? error.message : String(error));
 	}
 }
-async function dispatchRequest(execServer, processes, socket, request) {
+async function dispatchRequest(execServer, processes, fileReads, socket, request) {
 	switch (request.method) {
 		case "initialize": return { sessionId: randomUUID() };
+		case "environment/info": return {
+			shell: {
+				name: "sh",
+				path: "/bin/sh"
+			},
+			cwd: pathToFileURL(execServer.sandbox.containerWorkdir, { windows: false }).href,
+			capabilities: { networkProxyLaunch: false }
+		};
+		case "environment/status": return { status: "ready" };
 		case "process/start": return startProcess(execServer, processes, socket, request.params);
 		case "process/read": return await readProcess(processes, request.params);
 		case "process/write": return writeProcess(processes, request.params);
 		case "process/terminate": return terminateProcess(processes, request.params);
+		case "fs/open": return await openFile(execServer, fileReads, request.params);
+		case "fs/readBlock": return readFileBlock(fileReads, request.params);
+		case "fs/close": return closeFile(fileReads, request.params);
 		case "fs/readFile": return await readFile(execServer, request.params);
 		case "fs/writeFile":
 			await writeFile(execServer, request.params);
@@ -9340,7 +9795,7 @@ async function dispatchRequest(execServer, processes, socket, request) {
 			await copyPath(execServer, request.params);
 			return {};
 		case "http/request": return await httpRequest(execServer, socket, request.params);
-		default: throw new Error(`Unsupported OpenClaw sandbox exec-server method: ${request.method}`);
+		default: throw new JsonRpcProtocolError(JSON_RPC_METHOD_NOT_FOUND, `Unsupported OpenClaw sandbox exec-server method: ${request.method}`);
 	}
 }
 //#endregion
@@ -9358,7 +9813,6 @@ function prepareCodexAttemptResources(prompt) {
 		developerInstructions: buildRenderedCodexDeveloperInstructions(),
 		prompt: turnState.codexTurnPromptText,
 		trajectoryRecorder: hostTrajectoryRecorder,
-		trajectorySessionFile: params.trajectorySessionFile,
 		tools: toolBridge.availableSpecs,
 		warn: (message, fields) => embeddedAgentLog.warn(message, fields)
 	});
@@ -9468,14 +9922,7 @@ function prepareCodexAttemptResources(prompt) {
 		timeoutFloorMs: options.startupTimeoutFloorMs
 	});
 	const requesterChannel = params.messageChannel ?? params.messageProvider;
-	const requester = {
-		...requesterChannel ? { channel: requesterChannel } : {},
-		...params.agentAccountId ? { accountId: params.agentAccountId } : {},
-		...params.senderId ? { senderId: params.senderId } : {},
-		...params.senderIsOwner !== void 0 ? { senderIsOwner: params.senderIsOwner } : {},
-		...params.memberRoleIds?.length ? { roleIds: [...params.memberRoleIds] } : {}
-	};
-	const hasRequester = Object.keys(requester).length > 0;
+	const requester = buildCodexHookRequester(params);
 	const buildNativeHookRelayFinalConfigPatch = (decision) => {
 		state.nativeHookRelay?.unregister();
 		state.nativeHookRelay = createCodexNativeHookRelay({
@@ -9489,7 +9936,15 @@ function prepareCodexAttemptResources(prompt) {
 			config: params.config,
 			runId: params.runId,
 			channelId: hookChannelId,
-			...hasRequester ? { requester } : {},
+			...requester ? { requester } : {},
+			approvalContext: {
+				trigger: params.trigger,
+				approvalReviewerDeviceId: params.approvalReviewerDeviceId,
+				turnSourceChannel: requesterChannel,
+				turnSourceTo: params.currentMessagingTarget ?? params.currentChannelId,
+				turnSourceAccountId: params.agentAccountId,
+				turnSourceThreadId: params.currentThreadTs
+			},
 			attemptTimeoutMs: params.timeoutMs,
 			startupTimeoutMs,
 			turnStartTimeoutMs: params.timeoutMs,
@@ -9663,6 +10118,7 @@ async function prepareCodexAttemptRuntime(connection) {
 		modelId: effectiveRuntimeModelId,
 		model: supervisedRuntimeModel,
 		thinkLevel: _outerThinkLevel,
+		fastMode: _outerFastMode,
 		sessionKey: contextSessionKey
 	} : {
 		...params,
@@ -9690,7 +10146,8 @@ async function prepareCodexAttemptRuntime(connection) {
 		cfg: params.config,
 		toolsEnabled: usesSupervisionConnection || supportsModelTools(params.model),
 		disableTools: params.disableTools,
-		toolsAllow: params.toolsAllow
+		toolsAllow: params.toolsAllow,
+		toolOverrides: params.toolOverrides
 	});
 	preDynamicStartupStages.mark("bundle-mcp");
 	const sandboxExecServerEnabled = isCodexSandboxExecServerEnabled(pluginConfig);
@@ -9842,6 +10299,7 @@ function handleApprovalRequest(params) {
 		turnId: params.turnId,
 		nativeHookRelay: params.nativeHookRelay,
 		autoApprove: params.autoApprove,
+		autoApproveOpenClawToolPolicy: params.autoApproveOpenClawToolPolicy,
 		signal: params.signal,
 		onNativeToolFailureDisposition: params.onNativeToolFailureDisposition
 	});
@@ -9859,7 +10317,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 	const { context } = prompt;
 	const { runtime, attemptTools } = context;
 	const { connection } = runtime;
-	const { params, computerUseConfig, runAbortController, appServer, sessionAgentId } = connection;
+	const { params, computerUseConfig, runAbortController, appServer, approvalPolicyPromotedForOpenClawToolPolicy, sessionAgentId } = connection;
 	const { toolBridge, toolOutcomeOrdinals, suppressedDynamicToolOutcomeOrdinals, allocateCodexToolOutcomeOrdinal } = attemptTools;
 	const { state, turnIdRef, userInputBridgeRef, openClawDynamicToolExecutions, pendingOpenClawDynamicToolCompletionIds, postToolRawAssistantCompletionIdleTimeoutMs, turnWatches } = turnRuntime;
 	const { emitExecutionPhaseOnce, scheduleTurnReleaseAfterTerminalDynamicTool, scheduleTerminalDynamicToolReleaseCheck } = lifecycle;
@@ -9917,6 +10375,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						turnId,
 						nativeHookRelay: resourceState.nativeHookRelay,
 						autoApprove: shouldAutoApproveCodexAppServerApprovals(appServer),
+						autoApproveOpenClawToolPolicy: approvalPolicyPromotedForOpenClawToolPolicy,
 						signal,
 						onNativeToolFailureDisposition: (itemId, disposition) => projector?.recordNativeToolApprovalFailure(itemId, disposition)
 					});
@@ -10218,8 +10677,8 @@ var CodexPluginMetadataCache = class {
 		this.clearGeneration = 0;
 	}
 	/** Returns a fresh cached snapshot without issuing a request. */
-	read(appCacheKey, queryKind) {
-		const entryKey = buildMetadataCacheEntryKey(appCacheKey, queryKind);
+	read(appCacheKey, queryKind, requestParams) {
+		const entryKey = buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams);
 		const entry = this.entries.get(entryKey);
 		if (!entry) return;
 		if (entry.expiresAtMs <= this.nowMs()) {
@@ -10228,10 +10687,10 @@ var CodexPluginMetadataCache = class {
 		}
 		return entry.snapshot;
 	}
-	/** Returns a fresh cached snapshot or coalesces one plugin/list request. */
+	/** Returns a fresh snapshot or coalesces one catalog or installed-plugin request. */
 	async load(params) {
-		const entryKey = buildMetadataCacheEntryKey(params.appCacheKey, params.queryKind);
-		const cached = this.read(params.appCacheKey, params.queryKind);
+		const entryKey = buildMetadataCacheEntryKey(params.appCacheKey, params.queryKind, params.requestParams);
+		const cached = this.read(params.appCacheKey, params.queryKind, params.requestParams);
 		if (cached) return cached;
 		const pending = this.inFlight.get(entryKey);
 		if (pending) try {
@@ -10243,7 +10702,8 @@ var CodexPluginMetadataCache = class {
 		const generation = this.generations.get(params.appCacheKey) ?? 0;
 		const clearGeneration = this.clearGeneration;
 		const promise = (async () => {
-			const response = await params.request("plugin/list", params.requestParams);
+			const method = params.queryKind === "installed" ? "plugin/installed" : "plugin/list";
+			const response = await params.request(method, params.requestParams);
 			const snapshot = {
 				appCacheKey: params.appCacheKey,
 				queryKind: params.queryKind,
@@ -10282,10 +10742,17 @@ var CodexPluginMetadataCache = class {
 /** Shared plugin metadata cache used by Codex app-server runtime paths. */
 const defaultCodexPluginMetadataCache = new CodexPluginMetadataCache();
 function hasMarketplaceLoadErrors(response) {
-	return (response.marketplaceLoadErrors?.length ?? 0) > 0;
-}
-function buildMetadataCacheEntryKey(appCacheKey, queryKind) {
-	return JSON.stringify([appCacheKey, queryKind]);
+	return response.marketplaceLoadErrors.length > 0;
+}
+function buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams) {
+	if (queryKind !== "installed") return JSON.stringify([appCacheKey, queryKind]);
+	const installedParams = requestParams;
+	return JSON.stringify([
+		appCacheKey,
+		queryKind,
+		installedParams?.cwds ?? [],
+		Array.from(new Set(installedParams?.installSuggestionPluginNames ?? [])).toSorted()
+	]);
 }
 //#endregion
 //#region extensions/codex/src/app-server/plugin-thread-config-deadline.ts
@@ -10379,7 +10846,8 @@ function createCodexPluginThreadConfigStartupProvider(params) {
 		recoverablePluginConfigKeys: policy ? resolveRecoverableCodexPluginConfigKeys({
 			policy,
 			metadataCache,
-			appCacheKey: params.appCacheKey
+			appCacheKey: params.appCacheKey,
+			configCwd: params.configCwd
 		}) : void 0,
 		build: () => buildCodexPluginThreadConfigWithinDeadline({
 			...buildParams,
@@ -10489,7 +10957,7 @@ async function startCodexAttemptThread(params) {
 						if (startupAbandonController.signal.aborted) throw new CodexAppServerStartupError("aborted");
 						let runtimeArtifact;
 						if (params.runtimeArtifactRequest) {
-							const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-C2ITXdhM.js");
+							const { readCodexAppServerClientRuntimeArtifact, validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CmtG_t1L.js");
 							runtimeArtifact = readCodexAppServerClientRuntimeArtifact(activeStartupClient);
 							const expected = params.runtimeArtifactRequest.expected;
 							const matchesExpected = !expected || Boolean(runtimeArtifact && runtimeArtifact.id === expected.id && runtimeArtifact.fingerprint === expected.fingerprint);
@@ -10834,6 +11302,14 @@ async function startCodexAttemptRuntime(resources) {
 			spawnedBy: params.spawnedBy
 		});
 		state.client = startupResult.client;
+		toolBridge.setRemoteWorkspaceFileReader?.(({ path, maxBytes, workspaceRoot, signal, timeoutMs }) => readBoundedCodexRemoteWorkspaceFile({
+			client: startupResult.client,
+			path,
+			maxBytes,
+			workspaceRoot,
+			signal,
+			timeoutMs
+		}));
 		state.thread = startupResult.thread;
 		state.runtimeArtifact = startupResult.runtimeArtifact;
 		state.turnRouter = startupResult.turnRouter;
@@ -11054,6 +11530,8 @@ async function prepareCodexAttemptTools(runtime) {
 				config: params.config,
 				contextWindowTokens: params.contextTokenBudget ?? params.model.contextWindow,
 				workspaceDir: effectiveWorkspace,
+				remoteWorkspaceRoot: connection.appServer.remoteWorkspaceRoot,
+				remoteWorkspaceRequestTimeoutMs: connection.appServer.requestTimeoutMs,
 				sessionId: params.sessionId,
 				sessionKey: sandboxSessionKey,
 				runId: params.runId,