@openclaw/codex 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{run-attempt-MLzoMe_m.js → run-attempt--858NXDl.js}

@@ -1,32 +1,43 @@
-import { A as isCodexAppServerStartupError, B as isCodexAppServerApprovalRequest, C as resolveCodexAppServerFallbackApiKeyCacheKey, D as resolveCodexAppServerHomeDir, F as resolveCodexTurnCompletionIdleTimeoutMs, H as isCodexAppServerConnectionClosedError, I as resolveCodexTurnTerminalIdleTimeoutMs, K as isCodexAppServerRequestTimeoutError, L as withCodexStartupTimeout, M as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, N as resolveCodexStartupTimeoutMs, O as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, P as resolveCodexTurnAssistantCompletionIdleTimeoutMs, R as CodexAppServerRpcError, S as resolveCodexAppServerAuthProfileIdForAgent, T as resolveCodexAppServerPreparedAuthHandoff, V as isCodexAppServerBrokenPipeError, X as flattenCodexDynamicToolFunctions, Z as isJsonObject, _ as readCodexRateLimitsRevision, a as getLeasedSharedCodexAppServerClient, b as resolveCodexAppServerAuthAccountCacheKey, c as releaseLeasedSharedCodexAppServerClient, d as retireSharedCodexAppServerClientIfCurrent, g as ensureCodexAppServerClientRuntime, k as CodexAppServerStartupError, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, o as isCodexAppServerStartSelectionChangedError, t as clearSharedCodexAppServerClientIfCurrent, u as retainSharedCodexAppServerClientIfCurrent, v as readRecentCodexRateLimits, w as resolveCodexAppServerPreparedApiKeyCacheKey, x as resolveCodexAppServerAuthProfileId } from "./shared-client-JiAnW6pc.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-BFmNhqFl.js";
-import { C as resolveCodexComputerUseConfig, D as resolveOpenClawExecPolicyForCodexAppServer, O as shouldAutoApproveCodexAppServerApprovals, T as resolveCodexPluginsPolicy, c as sessionBindingIdentity, g as isCodexAppServerApprovalPolicyAllowedByRequirements, k as withMcpElicitationsApprovalPolicy, s as reclaimCurrentCodexSessionGeneration, v as isCodexSandboxExecServerEnabled, w as resolveCodexModelBackedReviewerPolicyContext, y as readCodexPluginConfig } from "./session-binding-h1mmCGnl.js";
-import { _ as readCodexTurnCompletedNotification, f as assertCodexTurnStartResponse, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, p as readCodexDynamicToolCallParams, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-D9rTxx2P.js";
-import { i as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-Ceb-lm2c.js";
-import { A as CodexAppServerUnsafeSubscriptionError, B as fitCodexProjectedContextForTurnStart, D as resolveCodexDynamicToolsLoadingForRuntime, F as areCodexDynamicToolFingerprintsCompatible, G as buildCodexPluginThreadConfig, H as resolveCodexContextEngineProjectionMaxChars, I as codexDynamicToolsFingerprint, J as mergeCodexThreadConfigs, K as buildCodexPluginThreadConfigInputFingerprint, L as codexLegacyDynamicToolsFingerprint, M as interruptCodexTurnBestEffort, N as retireCodexAppServerClientAfterTimedOutTurn, O as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, P as unsubscribeCodexThreadBestEffort, Q as resolveRecoverableCodexPluginConfigKeys, R as buildContextEngineBinding, U as resolveCodexContextEngineProjectionReserveTokens, V as projectContextEngineAssemblyForCodex, Y as shouldBuildCodexPluginThreadConfig, b as isCodexAppServerProfilerEnabled, d as resolveCodexWebSearchPlan, f as buildDeveloperInstructions, g as resolveCodexAppServerThreadModelSelection, j as closeCodexStartupClientBestEffort, k as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, n as buildTurnStartParams, q as buildCodexPluginThreadConfigTimeoutFallback, r as buildCodexUserInput, s as startOrResumeThread, t as buildTurnCollaborationMode, w as isSystemAgentOnlyCodexDynamicToolAllowlist, x as filterCodexDynamicTools, z as isContextEngineBindingCompatible } from "./thread-lifecycle-CN_pPtPh.js";
-import { r as formatCodexDisplayText } from "./command-formatters-Dq9InZUK.js";
-import { n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-Scc-Wevo.js";
-import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId, t as isCodexNotificationForTurn } from "./notification-correlation-KmfV4EkP.js";
+import { A as isCodexAppServerStartupError, B as isCodexAppServerApprovalRequest, C as resolveCodexAppServerFallbackApiKeyCacheKey, D as resolveCodexAppServerHomeDir, F as resolveCodexTurnCompletionIdleTimeoutMs, H as isCodexAppServerConnectionClosedError, I as resolveCodexTurnTerminalIdleTimeoutMs, K as isCodexAppServerRequestTimeoutError, L as withCodexStartupTimeout, M as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, N as resolveCodexStartupTimeoutMs, O as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, P as resolveCodexTurnAssistantCompletionIdleTimeoutMs, Q as isJsonObject, R as CodexAppServerRpcError, S as resolveCodexAppServerAuthProfileIdForAgent, T as resolveCodexAppServerPreparedAuthHandoff, V as isCodexAppServerBrokenPipeError, Z as flattenCodexDynamicToolFunctions, _ as readCodexRateLimitsRevision, a as getLeasedSharedCodexAppServerClient, b as resolveCodexAppServerAuthAccountCacheKey, c as releaseLeasedSharedCodexAppServerClient, d as retireSharedCodexAppServerClientIfCurrent, g as ensureCodexAppServerClientRuntime, k as CodexAppServerStartupError, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, o as isCodexAppServerStartSelectionChangedError, t as clearSharedCodexAppServerClientIfCurrent, u as retainSharedCodexAppServerClientIfCurrent, v as readRecentCodexRateLimits, w as resolveCodexAppServerPreparedApiKeyCacheKey, x as resolveCodexAppServerAuthProfileId, y as rememberCodexRateLimitsRead } from "./shared-client-wmgNFNYp.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-DdmnBMUp.js";
+import { A as withMcpElicitationsApprovalPolicy, E as resolveCodexPluginsPolicy, O as resolveOpenClawExecPolicyForCodexAppServer, T as resolveCodexModelBackedReviewerPolicyContext, _ as isCodexAppServerApprovalPolicyAllowedByRequirements, b as readCodexPluginConfig, c as reclaimCurrentCodexSessionGeneration, i as createCodexSessionGenerationSupersededError, k as shouldAutoApproveCodexAppServerApprovals, l as sessionBindingIdentity, w as resolveCodexComputerUseConfig, y as isCodexSandboxExecServerEnabled } from "./session-binding-ZSMX1omP.js";
+import { $ as shouldBuildCodexPluginThreadConfig, B as codexDynamicToolsFingerprint, F as closeCodexStartupClientBestEffort, G as projectContextEngineAssemblyForCodex, H as buildContextEngineBinding, I as interruptCodexTurnBestEffort, K as resolveCodexContextEngineProjectionMaxChars, L as retireCodexAppServerClientAfterTimedOutTurn, M as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, N as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, O as isSystemAgentOnlyCodexDynamicToolAllowlist, P as CodexAppServerUnsafeSubscriptionError, Q as mergeCodexThreadConfigs, R as unsubscribeCodexThreadBestEffort, T as filterCodexDynamicTools, U as isContextEngineBindingCompatible, V as codexLegacyDynamicToolsFingerprint, W as fitCodexProjectedContextForTurnStart, X as buildCodexPluginThreadConfigInputFingerprint, Y as buildCodexPluginThreadConfig, Z as buildCodexPluginThreadConfigTimeoutFallback, a as sanitizeCodexHistoryImagePayloads, at as readCodexErrorNotificationMessage, b as resolveCodexAppServerThreadModelSelection, ct as readItemString, dt as readNonNegativeInteger, ft as readNullableString$1, g as buildDeveloperInstructions, h as resolveCodexWebSearchPlan, ht as splitPlanText, it as normalizeNonEmptyString, j as resolveCodexDynamicToolsLoadingForRuntime, lt as readNonEmptyString$1, mt as readString$5, n as buildTurnStartParams, nt as resolveRecoverableCodexPluginConfigKeys, ot as readHookOutputEntries, pt as readNumber, q as resolveCodexContextEngineProjectionReserveTokens, r as buildCodexUserInput, rt as extractRawAssistantText, s as startOrResumeThread, st as readItem, t as buildTurnCollaborationMode, ut as readNonEmptyStringArray, w as isCodexAppServerProfilerEnabled, z as areCodexDynamicToolFingerprintsCompatible } from "./thread-lifecycle-cqrOlJkq.js";
+import { n as projectCodexThreadUsageUpdate, t as normalizeCodexResponseTokenUsage } from "./event-projector-usage-D6tE7_qD.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-2p7kl6e4.js";
+import { i as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-CvzvmBRz.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-CLICvTxf.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-D0IJT-a6.js";
+import { r as formatCodexDisplayText } from "./command-formatters-DgADqnHa.js";
+import { n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BO3jYBkv.js";
+import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId, t as isCodexNotificationForTurn } from "./notification-correlation-BGLixv5_.js";
 import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-C1czuHPA.js";
-import { $ as resolveCodexToolProgressDetailMode, B as hasPendingDynamicToolTerminalDiagnostic, C as CodexAppServerEventProjector, D as markCodexAuthProfileBlockedFromRateLimits, E as isCodexUsageLimitPromptError, F as emitCodexNativePreToolUseFailureDiagnostic, G as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, H as isMatchingDynamicToolTerminalDiagnostic, I as resolveCodexNativeHookRelayEvents, J as toCodexDynamicToolProtocolResponse, K as shouldReleaseTurnAfterTerminalDynamicTool, L as resolveCodexNativeHookRelayTtlMs, M as buildCodexNativeHookRelayConfig, N as buildCodexNativeHookRelayDisabledConfig, O as refreshCodexUsageLimitPromptError, P as createCodexNativeHookRelay, Q as inferCodexDynamicToolMeta, R as scheduleCodexNativeHookRelayUnregister, T as formatCodexTurnStartUsageLimitError, U as resolveDynamicToolCallTimeoutMs, V as isDynamicToolTerminalDiagnosticEvent, W as resolveTerminalDynamicToolBatchAction, X as readCodexMirroredSessionHistoryMessages, Y as resolveCodexToolAbortTerminalReason, Z as shouldEmitTranscriptToolProgress, _ as resolveCodexMessageToolProvider, a as emitDynamicToolStartedDiagnostic, b as shouldRequireCodexSandboxExecServerEnvironment, d as createCodexDynamicToolBuildStageTracker, et as sanitizeCodexToolArguments, f as disableCodexPluginThreadConfig, g as resolveCodexExternalSandboxPolicyForOpenClawSandbox, h as resolveCodexAppServerHookChannelId, i as emitDynamicToolErrorDiagnostic, j as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, l as settleCodexSourceReplyFinality, m as resolveCodexAppServerExecutionCwd, n as handleCodexAppServerApprovalRequest, nt as resolveCodexLocalRuntimeAttribution, o as emitDynamicToolTerminalDiagnostic, p as formatCodexDynamicToolBuildStageSummary, q as toCodexDynamicToolProgressResponse, r as handleCodexAppServerElicitationRequest, s as resolveCodexProviderWebSearchSupport, t as createCodexDynamicToolBridge, tt as sanitizeCodexToolResponse, u as buildDynamicTools, v as resolveCodexSandboxEnvironmentSelection, w as createCodexUsageLimitPromptError, x as shouldWarnCodexDynamicToolBuildStageSummary, y as shouldEnableCodexAppServerNativeToolSurface, z as handleDynamicToolCallWithTimeout } from "./dynamic-tools-C_1tEs34.js";
-import { a as runCodexComputerUseLiveTest, r as killStaleComputerUseMcpChildren, t as ensureCodexComputerUse } from "./computer-use-CPcU8TjG.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-CQI3UwqY.js";
+import { a as runCodexComputerUseLiveTest, r as killStaleComputerUseMcpChildren, t as ensureCodexComputerUse } from "./computer-use-Ip1-QGa-.js";
 import fs from "node:fs/promises";
 import path, { posix } from "node:path";
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import { resolveAgentDir, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { markAuthProfileBlockedUntil, resolveAgentDir, 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 { CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, finalizeHarnessContextEngineTurn, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, getBeforeToolCallPolicyDiagnosticState, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, resolveAgentDir as resolveAgentDir$1, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds as resolveSessionAgentIds$1, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, TOOL_PROGRESS_OUTPUT_MAX_CHARS, 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, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir as resolveAgentDir$1, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds as resolveSessionAgentIds$1, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessGatewayQuestion, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { spawn } from "node:child_process";
 import { once } from "node:events";
 import { isIP } from "node:net";
 import { WebSocketServer } from "ws";
-import { parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
+import { listSessionEntries, parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
 import { fileURLToPath } 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 { buildMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";
+import { readSessionTranscriptEvents } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { prepareMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";
+import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
+import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "openclaw/plugin-sdk/agent-sessions";
+import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
+import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 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";
@@ -190,41 +201,2467 @@ function normalizeCodexSteerDebounceMs(value) {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : CODEX_STEER_ALL_DEBOUNCE_MS;
 }
 //#endregion
-//#region extensions/codex/src/app-server/user-input-bridge.ts
+//#region extensions/codex/src/app-server/event-projector-assistant.ts
+var CodexAssistantProjection = class {
+	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp) {
+		this.params = params;
+		this.emitAgentEvent = emitAgentEvent;
+		this.matchesToolProgressEcho = matchesToolProgressEcho;
+		this.nextTranscriptTimestamp = nextTranscriptTimestamp;
+		this.assistantTextByItem = /* @__PURE__ */ new Map();
+		this.assistantItemOrder = [];
+		this.assistantTimestampByItem = /* @__PURE__ */ new Map();
+		this.assistantPhaseByItem = /* @__PURE__ */ new Map();
+		this.latestTerminalAssistantCandidateSuperseded = false;
+		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
+		this.terminalAssistantCandidateEarlierActiveItemIds = /* @__PURE__ */ new Set();
+		this.lastCommentaryProgressTextByItem = /* @__PURE__ */ new Map();
+		this.lastAnswerCandidateEventByItem = /* @__PURE__ */ new Map();
+		this.pendingRawCommentaryEchoes = 0;
+		this.rawPromotedAssistantItemIds = /* @__PURE__ */ new Set();
+		this.assistantStarted = false;
+		this.streamedPartialAssistantItemReplaceable = false;
+	}
+	hasCompletedTerminalAssistantText(completedItemIds) {
+		const latestCompletedItemId = this.latestCompletedTerminalAssistantItemId;
+		if (!latestCompletedItemId) return false;
+		const finalItem = this.resolveFinalAssistantTextItem();
+		return this.latestCompletedItemId === latestCompletedItemId && finalItem?.itemId === latestCompletedItemId && completedItemIds.has(latestCompletedItemId);
+	}
+	getLatestTerminalAssistantCandidate() {
+		const itemId = this.latestTerminalAssistantCandidateItemId;
+		if (!itemId) return;
+		const text = this.assistantTextByItem.get(itemId)?.trim();
+		return {
+			itemId,
+			hasText: Boolean(text && !this.isToolProgressEchoText(itemId, text))
+		};
+	}
+	hasLatestTerminalAssistantCandidateText() {
+		return !this.latestTerminalAssistantCandidateSuperseded && this.getLatestTerminalAssistantCandidate()?.hasText === true;
+	}
+	canReleaseLatestTerminalAssistantAfterToolHandoff() {
+		return this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff && this.hasLatestTerminalAssistantCandidateText();
+	}
+	async handleAssistantDelta(params) {
+		const itemId = readString$5(params, "itemId") ?? "assistant";
+		const delta = readString$5(params, "delta") ?? "";
+		if (!delta) return;
+		if (itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		const isCommentary = this.isCommentaryAssistantItem(itemId);
+		if (!isCommentary && itemId !== this.latestTerminalAssistantCandidateItemId) this.markTerminalAssistantCandidateSupersededBy();
+		if (!this.assistantStarted) {
+			this.assistantStarted = true;
+			await this.params.onAssistantMessageStart?.();
+		}
+		this.rememberAssistantItem(itemId);
+		const text = `${this.assistantTextByItem.get(itemId) ?? ""}${delta}`;
+		this.assistantTextByItem.set(itemId, text);
+		if (isCommentary) {
+			this.emitCommentaryProgress({
+				itemId,
+				text
+			});
+			return;
+		}
+		if (this.isFinalAnswerAssistantItem(itemId)) this.emitAnswerCandidate(itemId, "candidate");
+		const knownFinalAnswer = this.shouldStreamAssistantPartial(itemId);
+		const replace = this.streamedPartialAssistantItemId !== void 0 && this.streamedPartialAssistantItemId !== itemId;
+		if (replace && (!knownFinalAnswer || this.streamedPartialAssistantItemReplaceable)) this.streamedPartialAssistantItemReplaceable = true;
+		else if (this.streamedPartialAssistantItemId === void 0) this.streamedPartialAssistantItemReplaceable = !knownFinalAnswer;
+		this.streamedPartialAssistantItemId = itemId;
+		const replaceable = this.streamedPartialAssistantItemReplaceable;
+		const replacement = replace && replaceable;
+		const streamPayload = {
+			text,
+			delta: replacement ? "" : delta,
+			...replacement ? { replace: true } : {}
+		};
+		this.emitAgentEvent({
+			stream: "assistant",
+			data: {
+				...streamPayload,
+				...replaceable ? { replaceable: true } : {}
+			}
+		});
+		if (knownFinalAnswer && !replaceable) await this.params.onPartialReply?.(streamPayload);
+	}
+	recordItemStarted(item, itemId) {
+		if (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		this.rememberAssistantPhase(item);
+		if (item?.type === "agentMessage" && itemId) this.rememberAssistantItem(itemId);
+		if (itemId && itemId !== this.latestTerminalAssistantCandidateItemId) {
+			this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
+			if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		}
+	}
+	recordItemCompleted(item, itemId, activeItemIds) {
+		if (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		if (itemId) this.latestCompletedItemId = itemId;
+		this.rememberAssistantPhase(item);
+		if (item?.type === "agentMessage" && !this.isCommentaryAssistantItem(item.id)) {
+			this.latestCompletedTerminalAssistantItemId = item.id;
+			this.markLatestTerminalAssistantCandidate(item.id, activeItemIds);
+			this.pendingRawTerminalAssistantEchoItemId = item.id;
+		} else if (itemId) {
+			this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
+			if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		}
+		if (item?.type === "agentMessage" && typeof item.text === "string") {
+			this.rememberAssistantItem(item.id);
+			this.assistantTextByItem.set(item.id, item.text);
+			if (item.text && this.isCommentaryAssistantItem(item.id)) {
+				this.emitCommentaryProgress({
+					itemId: item.id,
+					text: item.text
+				});
+				this.pendingRawCommentaryEchoes += 1;
+			} else if (item.text && this.isFinalAnswerAssistantItem(item.id)) this.emitAnswerCandidate(item.id, "candidate");
+		}
+	}
+	recordSnapshotItem(item) {
+		this.rememberAssistantPhase(item);
+		if (item.type === "agentMessage" && typeof item.text === "string") {
+			this.rememberAssistantItem(item.id);
+			this.assistantTextByItem.set(item.id, item.text);
+		}
+	}
+	handleRawResponseItemCompleted(item, activeItemIds) {
+		const role = readString$5(item, "role");
+		const phase = readString$5(item, "phase");
+		const rawItemId = readString$5(item, "id");
+		const candidateWasSupersededBeforeRaw = this.latestTerminalAssistantCandidateSuperseded;
+		const pendingTerminalAssistantEchoItemId = this.pendingRawTerminalAssistantEchoItemId;
+		const isPendingTerminalAssistantEcho = role === "assistant" && phase !== "commentary" && pendingTerminalAssistantEchoItemId !== void 0 && (rawItemId === void 0 || rawItemId === pendingTerminalAssistantEchoItemId);
+		if (pendingTerminalAssistantEchoItemId !== void 0 && !isPendingTerminalAssistantEcho) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		if (!isPendingTerminalAssistantEcho) {
+			this.latestCompletedItemId = void 0;
+			this.markTerminalAssistantCandidateSupersededBy(rawItemId);
+		}
+		if (role !== "assistant") return;
+		if (phase === "commentary" && this.pendingRawCommentaryEchoes > 0) {
+			this.pendingRawCommentaryEchoes -= 1;
+			return;
+		}
+		const text = extractRawAssistantText(item);
+		if (isPendingTerminalAssistantEcho) {
+			const typedItemId = pendingTerminalAssistantEchoItemId;
+			this.pendingRawTerminalAssistantEchoItemId = void 0;
+			if (this.assistantTextByItem.get(typedItemId)?.trim() || !text) return;
+			this.rememberAssistantItem(typedItemId);
+			this.assistantTextByItem.set(typedItemId, text);
+			return;
+		}
+		if (!text) return;
+		const itemId = rawItemId ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
+		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && activeItemIds.size === 0;
+		if (phase !== "commentary" && candidateWasSupersededBeforeRaw && itemId !== this.streamedPartialAssistantItemId && !isIdlessTerminalAssistantAfterCompletedWork) return;
+		if (phase) this.assistantPhaseByItem.set(itemId, phase);
+		this.rememberAssistantItem(itemId);
+		this.assistantTextByItem.set(itemId, text);
+		this.rawPromotedAssistantItemIds.add(itemId);
+		if (phase === "commentary") this.emitCommentaryProgress({
+			itemId,
+			text
+		});
+		else this.markLatestTerminalAssistantCandidate(itemId, activeItemIds, { canReleaseAfterToolHandoff: isIdlessTerminalAssistantAfterCompletedWork });
+	}
+	collectAssistantTexts() {
+		const finalText = this.resolveFinalAssistantTextItem()?.text;
+		return finalText ? [finalText] : [];
+	}
+	collectCommentaryMessages() {
+		return this.assistantItemOrder.flatMap((itemId) => {
+			if (!this.isCommentaryAssistantItem(itemId)) return [];
+			const text = this.assistantTextByItem.get(itemId)?.trim();
+			const timestamp = this.assistantTimestampByItem.get(itemId);
+			if (!text || timestamp === void 0) return [];
+			return [{
+				itemId,
+				message: createAssistantCommentaryMessage(this.params, text, itemId, timestamp)
+			}];
+		});
+	}
+	finalizeAnswerCandidate(turn) {
+		if (turn.status !== "completed") {
+			this.supersedeVisibleAnswerCandidate();
+			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 authoritative = authoritativeIndex >= 0 ? turnItems[authoritativeIndex] : void 0;
+		if (turnItems.slice(authoritativeIndex + 1).some(shouldClearTerminalPresentationForNativeItem) || authoritative?.id === this.latestTerminalAssistantCandidateItemId && this.latestTerminalAssistantCandidateSuperseded) {
+			this.supersedeVisibleAnswerCandidate();
+			return;
+		}
+		const itemId = authoritative?.id ?? this.visibleAnswerCandidateItemId;
+		if (!itemId) return;
+		if (itemId !== this.visibleAnswerCandidateItemId) {
+			this.supersedeVisibleAnswerCandidate();
+			this.visibleAnswerCandidateItemId = itemId;
+		}
+		this.emitAnswerCandidate(itemId, "selected");
+	}
+	hasAssistantItemTextForSynthesis() {
+		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
+			const itemId = this.assistantItemOrder[i];
+			if (!itemId || this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			const text = this.assistantTextByItem.get(itemId);
+			if (text && text.length > 0) return true;
+		}
+		return false;
+	}
+	createCurrentAttemptAssistantMessage(options) {
+		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
+			const itemId = this.assistantItemOrder[i];
+			if (!itemId || this.isCommentaryAssistantItem(itemId) || !this.assistantTextByItem.has(itemId)) continue;
+			const text = this.assistantTextByItem.get(itemId) ?? "";
+			const normalizedText = text.trim();
+			if (normalizedText && this.isToolProgressEchoText(itemId, normalizedText)) continue;
+			return this.createAssistantMessage(text, options);
+		}
+	}
+	createAssistantMessage(text, options) {
+		return createAssistantMessage(this.params, text, options);
+	}
+	createAssistantMirrorMessage(title, text) {
+		return createAssistantMirrorMessage(this.params, title, text);
+	}
+	rememberAssistantPhase(item) {
+		if (item?.type !== "agentMessage") return;
+		const phase = readItemString(item, "phase");
+		if (phase) this.assistantPhaseByItem.set(item.id, phase);
+	}
+	isCommentaryAssistantItem(itemId) {
+		return this.assistantPhaseByItem.get(itemId) === "commentary";
+	}
+	isFinalAnswerAssistantItem(itemId) {
+		return this.assistantPhaseByItem.get(itemId) === "final_answer";
+	}
+	shouldStreamAssistantPartial(itemId) {
+		return this.assistantPhaseByItem.get(itemId) === "final_answer";
+	}
+	emitCommentaryProgress(params) {
+		const progressText = params.text.replace(/\s+/g, " ").trim();
+		if (!progressText || this.lastCommentaryProgressTextByItem.get(params.itemId) === progressText) return;
+		this.lastCommentaryProgressTextByItem.set(params.itemId, progressText);
+		this.emitAgentEvent({
+			stream: "item",
+			data: {
+				itemId: params.itemId,
+				kind: "preamble",
+				title: "Preamble",
+				phase: "update",
+				progressText,
+				source: "codex-app-server"
+			}
+		});
+	}
+	emitAnswerCandidate(itemId, status) {
+		const text = this.assistantTextByItem.get(itemId)?.trim();
+		if (!text) return;
+		if (status === "candidate" && this.visibleAnswerCandidateItemId !== itemId) {
+			this.supersedeVisibleAnswerCandidate();
+			this.visibleAnswerCandidateItemId = itemId;
+		}
+		const signature = `${status}\0${text}`;
+		if (this.lastAnswerCandidateEventByItem.get(itemId) === signature) return;
+		this.lastAnswerCandidateEventByItem.set(itemId, signature);
+		this.emitAgentEvent({
+			stream: "item",
+			data: {
+				itemId,
+				kind: "answer_candidate",
+				title: "Answer candidate",
+				phase: "update",
+				status,
+				progressText: text,
+				source: "codex-app-server",
+				hideFromChannelProgress: true
+			}
+		});
+	}
+	supersedeVisibleAnswerCandidate() {
+		const itemId = this.visibleAnswerCandidateItemId;
+		if (!itemId) return;
+		this.emitAnswerCandidate(itemId, "superseded");
+		this.visibleAnswerCandidateItemId = void 0;
+	}
+	markLatestTerminalAssistantCandidate(itemId, activeItemIds, options) {
+		this.latestTerminalAssistantCandidateItemId = itemId;
+		this.latestTerminalAssistantCandidateSuperseded = false;
+		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = options?.canReleaseAfterToolHandoff === true;
+		this.terminalAssistantCandidateEarlierActiveItemIds = new Set(activeItemIds);
+	}
+	markTerminalAssistantCandidateSupersededBy(itemId, options) {
+		if (!this.latestTerminalAssistantCandidateItemId) return;
+		if (itemId && this.terminalAssistantCandidateEarlierActiveItemIds.has(itemId)) {
+			if (!options?.preserveEarlierActiveItem) this.terminalAssistantCandidateEarlierActiveItemIds.delete(itemId);
+			return;
+		}
+		this.latestTerminalAssistantCandidateSuperseded = true;
+		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
+		this.terminalAssistantCandidateEarlierActiveItemIds.clear();
+		this.supersedeVisibleAnswerCandidate();
+	}
+	resolveFinalAssistantTextItem() {
+		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
+			const itemId = this.assistantItemOrder[i];
+			if (!itemId) continue;
+			const text = this.assistantTextByItem.get(itemId)?.trim();
+			if (this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			if (text && !this.isToolProgressEchoText(itemId, text)) return {
+				itemId,
+				text
+			};
+		}
+	}
+	rememberAssistantItem(itemId) {
+		if (!itemId || this.assistantItemOrder.includes(itemId)) return;
+		this.assistantItemOrder.push(itemId);
+		this.assistantTimestampByItem.set(itemId, this.nextTranscriptTimestamp());
+	}
+	isToolProgressEchoText(itemId, text) {
+		return this.rawPromotedAssistantItemIds.has(itemId) && this.matchesToolProgressEcho(text);
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-diagnostics.ts
+function redactCodexEventKind(method) {
+	return redactSensitiveText(sanitizeTerminalText(method));
+}
+var CodexProjectionDiagnostics = class {
+	constructor(threadId, turnId) {
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.warningKeys = /* @__PURE__ */ new Set();
+	}
+	warnUnknownItemStatus(item) {
+		if (!item) return;
+		const status = unknownItemStatus(item);
+		if (!status) return;
+		const safeStatus = redactCodexEventKind(status);
+		const safeItemType = redactCodexEventKind(item.type);
+		this.warnOnce(JSON.stringify([
+			"status",
+			item.type,
+			status
+		]), "codex app-server item reported unknown status; continuing projection", {
+			itemId: item.id,
+			itemType: safeItemType,
+			status: safeStatus
+		});
+	}
+	warnUnknownEvent(notification, params) {
+		const notificationThreadId = readCodexNotificationThreadId(params);
+		const notificationTurnId = readCodexNotificationTurnId(params);
+		const eventKind = redactCodexEventKind(notification.method);
+		this.warnOnce(JSON.stringify(["method", notification.method]), `codex app-server projector received unknown event kind; continuing: ${eventKind}`, {
+			eventKind,
+			activeThreadId: this.threadId,
+			activeTurnId: this.turnId,
+			threadId: notificationThreadId,
+			turnId: notificationTurnId,
+			matchesActiveThread: notificationThreadId === this.threadId,
+			matchesActiveTurn: notificationTurnId === this.turnId
+		});
+	}
+	warnOnce(key, message, context) {
+		if (this.warningKeys.has(key)) return;
+		this.warningKeys.add(key);
+		embeddedAgentLog.warn(message, context);
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-tool-output.ts
+const TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS = 1e4;
+const TOOL_OUTPUT_TRUNCATION_NOTICE_PREFIX = "...(OpenClaw truncated Codex native tool output";
+var ToolOutputAccumulator = class {
+	constructor() {
+		this.prefixByItem = /* @__PURE__ */ new Map();
+		this.originalLengthByItem = /* @__PURE__ */ new Map();
+		this.normalizedLengthByItem = /* @__PURE__ */ new Map();
+		this.trimStateByItem = /* @__PURE__ */ new Map();
+		this.truncatedItemIds = /* @__PURE__ */ new Set();
+		this.textByItem = /* @__PURE__ */ new Map();
+	}
+	append(itemId, delta) {
+		const originalLength = (this.originalLengthByItem.get(itemId) ?? this.textByItem.get(itemId)?.length ?? 0) + delta.length;
+		this.originalLengthByItem.set(itemId, originalLength);
+		const normalizedLength = updateToolOutputTrimState(this.trimStateByItem, itemId, delta);
+		this.normalizedLengthByItem.set(itemId, normalizedLength);
+		if (this.truncatedItemIds.has(itemId)) {
+			const next = appendBoundedToolTranscriptText(this.prefixByItem.get(itemId) ?? this.textByItem.get(itemId) ?? "", "", originalLength);
+			this.prefixByItem.set(itemId, next.rawPrefix);
+			this.textByItem.set(itemId, next.text);
+			return {
+				text: next.text,
+				originalLength,
+				normalizedLength,
+				rawPrefix: next.rawPrefix
+			};
+		}
+		const next = appendBoundedToolTranscriptText(this.prefixByItem.get(itemId) ?? this.textByItem.get(itemId) ?? "", delta, originalLength);
+		this.prefixByItem.set(itemId, next.rawPrefix);
+		this.textByItem.set(itemId, next.text);
+		if (originalLength > 1e4) this.truncatedItemIds.add(itemId);
+		return {
+			text: next.text,
+			originalLength,
+			normalizedLength,
+			rawPrefix: next.rawPrefix
+		};
+	}
+};
+function updateToolOutputTrimState(trimStateByItem, itemId, delta) {
+	const state = trimStateByItem.get(itemId) ?? {
+		totalLength: 0,
+		leadingWhitespaceLength: 0,
+		trailingWhitespaceLength: 0,
+		sawNonWhitespace: false
+	};
+	state.totalLength += delta.length;
+	const firstNonWhitespace = delta.search(/\S/u);
+	if (firstNonWhitespace === -1) {
+		if (!state.sawNonWhitespace) state.leadingWhitespaceLength += delta.length;
+		state.trailingWhitespaceLength += delta.length;
+		trimStateByItem.set(itemId, state);
+		return state.sawNonWhitespace ? state.totalLength - state.leadingWhitespaceLength - state.trailingWhitespaceLength : 0;
+	}
+	if (!state.sawNonWhitespace) {
+		state.leadingWhitespaceLength += firstNonWhitespace;
+		state.sawNonWhitespace = true;
+	}
+	state.trailingWhitespaceLength = delta.match(/\s*$/u)?.[0].length ?? 0;
+	trimStateByItem.set(itemId, state);
+	return state.totalLength - state.leadingWhitespaceLength - state.trailingWhitespaceLength;
+}
+function toolOutputRawEchoSignature(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return;
+	return {
+		rawLength: trimmed.length,
+		rawPrefix: trimmed.slice(0, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS)
+	};
+}
+function normalizeToolTranscriptArguments(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+function collectDynamicToolContentText(contentItems) {
+	if (!Array.isArray(contentItems)) return "";
+	return contentItems.flatMap((entry) => {
+		if (!isJsonObject(entry)) return [];
+		const text = readString$5(entry, "text");
+		return text ? [text] : [];
+	}).join("\n");
+}
+function appendBoundedToolTranscriptText(currentPrefix, delta, originalLength) {
+	if (originalLength <= 1e4) {
+		const rawPrefix = currentPrefix + delta;
+		return {
+			text: rawPrefix,
+			rawPrefix
+		};
+	}
+	const notice = toolTranscriptTruncationNotice(originalLength);
+	if (notice.length >= 1e4) return {
+		text: notice.slice(0, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS),
+		rawPrefix: ""
+	};
+	const textBudget = TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS - notice.length;
+	const remaining = Math.max(0, textBudget - currentPrefix.length);
+	const rawPrefix = truncateUtf16Safe(remaining > 0 ? `${currentPrefix}${truncateUtf16Safe(delta, remaining)}` : currentPrefix, textBudget);
+	return {
+		text: `${rawPrefix}${notice}`,
+		rawPrefix
+	};
+}
+function toolTranscriptTruncationNotice(originalLength) {
+	return `\n${`${TOOL_OUTPUT_TRUNCATION_NOTICE_PREFIX}: original ${originalLength} chars, showing ${TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS}; rerun with narrower args.)`}`;
+}
+function truncateToolTranscriptText(text, originalLength = text.length) {
+	if (originalLength <= 1e4 && text.length <= 1e4) return text;
+	const notice = toolTranscriptTruncationNotice(originalLength);
+	if (notice.length >= 1e4) return notice.slice(1, 10001);
+	return `${truncateUtf16Safe(text, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS - notice.length)}${notice}`;
+}
+function formatToolSummary(toolName, meta) {
+	const trimmedMeta = meta?.trim();
+	return formatToolAggregate(toolName, trimmedMeta ? [trimmedMeta] : void 0, { markdown: true });
+}
+function formatToolOutput(toolName, meta, output) {
+	const formattedOutput = formatToolProgressOutput(output);
+	if (!formattedOutput) return formatToolSummary(toolName, meta);
+	const fence = markdownFenceForText(formattedOutput);
+	return `${formatToolSummary(toolName, meta)}\n${fence}txt\n${formattedOutput}\n${fence}`;
+}
+function markdownFenceForText(text) {
+	return "`".repeat(Math.max(3, longestBacktickRun(text) + 1));
+}
+function longestBacktickRun(value) {
+	let longest = 0;
+	let current = 0;
+	for (const char of value) {
+		if (char === "`") {
+			current += 1;
+			longest = Math.max(longest, current);
+			continue;
+		}
+		current = 0;
+	}
+	return longest;
+}
+//#endregion
+//#region extensions/codex/src/app-server/tool-progress-normalization.ts
+/**
+* Normalizes and sanitizes Codex dynamic-tool progress payloads before they are
+* emitted into OpenClaw events or logs.
+*/
+/** Maps OpenClaw tool-progress config to the mode used by Codex progress metadata. */
+function resolveCodexToolProgressDetailMode(value) {
+	return value === "raw" ? "raw" : "explain";
+}
+/** Recursively redacts sensitive strings and handles circular values in event payloads. */
+function sanitizeCodexAgentEventValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (typeof value === "string") return redactToolPayloadText(value);
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		return value.map((entry) => sanitizeCodexAgentEventValue(entry, seen));
+	}
+	if (value && typeof value === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		const out = {};
+		for (const [key, child] of Object.entries(value)) out[key] = typeof child === "string" ? redactSensitiveFieldValue(key, child) : sanitizeCodexAgentEventValue(child, seen);
+		return out;
+	}
+	return value;
+}
+/** Sanitizes a record-shaped Codex agent event payload. */
+function sanitizeCodexAgentEventRecord(value) {
+	return sanitizeCodexAgentEventValue(value);
+}
+/** Sanitizes dynamic-tool arguments before diagnostic/event emission. */
+function sanitizeCodexToolArguments(value) {
+	if (!isJsonObject(value)) return;
+	return sanitizeCodexAgentEventRecord(value);
+}
+/** Sanitizes a Codex dynamic-tool response before diagnostic/event emission. */
+function sanitizeCodexToolResponse(response) {
+	return sanitizeCodexAgentEventRecord(response);
+}
+/** Infers compact human-readable tool metadata from Codex dynamic-tool arguments. */
+function inferCodexDynamicToolMeta(call, detailMode) {
+	return inferToolMetaFromArgs(call.tool, call.arguments, { detailMode });
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-tool-items.ts
+function nativeToolActionFingerprint(item) {
+	if (item.type === "commandExecution" && typeof item.command === "string") return JSON.stringify({
+		type: item.type,
+		command: item.command,
+		cwd: typeof item.cwd === "string" ? item.cwd : ""
+	});
+	if (item.type === "fileChange") return JSON.stringify({
+		type: item.type,
+		changes: itemFileChanges(item)
+	});
+}
+function isNativePostToolUseRelayItem(item) {
+	switch (item.type) {
+		case "commandExecution":
+		case "fileChange":
+		case "mcpToolCall": return true;
+		default: return false;
+	}
+}
+function shouldSuppressChannelProgressForItem(item) {
+	if (shouldSynthesizeToolProgressForItem(item)) return true;
+	return item.type === "dynamicToolCall";
+}
+function itemToolArgs(item) {
+	if (item.type === "commandExecution") return sanitizeCodexAgentEventRecord({
+		command: item.command,
+		...typeof item.cwd === "string" ? { cwd: item.cwd } : {}
+	});
+	if (item.type === "fileChange") return sanitizeCodexAgentEventRecord({ changes: itemFileChangesForTranscript(item) });
+	if (item.type === "webSearch") return webSearchToolArgs(item);
+	if (item.type === "dynamicToolCall" || item.type === "mcpToolCall") return sanitizeCodexToolArguments(item.arguments);
+}
+function webSearchToolArgs(item) {
+	const action = isJsonObject(item.action) ? item.action : void 0;
+	const actionType = action ? readNonEmptyString$1(action, "type") : void 0;
+	const queries = action && actionType === "search" ? readNonEmptyStringArray(action, "queries") : [];
+	const query = normalizeNonEmptyString(item.query) ?? (action && actionType === "search" ? readNonEmptyString$1(action, "query") : void 0) ?? queries[0];
+	const url = action ? readNonEmptyString$1(action, "url") : void 0;
+	const pattern = action ? readNonEmptyString$1(action, "pattern") : void 0;
+	const args = {};
+	if (query) args.query = query;
+	if (queries.length > 0) args.queries = queries;
+	if (actionType && actionType !== "search") args.action = actionType;
+	if (url) args.url = url;
+	if (pattern) args.pattern = pattern;
+	if (!query && !url && !pattern) args.queryUnavailable = true;
+	return sanitizeCodexAgentEventRecord(args);
+}
+function itemToolResult(item) {
+	if (item.type === "commandExecution") return { result: sanitizeCodexAgentEventRecord({
+		status: item.status,
+		exitCode: item.exitCode,
+		durationMs: item.durationMs
+	}) };
+	if (item.type === "fileChange") return { result: sanitizeCodexAgentEventRecord({
+		status: item.status,
+		changes: itemFileChanges(item)
+	}) };
+	if (item.type === "mcpToolCall") return { result: sanitizeCodexAgentEventRecord({
+		status: item.status,
+		durationMs: item.durationMs,
+		...item.error ? { error: item.error } : {},
+		...item.result ? { result: item.result } : {}
+	}) };
+	if (item.type === "webSearch") return { result: webSearchToolResult(item) };
+	return {};
+}
+function webSearchToolResult(item) {
+	return sanitizeCodexAgentEventRecord({
+		status: itemStatus(item),
+		...typeof item.durationMs === "number" ? { durationMs: item.durationMs } : {},
+		...webSearchToolArgs(item)
+	});
+}
+function itemFileChangeRecords(item) {
+	const changes = item.changes;
+	return Array.isArray(changes) ? changes.filter(isJsonObject) : [];
+}
+function itemFileChanges(item) {
+	return itemFileChangeRecords(item).flatMap((change) => {
+		const path = normalizeNonEmptyString(change.path);
+		if (!path || change.kind === void 0) return [];
+		return [{
+			path,
+			kind: change.kind
+		}];
+	});
+}
+function fileChangeKindType(kind) {
+	if (typeof kind === "string") return kind;
+	return isJsonObject(kind) ? normalizeNonEmptyString(kind.type) : void 0;
+}
+function countFileContentLines(content) {
+	if (!content) return 0;
+	const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+	if (lines.length > 1 && lines.at(-1) === "") lines.pop();
+	return lines.length;
+}
+function fileChangeDiffStat(diff, kind) {
+	const kindType = fileChangeKindType(kind);
+	if (kindType === "add") return {
+		added: countFileContentLines(diff),
+		removed: 0
+	};
+	if (kindType === "delete") return {
+		added: 0,
+		removed: countFileContentLines(diff)
+	};
+	let added = 0;
+	let removed = 0;
+	let inHunk = false;
+	for (const line of diff.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n")) {
+		if (line.startsWith("@@")) {
+			inHunk = true;
+			continue;
+		}
+		if (!inHunk) continue;
+		if (line.startsWith("+")) added += 1;
+		else if (line.startsWith("-")) removed += 1;
+	}
+	return {
+		added,
+		removed
+	};
+}
+function truncateFileChangeDiffAtLineBoundary(diff, maxChars) {
+	if (diff.length <= maxChars) return { diff };
+	if (maxChars <= 0) return { diffTruncated: true };
+	const boundary = diff.lastIndexOf("\n", maxChars - 1);
+	return boundary >= 0 ? {
+		diff: diff.slice(0, boundary + 1),
+		diffTruncated: true
+	} : { diffTruncated: true };
+}
+function itemFileChangesForTranscript(item) {
+	let remainingDiffChars = 1e4;
+	return itemFileChangeRecords(item).flatMap((change) => {
+		const path = normalizeNonEmptyString(change.path);
+		if (!path || change.kind === void 0) return [];
+		const result = {
+			path,
+			kind: change.kind
+		};
+		if (typeof change.diff !== "string") return [result];
+		result.stat = fileChangeDiffStat(change.diff, change.kind);
+		const bounded = truncateFileChangeDiffAtLineBoundary(change.diff, remainingDiffChars);
+		if (bounded.diff !== void 0) {
+			result.diff = bounded.diff;
+			remainingDiffChars -= bounded.diff.length;
+		}
+		if (bounded.diffTruncated) result.diffTruncated = true;
+		return [result];
+	});
+}
+function itemToolError(item, status, outputTextByItem) {
+	if (status === "blocked") return "codex native tool blocked";
+	if (status !== "failed") return;
+	return itemOutputText(item, outputTextByItem) ?? "codex native tool failed";
+}
+function itemMeta(item, detailMode = "explain") {
+	if (item.type === "commandExecution" && typeof item.command === "string") return inferToolMetaFromArgs("exec", {
+		command: item.command,
+		cwd: typeof item.cwd === "string" ? item.cwd : void 0
+	}, { detailMode });
+	if (item.type === "webSearch") return inferToolMetaFromArgs("web_search", webSearchToolArgs(item), { detailMode });
+	const toolName = itemName(item);
+	if ((item.type === "dynamicToolCall" || item.type === "mcpToolCall") && toolName) return inferToolMetaFromArgs(toolName, item.arguments, { detailMode });
+}
+function itemOutputText(item, outputTextByItem) {
+	if (item.type === "commandExecution") {
+		const output = item.aggregatedOutput?.trim() || outputTextByItem?.get(item.id)?.trim();
+		return output ? truncateToolTranscriptText(output) : void 0;
+	}
+	if (item.type === "dynamicToolCall") {
+		const output = collectDynamicToolContentText(item.contentItems).trim();
+		return output ? truncateToolTranscriptText(output) : void 0;
+	}
+	if (item.type === "mcpToolCall") {
+		const output = item.error ? stringifyJsonValue(item.error) : item.result ? stringifyJsonValue(item.result) : void 0;
+		return output ? truncateToolTranscriptText(output) : void 0;
+	}
+}
+function itemTranscriptResultText(item, outputTextByItem) {
+	const output = itemOutputText(item, outputTextByItem);
+	if (output) return output;
+	const result = itemToolResult(item).result;
+	const resultText = result ? stringifyJsonValue(result) : void 0;
+	return resultText ? truncateToolTranscriptText(resultText) : itemStatus(item);
+}
+function stringifyJsonValue(value) {
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-tool-progress.ts
+const TRANSCRIPT_PROGRESS_SUPPRESSED_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"message",
+	"messages",
+	"reply",
+	"send",
+	"reaction",
+	"react",
+	"typing"
+]);
+function shouldEmitTranscriptToolProgress(toolName, _args) {
+	const normalized = typeof toolName === "string" ? toolName.trim().toLowerCase() : "";
+	return Boolean(normalized && !TRANSCRIPT_PROGRESS_SUPPRESSED_TOOL_NAMES.has(normalized));
+}
+var CodexToolProgressProjection = class {
+	constructor(params) {
+		this.params = params;
+		this.echoesByItem = /* @__PURE__ */ new Map();
+		this.resultSummaryItemIds = /* @__PURE__ */ new Set();
+		this.resultOutputItemIds = /* @__PURE__ */ new Set();
+		this.resultOutputStreamedItemIds = /* @__PURE__ */ new Set();
+		this.transcriptProgressSuppressedIds = /* @__PURE__ */ new Set();
+		this.transcriptArgumentsById = /* @__PURE__ */ new Map();
+		this.resultOutputDeltaState = /* @__PURE__ */ new Map();
+		this.output = new ToolOutputAccumulator();
+		this.metas = /* @__PURE__ */ new Map();
+		this.sideEffectingNativeIds = /* @__PURE__ */ new Set();
+		this.sideEffectingDynamicIds = /* @__PURE__ */ new Set();
+		this.transcriptProgressCallIds = /* @__PURE__ */ new Set();
+	}
+	get outputTextByItem() {
+		return this.output.textByItem;
+	}
+	get toolMetas() {
+		return [...this.metas.values()];
+	}
+	getToolMeta(itemId) {
+		return this.metas.get(itemId);
+	}
+	get lastToolError() {
+		return this.lastNativeToolError;
+	}
+	get hasPotentialSideEffects() {
+		return this.sideEffectingNativeIds.size > 0 || this.sideEffectingDynamicIds.size > 0;
+	}
+	setLastToolError(error) {
+		if (!error) {
+			this.lastNativeToolError = void 0;
+			return;
+		}
+		const terminalResolution = this.params.observeToolTerminal?.({
+			toolName: error.toolName,
+			...error.meta ? { meta: error.meta } : {},
+			outcome: "failure",
+			failure: {
+				...error.errorCode ? { errorCode: error.errorCode } : {},
+				...error.error ? { error: error.error } : {},
+				...error.validationErrorSummary ? { validationErrorSummary: error.validationErrorSummary } : {},
+				...error.timedOut ? { timedOut: true } : {},
+				...error.middlewareError ? { middlewareError: true } : {}
+			},
+			nativeMutation: {
+				mutatingAction: error.mutatingAction === true,
+				replaySafe: error.mutatingAction !== true,
+				...error.actionFingerprint ? { actionFingerprint: error.actionFingerprint } : {},
+				...error.fileTarget ? { fileTarget: error.fileTarget } : {}
+			}
+		});
+		this.lastNativeToolError = terminalResolution?.lastToolError ?? (this.lastNativeToolError?.mutatingAction && error.mutatingAction !== true ? this.lastNativeToolError : error);
+	}
+	recordDynamicToolResult(params) {
+		const resultText = collectDynamicToolContentText(params.contentItems);
+		const existing = this.metas.get(params.callId);
+		this.metas.set(params.callId, {
+			toolName: existing?.toolName ?? params.tool,
+			...existing?.meta ? { meta: existing.meta } : {},
+			...params.asyncStarted === true ? { asyncStarted: true } : {},
+			...!params.success ? { isError: true } : {}
+		});
+		if (params.terminalResolution) this.lastNativeToolError = params.terminalResolution.lastToolError;
+		else if (!params.success) this.lastNativeToolError = {
+			toolName: params.tool,
+			error: resultText || (params.terminalType === "blocked" ? "codex dynamic tool blocked" : "codex dynamic tool failed")
+		};
+		else if (this.lastNativeToolError?.mutatingAction !== true) this.lastNativeToolError = void 0;
+		if (params.sideEffectEvidence === true) this.sideEffectingDynamicIds.add(params.callId);
+	}
+	handleOutputDelta(params, toolName) {
+		const itemId = readString$5(params, "itemId");
+		const delta = readString$5(params, "delta");
+		if (!itemId || !delta) return;
+		const storedOutput = this.output.append(itemId, delta);
+		this.rememberEcho(itemId, {
+			displayText: storedOutput.text,
+			rawLength: storedOutput.normalizedLength,
+			rawPrefix: storedOutput.rawPrefix,
+			streamedDisplay: true
+		});
+		if (!this.shouldEmitToolOutput()) return;
+		if (this.transcriptProgressSuppressedIds.has(itemId) || !shouldEmitTranscriptToolProgress(toolName, this.transcriptArgumentsById.get(itemId))) return;
+		const state = this.resultOutputDeltaState.get(itemId) ?? {
+			chars: 0,
+			messages: 0,
+			truncated: false
+		};
+		if (state.truncated) return;
+		const remainingChars = Math.max(0, TOOL_PROGRESS_OUTPUT_MAX_CHARS - state.chars);
+		const remainingMessages = Math.max(0, 20 - state.messages);
+		if (remainingChars === 0 || remainingMessages === 0) {
+			state.truncated = true;
+			this.resultOutputDeltaState.set(itemId, state);
+			this.emitToolResultMessage({
+				itemId,
+				text: formatToolOutput(toolName, void 0, "(output truncated)")
+			});
+			return;
+		}
+		const chunk = delta.length > remainingChars ? truncateUtf16Safe(delta, remainingChars) : delta;
+		state.chars += chunk.length;
+		state.messages += 1;
+		const reachedLimit = delta.length > remainingChars || state.chars >= TOOL_PROGRESS_OUTPUT_MAX_CHARS || state.messages >= 20;
+		if (reachedLimit) state.truncated = true;
+		this.resultOutputDeltaState.set(itemId, state);
+		this.resultOutputStreamedItemIds.add(itemId);
+		this.emitToolResultMessage({
+			itemId,
+			text: formatToolOutput(toolName, void 0, reachedLimit ? `${chunk}\n...(truncated)...` : chunk)
+		});
+	}
+	recordNativeToolError(params) {
+		const executionStarted = params.status !== "blocked";
+		const mutatingAction = executionStarted && isMutatingNativeToolItem(params.item);
+		const actionFingerprint = mutatingAction ? nativeToolActionFingerprint(params.item) : void 0;
+		const isFailure = isNonSuccessItemStatus(params.status);
+		const error = isFailure ? itemToolError(params.item, params.status, this.output.textByItem) : void 0;
+		const terminalResolution = this.params.observeToolTerminal?.({
+			toolCallId: params.item.id,
+			toolName: params.name,
+			arguments: itemToolArgs(params.item),
+			...params.meta ? { meta: params.meta } : {},
+			executionStarted,
+			outcome: isFailure ? "failure" : "success",
+			...isFailure ? { failure: error ? { error } : {} } : {},
+			nativeMutation: {
+				mutatingAction,
+				replaySafe: !mutatingAction,
+				...actionFingerprint ? { actionFingerprint } : {}
+			}
+		});
+		if (terminalResolution) {
+			this.lastNativeToolError = terminalResolution.lastToolError;
+			return;
+		}
+		if (isFailure) this.lastNativeToolError = {
+			toolName: params.name,
+			...params.meta ? { meta: params.meta } : {},
+			...error ? { error } : {},
+			...mutatingAction ? { mutatingAction: true } : {},
+			...actionFingerprint ? { actionFingerprint } : {}
+		};
+		else if (this.lastNativeToolError?.mutatingAction !== true) this.lastNativeToolError = void 0;
+	}
+	emitToolResultSummary(item) {
+		if (!item || !this.params.onToolResult || !this.shouldEmitToolResult()) return;
+		if (this.resultSummaryItemIds.has(item.id)) return;
+		const toolName = itemName(item);
+		if (!toolName || !shouldEmitTranscriptToolProgress(toolName, itemToolArgs(item))) return;
+		this.resultSummaryItemIds.add(item.id);
+		this.emitToolResultMessage({
+			itemId: item.id,
+			text: formatToolSummary(toolName, itemMeta(item, this.toolProgressDetailMode()))
+		});
+	}
+	emitToolResultOutput(item) {
+		if (!item || !this.params.onToolResult || !this.shouldEmitToolOutput()) return;
+		if (this.resultOutputItemIds.has(item.id) || this.resultOutputStreamedItemIds.has(item.id)) return;
+		const toolName = itemName(item);
+		const output = itemOutputText(item, this.output.textByItem);
+		if (!toolName || !output || !shouldEmitTranscriptToolProgress(toolName, itemToolArgs(item))) return;
+		this.emitToolResultMessage({
+			itemId: item.id,
+			text: formatToolOutput(toolName, itemMeta(item, this.toolProgressDetailMode()), output),
+			finalOutput: true,
+			isError: isNonSuccessItemStatus(itemStatus(item))
+		});
+	}
+	recordToolMeta(item) {
+		if (!item) return;
+		if (isSideEffectingNativeToolItem(item)) this.sideEffectingNativeIds.add(item.id);
+		else this.sideEffectingNativeIds.delete(item.id);
+		const toolName = itemName(item);
+		if (!toolName) return;
+		const meta = itemMeta(item, this.toolProgressDetailMode());
+		const status = itemStatus(item);
+		const existing = this.metas.get(item.id);
+		this.metas.set(item.id, {
+			toolName,
+			...meta ? { meta } : {},
+			...existing?.asyncStarted ? { asyncStarted: true } : {},
+			...status !== "running" && isNonSuccessItemStatus(status) ? { isError: true } : {}
+		});
+	}
+	recordTranscriptCall(params) {
+		this.transcriptArgumentsById.set(params.id, params.arguments);
+		if (!shouldEmitTranscriptToolProgress(params.name, params.arguments)) this.transcriptProgressSuppressedIds.add(params.id);
+		else this.transcriptProgressSuppressedIds.delete(params.id);
+		this.emitTranscriptToolCallProgress(params);
+	}
+	recordTranscriptResult(params) {
+		this.emitTranscriptToolResultProgress(params);
+	}
+	matchesEcho(text) {
+		for (const state of this.echoesByItem.values()) {
+			if (state.streamedDisplayText === text || state.displayTexts.includes(text)) return true;
+			if (state.streamedRawSignature && text.length === state.streamedRawSignature.length && text.startsWith(state.streamedRawSignature.prefix)) return true;
+			for (const signature of state.rawSignatures) if (text.length === signature.length && text.startsWith(signature.prefix)) return true;
+		}
+		return false;
+	}
+	rememberCommandAggregateOutputEcho(item) {
+		if (item?.type !== "commandExecution" || typeof item.aggregatedOutput !== "string") return;
+		const signature = toolOutputRawEchoSignature(item.aggregatedOutput);
+		if (signature) this.rememberEcho(item.id, signature);
+	}
+	toolProgressDetailMode() {
+		return resolveCodexToolProgressDetailMode(this.params.toolProgressDetail);
+	}
+	emitToolResultMessage(params) {
+		const rawText = params.text.trim();
+		const text = truncateToolTranscriptText(rawText);
+		if (!text) return;
+		this.rememberEcho(params.itemId, {
+			displayText: text,
+			rawText
+		});
+		if (params.finalOutput) this.resultOutputItemIds.add(params.itemId);
+		try {
+			Promise.resolve(this.params.onToolResult?.({
+				text,
+				...params.isError === true ? { isError: true } : {}
+			})).catch(() => {});
+		} catch {}
+	}
+	shouldEmitToolResult() {
+		return typeof this.params.shouldEmitToolResult === "function" ? this.params.shouldEmitToolResult() : this.params.verboseLevel === "on" || this.params.verboseLevel === "full";
+	}
+	shouldEmitToolOutput() {
+		return typeof this.params.shouldEmitToolOutput === "function" ? this.params.shouldEmitToolOutput() : this.params.verboseLevel === "full";
+	}
+	emitTranscriptToolCallProgress(params) {
+		if (!shouldEmitTranscriptToolProgress(params.name, params.arguments)) return;
+		this.transcriptProgressCallIds.add(params.id);
+		const args = normalizeToolTranscriptArguments(params.arguments);
+		const meta = inferToolMetaFromArgs(params.name, args, { detailMode: this.toolProgressDetailMode() });
+		if (!this.params.onToolResult || !this.shouldEmitToolResult() || this.resultSummaryItemIds.has(params.id) || this.resultOutputStreamedItemIds.has(params.id)) return;
+		this.resultSummaryItemIds.add(params.id);
+		this.emitToolResultMessage({
+			itemId: params.id,
+			text: formatToolSummary(params.name, meta)
+		});
+	}
+	emitTranscriptToolResultProgress(params) {
+		if (this.transcriptProgressSuppressedIds.has(params.id) || !shouldEmitTranscriptToolProgress(params.name, this.transcriptArgumentsById.get(params.id))) return;
+		if (!this.transcriptProgressCallIds.has(params.id)) this.emitTranscriptToolCallProgress({
+			id: params.id,
+			name: params.name,
+			arguments: {}
+		});
+		if (!this.params.onToolResult || !this.shouldEmitToolOutput() || this.resultOutputItemIds.has(params.id) || this.resultOutputStreamedItemIds.has(params.id)) return;
+		const text = params.text?.trim();
+		if (text) this.emitToolResultMessage({
+			itemId: params.id,
+			text: formatToolOutput(params.name, void 0, text),
+			finalOutput: true,
+			isError: params.isError
+		});
+	}
+	rememberEcho(itemId, signature) {
+		if (!itemId) return;
+		const existing = this.echoesByItem.get(itemId) ?? {
+			displayTexts: [],
+			rawSignatures: []
+		};
+		const displayText = signature.displayText?.trim();
+		if (displayText) {
+			if (signature.streamedDisplay) existing.streamedDisplayText = displayText;
+			else if (!existing.displayTexts.includes(displayText)) {
+				if (existing.displayTexts.length >= 24) existing.displayTexts.shift();
+				existing.displayTexts.push(displayText);
+			}
+		}
+		const rawText = signature.rawText?.trim();
+		const rawLength = signature.rawLength ?? rawText?.length;
+		const rawPrefix = signature.rawPrefix?.trim() ?? rawText;
+		if (rawLength !== void 0 && rawPrefix && rawPrefix.length >= 1024) {
+			const next = {
+				length: rawLength,
+				prefix: rawPrefix.slice(0, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS)
+			};
+			if (signature.streamedDisplay) existing.streamedRawSignature = next;
+			else {
+				const matchIndex = existing.rawSignatures.findIndex((entry) => entry.prefix === next.prefix);
+				if (matchIndex >= 0) existing.rawSignatures[matchIndex] = next;
+				else {
+					if (existing.rawSignatures.length >= 24) existing.rawSignatures.shift();
+					existing.rawSignatures.push(next);
+				}
+			}
+		}
+		this.echoesByItem.set(itemId, existing);
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/session-history.ts
+/**
+* Reads OpenClaw session history for Codex transcript mirroring and sanitizes
+* image payloads before replaying messages into the app-server projector.
+*/
+function isMissingFileError(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+/** Returns sanitized session-context messages for a Codex mirrored session file. */
+async function readCodexMirroredSessionHistoryMessages(target) {
+	try {
+		const entries = await readCodexMirroredSessionEntries(target);
+		if (entries.length === 0) return [];
+		const firstEntry = entries[0];
+		if (firstEntry?.type !== "session") return [];
+		if (typeof firstEntry.id !== "string") return;
+		migrateSessionEntries(entries);
+		return sanitizeCodexHistoryImagePayloads(buildSessionContext(entries.filter((entry) => {
+			return entry !== null && typeof entry === "object" && !Array.isArray(entry) && entry.type !== "session";
+		})).messages, "codex mirrored history");
+	} catch (error) {
+		if (isMissingFileError(error)) return [];
+		return;
+	}
+}
+async function readCodexMirroredSessionEntries(target) {
+	const sqliteMarker = parseSqliteSessionFileMarker(target.sessionFile);
+	if (sqliteMarker) {
+		if (sqliteMarker.sessionId !== target.sessionId || target.agentId !== void 0 && sqliteMarker.agentId !== target.agentId) return [];
+		const sessionKey = resolveSqliteMarkerSessionKey(target, sqliteMarker);
+		if (!sessionKey) return [];
+		return await readSessionTranscriptEvents({
+			agentId: sqliteMarker.agentId,
+			sessionId: sqliteMarker.sessionId,
+			sessionKey,
+			storePath: sqliteMarker.storePath
+		});
+	}
+	return parseSessionEntries(await fs.readFile(target.sessionFile, "utf-8"));
+}
+function resolveSqliteMarkerSessionKey(target, marker) {
+	const explicitSessionKey = target.sessionKey?.trim();
+	if (explicitSessionKey) return explicitSessionKey;
+	const entries = listSessionEntries({
+		agentId: marker.agentId,
+		readOnly: true,
+		storePath: marker.storePath
+	});
+	return (entries.find(({ entry }) => {
+		return entry.sessionId === marker.sessionId && entry.sessionFile === target.sessionFile;
+	}) ?? entries.find(({ entry }) => {
+		return entry.sessionId === marker.sessionId;
+	}))?.sessionKey;
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-tool-transcript.ts
+const ZERO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+const MISSING_TOOL_RESULT_ERROR = "OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.";
+var CodexToolTranscriptProjection = class {
+	constructor(params, threadId, turnId, progress, nextTranscriptTimestamp, options = {}) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.progress = progress;
+		this.nextTranscriptTimestamp = nextTranscriptTimestamp;
+		this.options = options;
+		this.messages = [];
+		this.callIds = /* @__PURE__ */ new Set();
+		this.resultIds = /* @__PURE__ */ new Set();
+		this.namesById = /* @__PURE__ */ new Map();
+		this.trajectoryCallIds = /* @__PURE__ */ new Set();
+		this.trajectoryResultIds = /* @__PURE__ */ new Set();
+		this.trajectoryNamesById = /* @__PURE__ */ new Map();
+		this.trajectoryItemsById = /* @__PURE__ */ new Map();
+		this.afterToolCallObservedItemIds = /* @__PURE__ */ new Set();
+	}
+	get transcriptMessages() {
+		return this.messages;
+	}
+	recordDynamicToolCall(params) {
+		this.recordToolCall({
+			id: params.callId,
+			name: params.tool,
+			arguments: sanitizeCodexToolArguments(params.arguments)
+		});
+	}
+	recordDynamicToolResult(params) {
+		this.recordToolResult({
+			id: params.callId,
+			name: params.tool,
+			text: collectDynamicToolContentText(params.contentItems),
+			isError: !params.success
+		});
+	}
+	recordNativeToolCall(item) {
+		if (!item || !shouldRecordNativeToolTranscript(item)) return;
+		const name = itemName(item);
+		if (name) this.recordToolCall({
+			id: item.id,
+			name,
+			arguments: itemToolArgs(item)
+		});
+	}
+	recordNativeToolResult(item) {
+		if (!item || !shouldRecordNativeToolTranscript(item)) return;
+		const name = itemName(item);
+		if (name) this.recordToolResult({
+			id: item.id,
+			name,
+			text: itemTranscriptResultText(item, this.progress.outputTextByItem),
+			isError: isNonSuccessItemStatus(itemStatus(item))
+		});
+	}
+	recordTrajectoryEvent(params) {
+		if (params.phase === "start") {
+			this.trajectoryCallIds.add(params.item.id);
+			this.trajectoryNamesById.set(params.item.id, params.name);
+			this.trajectoryItemsById.set(params.item.id, params.item);
+			this.options.trajectoryRecorder?.recordEvent("tool.call", {
+				threadId: this.threadId,
+				turnId: this.turnId,
+				itemId: params.item.id,
+				toolCallId: params.item.id,
+				name: params.name,
+				arguments: params.args
+			});
+			return;
+		}
+		this.trajectoryResultIds.add(params.item.id);
+		const toolResult = itemToolResult(params.item).result;
+		const output = itemOutputText(params.item, this.progress.outputTextByItem);
+		this.options.trajectoryRecorder?.recordEvent("tool.result", {
+			threadId: this.threadId,
+			turnId: this.turnId,
+			itemId: params.item.id,
+			toolCallId: params.item.id,
+			name: params.name,
+			status: params.status,
+			isError: isNonSuccessItemStatus(params.status),
+			...toolResult ? { result: toolResult } : {},
+			...output ? { output } : {}
+		});
+	}
+	emitAfterToolCallObservation(item) {
+		if (!this.shouldEmitAfterToolCallObservation(item)) return;
+		const name = itemName(item);
+		const status = itemStatus(item);
+		if (!name || status === "running") return;
+		this.afterToolCallObservedItemIds.add(item.id);
+		const result = itemToolResult(item).result;
+		const error = itemToolError(item, status, this.progress.outputTextByItem);
+		const startedAt = resolveStartedAtFromDurationMs(item.durationMs);
+		const hookParams = {
+			toolName: name,
+			toolCallId: item.id,
+			runId: this.params.runId,
+			agentId: this.params.agentId,
+			sessionId: this.params.sessionId,
+			sessionKey: this.params.sessionKey,
+			startArgs: itemToolArgs(item) ?? {},
+			...result !== void 0 ? { result } : {},
+			...error ? { error } : {},
+			...startedAt !== void 0 ? { startedAt } : {}
+		};
+		setImmediate(() => {
+			runAgentHarnessAfterToolCallHook(hookParams);
+		});
+	}
+	synthesizeMissingToolResults(params) {
+		if (!params.synthesize) return;
+		const missingTranscriptIds = [...this.callIds].filter((id) => !this.resultIds.has(id));
+		const missingTrajectoryIds = [...this.trajectoryCallIds].filter((id) => !this.trajectoryResultIds.has(id));
+		if (missingTranscriptIds.length === 0 && missingTrajectoryIds.length === 0) return;
+		for (const id of missingTranscriptIds) {
+			const name = this.namesById.get(id) ?? this.trajectoryNamesById.get(id);
+			if (name) this.recordToolResult({
+				id,
+				name,
+				text: formatMissingToolResultError({
+					id,
+					name
+				}),
+				isError: true
+			});
+		}
+		for (const id of missingTrajectoryIds) {
+			const name = this.trajectoryNamesById.get(id) ?? this.namesById.get(id);
+			if (!name) continue;
+			this.trajectoryResultIds.add(id);
+			const text = formatMissingToolResultError({
+				id,
+				name
+			});
+			this.options.trajectoryRecorder?.recordEvent("tool.result", {
+				threadId: this.threadId,
+				turnId: this.turnId,
+				itemId: id,
+				toolCallId: id,
+				name,
+				status: "failed",
+				isError: true,
+				result: {
+					status: "failed",
+					reason: "missing_tool_result"
+				},
+				output: text
+			});
+		}
+		if (!params.recordPromptError) {
+			this.recordMissingToolError(missingTranscriptIds, missingTrajectoryIds);
+			return;
+		}
+		const missingCount = (/* @__PURE__ */ new Set([...missingTranscriptIds, ...missingTrajectoryIds])).size;
+		return missingCount === 1 ? MISSING_TOOL_RESULT_ERROR : `${MISSING_TOOL_RESULT_ERROR} missingToolResultCount=${missingCount}`;
+	}
+	async readMirroredSessionMessages() {
+		return await readCodexMirroredSessionHistoryMessages({
+			agentId: this.params.agentId,
+			sessionFile: this.params.sessionFile,
+			sessionId: this.params.sessionId,
+			sessionKey: this.params.sessionKey
+		}) ?? [];
+	}
+	recordToolCall(params) {
+		if (!params.id || !params.name || this.callIds.has(params.id)) return;
+		this.callIds.add(params.id);
+		this.namesById.set(params.id, params.name);
+		this.progress.recordTranscriptCall(params);
+		this.messages.push(attachCodexMirrorIdentity(this.createToolCallMessage(params), `${this.turnId}:tool:${params.id}:call`));
+	}
+	recordToolResult(params) {
+		if (!params.id || !params.name || this.resultIds.has(params.id)) return;
+		this.resultIds.add(params.id);
+		this.progress.recordTranscriptResult(params);
+		this.messages.push(attachCodexMirrorIdentity(this.createToolResultMessage(params), `${this.turnId}:tool:${params.id}:result`));
+	}
+	recordMissingToolError(missingTranscriptIds, missingTrajectoryIds) {
+		const firstMissingId = missingTranscriptIds.find((id) => Boolean(this.namesById.get(id))) ?? missingTrajectoryIds.find((id) => Boolean(this.trajectoryNamesById.get(id) ?? this.namesById.get(id)));
+		if (!firstMissingId) return;
+		const name = this.namesById.get(firstMissingId) ?? this.trajectoryNamesById.get(firstMissingId);
+		if (!name) return;
+		const item = this.trajectoryItemsById.get(firstMissingId);
+		const meta = item ? itemMeta(item, this.progress.toolProgressDetailMode()) : this.progress.getToolMeta(firstMissingId)?.meta;
+		const actionFingerprint = item ? nativeToolActionFingerprint(item) : void 0;
+		this.progress.setLastToolError({
+			toolName: name,
+			...meta ? { meta } : {},
+			error: formatMissingToolResultError({
+				id: firstMissingId,
+				name
+			}),
+			...item && isMutatingNativeToolItem(item) ? { mutatingAction: true } : {},
+			...actionFingerprint ? { actionFingerprint } : {}
+		});
+	}
+	shouldEmitAfterToolCallObservation(item) {
+		if (!shouldSynthesizeToolProgressForItem(item) || this.afterToolCallObservedItemIds.has(item.id)) return false;
+		return !(this.options.nativePostToolUseRelayEnabled && isNativePostToolUseRelayItem(item));
+	}
+	createToolCallMessage(params) {
+		const args = normalizeToolTranscriptArguments(params.arguments);
+		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
+		return {
+			role: "assistant",
+			content: [{
+				type: "toolCall",
+				id: params.id,
+				name: params.name,
+				arguments: args,
+				input: args
+			}],
+			api: attribution.api ?? "openai-chatgpt-responses",
+			provider: attribution.provider,
+			model: this.params.modelId,
+			usage: ZERO_USAGE,
+			stopReason: "toolUse",
+			timestamp: this.nextTranscriptTimestamp()
+		};
+	}
+	createToolResultMessage(params) {
+		const text = truncateToolTranscriptText(params.text?.trim() || toolResultStatusText(params));
+		return {
+			role: "toolResult",
+			toolCallId: params.id,
+			toolName: params.name,
+			isError: params.isError,
+			content: [{
+				type: "toolResult",
+				id: params.id,
+				name: params.name,
+				toolName: params.name,
+				toolCallId: params.id,
+				toolUseId: params.id,
+				tool_use_id: params.id,
+				content: text,
+				text
+			}],
+			timestamp: this.nextTranscriptTimestamp()
+		};
+	}
+};
+function formatMissingToolResultError(params) {
+	return `${MISSING_TOOL_RESULT_ERROR} toolCallId=${params.id}; toolName=${params.name}`;
+}
+function toolResultStatusText(params) {
+	return params.isError ? `${params.name} failed` : `${params.name} completed`;
+}
+function resolveStartedAtFromDurationMs(durationMs) {
+	if (typeof durationMs !== "number" || !Number.isFinite(durationMs)) return;
+	return asDateTimestampMs(Date.now() - Math.max(0, durationMs));
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-events.ts
+var CodexEventProjection = class {
+	constructor(threadId, turnId, emitAgentEvent, toolProgress, toolTranscript, onNativeToolResultRecorded) {
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.emitAgentEvent = emitAgentEvent;
+		this.toolProgress = toolProgress;
+		this.toolTranscript = toolTranscript;
+		this.onNativeToolResultRecorded = onNativeToolResultRecorded;
+		this.reviewCount = 0;
+	}
+	get guardianReviewCount() {
+		return this.reviewCount;
+	}
+	handleGuardianReview(method, params) {
+		this.reviewCount += 1;
+		const review = isJsonObject(params.review) ? params.review : void 0;
+		const action = isJsonObject(params.action) ? params.action : void 0;
+		this.emitAgentEvent({
+			stream: "codex_app_server.guardian",
+			data: {
+				method,
+				phase: method.endsWith("/started") ? "started" : "completed",
+				reviewId: readString$5(params, "reviewId"),
+				targetItemId: readNullableString$1(params, "targetItemId"),
+				decisionSource: readString$5(params, "decisionSource"),
+				status: review ? readString$5(review, "status") : void 0,
+				riskLevel: review ? readString$5(review, "riskLevel") : void 0,
+				userAuthorization: review ? readString$5(review, "userAuthorization") : void 0,
+				rationale: review ? readNullableString$1(review, "rationale") : void 0,
+				actionType: action ? readString$5(action, "type") : void 0
+			}
+		});
+	}
+	handleGuardianWarning(params) {
+		this.emitAgentEvent({
+			stream: "codex_app_server.guardian",
+			data: {
+				phase: "warning",
+				message: readString$5(params, "message")
+			}
+		});
+	}
+	handleHook(method, params) {
+		const run = isJsonObject(params.run) ? params.run : void 0;
+		if (!run) return;
+		const durationMs = readNumber(run, "durationMs");
+		const entries = readHookOutputEntries(run.entries);
+		const hookTurnId = readNullableString$1(params, "turnId");
+		this.emitAgentEvent({
+			stream: "codex_app_server.hook",
+			data: {
+				phase: method === "hook/started" ? "started" : "completed",
+				threadId: this.threadId,
+				turnId: hookTurnId === void 0 ? this.turnId : hookTurnId,
+				hookRunId: readString$5(run, "id"),
+				eventName: readString$5(run, "eventName"),
+				handlerType: readString$5(run, "handlerType"),
+				executionMode: readString$5(run, "executionMode"),
+				scope: readString$5(run, "scope"),
+				source: readString$5(run, "source"),
+				sourcePath: readString$5(run, "sourcePath"),
+				status: readString$5(run, "status"),
+				statusMessage: readNullableString$1(run, "statusMessage"),
+				...durationMs !== void 0 ? { durationMs } : {},
+				...entries.length > 0 ? { entries } : {}
+			}
+		});
+	}
+	emitStandardItemEvent(params) {
+		const { item } = params;
+		if (!item) return;
+		const kind = itemKind(item);
+		if (!kind) return;
+		const meta = itemMeta(item, this.toolProgress.toolProgressDetailMode());
+		const suppressChannelProgress = shouldSuppressChannelProgressForItem(item);
+		this.emitAgentEvent({
+			stream: "item",
+			data: {
+				itemId: item.id,
+				phase: params.phase,
+				kind,
+				title: itemTitle(item),
+				status: params.phase === "start" ? "running" : itemStatus(item),
+				...itemName(item) ? { name: itemName(item) } : {},
+				...meta ? { meta } : {},
+				...suppressChannelProgress ? { suppressChannelProgress: true } : {}
+			}
+		});
+	}
+	async emitNormalizedToolItemEvent(params) {
+		const { item } = params;
+		if (!item || !shouldSynthesizeToolProgressForItem(item)) return;
+		const name = itemName(item);
+		if (!name) return;
+		const status = params.phase === "result" ? itemStatus(item) : "running";
+		const args = itemToolArgs(item);
+		const meta = itemMeta(item, this.toolProgress.toolProgressDetailMode());
+		this.toolTranscript.recordTrajectoryEvent({
+			phase: params.phase,
+			item,
+			name,
+			args,
+			status
+		});
+		if (params.phase === "result") this.toolProgress.recordNativeToolError({
+			item,
+			name,
+			meta,
+			status
+		});
+		if (!shouldEmitTranscriptToolProgress(name, args)) {
+			if (params.phase === "result") {
+				this.toolTranscript.emitAfterToolCallObservation(item);
+				await this.onNativeToolResultRecorded?.();
+			}
+			return;
+		}
+		this.emitAgentEvent({
+			stream: "tool",
+			data: {
+				phase: params.phase,
+				name,
+				itemId: item.id,
+				toolCallId: item.id,
+				...meta ? { meta } : {},
+				...params.phase === "start" && args ? { args } : {},
+				...params.phase === "result" ? {
+					status,
+					isError: isNonSuccessItemStatus(status),
+					...itemToolResult(item)
+				} : {}
+			}
+		});
+		if (params.phase === "result") {
+			this.toolTranscript.emitAfterToolCallObservation(item);
+			await this.onNativeToolResultRecorded?.();
+		}
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-media.ts
+const GENERATED_IMAGE_MEDIA_SUBDIR = "tool-image-generation";
+const BYTES_PER_MB = 1024 * 1024;
+const DEFAULT_GENERATED_IMAGE_MAX_BYTES = 6 * BYTES_PER_MB;
+var CodexGeneratedMediaProjection = class {
+	constructor(config) {
+		this.config = config;
+		this.itemIds = /* @__PURE__ */ new Set();
+		this.urlsByItemId = /* @__PURE__ */ new Map();
+	}
+	hasGeneratedMedia() {
+		return this.itemIds.size > 0;
+	}
+	recordNative(item) {
+		if (item?.type !== "imageGeneration") return;
+		const savedPath = readItemString(item, "savedPath")?.trim();
+		if (savedPath) this.recordUrl({
+			itemId: item.id,
+			mediaUrl: savedPath
+		});
+	}
+	async recordRaw(item) {
+		if (readString$5(item, "type") !== "image_generation_call") return;
+		const result = readString$5(item, "result");
+		if (!result) return;
+		const itemId = readString$5(item, "id") ?? `raw-image-${this.itemIds.size}`;
+		this.itemIds.add(itemId);
+		const maxBytes = resolveGeneratedImageMaxBytes(this.config);
+		const estimatedDecodedBytes = estimateBase64DecodedBytes(result);
+		if (estimatedDecodedBytes !== void 0 && estimatedDecodedBytes > maxBytes) {
+			embeddedAgentLog.warn("codex app-server raw image generation result exceeds media limit", {
+				itemId,
+				estimatedDecodedBytes,
+				maxBytes
+			});
+			return;
+		}
+		const asset = generatedImageAssetFromBase64({
+			base64: result,
+			index: this.itemIds.size,
+			revisedPrompt: readString$5(item, "revised_prompt") ?? readString$5(item, "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.recordUrl({
+				itemId,
+				mediaUrl: saved.path,
+				replaceExisting: true
+			});
+		} catch (error) {
+			embeddedAgentLog.warn("codex app-server raw image generation result save failed", {
+				itemId,
+				error
+			});
+		}
+	}
+	buildToolMediaUrls(params) {
+		const mediaUrls = new Set(params.toolMediaUrls?.map((url) => url.trim()).filter(Boolean) ?? []);
+		if ((params.messagingToolSentMediaUrls?.length ?? 0) === 0) for (const mediaUrl of this.urlsByItemId.values()) mediaUrls.add(mediaUrl);
+		return mediaUrls.size > 0 ? [...mediaUrls] : params.toolMediaUrls;
+	}
+	buildHostOwnedMediaUrls(params) {
+		if ((params.messagingToolSentMediaUrls?.length ?? 0) > 0) return;
+		const mediaUrls = [...this.urlsByItemId.values()];
+		return mediaUrls.length > 0 ? mediaUrls : void 0;
+	}
+	recordUrl(params) {
+		if (this.urlsByItemId.has(params.itemId) && params.replaceExisting !== true) {
+			this.itemIds.add(params.itemId);
+			return;
+		}
+		this.urlsByItemId.set(params.itemId, params.mediaUrl);
+		this.itemIds.add(params.itemId);
+	}
+};
+function estimateBase64DecodedBytes(base64) {
+	let nonWhitespaceLength = 0;
+	let previousCode = -1;
+	let lastCode = -1;
+	for (let i = 0; i < base64.length; i += 1) {
+		const code = base64.charCodeAt(i);
+		if (isBase64WhitespaceCode(code)) continue;
+		nonWhitespaceLength += 1;
+		previousCode = lastCode;
+		lastCode = code;
+	}
+	if (nonWhitespaceLength === 0) return;
+	const equalsCode = "=".charCodeAt(0);
+	const padding = lastCode === equalsCode ? previousCode === equalsCode ? 2 : 1 : 0;
+	return Math.max(0, Math.floor(nonWhitespaceLength * 3 / 4) - padding);
+}
+function isBase64WhitespaceCode(code) {
+	return code === 32 || code === 9 || code === 10 || code === 13;
+}
+function resolveGeneratedImageMaxBytes(config) {
+	const configured = config?.agents?.defaults?.mediaMaxMb;
+	if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) return Math.floor(configured * BYTES_PER_MB);
+	return DEFAULT_GENERATED_IMAGE_MAX_BYTES;
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-reasoning.ts
+var CodexReasoningProjection = class {
+	constructor(params, emitAgentEvent) {
+		this.params = params;
+		this.emitAgentEvent = emitAgentEvent;
+		this.reasoningTextByGroup = /* @__PURE__ */ new Map();
+		this.reasoningItemOrder = /* @__PURE__ */ new Map();
+		this.planTextByItem = /* @__PURE__ */ new Map();
+		this.reasoningStarted = false;
+		this.reasoningEnded = false;
+	}
+	async handleReasoningDelta(method, params) {
+		const itemId = readString$5(params, "itemId") ?? "reasoning";
+		const delta = readString$5(params, "delta") ?? "";
+		if (!delta) return;
+		this.reasoningStarted = true;
+		if (!this.reasoningItemOrder.has(itemId)) this.reasoningItemOrder.set(itemId, this.reasoningItemOrder.size);
+		const groupIndex = method === "item/reasoning/textDelta" ? readNonNegativeInteger(params, "contentIndex") ?? 0 : readNonNegativeInteger(params, "summaryIndex") ?? 0;
+		const groupKey = `${method}\0${itemId}\0${groupIndex}`;
+		const current = this.reasoningTextByGroup.get(groupKey);
+		this.reasoningTextByGroup.set(groupKey, {
+			itemId,
+			method,
+			index: groupIndex,
+			text: `${current?.text ?? ""}${delta}`
+		});
+		await this.params.onReasoningStream?.({
+			text: this.reasoningText(),
+			isReasoningSnapshot: true
+		});
+	}
+	handlePlanDelta(params) {
+		const itemId = readString$5(params, "itemId") ?? "plan";
+		const delta = readString$5(params, "delta") ?? "";
+		if (!delta) return;
+		const text = `${this.planTextByItem.get(itemId) ?? ""}${delta}`;
+		this.planTextByItem.set(itemId, text);
+		this.emitPlanUpdate({
+			explanation: void 0,
+			steps: splitPlanText(text).map((step) => ({
+				step,
+				status: "pending"
+			}))
+		});
+	}
+	handleTurnPlanUpdated(params) {
+		const explanation = readNullableString$1(params, "explanation");
+		const plan = Array.isArray(params.plan) ? params.plan.flatMap((entry) => {
+			if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
+			const record = entry;
+			const step = readString$5(record, "step");
+			if (!step) return [];
+			return [{
+				step,
+				status: normalizePlanStepStatus(readString$5(record, "status"))
+			}];
+		}) : void 0;
+		const planText = [explanation, ...(plan ?? []).map(({ step, status }) => `- [${status}] ${step}`)].filter((part) => Boolean(part)).join("\n");
+		if (planText) this.turnPlanText = planText;
+		this.emitPlanUpdate({
+			explanation,
+			steps: plan
+		});
+	}
+	recordItem(item) {
+		if (item?.type === "plan" && typeof item.text === "string" && item.text) {
+			this.planTextByItem.set(item.id, item.text);
+			this.emitPlanUpdate({
+				explanation: void 0,
+				steps: splitPlanText(item.text).map((step) => ({
+					step,
+					status: "pending"
+				}))
+			});
+		}
+	}
+	async maybeEndReasoning() {
+		if (!this.reasoningStarted || this.reasoningEnded) return;
+		this.reasoningEnded = true;
+		await this.params.onReasoningEnd?.();
+	}
+	reasoningText() {
+		return collectReasoningTextValues(this.reasoningTextByGroup, this.reasoningItemOrder).join("\n\n");
+	}
+	planText() {
+		return this.turnPlanText ?? [...this.planTextByItem.values()].filter((text) => text.trim().length > 0).join("\n\n");
+	}
+	emitPlanUpdate(params) {
+		if (!params.explanation && (!params.steps || params.steps.length === 0)) return;
+		this.emitAgentEvent({
+			stream: "plan",
+			data: {
+				phase: "update",
+				title: "Plan updated",
+				source: "codex-app-server",
+				...params.explanation ? { explanation: params.explanation } : {},
+				...params.steps && params.steps.length > 0 ? { steps: params.steps } : {}
+			}
+		});
+	}
+};
+function normalizePlanStepStatus(status) {
+	if (status === "inProgress" || status === "in_progress") return "in_progress";
+	return status === "completed" ? "completed" : "pending";
+}
+function collectReasoningTextValues(groups, itemOrder) {
+	return [...groups.values()].toSorted((left, right) => {
+		const itemDelta = (itemOrder.get(left.itemId) ?? Number.MAX_SAFE_INTEGER) - (itemOrder.get(right.itemId) ?? Number.MAX_SAFE_INTEGER);
+		if (itemDelta !== 0) return itemDelta;
+		const methodDelta = reasoningMethodOrder(left.method) - reasoningMethodOrder(right.method);
+		return methodDelta !== 0 ? methodDelta : left.index - right.index;
+	}).map((group) => group.text).filter((text) => text.trim().length > 0);
+}
+function reasoningMethodOrder(method) {
+	return method === "item/reasoning/summaryTextDelta" ? 0 : 1;
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-snapshot.ts
+function buildCodexMessagesSnapshot(params) {
+	const messages = promptSnapshot(params.runParams, params.turnId, params.upstreamUserText);
+	if (params.reasoningText) messages.push(attachCodexMirrorIdentity(params.createAssistantMirrorMessage("Codex reasoning", params.reasoningText), `${params.turnId}:reasoning`));
+	if (params.planText) messages.push(attachCodexMirrorIdentity(params.createAssistantMirrorMessage("Codex plan", params.planText), `${params.turnId}:plan`));
+	const visibleWorkMessages = [...params.runParams.config?.ui?.prefs?.chatPersistCommentary === false ? [] : params.commentaryMessages.map(({ itemId, message }) => attachCodexMirrorIdentity(message, `${params.turnId}:commentary:${itemId}`)), ...params.toolMessages].toSorted((left, right) => (asDateTimestampMs(left.timestamp) ?? 0) - (asDateTimestampMs(right.timestamp) ?? 0));
+	messages.push(...visibleWorkMessages);
+	if (params.lastAssistant) messages.push(attachCodexMirrorIdentity(params.lastAssistant, `${params.turnId}:assistant`));
+	return messages.map((message) => projectAgentHarnessTranscriptMessageForDisplay({
+		hidden: params.runParams.trigger === "memory",
+		message
+	}));
+}
+//#endregion
+//#region extensions/codex/src/app-server/usage-limit-error.ts
 /**
-* Bridges Codex item/tool user-input requests to OpenClaw messaging prompts and
-* turns replies into app-server answer payloads.
+* Enriches Codex usage-limit failures with current rate-limit information and
+* marks blocked auth profiles when Codex exposes a reset time.
 */
+const CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS = 5e3;
+function createCodexUsageLimitPromptError(message) {
+	return Object.assign(new Error(message), { status: 429 });
+}
+function isCodexUsageLimitPromptError(error) {
+	return error instanceof Error && "status" in error && error.status === 429;
+}
+/** Marks a Codex auth profile blocked until the reset time advertised by rate limits. */
+async function markCodexAuthProfileBlockedFromRateLimits(params) {
+	const authProfileId = params.authProfileId?.trim();
+	if (!authProfileId || !params.params.authProfileStore) return;
+	const blockedUntil = resolveCodexUsageLimitResetAtMs(params.rateLimits);
+	if (!blockedUntil) return;
+	try {
+		await markAuthProfileBlockedUntil({
+			store: params.params.authProfileStore,
+			profileId: authProfileId,
+			blockedUntil,
+			source: "codex_rate_limits",
+			agentDir: params.params.agentDir,
+			runId: params.params.runId,
+			modelId: params.params.modelId
+		});
+	} catch (error) {
+		embeddedAgentLog.debug("failed to mark Codex auth profile blocked from app-server limits", {
+			authProfileId,
+			error: formatErrorMessage(error)
+		});
+	}
+}
+/** Formats a turn-start usage-limit error, refreshing rate limits when needed. */
+async function formatCodexTurnStartUsageLimitError(params) {
+	return refreshCodexUsageLimitError({
+		client: params.client,
+		source: readCodexTurnStartUsageLimitErrorSource(params.client, params.error, params.errorNotification, params.rateLimitsRevisionBeforeTurnStart),
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+}
+/** Refreshes a generic prompt usage-limit message into a reset-aware message. */
+async function refreshCodexUsageLimitPromptError(params) {
+	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(params.message)) return;
+	return refreshCodexUsageLimitError({
+		client: params.client,
+		source: {
+			message: params.message,
+			codexErrorInfo: "usageLimitExceeded",
+			rateLimits: readRecentCodexRateLimits(params.client)
+		},
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+}
+async function refreshCodexUsageLimitError(params) {
+	const initialMessage = formatCodexUsageLimitErrorMessage(params.source);
+	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(initialMessage)) return initialMessage ? {
+		message: initialMessage,
+		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
+	} : void 0;
+	const rateLimits = await readCodexRateLimitsFromAppServerForUsageLimitError({
+		client: params.client,
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+	if (!rateLimits) return initialMessage ? {
+		message: initialMessage,
+		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
+	} : void 0;
+	const message = formatCodexUsageLimitErrorMessage({
+		message: params.source.message,
+		codexErrorInfo: params.source.codexErrorInfo,
+		rateLimits,
+		rateLimitsAuthoritative: true
+	}) ?? initialMessage;
+	return message ? {
+		message,
+		rateLimitsForProfile: rateLimits
+	} : void 0;
+}
+async function readCodexRateLimitsFromAppServerForUsageLimitError(params) {
+	if (params.signal?.aborted) return;
+	try {
+		const rateLimits = await params.client.request(CODEX_CONTROL_METHODS.rateLimits, void 0, {
+			timeoutMs: resolveCodexUsageLimitRateLimitRefreshTimeoutMs(params.timeoutMs),
+			signal: params.signal
+		});
+		rememberCodexRateLimitsRead(params.client, rateLimits);
+		return rateLimits;
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server rate-limit refresh failed after usage-limit error", { error: formatErrorMessage(error) });
+		return;
+	}
+}
+function resolveCodexUsageLimitRateLimitRefreshTimeoutMs(timeoutMs) {
+	if (timeoutMs === void 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS;
+	return Math.max(100, Math.min(timeoutMs, CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS));
+}
+function readCodexTurnStartUsageLimitErrorSource(client, error, errorNotification, rateLimitsRevisionBeforeTurnStart) {
+	const notificationError = readCodexErrorNotification(errorNotification);
+	const errorPayload = readCodexErrorPayload(error);
+	const rateLimits = errorPayload.rateLimits ?? readRecentCodexRateLimits(client);
+	const cacheUpdatedDuringTurnStart = rateLimitsRevisionBeforeTurnStart !== void 0 && readCodexRateLimitsRevision(client) > rateLimitsRevisionBeforeTurnStart;
+	return {
+		message: notificationError?.message ?? errorPayload.message ?? formatErrorMessage(error),
+		codexErrorInfo: notificationError?.codexErrorInfo ?? errorPayload.codexErrorInfo,
+		rateLimits,
+		rateLimitsTrustedForProfile: errorPayload.rateLimits !== void 0 || cacheUpdatedDuringTurnStart
+	};
+}
+function readCodexErrorNotification(notification) {
+	if (notification?.method !== "error" || !isJsonObject(notification.params)) return;
+	const error = notification.params.error;
+	return isJsonObject(error) ? {
+		message: readString$4(error, "message"),
+		codexErrorInfo: error.codexErrorInfo
+	} : void 0;
+}
+function readCodexErrorPayload(error) {
+	const message = error instanceof Error ? error.message : void 0;
+	if (!error || typeof error !== "object" || !("data" in error)) return { message };
+	const data = error.data;
+	if (!isJsonObject(data)) return { message };
+	const nestedError = isJsonObject(data.error) ? data.error : data;
+	const rateLimits = nestedError.rateLimits ?? data.rateLimits;
+	return {
+		message: readString$4(nestedError, "message") ?? message,
+		codexErrorInfo: nestedError.codexErrorInfo,
+		rateLimits
+	};
+}
+function readString$4(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector.ts
+var CodexAppServerEventProjector = class {
+	constructor(params, threadId, turnId, options = {}) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.options = options;
+		this.activeItemIds = /* @__PURE__ */ new Set();
+		this.completedItemIds = /* @__PURE__ */ new Set();
+		this.activeCompactionItemIds = /* @__PURE__ */ new Set();
+		this.terminalPresentationClearedItemIds = /* @__PURE__ */ new Set();
+		this.nativeToolOutcomeOrdinals = /* @__PURE__ */ new Map();
+		this.promptErrorSource = null;
+		this.synthesizedMissingToolResultError = null;
+		this.aborted = false;
+		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.toolProgressProjection = new CodexToolProgressProjection(params);
+		this.toolTranscriptProjection = new CodexToolTranscriptProjection(params, threadId, turnId, this.toolProgressProjection, () => this.nextTranscriptTimestamp(), {
+			nativePostToolUseRelayEnabled: options.nativePostToolUseRelayEnabled,
+			trajectoryRecorder: options.trajectoryRecorder
+		});
+		this.eventProjection = new CodexEventProjection(threadId, turnId, (event) => this.emitAgentEvent(event), this.toolProgressProjection, this.toolTranscriptProjection, options.onNativeToolResultRecorded);
+		this.assistantProjection = new CodexAssistantProjection(params, (event) => this.emitAgentEvent(event), (text) => this.toolProgressProjection.matchesEcho(text), () => this.nextTranscriptTimestamp());
+		this.reasoningProjection = new CodexReasoningProjection(params, (event) => this.emitAgentEvent(event));
+	}
+	nextTranscriptTimestamp() {
+		this.lastTranscriptTimestamp = Math.max(Date.now(), this.lastTranscriptTimestamp + 1);
+		return this.lastTranscriptTimestamp;
+	}
+	getCompletedTurnStatus() {
+		return this.completedTurn?.status;
+	}
+	hasCompletedTerminalAssistantText() {
+		return this.assistantProjection.hasCompletedTerminalAssistantText(this.completedItemIds);
+	}
+	getLatestTerminalAssistantCandidate() {
+		return this.assistantProjection.getLatestTerminalAssistantCandidate();
+	}
+	hasLatestTerminalAssistantCandidateText() {
+		return this.assistantProjection.hasLatestTerminalAssistantCandidateText();
+	}
+	canReleaseLatestTerminalAssistantAfterToolHandoff() {
+		return this.assistantProjection.canReleaseLatestTerminalAssistantAfterToolHandoff();
+	}
+	/** Restores a completed final item after only the enclosing turn timeout fired. */
+	recoverCompletedTerminalAssistantAfterTurnWatchTimeout() {
+		if (!this.aborted || this.promptError !== "codex app-server attempt timed out" || !this.hasCompletedTerminalAssistantText()) return false;
+		this.aborted = false;
+		this.promptError = void 0;
+		this.promptErrorSource = null;
+		return true;
+	}
+	/** Resolves the shared model-order position for a native tool item. */
+	recordNativeToolOutcome(item) {
+		if (!item || this.nativeToolOutcomeOrdinals.has(item.id) || !shouldClearTerminalPresentationForNativeItem(item)) return;
+		const ordinal = this.params.allocateToolOutcomeOrdinal?.(item.id);
+		if (ordinal !== void 0) this.nativeToolOutcomeOrdinals.set(item.id, ordinal);
+	}
+	recordNativeToolApprovalFailure(toolCallId, disposition) {
+		this.nativeToolLifecycleProjector.recordApprovalFailureDisposition(toolCallId, disposition);
+	}
+	recordNativeToolPreToolUseFailure(failure) {
+		this.nativeToolLifecycleProjector.recordPreToolUseFailure(failure);
+	}
+	async handleNotification(notification) {
+		const params = isJsonObject(notification.params) ? notification.params : void 0;
+		if (!params) return;
+		if (isHookNotificationMethod(notification.method)) {
+			if (!this.isHookNotificationForCurrentThread(params)) return;
+		} else if (notification.method === "guardianWarning") {
+			if (readCodexNotificationThreadId(params) !== this.threadId) return;
+		} else if (!this.isNotificationForTurn(params)) return;
+		this.nativeToolLifecycleProjector.handleNotification(notification);
+		switch (notification.method) {
+			case "item/agentMessage/delta":
+				await this.assistantProjection.handleAssistantDelta(params);
+				break;
+			case "item/reasoning/summaryTextDelta":
+			case "item/reasoning/textDelta":
+				await this.reasoningProjection.handleReasoningDelta(notification.method, params);
+				break;
+			case "item/plan/delta":
+				this.reasoningProjection.handlePlanDelta(params);
+				break;
+			case "turn/plan/updated":
+				this.reasoningProjection.handleTurnPlanUpdated(params);
+				break;
+			case "item/started":
+				await this.handleItemStarted(params);
+				break;
+			case "item/completed":
+				await this.handleItemCompleted(params);
+				break;
+			case "item/commandExecution/outputDelta":
+				this.toolProgressProjection.handleOutputDelta(params, "bash");
+				break;
+			case "item/autoApprovalReview/started":
+			case "item/autoApprovalReview/completed":
+				this.eventProjection.handleGuardianReview(notification.method, params);
+				break;
+			case "guardianWarning":
+				this.eventProjection.handleGuardianWarning(params);
+				break;
+			case "hook/started":
+			case "hook/completed":
+				this.eventProjection.handleHook(notification.method, params);
+				break;
+			case "thread/tokenUsage/updated":
+				projectCodexThreadUsageUpdate(params, this.tokenUsage, (usage) => this.tokenUsage = usage, (data) => this.emitAgentEvent({
+					stream: "codex_app_server.usage",
+					data
+				}));
+				break;
+			case "turn/completed":
+				await this.handleTurnCompleted(params);
+				break;
+			case "rawResponse/completed":
+				this.handleRawResponseCompleted(params);
+				break;
+			case "rawResponseItem/completed":
+				await this.handleRawResponseItemCompleted(params);
+				break;
+			case "error":
+				this.responseUsage = void 0;
+				if (params.willRetry === true) break;
+				this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
+				this.promptErrorSource = "prompt";
+				break;
+			case "thread/compacted":
+			case "turn/started":
+			case "turn/diff/updated":
+			case "item/reasoning/summaryPartAdded":
+			case "item/commandExecution/terminalInteraction":
+			case "item/fileChange/outputDelta":
+			case "item/fileChange/patchUpdated":
+			case "item/mcpToolCall/progress":
+			case "model/rerouted":
+			case "model/verification":
+			case "turn/moderationMetadata":
+			case "model/safetyBuffering/updated": break;
+			default:
+				this.diagnostics.warnUnknownEvent(notification, params);
+				break;
+		}
+	}
+	buildResult(toolTelemetry, options) {
+		this.nativeToolLifecycleProjector.finalizeActive();
+		const assistantTexts = this.assistantProjection.collectAssistantTexts();
+		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 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
+		});
+		if (synthesizedMissingToolResultError) {
+			this.synthesizedMissingToolResultError = synthesizedMissingToolResultError;
+			this.promptErrorSource = this.promptErrorSource ?? "prompt";
+		}
+		const assistantMessageOptions = {
+			tokenUsage: projectedUsage,
+			aborted: this.aborted,
+			promptError: this.promptError
+		};
+		const lastAssistant = assistantTexts.length ? this.assistantProjection.createAssistantMessage(assistantTexts.join("\n\n"), assistantMessageOptions) : void 0;
+		const currentAttemptAssistant = this.assistantProjection.createCurrentAttemptAssistantMessage(assistantMessageOptions);
+		const messagesSnapshot = buildCodexMessagesSnapshot({
+			runParams: this.params,
+			turnId: this.turnId,
+			upstreamUserText: this.options.upstreamUserText,
+			reasoningText,
+			planText,
+			commentaryMessages,
+			toolMessages: this.toolTranscriptProjection.transcriptMessages,
+			lastAssistant,
+			createAssistantMirrorMessage: (title, text) => this.assistantProjection.createAssistantMirrorMessage(title, text)
+		});
+		const turnFailed = this.completedTurn?.status === "failed";
+		const promptError = this.promptError ?? this.synthesizedMissingToolResultError ?? (turnFailed ? this.completedTurn?.error?.message ?? "codex app-server turn failed" : null);
+		const agentHarnessResultClassification = classifyAgentHarnessTerminalOutcome({
+			assistantTexts,
+			reasoningText,
+			planText,
+			promptError,
+			turnCompleted: Boolean(this.completedTurn)
+		});
+		const toolMetas = this.toolProgressProjection.toolMetas;
+		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || (toolTelemetry.successfulCronAdds ?? 0) > 0 || this.generatedMediaProjection.hasGeneratedMedia() || this.toolProgressProjection.hasPotentialSideEffects;
+		return {
+			aborted: this.aborted,
+			externalAbort: false,
+			timedOut: false,
+			idleTimedOut: false,
+			timedOutDuringCompaction: false,
+			timedOutDuringToolExecution: false,
+			promptError,
+			promptErrorSource: promptError ? this.promptErrorSource || "prompt" : null,
+			sessionIdUsed: this.params.sessionId,
+			...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
+			bootstrapPromptWarningSignaturesSeen: this.params.bootstrapPromptWarningSignaturesSeen,
+			bootstrapPromptWarningSignature: this.params.bootstrapPromptWarningSignature,
+			messagesSnapshot,
+			assistantTexts,
+			toolMetas,
+			lastAssistant,
+			currentAttemptAssistant,
+			...this.toolProgressProjection.lastToolError ? { lastToolError: this.toolProgressProjection.lastToolError } : {},
+			didSendViaMessagingTool: toolTelemetry.didSendViaMessagingTool,
+			didDeliverSourceReplyViaMessageTool: toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
+			messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,
+			messagingToolSentMediaUrls: toolTelemetry.messagingToolSentMediaUrls,
+			messagingToolSentTargets: toolTelemetry.messagingToolSentTargets,
+			messagingToolSourceReplyPayloads: toolTelemetry.messagingToolSourceReplyPayloads ?? [],
+			heartbeatToolResponse: toolTelemetry.heartbeatToolResponse,
+			toolMediaUrls: this.generatedMediaProjection.buildToolMediaUrls(toolTelemetry),
+			hostOwnedToolMediaUrls: this.generatedMediaProjection.buildHostOwnedMediaUrls(toolTelemetry),
+			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
+			successfulCronAdds: toolTelemetry.successfulCronAdds,
+			cloudCodeAssistFormatError: false,
+			attemptUsage: projectedUsage,
+			...this.completedCompactionCount > 0 ? { compactionCount: this.completedCompactionCount } : {},
+			replayMetadata: {
+				hadPotentialSideEffects,
+				replaySafe: !hadPotentialSideEffects
+			},
+			itemLifecycle: {
+				startedCount: this.activeItemIds.size + this.completedItemIds.size,
+				completedCount: this.completedItemIds.size,
+				activeCount: this.activeItemIds.size
+			},
+			yieldDetected: options?.yieldDetected || false,
+			didSendDeterministicApprovalPrompt: this.eventProjection.guardianReviewCount > 0 ? false : void 0
+		};
+	}
+	recordDynamicToolCall(params) {
+		this.toolTranscriptProjection.recordDynamicToolCall(params);
+	}
+	recordDynamicToolResult(params) {
+		this.toolProgressProjection.recordDynamicToolResult(params);
+		this.toolTranscriptProjection.recordDynamicToolResult(params);
+	}
+	markTimedOut() {
+		this.aborted = true;
+		this.promptError = "codex app-server attempt timed out";
+		this.promptErrorSource = "prompt";
+	}
+	markAborted() {
+		this.aborted = true;
+		this.responseUsage = void 0;
+	}
+	isCompacting() {
+		return this.activeCompactionItemIds.size > 0;
+	}
+	async handleItemStarted(params) {
+		const item = readItem(params.item);
+		const itemId = item?.id ?? readString$5(params, "itemId");
+		this.assistantProjection.recordItemStarted(item, itemId);
+		if (itemId) this.activeItemIds.add(itemId);
+		this.recordNativeToolOutcome(item);
+		if (item?.type === "contextCompaction" && itemId) {
+			this.activeCompactionItemIds.add(itemId);
+			await runAgentHarnessBeforeCompactionHook({
+				sessionFile: this.params.sessionFile,
+				messages: await this.toolTranscriptProjection.readMirroredSessionMessages(),
+				ctx: {
+					runId: this.params.runId,
+					agentId: this.params.agentId,
+					sessionKey: this.params.sessionKey,
+					sessionId: this.params.sessionId,
+					workspaceDir: this.params.workspaceDir,
+					messageProvider: this.params.messageProvider ?? void 0,
+					trigger: this.params.trigger,
+					channelId: this.params.messageChannel ?? this.params.messageProvider ?? void 0
+				}
+			});
+			this.emitAgentEvent({
+				stream: "compaction",
+				data: {
+					phase: "start",
+					backend: "codex-app-server",
+					threadId: this.threadId,
+					turnId: this.turnId,
+					itemId
+				}
+			});
+		}
+		this.toolProgressProjection.recordToolMeta(item);
+		this.eventProjection.emitStandardItemEvent({
+			phase: "start",
+			item
+		});
+		await this.eventProjection.emitNormalizedToolItemEvent({
+			phase: "start",
+			item
+		});
+		this.toolTranscriptProjection.recordNativeToolCall(item);
+		this.toolProgressProjection.emitToolResultSummary(item);
+		this.emitAgentEvent({
+			stream: "codex_app_server.item",
+			data: {
+				phase: "started",
+				itemId,
+				type: item?.type
+			}
+		});
+	}
+	async handleItemCompleted(params) {
+		const item = readItem(params.item);
+		this.diagnostics.warnUnknownItemStatus(item);
+		this.recordNativeToolOutcome(item);
+		this.clearTerminalPresentationForNativeItem(item);
+		const itemId = item?.id ?? readString$5(params, "itemId");
+		if (itemId) {
+			this.activeItemIds.delete(itemId);
+			this.completedItemIds.add(itemId);
+		}
+		this.assistantProjection.recordItemCompleted(item, itemId, this.activeItemIds);
+		this.reasoningProjection.recordItem(item);
+		this.generatedMediaProjection.recordNative(item);
+		if (item?.type === "contextCompaction" && itemId) {
+			this.activeCompactionItemIds.delete(itemId);
+			this.completedCompactionCount += 1;
+			this.options.onContextCompacted?.();
+			await runAgentHarnessAfterCompactionHook({
+				sessionFile: this.params.sessionFile,
+				messages: await this.toolTranscriptProjection.readMirroredSessionMessages(),
+				compactedCount: -1,
+				ctx: {
+					runId: this.params.runId,
+					agentId: this.params.agentId,
+					sessionKey: this.params.sessionKey,
+					sessionId: this.params.sessionId,
+					workspaceDir: this.params.workspaceDir,
+					messageProvider: this.params.messageProvider ?? void 0,
+					trigger: this.params.trigger,
+					channelId: this.params.messageChannel ?? this.params.messageProvider ?? void 0
+				}
+			});
+			this.emitAgentEvent({
+				stream: "compaction",
+				data: {
+					phase: "end",
+					backend: "codex-app-server",
+					completed: true,
+					threadId: this.threadId,
+					turnId: this.turnId,
+					itemId
+				}
+			});
+		}
+		this.toolProgressProjection.recordToolMeta(item);
+		this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
+		this.eventProjection.emitStandardItemEvent({
+			phase: "end",
+			item
+		});
+		await this.eventProjection.emitNormalizedToolItemEvent({
+			phase: "result",
+			item
+		});
+		this.toolTranscriptProjection.recordNativeToolCall(item);
+		this.toolTranscriptProjection.recordNativeToolResult(item);
+		this.toolProgressProjection.emitToolResultSummary(item);
+		this.toolProgressProjection.emitToolResultOutput(item);
+		this.emitAgentEvent({
+			stream: "codex_app_server.item",
+			data: {
+				phase: "completed",
+				itemId,
+				type: item?.type
+			}
+		});
+	}
+	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 === "failed") {
+			const usageLimitMessage = formatCodexUsageLimitErrorMessage({
+				message: turn.error?.message,
+				codexErrorInfo: turn.error?.codexErrorInfo,
+				rateLimits: this.options.readRecentRateLimits?.()
+			});
+			this.promptError = usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : turn.error?.message ?? "codex app-server turn failed";
+			this.promptErrorSource = "prompt";
+		}
+		const turnItems = turn.items ?? [];
+		for (let index = turnItems.length - 1; index >= 0; index -= 1) {
+			const item = turnItems[index];
+			if (!item || !this.isCurrentTurnSnapshotItem(item)) continue;
+			if (item?.type === "dynamicToolCall") break;
+			if (shouldClearTerminalPresentationForNativeItem(item)) {
+				this.clearTerminalPresentationForNativeItem(item);
+				break;
+			}
+		}
+		for (const item of turnItems) {
+			this.diagnostics.warnUnknownItemStatus(item);
+			this.assistantProjection.recordSnapshotItem(item);
+			this.reasoningProjection.recordItem(item);
+			this.generatedMediaProjection.recordNative(item);
+			this.toolProgressProjection.recordToolMeta(item);
+			this.toolProgressProjection.rememberCommandAggregateOutputEcho(item);
+			await this.emitSnapshotOnlyNativeToolProgress(item);
+			this.toolTranscriptProjection.recordNativeToolCall(item);
+			this.toolTranscriptProjection.recordNativeToolResult(item);
+			this.toolTranscriptProjection.emitAfterToolCallObservation(item);
+			this.toolProgressProjection.emitToolResultSummary(item);
+			this.toolProgressProjection.emitToolResultOutput(item);
+		}
+		this.assistantProjection.finalizeAnswerCandidate(turn);
+		this.activeCompactionItemIds.clear();
+		await this.reasoningProjection.maybeEndReasoning();
+	}
+	async emitSnapshotOnlyNativeToolProgress(item) {
+		if (!shouldSynthesizeToolProgressForItem(item) || !this.isCurrentTurnSnapshotItem(item) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
+		if (!this.activeItemIds.has(item.id)) {
+			this.eventProjection.emitStandardItemEvent({
+				phase: "start",
+				item
+			});
+			await this.eventProjection.emitNormalizedToolItemEvent({
+				phase: "start",
+				item
+			});
+		}
+		this.activeItemIds.delete(item.id);
+		this.eventProjection.emitStandardItemEvent({
+			phase: "end",
+			item
+		});
+		await this.eventProjection.emitNormalizedToolItemEvent({
+			phase: "result",
+			item
+		});
+		this.completedItemIds.add(item.id);
+	}
+	isCurrentTurnSnapshotItem(item) {
+		const itemTurnId = readItemString(item, "turnId");
+		return itemTurnId === void 0 || itemTurnId === this.turnId;
+	}
+	async handleRawResponseItemCompleted(params) {
+		const item = isJsonObject(params.item) ? params.item : void 0;
+		if (!item) return;
+		this.assistantProjection.handleRawResponseItemCompleted(item, this.activeItemIds);
+		await this.generatedMediaProjection.recordRaw(item);
+	}
+	clearTerminalPresentationForNativeItem(item) {
+		if (!item || this.terminalPresentationClearedItemIds.has(item.id) || !shouldClearTerminalPresentationForNativeItem(item)) return;
+		const toolCallOrdinal = this.nativeToolOutcomeOrdinals.get(item.id);
+		this.terminalPresentationClearedItemIds.add(item.id);
+		this.params.onToolOutcome?.({
+			toolName: itemName(item) ?? item.type,
+			argsHash: "",
+			resultHash: "",
+			...toolCallOrdinal !== void 0 ? { toolCallOrdinal } : {},
+			terminalPresentation: void 0,
+			presentationOnly: true
+		});
+	}
+	formatCodexErrorMessage(params) {
+		const error = isJsonObject(params.error) ? params.error : void 0;
+		const usageLimitMessage = formatCodexUsageLimitErrorMessage({
+			message: error ? readString$5(error, "message") : void 0,
+			codexErrorInfo: error?.codexErrorInfo,
+			rateLimits: this.options.readRecentRateLimits?.()
+		});
+		return usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : readCodexErrorNotificationMessage(params);
+	}
+	emitAgentEvent(event) {
+		try {
+			emitAgentEvent({
+				runId: this.params.runId,
+				stream: event.stream,
+				data: event.data,
+				...this.params.sessionKey ? { sessionKey: this.params.sessionKey } : {}
+			});
+		} catch (error) {
+			embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
+		}
+		try {
+			const maybePromise = this.params.onAgentEvent?.(event);
+			Promise.resolve(maybePromise).catch((error) => {
+				embeddedAgentLog.debug("codex app-server agent event handler rejected", { error });
+			});
+		} catch (error) {
+			embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
+		}
+	}
+	isNotificationForTurn(params) {
+		const threadId = readCodexNotificationThreadId(params);
+		const turnId = readCodexNotificationTurnId(params);
+		return threadId === this.threadId && turnId === this.turnId;
+	}
+	isHookNotificationForCurrentThread(params) {
+		const threadId = readString$5(params, "threadId");
+		const turnId = params.turnId;
+		return threadId === this.threadId && (turnId === this.turnId || turnId === null);
+	}
+};
+function isHookNotificationMethod(method) {
+	return method === "hook/started" || method === "hook/completed";
+}
+//#endregion
+//#region extensions/codex/src/app-server/user-input-bridge.ts
+/** Bridges Codex request_user_input calls to gateway questions and secret text prompts. */
+const DEFAULT_USER_INPUT_TIMEOUT_MS = 15 * 6e4;
 /** Creates a per-turn bridge for pending Codex user-input requests. */
 function createCodexUserInputBridge(params) {
-	let pending;
-	const resolvePending = (value) => {
-		const current = pending;
+	let sensitiveInput;
+	let pendingGateway;
+	const gatewayCall = params.gatewayCall ?? callGatewayTool;
+	const resolveSecret = (value) => {
+		const current = sensitiveInput;
 		if (!current) return;
-		pending = void 0;
+		sensitiveInput = void 0;
 		current.cleanup();
 		current.resolve(value);
 	};
-	const resolvePendingIfCurrent = (current, value) => {
-		if (pending !== current) return false;
-		resolvePending(value);
+	const resolveSecretIfCurrent = (current, value) => {
+		if (sensitiveInput !== current) return false;
+		resolveSecret(value);
 		return true;
 	};
+	const cancelGateway = () => {
+		pendingGateway?.abort.abort(/* @__PURE__ */ new Error("Codex user input request cancelled"));
+	};
 	return {
 		async handleRequest(request) {
 			const requestParams = readUserInputParams(request.params);
 			if (!requestParams) return;
 			if (requestParams.threadId !== params.threadId || requestParams.turnId !== params.turnId) return;
 			if (requestParams.questions.length === 0) return emptyUserInputResponse();
-			resolvePending(emptyUserInputResponse());
-			return new Promise((resolve) => {
-				const abortListener = () => resolvePending(emptyUserInputResponse());
+			resolveSecret(emptyUserInputResponse());
+			cancelGateway();
+			if (requestParams.questions.some((question) => question.isSecret)) return new Promise((resolve) => {
+				const abortListener = () => resolveSecret(emptyUserInputResponse());
 				const cleanup = () => params.signal?.removeEventListener("abort", abortListener);
-				pending = {
+				sensitiveInput = {
 					requestId: request.id,
 					threadId: requestParams.threadId,
-					turnId: requestParams.turnId,
-					itemId: requestParams.itemId,
 					questions: requestParams.questions,
 					claimed: false,
 					resolve,
@@ -232,37 +2669,68 @@ function createCodexUserInputBridge(params) {
 				};
 				params.signal?.addEventListener("abort", abortListener, { once: true });
 				if (params.signal?.aborted) {
-					resolvePending(emptyUserInputResponse());
+					resolveSecret(emptyUserInputResponse());
 					return;
 				}
-				deliverUserInputPrompt(params.paramsForRun, requestParams.questions).catch((error) => {
-					embeddedAgentLog.warn("failed to deliver codex user input prompt", { error });
+				deliverAgentHarnessUserInputPrompt(params.paramsForRun, requestParams.questions, {
+					formatText: formatCodexDisplayText,
+					intro: "Codex needs input:"
+				}).catch((error) => {
+					embeddedAgentLog.warn("failed to deliver secret codex user input prompt", { error });
 				});
 			});
+			const abort = new AbortController();
+			const abortFromRun = () => abort.abort(params.signal?.reason);
+			params.signal?.addEventListener("abort", abortFromRun, { once: true });
+			if (params.signal?.aborted) abortFromRun();
+			pendingGateway = {
+				requestId: request.id,
+				threadId: requestParams.threadId,
+				abort
+			};
+			try {
+				const result = await runAgentHarnessGatewayQuestion({
+					questions: requestParams.questions,
+					sessionKey: params.paramsForRun.sessionKey ?? params.paramsForRun.sessionId,
+					agentId: params.paramsForRun.agentId,
+					timeoutMs: requestParams.autoResolutionMs ?? params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS,
+					gatewayCall,
+					delivery: params.paramsForRun,
+					promptOptions: {
+						formatText: formatCodexDisplayText,
+						intro: "Codex needs input:"
+					},
+					signal: abort.signal
+				});
+				return result.status === "answered" ? gatewayAnswersToCodexResponse(result.answers.answers) : emptyUserInputResponse();
+			} catch (error) {
+				embeddedAgentLog.warn("failed to bridge codex user input through gateway", { error });
+				return emptyUserInputResponse();
+			} finally {
+				params.signal?.removeEventListener("abort", abortFromRun);
+				if (pendingGateway?.abort === abort) pendingGateway = void 0;
+			}
 		},
 		claimPendingRequest() {
-			const current = pending;
+			const current = sensitiveInput;
 			if (!current || current.claimed) return;
 			current.claimed = true;
 			return {
-				answer: (text) => resolvePendingIfCurrent(current, buildUserInputResponse(current.questions, text)),
-				cancel: () => resolvePendingIfCurrent(current, emptyUserInputResponse())
+				answer: (text) => resolveSecretIfCurrent(current, buildUserInputResponse(current.questions, text)),
+				cancel: () => resolveSecretIfCurrent(current, emptyUserInputResponse())
 			};
 		},
-		handleQueuedMessage(text) {
-			const current = pending;
-			if (!current || current.claimed) return false;
-			resolvePending(buildUserInputResponse(current.questions, text));
-			return true;
-		},
 		handleNotification(notification) {
-			if (notification.method !== "serverRequest/resolved" || !pending) return;
+			if (notification.method !== "serverRequest/resolved") return;
 			const notificationParams = isJsonObject(notification.params) ? notification.params : void 0;
 			const requestId = notificationParams ? readRequestId(notificationParams) : void 0;
-			if (notificationParams && readString$3(notificationParams, "threadId") === pending.threadId && requestId !== void 0 && String(requestId) === String(pending.requestId)) resolvePending(emptyUserInputResponse());
+			if (!notificationParams || requestId === void 0) return;
+			if (sensitiveInput && readString$3(notificationParams, "threadId") === sensitiveInput.threadId && String(requestId) === String(sensitiveInput.requestId)) resolveSecret(emptyUserInputResponse());
+			if (pendingGateway && readString$3(notificationParams, "threadId") === pendingGateway.threadId && String(requestId) === String(pendingGateway.requestId)) pendingGateway.abort.abort(/* @__PURE__ */ new Error("Codex server request resolved"));
 		},
 		cancelPending() {
-			resolvePending(emptyUserInputResponse());
+			resolveSecret(emptyUserInputResponse());
+			cancelGateway();
 		}
 	};
 }
@@ -277,7 +2745,12 @@ function readUserInputParams(value) {
 		threadId,
 		turnId,
 		itemId,
-		questions: questionsRaw.map(readQuestion).filter((question) => Boolean(question))
+		questions: questionsRaw.map((rawQuestion) => {
+			const question = readQuestion(rawQuestion);
+			if (question && isJsonObject(rawQuestion) && rawQuestion.multiSelect === true) question.multiSelect = true;
+			return question;
+		}).filter((question) => Boolean(question)),
+		autoResolutionMs: typeof value.autoResolutionMs === "number" && value.autoResolutionMs > 0 ? value.autoResolutionMs : void 0
 	};
 }
 function readQuestion(value) {
@@ -309,15 +2782,12 @@ function readOption(value) {
 		description
 	} : void 0;
 }
-async function deliverUserInputPrompt(params, questions) {
-	await deliverAgentHarnessUserInputPrompt(params, questions, {
-		formatText: formatCodexDisplayText,
-		intro: "Codex needs input:"
-	});
-}
 function buildUserInputResponse(questions, inputText) {
 	return buildAgentHarnessUserInputAnswers(questions, inputText);
 }
+function gatewayAnswersToCodexResponse(answers) {
+	return { answers: Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [questionId, { answers: values }])) };
+}
 function emptyUserInputResponse() {
 	return emptyAgentHarnessUserInputAnswers();
 }
@@ -421,11 +2891,28 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const handle = {
 		kind: "embedded",
 		runId: params.runId,
-		queueMessage: async (text, optionsLocal) => activeSteeringQueue.queue(text, optionsLocal),
+		queueMessage: async (text, optionsLocal) => {
+			const isInboundUserMessage = optionsLocal?.isInboundUserMessage === true;
+			if (isInboundUserMessage && !optionsLocal?.images?.length) {
+				if (await claimPendingAgentQuestionAnswer({
+					sessionKey: params.sessionKey ?? params.sessionId,
+					text
+				})) return;
+			} else if (isInboundUserMessage) try {
+				await cancelPendingAgentQuestionForSession({
+					sessionKey: params.sessionKey ?? params.sessionId,
+					resolvedBy: "image-reply"
+				});
+			} catch (error) {
+				embeddedAgentLog.warn("failed to cancel codex gateway question before image steering", { error });
+			}
+			await activeSteeringQueue.queue(text, optionsLocal);
+		},
 		isStreaming: () => !state.completed && !runAbortController.signal.aborted,
 		isStopped: () => state.completed || state.timedOut || runAbortController.signal.aborted,
 		isAbortable: () => !terminalState.terminalOutcomeFrozen || terminalState.sharedAbortAllowedAfterTerminalOutcome,
 		isCompacting: () => projectorRef.current?.isCompacting() ?? false,
+		supportsTranscriptCommitWait: true,
 		supportsQueueMessageImages: true,
 		sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
 		cancel: () => abortExplicitly("cancelled"),
@@ -488,7 +2975,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRuntime, activeTurn) {
 	const { prompt, state: resourceState, trajectoryRecorder, releaseCurrentRoute, releaseSharedClientLeaseAndRetireOneShotClient, releaseSandboxExecEnvironment } = resources;
 	const { connection } = prompt.context.runtime;
-	const { params, options, runAbortController } = connection;
+	const { params, options, runAbortController, terminalState, bindingStore, bindingIdentity } = connection;
 	const { state, steeringQueueRef, userInputBridgeRef, turnWatches } = turnRuntime;
 	const { maybeEmitFastModeAutoResetBestEffort, emitLifecycleTerminal, buildLifecycleTerminalMeta } = lifecycle;
 	const { codexModelCallDiagnostics } = requestRuntime;
@@ -518,10 +3005,17 @@ async function cleanupCodexAttempt(resources, turnRuntime, lifecycle, requestRun
 		cleanup: async () => trajectoryRecorder?.flush()
 	});
 	if (!state.timedOut && !runAbortController.signal.aborted) await steeringQueueRef.current?.flushPending();
-	if (!state.timedOut) await unsubscribeCodexThreadBestEffort(resourceState.client, {
-		threadId: resourceState.thread.threadId,
-		timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
-	});
+	const retainLiveIncognitoThread = terminalState.turnSucceeded && isIncognitoSessionKey(params.sessionKey);
+	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
+		});
+	}
 	userInputBridgeRef.current?.cancelPending();
 	turnWatches.clearAllTimers();
 	releaseCurrentRoute();
@@ -782,19 +3276,11 @@ function readCodexAppServerRolloutTokenSnapshotLine(line) {
 		return;
 	}
 }
-function toNonNegativeInt(value) {
-	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return;
-	return Math.floor(value);
-}
 function readCompactionConfig(config) {
 	return isJsonObject(config?.agents?.defaults?.compaction) ? config.agents.defaults.compaction : void 0;
 }
-function resolveCodexAppServerNativeThreadReserveTokens(config) {
-	const compaction = readCompactionConfig(config);
-	const reserveTokens = toNonNegativeInt(compaction?.reserveTokens);
-	const reserveTokensFloor = toNonNegativeInt(compaction?.reserveTokensFloor);
-	if (reserveTokens !== void 0) return Math.max(reserveTokens, reserveTokensFloor ?? CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS);
-	return reserveTokensFloor ?? CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
+function resolveCodexAppServerNativeThreadReserveTokens(_config) {
+	return CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
 }
 function resolveCodexAppServerNativeThreadTokenFuse(params) {
 	const projectedTurnTokens = typeof params.projectedTurnTokens === "number" && Number.isFinite(params.projectedTurnTokens) && params.projectedTurnTokens > 0 ? Math.floor(params.projectedTurnTokens) : 0;
@@ -890,6 +3376,14 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-connection.ts
+function applyStoredBindingPermissions(params) {
+	if (params.execPolicyTouched || params.binding?.connectionScope === "supervision") return params.appServer;
+	return {
+		...params.appServer,
+		approvalPolicy: params.binding?.approvalPolicy ?? params.appServer.approvalPolicy,
+		sandbox: params.binding?.sandbox ?? params.appServer.sandbox
+	};
+}
 async function prepareCodexAttemptConnection({ params, options }) {
 	const attemptStartedAt = Date.now();
 	const profilerEnabled = isCodexAppServerProfilerEnabled(params.config);
@@ -947,23 +3441,27 @@ async function prepareCodexAttemptConnection({ params, options }) {
 			bindingStore,
 			identity: bindingIdentity,
 			config: params.config
-		})) throw new Error(`Codex session generation is no longer current: ${bindingIdentity.sessionId}`);
+		})) throw createCodexSessionGenerationSupersededError(bindingIdentity.sessionId);
 		startupBinding = await bindingStore.read(bindingIdentity);
 	}
 	preDynamicStartupStages.mark("read-binding");
 	const usesSupervisionConnection = startupBinding?.connectionScope === "supervision";
 	if (usesSupervisionConnection) activeContextEngine = void 0;
 	if (usesSupervisionConnection && pluginConfig.supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
-	const resolveRuntimeOptionsForBinding = (selection) => resolveCodexBindingAppServerConnection({
+	const resolveRuntimeOptionsForBinding = (selection) => applyStoredBindingPermissions({
+		appServer: resolveCodexBindingAppServerConnection({
+			binding: startupBinding,
+			pluginConfig,
+			execPolicy,
+			modelProvider: selection.modelProvider,
+			model: selection.model,
+			config: params.config,
+			agentDir,
+			openClawSandboxActive: sandbox?.enabled === true
+		}).appServer,
 		binding: startupBinding,
-		pluginConfig,
-		execPolicy,
-		modelProvider: selection.modelProvider,
-		model: selection.model,
-		config: params.config,
-		agentDir,
-		openClawSandboxActive: sandbox?.enabled === true
-	}).appServer;
+		execPolicyTouched: execPolicy.touched
+	});
 	const initialStartupBindingHadInactiveThreadBootstrap = isInactiveThreadBootstrapBinding(startupBinding);
 	const preparedAuthRoute = usesSupervisionConnection ? void 0 : params.runtimePlan?.auth.modelRoute;
 	const startupAuthProfileCandidate = usesSupervisionConnection ? void 0 : preparedAuthRoute ? params.runtimePlan?.auth.forwardedAuthProfileId : params.runtimePlan?.auth.forwardedAuthProfileId ?? params.authProfileId ?? startupBinding?.authProfileId;
@@ -1039,6 +3537,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	preDynamicStartupStages.mark("app-server-policy");
 	preDynamicStartupStages.mark("native-hook-relay");
 	const terminalState = {
+		turnSucceeded: false,
 		explicitCancellationObserved: false,
 		explicitCancellationReason: void 0,
 		terminalOutcomeFrozen: false,
@@ -1100,16 +3599,20 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		startupBinding,
 		pluginAppServer: appServer
 	};
-	const resolveRuntimeOptionsForCurrentBinding = (selection) => resolveCodexBindingAppServerConnection({
+	const resolveRuntimeOptionsForCurrentBinding = (selection) => applyStoredBindingPermissions({
+		appServer: resolveCodexBindingAppServerConnection({
+			binding: mutable.startupBinding,
+			pluginConfig,
+			execPolicy,
+			modelProvider: selection.modelProvider,
+			model: selection.model,
+			config: params.config,
+			agentDir,
+			openClawSandboxActive: sandbox?.enabled === true
+		}).appServer,
 		binding: mutable.startupBinding,
-		pluginConfig,
-		execPolicy,
-		modelProvider: selection.modelProvider,
-		model: selection.model,
-		config: params.config,
-		agentDir,
-		openClawSandboxActive: sandbox?.enabled === true
-	}).appServer;
+		execPolicyTouched: execPolicy.touched
+	});
 	return {
 		params,
 		options,
@@ -1169,7 +3672,6 @@ const CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = /* @__PURE__ */
 	"user.md"
 ]);
 const CODEX_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = /* @__PURE__ */ new Set([...CODEX_INHERITED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES, ...CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES]);
-const CODEX_HEARTBEAT_CONTEXT_BASENAME = "heartbeat.md";
 const CODEX_MEMORY_CONTEXT_BASENAME = "memory.md";
 const CODEX_MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set(["memory_search", "memory_get"]);
 const CODEX_BOOTSTRAP_CONTEXT_ORDER = /* @__PURE__ */ new Map([
@@ -1178,8 +3680,7 @@ const CODEX_BOOTSTRAP_CONTEXT_ORDER = /* @__PURE__ */ new Map([
 	["user.md", 30],
 	["tools.md", 40],
 	["bootstrap.md", 50],
-	["memory.md", 60],
-	["heartbeat.md", 70]
+	["memory.md", 60]
 ]);
 /** Reads mirrored Codex session history for harness hooks. */
 async function readMirroredSessionHistoryMessages(params) {
@@ -1280,14 +3781,12 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 		});
 		const developerInstructionFiles = shouldInjectCodexOpenClawPromptContext(params.params) ? selectCodexWorkspaceInheritedDeveloperInstructionFiles(contextFiles) : [];
 		const turnScopedDeveloperInstructionFiles = shouldInjectCodexOpenClawPromptContext(params.params) ? selectCodexWorkspaceTurnScopedDeveloperInstructionFiles(contextFiles) : [];
-		const heartbeatReferenceFiles = selectCodexWorkspaceHeartbeatReferenceFiles(contextFiles);
 		return {
 			bootstrapFiles,
 			contextFiles,
 			promptContextFiles,
 			developerInstructionFiles,
 			turnScopedDeveloperInstructionFiles,
-			heartbeatReferenceFiles,
 			memoryReferenceFiles,
 			memoryToolRoutedBootstrapFiles,
 			memoryToolNames: [...params.memoryToolNames],
@@ -1295,15 +3794,15 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 			promptContext: renderCodexWorkspaceBootstrapPromptContext(promptContextFiles),
 			developerInstructions: renderCodexWorkspaceThreadDeveloperInstructions(developerInstructionFiles),
 			turnScopedDeveloperInstructions: renderCodexWorkspaceCollaborationDeveloperInstructions(turnScopedDeveloperInstructionFiles),
-			memoryCollaborationInstructions: shouldInjectCodexOpenClawPromptContext(params.params) ? renderCodexWorkspaceMemoryCollaborationInstructions({
+			memoryCollaborationInstructions: shouldInjectCodexOpenClawPromptContext(params.params) ? await renderCodexWorkspaceMemoryCollaborationInstructions({
 				files: memoryReferenceFiles,
 				toolNames: params.memoryToolNames,
 				memoryToolRouted: memoryToolsAvailable,
 				citationsMode: params.params.config?.memory?.citations,
 				agentId: params.params.agentId ?? params.sessionAgentId,
-				agentSessionKey: params.sessionKey
-			}) : void 0,
-			heartbeatCollaborationInstructions: renderCodexWorkspaceHeartbeatReference(heartbeatReferenceFiles)
+				agentSessionKey: params.sessionKey,
+				sandboxed: params.sandboxed
+			}) : void 0
 		};
 	} catch (error) {
 		embeddedAgentLog.warn("failed to load codex workspace bootstrap instructions", { error });
@@ -1425,14 +3924,9 @@ function buildCodexBootstrapInjectionStats(params) {
 		const injected = memoryToolRoutedFile ? void 0 : readCodexIndexedContextFileContent(injectedIndex, pathValue, fileName) ?? readCodexIndexedContextFileContent(developerInstructionIndex, pathValue, fileName);
 		let injectedChars = memoryToolRoutedFile ? 0 : injected?.length ?? 0;
 		let truncated = memoryToolRoutedFile ? false : !file.missing && injectedChars < rawChars;
-		if (injected === void 0) {
-			if (CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName)) {
-				injectedChars = rawChars;
-				truncated = false;
-			} else if (baseName === CODEX_HEARTBEAT_CONTEXT_BASENAME) {
-				injectedChars = 0;
-				truncated = false;
-			}
+		if (injected === void 0 && CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName)) {
+			injectedChars = rawChars;
+			truncated = false;
 		}
 		return {
 			name: displayName,
@@ -1556,7 +4050,7 @@ function renderCodexWorkspaceBootstrapPromptContext(contextFiles) {
 	const files = contextFiles;
 	if (files.length === 0) return;
 	const lines = [
-		"OpenClaw loaded these user-editable workspace files for the current turn. Codex loads AGENTS.md natively. TOOLS.md is provided as inherited Codex developer instructions. SOUL.md, IDENTITY.md, and USER.md are provided as turn-scoped collaboration instructions so native Codex subagents do not inherit them. HEARTBEAT.md is handled by heartbeat collaboration-mode guidance. Those files are not repeated here.",
+		"OpenClaw loaded these user-editable workspace files for the current turn. Codex loads AGENTS.md natively. TOOLS.md is provided as inherited Codex developer instructions. SOUL.md, IDENTITY.md, and USER.md are provided as turn-scoped collaboration instructions so native Codex subagents do not inherit them. Those files are not repeated here.",
 		"",
 		"# Project Context",
 		"",
@@ -1570,7 +4064,7 @@ function selectCodexWorkspacePromptContextFiles(contextFiles, options = {}) {
 	const excludeMemory = options.excludeMemory ?? true;
 	return contextFiles.filter((file) => {
 		const baseName = getCodexContextFileBasename(file.path);
-		return baseName && !CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName) && !CODEX_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES.has(baseName) && baseName !== CODEX_HEARTBEAT_CONTEXT_BASENAME && (!excludeMemory || !isCodexWorkspaceRootMemoryContextFile({
+		return baseName && !CODEX_NATIVE_PROJECT_DOC_BASENAMES.has(baseName) && !CODEX_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES.has(baseName) && (!excludeMemory || !isCodexWorkspaceRootMemoryContextFile({
 			file,
 			workspaceDir: options.memoryWorkspaceDir
 		})) && !isMissingCodexBootstrapContextFile(file);
@@ -1617,22 +4111,6 @@ function renderCodexWorkspaceDeveloperInstructions(params) {
 	if (wrapperTag) lines.push(`</${wrapperTag}>`);
 	return lines.join("\n").trim();
 }
-function selectCodexWorkspaceHeartbeatReferenceFiles(contextFiles) {
-	return contextFiles.filter((file) => {
-		return getCodexContextFileBasename(file.path) === CODEX_HEARTBEAT_CONTEXT_BASENAME && !isMissingCodexBootstrapContextFile(file) && file.content.trim().length > 0;
-	}).toSorted(compareCodexContextFiles);
-}
-function renderCodexWorkspaceHeartbeatReference(files) {
-	if (files.length === 0) return;
-	const lines = [
-		"## OpenClaw Heartbeat Workspace",
-		"",
-		"HEARTBEAT.md exists in the active agent workspace. Read it before proceeding with this heartbeat, then decide what action is appropriate.",
-		""
-	];
-	for (const file of files) lines.push(`- ${file.path}`);
-	return lines.join("\n").trim();
-}
 function selectCodexWorkspaceMemoryReferenceFiles(params) {
 	return params.bootstrapFiles.filter((file) => {
 		return isCodexWorkspaceRootMemoryBootstrapFile({
@@ -1656,24 +4134,26 @@ function renderCodexWorkspaceMemoryReference(params) {
 	for (const file of params.files) lines.push(`- ${file.path}`);
 	return lines.join("\n").trim();
 }
-function renderCodexWorkspaceMemoryCollaborationInstructions(params) {
-	const sections = [params.memoryToolRouted ? renderCodexMemoryRecallInstructions({
+async function renderCodexWorkspaceMemoryCollaborationInstructions(params) {
+	const sections = [params.memoryToolRouted ? await renderCodexMemoryRecallInstructions({
 		toolNames: params.toolNames,
 		citationsMode: params.citationsMode,
 		agentId: params.agentId,
-		agentSessionKey: params.agentSessionKey
+		agentSessionKey: params.agentSessionKey,
+		sandboxed: params.sandboxed
 	}) : void 0, renderCodexWorkspaceMemoryReference({
 		files: params.files,
 		toolNames: params.toolNames
 	})].filter(isNonEmptyString$1);
 	return sections.length > 0 ? sections.join("\n\n") : void 0;
 }
-function renderCodexMemoryRecallInstructions(params) {
-	const memoryPrompt = buildMemorySystemPromptAddition({
+async function renderCodexMemoryRecallInstructions(params) {
+	const memoryPrompt = await prepareMemorySystemPromptAddition({
 		availableTools: new Set(params.toolNames),
 		citationsMode: params.citationsMode,
 		agentId: params.agentId,
-		agentSessionKey: params.agentSessionKey
+		agentSessionKey: params.agentSessionKey,
+		sandboxed: params.sandboxed
 	});
 	if (!memoryPrompt) return;
 	return [memoryPrompt, renderCodexMemoryToolSearchBridge(params.toolNames)].filter(isNonEmptyString$1).join("\n").trim();
@@ -1870,7 +4350,7 @@ function buildCodexAppServerTimeoutDiagnostics(params) {
 //#region extensions/codex/src/app-server/run-attempt-context.ts
 async function prepareCodexAttemptContext(runtime, attemptTools) {
 	const { connection, runtimeParams, activeSessionId, activeSessionFile, buildActiveRunAttemptParams, effectiveContextWindowInfo, effectiveContextTokenBudget, effectiveRuntimeProviderId, effectiveRuntimeModelId, hookChannelId } = runtime;
-	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, sandboxSessionKey, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart } = connection;
+	const { params, sessionAgentId, contextSessionKey, activeContextEngine, initialStartupBindingHadInactiveThreadBootstrap, sandboxSessionKey, effectiveWorkspace, effectiveCwd, agentDir, usesSupervisionConnection, resolvedWorkspace, initialInactiveThreadBootstrapBindingForcedFreshStart, sandbox } = connection;
 	const { toolBridge } = attemptTools;
 	const activeTranscriptTarget = {
 		agentId: sessionAgentId,
@@ -1934,7 +4414,8 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		effectiveWorkspace,
 		sessionKey: contextSessionKey,
 		sessionAgentId,
-		memoryToolNames: getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs)
+		memoryToolNames: getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs),
+		sandboxed: sandbox?.enabled === true
 	});
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), workspaceBootstrapContext.developerInstructions);
 	return {
@@ -1968,7 +4449,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		},
 		codexContextProjectionMaxChars: resolveCodexContextEngineProjectionMaxChars({
 			contextTokenBudget: effectiveContextTokenBudget,
-			reserveTokens: resolveCodexContextEngineProjectionReserveTokens({ config: params.config })
+			reserveTokens: resolveCodexContextEngineProjectionReserveTokens()
 		})
 	};
 }
@@ -2183,6 +4664,67 @@ function isInvalidCodexImagePayloadError(message) {
 	return /\b(?:invalid|malformed)\b[\s\S]{0,120}\b(?:image|image url|base64)\b/iu.test(normalizedMessage) || /\b(?:image|image url|base64)\b[\s\S]{0,120}\b(?:invalid|malformed)\b/iu.test(normalizedMessage);
 }
 //#endregion
+//#region extensions/codex/src/app-server/settled-turn-context.ts
+function collectUniqueMessageIdentities(messages) {
+	const identities = /* @__PURE__ */ new Map();
+	for (const [index, message] of messages.entries()) {
+		const identity = readMirrorIdentity(message);
+		if (!identity) continue;
+		if (identities.has(identity)) return;
+		identities.set(identity, index);
+	}
+	return identities;
+}
+/** Freezes one complete active transcript branch through the settled tool-result boundary. */
+function buildCodexSettledTurnFinalizationContext(params) {
+	const boundaryMessage = params.settledMessages.findLast((message) => message.role === "toolResult");
+	const boundaryIdentity = boundaryMessage ? readMirrorIdentity(boundaryMessage) : void 0;
+	if (!boundaryMessage || !boundaryIdentity || !boundaryIdentity.startsWith(`${params.turnId}:tool:`)) return;
+	const settledBoundaryIndex = params.settledMessages.indexOf(boundaryMessage);
+	const requiredIdentities = params.settledMessages.slice(0, settledBoundaryIndex + 1).map(readMirrorIdentity);
+	if (requiredIdentities.length === 0 || requiredIdentities.some((identity) => !identity) || new Set(requiredIdentities).size !== requiredIdentities.length || !requiredIdentities.includes(`${params.turnId}:prompt`)) return;
+	const historyIdentities = collectUniqueMessageIdentities(params.historyMessages);
+	const mirroredIdentities = collectUniqueMessageIdentities(params.mirroredMessages);
+	if (!historyIdentities || !mirroredIdentities) return;
+	const mirroredBoundaryIndex = mirroredIdentities.get(boundaryIdentity);
+	if (mirroredBoundaryIndex === void 0) return;
+	const mirroredThroughBoundary = params.mirroredMessages.slice(0, mirroredBoundaryIndex + 1);
+	if (mirroredThroughBoundary.length !== requiredIdentities.length || mirroredThroughBoundary.some((message, index) => readMirrorIdentity(message) !== requiredIdentities[index])) return;
+	const historyBoundaryIndex = historyIdentities.get(boundaryIdentity);
+	if (historyBoundaryIndex === void 0) return;
+	let previousHistoryIndex = -1;
+	for (const mirroredMessage of mirroredThroughBoundary) {
+		const identity = readMirrorIdentity(mirroredMessage);
+		const historyIndex = identity ? historyIdentities.get(identity) : void 0;
+		const historyMessage = historyIndex === void 0 ? void 0 : params.historyMessages[historyIndex];
+		if (historyIndex === void 0 || historyIndex <= previousHistoryIndex || historyIndex > historyBoundaryIndex || !historyMessage || serializeCodexMirrorSourceEvidence(historyMessage) !== serializeCodexMirrorSourceEvidence(mirroredMessage)) return;
+		previousHistoryIndex = historyIndex;
+	}
+	return {
+		source: "openclaw-transcript",
+		messages: Object.freeze(structuredClone(params.historyMessages.slice(0, historyBoundaryIndex + 1)))
+	};
+}
+/** Reads and freezes the current active transcript branch after mirroring has settled. */
+async function captureCodexSettledTurnFinalizationContext(params) {
+	try {
+		const historyMessages = await readCodexMirroredSessionHistoryMessages(params);
+		if (!historyMessages) return;
+		return buildCodexSettledTurnFinalizationContext({
+			historyMessages,
+			mirroredMessages: params.mirroredMessages,
+			settledMessages: params.settledMessages,
+			turnId: params.turnId
+		});
+	} catch (error) {
+		embeddedAgentLog.warn("codex settled-turn finalization context capture failed", {
+			error: formatErrorMessage(error),
+			turnId: params.turnId
+		});
+		return;
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
 const SENSITIVE_FIELD_RE = /(?:authorization|cookie|credential|key|password|passwd|secret|token)/iu;
 const PRIVATE_PAYLOAD_FIELD_RE = /(?:image|screenshot|attachment|fileData|dataUri)/iu;
@@ -2476,6 +5018,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	const turnSucceeded = !finalAborted && !effectiveTimedOut && (finalPromptError === null || finalPromptError === void 0) && (completedTurnStatus === "completed" || recoveredTurnWatchTimeout || completedWithoutTerminalNotification);
 	if (settleCodexSourceReplyFinality(toolBridge.telemetry, turnSucceeded)) result.agentHarnessResultClassification = void 0;
 	const attemptSucceeded = turnSucceeded && result.agentHarnessResultClassification === void 0;
+	terminalState.turnSucceeded = turnSucceeded;
 	terminalState.sharedAbortAllowedAfterTerminalOutcome = shouldKeepCodexSharedAbortOpen({
 		trigger: params.trigger,
 		result,
@@ -2495,7 +5038,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	if (modelCallFailureKind) codexModelCallDiagnostics.emitError(finalPromptError ?? "codex app-server attempt interrupted", { failureKind: modelCallFailureKind });
 	else if (finalPromptError) codexModelCallDiagnostics.emitError(finalPromptError);
 	else codexModelCallDiagnostics.emitCompleted(result);
-	const assistantTranscriptOwned = await codexTranscriptMirrorRuntime.mirrorBestEffort({
+	const mirrorOutcome = await codexTranscriptMirrorRuntime.mirrorBestEffort({
 		params,
 		agentId: sessionAgentId,
 		notifyUserMessagePersisted,
@@ -2505,6 +5048,18 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		threadId: resourceState.thread.threadId,
 		turnId: activeTurnId
 	});
+	const { assistantTranscriptOwned, assistantTranscriptIdempotencyKey } = mirrorOutcome;
+	const shouldCaptureSettledTurnFinalizationContext = turnSucceeded && result.assistantTexts.every((text) => !text.trim()) && result.messagesSnapshot.some((message) => message.role === "toolResult");
+	const settledTurnFinalizationContext = shouldCaptureSettledTurnFinalizationContext ? await captureCodexSettledTurnFinalizationContext({
+		...activeTranscriptTarget,
+		mirroredMessages: mirrorOutcome.mirroredMessages,
+		settledMessages: result.messagesSnapshot,
+		turnId: activeTurnId
+	}) : void 0;
+	if (shouldCaptureSettledTurnFinalizationContext && !settledTurnFinalizationContext) embeddedAgentLog.warn("codex settled-turn finalization context is unavailable", {
+		threadId: resourceState.thread.threadId,
+		turnId: activeTurnId
+	});
 	if (activeContextEngine) {
 		const contextEnginePluginId = resolveContextEngineOwnerPluginId(activeContextEngine);
 		const isHeartbeat = params.bootstrapContextRunKind === "heartbeat" || params.bootstrapContextRunKind === "commitment-only";
@@ -2635,6 +5190,8 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		...codexAppServerFailure ? { codexAppServerFailure } : {},
 		...promptTimeoutOutcome ? { promptTimeoutOutcome } : {},
 		...assistantTranscriptOwned ? { assistantTranscriptOwned: true } : {},
+		...assistantTranscriptIdempotencyKey ? { assistantTranscriptIdempotencyKey } : {},
+		...settledTurnFinalizationContext ? { settledTurnFinalizationContext } : {},
 		...resourceState.runtimeArtifact ? { runtimeArtifact: resourceState.runtimeArtifact } : {},
 		...!finalAborted && !effectiveTimedOut && !finalPromptError && preparedAuthBinding ? { authBindingFingerprint: preparedAuthBinding.fingerprint } : {},
 		systemPromptReport
@@ -2851,7 +5408,7 @@ function createCodexAttemptLifecycleController(resources, turnRuntime) {
 				startedAt: attemptStartedAt,
 				endedAt: Date.now(),
 				...data,
-				...params.deferTerminalLifecycle ?? params.deferTerminalLifecycleEnd ? { phase: "finishing" } : {}
+				...params.deferTerminalLifecycle ? { phase: "finishing" } : {}
 			}
 		});
 		state.lifecycleTerminalEmitted = true;
@@ -2959,7 +5516,7 @@ var ClientTurnRouter = class {
 		this.nativeTurnCompletionWatchers = /* @__PURE__ */ new Map();
 		this.disposed = false;
 		client.addNotificationHandler((notification) => this.routeNotification(notification));
-		client.addRequestHandler((request) => this.routeRequest(request));
+		client.addRequestHandler((request, signal) => this.routeRequest(request, signal));
 		client.addCloseHandler(() => this.dispose());
 	}
 	reserveThread(options) {
@@ -2974,7 +5531,8 @@ var ClientTurnRouter = class {
 			gate: "open",
 			pending: [],
 			notificationTail: Promise.resolve(),
-			nativeTurnCompleted: false
+			nativeTurnCompleted: false,
+			ignoredTurnNotificationKeys: /* @__PURE__ */ new Set()
 		};
 		this.routes.set(threadId, route);
 		if (options.onNotification || options.onRequest) this.activateNow(route, options);
@@ -3057,6 +5615,7 @@ var ClientTurnRouter = class {
 		this.assertRoute(route);
 		if (route.gate !== "open") throw new Error(`codex app-server thread route cannot arm from ${route.gate}`);
 		route.gate = "armed";
+		route.ignoredTurnNotificationKeys.clear();
 		route.nativeTurnCompleted = false;
 		route.binding = deferred();
 	}
@@ -3106,7 +5665,10 @@ var ClientTurnRouter = class {
 		}
 		const handler = route.handlers.onNotification;
 		if (!handler) return;
-		if (route.gate === "bound" && scope.turnId && scope.turnId !== route.turnId) return;
+		if (route.gate === "bound" && scope.turnId && scope.turnId !== route.turnId) {
+			this.warnDroppedStaleTurnNotification(route, notification, routeScope);
+			return;
+		}
 		if (route.gate === "armed") {
 			this.bufferNotification(route, notification, routeScope, receivedAtMs);
 			return;
@@ -3115,45 +5677,66 @@ var ClientTurnRouter = class {
 		this.enqueueNotification(route, handler, notification, routeScope);
 		return route.notificationTail;
 	}
-	async routeRequest(request) {
-		if (this.disposed) return;
+	async routeRequest(request, signal = new AbortController().signal) {
+		if (this.disposed || signal.aborted) return;
 		const scope = readScope(request.params);
 		if (!scope.threadId) return;
 		const route = this.routes.get(scope.threadId);
 		if (!route || route.released) return;
-		if (!route.handlers) await route.activated.promise;
-		if (route.released || !route.handlers) return;
+		if (!route.handlers && !await waitForPromiseOrAbort(route.activated.promise, signal)) return;
+		if (signal.aborted || route.released || !route.handlers) return;
 		const handler = route.handlers.onRequest;
 		if (!handler) return;
 		while (route.gate === "armed") {
-			await route.binding?.promise;
-			if (route.released) return;
+			const binding = route.binding?.promise;
+			if (!binding || !await waitForPromiseOrAbort(binding, signal)) return;
+			if (signal.aborted || route.released) return;
 		}
 		if (route.gate === "bound") {
 			if (scope.turnId && scope.turnId !== route.turnId) return;
 			if (route.released) return;
 		}
-		await this.waitForNotifications(route);
-		if (route.released) return;
+		if (!await waitForPromiseOrAbort(this.waitForNotifications(route), signal)) return;
+		if (signal.aborted || route.released) return;
 		try {
 			const result = await handler(request, {
 				threadId: scope.threadId,
 				...scope.turnId ? { turnId: scope.turnId } : {}
-			});
-			return route.released ? void 0 : result;
+			}, signal);
+			return signal.aborted || route.released ? void 0 : result;
 		} catch (error) {
-			if (route.released) return;
+			if (signal.aborted || route.released) return;
 			throw error;
 		}
 	}
 	flushNotifications(route) {
 		const handler = route.handlers?.onNotification;
 		if (!handler) return;
-		for (const pending of route.pending.splice(0)) if (!pending.scope.turnId || route.gate !== "bound" || pending.scope.turnId === route.turnId) {
+		for (const pending of route.pending.splice(0)) {
+			if (route.gate === "bound" && pending.scope.turnId && pending.scope.turnId !== route.turnId) {
+				this.warnDroppedStaleTurnNotification(route, pending.notification, pending.scope);
+				continue;
+			}
 			route.handlers?.onNotificationReceived?.(pending.notification, pending.scope, pending.receivedAtMs);
 			this.enqueueNotification(route, handler, pending.notification, pending.scope);
 		}
 	}
+	warnDroppedStaleTurnNotification(route, notification, scope) {
+		if (notification.method === "turn/completed" || !scope.turnId || !route.turnId) return;
+		const eventKind = redactCodexEventKind(notification.method);
+		const key = JSON.stringify([notification.method, scope.turnId]);
+		if (route.ignoredTurnNotificationKeys.has(key)) return;
+		route.ignoredTurnNotificationKeys.add(key);
+		embeddedAgentLog.warn("codex app-server notification ignored for inactive turn", {
+			eventKind,
+			activeThreadId: route.threadId,
+			activeTurnId: route.turnId,
+			threadId: scope.threadId,
+			turnId: scope.turnId,
+			matchesActiveThread: true,
+			matchesActiveTurn: false
+		});
+	}
 	bufferNotification(route, notification, scope, receivedAtMs) {
 		if (route.pending.length < DEFAULT_PREBIND_NOTIFICATION_LIMIT) {
 			route.pending.push({
@@ -3242,6 +5825,20 @@ function isCodexTerminalTurnNotification(notification) {
 	if (notification.method === "turn/completed") return true;
 	return notification.method === "error" && isJsonObject(notification.params) && notification.params.willRetry === false;
 }
+async function waitForPromiseOrAbort(promise, signal) {
+	if (signal.aborted) return false;
+	let removeAbort;
+	try {
+		return await Promise.race([promise.then(() => true), new Promise((resolve) => {
+			const onAbort = () => resolve(false);
+			signal.addEventListener("abort", onAbort, { once: true });
+			removeAbort = () => signal.removeEventListener("abort", onAbort);
+			if (signal.aborted) onAbort();
+		})]);
+	} finally {
+		removeAbort?.();
+	}
+}
 function deferred() {
 	let resolve;
 	return {
@@ -3415,7 +6012,7 @@ function createCodexAttemptNotificationController(resources, turnRuntime, lifecy
 async function prepareCodexAttemptPrompt(context) {
 	const { runtime, attemptTools, historyState, hookContext, workspaceBootstrapContext, baseDeveloperInstructions, openClawPromptContext, skillsCollaborationInstructions, promptState, codexContextProjectionMaxChars } = context;
 	const { connection, buildActiveRunAttemptParams, effectiveContextTokenBudget, effectiveRuntimeModelId, effectiveRuntimeProviderId } = runtime;
-	const { params, activeContextEngine, usesSupervisionConnection, mutable, isInactiveThreadBootstrapBinding, bindingStore, bindingIdentity, agentDir, appServer, contextSessionKey, effectiveWorkspace } = connection;
+	const { params, activeContextEngine, usesSupervisionConnection, mutable, isInactiveThreadBootstrapBinding, bindingStore, bindingIdentity, agentDir, appServer, contextSessionKey, effectiveWorkspace, sandbox } = connection;
 	const { toolBridge } = attemptTools;
 	const applyFreshThreadContinuityProjection = () => {
 		const projection = projectContextEngineAssemblyForCodex({
@@ -3438,6 +6035,7 @@ async function prepareCodexAttemptPrompt(context) {
 			tokenBudget: effectiveContextTokenBudget,
 			availableTools: new Set(flattenCodexDynamicToolFunctions(toolBridge.availableSpecs).map((tool) => tool.name).filter(isNonEmptyString)),
 			citationsMode: params.config?.memory?.citations,
+			sandboxed: sandbox?.enabled === true,
 			modelId: effectiveRuntimeModelId,
 			contextEngineHostSupport: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST,
 			providerId: effectiveRuntimeProviderId,
@@ -3499,10 +6097,9 @@ async function prepareCodexAttemptPrompt(context) {
 	const buildPromptFromCurrentInputs = () => resolveAgentHarnessBeforePromptBuildResult({
 		prompt: prependCurrentInboundContext(promptState.promptText, params.currentInboundContext),
 		developerInstructions: promptState.developerInstructions,
-		messages: codexModelInputHistoryMessages,
+		messages: structuredClone(historyState.messages),
 		ctx: hookContext,
-		bootstrapContextRunKind: params.bootstrapContextRunKind,
-		..."beforeAgentStartResult" in params ? { beforeAgentStartResult: params.beforeAgentStartResult } : {}
+		bootstrapContextRunKind: params.bootstrapContextRunKind
 	});
 	const resolveShiftedPromptInputRange = (prompt, promptInputRange, turnPromptText) => {
 		if (!promptInputRange || promptInputRange.start < 0 || promptInputRange.end < promptInputRange.start || promptInputRange.end > prompt.length || !turnPromptText.endsWith(prompt)) return;
@@ -3553,8 +6150,7 @@ async function prepareCodexAttemptPrompt(context) {
 	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(turnState.promptBuild.developerInstructions, buildTurnCollaborationMode(params, {
 		turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
 		skillsCollaborationInstructions,
-		memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
-		heartbeatCollaborationInstructions: workspaceBootstrapContext.heartbeatCollaborationInstructions
+		memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions
 	}).settings.developer_instructions ?? void 0);
 	const rebuildCodexPromptBuildFromCurrentProjection = async () => {
 		turnState.promptBuild = await buildPromptFromCurrentInputs();
@@ -5517,7 +8113,7 @@ async function readFile(execServer, params) {
 	const fsBridge = requireFsBridge(execServer);
 	const stat = await fsBridge.stat({ filePath });
 	if (!stat) throw new JsonRpcProtocolError(JSON_RPC_NOT_FOUND, "file not found");
-	if (stat.type === "file" && stat.size > CODEX_SANDBOX_EXEC_SERVER_MAX_READ_FILE_BYTES) throw new Error(`file is too large to read through Codex sandbox exec-server: ${stat.size} bytes`);
+	assertSandboxFileReadWithinLimit(stat);
 	return { dataBase64: (await fsBridge.readFile({ filePath })).toString("base64") };
 }
 /** Writes base64 data to an existing sandbox directory after write-policy checks. */
@@ -5658,6 +8254,15 @@ async function copySandboxPath(execServer, params) {
 		}
 		return;
 	}
+	if (sourceStat.type === "file" && fsBridge.copyFile) {
+		await fsBridge.copyFile({
+			sourcePath: params.sourcePath,
+			destinationPath: params.destinationPath,
+			mkdir: true
+		});
+		return;
+	}
+	assertSandboxFileReadWithinLimit(sourceStat);
 	const data = await fsBridge.readFile({ filePath: params.sourcePath });
 	await fsBridge.writeFile({
 		filePath: params.destinationPath,
@@ -5665,6 +8270,9 @@ async function copySandboxPath(execServer, params) {
 		mkdir: true
 	});
 }
+function assertSandboxFileReadWithinLimit(stat) {
+	if (stat.type === "file" && stat.size > CODEX_SANDBOX_EXEC_SERVER_MAX_READ_FILE_BYTES) throw new Error(`file is too large to read through Codex sandbox exec-server: ${stat.size} bytes`);
+}
 function metadataResponse(stat) {
 	return {
 		isDirectory: stat?.type === "directory",
@@ -6662,16 +9270,17 @@ function prepareCodexAttemptResources(prompt) {
 	const retireSharedCodexClientForOneShotCleanup = async () => {
 		if (params.cleanupBundleMcpOnRunEnd !== true || state.sharedCodexClientRetiredForOneShotCleanup) return;
 		state.sharedCodexClientRetiredForOneShotCleanup = true;
-		const retired = retireSharedCodexAppServerClientIfCurrent(state.client);
-		embeddedAgentLog.info("codex app-server one-shot cleanup retired shared client", {
+		const retired = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(state.client);
+		embeddedAgentLog.info("codex app-server one-shot cleanup checked shared client retirement", {
 			runId: params.runId,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
-			activeLeases: retired?.activeLeases ?? null,
-			closed: retired?.closed ?? false,
-			matchedSharedClient: Boolean(retired)
+			activeLeases: retired.activeLeases,
+			pendingAcquires: retired.pendingAcquires,
+			closed: retired.closed,
+			matchedSharedClient: retired.found
 		});
-		if (retired?.closed) await state.client.closeAndWait({
+		if (retired.closed) await state.client.closeAndWait({
 			exitTimeoutMs: 2e3,
 			forceKillDelayMs: 250
 		});
@@ -6713,6 +9322,15 @@ function prepareCodexAttemptResources(prompt) {
 		timeoutMs: params.timeoutMs,
 		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 buildNativeHookRelayFinalConfigPatch = (decision) => {
 		state.nativeHookRelay?.unregister();
 		state.nativeHookRelay = createCodexNativeHookRelay({
@@ -6726,6 +9344,7 @@ function prepareCodexAttemptResources(prompt) {
 			config: params.config,
 			runId: params.runId,
 			channelId: hookChannelId,
+			...hasRequester ? { requester } : {},
 			attemptTimeoutMs: params.timeoutMs,
 			startupTimeoutMs,
 			turnStartTimeoutMs: params.timeoutMs,
@@ -7071,7 +9690,8 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 	const { toolBridge, toolOutcomeOrdinals, suppressedDynamicToolOutcomeOrdinals, allocateCodexToolOutcomeOrdinal } = attemptTools;
 	const { state, turnIdRef, userInputBridgeRef, openClawDynamicToolExecutions, pendingOpenClawDynamicToolCompletionIds, postToolRawAssistantCompletionIdleTimeoutMs, turnWatches } = turnRuntime;
 	const { emitExecutionPhaseOnce, scheduleTurnReleaseAfterTerminalDynamicTool, scheduleTerminalDynamicToolReleaseCheck } = lifecycle;
-	const handleServerRequest = async (request, scope) => {
+	const handleServerRequest = async (request, scope, requestSignal = new AbortController().signal) => {
+		const signal = AbortSignal.any([runAbortController.signal, requestSignal]);
 		const turnId = turnIdRef.current;
 		const projector = projectorRef.current;
 		let armCompletionWatchOnResponse = false;
@@ -7097,7 +9717,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 					turnId,
 					pluginAppPolicyContext: resourceState.thread.pluginAppPolicyContext,
 					...computerUseConfig.enabled ? { computerUseMcpServerName: computerUseConfig.mcpServerName } : {},
-					signal: runAbortController.signal
+					signal
 				});
 			}
 			if (request.method === "item/tool/requestUserInput") {
@@ -7124,7 +9744,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						turnId,
 						nativeHookRelay: resourceState.nativeHookRelay,
 						autoApprove: shouldAutoApproveCodexAppServerApprovals(appServer),
-						signal: runAbortController.signal,
+						signal,
 						onNativeToolFailureDisposition: (itemId, disposition) => projector?.recordNativeToolApprovalFailure(itemId, disposition)
 					});
 				}
@@ -7200,7 +9820,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				const { execution } = openClawDynamicToolExecutions.claim(call, () => handleDynamicToolCallWithTimeout({
 					call,
 					toolBridge,
-					signal: runAbortController.signal,
+					signal,
 					timeoutMs: dynamicToolTimeoutMs,
 					toolMeta,
 					toolCallOrdinal,
@@ -7497,7 +10117,7 @@ function buildMetadataCacheEntryKey(appCacheKey, queryKind) {
 //#endregion
 //#region extensions/codex/src/app-server/plugin-thread-config-deadline.ts
 /** Enforces one bounded startup budget across Codex plugin config discovery. */
-const CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS = 5e3;
+const CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS = 6e4;
 const CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR = 4;
 const CODEX_PLUGIN_THREAD_CONFIG_MIN_TIMEOUT_MS = 100;
 var CodexPluginThreadConfigDeadlineError = class extends Error {
@@ -8075,7 +10695,9 @@ async function startCodexAttemptRuntime(resources) {
 			stream: "codex_app_server.lifecycle",
 			data: {
 				phase: "thread_ready",
-				threadId: state.thread.threadId
+				threadId: state.thread.threadId,
+				action: state.thread.lifecycle.action,
+				clientId: state.client.getInstanceId()
 			}
 		});
 	} catch (error) {
@@ -8299,6 +10921,7 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			model: usesSupervisionConnection ? resourceState.thread.model ?? effectiveRuntimeModelId : params.modelId,
 			api: usesSupervisionConnection ? runtimeParams.model.api : params.model.api,
 			transport: appServer.start.transport,
+			observationUnit: "turn",
 			...hookContextWindowFields,
 			trace: codexModelCallTrace
 		},
@@ -8336,7 +10959,6 @@ async function prepareCodexAttemptTurnRequest(resources, turnRuntime, ensureCurr
 			turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
 			skillsCollaborationInstructions: context.skillsCollaborationInstructions,
 			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
-			heartbeatCollaborationInstructions: workspaceBootstrapContext.heartbeatCollaborationInstructions,
 			preserveNativeTurnSettings: usesSupervisionConnection
 		});
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
@@ -8561,7 +11183,11 @@ async function startCodexAttemptTurn(resources, turnRuntime, notifications, requ
 				ctx: hookContext,
 				hookRunner
 			});
-			if (!state.timedOut) await unsubscribeCodexThreadBestEffort(resourceState.client, {
+			const bindingReleased = isIncognitoSessionKey(params.sessionKey) ? await bindingStore.mutate(bindingIdentity, {
+				kind: "clear",
+				threadId: resourceState.thread.threadId
+			}) : true;
+			if (!state.timedOut && bindingReleased) await unsubscribeCodexThreadBestEffort(resourceState.client, {
 				threadId: resourceState.thread.threadId,
 				timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
 			});
@@ -9002,7 +11628,7 @@ function createCodexAttemptTurnState(resources) {
 		state.resolveCompletion = resolve;
 	});
 	const turnCompletionIdleTimeoutMs = resolveCodexTurnCompletionIdleTimeoutMs(options.turnCompletionIdleTimeoutMs ?? appServer.turnCompletionIdleTimeoutMs);
-	const turnAssistantCompletionIdleTimeoutMs = resolveCodexTurnAssistantCompletionIdleTimeoutMs(options.turnAssistantCompletionIdleTimeoutMs);
+	const turnAssistantCompletionIdleTimeoutMs = resolveCodexTurnAssistantCompletionIdleTimeoutMs(options.turnAssistantCompletionIdleTimeoutMs ?? appServer.turnAssistantCompletionIdleTimeoutMs);
 	const postToolRawAssistantCompletionIdleTimeoutMs = resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(options.postToolRawAssistantCompletionIdleTimeoutMs ?? appServer.postToolRawAssistantCompletionIdleTimeoutMs, turnAssistantCompletionIdleTimeoutMs);
 	const turnTerminalIdleTimeoutMs = resolveCodexTurnTerminalIdleTimeoutMs(options.turnTerminalIdleTimeoutMs, params.runTimeoutOverrideMs);
 	const turnAttemptIdleTimeoutMs = Math.max(100, Math.floor(params.timeoutMs));