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

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

@@ -1,32 +1,46 @@
-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-CSXLtCLE.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-Ecjyzufe.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-Bmt20HfB.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-DJbhLYSK.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-CQ_9mAa1.js";
-import { r as formatCodexDisplayText } from "./command-formatters-NCTL7A2q.js";
-import { n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-DUMF2Xyr.js";
-import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId, t as isCodexNotificationForTurn } from "./notification-correlation-C8DVQ_Bq.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 redactCodexEventKind, o as emitDynamicToolTerminalDiagnostic, p as formatCodexDynamicToolBuildStageSummary, q as toCodexDynamicToolProgressResponse, r as handleCodexAppServerElicitationRequest, rt as resolveCodexLocalRuntimeAttribution, 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-D_vSVmv9.js";
-import { a as runCodexComputerUseLiveTest, r as killStaleComputerUseMcpChildren, t as ensureCodexComputerUse } from "./computer-use-C7x4ZaqR.js";
+import { $ as withCodexStartupTimeout, A as rememberCodexRateLimitsRead, B as flattenCodexDynamicToolFunctions, D as ensureCodexAppServerClientRuntime, F as resolveCodexAppServerPreparedApiKeyCacheKey, G as CodexAppServerStartupError, I as resolveCodexAppServerPreparedAuthHandoff, J as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, K as isCodexAppServerStartupError, M as resolveCodexAppServerAuthProfileId, N as resolveCodexAppServerAuthProfileIdForAgent, O as readCodexRateLimitsRevision, P as resolveCodexAppServerFallbackApiKeyCacheKey, Q as resolveCodexTurnTerminalIdleTimeoutMs, T as isCodexAppServerRequestTimeoutError, U as resolveCodexAppServerHomeDir, V as isJsonObject, W as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, X as resolveCodexTurnAssistantCompletionIdleTimeoutMs, Y as resolveCodexStartupTimeoutMs, Z as resolveCodexTurnCompletionIdleTimeoutMs, _ as CodexAppServerRpcError, a as getLeasedSharedCodexAppServerClient, b as isCodexAppServerBrokenPipeError, d as retainSharedCodexAppServerClientIfCurrent, f as retireSharedCodexAppServerClientIfCurrent, j as resolveCodexAppServerAuthAccountCacheKey, k as readRecentCodexRateLimits, l as releaseLeasedSharedCodexAppServerClient, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, o as getSharedCodexAppServerClient, s as isCodexAppServerStartSelectionChangedError, t as clearSharedCodexAppServerClientIfCurrent, v as getCodexAppServerClientInstanceId, x as isCodexAppServerConnectionClosedError, y as isCodexAppServerApprovalRequest } from "./shared-client-BVKE40c-.js";
+import { C as isCodexAppServerApprovalPolicyAllowedByRequirements, D as resolveOpenClawExecPolicyForCodexAppServer, E as resolveCodexPluginsPolicy, S as resolveCodexModelBackedReviewerPolicyContext, T as readCodexPluginConfig, c as reclaimCurrentCodexSessionGeneration, h as resolveCodexComputerUseConfig, i as createCodexSessionGenerationSupersededError, l as sessionBindingIdentity, v as shouldAutoApproveCodexAppServerApprovals, w as isCodexSandboxExecServerEnabled, y as withMcpElicitationsApprovalPolicy } from "./session-binding-DlVQ-Pxs.js";
+import { a as closeCodexStartupClientBestEffort, l as retireCodexAppServerClientAfterTimedOutTurn, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError, s as interruptCodexTurnBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, u as unsubscribeCodexThreadBestEffort } from "./attempt-client-cleanup-Ia52yRWc.js";
+import { S as updateActiveTurnItemIds, _ as readCodexNotificationItem, a as isCodexTurnAbortMarkerNotification, b as shouldDisarmAssistantCompletionIdleWatch, c as isPendingOpenClawDynamicToolCompletionNotification, d as isRawReasoningCompletionNotification, f as isRawToolOutputCompletionNotification, g as isTerminalTurnStatus, h as isRetryableErrorNotification, i as isAssistantCompletionReleaseNotification, l as isRawAssistantProgressNotification, m as isReasoningProgressNotification, n as describeNotificationActivity, o as isFileChangePatchUpdatedNotification, p as isReasoningItemCompletionNotification, r as isAssistantCommentaryCompletionNotification, s as isNativeToolProgressNotification, t as codexExecutionToolName, u as isRawFunctionToolOutputCompletionNotification, v as readNotificationItemId, x as updateActiveCompletionBlockerItemIds, y as readRawResponseToolCallId } from "./attempt-notifications-CMR2_fmR.js";
+import { $ as readHookOutputEntries, B as resolveCodexContextEngineProjectionReserveTokens, F as buildContextEngineBinding, G as mergeCodexThreadConfigs, H as buildCodexPluginThreadConfig, I as isContextEngineBindingCompatible, K as shouldBuildCodexPluginThreadConfig, L as fitCodexProjectedContextForTurnStart, M as areCodexDynamicToolFingerprintsCompatible, N as codexDynamicToolsFingerprint, O as isSystemAgentOnlyCodexDynamicToolAllowlist, P as codexLegacyDynamicToolsFingerprint, Q as readCodexErrorNotificationMessage, R as projectContextEngineAssemblyForCodex, T as filterCodexDynamicTools, U as buildCodexPluginThreadConfigInputFingerprint, W as buildCodexPluginThreadConfigTimeoutFallback, X as extractRawAssistantText, Y as resolveRecoverableCodexPluginConfigKeys, Z as normalizeNonEmptyString, a as sanitizeCodexHistoryImagePayloads, at as readNullableString$1, b as resolveCodexAppServerThreadModelSelection, ct as splitPlanText, et as readItem, g as buildDeveloperInstructions, h as resolveCodexWebSearchPlan, it as readNonNegativeInteger, j as resolveCodexDynamicToolsLoadingForRuntime, n as buildTurnStartParams, nt as readNonEmptyString$1, ot as readNumber, r as buildCodexUserInput, rt as readNonEmptyStringArray, s as startOrResumeThread, st as readString$6, t as buildTurnCollaborationMode, tt as readItemString, w as isCodexAppServerProfilerEnabled, z as resolveCodexContextEngineProjectionMaxChars } from "./thread-lifecycle-DRg_FdzC.js";
+import { n as projectCodexThreadUsageUpdate, t as normalizeCodexResponseTokenUsage } from "./event-projector-usage-tvgb1NCX.js";
+import { a as assertCodexTurnStartResponse, l as readCodexTurn, o as readCodexDynamicToolCallParams, u as readCodexTurnCompletedNotification } from "./protocol-validators-Dm4eXZmt.js";
+import { i as defaultCodexAppInventoryCache, n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-DSXX-rXO.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
+import { d as attachCodexMirrorIdentity, f as readMirrorIdentity, i as mirrorPromptAtTurnStartBestEffort, n as createCodexAppServerUserMessagePersistenceNotifier, o as buildCodexUserPromptMessage, s as promptSnapshot, t as codexTranscriptMirrorRuntime, u as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-uKA-A4tB.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-BHRSI6Cn.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-S_PXs0ul.js";
+import { r as formatCodexDisplayText } from "./command-formatters-ico4ZFnk.js";
+import { n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BmDgseo_.js";
+import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId, t as isCodexNotificationForTurn } from "./notification-correlation-Bj_Ak_jI.js";
+import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-B4FfbcCg.js";
+import { i as resolveCodexLocalRuntimeAttribution, n as createAssistantMessage, r as createAssistantMirrorMessage, t as createAssistantCommentaryMessage } from "./event-projector-assistant-message-DTgnPPVF.js";
+import { $ as shouldSynthesizeToolProgressForItem, A as resolveCodexNativeHookRelayEvents, B as shouldReleaseTurnAfterTerminalDynamicTool, C as CodexNativeToolLifecycleProjector, D as buildCodexNativeHookRelayDisabledConfig, E as buildCodexNativeHookRelayConfig, F as isDynamicToolTerminalDiagnosticEvent, G as isNonSuccessItemStatus, H as toCodexDynamicToolProtocolResponse, I as isMatchingDynamicToolTerminalDiagnostic, J as itemName, K as isSideEffectingNativeToolItem, L as resolveDynamicToolCallTimeoutMs, M as scheduleCodexNativeHookRelayUnregister, N as handleDynamicToolCallWithTimeout, O as createCodexNativeHookRelay, P as hasPendingDynamicToolTerminalDiagnostic, Q as shouldRecordNativeToolTranscript, R as resolveTerminalDynamicToolBatchAction, T as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, U as resolveCodexToolAbortTerminalReason, V as toCodexDynamicToolProgressResponse, W as isMutatingNativeToolItem, X as itemTitle, Y as itemStatus, Z as shouldClearTerminalPresentationForNativeItem, _ as resolveCodexMessageToolProvider, a as emitDynamicToolStartedDiagnostic, b as shouldRequireCodexSandboxExecServerEnvironment, d as createCodexDynamicToolBuildStageTracker, et as unknownItemStatus, f as disableCodexPluginThreadConfig, g as resolveCodexExternalSandboxPolicyForOpenClawSandbox, h as resolveCodexAppServerHookChannelId, i as emitDynamicToolErrorDiagnostic, j as resolveCodexNativeHookRelayTtlMs, k as emitCodexNativePreToolUseFailureDiagnostic, l as settleCodexSourceReplyFinality, m as resolveCodexAppServerExecutionCwd, n as handleCodexAppServerApprovalRequest, o as emitDynamicToolTerminalDiagnostic, p as formatCodexDynamicToolBuildStageSummary, q as itemKind, r as handleCodexAppServerElicitationRequest, s as resolveCodexProviderWebSearchSupport, t as createCodexDynamicToolBridge, u as buildDynamicTools, v as resolveCodexSandboxEnvironmentSelection, x as shouldWarnCodexDynamicToolBuildStageSummary, y as shouldEnableCodexAppServerNativeToolSurface, z as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult } from "./dynamic-tools-LIt9ojep.js";
+import { a as runCodexComputerUseLiveTest, r as killStaleComputerUseMcpChildren, t as ensureCodexComputerUse } from "./computer-use-BjGylO-E.js";
 import fs from "node:fs/promises";
 import path, { posix } from "node:path";
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { asDateTimestampMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { AgentHarnessPreflightError, CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, TOOL_PROGRESS_OUTPUT_MAX_CHARS, agentHarnessAttemptTerminal, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, finalizeHarnessContextEngineTurn, formatErrorMessage, formatFastModeAutoProgressText, formatToolAggregate, formatToolProgressOutput, getAgentHarnessHookRunner, getBeforeToolCallPolicyDiagnosticState, inferToolMetaFromArgs, isActiveHarnessContextEngine, isHostScopedAgentToolActive, loadCodexBundleMcpThreadConfig, materializeRequesterScopedMcpToolsForHarnessRun, prepareHarnessNativeMcpAppPreview, projectAgentHarnessTranscriptMessageForDisplay, resolveAgentDir, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessGatewayQuestion, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import { resolveAgentDir, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { asFiniteNumber, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, callGatewayTool, cancelPendingAgentQuestionForSession, claimPendingAgentQuestionAnswer, 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, runAgentHarnessGatewayQuestion, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { listSessionEntries, parseSqliteSessionFileMarker } from "openclaw/plugin-sdk/session-store-runtime";
 import { spawn } from "node:child_process";
+import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { once } from "node:events";
 import { isIP } from "node:net";
 import { WebSocketServer } from "ws";
-import { 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 { 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 { resolveGeneratedMediaMaxBytes } from "openclaw/plugin-sdk/media-generation-runtime";
+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";
@@ -89,106 +103,2677 @@ function createCodexSteeringQueue(params) {
 			for (const item of liveItems) rejectItem(item, unavailableError);
 			throw unavailableError;
 		}
-		const clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
-		const batch = { items: liveItems };
-		dispatchedBatches.set(clientUserMessageId, batch);
+		const clientUserMessageId = `openclaw:${params.turnId}:steer:${++batchSequence}`;
+		const batch = { items: liveItems };
+		dispatchedBatches.set(clientUserMessageId, batch);
+		try {
+			await params.client.request("turn/steer", {
+				threadId: params.threadId,
+				expectedTurnId: params.turnId,
+				input: liveItems.flatMap((item) => buildCodexUserInput(item.text, item.images)),
+				clientUserMessageId
+			});
+		} catch (error) {
+			dispatchedBatches.delete(clientUserMessageId);
+			for (const item of liveItems) rejectItem(item, error);
+			throw error;
+		}
+	};
+	const enqueueSend = (items) => {
+		const send = sendChain.then(() => sendBatch(items));
+		sendChain = send;
+		send.catch((error) => {
+			for (const item of items) rejectItem(item, error);
+			embeddedAgentLog.debug("codex app-server queued steer failed", { error });
+		});
+		return send;
+	};
+	const flushBatch = () => {
+		clearBatchTimer();
+		const items = batchedMessages;
+		batchedMessages = [];
+		if (items.length === 0) return sendChain;
+		const send = enqueueSend(items);
+		send.catch(() => void 0);
+		return send;
+	};
+	const createPendingMessage = (text, images) => {
+		let resolveDelivery;
+		let rejectDelivery;
+		const delivery = new Promise((resolve, reject) => {
+			resolveDelivery = resolve;
+			rejectDelivery = reject;
+		});
+		const item = {
+			text,
+			images,
+			resolve: resolveDelivery,
+			reject: rejectDelivery,
+			settled: false
+		};
+		pendingMessages.add(item);
+		return {
+			item,
+			delivery
+		};
+	};
+	params.signal.addEventListener("abort", abortQueue, { once: true });
+	if (params.signal.aborted) abortQueue();
+	return {
+		async queue(text, options) {
+			const pendingUserInput = params.claimPendingUserInput();
+			if (pendingUserInput) {
+				if (!options?.images?.length) {
+					pendingUserInput.answer(text);
+					return;
+				}
+				flushBatch().catch(() => void 0);
+				const { item, delivery } = createPendingMessage(text, options.images);
+				await Promise.all([enqueueSend([item]).finally(() => pendingUserInput.cancel()), delivery]);
+				return;
+			}
+			if (closedError) throw closedError;
+			if (params.signal.aborted) throw new Error("codex app-server steering queue aborted");
+			const { item, delivery } = createPendingMessage(text, options?.images);
+			batchedMessages.push(item);
+			clearBatchTimer();
+			const debounceMs = normalizeCodexSteerDebounceMs(options?.debounceMs);
+			if (debounceMs === 0) flushBatch();
+			else batchTimer = setTimeout(() => {
+				batchTimer = void 0;
+				flushBatch();
+			}, debounceMs);
+			return await delivery;
+		},
+		async flushPending() {
+			if (closedError) return;
+			await flushBatch().catch(() => void 0);
+		},
+		confirmConsumed(clientUserMessageId) {
+			const batch = dispatchedBatches.get(clientUserMessageId);
+			if (!batch) return false;
+			dispatchedBatches.delete(clientUserMessageId);
+			for (const item of batch.items) resolveItem(item);
+			return true;
+		},
+		cancel: cancelQueue
+	};
+}
+/** Normalizes steer debounce milliseconds, preserving explicit zero. */
+function normalizeCodexSteerDebounceMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : CODEX_STEER_ALL_DEBOUNCE_MS;
+}
+//#endregion
+//#region extensions/codex/src/app-server/attempt-terminal.ts
+const attemptTerminal = agentHarnessAttemptTerminal;
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-assistant.ts
+var CodexAssistantProjection = class {
+	constructor(params, emitAgentEvent, matchesToolProgressEcho, nextTranscriptTimestamp) {
+		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$6(params, "itemId") ?? "assistant";
+		const delta = readString$6(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$6(item, "role");
+		const phase = readString$6(item, "phase");
+		const rawItemId = readString$6(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$6(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$6(params, "itemId");
+		const delta = readString$6(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");
+}
+function selectPreferredSessionKey(matches, sessionId) {
+	const structural = matches.filter(({ sessionKey }) => sessionKey === sessionId || sessionKey.endsWith(`:${sessionId}`));
+	const candidates = structural.length > 0 ? structural : matches;
+	if (candidates.length === 1) return candidates[0]?.sessionKey;
+	const sorted = candidates.toSorted((left, right) => (right.entry.updatedAt ?? 0) - (left.entry.updatedAt ?? 0));
+	return (sorted[0]?.entry.updatedAt ?? 0) > (sorted[1]?.entry.updatedAt ?? 0) ? sorted[0]?.sessionKey : void 0;
+}
+/** Returns sanitized session-context messages for a Codex mirrored session file. */
+async function readCodexMirroredSessionHistoryMessages(target) {
+	try {
+		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();
+	const entries = listSessionEntries({
+		agentId: marker.agentId,
+		readOnly: true,
+		storePath: marker.storePath
+	});
+	if (explicitSessionKey) {
+		const explicitEntry = entries.find(({ sessionKey }) => sessionKey === explicitSessionKey);
+		if (explicitEntry) return explicitEntry.entry.sessionId === marker.sessionId ? explicitSessionKey : void 0;
+	}
+	return selectPreferredSessionKey(entries.filter(({ entry }) => entry.sessionId === marker.sessionId), marker.sessionId);
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-tool-transcript.ts
+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();
+		this.nativeMcpAppResultDetails = /* @__PURE__ */ new Map();
+		this.nativeMcpAppResultDetailsAttempted = /* @__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,
+			details: params.details
+		});
+	}
+	recordNativeToolCall(item) {
+		if (!item || !shouldRecordNativeToolTranscript(item)) return;
+		const name = itemName(item);
+		if (name) this.recordToolCall({
+			id: item.id,
+			name,
+			arguments: itemToolArgs(item)
+		});
+	}
+	recordNativeToolResult(item, details) {
+		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)),
+			details
+		});
+	}
+	async recordNativeToolResultWithDetails(item) {
+		this.recordNativeToolResult(item, await this.prepareNativeMcpAppResultDetails(item));
+	}
+	async prepareNativeMcpAppResultDetails(item) {
+		if (!item || item.type !== "mcpToolCall" || itemStatus(item) === "running") return;
+		if (this.nativeMcpAppResultDetails.has(item.id)) return this.nativeMcpAppResultDetails.get(item.id);
+		if (this.nativeMcpAppResultDetailsAttempted.has(item.id) || !this.options.prepareNativeMcpAppResultDetails) return;
+		this.nativeMcpAppResultDetailsAttempted.add(item.id);
+		try {
+			const details = await this.options.prepareNativeMcpAppResultDetails(item);
+			if (details !== void 0) this.nativeMcpAppResultDetails.set(item.id, details);
+			return details;
+		} catch (error) {
+			embeddedAgentLog.debug("codex native MCP App preview preparation failed", {
+				itemId: item.id,
+				error
+			});
+			return;
+		}
+	}
+	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
+			}],
+			...params.details !== void 0 ? { details: params.details } : {},
+			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$6(params, "reviewId"),
+				targetItemId: readNullableString$1(params, "targetItemId"),
+				decisionSource: readString$6(params, "decisionSource"),
+				status: review ? readString$6(review, "status") : void 0,
+				riskLevel: review ? readString$6(review, "riskLevel") : void 0,
+				userAuthorization: review ? readString$6(review, "userAuthorization") : void 0,
+				rationale: review ? readNullableString$1(review, "rationale") : void 0,
+				actionType: action ? readString$6(action, "type") : void 0
+			}
+		});
+	}
+	handleGuardianWarning(params) {
+		this.emitAgentEvent({
+			stream: "codex_app_server.guardian",
+			data: {
+				phase: "warning",
+				message: readString$6(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$6(run, "id"),
+				eventName: readString$6(run, "eventName"),
+				handlerType: readString$6(run, "handlerType"),
+				executionMode: readString$6(run, "executionMode"),
+				scope: readString$6(run, "scope"),
+				source: readString$6(run, "source"),
+				sourcePath: readString$6(run, "sourcePath"),
+				status: readString$6(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";
+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$6(item, "type") !== "image_generation_call") return;
+		const result = readString$6(item, "result");
+		if (!result) return;
+		const itemId = readString$6(item, "id") ?? `raw-image-${this.itemIds.size}`;
+		this.itemIds.add(itemId);
+		const maxBytes = resolveGeneratedMediaMaxBytes(this.config, "image");
+		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$6(item, "revised_prompt") ?? readString$6(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;
+}
+//#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$6(params, "itemId") ?? "reasoning";
+		const delta = readString$6(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$6(params, "itemId") ?? "plan";
+		const delta = readString$6(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$6(record, "step");
+			if (!step) return [];
+			return [{
+				step,
+				status: normalizePlanStepStatus(readString$6(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
+/**
+* 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$5(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$5(nestedError, "message") ?? message,
+		codexErrorInfo: nestedError.codexErrorInfo,
+		rateLimits
+	};
+}
+function readString$5(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,
+			prepareNativeMcpAppResultDetails: options.prepareNativeMcpAppResultDetails,
+			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 {
+			terminal: attemptTerminal.normalize({
+				aborted: this.aborted,
+				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$6(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$6(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);
+		await this.toolTranscriptProjection.recordNativeToolResultWithDetails(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);
+			await this.toolTranscriptProjection.recordNativeToolResultWithDetails(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$6(error, "message") : void 0,
+			codexErrorInfo: error?.codexErrorInfo,
+			rateLimits: this.options.readRecentRateLimits?.()
+		});
+		return usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : readCodexErrorNotificationMessage(params);
+	}
+	emitAgentEvent(event) {
 		try {
-			await params.client.request("turn/steer", {
-				threadId: params.threadId,
-				expectedTurnId: params.turnId,
-				input: liveItems.flatMap((item) => buildCodexUserInput(item.text, item.images)),
-				clientUserMessageId
+			emitAgentEvent({
+				runId: this.params.runId,
+				stream: event.stream,
+				data: event.data,
+				...this.params.sessionKey ? { sessionKey: this.params.sessionKey } : {}
 			});
 		} catch (error) {
-			dispatchedBatches.delete(clientUserMessageId);
-			for (const item of liveItems) rejectItem(item, error);
-			throw error;
+			embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
 		}
-	};
-	const enqueueSend = (items) => {
-		const send = sendChain.then(() => sendBatch(items));
-		sendChain = send;
-		send.catch((error) => {
-			for (const item of items) rejectItem(item, error);
-			embeddedAgentLog.debug("codex app-server queued steer failed", { error });
-		});
-		return send;
-	};
-	const flushBatch = () => {
-		clearBatchTimer();
-		const items = batchedMessages;
-		batchedMessages = [];
-		if (items.length === 0) return sendChain;
-		const send = enqueueSend(items);
-		send.catch(() => void 0);
-		return send;
-	};
-	const createPendingMessage = (text, images) => {
-		let resolveDelivery;
-		let rejectDelivery;
-		const delivery = new Promise((resolve, reject) => {
-			resolveDelivery = resolve;
-			rejectDelivery = reject;
-		});
-		const item = {
-			text,
-			images,
-			resolve: resolveDelivery,
-			reject: rejectDelivery,
-			settled: false
-		};
-		pendingMessages.add(item);
-		return {
-			item,
-			delivery
+		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$6(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/native-mcp-app.ts
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString$4(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readMcpAppResourceUri(item) {
+	const uri = readString$4(asRecord(item.appContext)?.resourceUri) ?? readString$4(item.mcpAppResourceUri);
+	return uri?.startsWith("ui://") ? uri : void 0;
+}
+function readMcpToolResult(item) {
+	const result = asRecord(item.result);
+	if (!result || !Array.isArray(result.content)) return;
+	const resultMeta = asRecord(result["_meta"]);
+	return {
+		content: result.content,
+		...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {},
+		...result.isError === true ? { isError: true } : {},
+		...resultMeta ? { _meta: resultMeta } : {}
+	};
+}
+function statusTools(status) {
+	return Object.entries(status.tools).map(([name, value]) => Object.assign({}, asRecord(value), { name }));
+}
+function createNativeMcpRuntime(params) {
+	let catalog = null;
+	let statuses;
+	const createdAt = Date.now();
+	const loadStatuses = async () => {
+		if (statuses) return statuses;
+		statuses = (await params.client.request("mcpServerStatus/list", {
+			threadId: params.threadId,
+			detail: "full"
+		})).data;
+		return statuses;
+	};
+	const getCatalog = async () => {
+		if (catalog) return catalog;
+		const loaded = await loadStatuses();
+		catalog = {
+			version: 1,
+			generatedAt: Date.now(),
+			servers: Object.fromEntries(loaded.map((status) => [status.name, {
+				serverName: status.name,
+				launchSummary: "Codex native MCP connection",
+				toolCount: Object.keys(status.tools).length
+			}])),
+			tools: loaded.flatMap((status) => statusTools(status).map((tool) => ({
+				serverName: status.name,
+				safeServerName: status.name,
+				toolName: String(tool.name),
+				inputSchema: asRecord(tool.inputSchema) ?? { type: "object" },
+				fallbackDescription: readString$4(tool.description) ?? String(tool.name)
+			})))
 		};
+		return catalog;
 	};
-	params.signal.addEventListener("abort", abortQueue, { once: true });
-	if (params.signal.aborted) abortQueue();
-	return {
-		async queue(text, options) {
-			const pendingUserInput = params.claimPendingUserInput();
-			if (pendingUserInput) {
-				if (!options?.images?.length) {
-					pendingUserInput.answer(text);
-					return;
-				}
-				flushBatch().catch(() => void 0);
-				const { item, delivery } = createPendingMessage(text, options.images);
-				await Promise.all([enqueueSend([item]).finally(() => pendingUserInput.cancel()), delivery]);
-				return;
-			}
-			if (closedError) throw closedError;
-			if (params.signal.aborted) throw new Error("codex app-server steering queue aborted");
-			const { item, delivery } = createPendingMessage(text, options?.images);
-			batchedMessages.push(item);
-			clearBatchTimer();
-			const debounceMs = normalizeCodexSteerDebounceMs(options?.debounceMs);
-			if (debounceMs === 0) flushBatch();
-			else batchTimer = setTimeout(() => {
-				batchTimer = void 0;
-				flushBatch();
-			}, debounceMs);
-			return await delivery;
+	const runtime = {
+		sessionId: params.attempt.sessionId,
+		sessionKey: params.attempt.sessionKey,
+		workspaceDir: params.attempt.workspaceDir,
+		configFingerprint: `${getCodexAppServerClientInstanceId(params.client)}:${params.threadId}`,
+		mcpAppsEnabled: true,
+		createdAt,
+		lastUsedAt: createdAt,
+		acquireLease: () => retainSharedCodexAppServerClientIfCurrent(params.client) ?? (() => {}),
+		getCatalog,
+		peekCatalog: () => catalog,
+		markUsed: () => {
+			runtime.lastUsedAt = Date.now();
 		},
-		async flushPending() {
-			if (closedError) return;
-			await flushBatch().catch(() => void 0);
+		callTool: async (serverName, toolName, input) => await params.client.request("mcpServer/tool/call", {
+			threadId: params.threadId,
+			server: serverName,
+			tool: toolName,
+			arguments: asRecord(input) ?? {}
+		}),
+		listTools: async (serverName) => {
+			const status = (await loadStatuses()).find((entry) => entry.name === serverName);
+			return { tools: status ? statusTools(status) : [] };
 		},
-		confirmConsumed(clientUserMessageId) {
-			const batch = dispatchedBatches.get(clientUserMessageId);
-			if (!batch) return false;
-			dispatchedBatches.delete(clientUserMessageId);
-			for (const item of batch.items) resolveItem(item);
-			return true;
+		readResource: async (serverName, uri) => await params.client.request("mcpServer/resource/read", {
+			threadId: params.threadId,
+			server: serverName,
+			uri
+		}),
+		listResources: async (serverName) => {
+			return { resources: (await loadStatuses()).find((entry) => entry.name === serverName)?.resources ?? [] };
 		},
-		cancel: cancelQueue
+		listResourceTemplates: async (serverName) => {
+			return { resourceTemplates: (await loadStatuses()).find((entry) => entry.name === serverName)?.resourceTemplates ?? [] };
+		},
+		dispose: async () => {}
+	};
+	return runtime;
+}
+function createCodexNativeMcpAppResultDetailsPreparer(params) {
+	if (params.attempt.config?.mcp?.apps?.enabled !== true) return;
+	const runtime = createNativeMcpRuntime(params);
+	return async (item) => {
+		const serverName = readString$4(item.server);
+		const toolName = readString$4(item.tool);
+		const uiResourceUri = readMcpAppResourceUri(item);
+		const toolResult = readMcpToolResult(item);
+		if (!serverName || !toolName || !uiResourceUri || !toolResult) return;
+		const allowedAppToolNames = new Set((await runtime.getCatalog()).tools.filter((tool) => tool.serverName === serverName).map((tool) => tool.toolName));
+		if (allowedAppToolNames.size === 0) return;
+		return await prepareHarnessNativeMcpAppPreview({
+			runtime,
+			serverName,
+			toolName,
+			uiResourceUri,
+			toolCallId: item.id,
+			toolInput: item.arguments ?? {},
+			toolResult,
+			allowedAppToolNames,
+			...toolResult["_meta"] !== void 0 ? { resultMetaState: "unavailable" } : {}
+		});
 	};
 }
-/** Normalizes steer debounce milliseconds, preserving explicit zero. */
-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
 /** Bridges Codex request_user_input calls to gateway questions and secret text prompts. */
@@ -258,6 +2843,7 @@ function createCodexUserInputBridge(params) {
 					questions: requestParams.questions,
 					sessionKey: params.paramsForRun.sessionKey ?? params.paramsForRun.sessionId,
 					agentId: params.paramsForRun.agentId,
+					runId: params.paramsForRun.runId,
 					timeoutMs: requestParams.autoResolutionMs ?? params.paramsForRun.timeoutMs ?? DEFAULT_USER_INPUT_TIMEOUT_MS,
 					gatewayCall,
 					delivery: params.paramsForRun,
@@ -267,7 +2853,7 @@ function createCodexUserInputBridge(params) {
 					},
 					signal: abort.signal
 				});
-				return result.status === "answered" ? result.answers : emptyUserInputResponse();
+				return result.status === "answered" ? gatewayAnswersToCodexResponse(result.answers.answers) : emptyUserInputResponse();
 			} catch (error) {
 				embeddedAgentLog.warn("failed to bridge codex user input through gateway", { error });
 				return emptyUserInputResponse();
@@ -350,6 +2936,9 @@ function readOption(value) {
 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();
 }
@@ -374,6 +2963,11 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 	const { emitExecutionPhaseOnce, emitLifecycleStart, maybeAnnounceFastModeAutoOff } = lifecycle;
 	const { enqueueNotification } = notifications;
 	const activeTurnId = turn.turn.id;
+	const prepareNativeMcpAppResultDetails = createCodexNativeMcpAppResultDetailsPreparer({
+		client: resourceState.client,
+		threadId: resourceState.thread.threadId,
+		attempt: dynamicToolParams
+	});
 	const streamState = {
 		eventEmitted: false,
 		needsTerminalSnapshot: false
@@ -406,6 +3000,7 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 		runAbortSignal: runAbortController.signal,
 		trajectoryRecorder,
 		onNativeToolResultRecorded: maybeAnnounceFastModeAutoOff,
+		...prepareNativeMcpAppResultDetails ? { prepareNativeMcpAppResultDetails } : {},
 		upstreamUserText: turnState.codexTurnPromptText,
 		onContextCompacted: () => {
 			computerContextEpoch.value += 1;
@@ -471,9 +3066,11 @@ async function activateCodexAttemptTurn(resources, turnRuntime, lifecycle, notif
 			await activeSteeringQueue.queue(text, optionsLocal);
 		},
 		isStreaming: () => !state.completed && !runAbortController.signal.aborted,
+		isAborted: () => 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"),
@@ -536,7 +3133,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;
@@ -566,10 +3163,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();
@@ -603,7 +3207,8 @@ const codexWorkspaceDirCache = /* @__PURE__ */ new Set();
 //#region extensions/codex/src/app-server/run-attempt-lifecycle.ts
 const CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN = 4;
 function shouldKeepCodexSharedAbortOpen(params) {
-	if (params.explicitCancellationObserved || params.result.aborted || params.result.externalAbort) return false;
+	const terminal = attemptTerminal.project(params.result.terminal);
+	if (params.explicitCancellationObserved || terminal.aborted || terminal.externalAbort) return false;
 	return params.trigger === "memory" || !params.attemptSucceeded;
 }
 function withCodexAppServerFastModeServiceTier(appServer, params) {
@@ -830,19 +3435,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;
@@ -938,6 +3535,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);
@@ -954,7 +3559,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 	const runtimeArtifactRequest = params.captureRuntimeArtifact || params.expectedRuntimeArtifact ? params.expectedRuntimeArtifact ? { expected: params.expectedRuntimeArtifact } : {} : void 0;
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
-	const { sessionAgentId } = resolveSessionAgentIds$1({
+	const { sessionAgentId } = resolveSessionAgentIds({
 		sessionKey: params.sessionKey,
 		config: params.config,
 		agentId: params.agentId
@@ -978,7 +3583,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		config: params.config,
 		agentId: sessionAgentId
 	});
-	const agentDir = params.agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId);
+	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
 	const bindingIdentity = sessionBindingIdentity({
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
@@ -995,23 +3600,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;
@@ -1034,6 +3643,7 @@ async function prepareCodexAttemptConnection({ params, options }) {
 		authProfileId: resolvedStartupAuthProfileId,
 		authProfileStore: params.authProfileStore,
 		agentDir,
+		...pluginConfig.appServer?.homeScope ? { homeScope: pluginConfig.appServer.homeScope } : {},
 		config: params.config,
 		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a forwarded OpenAI OAuth or token profile.",
 		subscriptionProfileUnusableError: "Prepared Codex subscription auth profile is unusable."
@@ -1087,6 +3697,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,
@@ -1148,16 +3759,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,
@@ -1210,24 +3825,20 @@ async function prepareCodexAttemptConnection({ params, options }) {
 * system-prompt reports, and context-engine projection decisions.
 */
 const CODEX_NATIVE_PROJECT_DOC_BASENAMES = /* @__PURE__ */ new Set(["agents.md"]);
-const CODEX_INHERITED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = /* @__PURE__ */ new Set(["tools.md"]);
 const CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = /* @__PURE__ */ new Set([
 	"identity.md",
 	"soul.md",
 	"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_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = new Set(CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES);
 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([
 	["soul.md", 10],
 	["identity.md", 20],
 	["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) {
@@ -1326,22 +3937,17 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 			excludeMemory: memoryToolsAvailable,
 			memoryWorkspaceDir: params.effectiveWorkspace
 		});
-		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],
 			memoryToolRouted: memoryToolsAvailable,
 			promptContext: renderCodexWorkspaceBootstrapPromptContext(promptContextFiles),
-			developerInstructions: renderCodexWorkspaceThreadDeveloperInstructions(developerInstructionFiles),
 			turnScopedDeveloperInstructions: renderCodexWorkspaceCollaborationDeveloperInstructions(turnScopedDeveloperInstructionFiles),
 			memoryCollaborationInstructions: shouldInjectCodexOpenClawPromptContext(params.params) ? await renderCodexWorkspaceMemoryCollaborationInstructions({
 				files: memoryReferenceFiles,
@@ -1351,8 +3957,7 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 				agentId: params.params.agentId ?? params.sessionAgentId,
 				agentSessionKey: params.sessionKey,
 				sandboxed: params.sandboxed
-			}) : void 0,
-			heartbeatCollaborationInstructions: renderCodexWorkspaceHeartbeatReference(heartbeatReferenceFiles)
+			}) : void 0
 		};
 	} catch (error) {
 		embeddedAgentLog.warn("failed to load codex workspace bootstrap instructions", { error });
@@ -1391,7 +3996,7 @@ function buildCodexSystemPromptReport(params) {
 		injectedWorkspaceFiles: buildCodexBootstrapInjectionStats({
 			bootstrapFiles: params.workspaceBootstrapContext.bootstrapFiles,
 			injectedFiles: params.workspaceBootstrapContext.promptContextFiles ?? [],
-			developerInstructionFiles: [...params.workspaceBootstrapContext.developerInstructionFiles ?? [], ...params.workspaceBootstrapContext.turnScopedDeveloperInstructionFiles ?? []],
+			developerInstructionFiles: params.workspaceBootstrapContext.turnScopedDeveloperInstructionFiles ?? [],
 			memoryToolRoutedBootstrapFiles: params.workspaceBootstrapContext.memoryToolRoutedBootstrapFiles ?? [],
 			memoryToolRouted: params.workspaceBootstrapContext.memoryToolRouted === true
 		}),
@@ -1474,14 +4079,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,
@@ -1605,7 +4205,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. 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",
 		"",
@@ -1619,15 +4219,12 @@ 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);
 	}).toSorted(compareCodexContextFiles);
 }
-function selectCodexWorkspaceInheritedDeveloperInstructionFiles(contextFiles) {
-	return selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, CODEX_INHERITED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES);
-}
 function selectCodexWorkspaceTurnScopedDeveloperInstructionFiles(contextFiles) {
 	return selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES);
 }
@@ -1637,13 +4234,6 @@ function selectCodexWorkspaceDeveloperInstructionFiles(contextFiles, basenames)
 		return baseName && basenames.has(baseName) && !isMissingCodexBootstrapContextFile(file) && file.content.trim().length > 0;
 	}).toSorted(compareCodexContextFiles);
 }
-function renderCodexWorkspaceThreadDeveloperInstructions(files) {
-	return renderCodexWorkspaceDeveloperInstructions({
-		files,
-		header: "## OpenClaw Workspace Instructions",
-		preamble: "OpenClaw loaded these workspace instruction files from the active agent workspace. Internalize and follow them accordingly."
-	});
-}
 function renderCodexWorkspaceCollaborationDeveloperInstructions(files) {
 	return renderCodexWorkspaceDeveloperInstructions({
 		files,
@@ -1666,22 +4256,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({
@@ -1771,151 +4345,50 @@ function isCodexWorkspaceRootMemoryPath(params) {
 	return (path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(params.workspaceDir, filePath)) === path.join(path.resolve(params.workspaceDir), "MEMORY.md");
 }
 function isSameCodexWorkspacePath(left, right) {
-	return path.resolve(left) === path.resolve(right);
-}
-/**
-* Remaps bootstrap file paths from the resolved workspace to the effective Codex
-* workspace while preserving platform path separators.
-*/
-function remapCodexContextFilePath(params) {
-	const relativePath = path.relative(params.sourceWorkspaceDir, params.file.path);
-	if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath) || params.sourceWorkspaceDir === params.targetWorkspaceDir) return params.file;
-	const targetUsesPosixSeparators = params.targetWorkspaceDir.includes("/") && !params.targetWorkspaceDir.includes("\\");
-	const normalizedRelativePath = targetUsesPosixSeparators ? relativePath.replaceAll("\\", "/") : relativePath.replaceAll("/", "\\");
-	return {
-		...params.file,
-		path: targetUsesPosixSeparators ? path.posix.join(params.targetWorkspaceDir, normalizedRelativePath) : path.win32.join(params.targetWorkspaceDir, normalizedRelativePath)
-	};
-}
-function compareCodexContextFiles(left, right) {
-	const leftPath = normalizeCodexContextFilePath(left.path);
-	const rightPath = normalizeCodexContextFilePath(right.path);
-	const leftBase = getCodexContextFileBasename(left.path);
-	const rightBase = getCodexContextFileBasename(right.path);
-	const leftOrder = CODEX_BOOTSTRAP_CONTEXT_ORDER.get(leftBase) ?? Number.MAX_SAFE_INTEGER;
-	const rightOrder = CODEX_BOOTSTRAP_CONTEXT_ORDER.get(rightBase) ?? Number.MAX_SAFE_INTEGER;
-	if (leftOrder !== rightOrder) return leftOrder - rightOrder;
-	if (leftBase !== rightBase) return leftBase.localeCompare(rightBase);
-	return leftPath.localeCompare(rightPath);
-}
-function compareCodexBootstrapFiles(left, right) {
-	return compareCodexContextFiles(toCodexEmbeddedContextFile(left), toCodexEmbeddedContextFile(right));
-}
-function normalizeCodexContextFilePath(filePath) {
-	return filePath.trim().replaceAll("\\", "/").toLowerCase();
-}
-function getCodexContextFileDisplayBasename(filePath) {
-	return filePath.trim().replaceAll("\\", "/").split("/").pop()?.trim() ?? "";
-}
-function getCodexContextFileBasename(filePath) {
-	return normalizeCodexContextFilePath(filePath).split("/").pop() ?? "";
-}
-function normalizeCodexDynamicToolName(name) {
-	return name.trim().toLowerCase();
-}
-function isNonEmptyString$1(value) {
-	return typeof value === "string" && value.length > 0;
-}
-//#endregion
-//#region extensions/codex/src/app-server/run-attempt-state.ts
-async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields) {
-	const currentBinding = await bindingStore.read(identity);
-	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
-	if (!expectedThreadId) return;
-	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
-		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
-			...fields,
-			boundThreadId: currentBinding.threadId
-		});
-		return;
-	}
-	if (currentBinding?.connectionScope === "supervision") {
-		embeddedAgentLog.warn("codex app-server image payload error detected for supervised thread; preserving native binding", fields);
-		return;
-	}
-	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
-	await bindingStore.mutate(identity, {
-		kind: "clear",
-		threadId: expectedThreadId
-	});
-}
-async function markCodexAppServerBindingCoveredThroughTurn(params) {
-	await params.bindingStore.mutate(params.identity, {
-		kind: "patch",
-		threadId: params.threadId,
-		patch: { historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString() }
-	});
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.length > 0;
-}
-function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
-	if (!params.contextEngineActive || params.thread.lifecycle.action !== "resumed") return false;
-	const message = formatErrorMessage(params.error);
-	return /ran out of room in the model'?s context window/iu.test(message) || /context window/iu.test(message) || /context length/iu.test(message) || /maximum context/iu.test(message) || /too many tokens/iu.test(message);
-}
-function isCodexActiveCompactTurnError(error) {
-	if (!(error instanceof CodexAppServerRpcError)) return false;
-	const data = isJsonObject(error.data) ? error.data : void 0;
-	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
-	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
+	return path.resolve(left) === path.resolve(right);
 }
-function readCodexFinalizationHookNotification(notification, threadId, turnId) {
-	if (notification.method !== "hook/started" && notification.method !== "hook/completed") return;
-	const params = isJsonObject(notification.params) ? notification.params : void 0;
-	const run = params && isJsonObject(params.run) ? params.run : void 0;
-	if (params?.threadId !== threadId || params.turnId !== turnId || run?.eventName !== "stop" && run?.eventName !== "subagentStop" || typeof run.id !== "string" || !run.id) return;
-	if (notification.method === "hook/started") return {
-		phase: "started",
-		runId: run.id
-	};
+/**
+* Remaps bootstrap file paths from the resolved workspace to the effective Codex
+* workspace while preserving platform path separators.
+*/
+function remapCodexContextFilePath(params) {
+	const relativePath = path.relative(params.sourceWorkspaceDir, params.file.path);
+	if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath) || params.sourceWorkspaceDir === params.targetWorkspaceDir) return params.file;
+	const targetUsesPosixSeparators = params.targetWorkspaceDir.includes("/") && !params.targetWorkspaceDir.includes("\\");
+	const normalizedRelativePath = targetUsesPosixSeparators ? relativePath.replaceAll("\\", "/") : relativePath.replaceAll("/", "\\");
 	return {
-		phase: "completed",
-		runId: run.id,
-		status: typeof run.status === "string" ? run.status : void 0
+		...params.file,
+		path: targetUsesPosixSeparators ? path.posix.join(params.targetWorkspaceDir, normalizedRelativePath) : path.win32.join(params.targetWorkspaceDir, normalizedRelativePath)
 	};
 }
-function joinPresentSections(...sections) {
-	return sections.filter((section) => Boolean(section?.trim())).join("\n\n");
+function compareCodexContextFiles(left, right) {
+	const leftPath = normalizeCodexContextFilePath(left.path);
+	const rightPath = normalizeCodexContextFilePath(right.path);
+	const leftBase = getCodexContextFileBasename(left.path);
+	const rightBase = getCodexContextFileBasename(right.path);
+	const leftOrder = CODEX_BOOTSTRAP_CONTEXT_ORDER.get(leftBase) ?? Number.MAX_SAFE_INTEGER;
+	const rightOrder = CODEX_BOOTSTRAP_CONTEXT_ORDER.get(rightBase) ?? Number.MAX_SAFE_INTEGER;
+	if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+	if (leftBase !== rightBase) return leftBase.localeCompare(rightBase);
+	return leftPath.localeCompare(rightPath);
 }
-function prependCurrentInboundContext(prompt, context) {
-	const text = context?.text.trim();
-	return text ? [text, prompt].filter(Boolean).join("\n\n") : prompt;
+function compareCodexBootstrapFiles(left, right) {
+	return compareCodexContextFiles(toCodexEmbeddedContextFile(left), toCodexEmbeddedContextFile(right));
 }
-function waitForCodexNotificationDispatchTurn() {
-	return new Promise((resolve) => {
-		setImmediate(resolve);
-	});
+function normalizeCodexContextFilePath(filePath) {
+	return filePath.trim().replaceAll("\\", "/").toLowerCase();
 }
-function buildCodexAppServerTimeoutDiagnostics(params) {
-	const readString = (key) => {
-		const value = params.details?.[key];
-		return typeof value === "string" && value.trim() ? value : void 0;
-	};
-	const readNumber = (key) => {
-		const value = params.details?.[key];
-		return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-	};
-	const readBoolean = (key) => {
-		const value = params.details?.[key];
-		return typeof value === "boolean" ? value : void 0;
-	};
-	return {
-		...params.idleMs !== void 0 ? { idleMs: params.idleMs } : {},
-		...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
-		...params.lastActivityReason ? { lastActivityReason: params.lastActivityReason } : {},
-		...readString("lastNotificationMethod") ? { lastNotificationMethod: readString("lastNotificationMethod") } : {},
-		...readString("lastNotificationItemId") ? { lastNotificationItemId: readString("lastNotificationItemId") } : {},
-		...readString("lastNotificationItemType") ? { lastNotificationItemType: readString("lastNotificationItemType") } : {},
-		...readString("lastNotificationItemRole") ? { lastNotificationItemRole: readString("lastNotificationItemRole") } : {},
-		...readString("lastAssistantTextPreview") ? { lastAssistantTextPreview: readString("lastAssistantTextPreview") } : {},
-		...readNumber("activeAppServerTurnRequests") !== void 0 ? { activeAppServerTurnRequests: readNumber("activeAppServerTurnRequests") } : {},
-		...readNumber("activeTurnItemCount") !== void 0 ? { activeTurnItemCount: readNumber("activeTurnItemCount") } : {},
-		...readBoolean("terminalTurnNotificationQueued") !== void 0 ? { terminalTurnNotificationQueued: readBoolean("terminalTurnNotificationQueued") } : {},
-		...readBoolean("completionIdleWatchArmed") !== void 0 ? { completionIdleWatchArmed: readBoolean("completionIdleWatchArmed") } : {},
-		...readBoolean("assistantCompletionIdleWatchArmed") !== void 0 ? { assistantCompletionIdleWatchArmed: readBoolean("assistantCompletionIdleWatchArmed") } : {},
-		...readBoolean("terminalIdleWatchArmed") !== void 0 ? { terminalIdleWatchArmed: readBoolean("terminalIdleWatchArmed") } : {}
-	};
+function getCodexContextFileDisplayBasename(filePath) {
+	return filePath.trim().replaceAll("\\", "/").split("/").pop()?.trim() ?? "";
+}
+function getCodexContextFileBasename(filePath) {
+	return normalizeCodexContextFilePath(filePath).split("/").pop() ?? "";
+}
+function normalizeCodexDynamicToolName(name) {
+	return name.trim().toLowerCase();
+}
+function isNonEmptyString$1(value) {
+	return typeof value === "string" && value.length > 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt-context.ts
@@ -1988,7 +4461,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		memoryToolNames: getCodexWorkspaceMemoryToolNames(toolBridge.availableSpecs),
 		sandboxed: sandbox?.enabled === true
 	});
-	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs }), workspaceBootstrapContext.developerInstructions);
+	const baseDeveloperInstructions = buildDeveloperInstructions(runtimeParams, { dynamicTools: toolBridge.availableSpecs });
 	return {
 		runtime,
 		attemptTools,
@@ -2020,7 +4493,7 @@ async function prepareCodexAttemptContext(runtime, attemptTools) {
 		},
 		codexContextProjectionMaxChars: resolveCodexContextEngineProjectionMaxChars({
 			contextTokenBudget: effectiveContextTokenBudget,
-			reserveTokens: resolveCodexContextEngineProjectionReserveTokens({ config: params.config })
+			reserveTokens: resolveCodexContextEngineProjectionReserveTokens()
 		})
 	};
 }
@@ -2196,14 +4669,10 @@ function resolveCodexAppServerReplayBlockedReason(result) {
 /** Builds an attempt result for failures before the app-server turn starts. */
 function buildCodexTurnStartFailureResult(params) {
 	return {
-		aborted: false,
-		externalAbort: false,
-		timedOut: false,
-		idleTimedOut: false,
-		timedOutDuringCompaction: false,
-		timedOutDuringToolExecution: false,
-		promptError: params.promptError ?? params.message,
-		promptErrorSource: "prompt",
+		terminal: attemptTerminal.normalize({
+			promptError: params.promptError ?? params.message,
+			promptErrorSource: "prompt"
+		}),
 		sessionIdUsed: params.params.sessionId,
 		messagesSnapshot: params.messagesSnapshot,
 		assistantTexts: [],
@@ -2235,6 +4704,168 @@ 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/run-attempt-state.ts
+async function clearCodexBindingAfterInvalidImagePayload(bindingStore, identity, fields) {
+	const currentBinding = await bindingStore.read(identity);
+	const expectedThreadId = fields.threadId ?? currentBinding?.threadId;
+	if (!expectedThreadId) return;
+	if (currentBinding && currentBinding.threadId !== expectedThreadId) {
+		embeddedAgentLog.warn("codex app-server image payload error detected for unbound thread; preserving thread binding", {
+			...fields,
+			boundThreadId: currentBinding.threadId
+		});
+		return;
+	}
+	if (currentBinding?.connectionScope === "supervision") {
+		embeddedAgentLog.warn("codex app-server image payload error detected for supervised thread; preserving native binding", fields);
+		return;
+	}
+	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
+	await bindingStore.mutate(identity, {
+		kind: "clear",
+		threadId: expectedThreadId
+	});
+}
+async function markCodexAppServerBindingCoveredThroughTurn(params) {
+	await params.bindingStore.mutate(params.identity, {
+		kind: "patch",
+		threadId: params.threadId,
+		patch: { historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString() }
+	});
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
+	if (!params.contextEngineActive || params.thread.lifecycle.action !== "resumed") return false;
+	const message = formatErrorMessage(params.error);
+	return /ran out of room in the model'?s context window/iu.test(message) || /context window/iu.test(message) || /context length/iu.test(message) || /maximum context/iu.test(message) || /too many tokens/iu.test(message);
+}
+function isCodexActiveCompactTurnError(error) {
+	if (!(error instanceof CodexAppServerRpcError)) return false;
+	const data = isJsonObject(error.data) ? error.data : void 0;
+	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
+	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
+}
+function readCodexFinalizationHookNotification(notification, threadId, turnId) {
+	if (notification.method !== "hook/started" && notification.method !== "hook/completed") return;
+	const params = isJsonObject(notification.params) ? notification.params : void 0;
+	const run = params && isJsonObject(params.run) ? params.run : void 0;
+	if (params?.threadId !== threadId || params.turnId !== turnId || run?.eventName !== "stop" && run?.eventName !== "subagentStop" || typeof run.id !== "string" || !run.id) return;
+	if (notification.method === "hook/started") return {
+		phase: "started",
+		runId: run.id
+	};
+	return {
+		phase: "completed",
+		runId: run.id,
+		status: typeof run.status === "string" ? run.status : void 0
+	};
+}
+function joinPresentSections(...sections) {
+	return sections.filter((section) => Boolean(section?.trim())).join("\n\n");
+}
+function prependCurrentInboundContext(prompt, context) {
+	const text = context?.text.trim();
+	return text ? [text, prompt].filter(Boolean).join("\n\n") : prompt;
+}
+function waitForCodexNotificationDispatchTurn() {
+	return new Promise((resolve) => {
+		setImmediate(resolve);
+	});
+}
+function buildCodexAppServerTimeoutDiagnostics(params) {
+	const readString = (key) => {
+		const value = params.details?.[key];
+		return typeof value === "string" && value.trim() ? value : void 0;
+	};
+	const readNumber = (key) => {
+		const value = params.details?.[key];
+		return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+	};
+	const readBoolean = (key) => {
+		const value = params.details?.[key];
+		return typeof value === "boolean" ? value : void 0;
+	};
+	return {
+		...params.idleMs !== void 0 ? { idleMs: params.idleMs } : {},
+		...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
+		...params.lastActivityReason ? { lastActivityReason: params.lastActivityReason } : {},
+		...readString("lastNotificationMethod") ? { lastNotificationMethod: readString("lastNotificationMethod") } : {},
+		...readString("lastNotificationItemId") ? { lastNotificationItemId: readString("lastNotificationItemId") } : {},
+		...readString("lastNotificationItemType") ? { lastNotificationItemType: readString("lastNotificationItemType") } : {},
+		...readString("lastNotificationItemRole") ? { lastNotificationItemRole: readString("lastNotificationItemRole") } : {},
+		...readString("lastAssistantTextPreview") ? { lastAssistantTextPreview: readString("lastAssistantTextPreview") } : {},
+		...readNumber("activeAppServerTurnRequests") !== void 0 ? { activeAppServerTurnRequests: readNumber("activeAppServerTurnRequests") } : {},
+		...readNumber("activeTurnItemCount") !== void 0 ? { activeTurnItemCount: readNumber("activeTurnItemCount") } : {},
+		...readBoolean("terminalTurnNotificationQueued") !== void 0 ? { terminalTurnNotificationQueued: readBoolean("terminalTurnNotificationQueued") } : {},
+		...readBoolean("completionIdleWatchArmed") !== void 0 ? { completionIdleWatchArmed: readBoolean("completionIdleWatchArmed") } : {},
+		...readBoolean("assistantCompletionIdleWatchArmed") !== void 0 ? { assistantCompletionIdleWatchArmed: readBoolean("assistantCompletionIdleWatchArmed") } : {},
+		...readBoolean("terminalIdleWatchArmed") !== void 0 ? { terminalIdleWatchArmed: readBoolean("terminalIdleWatchArmed") } : {}
+	};
+}
+//#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;
@@ -2353,13 +4984,14 @@ function recordCodexTrajectoryContext(recorder, params) {
 /** Records final Codex model completion metadata and assistant snapshots. */
 function recordCodexTrajectoryCompletion(recorder, params) {
 	if (!recorder) return;
+	const terminal = attemptTerminal.project(params.result.terminal);
 	recorder.recordEvent("model.completed", {
 		threadId: params.threadId,
 		turnId: params.turnId,
 		timedOut: params.timedOut,
 		yieldDetected: params.yieldDetected ?? false,
-		aborted: params.result.aborted,
-		promptError: normalizeCodexTrajectoryError(params.result.promptError),
+		aborted: terminal.aborted,
+		promptError: normalizeCodexTrajectoryError(terminal.promptError),
 		usage: params.result.attemptUsage,
 		assistantTexts: params.result.assistantTexts,
 		messagesSnapshot: params.result.messagesSnapshot
@@ -2453,11 +5085,12 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		});
 	}
 	const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected: toolState.yieldDetected });
+	const projectedTerminal = attemptTerminal.project(result.terminal);
 	const effectiveTimedOut = state.timedOut && !recoveredTurnWatchTimeout;
 	const effectiveTurnCompletionIdleTimedOut = state.turnCompletionIdleTimedOut && !recoveredTurnWatchTimeout;
-	const isFinalAborted = () => result.aborted || terminalState.explicitCancellationObserved || runAbortController.signal.aborted && !state.clientClosedAbort && !recoveredTurnWatchTimeout;
+	const isFinalAborted = () => projectedTerminal.aborted || terminalState.explicitCancellationObserved || runAbortController.signal.aborted && !state.clientClosedAbort && !recoveredTurnWatchTimeout;
 	const clientClosedPromptErrorForFinal = state.clientClosedPromptError && hasRecoverableCompletedAssistant ? void 0 : state.clientClosedPromptError;
-	let finalPromptError = clientClosedPromptErrorForFinal ?? (effectiveTurnCompletionIdleTimedOut ? state.turnCompletionIdleTimeoutMessage : effectiveTimedOut ? "codex app-server attempt timed out" : result.promptError);
+	let finalPromptError = clientClosedPromptErrorForFinal ?? (effectiveTurnCompletionIdleTimedOut ? state.turnCompletionIdleTimeoutMessage : effectiveTimedOut ? "codex app-server attempt timed out" : projectedTerminal.promptError);
 	const finalPromptErrorMessage = typeof finalPromptError === "string" ? finalPromptError : finalPromptError instanceof Error ? finalPromptError.message : finalPromptError ? formatErrorMessage(finalPromptError) : void 0;
 	if (isInvalidCodexImagePayloadError(finalPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 		phase: "turn_completed",
@@ -2498,7 +5131,7 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 		authProfileId: startupAuthProfileId,
 		rateLimits: readRecentCodexRateLimits(resourceState.client)
 	});
-	const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : result.promptErrorSource;
+	const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : projectedTerminal.promptErrorSource;
 	const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : effectiveTurnCompletionIdleTimedOut ? "turn_completion_idle_timeout" : void 0;
 	const replayBlockedReason = codexAppServerFailureKind ? resolveCodexAppServerReplayBlockedReason(result) : void 0;
 	const promptTimeoutOutcome = buildCodexAppServerPromptTimeoutOutcome({
@@ -2528,6 +5161,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,
@@ -2547,7 +5181,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,
@@ -2557,6 +5191,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";
@@ -2680,13 +5326,17 @@ async function finalizeCodexAttempt(resources, turnRuntime, lifecycle, notificat
 	});
 	return {
 		...result,
-		timedOut: effectiveTimedOut,
-		aborted: finalAborted,
-		promptError: finalPromptError,
-		promptErrorSource: finalPromptErrorSource,
+		terminal: attemptTerminal.normalize({
+			timedOut: effectiveTimedOut,
+			aborted: finalAborted,
+			promptError: finalPromptError,
+			promptErrorSource: finalPromptErrorSource
+		}),
 		...codexAppServerFailure ? { codexAppServerFailure } : {},
 		...promptTimeoutOutcome ? { promptTimeoutOutcome } : {},
 		...assistantTranscriptOwned ? { assistantTranscriptOwned: true } : {},
+		...assistantTranscriptIdempotencyKey ? { assistantTranscriptIdempotencyKey } : {},
+		...settledTurnFinalizationContext ? { settledTurnFinalizationContext } : {},
 		...resourceState.runtimeArtifact ? { runtimeArtifact: resourceState.runtimeArtifact } : {},
 		...!finalAborted && !effectiveTimedOut && !finalPromptError && preparedAuthBinding ? { authBindingFingerprint: preparedAuthBinding.fingerprint } : {},
 		systemPromptReport
@@ -3011,7 +5661,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) {
@@ -3172,34 +5822,35 @@ 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;
 		}
 	}
@@ -3319,6 +5970,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 {
@@ -3579,8 +6244,7 @@ async function prepareCodexAttemptPrompt(context) {
 		developerInstructions: promptState.developerInstructions,
 		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;
@@ -3631,8 +6295,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();
@@ -5595,7 +8258,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. */
@@ -5736,6 +8399,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,
@@ -5743,6 +8415,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",
@@ -6792,6 +9467,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({
@@ -6805,6 +9489,7 @@ function prepareCodexAttemptResources(prompt) {
 			config: params.config,
 			runId: params.runId,
 			channelId: hookChannelId,
+			...hasRequester ? { requester } : {},
 			attemptTimeoutMs: params.timeoutMs,
 			startupTimeoutMs,
 			turnStartTimeoutMs: params.timeoutMs,
@@ -6914,6 +9599,28 @@ async function prepareCodexAttemptRoute(resources, turnRuntime, notifications, h
 	return { ensureCurrentThreadRoute };
 }
 //#endregion
+//#region extensions/codex/src/app-server/run-attempt-client-prewarm.ts
+/** Starts the shared process while tools and prompt context are still being prepared. */
+function prewarmCodexAttemptClient(params) {
+	const { connection, authProfileStore, authBindingFingerprint } = params;
+	const { appServer, attemptClientFactory, options, pluginConfig, runtimeArtifactRequest, startupAuthRequirement, startupClientAuthProfileId, startupPreparedAuth, agentDir, params: runParams, runAbortController } = connection;
+	if (options.clientFactory || attemptClientFactory !== getLeasedSharedCodexAppServerClient || runtimeArtifactRequest) return;
+	getSharedCodexAppServerClient({
+		startOptions: appServer.start,
+		pluginConfig,
+		...startupPreparedAuth ? { preparedAuth: startupPreparedAuth } : { authProfileId: startupClientAuthProfileId },
+		authRequirement: startupAuthRequirement,
+		authProfileStore,
+		authBindingFingerprint,
+		agentDir,
+		config: runParams.config,
+		timeoutMs: appServer.requestTimeoutMs,
+		abandonSignal: runAbortController.signal
+	}).catch((error) => {
+		embeddedAgentLog.debug("codex app-server client prewarm failed", { error });
+	});
+}
+//#endregion
 //#region extensions/codex/src/app-server/run-attempt-runtime.ts
 async function prepareCodexAttemptRuntime(connection) {
 	const { params, pluginConfig, usesSupervisionConnection, appServer, startupAuthProfileId, startupPreparedAuth, startupClientAuthProfileId, agentDir, preDynamicStartupStages, effectiveWorkspace, contextSessionKey, sandboxSessionKey, sessionAgentId, sandbox, attemptClientFactory, runAbortController, activeContextEngine, mutable } = connection;
@@ -6924,6 +9631,11 @@ async function prepareCodexAttemptRuntime(connection) {
 		config: params.config
 	}) : void 0;
 	const attemptAuthProfileStore = preparedAuthBinding?.authProfileStore ?? params.authProfileStore;
+	prewarmCodexAttemptClient({
+		connection,
+		authProfileStore: attemptAuthProfileStore,
+		authBindingFingerprint: preparedAuthBinding?.fingerprint
+	});
 	const effectiveContextWindowInfo = usesSupervisionConnection ? void 0 : params.contextWindowInfo;
 	const effectiveContextTokenBudget = usesSupervisionConnection ? void 0 : params.contextTokenBudget;
 	const effectiveRuntimeProviderId = usesSupervisionConnection ? mutable.startupBinding?.modelProvider ?? "codex" : params.provider;
@@ -7052,7 +9764,8 @@ function recordCodexDynamicToolResult(projector, call, response, protocolRespons
 		success: protocolResponse.success,
 		terminalType: response.diagnosticTerminalType ?? (protocolResponse.success ? "completed" : "error"),
 		sideEffectEvidence: response.sideEffectEvidence === true || response.terminalResolution?.sideEffectEvidence === true,
-		contentItems: protocolResponse.contentItems
+		contentItems: protocolResponse.contentItems,
+		details: response.transcriptDetails
 	});
 }
 //#endregion
@@ -7150,7 +9863,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;
@@ -7176,7 +9890,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") {
@@ -7203,7 +9917,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 						turnId,
 						nativeHookRelay: resourceState.nativeHookRelay,
 						autoApprove: shouldAutoApproveCodexAppServerApprovals(appServer),
-						signal: runAbortController.signal,
+						signal,
 						onNativeToolFailureDisposition: (itemId, disposition) => projector?.recordNativeToolApprovalFailure(itemId, disposition)
 					});
 				}
@@ -7279,7 +9993,7 @@ function createCodexAttemptServerRequestController(resources, turnRuntime, lifec
 				const { execution } = openClawDynamicToolExecutions.claim(call, () => handleDynamicToolCallWithTimeout({
 					call,
 					toolBridge,
-					signal: runAbortController.signal,
+					signal,
 					timeoutMs: dynamicToolTimeoutMs,
 					toolMeta,
 					toolCallOrdinal,
@@ -7576,7 +10290,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 {
@@ -7743,6 +10457,7 @@ async function startCodexAttemptThread(params) {
 						const attemptParams = params.buildAttemptParams();
 						startupClient = await params.attemptClientFactory({
 							startOptions: params.appServer.start,
+							pluginConfig: params.pluginConfig,
 							...params.startupPreparedAuth ? { preparedAuth: params.startupPreparedAuth } : { authProfileId: params.startupAuthProfileId },
 							authRequirement: params.startupAuthRequirement,
 							authProfileStore: attemptParams.authProfileStore,
@@ -7791,14 +10506,19 @@ async function startCodexAttemptThread(params) {
 							config: params.config
 						});
 						const turnRouter = getCodexAppServerTurnRouter(activeStartupClient);
-						await ensureCodexComputerUse({
-							client: activeStartupClient,
-							pluginConfig: params.pluginConfig,
-							config: params.config,
-							agentDir: params.agentDir,
-							timeoutMs: params.appServer.requestTimeoutMs,
-							signal: startupAbandonController.signal
-						});
+						try {
+							await ensureCodexComputerUse({
+								client: activeStartupClient,
+								pluginConfig: params.pluginConfig,
+								config: params.config,
+								agentDir: params.agentDir,
+								timeoutMs: params.appServer.requestTimeoutMs,
+								signal: startupAbandonController.signal
+							});
+						} catch (error) {
+							if (startupAbandonController.signal.aborted) throw error;
+							throw new AgentHarnessPreflightError(`Codex Computer Use readiness failed: ${formatErrorMessage(error)}`, { cause: error });
+						}
 						const startupRuntimeIdentity = activeStartupClient.getRuntimeIdentity();
 						const pluginAppCacheKey = buildCodexPluginAppCacheKey({
 							appServer: params.appServer,
@@ -8266,7 +10986,7 @@ async function prepareCodexAttemptTools(runtime) {
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
 		workspaceDir: effectiveWorkspace,
-		agentDir: agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId),
+		agentDir: agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId),
 		cfg: params.config,
 		requesterSenderId: params.senderId,
 		agentAccountId: params.agentAccountId,
@@ -8280,7 +11000,7 @@ async function prepareCodexAttemptTools(runtime) {
 			sessionId: params.sessionId,
 			runId: params.runId,
 			agentId: sessionAgentId,
-			agentDir: agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId),
+			agentDir: agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId),
 			agentAccountId: params.agentAccountId,
 			messageProvider: params.messageProvider ?? params.messageChannel,
 			messageChannel: params.messageChannel,
@@ -8332,6 +11052,7 @@ async function prepareCodexAttemptTools(runtime) {
 			hookContext: {
 				agentId: sessionAgentId,
 				config: params.config,
+				contextWindowTokens: params.contextTokenBudget ?? params.model.contextWindow,
 				workspaceDir: effectiveWorkspace,
 				sessionId: params.sessionId,
 				sessionKey: sandboxSessionKey,
@@ -8418,7 +11139,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));
@@ -8643,7 +11363,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
 			});