@openclaw/codex 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{run-attempt-O3Zs32KI.js → run-attempt-8SPLiDlT.js}

@@ -1,194 +1,53 @@
-import { n as isJsonObject, t as flattenCodexDynamicToolFunctions } from "./protocol-dh-ETiNd.js";
-import { A as resolveCodexContextEngineProjectionReserveTokens, B as describeCodexNotificationCorrelation, D as fitCodexProjectedContextForTurnStart, E as resolveCodexDynamicToolsLoadingForRuntime, F as shouldBuildCodexPluginThreadConfig, H as readCodexNotificationThreadId, M as buildCodexPluginThreadConfig, N as buildCodexPluginThreadConfigInputFingerprint, O as projectContextEngineAssemblyForCodex, P as mergeCodexThreadConfigs, U as readCodexNotificationTurnId, _ as resolveCodexWebSearchPlan, a as buildDeveloperInstructions, b as sanitizeCodexHistoryImagePayloads, c as codexDynamicToolsFingerprint, f as resolveCodexAppServerThreadModelSelection, h as startOrResumeThread, i as buildContextEngineBinding, k as resolveCodexContextEngineProjectionMaxChars, l as isContextEngineBindingCompatible, n as areCodexDynamicToolFingerprintsCompatible, o as buildTurnCollaborationMode, s as buildTurnStartParams, v as isCodexAppServerProfilerEnabled, z as defaultCodexAppInventoryCache } from "./thread-lifecycle-DeSMZSXr.js";
-import { C as readCodexNotificationItem, D as updateActiveCompletionBlockerItemIds, E as shouldDisarmAssistantCompletionIdleWatch, O as updateActiveTurnItemIds, S as isTurnNotification, T as readRawResponseToolCallId, _ as isRawToolOutputCompletionNotification, a as isCodexNotificationOutsideActiveRun, b as isRetryableErrorNotification, c as isCurrentThreadOptionalTurnRequestParams, d as isNativeResponseStreamDeltaNotification, f as isNativeToolProgressNotification, g as isRawReasoningCompletionNotification, h as isRawFunctionToolOutputCompletionNotification, i as isAssistantCompletionReleaseNotification, l as isCurrentThreadTurnRequestParams, m as isRawAssistantProgressNotification, n as describeNotificationActivity, o as isCodexTurnAbortMarkerNotification, p as isPendingOpenClawDynamicToolCompletionNotification, r as isAssistantCommentaryCompletionNotification, s as isCurrentApprovalTurnRequestParams, t as codexExecutionToolName, u as isFileChangePatchUpdatedNotification, v as isReasoningItemCompletionNotification, w as readNotificationItemId, x as isTerminalTurnStatus, y as isReasoningProgressNotification } from "./attempt-notifications-l9LElGOU.js";
-import { _ as withMcpElicitationsApprovalPolicy, a as isCodexAppServerApprovalPolicyAllowedByRequirements, d as resolveCodexAppServerRuntimeOptions, f as resolveCodexComputerUseConfig, g as shouldAutoApproveCodexAppServerApprovals, h as resolveOpenClawExecPolicyForCodexAppServer, m as resolveCodexPluginsPolicy, p as resolveCodexModelBackedReviewerPolicyContext, s as isCodexSandboxExecServerEnabled, u as readCodexPluginConfig } from "./config-C_whBx3M.js";
-import { a as readCodexDynamicToolCallParams, c as readCodexTurn, i as assertCodexTurnStartResponse } from "./protocol-validators-CB4mtyrs.js";
-import { l as resolveCodexUsageLimitResetAtMs, s as formatCodexUsageLimitErrorMessage, u as shouldRefreshCodexRateLimitsForUsageLimitMessage } from "./provider-DosqwRb6.js";
-import { a as isCodexAppServerConnectionClosedError, c as MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION, i as isCodexAppServerApprovalRequest, n as CodexAppServerRpcError, r as compareCodexAppServerVersions } from "./client-IcTBKEqA.js";
-import { i as isCodexAppServerNativeAuthProfile, l as writeCodexAppServerBinding, n as clearCodexAppServerBinding, o as readCodexAppServerBinding, r as clearCodexAppServerBindingForThread } from "./session-binding-Cm0Gg7Z1.js";
-import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS, t as buildCodexAppServerRuntimeFingerprint } from "./plugin-app-cache-key-CDioyur-.js";
-import { a as formatCodexDisplayText, n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-xi0ZmBGO.js";
-import { d as resolveCodexAppServerAuthAccountCacheKey, f as resolveCodexAppServerAuthProfileId, h as resolveCodexAppServerHomeDir, m as resolveCodexAppServerFallbackApiKeyCacheKey, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, o as releaseLeasedSharedCodexAppServerClient, p as resolveCodexAppServerAuthProfileIdForAgent, s as retireSharedCodexAppServerClientIfCurrent, t as clearSharedCodexAppServerClientIfCurrent, u as refreshCodexAppServerAuthTokens } from "./shared-client-rR6TDJA3.js";
-import { t as defaultLeasedCodexAppServerClientFactory } from "./client-factory-CwjdQQ4j.js";
-import { A as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, C as resolveCodexMessageToolProvider, D as shouldWarnCodexDynamicToolBuildStageSummary, E as shouldRequireCodexSandboxExecServerEnvironment, F as resolveCodexTurnTerminalIdleTimeoutMs, I as withCodexStartupTimeout, M as resolveCodexStartupTimeoutMs, N as resolveCodexTurnAssistantCompletionIdleTimeoutMs, P as resolveCodexTurnCompletionIdleTimeoutMs, S as resolveCodexExternalSandboxPolicyForOpenClawSandbox, T as shouldEnableCodexAppServerNativeToolSurface, _ as createCodexDynamicToolBuildStageTracker, a as buildCodexNativeHookRelayConfig, b as resolveCodexAppServerExecutionCwd, c as resolveCodexNativeHookRelayEvents, d as handleCodexAppServerElicitationRequest, f as createCodexDynamicToolBridge, g as buildDynamicTools, h as emitDynamicToolTerminalDiagnostic, i as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, j as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, k as handleCodexAppServerApprovalRequest, l as resolveCodexNativeHookRelayTtlMs, m as emitDynamicToolStartedDiagnostic, o as buildCodexNativeHookRelayDisabledConfig, p as emitDynamicToolErrorDiagnostic, s as createCodexNativeHookRelay, t as resolveCodexProviderWebSearchSupport, u as scheduleCodexNativeHookRelayUnregister, v as disableCodexPluginThreadConfig, w as resolveCodexSandboxEnvironmentSelection, x as resolveCodexAppServerHookChannelId, y as formatCodexDynamicToolBuildStageSummary } from "./provider-capabilities-CE5k8cmO.js";
-import { t as ensureCodexComputerUse } from "./computer-use-FPGG-mtX.js";
-import { n as rememberCodexRateLimits, t as readRecentCodexRateLimits } from "./rate-limit-cache-C7qmZ0Jh.js";
+import { n as flattenCodexDynamicToolFunctions, r as isJsonObject } from "./protocol-2POPqAY4.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-BGsEIIDI.js";
+import { _ as shouldAutoApproveCodexAppServerApprovals, a as isCodexAppServerApprovalPolicyAllowedByRequirements, d as resolveCodexAppServerRuntimeOptions, g as resolveOpenClawExecPolicyForCodexAppServer, h as resolveCodexPluginsPolicy, m as resolveCodexModelBackedReviewerPolicyContext, p as resolveCodexComputerUseConfig, s as isCodexSandboxExecServerEnabled, u as readCodexPluginConfig, v as withMcpElicitationsApprovalPolicy } from "./config-CYEDnLJ2.js";
+import { a as readCodexDynamicToolCallParams, i as assertCodexTurnStartResponse } from "./protocol-validators-dZQ-UTOa.js";
+import { A as resolveCodexContextEngineProjectionReserveTokens, B as buildCodexPluginThreadConfigInputFingerprint, D as fitCodexProjectedContextForTurnStart, E as resolveCodexDynamicToolsLoadingForRuntime, F as interruptCodexTurnBestEffort, H as shouldBuildCodexPluginThreadConfig, I as retireCodexAppServerClientAfterTimedOutTurn, K as defaultCodexAppInventoryCache, L as unsubscribeCodexThreadBestEffort, M as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, N as CodexAppServerUnsafeSubscriptionError, O as projectContextEngineAssemblyForCodex, P as closeCodexStartupClientBestEffort, V as mergeCodexThreadConfigs, _ as resolveCodexWebSearchPlan, a as buildDeveloperInstructions, c as codexDynamicToolsFingerprint, f as resolveCodexAppServerThreadModelSelection, h as startOrResumeThread, i as buildContextEngineBinding, j as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, k as resolveCodexContextEngineProjectionMaxChars, l as isContextEngineBindingCompatible, n as areCodexDynamicToolFingerprintsCompatible, o as buildTurnCollaborationMode, s as buildTurnStartParams, v as isCodexAppServerProfilerEnabled, z as buildCodexPluginThreadConfig } from "./thread-lifecycle-BskXnNP-.js";
+import { c as formatCodexUsageLimitErrorMessage, d as shouldRefreshCodexRateLimitsForUsageLimitMessage, u as resolveCodexUsageLimitResetAtMs } from "./provider-cc_62eQE.js";
+import { _ as resolveCodexAppServerAuthAccountCacheKey, a as getLeasedSharedCodexAppServerClient, b as resolveCodexAppServerFallbackApiKeyCacheKey, d as isCodexAppServerApprovalRequest, f as isCodexAppServerConnectionClosedError, g as rememberCodexRateLimitsRead, h as readRecentCodexRateLimits, m as readCodexRateLimitsRevision, o as releaseLeasedSharedCodexAppServerClient, p as ensureCodexAppServerClientRuntime, s as retireSharedCodexAppServerClientIfCurrent, t as clearSharedCodexAppServerClientIfCurrent, u as CodexAppServerRpcError, v as resolveCodexAppServerAuthProfileId, x as resolveCodexAppServerHomeDir, y as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-4ICy3U6d.js";
+import { o as sessionBindingIdentity, r as isCodexAppServerNativeAuthProfile } from "./session-binding-Dc03iwRF.js";
+import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS, t as buildCodexAppServerRuntimeFingerprint } from "./plugin-app-cache-key-o-AHbdaf.js";
+import { a as formatCodexDisplayText, n as resolveCodexAppServerForOpenClawToolPolicy, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BUk0GLMy.js";
+import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId, t as isCodexNotificationForTurn } from "./notification-correlation-Bo7KB3ks.js";
+import { $ as isDynamicToolTerminalDiagnosticEvent, A as createCodexDynamicToolBuildStageTracker, B as shouldWarnCodexDynamicToolBuildStageSummary, C as resolveCodexLocalRuntimeAttribution, D as emitDynamicToolStartedDiagnostic, E as emitDynamicToolErrorDiagnostic, F as resolveCodexExternalSandboxPolicyForOpenClawSandbox, G as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, H as readCodexMirroredSessionHistoryMessages, I as resolveCodexMessageToolProvider, J as resolveCodexTurnCompletionIdleTimeoutMs, K as resolveCodexStartupTimeoutMs, L as resolveCodexSandboxEnvironmentSelection, M as formatCodexDynamicToolBuildStageSummary, N as resolveCodexAppServerExecutionCwd, O as emitDynamicToolTerminalDiagnostic, P as resolveCodexAppServerHookChannelId, Q as hasPendingDynamicToolTerminalDiagnostic, R as shouldEnableCodexAppServerNativeToolSurface, S as scheduleCodexNativeHookRelayUnregister, T as createCodexDynamicToolBridge, U as handleCodexAppServerApprovalRequest, W as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, X as withCodexStartupTimeout, Y as resolveCodexTurnTerminalIdleTimeoutMs, Z as handleDynamicToolCallWithTimeout, _ as buildCodexNativeHookRelayDisabledConfig, a as shouldEmitTranscriptToolProgress, at as toCodexDynamicToolProgressResponse, b as resolveCodexNativeHookRelayEvents, c as mirrorPromptAtTurnStartBestEffort, d as resolveCodexToolProgressDetailMode, et as isMatchingDynamicToolTerminalDiagnostic, f as sanitizeCodexToolArguments, g as buildCodexNativeHookRelayConfig, h as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, it as shouldReleaseTurnAfterTerminalDynamicTool, j as disableCodexPluginThreadConfig, k as buildDynamicTools, l as mirrorTranscriptBestEffort, nt as resolveTerminalDynamicToolBatchAction, o as buildCodexUserPromptMessage, ot as toCodexDynamicToolProtocolResponse, p as sanitizeCodexToolResponse, q as resolveCodexTurnAssistantCompletionIdleTimeoutMs, r as CodexAppServerEventProjector, rt as shouldBlockTerminalReleaseForNonTerminalDynamicToolResult, s as createCodexAppServerUserMessagePersistenceNotifier, st as resolveCodexToolAbortTerminalReason, t as resolveCodexProviderWebSearchSupport, tt as resolveDynamicToolCallTimeoutMs, u as inferCodexDynamicToolMeta, v as createCodexNativeHookRelay, w as handleCodexAppServerElicitationRequest, x as resolveCodexNativeHookRelayTtlMs, y as emitCodexNativePreToolUseFailureDiagnostic, z as shouldRequireCodexSandboxExecServerEnvironment } from "./provider-capabilities-gTCwjfmh.js";
+import { t as ensureCodexComputerUse } from "./computer-use-DDeySrnb.js";
 import fs from "node:fs/promises";
 import path, { posix } from "node:path";
-import { asDateTimestampMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { asFiniteNumber, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash, randomUUID } from "node:crypto";
 import fsSync from "node:fs";
 import { markAuthProfileBlockedUntil, resolveAgentDir, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
-import { CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, TOOL_PROGRESS_OUTPUT_MAX_CHARS, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, finalizeHarnessContextEngineTurn, formatErrorMessage, formatFastModeAutoProgressText, formatToolAggregate, formatToolProgressOutput, getAgentHarnessHookRunner, getBeforeToolCallPolicyDiagnosticState, inferToolMetaFromArgs, isActiveHarnessContextEngine, loadCodexBundleMcpThreadConfig, normalizeUsage, resolveAgentHarnessBeforePromptBuildResult, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds as resolveSessionAgentIds$1, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessBeforeMessageWriteHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { asFiniteNumber, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, FAST_MODE_AUTO_PROGRESS_KIND, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentEndSideEffects, bootstrapHarnessContextEngine, buildAgentHarnessUserInputAnswers, buildBootstrapContextForFiles, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, embeddedAgentLog, emitAgentEvent, emptyAgentHarnessUserInputAnswers, finalizeHarnessContextEngineTurn, formatErrorMessage, formatFastModeAutoProgressText, getAgentHarnessHookRunner, getBeforeToolCallPolicyDiagnosticState, isActiveHarnessContextEngine, loadCodexBundleMcpThreadConfig, resolveAgentHarnessBeforePromptBuildResult, resolveAgentRunAbortLifecycleFields, resolveBootstrapFilesForRun, resolveContextEngineOwnerPluginId, resolveFastModeForElapsed, resolveSandboxContext, resolveSessionAgentIds as resolveSessionAgentIds$1, resolveUserPath, runAgentCleanupStep, runAgentEndSideEffects, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { buildMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";
 import { spawn } from "node:child_process";
 import { once } from "node:events";
 import { WebSocketServer } from "ws";
-import { redactSensitiveFieldValue, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
-import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, hasPendingInternalDiagnosticEvent, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { appendRegularFile, pathExists } from "openclaw/plugin-sdk/security-runtime";
+import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
-import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "openclaw/plugin-sdk/agent-sessions";
-import { publishSessionTranscriptUpdateByIdentity, resolveSessionTranscriptTarget, withSessionTranscriptWriteLock } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { isIP } from "node:net";
 import { SsrFBlockedError, isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
-import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
-import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { createAgentHarnessTaskRuntime, deliverAgentHarnessTaskCompletion, isDurableAgentHarnessCompletionDelivery } from "openclaw/plugin-sdk/agent-harness-task-runtime";
-//#region extensions/codex/src/app-server/attempt-client-cleanup.ts
-/**
-* Best-effort cleanup helpers for Codex app-server startup attempts and turns.
-*/
-/** Timeout for best-effort app-server turn interruption during cleanup. */
-const CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS = 5e3;
-/** Timeout for best-effort thread unsubscribe during cleanup. */
-const CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS = 5e3;
-async function closeClientAndWaitIfAvailable(client) {
-	const closeable = client;
-	if (typeof closeable.closeAndWait === "function") {
-		await closeable.closeAndWait();
-		return;
-	}
-	closeable.close?.();
-}
-async function closeCodexStartupClientBestEffort(client) {
-	if (!client) return;
-	const unclaimedSharedClient = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client);
-	if (unclaimedSharedClient.closed) {
-		await closeClientAndWaitIfAvailable(client);
-		return;
-	}
-	if (unclaimedSharedClient.found) {
-		if (retireSharedCodexAppServerClientIfCurrent(client)?.closed) await closeClientAndWaitIfAvailable(client);
-		return;
-	}
-	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
-	if (retiredSharedClient) {
-		if (retiredSharedClient.closed) await closeClientAndWaitIfAvailable(client);
-		return;
-	}
-	if (clearSharedCodexAppServerClientIfCurrent(client)) {
-		await closeClientAndWaitIfAvailable(client);
-		return;
-	}
-	await closeClientAndWaitIfAvailable(client);
-}
-/** Sends a turn interrupt without blocking abort cleanup on app-server errors. */
-function interruptCodexTurnBestEffort(client, params) {
-	const requestOptions = params.timeoutMs && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? { timeoutMs: params.timeoutMs } : void 0;
-	const requestParams = {
-		threadId: params.threadId,
-		turnId: params.turnId
-	};
-	try {
-		const interrupt = requestOptions ? client.request("turn/interrupt", requestParams, requestOptions) : client.request("turn/interrupt", requestParams);
-		Promise.resolve(interrupt).catch((error) => {
-			embeddedAgentLog.debug("codex app-server turn interrupt failed during abort", { error });
-		});
-	} catch (error) {
-		embeddedAgentLog.debug("codex app-server turn interrupt failed during abort", { error });
-	}
-}
-/** Unsubscribes from a thread while swallowing cleanup-only failures. */
-async function unsubscribeCodexThreadBestEffort(client, params) {
-	try {
-		await client.request("thread/unsubscribe", { threadId: params.threadId }, { timeoutMs: params.timeoutMs });
-	} catch (error) {
-		embeddedAgentLog.debug("codex app-server thread unsubscribe cleanup failed", {
-			threadId: params.threadId,
-			error
-		});
-	}
-}
-/**
-* Retires the shared client after a timed-out turn so later runs do not reuse a
-* potentially wedged app-server connection.
-*/
-async function retireCodexAppServerClientAfterTimedOutTurn(client, params) {
-	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
-	const detachedSharedClient = Boolean(retiredSharedClient);
-	interruptCodexTurnBestEffort(client, {
-		threadId: params.threadId,
-		turnId: params.turnId,
-		timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS
-	});
-	await unsubscribeCodexThreadBestEffort(client, {
-		threadId: params.threadId,
-		timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
-	});
-	let closedClient = retiredSharedClient?.closed ?? false;
-	if (!detachedSharedClient) {
-		const close = client.close;
-		if (typeof close === "function") try {
-			close.call(client);
-			closedClient = true;
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server client close failed during timeout cleanup", {
-				threadId: params.threadId,
-				turnId: params.turnId,
-				error
-			});
-		}
-	}
-	embeddedAgentLog.warn("codex app-server client retired after timed-out turn", {
-		threadId: params.threadId,
-		turnId: params.turnId,
-		reason: params.reason,
-		detachedSharedClient,
-		closedClient,
-		activeSharedClientLeases: retiredSharedClient?.activeLeases ?? 0
-	});
-}
-//#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.
-*/
-/** Returns sanitized session-context messages for a Codex mirrored session file. */
-async function readCodexMirroredSessionHistoryMessages(target) {
-	try {
-		await resolveSessionTranscriptTarget(resolveCodexHistoryTranscriptTarget(target));
-		const entries = parseSessionEntries(await fs.readFile(target.sessionFile, "utf-8"));
-		if (entries.length === 0) return [];
-		const firstEntry = entries[0];
-		if (firstEntry?.type !== "session" || 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 {
-		return;
-	}
-}
-function resolveCodexHistoryTranscriptTarget(target) {
-	return {
-		...target.agentId ? { agentId: target.agentId } : {},
-		sessionFile: target.sessionFile,
-		sessionId: target.sessionId,
-		sessionKey: target.sessionKey ?? ""
-	};
-}
-//#endregion
 //#region extensions/codex/src/app-server/attempt-context.ts
 /**
 * Builds Codex app-server prompt context, workspace bootstrap injections,
 * system-prompt reports, and context-engine projection decisions.
 */
-const CODEX_NATIVE_PROJECT_DOC_BASENAMES = new Set(["agents.md"]);
-const CODEX_INHERITED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = new Set(["tools.md"]);
-const CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = new Set([
+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 = new Set([...CODEX_INHERITED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES, ...CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES]);
+const CODEX_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES = /* @__PURE__ */ new Set([...CODEX_INHERITED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES, ...CODEX_TURN_SCOPED_WORKSPACE_DEVELOPER_CONTEXT_BASENAMES]);
 const CODEX_HEARTBEAT_CONTEXT_BASENAME = "heartbeat.md";
 const CODEX_MEMORY_CONTEXT_BASENAME = "memory.md";
-const CODEX_MEMORY_TOOL_NAMES = new Set(["memory_search", "memory_get"]);
-const CODEX_BOOTSTRAP_CONTEXT_ORDER = new Map([
+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],
@@ -427,10 +286,10 @@ function stableJsonHash(value) {
 function buildCodexBootstrapInjectionStats(params) {
 	const injectedIndex = indexCodexContextFileContent(params.injectedFiles);
 	const developerInstructionIndex = indexCodexContextFileContent(params.developerInstructionFiles ?? []);
-	const memoryToolRoutedPaths = new Set((params.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonEmptyString$1(file.path)).filter(isNonEmptyString$1).map(normalizeCodexContextFilePath));
+	const memoryToolRoutedPaths = new Set((params.memoryToolRoutedBootstrapFiles ?? []).map((file) => readNonEmptyString(file.path)).filter(isNonEmptyString$1).map(normalizeCodexContextFilePath));
 	return params.bootstrapFiles.map((file) => {
-		const fileName = readNonEmptyString$1(file.name);
-		const pathValue = readNonEmptyString$1(file.path) ?? fileName ?? "";
+		const fileName = readNonEmptyString(file.name);
+		const pathValue = readNonEmptyString(file.path) ?? fileName ?? "";
 		const displayName = (fileName ?? getCodexContextFileDisplayBasename(pathValue)) || pathValue;
 		const baseName = getCodexContextFileBasename(pathValue || fileName || "");
 		const rawChars = file.missing ? 0 : (file.content ?? "").trimEnd().length;
@@ -461,7 +320,7 @@ function indexCodexContextFileContent(files) {
 	const byPath = /* @__PURE__ */ new Map();
 	const byBaseName = /* @__PURE__ */ new Map();
 	for (const file of files) {
-		const pathValue = readNonEmptyString$1(file.path);
+		const pathValue = readNonEmptyString(file.path);
 		if (!pathValue) continue;
 		if (!byPath.has(pathValue)) byPath.set(pathValue, file.content);
 		const baseName = getCodexContextFileBasename(pathValue);
@@ -485,7 +344,7 @@ function readCodexIndexedContextFileContent(index, pathValue, fileName) {
 function readPositiveNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
 }
-function readNonEmptyString$1(value) {
+function readNonEmptyString(value) {
 	return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
 /**
@@ -706,13 +565,13 @@ function isMissingCodexBootstrapContextFile(file) {
 }
 function toCodexEmbeddedContextFile(file) {
 	return {
-		path: readNonEmptyString$1(file.path) ?? readNonEmptyString$1(file.name) ?? "",
+		path: readNonEmptyString(file.path) ?? readNonEmptyString(file.name) ?? "",
 		content: file.content ?? ""
 	};
 }
 function isCodexWorkspaceRootMemoryBootstrapFile(params) {
 	return isCodexWorkspaceRootMemoryPath({
-		filePath: readNonEmptyString$1(params.file.path) ?? readNonEmptyString$1(params.file.name) ?? "",
+		filePath: readNonEmptyString(params.file.path) ?? readNonEmptyString(params.file.name) ?? "",
 		workspaceDir: params.workspaceDir
 	});
 }
@@ -819,6 +678,7 @@ function buildCodexPluginThreadConfigEligibilityLogData(params) {
 		enabled: params.pluginThreadConfigRequired,
 		policyConfigured: params.resolvedPluginPolicy?.configured === true,
 		policyEnabled: params.resolvedPluginPolicy?.enabled === true,
+		allowAllPlugins: params.resolvedPluginPolicy?.allowAllPlugins === true,
 		pluginConfigKeys: params.resolvedPluginPolicy?.pluginPolicies.map((plugin) => plugin.configKey).toSorted(),
 		enabledPluginConfigKeys: params.enabledPluginConfigKeys,
 		appCacheKeyFingerprint: fingerprintCodexLogValue("openclaw:codex:plugin-app-cache-key:v1", params.pluginAppCacheKey),
@@ -927,7 +787,7 @@ function reportCodexExecutionNotification(params) {
 }
 /** Returns true when a notification ends the current app-server turn. */
 function isTerminalCodexTurnNotificationForTurn(params) {
-	if (!isTurnNotification(params.notification.params, params.threadId, params.turnId)) return false;
+	if (!isCodexNotificationForTurn(params.notification.params, params.threadId, params.turnId)) return false;
 	return params.notification.method === "turn/completed" || isCodexTurnAbortMarkerNotification(params.notification, { currentPromptTexts: params.currentPromptTexts });
 }
 /**
@@ -936,11 +796,10 @@ function isTerminalCodexTurnNotificationForTurn(params) {
 */
 function applyCodexTurnNotificationState(params) {
 	const { notification, turnWatches } = params;
-	const isCurrentTurnNotification = isTurnNotification(notification.params, params.threadId, params.turnId);
+	const isCurrentTurnNotification = isCodexNotificationForTurn(notification.params, params.threadId, params.turnId);
 	const isTurnCompletion = notification.method === "turn/completed" && isCurrentTurnNotification;
-	const isNativeResponseStreamDelta = isNativeResponseStreamDeltaNotification(notification);
 	let turnCrossedToolHandoff = params.turnCrossedToolHandoff;
-	if (isCurrentTurnNotification && !isNativeResponseStreamDelta) {
+	if (isCurrentTurnNotification) {
 		turnWatches.touchActivity(`notification:${notification.method}`, {
 			details: describeNotificationActivity(notification),
 			attemptProgress: true
@@ -985,7 +844,7 @@ function applyCodexTurnNotificationState(params) {
 	else if (rawResponseItemCompletedWithNoActiveItems) turnWatches.armCompletionIdleWatch();
 	else if (isCurrentTurnNotification && rawToolOutputCompletion) armPostToolContinuationWatch();
 	else if (isCurrentTurnNotification && shouldDisarmAssistantCompletionIdleWatch(notification)) turnWatches.disarmAssistantCompletionIdleWatch();
-	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !isNativeResponseStreamDelta && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolProgressNeedsTerminalGuard && !postToolPatchUpdateNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmNoToolPostProgressReplyWatch && !shouldArmNoToolPostRawProgressReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
+	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolProgressNeedsTerminalGuard && !postToolPatchUpdateNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmNoToolPostProgressReplyWatch && !shouldArmNoToolPostRawProgressReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
 	if (trackedDynamicToolCompletion) {
 		const itemId = readNotificationItemId(notification);
 		if (itemId) {
@@ -2258,7 +2117,6 @@ const CODEX_SANDBOX_EXEC_SERVER_MAX_INBOUND_MESSAGE_BYTES = 100 * 1024 * 1024;
 async function ensureCodexSandboxExecServerEnvironment(params) {
 	if (!params.sandbox?.enabled || !params.sandbox.backend) return;
 	if (!canExposeLocalExecServerToAppServer(params.appServerStartOptions)) throw new Error("OpenClaw Codex exec-server uses a local loopback URL and cannot be registered with a remote Codex app-server.");
-	assertCodexSandboxExecServerSupported(params.client);
 	const execServer = await acquireOpenClawExecServer(params.sandbox);
 	try {
 		await params.client.request("environment/add", {
@@ -2287,10 +2145,6 @@ async function releaseCodexSandboxExecServerEnvironment(sandbox) {
 	const server = await SANDBOX_EXEC_SERVERS.get(sandbox.runtimeId)?.catch(() => void 0);
 	if (server) await releaseOpenClawExecServer(server);
 }
-function assertCodexSandboxExecServerSupported(client) {
-	const detectedVersion = client.getServerVersion();
-	if (!detectedVersion || compareCodexAppServerVersions(detectedVersion, "0.132.0") < 0) throw new Error(`Codex app-server ${MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION} or newer is required for OpenClaw sandbox exec-server environments, but detected ${detectedVersion ?? "an unknown version"}. Disable appServer.experimental.sandboxExecServer or configure a newer Codex app-server binary.`);
-}
 function isEnvironmentAddUnsupported(error) {
 	if (!(error instanceof Error)) return false;
 	return error.message.includes("environment/add") && (error.message.includes("unknown variant") || error.message.includes("Method not found"));
@@ -2447,6 +2301,335 @@ async function dispatchRequest(execServer, processes, socket, request) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/turn-router.ts
+/** Keyed routing for all turn traffic on one shared Codex app-server client. */
+const DEFAULT_PREBIND_NOTIFICATION_LIMIT = 256;
+const CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS = 3e4;
+const routers = /* @__PURE__ */ new WeakMap();
+/** Returns the sole router installed on a physical app-server client. */
+function getCodexAppServerTurnRouter(client) {
+	const existing = routers.get(client);
+	if (existing) return existing;
+	const router = new ClientTurnRouter(client);
+	routers.set(client, router);
+	return router;
+}
+var ClientTurnRouter = class {
+	constructor(client) {
+		this.routes = /* @__PURE__ */ new Map();
+		this.nativeTurnCompletionWatchers = /* @__PURE__ */ new Map();
+		this.disposed = false;
+		client.addNotificationHandler((notification) => this.routeNotification(notification));
+		client.addRequestHandler((request) => this.routeRequest(request));
+		client.addCloseHandler(() => this.dispose());
+	}
+	reserveThread(options) {
+		this.assertActive();
+		const threadId = requireId(options.threadId, "thread id");
+		if (this.routes.has(threadId)) throw new Error(`codex app-server thread route already reserved: ${threadId}`);
+		const route = {
+			threadId,
+			controller: new AbortController(),
+			ended: deferred(),
+			activated: deferred(),
+			gate: "open",
+			pending: [],
+			notificationTail: Promise.resolve(),
+			nativeTurnCompleted: false
+		};
+		this.routes.set(threadId, route);
+		if (options.onNotification || options.onRequest) this.activateNow(route, options);
+		const releaseOn = options.releaseOn;
+		if (releaseOn) {
+			const release = () => this.release(route, abortReason(releaseOn));
+			releaseOn.addEventListener("abort", release, { once: true });
+			route.detachReleaseOn = () => releaseOn.removeEventListener("abort", release);
+			if (releaseOn.aborted) release();
+		}
+		return {
+			threadId,
+			signal: route.controller.signal,
+			activate: (handlers) => this.activate(route, handlers),
+			armTurn: () => this.armTurn(route),
+			bindTurn: (turnId) => this.bindTurn(route, turnId),
+			cancelTurn: () => this.cancelTurn(route),
+			waitForTurnCompletion: (waitOptions) => this.waitForTurnCompletion(route, waitOptions),
+			drain: () => this.drainNotifications(route),
+			release: () => this.release(route)
+		};
+	}
+	watchNativeTurnCompletion(options) {
+		this.assertActive();
+		const threadId = requireId(options.threadId, "thread id");
+		const turnId = requireId(options.turnId, "turn id");
+		let settle;
+		const completion = new Promise((resolve) => {
+			settle = resolve;
+		});
+		const watchers = this.nativeTurnCompletionWatchers.get(threadId) ?? /* @__PURE__ */ new Set();
+		this.nativeTurnCompletionWatchers.set(threadId, watchers);
+		let settled = false;
+		const finish = (completed) => {
+			if (settled) return;
+			settled = true;
+			watchers.delete(watcher);
+			if (watchers.size === 0) this.nativeTurnCompletionWatchers.delete(threadId);
+			clearTimeout(timeout);
+			settle(completed);
+		};
+		const touch = () => {
+			timeout.refresh();
+		};
+		const watcher = {
+			turnId,
+			finish,
+			touch
+		};
+		watchers.add(watcher);
+		const timeout = setTimeout(() => finish(false), Math.max(1, options.timeoutMs));
+		timeout.unref?.();
+		return {
+			completion,
+			cancel: () => finish(false)
+		};
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const route of this.routes.values()) this.release(route, /* @__PURE__ */ new Error("codex app-server turn router closed"));
+		for (const watchers of this.nativeTurnCompletionWatchers.values()) for (const watcher of watchers) watcher.finish(false);
+	}
+	async activate(route, handlers) {
+		this.assertRoute(route);
+		this.activateNow(route, handlers);
+		await this.waitForNotifications(route);
+		this.assertRoute(route);
+	}
+	activateNow(route, handlers) {
+		if (route.handlers) throw new Error(`codex app-server thread route already activated: ${route.threadId}`);
+		this.assertRoute(route);
+		if (!handlers.onNotification && !handlers.onRequest) throw new Error("codex app-server thread route requires a notification or request handler");
+		route.handlers = handlers;
+		if (!handlers.onNotification) route.pending.length = 0;
+		else if (route.gate !== "armed") this.flushNotifications(route);
+		route.activated.resolve();
+	}
+	armTurn(route) {
+		this.assertRoute(route);
+		if (route.gate !== "open") throw new Error(`codex app-server thread route cannot arm from ${route.gate}`);
+		route.gate = "armed";
+		route.nativeTurnCompleted = false;
+		route.binding = deferred();
+	}
+	async cancelTurn(route) {
+		if (route.released || route.gate !== "armed") return;
+		route.gate = "open";
+		route.binding?.resolve();
+		route.binding = void 0;
+		this.flushNotifications(route);
+		await this.waitForNotifications(route);
+		this.assertRoute(route);
+	}
+	async bindTurn(route, turnIdInput) {
+		this.assertRoute(route);
+		if (!route.handlers) throw new Error("codex app-server thread route must be activated before binding a turn");
+		if (route.gate !== "armed") throw new Error(`codex app-server thread route cannot bind from ${route.gate}`);
+		const turnId = requireId(turnIdInput, "turn id");
+		route.gate = "bound";
+		route.turnId = turnId;
+		this.flushNotifications(route);
+		route.binding?.resolve();
+		await this.waitForNotifications(route);
+		this.assertRoute(route);
+	}
+	routeNotification(notification) {
+		if (this.disposed) return;
+		const scope = readScope(notification.params);
+		const watchers = scope.threadId ? this.nativeTurnCompletionWatchers.get(scope.threadId) : void 0;
+		const route = scope.threadId ? this.routes.get(scope.threadId) : void 0;
+		if (!watchers && !route) return;
+		const terminal = isCodexTerminalTurnNotification(notification);
+		if (scope.turnId && watchers) {
+			for (const watcher of watchers) if (watcher.turnId === scope.turnId) if (terminal) watcher.finish(true);
+			else watcher.touch();
+		}
+		if (!route) return;
+		const routeScope = {
+			threadId: route.threadId,
+			...scope.turnId ? { turnId: scope.turnId } : {}
+		};
+		const receivedAtMs = Date.now();
+		if (route.gate !== "bound" && terminal) if (route.nativeTurnCompletion) route.nativeTurnCompletion.resolve();
+		else route.nativeTurnCompleted = true;
+		if (!route.handlers) {
+			this.bufferNotification(route, notification, routeScope, receivedAtMs);
+			return;
+		}
+		const handler = route.handlers.onNotification;
+		if (!handler) return;
+		if (route.gate === "bound" && scope.turnId && scope.turnId !== route.turnId) return;
+		if (route.gate === "armed") {
+			this.bufferNotification(route, notification, routeScope, receivedAtMs);
+			return;
+		}
+		route.handlers.onNotificationReceived?.(notification, routeScope, receivedAtMs);
+		this.enqueueNotification(route, handler, notification, routeScope);
+		return route.notificationTail;
+	}
+	async routeRequest(request) {
+		if (this.disposed) 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;
+		const handler = route.handlers.onRequest;
+		if (!handler) return;
+		while (route.gate === "armed") {
+			await route.binding?.promise;
+			if (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;
+		try {
+			const result = await handler(request, {
+				threadId: scope.threadId,
+				...scope.turnId ? { turnId: scope.turnId } : {}
+			});
+			return route.released ? void 0 : result;
+		} catch (error) {
+			if (route.released) return;
+			throw error;
+		}
+	}
+	flushNotifications(route) {
+		const handler = route.handlers?.onNotification;
+		if (!handler) return;
+		for (const pending of route.pending.splice(0)) if (!pending.scope.turnId || route.gate !== "bound" || pending.scope.turnId === route.turnId) {
+			route.handlers?.onNotificationReceived?.(pending.notification, pending.scope, pending.receivedAtMs);
+			this.enqueueNotification(route, handler, pending.notification, pending.scope);
+		}
+	}
+	bufferNotification(route, notification, scope, receivedAtMs) {
+		if (route.pending.length < DEFAULT_PREBIND_NOTIFICATION_LIMIT) {
+			route.pending.push({
+				notification,
+				receivedAtMs,
+				scope
+			});
+			return;
+		}
+		const error = /* @__PURE__ */ new Error(`codex app-server pre-bind notification buffer exceeded ${DEFAULT_PREBIND_NOTIFICATION_LIMIT} entries for thread ${route.threadId}`);
+		embeddedAgentLog.warn(error.message);
+		this.release(route, error);
+	}
+	enqueueNotification(route, handler, notification, scope) {
+		if (route.released) return;
+		route.notificationTail = route.notificationTail.then(() => handler(notification, scope)).catch((error) => {
+			if (!route.released) embeddedAgentLog.warn("codex app-server keyed notification handler failed", {
+				method: notification.method,
+				threadId: route.threadId,
+				turnId: route.turnId,
+				error
+			});
+		});
+	}
+	async waitForNotifications(route) {
+		await Promise.race([route.notificationTail, route.ended.promise]);
+	}
+	async drainNotifications(route) {
+		await route.notificationTail;
+	}
+	async waitForTurnCompletion(route, options) {
+		this.assertRoute(route);
+		if (route.nativeTurnCompleted) {
+			route.nativeTurnCompleted = false;
+			return true;
+		}
+		if (route.nativeTurnCompletion) throw new Error(`codex app-server turn completion wait already active: ${route.threadId}`);
+		const completion = deferred();
+		route.nativeTurnCompletion = completion;
+		let timeout;
+		let removeAbort;
+		const timedOut = new Promise((resolve) => {
+			timeout = setTimeout(() => resolve(false), Math.max(1, options.timeoutMs));
+		});
+		const aborted = new Promise((resolve) => {
+			const signal = options.signal;
+			if (!signal) return;
+			const onAbort = () => resolve(false);
+			signal.addEventListener("abort", onAbort, { once: true });
+			removeAbort = () => signal.removeEventListener("abort", onAbort);
+			if (signal.aborted) onAbort();
+		});
+		try {
+			return await Promise.race([
+				completion.promise.then(() => true),
+				route.ended.promise.then(() => false),
+				timedOut,
+				aborted
+			]);
+		} finally {
+			if (route.nativeTurnCompletion === completion) route.nativeTurnCompletion = void 0;
+			if (timeout) clearTimeout(timeout);
+			removeAbort?.();
+		}
+	}
+	release(route, error = /* @__PURE__ */ new Error("codex app-server thread route is released")) {
+		if (route.released) return;
+		route.released = error;
+		route.pending.length = 0;
+		route.ended.resolve();
+		route.activated.resolve();
+		route.binding?.resolve();
+		route.detachReleaseOn?.();
+		route.controller.abort(error);
+		if (this.routes.get(route.threadId) === route) this.routes.delete(route.threadId);
+	}
+	assertActive() {
+		if (this.disposed) throw new Error("codex app-server turn router is closed");
+	}
+	assertRoute(route) {
+		if (route.released) throw route.released;
+	}
+};
+/** True after Codex will not continue the exact turn. */
+function isCodexTerminalTurnNotification(notification) {
+	if (notification.method === "turn/completed") return true;
+	return notification.method === "error" && isJsonObject(notification.params) && notification.params.willRetry === false;
+}
+function deferred() {
+	let resolve;
+	return {
+		promise: new Promise((resolvePromise) => {
+			resolve = resolvePromise;
+		}),
+		resolve
+	};
+}
+function abortReason(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "codex app-server thread route aborted"));
+}
+function readScope(value) {
+	if (!isJsonObject(value)) return {};
+	const threadId = readCodexNotificationThreadId(value);
+	const turnId = readCodexNotificationTurnId(value);
+	return {
+		...threadId ? { threadId } : {},
+		...turnId ? { turnId } : {}
+	};
+}
+function requireId(value, label) {
+	const normalized = value.trim();
+	if (!normalized) throw new Error(`codex app-server ${label} must not be empty`);
+	return normalized;
+}
+//#endregion
 //#region extensions/codex/src/app-server/attempt-startup.ts
 /**
 * Startup orchestration for Codex app-server attempts, including shared-client
@@ -2500,7 +2683,11 @@ async function startCodexAttemptThread(params) {
 					let startupAttemptError;
 					let startupAttemptSucceeded = false;
 					try {
-						startupClient = await params.attemptClientFactory(params.appServer.start, params.startupAuthProfileId, params.agentDir, params.config, {
+						startupClient = await params.attemptClientFactory({
+							startOptions: params.appServer.start,
+							authProfileId: params.startupAuthProfileId,
+							agentDir: params.agentDir,
+							config: params.config,
 							onStartedClient: (client) => {
 								startupClientForAbandonedRequestCleanup = client;
 								if (startupAbandoned || startupAbandonController.signal.aborted) closeCodexStartupClientBestEffort(client);
@@ -2519,6 +2706,12 @@ async function startCodexAttemptThread(params) {
 						startupClientForAbandonedRequestCleanup = activeStartupClient;
 						if (startupAbandoned) throw new Error("codex app-server startup timed out");
 						if (startupAbandonController.signal.aborted) throw new Error("codex app-server startup aborted");
+						ensureCodexAppServerClientRuntime(activeStartupClient, {
+							agentDir: params.agentDir,
+							authProfileId: params.startupAuthProfileId,
+							config: params.config
+						});
+						const turnRouter = getCodexAppServerTurnRouter(activeStartupClient);
 						await ensureCodexComputerUse({
 							client: activeStartupClient,
 							pluginConfig: params.pluginConfig,
@@ -2595,8 +2788,31 @@ async function startCodexAttemptThread(params) {
 							remoteWorkspaceRoot: params.appServer.remoteWorkspaceRoot
 						});
 						const startupSandboxPolicy = startupSandboxEnvironment ? resolveCodexExternalSandboxPolicyForOpenClawSandbox(params.sandbox) : void 0;
-						const buildThreadLifecycleParams = (signal) => ({
+						let startupReservation;
+						const releaseStartupReservation = () => {
+							startupReservation?.release();
+							startupReservation = void 0;
+						};
+						const reserveStartupThread = (threadId) => {
+							if (startupReservation) {
+								if (startupReservation.threadId !== threadId) throw new Error(`codex app-server reserved ${startupReservation.threadId} but started ${threadId}`);
+								return { release: releaseStartupReservation };
+							}
+							startupReservation = turnRouter.reserveThread({
+								threadId,
+								releaseOn: params.signal
+							});
+							return { release: releaseStartupReservation };
+						};
+						const releaseStartupResources = async () => {
+							releaseStartupReservation();
+							await releaseStartupSandboxEnvironment();
+						};
+						releaseStartupResourcesOnTimeout = releaseStartupResources;
+						const buildThreadLifecycleParams = (signal, reserveResumeThread) => ({
 							client: activeStartupClient,
+							reserveResumeThread,
+							bindingStore: params.bindingStore,
 							params: params.buildAttemptParams(),
 							agentId: params.sessionAgentId,
 							cwd: startupExecutionCwd,
@@ -2636,15 +2852,25 @@ async function startCodexAttemptThread(params) {
 							} : void 0
 						});
 						try {
-							const startupThread = await startOrResumeThread(buildThreadLifecycleParams(startupAbandonController.signal));
-							if (startupAbandonController.signal.aborted) {
-								await releaseStartupSandboxEnvironment();
-								throw new Error("codex app-server startup aborted");
+							const startupThread = await startOrResumeThread(buildThreadLifecycleParams(startupAbandonController.signal, reserveStartupThread));
+							try {
+								reserveStartupThread(startupThread.threadId);
+							} catch (error) {
+								if (!await unsubscribeCodexThreadBestEffort(activeStartupClient, {
+									threadId: startupThread.threadId,
+									timeoutMs: 5e3
+								})) throw new CodexAppServerUnsafeSubscriptionError("Codex startup subscription cleanup failed", { cause: error });
+								throw error;
 							}
+							if (startupAbandonController.signal.aborted) throw new Error("codex app-server startup aborted");
+							const startupRoute = startupReservation;
+							if (!startupRoute) throw new Error("codex app-server startup did not reserve its thread route");
 							startupSandboxEnvironmentAcquired = false;
 							startupAttemptSucceeded = true;
 							return {
 								client: activeStartupClient,
+								turnRouter,
+								turnRoute: startupRoute,
 								thread: startupThread,
 								sandboxEnvironment: startupSandboxEnvironment,
 								environmentSelection: startupEnvironmentSelection,
@@ -2653,10 +2879,10 @@ async function startCodexAttemptThread(params) {
 								restartContextEngineCodexThread: () => startOrResumeThread(buildThreadLifecycleParams(params.signal))
 							};
 						} catch (error) {
-							await releaseStartupSandboxEnvironment();
+							await releaseStartupResources();
 							throw error;
 						} finally {
-							if (releaseStartupResourcesOnTimeout === releaseStartupSandboxEnvironment) releaseStartupResourcesOnTimeout = void 0;
+							if (releaseStartupResourcesOnTimeout === releaseStartupResources) releaseStartupResourcesOnTimeout = void 0;
 						}
 					} catch (error) {
 						startupAttemptError = error;
@@ -2912,7 +3138,7 @@ function createCodexAttemptTurnWatchController(params) {
 	}
 	function scheduleAssistantCompletionIdleWatch() {
 		clearAssistantCompletionIdleTimer();
-		if (params.isCompleted() || params.signal.aborted || !assistantCompletionIdleWatchArmed) return;
+		if (params.isCompleted() || params.signal.aborted || !assistantCompletionIdleWatchArmed || params.getActiveFinalizationHookCount() > 0) return;
 		const elapsedMs = Math.max(0, Date.now() - assistantCompletionLastActivityAt);
 		const delayMs = Math.max(1, turnAssistantCompletionIdleTimeoutMs - elapsedMs);
 		assistantCompletionIdleTimer = setTimeout(fireAssistantCompletionIdleRelease, delayMs);
@@ -2955,10 +3181,16 @@ function createCodexAttemptTurnWatchController(params) {
 	}
 	function fireAssistantCompletionIdleRelease() {
 		if (params.isCompleted() || params.signal.aborted || !assistantCompletionIdleWatchArmed) return;
-		if (params.getActiveAppServerTurnRequests() > 0 || params.getActiveTurnItemCount() > 0) {
+		if (params.getActiveAppServerTurnRequests() > 0 || params.getActiveTurnItemCount() > 0 || params.getActiveFinalizationHookCount() > 0) {
 			scheduleAssistantCompletionIdleWatch();
 			return;
 		}
+		if (!params.canReleaseAssistantCompletionIdle()) {
+			assistantCompletionIdleWatchArmed = false;
+			assistantCompletionLastActivityDetails = void 0;
+			clearAssistantCompletionIdleTimer();
+			return;
+		}
 		const idleMs = Math.max(0, Date.now() - assistantCompletionLastActivityAt);
 		if (idleMs < turnAssistantCompletionIdleTimeoutMs) {
 			scheduleAssistantCompletionIdleWatch();
@@ -3156,2406 +3388,23 @@ function createCodexAttemptTurnWatchController(params) {
 			scheduleProgressWatches();
 		},
 		noteNotificationReceived: (method, options) => {
-			completionLastActivityAt = Date.now();
+			const now = Date.now();
+			completionLastActivityAt = Math.max(completionLastActivityAt, Math.min(now, options?.receivedAtMs ?? now));
 			completionLastActivityReason = `notification:${method}`;
 			if (options?.details !== void 0) completionLastActivityDetails = options.details;
-			if (options?.attemptProgress) recordAttemptProgress(completionLastActivityReason, options);
-		},
-		extendAttemptIdleWatch: (timeoutMs) => {
-			attemptIdleTimeoutOverrideMs = resolveWatchTimeoutMs(timeoutMs);
-			scheduleAttemptIdleWatch();
-		},
-		scheduleProgressWatches,
-		clearCompletionIdleTimer,
-		clearAssistantCompletionIdleTimer,
-		clearTerminalIdleTimer,
-		clearAttemptIdleTimer,
-		clearAllTimers
-	};
-}
-/** Hard cap for per-call Codex dynamic tool timeout overrides. */
-const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 6e5;
-const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12e4;
-/** Timeout for message-delivery dynamic tool calls. */
-const CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS = 12e4;
-const LOG_FIELD_MAX_LENGTH = 160;
-function normalizeLogField(value) {
-	if (typeof value !== "string") return;
-	const normalized = value.replaceAll(String.fromCharCode(27), " ").replaceAll("\r", " ").replaceAll("\n", " ").replaceAll("	", " ").trim();
-	if (!normalized) return;
-	return normalized.length > LOG_FIELD_MAX_LENGTH ? `${normalized.slice(0, LOG_FIELD_MAX_LENGTH - 3)}...` : normalized;
-}
-function readNumericTimeoutMs(value) {
-	if (typeof value === "number" && Number.isFinite(value)) return Math.max(0, Math.floor(value));
-	if (typeof value === "string") {
-		const parsed = parseStrictNonNegativeInteger(value);
-		if (parsed !== void 0) return Math.max(0, Math.floor(parsed));
-	}
-}
-function formatDynamicToolTimeoutDetails(params) {
-	const tool = normalizeLogField(params.call.tool) ?? "unknown";
-	const baseMeta = {
-		tool: params.call.tool,
-		toolCallId: params.call.callId,
-		threadId: params.call.threadId,
-		turnId: params.call.turnId,
-		timeoutMs: params.timeoutMs,
-		timeoutKind: "codex_dynamic_tool_rpc"
-	};
-	if (tool !== "process" || !isJsonObject(params.call.arguments)) return {
-		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms while running tool ${tool}.`,
-		consoleMessage: `codex dynamic tool timeout: tool=${tool} toolTimeoutMs=${params.timeoutMs}; per-tool-call watchdog, not session idle`,
-		meta: baseMeta
-	};
-	const action = normalizeLogField(params.call.arguments.action);
-	const sessionId = normalizeLogField(params.call.arguments.sessionId);
-	const requestedTimeoutMs = readNumericTimeoutMs(params.call.arguments.timeout);
-	const actionPart = action ? ` action=${action}` : "";
-	const sessionPart = sessionId ? ` sessionId=${sessionId}` : "";
-	const requestedPart = requestedTimeoutMs === void 0 ? "" : ` requestedWaitMs=${requestedTimeoutMs}`;
-	const retryHint = action === "poll" ? "; repeated lines usually mean process-poll retry churn, not model progress" : "";
-	const responseTarget = action || sessionId ? ` while waiting for process${actionPart}${sessionPart}` : " while waiting for the process tool";
-	return {
-		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms${responseTarget}. This is a tool RPC timeout, not a session idle timeout.`,
-		consoleMessage: `codex process tool timeout:${actionPart}${sessionPart} toolTimeoutMs=${params.timeoutMs}${requestedPart}; per-tool-call watchdog, not session idle${retryHint}`,
-		meta: {
-			...baseMeta,
-			processAction: action,
-			processSessionId: sessionId,
-			processRequestedTimeoutMs: requestedTimeoutMs
-		}
-	};
-}
-/**
-* Runs a dynamic tool call with run-abort and per-call timeout handling,
-* returning a Codex protocol response instead of throwing.
-*/
-async function handleDynamicToolCallWithTimeout(params) {
-	let didNotifyAgentToolResult = false;
-	const notifyAgentToolResult = (event) => {
-		if (didNotifyAgentToolResult) return;
-		didNotifyAgentToolResult = true;
-		try {
-			params.onAgentToolResult?.(event);
-		} catch (error) {
-			embeddedAgentLog.warn(`onAgentToolResult handler failed: tool=${params.call.tool} error=${String(error)}`);
-		}
-	};
-	const notifyFailedToolResult = (message) => {
-		notifyAgentToolResult({
-			toolName: params.call.tool,
-			result: {
-				content: [{
-					type: "text",
-					text: message
-				}],
-				details: {
-					status: "failed",
-					error: message
-				}
-			},
-			isError: true
-		});
-	};
-	if (params.signal.aborted) {
-		const message = "OpenClaw dynamic tool call aborted before execution.";
-		params.onFallbackSelected?.();
-		notifyFailedToolResult(message);
-		return failedDynamicToolResponse(message);
-	}
-	const controller = new AbortController();
-	let timeout;
-	let timedOut = false;
-	let resolveAbort;
-	const abortFromRun = () => {
-		const message = "OpenClaw dynamic tool call aborted.";
-		params.onFallbackSelected?.();
-		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
-		notifyFailedToolResult(message);
-		resolveAbort?.(failedDynamicToolResponse(message, { sideEffectEvidence: true }));
-	};
-	const abortPromise = new Promise((resolve) => {
-		resolveAbort = resolve;
-	});
-	const timeoutPromise = new Promise((resolve) => {
-		const timeoutMs = clampDynamicToolTimeoutMs(params.timeoutMs);
-		timeout = setTimeout(() => {
-			timedOut = true;
-			const timeoutDetails = formatDynamicToolTimeoutDetails({
-				call: params.call,
-				timeoutMs
-			});
-			params.onFallbackSelected?.();
-			controller.abort(new Error(timeoutDetails.responseMessage));
-			params.onTimeout?.();
-			embeddedAgentLog.warn("codex dynamic tool call timed out", {
-				...timeoutDetails.meta,
-				consoleMessage: timeoutDetails.consoleMessage
-			});
-			notifyFailedToolResult(timeoutDetails.responseMessage);
-			resolve(failedDynamicToolResponse(timeoutDetails.responseMessage, { sideEffectEvidence: true }));
-		}, timeoutMs);
-		timeout.unref?.();
-	});
-	try {
-		params.signal.addEventListener("abort", abortFromRun, { once: true });
-		if (params.signal.aborted) abortFromRun();
-		const response = await Promise.race([
-			params.toolBridge.handleToolCall(params.call, {
-				signal: controller.signal,
-				onAgentToolResult: notifyAgentToolResult,
-				toolCallOrdinal: params.toolCallOrdinal
-			}),
-			abortPromise,
-			timeoutPromise
-		]);
-		if (!response.success && !didNotifyAgentToolResult) notifyFailedToolResult(readDynamicToolResponseText(response));
-		return response;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		notifyFailedToolResult(message);
-		return failedDynamicToolResponse(message, { sideEffectEvidence: true });
-	} finally {
-		if (timeout) clearTimeout(timeout);
-		params.signal.removeEventListener("abort", abortFromRun);
-		resolveAbort = void 0;
-		if (!timedOut && !controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("OpenClaw dynamic tool call finished."));
-	}
-}
-function readDynamicToolResponseText(response) {
-	return response.contentItems.flatMap((item) => item.type === "inputText" && typeof item.text === "string" ? [item.text] : []).join("\n").trim() || "OpenClaw dynamic tool call failed.";
-}
-function failedDynamicToolResponse(message, options) {
-	const response = {
-		contentItems: [{
-			type: "inputText",
-			text: message
-		}],
-		success: false
-	};
-	Object.defineProperty(response, "diagnosticTerminalType", {
-		configurable: true,
-		enumerable: false,
-		value: "error"
-	});
-	if (options?.sideEffectEvidence === true) Object.defineProperty(response, "sideEffectEvidence", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
-}
-/** Strips OpenClaw-only metadata before sending a dynamic tool response to Codex. */
-function toCodexDynamicToolProtocolResponse(response) {
-	return {
-		contentItems: response.contentItems,
-		success: response.success
-	};
-}
-/** Adds async-started progress details when a tool result continues out of band. */
-function toCodexDynamicToolProgressResponse(response, protocolResponse) {
-	if (response.asyncStarted !== true) return protocolResponse;
-	return {
-		...protocolResponse,
-		details: {
-			async: true,
-			status: "started"
-		}
-	};
-}
-/** Decides whether a terminal dynamic tool response can release the Codex turn. */
-function shouldReleaseTurnAfterTerminalDynamicTool(state) {
-	return !state.completed && !state.aborted && state.responseSuccess && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && state.activeTurnItemIdsCount === 0 && state.pendingOpenClawDynamicToolCompletionIdsCount === 0;
-}
-/** Returns true when a non-async result should block terminal-release shortcuts. */
-function shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response) {
-	return response.asyncStarted !== true;
-}
-/** Resolves whether terminal diagnostic state should release, wait, or stay idle. */
-function resolveTerminalDynamicToolBatchAction(state) {
-	if (state.activeAppServerTurnRequests > 0 || state.activeTurnItemIdsCount > 0 || state.pendingOpenClawDynamicToolCompletionIdsCount > 0) return "wait";
-	if (state.currentTurnHadNonTerminalDynamicToolResult) return "clear-nonterminal-batch";
-	if (state.hasPendingTerminalDynamicToolRelease) return "release-pending-terminal";
-	return "idle";
-}
-/** Returns true for diagnostic events that terminate a dynamic tool call. */
-function isDynamicToolTerminalDiagnosticEvent(event) {
-	return event.type === "tool.execution.completed" || event.type === "tool.execution.error" || event.type === "tool.execution.blocked";
-}
-/** Matches terminal diagnostics to a specific dynamic tool call id/name. */
-function isMatchingDynamicToolTerminalDiagnostic(params) {
-	if (params.event.toolCallId !== params.call.callId || params.event.toolName !== params.call.tool) return false;
-	if (params.runId !== void 0) return params.event.runId === params.runId;
-	if (params.sessionId !== void 0) return params.event.sessionId === params.sessionId;
-	if (params.sessionKey !== void 0) return params.event.sessionKey === params.sessionKey;
-	return params.event.runId === void 0 && params.event.sessionId === void 0 && params.event.sessionKey === void 0;
-}
-/** Checks pending diagnostics for a terminal event matching a tool call. */
-function hasPendingDynamicToolTerminalDiagnostic(params) {
-	return hasPendingInternalDiagnosticEvent((event) => {
-		if (!isDynamicToolTerminalDiagnosticEvent(event)) return false;
-		return isMatchingDynamicToolTerminalDiagnostic({
-			event,
-			call: params.call,
-			runId: params.runId,
-			sessionId: params.sessionId,
-			sessionKey: params.sessionKey
-		});
-	});
-}
-/** Resolves per-tool timeout, applying media/message defaults and hard caps. */
-function resolveDynamicToolCallTimeoutMs(params) {
-	return clampDynamicToolTimeoutMs(readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? 9e4);
-}
-function readDynamicToolCallTimeoutMs(value) {
-	if (!isJsonObject(value)) return;
-	return readPositiveFiniteTimeoutMs(value.timeoutMs);
-}
-function readConfiguredDynamicToolTimeoutMs(toolName, config) {
-	if (toolName === "image_generate") {
-		const imageGenerationModel = config?.agents?.defaults?.imageGenerationModel;
-		if (!imageGenerationModel || typeof imageGenerationModel !== "object") return CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
-		return readPositiveFiniteTimeoutMs(imageGenerationModel.timeoutMs) ?? CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
-	}
-	if (toolName === "image") return readTimeoutSecondsAsMs(config?.tools?.media?.image?.timeoutSeconds) ?? 6e4;
-	if (toolName === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
-}
-function readTimeoutSecondsAsMs(value) {
-	const seconds = readPositiveFiniteTimeoutMs(value);
-	return seconds === void 0 ? void 0 : seconds * 1e3;
-}
-function readPositiveFiniteTimeoutMs(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
-}
-function clampDynamicToolTimeoutMs(timeoutMs) {
-	return Math.max(1, Math.min(CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS, Math.floor(timeoutMs)));
-}
-//#endregion
-//#region extensions/codex/src/app-server/local-runtime-attribution.ts
-const OPENAI_PROVIDER_ID = "openai";
-const OPENAI_RESPONSES_API = "openai-responses";
-const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
-function normalizeRuntimeId(value) {
-	return value?.trim().toLowerCase() ?? "";
-}
-/** Maps local Codex runtime plans onto the provider/api pair exposed to event projection. */
-function resolveCodexLocalRuntimeAttribution(params) {
-	const authProfileProvider = normalizeRuntimeId(params.runtimePlan?.auth?.authProfileProviderForAuth);
-	if (normalizeRuntimeId(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.provider) === OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.api) === OPENAI_RESPONSES_API) return {
-		provider: OPENAI_PROVIDER_ID,
-		api: OPENAI_CODEX_RESPONSES_API
-	};
-	return {
-		provider: params.provider,
-		api: params.model.api
-	};
-}
-//#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/transcript-mirror.ts
-const MIRROR_IDENTITY_META_KEY = "mirrorIdentity";
-function buildSenderLabel(params) {
-	const label = params.senderName ?? params.senderUsername ?? params.senderE164 ?? params.senderId;
-	if (!label) return;
-	if (!params.senderId || label.includes(params.senderId)) return label;
-	return `${label} (${params.senderId})`;
-}
-function buildCodexUserPromptMessageFromPrepared(params, preparedUserMessage) {
-	const senderId = normalizeOptionalString(params.senderId);
-	const senderName = normalizeOptionalString(params.senderName);
-	const senderUsername = normalizeOptionalString(params.senderUsername);
-	const senderE164 = normalizeOptionalString(params.senderE164);
-	const senderLabel = buildSenderLabel({
-		senderId,
-		senderName,
-		senderUsername,
-		senderE164
-	});
-	const sourceChannel = normalizeOptionalString(params.inputProvenance?.sourceChannel ?? params.messageChannel ?? params.messageProvider);
-	if (preparedUserMessage) return {
-		role: "user",
-		timestamp: Date.now(),
-		...params.inputProvenance ? { provenance: params.inputProvenance } : {},
-		...sourceChannel ? { sourceChannel } : {},
-		...senderId ? { senderId } : {},
-		...senderName ? { senderName } : {},
-		...senderUsername ? { senderUsername } : {},
-		...senderE164 ? { senderE164 } : {},
-		...senderLabel ? { senderLabel } : {},
-		...preparedUserMessage
-	};
-	return {
-		role: "user",
-		content: params.prompt,
-		timestamp: Date.now(),
-		...params.inputProvenance ? { provenance: params.inputProvenance } : {},
-		...sourceChannel ? { sourceChannel } : {},
-		...senderId ? { senderId } : {},
-		...senderName ? { senderName } : {},
-		...senderUsername ? { senderUsername } : {},
-		...senderE164 ? { senderE164 } : {},
-		...senderLabel ? { senderLabel } : {}
-	};
-}
-function buildCodexUserPromptMessage(params) {
-	return buildCodexUserPromptMessageFromPrepared(params, params.userTurnTranscriptRecorder?.message);
-}
-async function buildResolvedCodexUserPromptMessage(params) {
-	return buildCodexUserPromptMessageFromPrepared(params, await params.userTurnTranscriptRecorder?.resolveMessage() ?? params.userTurnTranscriptRecorder?.message);
-}
-async function mirrorTranscriptBestEffort(params) {
-	try {
-		const messages = await resolveFinalCodexMirrorMessages({
-			params: params.params,
-			messagesSnapshot: params.result.messagesSnapshot,
-			turnId: params.turnId
-		});
-		const mirrorResult = await mirrorCodexAppServerTranscript({
-			sessionFile: params.params.sessionFile,
-			agentId: params.agentId,
-			sessionKey: params.sessionKey,
-			sessionId: params.params.sessionId,
-			cwd: params.cwd,
-			messages,
-			idempotencyScope: `codex-app-server:${params.threadId}`,
-			config: params.params.config
-		});
-		for (const message of mirrorResult.userMessagesPresent) params.notifyUserMessagePersisted(message);
-	} catch (error) {
-		embeddedAgentLog.warn("failed to mirror codex app-server transcript", { error });
-	}
-}
-async function resolveFinalCodexMirrorMessages(params) {
-	if (params.params.suppressNextUserMessagePersistence || !params.params.userTurnTranscriptRecorder) return params.messagesSnapshot;
-	const resolvedPrompt = attachCodexMirrorIdentity(await buildResolvedCodexUserPromptMessage(params.params), `${params.turnId}:prompt`);
-	const firstUserIndex = params.messagesSnapshot.findIndex((message) => message.role === "user");
-	if (firstUserIndex === -1) return [resolvedPrompt, ...params.messagesSnapshot];
-	const messages = params.messagesSnapshot.slice();
-	messages[firstUserIndex] = resolvedPrompt;
-	return messages;
-}
-function createCodexAppServerUserMessagePersistenceNotifier(runParams) {
-	let notified = false;
-	return (message) => {
-		if (notified) return;
-		notified = true;
-		runParams.userTurnTranscriptRecorder?.markRuntimePersisted(message);
-		try {
-			runParams.onUserMessagePersisted?.(message);
-		} catch (error) {
-			embeddedAgentLog.warn("codex app-server user persistence notification failed", { error: formatErrorMessage(error) });
-		}
-	};
-}
-async function mirrorPromptAtTurnStartBestEffort(params) {
-	if (params.params.suppressNextUserMessagePersistence) return;
-	try {
-		const mirrorPromise = (async () => {
-			const userPromptMessage = attachCodexMirrorIdentity(await buildResolvedCodexUserPromptMessage(params.params), `${params.turnId}:prompt`);
-			const mirrorResult = await mirrorCodexAppServerTranscript({
-				sessionFile: params.params.sessionFile,
-				agentId: params.agentId,
-				sessionKey: params.sessionKey,
-				sessionId: params.params.sessionId,
-				cwd: params.cwd,
-				messages: [userPromptMessage],
-				idempotencyScope: `codex-app-server:${params.threadId}`,
-				config: params.params.config
-			});
-			for (const message of mirrorResult.userMessagesPresent) params.notifyUserMessagePersisted(message);
-		})();
-		params.params.userTurnTranscriptRecorder?.markRuntimePersistencePending(mirrorPromise);
-		await mirrorPromise;
-	} catch (error) {
-		embeddedAgentLog.warn("failed to mirror codex app-server prompt at turn start", { error });
-	}
-}
-/**
-* Tag a message with a stable logical identity for mirror dedupe. Callers
-* should use a value that is invariant for the same logical message across
-* re-emits (e.g. `${turnId}:prompt`, `${turnId}:assistant`) but distinct
-* for genuinely-distinct messages (different turns, different kinds). When
-* present this identity replaces the role/content fingerprint in the
-* idempotency key, so the dedupe survives caller-scope rotation without
-* collapsing distinct same-content turns.
-*/
-function attachCodexMirrorIdentity(message, identity) {
-	const record = message;
-	const existing = record["__openclaw"];
-	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
-	return {
-		...record,
-		__openclaw: {
-			...baseMeta,
-			[MIRROR_IDENTITY_META_KEY]: identity
-		}
-	};
-}
-function readMirrorIdentity(message) {
-	const meta = message["__openclaw"];
-	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
-	const id = meta[MIRROR_IDENTITY_META_KEY];
-	return typeof id === "string" && id.length > 0 ? id : void 0;
-}
-function fingerprintMirrorMessageContent(message) {
-	const payload = JSON.stringify({
-		role: message.role,
-		content: message.content
-	});
-	return createHash("sha256").update(payload).digest("hex").slice(0, 16);
-}
-function buildMirrorDedupeIdentity(message) {
-	const explicit = readMirrorIdentity(message);
-	if (explicit) return explicit;
-	return `${message.role}:${fingerprintMirrorMessageContent(message)}`;
-}
-async function mirrorCodexAppServerTranscript(params) {
-	const messages = params.messages.filter((message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
-	if (messages.length === 0) return { userMessagesPresent: [] };
-	const transcriptTarget = resolveCodexMirrorTranscriptTarget(params);
-	const { appendedUpdates, userMessagesPresent } = await withSessionTranscriptWriteLock({
-		...transcriptTarget,
-		config: params.config
-	}, async (transcript) => {
-		const nextAppendedUpdates = [];
-		const nextUserMessagesPresent = [];
-		const mirrorState = readTranscriptMirrorState(await transcript.readEvents());
-		let nextMessageSeq = mirrorState.messageCount;
-		for (const message of messages) {
-			const dedupeIdentity = buildMirrorDedupeIdentity(message);
-			const idempotencyKey = params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0;
-			const transcriptMessage = {
-				...message,
-				...idempotencyKey ? { idempotencyKey } : {}
-			};
-			if (idempotencyKey && mirrorState.idempotencyKeys.has(idempotencyKey)) {
-				const persistedUserMessage = mirrorState.userMessagesByIdempotencyKey.get(idempotencyKey);
-				if (persistedUserMessage) nextUserMessagesPresent.push(persistedUserMessage);
-				continue;
-			}
-			const nextMessage = runAgentHarnessBeforeMessageWriteHook({
-				message: transcriptMessage,
-				agentId: params.agentId,
-				sessionKey: params.sessionKey
-			});
-			if (!nextMessage) continue;
-			const messageToAppend = idempotencyKey ? {
-				...nextMessage,
-				idempotencyKey
-			} : nextMessage;
-			const appended = await transcript.appendMessage({
-				message: messageToAppend,
-				idempotencyLookup: idempotencyKey ? "caller-checked" : "scan",
-				cwd: params.cwd
-			});
-			if (!appended) continue;
-			const { messageId, message: appendedMessage } = appended;
-			if (appendedMessage.role === "user") {
-				nextUserMessagesPresent.push(appendedMessage);
-				if (idempotencyKey) mirrorState.userMessagesByIdempotencyKey.set(idempotencyKey, appendedMessage);
-			}
-			nextMessageSeq += 1;
-			nextAppendedUpdates.push({
-				messageId,
-				message: appendedMessage,
-				messageSeq: nextMessageSeq
-			});
-			if (idempotencyKey) mirrorState.idempotencyKeys.add(idempotencyKey);
-		}
-		return {
-			appendedUpdates: nextAppendedUpdates,
-			userMessagesPresent: nextUserMessagesPresent
-		};
-	});
-	for (const update of appendedUpdates) await publishSessionTranscriptUpdateByIdentity({
-		...transcriptTarget,
-		update: {
-			...params.sessionKey ? { sessionKey: params.sessionKey } : {},
-			...params.agentId ? { agentId: params.agentId } : {},
-			message: update.message,
-			messageId: update.messageId,
-			messageSeq: update.messageSeq
-		}
-	});
-	return { userMessagesPresent };
-}
-function resolveCodexMirrorTranscriptTarget(params) {
-	return {
-		...params.agentId ? { agentId: params.agentId } : {},
-		sessionFile: params.sessionFile,
-		sessionId: params.sessionId,
-		sessionKey: params.sessionKey ?? ""
-	};
-}
-function readTranscriptMirrorState(events) {
-	const idempotencyKeys = /* @__PURE__ */ new Set();
-	const userMessagesByIdempotencyKey = /* @__PURE__ */ new Map();
-	let messageCount = 0;
-	for (const event of events) {
-		if (!event || typeof event !== "object" || Array.isArray(event)) continue;
-		const parsed = event;
-		if (parsed.type === "message") messageCount += 1;
-		if (typeof parsed.message?.idempotencyKey === "string") {
-			idempotencyKeys.add(parsed.message.idempotencyKey);
-			if (parsed.message.role === "user") userMessagesByIdempotencyKey.set(parsed.message.idempotencyKey, parsed.message);
-		}
-	}
-	return {
-		idempotencyKeys,
-		messageCount,
-		userMessagesByIdempotencyKey
-	};
-}
-//#endregion
-//#region extensions/codex/src/app-server/event-projector.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 CURRENT_TOKEN_USAGE_KEYS = [
-	"last",
-	"current",
-	"lastCall",
-	"lastCallUsage",
-	"lastTokenUsage",
-	"last_token_usage"
-];
-const CODEX_PROMPT_TOTAL_INPUT_KEYS = [
-	"inputTokens",
-	"input_tokens",
-	"promptTokens",
-	"prompt_tokens"
-];
-const MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM = 20;
-const TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS = 12e3;
-const MISSING_TOOL_RESULT_ERROR = "OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.";
-const GENERATED_IMAGE_MEDIA_SUBDIR = "tool-image-generation";
-const BYTES_PER_MB = 1024 * 1024;
-const DEFAULT_GENERATED_IMAGE_MAX_BYTES = 6 * BYTES_PER_MB;
-const TRANSCRIPT_PROGRESS_SUPPRESSED_TOOL_NAMES = 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 CodexAppServerEventProjector = class {
-	constructor(params, threadId, turnId, options = {}) {
-		this.params = params;
-		this.threadId = threadId;
-		this.turnId = turnId;
-		this.options = options;
-		this.assistantTextByItem = /* @__PURE__ */ new Map();
-		this.assistantItemOrder = [];
-		this.assistantPhaseByItem = /* @__PURE__ */ new Map();
-		this.lastCommentaryProgressTextByItem = /* @__PURE__ */ new Map();
-		this.pendingRawCommentaryEchoes = 0;
-		this.reasoningTextByGroup = /* @__PURE__ */ new Map();
-		this.reasoningItemOrder = /* @__PURE__ */ new Map();
-		this.planTextByItem = /* @__PURE__ */ new Map();
-		this.activeItemIds = /* @__PURE__ */ new Set();
-		this.completedItemIds = /* @__PURE__ */ new Set();
-		this.activeCompactionItemIds = /* @__PURE__ */ new Set();
-		this.toolProgressTexts = /* @__PURE__ */ new Set();
-		this.toolResultSummaryItemIds = /* @__PURE__ */ new Set();
-		this.toolResultOutputItemIds = /* @__PURE__ */ new Set();
-		this.toolResultOutputStreamedItemIds = /* @__PURE__ */ new Set();
-		this.transcriptToolProgressSuppressedIds = /* @__PURE__ */ new Set();
-		this.toolTranscriptArgumentsById = /* @__PURE__ */ new Map();
-		this.toolResultOutputDeltaState = /* @__PURE__ */ new Map();
-		this.toolResultOutputTextByItem = /* @__PURE__ */ new Map();
-		this.toolMetas = /* @__PURE__ */ new Map();
-		this.terminalPresentationClearedItemIds = /* @__PURE__ */ new Set();
-		this.nativeToolOutcomeOrdinals = /* @__PURE__ */ new Map();
-		this.sideEffectingToolItemIds = /* @__PURE__ */ new Set();
-		this.sideEffectingDynamicToolCallIds = /* @__PURE__ */ new Set();
-		this.toolTranscriptMessages = [];
-		this.toolTranscriptCallIds = /* @__PURE__ */ new Set();
-		this.toolTranscriptResultIds = /* @__PURE__ */ new Set();
-		this.toolTranscriptNamesById = /* @__PURE__ */ new Map();
-		this.toolTrajectoryCallIds = /* @__PURE__ */ new Set();
-		this.toolTrajectoryResultIds = /* @__PURE__ */ new Set();
-		this.toolTrajectoryNamesById = /* @__PURE__ */ new Map();
-		this.toolTrajectoryItemsById = /* @__PURE__ */ new Map();
-		this.transcriptToolProgressCallIds = /* @__PURE__ */ new Set();
-		this.nativeGeneratedMediaItemIds = /* @__PURE__ */ new Set();
-		this.nativeGeneratedMediaUrlsByItemId = /* @__PURE__ */ new Map();
-		this.diagnosticToolStartedAtByItem = /* @__PURE__ */ new Map();
-		this.afterToolCallObservedItemIds = /* @__PURE__ */ new Set();
-		this.assistantStarted = false;
-		this.reasoningStarted = false;
-		this.reasoningEnded = false;
-		this.streamedPartialAssistantItemReplaceable = false;
-		this.promptErrorSource = null;
-		this.synthesizedMissingToolResultError = null;
-		this.aborted = false;
-		this.guardianReviewCount = 0;
-		this.completedCompactionCount = 0;
-	}
-	getCompletedTurnStatus() {
-		return this.completedTurn?.status;
-	}
-	hasCompletedTerminalAssistantText() {
-		const finalItem = this.resolveFinalAssistantTextItem();
-		return finalItem !== void 0 && this.completedItemIds.has(finalItem.itemId);
-	}
-	/** 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);
-	}
-	async handleNotification(notification) {
-		const params = isJsonObject(notification.params) ? notification.params : void 0;
-		if (!params) return;
-		if (notification.method === "account/rateLimits/updated") {
-			this.latestRateLimits = params;
-			rememberCodexRateLimits(params);
-			return;
-		}
-		if (isHookNotificationMethod(notification.method)) {
-			if (!this.isHookNotificationForCurrentThread(params)) return;
-		} else if (!this.isNotificationForTurn(params)) return;
-		switch (notification.method) {
-			case "item/agentMessage/delta":
-				await this.handleAssistantDelta(params);
-				break;
-			case "item/reasoning/summaryTextDelta":
-			case "item/reasoning/textDelta":
-				await this.handleReasoningDelta(notification.method, params);
-				break;
-			case "item/plan/delta":
-				this.handlePlanDelta(params);
-				break;
-			case "turn/plan/updated":
-				this.handleTurnPlanUpdated(params);
-				break;
-			case "item/started":
-				await this.handleItemStarted(params);
-				break;
-			case "item/completed":
-				await this.handleItemCompleted(params);
-				break;
-			case "item/commandExecution/outputDelta":
-				this.handleOutputDelta(params, "bash");
-				break;
-			case "item/fileChange/outputDelta":
-				this.handleOutputDelta(params, "apply_patch");
-				break;
-			case "item/autoApprovalReview/started":
-			case "item/autoApprovalReview/completed":
-				this.handleGuardianReviewNotification(notification.method, params);
-				break;
-			case "hook/started":
-			case "hook/completed":
-				this.handleHookNotification(notification.method, params);
-				break;
-			case "thread/tokenUsage/updated":
-				this.handleTokenUsage(params);
-				break;
-			case "turn/completed":
-				await this.handleTurnCompleted(params);
-				break;
-			case "rawResponseItem/completed":
-				await this.handleRawResponseItemCompleted(params);
-				break;
-			case "error":
-				if (readBooleanAlias(params, ["willRetry", "will_retry"]) === true) break;
-				this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
-				this.promptErrorSource = "prompt";
-				break;
-			default: break;
-		}
-	}
-	buildResult(toolTelemetry, options) {
-		const assistantTexts = this.collectAssistantTexts();
-		const reasoningText = collectReasoningTextValues(this.reasoningTextByGroup, this.reasoningItemOrder).join("\n\n");
-		const planText = collectTextValues(this.planTextByItem).join("\n\n");
-		const hasAssistantItemText = this.hasAssistantItemTextForSynthesis();
-		const legacyFailClosed = !this.completedTurn || this.completedTurn.status !== "completed" || hasAssistantItemText;
-		const hasDeliverableAssistantOnCompletedTurn = this.completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
-		this.synthesizeMissingToolResults({
-			synthesize: legacyFailClosed,
-			recordPromptError: legacyFailClosed && !hasDeliverableAssistantOnCompletedTurn
-		});
-		const lastAssistant = assistantTexts.length > 0 ? this.createAssistantMessage(assistantTexts.join("\n\n")) : void 0;
-		const currentAttemptAssistant = this.createCurrentAttemptAssistantMessage();
-		const turnId = this.turnId;
-		const messagesSnapshot = this.params.suppressNextUserMessagePersistence ? [] : [attachCodexMirrorIdentity(buildCodexUserPromptMessage(this.params), `${turnId}:prompt`)];
-		if (reasoningText) messagesSnapshot.push(attachCodexMirrorIdentity(this.createAssistantMirrorMessage("Codex reasoning", reasoningText), `${turnId}:reasoning`));
-		if (planText) messagesSnapshot.push(attachCodexMirrorIdentity(this.createAssistantMirrorMessage("Codex plan", planText), `${turnId}:plan`));
-		messagesSnapshot.push(...this.toolTranscriptMessages);
-		if (lastAssistant) messagesSnapshot.push(attachCodexMirrorIdentity(lastAssistant, `${turnId}:assistant`));
-		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.toolMetas.values()];
-		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || (toolTelemetry.successfulCronAdds ?? 0) > 0 || this.nativeGeneratedMediaItemIds.size > 0 || this.sideEffectingToolItemIds.size > 0 || this.sideEffectingDynamicToolCallIds.size > 0;
-		return {
-			aborted: this.aborted,
-			externalAbort: false,
-			timedOut: false,
-			idleTimedOut: false,
-			timedOutDuringCompaction: false,
-			timedOutDuringToolExecution: false,
-			promptError,
-			promptErrorSource: promptError ? this.promptErrorSource || "prompt" : null,
-			sessionIdUsed: this.params.sessionId,
-			...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
-			bootstrapPromptWarningSignaturesSeen: this.params.bootstrapPromptWarningSignaturesSeen,
-			bootstrapPromptWarningSignature: this.params.bootstrapPromptWarningSignature,
-			messagesSnapshot,
-			assistantTexts,
-			toolMetas,
-			lastAssistant,
-			currentAttemptAssistant,
-			...this.lastNativeToolError ? { lastToolError: this.lastNativeToolError } : {},
-			didSendViaMessagingTool: toolTelemetry.didSendViaMessagingTool,
-			didDeliverSourceReplyViaMessageTool: toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
-			messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,
-			messagingToolSentMediaUrls: toolTelemetry.messagingToolSentMediaUrls,
-			messagingToolSentTargets: toolTelemetry.messagingToolSentTargets,
-			messagingToolSourceReplyPayloads: toolTelemetry.messagingToolSourceReplyPayloads ?? [],
-			heartbeatToolResponse: toolTelemetry.heartbeatToolResponse,
-			toolMediaUrls: this.buildToolMediaUrls(toolTelemetry),
-			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
-			successfulCronAdds: toolTelemetry.successfulCronAdds,
-			cloudCodeAssistFormatError: false,
-			attemptUsage: this.tokenUsage,
-			replayMetadata: {
-				hadPotentialSideEffects,
-				replaySafe: !hadPotentialSideEffects
-			},
-			itemLifecycle: {
-				startedCount: this.activeItemIds.size + this.completedItemIds.size,
-				completedCount: this.completedItemIds.size,
-				activeCount: this.activeItemIds.size,
-				...this.completedCompactionCount > 0 ? { compactionCount: this.completedCompactionCount } : {}
-			},
-			yieldDetected: options?.yieldDetected || false,
-			didSendDeterministicApprovalPrompt: this.guardianReviewCount > 0 ? false : void 0
-		};
-	}
-	recordDynamicToolCall(params) {
-		const args = sanitizeCodexToolArguments(params.arguments);
-		this.recordToolTranscriptCall({
-			id: params.callId,
-			name: params.tool,
-			arguments: args
-		});
-	}
-	recordDynamicToolResult(params) {
-		const resultText = collectDynamicToolContentText(params.contentItems);
-		if (params.asyncStarted === true) {
-			const existing = this.toolMetas.get(params.callId);
-			this.toolMetas.set(params.callId, {
-				toolName: existing?.toolName ?? params.tool,
-				...existing?.meta ? { meta: existing.meta } : {},
-				asyncStarted: true
-			});
-		}
-		this.recordToolTranscriptResult({
-			id: params.callId,
-			name: params.tool,
-			text: resultText,
-			isError: !params.success
-		});
-		if (!params.success && params.terminalType === "blocked") this.lastNativeToolError = {
-			toolName: params.tool,
-			error: resultText || "codex dynamic tool blocked"
-		};
-		else if (params.success && this.lastNativeToolError && !this.lastNativeToolError.mutatingAction) this.lastNativeToolError = void 0;
-		if (params.sideEffectEvidence === true) this.sideEffectingDynamicToolCallIds.add(params.callId);
-	}
-	markTimedOut() {
-		this.aborted = true;
-		this.promptError = "codex app-server attempt timed out";
-		this.promptErrorSource = "prompt";
-	}
-	markAborted() {
-		this.aborted = true;
-	}
-	isCompacting() {
-		return this.activeCompactionItemIds.size > 0;
-	}
-	async handleAssistantDelta(params) {
-		const itemId = readString$5(params, "itemId") ?? readString$5(params, "id") ?? "assistant";
-		const delta = readString$5(params, "delta") ?? "";
-		if (!delta) return;
-		this.rememberAssistantPhase(readItem(params.item));
-		const phase = readString$5(params, "phase");
-		if (phase) this.assistantPhaseByItem.set(itemId, phase);
-		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 (this.isCommentaryAssistantItem(itemId)) this.emitCommentaryProgress({
-			itemId,
-			text
-		});
-		else {
-			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);
-		}
-	}
-	async handleReasoningDelta(method, params) {
-		const itemId = readString$5(params, "itemId") ?? readString$5(params, "id") ?? "reasoning";
-		const delta = readString$5(params, "delta") ?? "";
-		if (!delta) return;
-		this.reasoningStarted = true;
-		if (!this.reasoningItemOrder.has(itemId)) this.reasoningItemOrder.set(itemId, this.reasoningItemOrder.size);
-		const groupIndex = method === "item/reasoning/textDelta" ? readNonNegativeInteger(params, "contentIndex") ?? 0 : readNonNegativeInteger(params, "summaryIndex") ?? 0;
-		const groupKey = `${method}\0${itemId}\0${groupIndex}`;
-		const current = this.reasoningTextByGroup.get(groupKey);
-		this.reasoningTextByGroup.set(groupKey, {
-			itemId,
-			method,
-			index: groupIndex,
-			text: `${current?.text ?? ""}${delta}`
-		});
-		await this.params.onReasoningStream?.({
-			text: collectReasoningTextValues(this.reasoningTextByGroup, this.reasoningItemOrder).join("\n\n"),
-			isReasoningSnapshot: true
-		});
-	}
-	handlePlanDelta(params) {
-		const itemId = readString$5(params, "itemId") ?? readString$5(params, "id") ?? "plan";
-		const delta = readString$5(params, "delta") ?? "";
-		if (!delta) return;
-		const text = `${this.planTextByItem.get(itemId) ?? ""}${delta}`;
-		this.planTextByItem.set(itemId, text);
-		this.emitPlanUpdate({
-			explanation: void 0,
-			steps: splitPlanText(text)
-		});
-	}
-	handleTurnPlanUpdated(params) {
-		const plan = Array.isArray(params.plan) ? params.plan.flatMap((entry) => {
-			if (!isJsonObject(entry)) return [];
-			const step = readString$5(entry, "step");
-			const status = readString$5(entry, "status");
-			if (!step) return [];
-			return status ? [`${step} (${status})`] : [step];
-		}) : void 0;
-		this.emitPlanUpdate({
-			explanation: readNullableString$1(params, "explanation"),
-			steps: plan
-		});
-	}
-	async handleItemStarted(params) {
-		const item = readItem(params.item);
-		const itemId = item?.id ?? readString$5(params, "itemId") ?? readString$5(params, "id");
-		this.rememberAssistantPhase(item);
-		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.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.recordToolMeta(item);
-		this.emitStandardItemEvent({
-			phase: "start",
-			item
-		});
-		await this.emitNormalizedToolItemEvent({
-			phase: "start",
-			item
-		});
-		this.recordNativeToolTranscriptCall(item);
-		this.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.recordNativeToolOutcome(item);
-		this.clearTerminalPresentationForNativeItem(item);
-		const itemId = item?.id ?? readString$5(params, "itemId") ?? readString$5(params, "id");
-		if (itemId) {
-			this.activeItemIds.delete(itemId);
-			this.completedItemIds.add(itemId);
-		}
-		this.rememberAssistantPhase(item);
-		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;
-			}
-		}
-		this.recordNativeGeneratedMedia(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)
-			});
-		}
-		if (item?.type === "contextCompaction" && itemId) {
-			this.activeCompactionItemIds.delete(itemId);
-			this.completedCompactionCount += 1;
-			await runAgentHarnessAfterCompactionHook({
-				sessionFile: this.params.sessionFile,
-				messages: await this.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.recordToolMeta(item);
-		this.emitStandardItemEvent({
-			phase: "end",
-			item
-		});
-		await this.emitNormalizedToolItemEvent({
-			phase: "result",
-			item
-		});
-		this.recordNativeToolTranscriptCall(item);
-		this.recordNativeToolTranscriptResult(item);
-		this.emitToolResultSummary(item);
-		this.emitToolResultOutput(item);
-		this.emitAgentEvent({
-			stream: "codex_app_server.item",
-			data: {
-				phase: "completed",
-				itemId,
-				type: item?.type
-			}
-		});
-	}
-	handleTokenUsage(params) {
-		const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
-		const current = (tokenUsage ? readFirstJsonObject(tokenUsage, CURRENT_TOKEN_USAGE_KEYS) : void 0) ?? readFirstJsonObject(params, CURRENT_TOKEN_USAGE_KEYS);
-		if (!current) return;
-		const usage = normalizeCodexTokenUsage(current);
-		if (usage) this.tokenUsage = usage;
-	}
-	handleGuardianReviewNotification(method, params) {
-		this.guardianReviewCount += 1;
-		const review = isJsonObject(params.review) ? params.review : void 0;
-		const action = isJsonObject(params.action) ? params.action : void 0;
-		this.emitAgentEvent({
-			stream: "codex_app_server.guardian",
-			data: {
-				method,
-				phase: method.endsWith("/started") ? "started" : "completed",
-				reviewId: readString$5(params, "reviewId"),
-				targetItemId: readNullableString$1(params, "targetItemId"),
-				decisionSource: readString$5(params, "decisionSource"),
-				status: review ? readString$5(review, "status") : void 0,
-				riskLevel: review ? readString$5(review, "riskLevel") : void 0,
-				userAuthorization: review ? readString$5(review, "userAuthorization") : void 0,
-				rationale: review ? readNullableString$1(review, "rationale") : void 0,
-				actionType: action ? readString$5(action, "type") : void 0
-			}
-		});
-	}
-	handleHookNotification(method, params) {
-		const run = isJsonObject(params.run) ? params.run : void 0;
-		if (!run) return;
-		const durationMs = readNumber$1(run, "durationMs");
-		const entries = readHookOutputEntries(run.entries);
-		const hookTurnId = readNullableString$1(params, "turnId");
-		this.emitAgentEvent({
-			stream: "codex_app_server.hook",
-			data: {
-				phase: method === "hook/started" ? "started" : "completed",
-				threadId: this.threadId,
-				turnId: hookTurnId === void 0 ? this.turnId : hookTurnId,
-				hookRunId: readString$5(run, "id"),
-				eventName: readString$5(run, "eventName"),
-				handlerType: readString$5(run, "handlerType"),
-				executionMode: readString$5(run, "executionMode"),
-				scope: readString$5(run, "scope"),
-				source: readString$5(run, "source"),
-				sourcePath: readString$5(run, "sourcePath"),
-				status: readString$5(run, "status"),
-				statusMessage: readNullableString$1(run, "statusMessage"),
-				...durationMs !== void 0 ? { durationMs } : {},
-				...entries.length > 0 ? { entries } : {}
-			}
-		});
-	}
-	async handleTurnCompleted(params) {
-		const turn = readTurn(params.turn);
-		if (!turn || turn.id !== this.turnId) return;
-		this.completedTurn = turn;
-		if (turn.status === "failed") {
-			this.promptError = formatCodexUsageLimitErrorMessage({
-				message: turn.error?.message,
-				codexErrorInfo: turn.error?.codexErrorInfo,
-				rateLimits: this.latestRateLimits ?? readRecentCodexRateLimits()
-			}) ?? 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.rememberAssistantPhase(item);
-			if (item.type === "agentMessage" && typeof item.text === "string") {
-				this.rememberAssistantItem(item.id);
-				this.assistantTextByItem.set(item.id, item.text);
-			}
-			this.recordNativeGeneratedMedia(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)
-				});
-			}
-			this.recordToolMeta(item);
-			await this.emitSnapshotOnlyNativeToolProgress(item);
-			this.recordNativeToolTranscriptCall(item);
-			this.recordNativeToolTranscriptResult(item);
-			this.emitAfterToolCallObservation(item);
-			this.emitToolResultSummary(item);
-			this.emitToolResultOutput(item);
-		}
-		this.activeCompactionItemIds.clear();
-		await this.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.emitStandardItemEvent({
-				phase: "start",
-				item
-			});
-			await this.emitNormalizedToolItemEvent({
-				phase: "start",
-				item
-			});
-		}
-		this.activeItemIds.delete(item.id);
-		this.emitStandardItemEvent({
-			phase: "end",
-			item
-		});
-		await this.emitNormalizedToolItemEvent({
-			phase: "result",
-			item
-		});
-		this.completedItemIds.add(item.id);
-	}
-	isCurrentTurnSnapshotItem(item) {
-		const itemTurnId = readItemString(item, "turnId") ?? readItemString(item, "turn_id");
-		return itemTurnId === void 0 || itemTurnId === this.turnId;
-	}
-	handleOutputDelta(params, toolName) {
-		const itemId = readString$5(params, "itemId");
-		const delta = readString$5(params, "delta");
-		if (!itemId || !delta) return;
-		appendToolOutputDeltaText(this.toolResultOutputTextByItem, itemId, delta);
-		if (!this.shouldEmitToolOutput()) return;
-		if (this.transcriptToolProgressSuppressedIds.has(itemId) || !shouldEmitTranscriptToolProgress(toolName, this.toolTranscriptArgumentsById.get(itemId))) return;
-		const state = this.toolResultOutputDeltaState.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, MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM - state.messages);
-		if (remainingChars === 0 || remainingMessages === 0) {
-			state.truncated = true;
-			this.toolResultOutputDeltaState.set(itemId, state);
-			this.emitToolResultMessage({
-				itemId,
-				text: formatToolOutput(toolName, void 0, "(output truncated)")
-			});
-			return;
-		}
-		const chunk = delta.length > remainingChars ? delta.slice(0, remainingChars) : delta;
-		state.chars += chunk.length;
-		state.messages += 1;
-		const reachedLimit = delta.length > remainingChars || state.chars >= TOOL_PROGRESS_OUTPUT_MAX_CHARS || state.messages >= MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM;
-		if (reachedLimit) state.truncated = true;
-		this.toolResultOutputDeltaState.set(itemId, state);
-		this.toolResultOutputStreamedItemIds.add(itemId);
-		this.emitToolResultMessage({
-			itemId,
-			text: formatToolOutput(toolName, void 0, reachedLimit ? `${chunk}\n...(truncated)...` : chunk)
-		});
-	}
-	async handleRawResponseItemCompleted(params) {
-		const item = isJsonObject(params.item) ? params.item : void 0;
-		if (!item) return;
-		await this.recordRawGeneratedImageMedia(item);
-		if (readString$5(item, "role") !== "assistant") return;
-		const phase = readString$5(item, "phase");
-		if (phase === "commentary" && this.pendingRawCommentaryEchoes > 0) {
-			this.pendingRawCommentaryEchoes -= 1;
-			return;
-		}
-		const text = extractRawAssistantText(item);
-		if (!text) return;
-		const itemId = readString$5(item, "id") ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
-		if (phase) this.assistantPhaseByItem.set(itemId, phase);
-		this.rememberAssistantItem(itemId);
-		this.assistantTextByItem.set(itemId, text);
-		if (phase === "commentary") this.emitCommentaryProgress({
-			itemId,
-			text
-		});
-	}
-	recordNativeGeneratedMedia(item) {
-		if (item?.type !== "imageGeneration") return;
-		const savedPath = readItemString(item, "savedPath")?.trim();
-		if (savedPath) this.recordNativeGeneratedMediaUrl({
-			itemId: item.id,
-			mediaUrl: savedPath
-		});
-	}
-	async recordRawGeneratedImageMedia(item) {
-		if (readString$5(item, "type") !== "image_generation_call") return;
-		const result = readString$5(item, "result");
-		if (!result) return;
-		const itemId = readString$5(item, "id") ?? `raw-image-${this.nativeGeneratedMediaItemIds.size}`;
-		this.nativeGeneratedMediaItemIds.add(itemId);
-		const maxBytes = resolveGeneratedImageMaxBytes(this.params.config);
-		const estimatedDecodedBytes = estimateBase64DecodedBytes(result);
-		if (estimatedDecodedBytes !== void 0 && estimatedDecodedBytes > maxBytes) {
-			embeddedAgentLog.warn("codex app-server raw image generation result exceeds media limit", {
-				itemId,
-				estimatedDecodedBytes,
-				maxBytes
-			});
-			return;
-		}
-		const asset = generatedImageAssetFromBase64({
-			base64: result,
-			index: this.nativeGeneratedMediaItemIds.size,
-			revisedPrompt: readString$5(item, "revised_prompt") ?? readString$5(item, "revisedPrompt"),
-			fileNamePrefix: "codex-image-generation",
-			sniffMimeType: true
-		});
-		if (!asset) return;
-		try {
-			const saved = await saveMediaBuffer(asset.buffer, asset.mimeType, GENERATED_IMAGE_MEDIA_SUBDIR, maxBytes, asset.fileName);
-			this.recordNativeGeneratedMediaUrl({
-				itemId,
-				mediaUrl: saved.path,
-				replaceExisting: true
-			});
-		} catch (error) {
-			embeddedAgentLog.warn("codex app-server raw image generation result save failed", {
-				itemId,
-				error
-			});
-		}
-	}
-	recordNativeGeneratedMediaUrl(params) {
-		if (this.nativeGeneratedMediaUrlsByItemId.has(params.itemId) && params.replaceExisting !== true) {
-			this.nativeGeneratedMediaItemIds.add(params.itemId);
-			return;
-		}
-		this.nativeGeneratedMediaUrlsByItemId.set(params.itemId, params.mediaUrl);
-		this.nativeGeneratedMediaItemIds.add(params.itemId);
-	}
-	buildToolMediaUrls(toolTelemetry) {
-		const mediaUrls = new Set(toolTelemetry.toolMediaUrls?.map((url) => url.trim()).filter(Boolean) ?? []);
-		if ((toolTelemetry.messagingToolSentMediaUrls?.length ?? 0) === 0) for (const mediaUrl of this.nativeGeneratedMediaUrlsByItemId.values()) mediaUrls.add(mediaUrl);
-		return mediaUrls.size > 0 ? [...mediaUrls] : toolTelemetry.toolMediaUrls;
-	}
-	async maybeEndReasoning() {
-		if (!this.reasoningStarted || this.reasoningEnded) return;
-		this.reasoningEnded = true;
-		await this.params.onReasoningEnd?.();
-	}
-	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 } : {}
-			}
-		});
-	}
-	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";
-	}
-	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"
-			}
-		});
-	}
-	emitStandardItemEvent(params) {
-		const { item } = params;
-		if (!item) return;
-		const kind = itemKind(item);
-		if (!kind) return;
-		const meta = itemMeta(item, this.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.toolProgressDetailMode());
-		this.recordToolTrajectoryEvent({
-			phase: params.phase,
-			item,
-			name,
-			args,
-			status
-		});
-		this.emitDiagnosticToolExecutionEvent({
-			phase: params.phase,
-			item,
-			name,
-			status
-		});
-		if (params.phase === "result") this.recordNativeToolError({
-			item,
-			name,
-			meta,
-			status
-		});
-		if (!shouldEmitTranscriptToolProgress(name, args)) {
-			if (params.phase === "result") {
-				this.emitAfterToolCallObservation(item);
-				await this.options.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.emitAfterToolCallObservation(item);
-			await this.options.onNativeToolResultRecorded?.();
-		}
-	}
-	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
-		});
-	}
-	recordNativeToolError(params) {
-		if (!isNonSuccessItemStatus(params.status)) {
-			if (!this.lastNativeToolError) return;
-			if (!this.lastNativeToolError.mutatingAction) {
-				this.lastNativeToolError = void 0;
-				return;
-			}
-			const actionFingerprint = nativeToolActionFingerprint(params.item);
-			if (this.lastNativeToolError.actionFingerprint && actionFingerprint && this.lastNativeToolError.actionFingerprint === actionFingerprint) this.lastNativeToolError = void 0;
-			return;
-		}
-		const error = itemToolError(params.item, params.status, this.toolResultOutputTextByItem);
-		const actionFingerprint = nativeToolActionFingerprint(params.item);
-		this.lastNativeToolError = {
-			toolName: params.name,
-			...params.meta ? { meta: params.meta } : {},
-			...error ? { error } : {},
-			...isMutatingNativeToolItem(params.item) ? { mutatingAction: true } : {},
-			...actionFingerprint ? { actionFingerprint } : {}
-		};
-	}
-	recordToolTrajectoryEvent(params) {
-		if (params.phase === "start") {
-			this.toolTrajectoryCallIds.add(params.item.id);
-			this.toolTrajectoryNamesById.set(params.item.id, params.name);
-			this.toolTrajectoryItemsById.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.toolTrajectoryResultIds.add(params.item.id);
-		const toolResult = itemToolResult(params.item).result;
-		const output = itemOutputText(params.item, this.toolResultOutputTextByItem);
-		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 } : {}
-		});
-	}
-	emitDiagnosticToolExecutionEvent(params) {
-		const base = {
-			runId: this.params.runId,
-			sessionId: this.params.sessionId,
-			sessionKey: this.params.sessionKey,
-			toolName: params.name,
-			toolCallId: params.item.id
-		};
-		if (params.phase === "start") {
-			this.diagnosticToolStartedAtByItem.set(params.item.id, Date.now());
-			emitTrustedDiagnosticEvent({
-				type: "tool.execution.started",
-				...base
-			});
-			return;
-		}
-		const startedAt = this.diagnosticToolStartedAtByItem.get(params.item.id);
-		this.diagnosticToolStartedAtByItem.delete(params.item.id);
-		const durationMs = (typeof params.item.durationMs === "number" ? params.item.durationMs : void 0) ?? (startedAt === void 0 ? 0 : Math.max(0, Date.now() - startedAt));
-		const terminalEvent = params.status === "blocked" ? {
-			type: "tool.execution.blocked",
-			reason: "codex_native_tool_blocked",
-			deniedReason: "codex_native_tool_blocked"
-		} : params.status === "failed" ? {
-			type: "tool.execution.error",
-			durationMs,
-			errorCategory: "codex_native_tool_error"
-		} : {
-			type: "tool.execution.completed",
-			durationMs
-		};
-		emitTrustedDiagnosticEvent({
-			...base,
-			...terminalEvent
-		});
-	}
-	emitAfterToolCallObservation(item) {
-		if (!this.shouldEmitAfterToolCallObservation(item)) return;
-		const name = itemName(item);
-		if (!name) return;
-		const status = itemStatus(item);
-		if (status === "running") return;
-		this.afterToolCallObservedItemIds.add(item.id);
-		const result = itemToolResult(item).result;
-		const error = itemToolError(item, status, this.toolResultOutputTextByItem);
-		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);
-		});
-	}
-	shouldEmitAfterToolCallObservation(item) {
-		if (!shouldSynthesizeToolProgressForItem(item) || this.afterToolCallObservedItemIds.has(item.id)) return false;
-		if (this.options.nativePostToolUseRelayEnabled && isNativePostToolUseRelayItem(item)) return false;
-		return true;
-	}
-	emitToolResultSummary(item) {
-		if (!item || !this.params.onToolResult || !this.shouldEmitToolResult()) return;
-		const itemId = item.id;
-		if (this.toolResultSummaryItemIds.has(itemId)) return;
-		const toolName = itemName(item);
-		if (!toolName) return;
-		if (!shouldEmitTranscriptToolProgress(toolName, itemToolArgs(item))) return;
-		this.toolResultSummaryItemIds.add(itemId);
-		const meta = itemMeta(item, this.toolProgressDetailMode());
-		this.emitToolResultMessage({
-			itemId,
-			text: formatToolSummary(toolName, meta)
-		});
-	}
-	emitToolResultOutput(item) {
-		if (!item || !this.params.onToolResult || !this.shouldEmitToolOutput()) return;
-		const itemId = item.id;
-		if (this.toolResultOutputItemIds.has(itemId)) return;
-		if (this.toolResultOutputStreamedItemIds.has(itemId)) return;
-		const toolName = itemName(item);
-		const output = itemOutputText(item, this.toolResultOutputTextByItem);
-		if (!toolName || !output) return;
-		if (!shouldEmitTranscriptToolProgress(toolName, itemToolArgs(item))) return;
-		this.emitToolResultMessage({
-			itemId,
-			text: formatToolOutput(toolName, itemMeta(item, this.toolProgressDetailMode()), output),
-			finalOutput: true,
-			isError: isNonSuccessItemStatus(itemStatus(item))
-		});
-	}
-	emitToolResultMessage(params) {
-		const text = params.text.trim();
-		if (!text) return;
-		this.toolProgressTexts.add(text);
-		if (params.finalOutput) this.toolResultOutputItemIds.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";
-	}
-	toolProgressDetailMode() {
-		return resolveCodexToolProgressDetailMode(this.params.toolProgressDetail);
-	}
-	recordToolMeta(item) {
-		if (!item) return;
-		if (isSideEffectingNativeToolItem(item)) this.sideEffectingToolItemIds.add(item.id);
-		else this.sideEffectingToolItemIds.delete(item.id);
-		const toolName = itemName(item);
-		if (!toolName) return;
-		const meta = itemMeta(item, this.toolProgressDetailMode());
-		const existing = this.toolMetas.get(item.id);
-		this.toolMetas.set(item.id, {
-			toolName,
-			...meta ? { meta } : {},
-			...existing?.asyncStarted ? { asyncStarted: true } : {}
-		});
-	}
-	recordNativeToolTranscriptCall(item) {
-		if (!item || !shouldRecordNativeToolTranscript(item)) return;
-		const name = itemName(item);
-		if (!name) return;
-		this.recordToolTranscriptCall({
-			id: item.id,
-			name,
-			arguments: itemToolArgs(item)
-		});
-	}
-	recordNativeToolTranscriptResult(item) {
-		if (!item || !shouldRecordNativeToolTranscript(item)) return;
-		const name = itemName(item);
-		if (!name) return;
-		this.recordToolTranscriptResult({
-			id: item.id,
-			name,
-			text: itemTranscriptResultText(item, this.toolResultOutputTextByItem),
-			isError: isNonSuccessItemStatus(itemStatus(item))
-		});
-	}
-	recordToolTranscriptCall(params) {
-		if (!params.id || !params.name || this.toolTranscriptCallIds.has(params.id)) return;
-		this.toolTranscriptCallIds.add(params.id);
-		this.toolTranscriptNamesById.set(params.id, params.name);
-		this.toolTranscriptArgumentsById.set(params.id, params.arguments);
-		if (!shouldEmitTranscriptToolProgress(params.name, params.arguments)) this.transcriptToolProgressSuppressedIds.add(params.id);
-		else this.transcriptToolProgressSuppressedIds.delete(params.id);
-		this.emitTranscriptToolCallProgress(params);
-		this.toolTranscriptMessages.push(attachCodexMirrorIdentity(this.createToolCallMessage(params), `${this.turnId}:tool:${params.id}:call`));
-	}
-	recordToolTranscriptResult(params) {
-		if (!params.id || !params.name || this.toolTranscriptResultIds.has(params.id)) return;
-		this.toolTranscriptResultIds.add(params.id);
-		this.emitTranscriptToolResultProgress(params);
-		this.toolTranscriptMessages.push(attachCodexMirrorIdentity(this.createToolResultMessage(params), `${this.turnId}:tool:${params.id}:result`));
-	}
-	synthesizeMissingToolResults(params) {
-		if (!params.synthesize) return;
-		const missingTranscriptIds = [...this.toolTranscriptCallIds].filter((id) => !this.toolTranscriptResultIds.has(id));
-		const missingTrajectoryIds = [...this.toolTrajectoryCallIds].filter((id) => !this.toolTrajectoryResultIds.has(id));
-		if (missingTranscriptIds.length === 0 && missingTrajectoryIds.length === 0) return;
-		for (const id of missingTranscriptIds) {
-			const name = this.toolTranscriptNamesById.get(id) ?? this.toolTrajectoryNamesById.get(id);
-			if (!name) continue;
-			this.recordToolTranscriptResult({
-				id,
-				name,
-				text: formatMissingToolResultError({
-					id,
-					name
-				}),
-				isError: true
-			});
-		}
-		for (const id of missingTrajectoryIds) {
-			const name = this.toolTrajectoryNamesById.get(id) ?? this.toolTranscriptNamesById.get(id);
-			if (!name) continue;
-			this.toolTrajectoryResultIds.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) {
-			const firstMissingId = missingTranscriptIds.find((id) => {
-				const name = this.toolTranscriptNamesById.get(id) ?? this.toolTrajectoryNamesById.get(id);
-				return Boolean(name);
-			}) ?? missingTrajectoryIds.find((id) => {
-				const name = this.toolTrajectoryNamesById.get(id) ?? this.toolTranscriptNamesById.get(id);
-				return Boolean(name);
-			});
-			if (firstMissingId) {
-				const name = this.toolTranscriptNamesById.get(firstMissingId) ?? this.toolTrajectoryNamesById.get(firstMissingId);
-				if (name) {
-					const item = this.toolTrajectoryItemsById.get(firstMissingId);
-					const meta = item ? itemMeta(item, this.toolProgressDetailMode()) : this.toolMetas.get(firstMissingId)?.meta;
-					const actionFingerprint = item ? nativeToolActionFingerprint(item) : void 0;
-					this.lastNativeToolError = {
-						toolName: name,
-						...meta ? { meta } : {},
-						error: formatMissingToolResultError({
-							id: firstMissingId,
-							name
-						}),
-						...item && isMutatingNativeToolItem(item) ? { mutatingAction: true } : {},
-						...actionFingerprint ? { actionFingerprint } : {}
-					};
-				}
-			}
-			return;
-		}
-		const missingCount = new Set([...missingTranscriptIds, ...missingTrajectoryIds]).size;
-		this.synthesizedMissingToolResultError = missingCount === 1 ? MISSING_TOOL_RESULT_ERROR : `${MISSING_TOOL_RESULT_ERROR} missingToolResultCount=${missingCount}`;
-		this.promptErrorSource = this.promptErrorSource ?? "prompt";
-	}
-	emitTranscriptToolCallProgress(params) {
-		if (!shouldEmitTranscriptToolProgress(params.name, params.arguments)) return;
-		this.transcriptToolProgressCallIds.add(params.id);
-		const args = normalizeToolTranscriptArguments(params.arguments);
-		const meta = inferToolMetaFromArgs(params.name, args, { detailMode: this.toolProgressDetailMode() });
-		if (!this.params.onToolResult || !this.shouldEmitToolResult() || this.toolResultSummaryItemIds.has(params.id) || this.toolResultOutputStreamedItemIds.has(params.id)) return;
-		this.toolResultSummaryItemIds.add(params.id);
-		this.emitToolResultMessage({
-			itemId: params.id,
-			text: formatToolSummary(params.name, meta)
-		});
-	}
-	emitTranscriptToolResultProgress(params) {
-		if (this.transcriptToolProgressSuppressedIds.has(params.id) || !shouldEmitTranscriptToolProgress(params.name, this.toolTranscriptArgumentsById.get(params.id))) return;
-		if (!this.transcriptToolProgressCallIds.has(params.id)) this.emitTranscriptToolCallProgress({
-			id: params.id,
-			name: params.name,
-			arguments: {}
-		});
-		if (!this.params.onToolResult || !this.shouldEmitToolOutput() || this.toolResultOutputItemIds.has(params.id) || this.toolResultOutputStreamedItemIds.has(params.id)) return;
-		const text = params.text?.trim();
-		if (!text) return;
-		this.emitToolResultMessage({
-			itemId: params.id,
-			text: formatToolOutput(params.name, void 0, text),
-			finalOutput: true,
-			isError: params.isError
-		});
-	}
-	formatCodexErrorMessage(params) {
-		const error = isJsonObject(params.error) ? params.error : void 0;
-		return formatCodexUsageLimitErrorMessage({
-			message: error ? readString$5(error, "message") : void 0,
-			codexErrorInfo: error?.codexErrorInfo,
-			rateLimits: this.latestRateLimits ?? readRecentCodexRateLimits()
-		}) ?? readCodexErrorNotificationMessage(params);
-	}
-	emitAgentEvent(event) {
-		try {
-			emitAgentEvent({
-				runId: this.params.runId,
-				stream: event.stream,
-				data: event.data,
-				...this.params.sessionKey ? { sessionKey: this.params.sessionKey } : {}
-			});
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
-		}
-		try {
-			const maybePromise = this.params.onAgentEvent?.(event);
-			Promise.resolve(maybePromise).catch((error) => {
-				embeddedAgentLog.debug("codex app-server agent event handler rejected", { error });
-			});
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
-		}
-	}
-	collectAssistantTexts() {
-		const finalText = this.resolveFinalAssistantText();
-		return finalText ? [finalText] : [];
-	}
-	hasAssistantItemTextForSynthesis() {
-		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
-			const itemId = this.assistantItemOrder[i];
-			if (!itemId) continue;
-			if (this.assistantPhaseByItem.get(itemId) === "commentary") continue;
-			const text = this.assistantTextByItem.get(itemId);
-			if (text && text.length > 0) return true;
-		}
-		return false;
-	}
-	resolveFinalAssistantText() {
-		return this.resolveFinalAssistantTextItem()?.text;
-	}
-	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.toolProgressTexts.has(text)) return {
-				itemId,
-				text
-			};
-		}
-	}
-	rememberAssistantItem(itemId) {
-		if (!itemId || this.assistantItemOrder.includes(itemId)) return;
-		this.assistantItemOrder.push(itemId);
-	}
-	createCurrentAttemptAssistantMessage() {
-		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.toolProgressTexts.has(normalizedText)) continue;
-			return this.createAssistantMessage(text);
-		}
-	}
-	async readMirroredSessionMessages() {
-		return await readCodexMirroredSessionHistoryMessages({
-			agentId: this.params.agentId,
-			sessionFile: this.params.sessionFile,
-			sessionId: this.params.sessionId,
-			sessionKey: this.params.sessionKey
-		}) ?? [];
-	}
-	createAssistantMessage(text) {
-		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
-		const usage = this.tokenUsage ? {
-			input: this.tokenUsage.input ?? 0,
-			output: this.tokenUsage.output ?? 0,
-			cacheRead: this.tokenUsage.cacheRead ?? 0,
-			cacheWrite: this.tokenUsage.cacheWrite ?? 0,
-			totalTokens: this.tokenUsage.total ?? (this.tokenUsage.input ?? 0) + (this.tokenUsage.output ?? 0) + (this.tokenUsage.cacheRead ?? 0) + (this.tokenUsage.cacheWrite ?? 0),
-			cost: ZERO_USAGE.cost
-		} : ZERO_USAGE;
-		return {
-			role: "assistant",
-			content: [{
-				type: "text",
-				text
-			}],
-			api: attribution.api ?? "openai-chatgpt-responses",
-			provider: attribution.provider,
-			model: this.params.modelId,
-			usage,
-			stopReason: this.aborted ? "aborted" : this.promptError ? "error" : "stop",
-			errorMessage: this.promptError ? formatErrorMessage(this.promptError) : void 0,
-			timestamp: Date.now()
-		};
-	}
-	createAssistantMirrorMessage(title, text) {
-		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
-		return {
-			role: "assistant",
-			content: [{
-				type: "text",
-				text: `${title}:\n${text}`
-			}],
-			api: attribution.api ?? "openai-chatgpt-responses",
-			provider: attribution.provider,
-			model: this.params.modelId,
-			usage: ZERO_USAGE,
-			stopReason: "stop",
-			timestamp: Date.now()
-		};
-	}
-	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: Date.now()
-		};
-	}
-	createToolResultMessage(params) {
-		const text = truncateToolTranscriptText(params.text?.trim() || toolResultStatusText(params));
-		return {
-			role: "toolResult",
-			toolCallId: params.id,
-			toolName: params.name,
-			isError: params.isError,
-			content: [{
-				type: "toolResult",
-				id: params.id,
-				name: params.name,
-				toolName: params.name,
-				toolCallId: params.id,
-				toolUseId: params.id,
-				tool_use_id: params.id,
-				content: text,
-				text
-			}],
-			timestamp: Date.now()
-		};
-	}
-	isNotificationForTurn(params) {
-		const threadId = readCodexNotificationThreadId(params);
-		const turnId = readNotificationTurnId(params);
-		return threadId === this.threadId && turnId === this.turnId;
-	}
-	isHookNotificationForCurrentThread(params) {
-		const threadId = readString$5(params, "threadId");
-		const turnId = params.turnId;
-		return threadId === this.threadId && (turnId === this.turnId || turnId === null);
-	}
-};
-function isHookNotificationMethod(method) {
-	return method === "hook/started" || method === "hook/completed";
-}
-function readNotificationTurnId(record) {
-	return readCodexNotificationTurnId(record);
-}
-function readString$5(record, key) {
-	const value = record[key];
-	return typeof value === "string" ? value : void 0;
-}
-function estimateBase64DecodedBytes(base64) {
-	let nonWhitespaceLength = 0;
-	let previousCode = -1;
-	let lastCode = -1;
-	for (let i = 0; i < base64.length; i += 1) {
-		const code = base64.charCodeAt(i);
-		if (isBase64WhitespaceCode(code)) continue;
-		nonWhitespaceLength += 1;
-		previousCode = lastCode;
-		lastCode = code;
-	}
-	if (nonWhitespaceLength === 0) return;
-	const equalsCode = "=".charCodeAt(0);
-	const padding = lastCode === equalsCode ? previousCode === equalsCode ? 2 : 1 : 0;
-	return Math.max(0, Math.floor(nonWhitespaceLength * 3 / 4) - padding);
-}
-function isBase64WhitespaceCode(code) {
-	return code === 32 || code === 9 || code === 10 || code === 13;
-}
-function resolveGeneratedImageMaxBytes(config) {
-	const configured = config?.agents?.defaults?.mediaMaxMb;
-	if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) return Math.floor(configured * BYTES_PER_MB);
-	return DEFAULT_GENERATED_IMAGE_MAX_BYTES;
-}
-function normalizeNonEmptyString(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
-}
-function readNonEmptyString(record, key) {
-	return normalizeNonEmptyString(record[key]);
-}
-function readNonEmptyStringArray(record, key) {
-	const value = record[key];
-	if (!Array.isArray(value)) return [];
-	const entries = [];
-	for (const entry of value) {
-		const normalized = normalizeNonEmptyString(entry);
-		if (normalized) entries.push(normalized);
-	}
-	return entries;
-}
-function readNullableString$1(record, key) {
-	const value = record[key];
-	if (value === null) return null;
-	return typeof value === "string" ? value : void 0;
-}
-function readNumber$1(record, key) {
-	const value = record[key];
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function resolveStartedAtFromDurationMs(durationMs) {
-	if (typeof durationMs !== "number" || !Number.isFinite(durationMs)) return;
-	return asDateTimestampMs(Date.now() - Math.max(0, durationMs));
-}
-function readNonNegativeInteger(record, key) {
-	const value = readNumber$1(record, key);
-	return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : void 0;
-}
-function readBoolean(record, key) {
-	const value = record[key];
-	return typeof value === "boolean" ? value : void 0;
-}
-function readBooleanAlias(record, keys) {
-	for (const key of keys) {
-		const value = readBoolean(record, key);
-		if (value !== void 0) return value;
-	}
-}
-function readCodexErrorNotificationMessage(record) {
-	const error = record.error;
-	if (isJsonObject(error)) return readString$5(error, "message") ?? readString$5(error, "error");
-	return readString$5(record, "message");
-}
-function readHookOutputEntries(value) {
-	if (!Array.isArray(value)) return [];
-	return value.flatMap((entry) => {
-		if (!isJsonObject(entry)) return [];
-		const text = readString$5(entry, "text");
-		if (!text) return [];
-		const kind = readString$5(entry, "kind");
-		return [{
-			...kind ? { kind } : {},
-			text
-		}];
-	});
-}
-function readFirstJsonObject(record, keys) {
-	for (const key of keys) {
-		const value = record[key];
-		if (isJsonObject(value)) return value;
-	}
-}
-function readNumberAlias(record, keys) {
-	for (const key of keys) {
-		const value = readNumber$1(record, key);
-		if (value !== void 0) return value;
-	}
-}
-function normalizeCodexTokenUsage(record) {
-	const promptTotalInput = readNumberAlias(record, CODEX_PROMPT_TOTAL_INPUT_KEYS);
-	const cacheRead = readNumberAlias(record, [
-		"cachedInputTokens",
-		"cached_input_tokens",
-		"cacheRead",
-		"cache_read",
-		"cache_read_input_tokens",
-		"cached_tokens"
-	]);
-	return normalizeUsage({
-		input: promptTotalInput !== void 0 && cacheRead !== void 0 ? Math.max(0, promptTotalInput - cacheRead) : promptTotalInput ?? readNumber$1(record, "input"),
-		output: readNumberAlias(record, [
-			"outputTokens",
-			"output_tokens",
-			"output"
-		]),
-		cacheRead,
-		cacheWrite: readNumberAlias(record, [
-			"cacheWrite",
-			"cache_write",
-			"cacheCreationInputTokens",
-			"cache_creation_input_tokens"
-		]),
-		total: readNumberAlias(record, [
-			"totalTokens",
-			"total_tokens",
-			"total"
-		])
-	});
-}
-function splitPlanText(text) {
-	return text.split(/\r?\n/).map((line) => line.trim().replace(/^[-*]\s+/, "")).filter((line) => line.length > 0);
-}
-function collectTextValues(map) {
-	return [...map.values()].filter((text) => text.trim().length > 0);
-}
-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;
-}
-function extractRawAssistantText(item) {
-	return (Array.isArray(item.content) ? item.content : []).flatMap((entry) => {
-		if (!isJsonObject(entry)) return [];
-		const type = readString$5(entry, "type");
-		if (type !== "output_text" && type !== "text") return [];
-		const value = readString$5(entry, "text");
-		return value ? [value] : [];
-	}).join("").trim() || void 0;
-}
-function itemKind(item) {
-	switch (item.type) {
-		case "dynamicToolCall":
-		case "mcpToolCall": return "tool";
-		case "commandExecution": return "command";
-		case "fileChange": return "patch";
-		case "webSearch": return "search";
-		case "reasoning":
-		case "contextCompaction": return "analysis";
-		default: return;
-	}
-}
-function itemTitle(item) {
-	switch (item.type) {
-		case "commandExecution": return "Command";
-		case "fileChange": return "File change";
-		case "mcpToolCall": return "MCP tool";
-		case "dynamicToolCall": return "Tool";
-		case "webSearch": return "Web search";
-		case "contextCompaction": return "Context compaction";
-		case "reasoning": return "Reasoning";
-		default: return item.type;
-	}
-}
-function itemStatus(item) {
-	const status = readItemString(item, "status");
-	if (status === "failed") return "failed";
-	if (status === "declined") return "blocked";
-	if (status === "inProgress" || status === "running") return "running";
-	return "completed";
-}
-function formatMissingToolResultError(params) {
-	return `${MISSING_TOOL_RESULT_ERROR} toolCallId=${params.id}; toolName=${params.name}`;
-}
-function isNonSuccessItemStatus(status) {
-	return status === "failed" || status === "blocked";
-}
-function itemName(item) {
-	if (item.type === "dynamicToolCall" && typeof item.tool === "string") return item.tool;
-	if (item.type === "mcpToolCall" && typeof item.tool === "string") {
-		const server = typeof item.server === "string" ? item.server : void 0;
-		return server ? `${server}.${item.tool}` : item.tool;
-	}
-	if (item.type === "commandExecution") return "bash";
-	if (item.type === "fileChange") return "apply_patch";
-	if (item.type === "webSearch") return "web_search";
-}
-function isSideEffectingNativeToolItem(item) {
-	return itemStatus(item) !== "blocked" && (isMutatingNativeToolItem(item) || item.type === "mcpToolCall");
-}
-function shouldSynthesizeToolProgressForItem(item) {
-	switch (item.type) {
-		case "commandExecution":
-		case "fileChange":
-		case "webSearch":
-		case "mcpToolCall": return true;
-		default: return false;
-	}
-}
-function shouldRecordNativeToolTranscript(item) {
-	return shouldSynthesizeToolProgressForItem(item) && item.type !== "webSearch";
-}
-function isMutatingNativeToolItem(item) {
-	if (item.type === "commandExecution") return true;
-	return item.type === "fileChange" || item.type === "collabAgentToolCall" || item.type === "imageGeneration";
-}
-function shouldClearTerminalPresentationForNativeItem(item) {
-	switch (item.type) {
-		case "collabAgentToolCall":
-		case "commandExecution":
-		case "fileChange":
-		case "imageGeneration":
-		case "imageView":
-		case "mcpToolCall":
-		case "webSearch": return true;
-		default: return false;
-	}
-}
-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: itemFileChanges(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(action, "type") : void 0;
-	const queries = action && actionType === "search" ? readNonEmptyStringArray(action, "queries") : [];
-	const query = normalizeNonEmptyString(item.query) ?? (action && actionType === "search" ? readNonEmptyString(action, "query") : void 0) ?? queries[0];
-	const url = action ? readNonEmptyString(action, "url") : void 0;
-	const pattern = action ? readNonEmptyString(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 itemFileChanges(item) {
-	return Array.isArray(item.changes) ? item.changes.map((change) => ({
-		path: change.path,
-		kind: change.kind
-	})) : [];
-}
-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") return item.aggregatedOutput?.trim() || outputTextByItem?.get(item.id)?.trim() || void 0;
-	if (item.type === "dynamicToolCall") return collectDynamicToolContentText(item.contentItems).trim() || void 0;
-	if (item.type === "mcpToolCall") {
-		if (item.error) return stringifyJsonValue(item.error);
-		return item.result ? stringifyJsonValue(item.result) : void 0;
-	}
-}
-function itemTranscriptResultText(item, outputTextByItem) {
-	const output = itemOutputText(item, outputTextByItem);
-	if (output) return output;
-	const result = itemToolResult(item).result;
-	return result ? stringifyJsonValue(result) : itemStatus(item);
-}
-function appendToolOutputDeltaText(outputTextByItem, itemId, delta) {
-	const current = outputTextByItem.get(itemId) ?? "";
-	if (current.length >= TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS) return;
-	const remaining = TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS - current.length;
-	const next = current + (delta.length > remaining ? delta.slice(0, remaining) : delta);
-	outputTextByItem.set(itemId, next);
-}
-function normalizeToolTranscriptArguments(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-	return value;
-}
-function collectDynamicToolContentText(contentItems) {
-	if (!Array.isArray(contentItems)) return "";
-	return contentItems.flatMap((entry) => {
-		if (!isJsonObject(entry)) return [];
-		const text = readString$5(entry, "text");
-		return text ? [text] : [];
-	}).join("\n");
-}
-function truncateToolTranscriptText(text) {
-	if (text.length <= TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS) return text;
-	return `${text.slice(0, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS)}\n...(truncated)...`;
-}
-function toolResultStatusText(params) {
-	return params.isError ? `${params.name} failed` : `${params.name} completed`;
-}
-function stringifyJsonValue(value) {
-	try {
-		return JSON.stringify(value, null, 2);
-	} catch {
-		return;
-	}
-}
-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;
-}
-function readItemString(item, key) {
-	const value = item[key];
-	return typeof value === "string" ? value : void 0;
-}
-function readItem(value) {
-	if (!isJsonObject(value)) return;
-	const type = typeof value.type === "string" ? value.type : void 0;
-	const id = typeof value.id === "string" ? value.id : void 0;
-	if (!type || !id) return;
-	return value;
-}
-function readTurn(value) {
-	return readCodexTurn(value);
+			if (options?.attemptProgress) recordAttemptProgress(completionLastActivityReason, options);
+		},
+		extendAttemptIdleWatch: (timeoutMs) => {
+			attemptIdleTimeoutOverrideMs = resolveWatchTimeoutMs(timeoutMs);
+			scheduleAttemptIdleWatch();
+		},
+		scheduleProgressWatches,
+		clearCompletionIdleTimer,
+		clearAssistantCompletionIdleTimer,
+		clearTerminalIdleTimer,
+		clearAttemptIdleTimer,
+		clearAllTimers
+	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-subagent-notification.ts
@@ -5701,8 +3550,7 @@ var CodexNativeSubagentTaskMirror = class {
 	constructor(params, runtime) {
 		this.params = params;
 		this.runtime = runtime;
-		this.mirroredThreadIds = /* @__PURE__ */ new Set();
-		this.failedMirrorThreadIds = /* @__PURE__ */ new Set();
+		this.mirrorStateByThreadId = /* @__PURE__ */ new Map();
 		this.terminalRunIds = /* @__PURE__ */ new Set();
 		this.authoritativeRunIds = /* @__PURE__ */ new Set();
 		this.expectedAuthoritativeRunIds = /* @__PURE__ */ new Set();
@@ -5736,8 +3584,8 @@ var CodexNativeSubagentTaskMirror = class {
 		const spawn = readSubagentThreadSpawnSource(thread.source, this.params.parentThreadId);
 		if (!spawn) return;
 		const threadId = thread.id.trim();
-		if (!threadId || this.mirroredThreadIds.has(threadId)) return;
-		this.mirroredThreadIds.add(threadId);
+		if (!threadId || this.mirrorStateByThreadId.get(threadId) === "mirrored") return;
+		this.mirrorStateByThreadId.set(threadId, "mirrored");
 		const runId = codexNativeSubagentRunId(threadId);
 		const label = trimOptional(spawn.agent_nickname) ?? trimOptional(thread.agentNickname) ?? trimOptional(spawn.agent_role) ?? trimOptional(thread.agentRole) ?? "Codex subagent";
 		const task = trimOptional(thread.preview) ?? `Codex native subagent${label === "Codex subagent" ? "" : ` ${label}`}`;
@@ -5755,11 +3603,9 @@ var CodexNativeSubagentTaskMirror = class {
 			lastEventAt: this.now(),
 			progressSummary: "Codex native subagent started."
 		})) {
-			this.mirroredThreadIds.delete(threadId);
-			this.failedMirrorThreadIds.add(threadId);
+			this.mirrorStateByThreadId.set(threadId, "failed");
 			return;
 		}
-		this.failedMirrorThreadIds.delete(threadId);
 		this.terminalRunIds.delete(runId);
 		this.authoritativeRunIds.delete(runId);
 		this.applyStatus(threadId, thread.status);
@@ -5770,7 +3616,7 @@ var CodexNativeSubagentTaskMirror = class {
 		this.applyStatus(notification.threadId, notification.status);
 	}
 	applyStatus(threadId, status) {
-		if (!this.mirroredThreadIds.has(threadId) && this.failedMirrorThreadIds.has(threadId)) return;
+		if (this.mirrorStateByThreadId.get(threadId) === "failed") return;
 		const statusType = status?.type;
 		if (!statusType) return;
 		const runId = codexNativeSubagentRunId(threadId);
@@ -5820,7 +3666,7 @@ var CodexNativeSubagentTaskMirror = class {
 		const isSpawnAgentTool = normalizeToolName$1(readString$3(item, "tool")) === "spawnagent";
 		const receiverThreadIds = readStringArray$1(item.receiverThreadIds);
 		const agentsStates = readAgentsStates(item.agentsStates);
-		const spawnChildThreadIds = new Set([...receiverThreadIds, ...agentsStates.keys()]);
+		const spawnChildThreadIds = /* @__PURE__ */ new Set([...receiverThreadIds, ...agentsStates.keys()]);
 		if (isSpawnAgentTool) for (const childThreadId of spawnChildThreadIds) this.createTaskFromCollabSpawnItem(childThreadId, item);
 		const toolCallStatus = normalizeCollabToolCallStatus(readString$3(item, "status"));
 		const terminalToolCallThreadIds = /* @__PURE__ */ new Set();
@@ -5843,8 +3689,8 @@ var CodexNativeSubagentTaskMirror = class {
 	}
 	createTaskFromCollabSpawnItem(threadId, item) {
 		const normalizedThreadId = threadId.trim();
-		if (!normalizedThreadId || this.mirroredThreadIds.has(normalizedThreadId)) return;
-		this.mirroredThreadIds.add(normalizedThreadId);
+		if (!normalizedThreadId || this.mirrorStateByThreadId.get(normalizedThreadId) === "mirrored") return;
+		this.mirrorStateByThreadId.set(normalizedThreadId, "mirrored");
 		const prompt = trimOptional(readString$3(item, "prompt"));
 		const runId = codexNativeSubagentRunId(normalizedThreadId);
 		const createdAt = this.now();
@@ -5861,16 +3707,14 @@ var CodexNativeSubagentTaskMirror = class {
 			lastEventAt: createdAt,
 			progressSummary: "Codex native subagent spawned."
 		})) {
-			this.mirroredThreadIds.delete(normalizedThreadId);
-			this.failedMirrorThreadIds.add(normalizedThreadId);
+			this.mirrorStateByThreadId.set(normalizedThreadId, "failed");
 			return;
 		}
-		this.failedMirrorThreadIds.delete(normalizedThreadId);
 		this.terminalRunIds.delete(runId);
 		this.authoritativeRunIds.delete(runId);
 	}
 	applyCollabAgentStatus(threadId, status, message) {
-		if (!this.mirroredThreadIds.has(threadId) && this.failedMirrorThreadIds.has(threadId)) return;
+		if (this.mirrorStateByThreadId.get(threadId) === "failed") return;
 		const normalizedStatus = normalizeAgentStateStatus(status);
 		if (!normalizedStatus) return;
 		const runId = codexNativeSubagentRunId(threadId);
@@ -6068,6 +3912,7 @@ function registerCodexNativeSubagentMonitor(params) {
 		taskRuntimeScope: params.taskRuntimeScope,
 		agentId: params.agentId
 	});
+	return monitor;
 }
 /** Tracks native subagent thread notifications, transcript completions, and task delivery. */
 var CodexNativeSubagentMonitor = class {
@@ -6094,6 +3939,13 @@ var CodexNativeSubagentMonitor = class {
 		this.childThreadIdsByAgentPath.clear();
 		this.transcriptPathsByChildThreadId.clear();
 	}
+	deferUntilParentSettles(parentThreadId, callback) {
+		const normalizedParentThreadId = parentThreadId.trim();
+		const state = this.parentStates.get(normalizedParentThreadId);
+		if (!state || !this.hasUnsettledChildren(normalizedParentThreadId)) return false;
+		state.deferredSettlement = callback;
+		return true;
+	}
 	configure(options) {
 		const codexHome = normalizeOptionalString(options.codexHome);
 		if (codexHome) this.codexHome = codexHome;
@@ -6131,10 +3983,29 @@ var CodexNativeSubagentMonitor = class {
 				error: formatErrorMessage(error)
 			});
 		}
+		this.markChildTurnStarted(notification);
+		await this.handleChildSystemError(notification);
 		this.captureChildAssistantMessage(notification);
 		await this.handleChildTurnCompletion(notification);
 		await this.handleCompletionNotification(notification);
 	}
+	markChildTurnStarted(notification) {
+		if (notification.method !== "turn/started") return;
+		const childThreadId = readString$2(isJsonObject(notification.params) ? notification.params : void 0, "threadId")?.trim();
+		const childState = childThreadId ? this.childStates.get(childThreadId) : void 0;
+		if (childState) childState.settledWithoutCompletion = false;
+	}
+	async handleChildSystemError(notification) {
+		if (notification.method !== "thread/status/changed") return;
+		const params = isJsonObject(notification.params) ? notification.params : void 0;
+		if (readString$2(isJsonObject(params?.status) ? params.status : void 0, "type") !== "systemError") return;
+		const childThreadId = readString$2(params, "threadId")?.trim();
+		const childState = childThreadId ? this.childStates.get(childThreadId) : void 0;
+		if (childState) {
+			childState.settledWithoutCompletion = true;
+			await this.flushDeferredParentSettlements(childState.parentThreadId);
+		}
+	}
 	ensureParentTaskRuntime(state) {
 		if (state.taskRuntime || !state.requesterSessionKey || !state.taskRuntimeScope) return;
 		state.taskRuntime = this.runtime.createAgentHarnessTaskRuntime({
@@ -6171,7 +4042,7 @@ var CodexNativeSubagentMonitor = class {
 			const parentThreadId = item ? (readString$2(item, "senderThreadId") ?? readString$2(params, "threadId"))?.trim() : void 0;
 			const state = parentThreadId ? this.parentStates.get(parentThreadId) : void 0;
 			if (state && parentThreadId) {
-				const childThreadIds = normalizeToolName(readString$2(item, "tool")) === "spawnagent" ? new Set([...readStringArray(item?.receiverThreadIds), ...readObjectStringKeys(item?.agentsStates)]) : new Set(readStringArray(item?.receiverThreadIds));
+				const childThreadIds = normalizeToolName(readString$2(item, "tool")) === "spawnagent" ? /* @__PURE__ */ new Set([...readStringArray(item?.receiverThreadIds), ...readObjectStringKeys(item?.agentsStates)]) : new Set(readStringArray(item?.receiverThreadIds));
 				for (const childThreadId of childThreadIds) this.registerChildThread(parentThreadId, childThreadId);
 			}
 			return state;
@@ -6257,6 +4128,8 @@ var CodexNativeSubagentMonitor = class {
 		if (childState && turn && readString$2(turn, "status") === "interrupted") {
 			const turnId = readString$2(turn, "id");
 			if (turnId) childState.assistantMessagesByTurn.delete(turnId);
+			childState.settledWithoutCompletion = true;
+			await this.flushDeferredParentSettlements(childState.parentThreadId);
 			return;
 		}
 		if (childState && turn) this.captureChildTurnAssistantMessages(childState, turn);
@@ -6310,7 +4183,10 @@ var CodexNativeSubagentMonitor = class {
 				childState.noFinalCompletionFallbackTimer = void 0;
 			}
 		}
-		if (!state.requesterSessionKey) return;
+		if (!state.requesterSessionKey) {
+			await this.flushDeferredParentSettlements(state.parentThreadId);
+			return;
+		}
 		const completionKey = buildCompletionDedupeKey(state.parentThreadId, completion);
 		if (state.deliveredCompletionKeys.has(completionKey)) return;
 		const deliveryState = childState ?? this.ensureChildState(state.parentThreadId, completion.childThreadId);
@@ -6363,6 +4239,7 @@ var CodexNativeSubagentMonitor = class {
 			});
 		} finally {
 			childState.deliveringCompletionKey = void 0;
+			await this.flushDeferredParentSettlements(state.parentThreadId);
 		}
 	}
 	markCompletionDeliveryPending(completion, error) {
@@ -6395,6 +4272,28 @@ var CodexNativeSubagentMonitor = class {
 		}, delayMs);
 		unrefTimer(childState.completionDeliveryTimer);
 	}
+	hasUnsettledChildren(parentThreadId) {
+		for (const childState of this.childStates.values()) if (childState.parentThreadId === parentThreadId && (childState.pendingCompletion !== void 0 || childState.deliveringCompletionKey !== void 0 || !childState.transcriptTerminal && !childState.settledWithoutCompletion)) return true;
+		return false;
+	}
+	async flushDeferredParentSettlements(parentThreadId) {
+		if (this.hasUnsettledChildren(parentThreadId)) return;
+		const state = this.parentStates.get(parentThreadId);
+		const callback = state?.deferredSettlement;
+		if (!state || !callback) return;
+		state.deferredSettlement = void 0;
+		await this.runDeferredParentSettlement(parentThreadId, callback);
+	}
+	async runDeferredParentSettlement(parentThreadId, callback) {
+		try {
+			await callback();
+		} catch (error) {
+			embeddedAgentLog.warn("Failed to finish deferred Codex app-server cleanup", {
+				parentThreadId,
+				error: formatErrorMessage(error)
+			});
+		}
+	}
 	finalizeCompletionTask(completion, eventAt) {
 		const taskRuntime = this.getTaskRuntimeForChild(completion.childThreadId);
 		if (!taskRuntime) return;
@@ -6435,7 +4334,8 @@ var CodexNativeSubagentMonitor = class {
 				assistantMessagesByTurn: /* @__PURE__ */ new Map(),
 				transcriptPollAttempt: 0,
 				transcriptTerminal: false,
-				completionDeliveryAttempt: 0
+				completionDeliveryAttempt: 0,
+				settledWithoutCompletion: false
 			};
 			this.childStates.set(normalizedChildThreadId, childState);
 		}
@@ -6874,7 +4774,8 @@ function parseCodexAppServerByteLimit(value) {
 	if (!match) return;
 	const amount = Number(match[1]);
 	if (!Number.isFinite(amount) || amount <= 0) return;
-	const multiplier = CODEX_APP_SERVER_BYTE_UNITS[(match[2] ?? "b").toLowerCase()];
+	const unit = (match[2] ?? "b").toLowerCase();
+	const multiplier = CODEX_APP_SERVER_BYTE_UNITS[unit];
 	if (multiplier === void 0) return;
 	return Math.max(1, Math.round(amount * multiplier));
 }
@@ -7058,7 +4959,10 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 						bytes: file.bytes
 					}))
 				});
-				await clearCodexAppServerBinding(params.sessionFile);
+				await params.bindingStore.mutate(params.identity, {
+					kind: "clear",
+					threadId: binding.threadId
+				});
 				return;
 			}
 		}
@@ -7087,7 +4991,10 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 			reserveTokens,
 			projectedTurnTokens: params.projectedTurnTokens
 		});
-		await clearCodexAppServerBinding(params.sessionFile);
+		await params.bindingStore.mutate(params.identity, {
+			kind: "clear",
+			threadId: binding.threadId
+		});
 		return;
 	}
 	if (compaction?.truncateAfterCompaction !== true) return binding;
@@ -7371,7 +5278,7 @@ async function markCodexAuthProfileBlockedFromRateLimits(params) {
 async function formatCodexTurnStartUsageLimitError(params) {
 	return refreshCodexUsageLimitError({
 		client: params.client,
-		source: readCodexTurnStartUsageLimitErrorSource(params.error, params.pendingNotifications),
+		source: readCodexTurnStartUsageLimitErrorSource(params.client, params.error, params.errorNotification, params.rateLimitsRevisionBeforeTurnStart),
 		timeoutMs: params.timeoutMs,
 		signal: params.signal
 	});
@@ -7384,7 +5291,7 @@ async function refreshCodexUsageLimitPromptError(params) {
 		source: {
 			message: params.message,
 			codexErrorInfo: "usageLimitExceeded",
-			rateLimits: readRecentCodexRateLimits()
+			rateLimits: readRecentCodexRateLimits(params.client)
 		},
 		timeoutMs: params.timeoutMs,
 		signal: params.signal
@@ -7422,7 +5329,7 @@ async function readCodexRateLimitsFromAppServerForUsageLimitError(params) {
 			timeoutMs: resolveCodexUsageLimitRateLimitRefreshTimeoutMs(params.timeoutMs),
 			signal: params.signal
 		});
-		rememberCodexRateLimits(rateLimits);
+		rememberCodexRateLimitsRead(params.client, rateLimits);
 		return rateLimits;
 	} catch (error) {
 		embeddedAgentLog.debug("codex app-server rate-limit refresh failed after usage-limit error", { error: formatErrorMessage(error) });
@@ -7433,38 +5340,25 @@ 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(error, pendingNotifications) {
-	const notificationError = readLatestCodexErrorNotification(pendingNotifications);
-	const notificationRateLimits = readLatestRateLimitNotificationPayload(pendingNotifications);
+function readCodexTurnStartUsageLimitErrorSource(client, error, errorNotification, rateLimitsRevisionBeforeTurnStart) {
+	const notificationError = readCodexErrorNotification(errorNotification);
 	const errorPayload = readCodexErrorPayload(error);
-	const rateLimits = notificationRateLimits ?? errorPayload.rateLimits ?? readRecentCodexRateLimits();
+	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: notificationRateLimits !== void 0 || errorPayload.rateLimits !== void 0
+		rateLimitsTrustedForProfile: errorPayload.rateLimits !== void 0 || cacheUpdatedDuringTurnStart
 	};
 }
-function readLatestRateLimitNotificationPayload(notifications) {
-	for (let index = notifications.length - 1; index >= 0; index -= 1) {
-		const notification = notifications[index];
-		if (notification?.method === "account/rateLimits/updated") {
-			rememberCodexRateLimits(notification.params);
-			return notification.params;
-		}
-	}
-}
-function readLatestCodexErrorNotification(notifications) {
-	for (let index = notifications.length - 1; index >= 0; index -= 1) {
-		const notification = notifications[index];
-		if (notification?.method !== "error" || !isJsonObject(notification.params)) continue;
-		const error = notification.params.error;
-		if (!isJsonObject(error)) continue;
-		return {
-			message: readString$1(error, "message"),
-			codexErrorInfo: error.codexErrorInfo
-		};
-	}
+function readCodexErrorNotification(notification) {
+	if (notification?.method !== "error" || !isJsonObject(notification.params)) return;
+	const error = notification.params.error;
+	return isJsonObject(error) ? {
+		message: readString$1(error, "message"),
+		codexErrorInfo: error.codexErrorInfo
+	} : void 0;
 }
 function readCodexErrorPayload(error) {
 	const message = error instanceof Error ? error.message : void 0;
@@ -7473,7 +5367,6 @@ function readCodexErrorPayload(error) {
 	if (!isJsonObject(data)) return { message };
 	const nestedError = isJsonObject(data.error) ? data.error : data;
 	const rateLimits = nestedError.rateLimits ?? data.rateLimits;
-	if (rateLimits !== void 0) rememberCodexRateLimits(rateLimits);
 	return {
 		message: readString$1(nestedError, "message") ?? message,
 		codexErrorInfo: nestedError.codexErrorInfo,
@@ -7613,7 +5506,10 @@ function readRequestId(record) {
 //#region extensions/codex/src/app-server/run-attempt.ts
 const CODEX_NATIVE_HOOK_RELAY_RENEW_INTERVAL_MS = 6e4;
 const CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN = 4;
-const CODEX_APP_SERVER_ACTIVE_NATIVE_TURN_WAIT_TIMEOUT_MS = 3e4;
+function shouldKeepCodexSharedAbortOpen(params) {
+	if (params.explicitCancellationObserved || params.result.aborted || params.result.externalAbort) return false;
+	return params.trigger === "memory" || !params.attemptSucceeded;
+}
 const ensuredCodexWorkspaceDirs = /* @__PURE__ */ new Set();
 function withCodexAppServerFastModeServiceTier(appServer, params) {
 	const fastMode = typeof params.fastMode === "function" ? params.fastMode() : params.fastMode;
@@ -7697,7 +5593,7 @@ function toTranscriptToolResultContentItem(item) {
 }
 function formatUnsupportedCodexDynamicToolOutput(type) {
 	const rawType = typeof type === "string" ? type.replace(/\s+/g, " ").trim() : "";
-	return `[Unsupported Codex dynamic tool output: ${rawType ? rawType.slice(0, 80) : "unknown"}${rawType.length > 80 ? "..." : ""}]`;
+	return `[Unsupported Codex dynamic tool output: ${rawType ? truncateUtf16Safe(rawType, 80) : "unknown"}${rawType.length > 80 ? "..." : ""}]`;
 }
 function shouldAwaitCodexAgentEndHook(params) {
 	return !params.messageChannel && !params.messageProvider;
@@ -7716,7 +5612,7 @@ async function runCodexAgentEndHook(params, hookParams) {
 	}
 	runAgentEndSideEffects(sideEffectParams);
 }
-async function runCodexAppServerAttempt(params, options = {}) {
+async function runCodexAppServerAttempt(params, options) {
 	const attemptStartedAt = Date.now();
 	const profilerEnabled = isCodexAppServerProfilerEnabled(params.config);
 	const codexModelCallTrace = freezeDiagnosticTraceContext(createDiagnosticTraceContextFromActiveScope());
@@ -7728,7 +5624,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		resetAnnounced: false
 	};
 	const preDynamicStartupStages = createCodexDynamicToolBuildStageTracker({ enabled: profilerEnabled });
-	const attemptClientFactory = options.clientFactory ?? defaultLeasedCodexAppServerClientFactory;
+	const attemptClientFactory = options.clientFactory ?? getLeasedSharedCodexAppServerClient;
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
 	const { sessionAgentId } = resolveSessionAgentIds$1({
@@ -7756,10 +5652,17 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		agentId: sessionAgentId
 	});
 	const agentDir = params.agentDir ?? resolveAgentDir(params.config ?? {}, sessionAgentId);
+	const bindingIdentity = sessionBindingIdentity({
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		agentId: params.agentId,
+		config: params.config
+	});
+	const bindingStore = options.bindingStore;
 	preDynamicStartupStages.mark("session-agent");
 	const activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
 	const isInactiveThreadBootstrapBinding = (binding) => !activeContextEngine && binding?.contextEngine?.projection?.mode === "thread_bootstrap";
-	let startupBinding = await readCodexAppServerBinding(params.sessionFile);
+	let startupBinding = await bindingStore.read(bindingIdentity);
 	preDynamicStartupStages.mark("read-binding");
 	const startupBindingAuthProfileId = startupBinding?.authProfileId;
 	const initialStartupBindingHadInactiveThreadBootstrap = isInactiveThreadBootstrapBinding(startupBinding);
@@ -7831,13 +5734,35 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	});
 	preDynamicStartupStages.mark("native-hook-relay");
 	const runAbortController = new AbortController();
+	let explicitCancellationObserved = false;
+	let explicitCancellationReason;
+	let terminalOutcomeFrozen = false;
+	let sharedAbortAllowedAfterTerminalOutcome = false;
+	let attemptAbortNotified = false;
+	const notifyAttemptAbort = () => {
+		if (attemptAbortNotified) return;
+		attemptAbortNotified = true;
+		params.onAttemptAbort?.();
+	};
+	const abortExplicitly = (reason) => {
+		if (terminalOutcomeFrozen) {
+			if (sharedAbortAllowedAfterTerminalOutcome) notifyAttemptAbort();
+			return;
+		}
+		notifyAttemptAbort();
+		explicitCancellationObserved = true;
+		explicitCancellationReason ??= reason;
+		runAbortController.abort(reason);
+	};
 	const abortFromUpstream = () => {
-		runAbortController.abort(params.abortSignal?.reason ?? "upstream_abort");
+		abortExplicitly(params.abortSignal?.reason ?? "upstream_abort");
 	};
 	if (params.abortSignal?.aborted) abortFromUpstream();
 	else params.abortSignal?.addEventListener("abort", abortFromUpstream, { once: true });
 	startupBinding = await rotateOversizedCodexAppServerStartupBinding({
 		binding: startupBinding,
+		bindingStore,
+		identity: bindingIdentity,
 		sessionFile: params.sessionFile,
 		agentDir,
 		codexHome: appServer.start.env?.CODEX_HOME,
@@ -8043,6 +5968,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		hookContext: {
 			agentId: sessionAgentId,
 			config: params.config,
+			workspaceDir: effectiveWorkspace,
 			sessionId: params.sessionId,
 			sessionKey: sandboxSessionKey,
 			runId: params.runId,
@@ -8291,8 +6217,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		codexTurnPromptText = decorateCodexTurnPromptText(nextPromptBuild);
 	};
 	const selectNewerVisibleHistoryAfterBinding = (binding) => {
-		const bindingUpdatedAt = Date.parse(binding.updatedAt);
-		if (!Number.isFinite(bindingUpdatedAt)) return [];
+		const historyCoveredThrough = Date.parse(binding.historyCoveredThrough ?? "");
+		const cutoff = Number.isFinite(historyCoveredThrough) ? historyCoveredThrough : 0;
 		return historyMessages.filter((message) => {
 			if (message.role !== "user" && message.role !== "assistant") return false;
 			const record = message;
@@ -8300,9 +6226,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			if (typeof idempotencyKey === "string" && idempotencyKey.startsWith("codex-app-server:")) return false;
 			const meta = record["__openclaw"];
 			const mirrorIdentity = meta && typeof meta === "object" && !Array.isArray(meta) ? meta.mirrorIdentity : void 0;
+			if ((meta && typeof meta === "object" && !Array.isArray(meta) ? meta.mirrorOrigin : void 0) === "codex-app-server") return false;
 			if (typeof mirrorIdentity === "string" && mirrorIdentity.startsWith("codex-app-server:")) return false;
 			const timestamp = typeof message.timestamp === "number" ? message.timestamp : typeof message.timestamp === "string" ? Date.parse(message.timestamp) : NaN;
-			return Number.isFinite(timestamp) && timestamp > bindingUpdatedAt;
+			return Number.isFinite(timestamp) && timestamp > cutoff;
 		});
 	};
 	const applyResumeStaleBindingContinuityProjection = (binding) => {
@@ -8354,6 +6281,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		});
 		startupBinding = await rotateOversizedCodexAppServerStartupBinding({
 			binding: startupBinding,
+			bindingStore,
+			identity: bindingIdentity,
 			sessionFile: params.sessionFile,
 			agentDir,
 			codexHome: appServer.start.env?.CODEX_HOME,
@@ -8401,11 +6330,41 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	});
 	let client;
 	let thread;
+	let turnRouter;
+	let turnRoute;
+	let routeActivated = false;
+	let detachRouteAbort = () => void 0;
 	let trajectoryEndRecorded = false;
 	const markTrajectoryEndRecorded = () => {
 		trajectoryEndRecorded = true;
 	};
 	let nativeHookRelay;
+	const nativeSubagentMonitorRef = {};
+	const pendingNativePreToolUseFailures = [];
+	const projectorRef = {};
+	let nativePreToolUseFailureFallbackActive = false;
+	let nativePreToolUseFailureFallbackTerminalReason;
+	const emitNativePreToolUseFailure = (failure) => {
+		emitCodexNativePreToolUseFailureDiagnostic({
+			agentId: sessionAgentId,
+			sessionId: params.sessionId,
+			sessionKey: sandboxSessionKey,
+			runId: params.runId,
+			signal: runAbortController.signal,
+			failure,
+			...nativePreToolUseFailureFallbackActive ? { terminalReason: nativePreToolUseFailureFallbackTerminalReason ?? failure.disposition } : {}
+		});
+	};
+	const flushPendingNativePreToolUseFailures = () => {
+		for (const failure of pendingNativePreToolUseFailures.splice(0)) emitNativePreToolUseFailure(failure);
+	};
+	const activateNativePreToolUseFailureFallback = () => {
+		if (!nativePreToolUseFailureFallbackActive) {
+			nativePreToolUseFailureFallbackTerminalReason = runAbortController.signal.aborted ? resolveCodexToolAbortTerminalReason(runAbortController.signal) : void 0;
+			nativePreToolUseFailureFallbackActive = true;
+		}
+		flushPendingNativePreToolUseFailures();
+	};
 	let releaseSharedClientLease;
 	let sharedCodexClientRetiredForOneShotCleanup = false;
 	const releaseSharedClientLeaseOnce = () => {
@@ -8443,6 +6402,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			await releaseCodexSandboxExecServerEnvironment(sandbox);
 		}
 	};
+	const releaseCurrentRoute = () => {
+		detachRouteAbort();
+		detachRouteAbort = () => void 0;
+		turnRoute?.release();
+		turnRoute = void 0;
+		routeActivated = false;
+	};
 	let codexEnvironmentSelection;
 	let codexExecutionCwd = effectiveCwd;
 	let codexSandboxPolicy;
@@ -8467,7 +6433,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			attemptTimeoutMs: params.timeoutMs,
 			startupTimeoutMs,
 			turnStartTimeoutMs: params.timeoutMs,
-			signal: runAbortController.signal
+			signal: runAbortController.signal,
+			onPreToolUseFailure: (failure) => {
+				const projector = projectorRef.current;
+				if (projector) projector.recordNativeToolPreToolUseFailure(failure);
+				else if (nativePreToolUseFailureFallbackActive) emitNativePreToolUseFailure(failure);
+				else pendingNativePreToolUseFailures.push(failure);
+			}
 		});
 		return {
 			configPatch: nativeHookRelay ? buildCodexNativeHookRelayConfig({
@@ -8487,6 +6459,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		pluginAppServer = attemptAppServer;
 		const startupResult = await startCodexAttemptThread({
 			attemptClientFactory,
+			bindingStore,
 			appServer: attemptAppServer,
 			pluginConfig,
 			computerUseConfig,
@@ -8519,6 +6492,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		});
 		client = startupResult.client;
 		thread = startupResult.thread;
+		turnRouter = startupResult.turnRouter;
+		turnRoute = startupResult.turnRoute;
 		pluginAppServer = startupResult.pluginAppServer;
 		if (thread.lifecycle.action === "started") {
 			const activeThreadReviewerPolicyContext = resolveCodexModelBackedReviewerPolicyContext({
@@ -8574,6 +6549,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			}
 		});
 	} catch (error) {
+		activateNativePreToolUseFailureFallback();
+		releaseCurrentRoute();
 		nativeHookRelay?.unregister();
 		await releaseSandboxExecEnvironment();
 		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
@@ -8594,7 +6571,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		prompt: codexTurnPromptText,
 		tools: toolBridge.availableSpecs
 	});
-	const pendingNotifications = [];
+	let latestStartupErrorNotification;
+	let rateLimitsRevisionBeforeLastTurnStart;
 	let completed = false;
 	let terminalTurnNotificationQueued = false;
 	let timedOut = false;
@@ -8614,7 +6592,6 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	const completion = new Promise((resolve) => {
 		resolveCompletion = resolve;
 	});
-	let notificationQueue = Promise.resolve();
 	const turnCompletionIdleTimeoutMs = resolveCodexTurnCompletionIdleTimeoutMs(options.turnCompletionIdleTimeoutMs ?? appServer.turnCompletionIdleTimeoutMs);
 	const turnAssistantCompletionIdleTimeoutMs = resolveCodexTurnAssistantCompletionIdleTimeoutMs(options.turnAssistantCompletionIdleTimeoutMs);
 	const postToolRawAssistantCompletionIdleTimeoutMs = resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(options.postToolRawAssistantCompletionIdleTimeoutMs ?? appServer.postToolRawAssistantCompletionIdleTimeoutMs, turnAssistantCompletionIdleTimeoutMs);
@@ -8625,12 +6602,15 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	const pendingOpenClawDynamicToolCompletionIds = /* @__PURE__ */ new Set();
 	const activeTurnItemIds = /* @__PURE__ */ new Set();
 	const activeCompletionBlockerItemIds = /* @__PURE__ */ new Set();
+	const activeFinalizationHookRunIds = /* @__PURE__ */ new Set();
+	const finalizationHookBatchStatuses = /* @__PURE__ */ new Map();
+	let unsettledFinalizationHookCount = 0;
+	let rejectedFinalizationHookAssistant;
 	let turnCrossedToolHandoff = false;
 	let pendingTerminalDynamicToolRelease;
 	let terminalDynamicToolReleaseCheckScheduled = false;
 	let currentTurnHadNonTerminalDynamicToolResult = false;
 	const turnIdRef = {};
-	const projectorRef = {};
 	const userInputBridgeRef = {};
 	const steeringQueueRef = {};
 	const renewNativeHookRelayForTurnProgress = () => {
@@ -8656,6 +6636,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		getActiveAppServerTurnRequests: () => activeAppServerTurnRequests,
 		getActiveTurnItemCount: () => activeTurnItemIds.size,
 		getActiveCompletionBlockerItemCount: () => activeCompletionBlockerItemIds.size,
+		getActiveFinalizationHookCount: () => unsettledFinalizationHookCount,
+		canReleaseAssistantCompletionIdle: () => projectorRef.current?.hasLatestTerminalAssistantCandidateText() === true,
 		turnCompletionIdleTimeoutMs,
 		turnAssistantCompletionIdleTimeoutMs,
 		turnAttemptIdleTimeoutMs,
@@ -8780,6 +6762,21 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		});
 		lifecycleTerminalEmitted = true;
 	};
+	const buildLifecycleTerminalMeta = (input) => {
+		const abortFields = input.aborted ? resolveAgentRunAbortLifecycleFields(runAbortController.signal) : void 0;
+		if (input.timedOut || abortFields?.stopReason === "timeout") return {
+			aborted: true,
+			status: "timed_out",
+			stopReason: "timeout",
+			timeoutPhase: "provider",
+			providerStarted: true
+		};
+		return input.aborted ? {
+			aborted: true,
+			status: "cancelled",
+			stopReason: "stop"
+		} : void 0;
+	};
 	const executionPhaseKeys = /* @__PURE__ */ new Set();
 	const emitExecutionPhaseOnce = (key, info) => {
 		if (executionPhaseKeys.has(key)) return;
@@ -8857,7 +6854,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		const steeringQueue = steeringQueueRef.current;
 		userInputBridge?.handleNotification(notification);
 		if (!projector || !turnId) {
-			pendingNotifications.push(notification);
+			if (notification.method === "error") latestStartupErrorNotification = notification;
 			return;
 		}
 		const notificationState = applyCodexTurnNotificationState({
@@ -8876,10 +6873,23 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			onReportExecutionNotification: reportExecutionNotification
 		});
 		turnCrossedToolHandoff = notificationState.turnCrossedToolHandoff;
+		const finalizationHookNotification = readCodexFinalizationHookNotification(notification, thread.threadId, turnId);
+		if (finalizationHookNotification?.phase === "started") {
+			if (activeFinalizationHookRunIds.size === 0) finalizationHookBatchStatuses.clear();
+			activeFinalizationHookRunIds.add(finalizationHookNotification.runId);
+			turnWatches.disarmAssistantCompletionIdleWatch();
+		}
 		if (notificationState.isTurnTerminal) terminalTurnNotificationQueued = true;
 		try {
 			await waitForCodexNotificationDispatchTurn();
 			await projector.handleNotification(notification);
+			const projectedAssistantCompletionCanRelease = isAssistantCompletionReleaseNotification(notification, turnCrossedToolHandoff) || notificationState.isCurrentTurnNotification && turnCrossedToolHandoff && notification.method === "rawResponseItem/completed" && projector.canReleaseLatestTerminalAssistantAfterToolHandoff();
+			if (notificationState.isCurrentTurnNotification && projectedAssistantCompletionCanRelease) {
+				const completedAssistantItemId = projector.getLatestTerminalAssistantCandidate()?.itemId;
+				if (rejectedFinalizationHookAssistant !== void 0 && completedAssistantItemId !== void 0 && completedAssistantItemId !== rejectedFinalizationHookAssistant.itemId) rejectedFinalizationHookAssistant = void 0;
+				else if (rejectedFinalizationHookAssistant !== void 0) turnWatches.disarmAssistantCompletionIdleWatch();
+				else if (activeFinalizationHookRunIds.size === 0 && !terminalTurnNotificationQueued && activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && projector.hasLatestTerminalAssistantCandidateText()) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
+			}
 			if (notificationState.isCurrentTurnNotification && activeTurnItemIds.size === 0 && isRawFunctionToolOutputCompletionNotification(notification)) await maybeAnnounceFastModeAutoOff();
 		} catch (error) {
 			embeddedAgentLog.debug("codex app-server projector notification threw", {
@@ -8887,6 +6897,24 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				error
 			});
 		} finally {
+			if (finalizationHookNotification?.phase === "completed") {
+				unsettledFinalizationHookCount = Math.max(0, unsettledFinalizationHookCount - 1);
+				activeFinalizationHookRunIds.delete(finalizationHookNotification.runId);
+				finalizationHookBatchStatuses.set(finalizationHookNotification.runId, finalizationHookNotification.status);
+				if (activeFinalizationHookRunIds.size === 0) {
+					const statuses = new Set(finalizationHookBatchStatuses.values());
+					if (statuses.has("blocked") && !statuses.has("stopped")) {
+						const itemId = projector.getLatestTerminalAssistantCandidate()?.itemId;
+						rejectedFinalizationHookAssistant = itemId ? { itemId } : {};
+						turnWatches.disarmAssistantCompletionIdleWatch();
+					} else rejectedFinalizationHookAssistant = void 0;
+				}
+				if (activeFinalizationHookRunIds.size === 0 && rejectedFinalizationHookAssistant === void 0 && !terminalTurnNotificationQueued && activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && projector.hasLatestTerminalAssistantCandidateText()) turnWatches.armAssistantCompletionIdleWatch({
+					lastNotificationMethod: notification.method,
+					hookRunId: finalizationHookNotification.runId,
+					hookStatus: finalizationHookNotification.status
+				});
+			}
 			if (notificationState.isTurnTerminal) {
 				if (notificationState.isTurnAbortMarker) projector.markAborted();
 				if (!timedOut && !runAbortController.signal.aborted) await steeringQueue?.flushPending();
@@ -8898,72 +6926,43 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			}
 		}
 	};
-	let activeNativeTurnCompletionWaiter;
-	const waitForActiveNativeTurnCompletion = async (turnIds) => {
-		const turnIdSet = turnIds?.length ? new Set(turnIds) : void 0;
-		const matchesCompletion = (notification) => isCodexThreadTurnCompletedNotification(notification, thread.threadId, turnIdSet);
-		if (pendingNotifications.some((notification) => matchesCompletion(notification))) return true;
-		return await new Promise((resolve) => {
-			let settled = false;
-			const timeoutRef = {};
-			const finish = (completedNativeTurn) => {
-				if (settled) return;
-				settled = true;
-				if (timeoutRef.current) clearTimeout(timeoutRef.current);
-				runAbortController.signal.removeEventListener("abort", abortListener);
-				if (activeNativeTurnCompletionWaiter?.resolve === finishComplete) activeNativeTurnCompletionWaiter = void 0;
-				resolve(completedNativeTurn);
-			};
-			const finishComplete = () => finish(true);
-			const abortListener = () => finish(false);
-			timeoutRef.current = setTimeout(() => finish(false), Math.min(appServer.requestTimeoutMs, CODEX_APP_SERVER_ACTIVE_NATIVE_TURN_WAIT_TIMEOUT_MS));
-			activeNativeTurnCompletionWaiter = {
-				matches: matchesCompletion,
-				resolve: finishComplete
-			};
-			runAbortController.signal.addEventListener("abort", abortListener, { once: true });
+	const waitForActiveNativeTurnCompletion = async () => {
+		const route = turnRoute;
+		if (!route) return false;
+		return await route.waitForTurnCompletion({
+			timeoutMs: Math.min(appServer.requestTimeoutMs, CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS),
+			signal: runAbortController.signal
 		});
 	};
-	const enqueueNotification = (notification) => {
+	const noteNotificationReceived = (notification, scope, receivedAtMs) => {
 		const projector = projectorRef.current;
 		const turnId = turnIdRef.current;
-		const userInputBridge = userInputBridgeRef.current;
-		const correlation = describeCodexNotificationCorrelation(notification, {
-			threadId: thread.threadId,
-			...turnId ? { turnId } : {}
-		});
-		embeddedAgentLog.trace("codex app-server raw notification received", correlation);
-		if (notification.method === "turn/completed" && correlation.matchesActiveTurn === false) if (correlation.matchesActiveThread) embeddedAgentLog.warn("codex app-server turn/completed did not match active turn", correlation);
-		else embeddedAgentLog.debug("codex app-server turn/completed ignored for other subscribed thread", correlation);
-		if (notification.method === "turn/completed" && correlation.matchesActiveThread) {
-			if (activeNativeTurnCompletionWaiter?.matches(notification)) activeNativeTurnCompletionWaiter.resolve();
-		}
-		if (isCodexNotificationOutsideActiveRun(correlation)) return Promise.resolve();
-		if (!projector || !turnId) {
-			userInputBridge?.handleNotification(notification);
-			pendingNotifications.push(notification);
-			return Promise.resolve();
-		}
+		if (!projector || !turnId) return;
 		if (isTerminalTurnNotificationForTurn(notification, turnId)) terminalTurnNotificationQueued = true;
-		const isNativeResponseStreamDelta = isNativeResponseStreamDeltaNotification(notification);
-		const nativeResponseStreamDeltaMatchesActiveTurn = isNativeResponseStreamDelta && (correlation.matchesActiveTurn === true || isUnscopedCodexNotification(correlation) && canAttributeUnscopedNativeResponseDeltaToThisTurn(client));
-		const notificationMatchesActiveTurn = correlation.matchesActiveTurn === true || !isNativeResponseStreamDelta && correlation.matchesActiveTurn !== false || nativeResponseStreamDeltaMatchesActiveTurn;
-		if (correlation.matchesActiveTurn === true) {
+		if (scope.turnId === turnId) {
 			const modelToolCallId = readRawResponseToolCallId(notification);
 			if (modelToolCallId) allocateCodexToolOutcomeOrdinal?.(modelToolCallId);
 			const nativeItem = readCodexNotificationItem(notification.params);
 			if (nativeItem?.type === "webSearch") projector.recordNativeToolOutcome(nativeItem);
 		}
-		if (notificationMatchesActiveTurn) turnWatches.noteNotificationReceived(notification.method, isNativeResponseStreamDelta ? {
-			attemptProgress: true,
-			...turnCrossedToolHandoff ? { attemptTimeoutMs: postToolRawAssistantCompletionIdleTimeoutMs } : {},
-			details: { lastNotificationMethod: notification.method }
-		} : void 0);
-		notificationQueue = notificationQueue.then(() => handleNotification(notification), () => handleNotification(notification));
-		return notificationQueue;
+		if (readCodexFinalizationHookNotification(notification, thread.threadId, turnId)?.phase === "started") {
+			unsettledFinalizationHookCount += 1;
+			turnWatches.disarmAssistantCompletionIdleWatch();
+		}
+		turnWatches.noteNotificationReceived(notification.method, { receivedAtMs });
+	};
+	const enqueueNotification = async (notification, scope) => {
+		embeddedAgentLog.trace("codex app-server raw notification received", {
+			method: notification.method,
+			...scope
+		});
+		await handleNotification(notification);
+	};
+	const drainNotificationQueue = async () => {
+		await turnRoute?.drain();
 	};
 	const nativeSubagentCodexHome = appServer.start.transport === "stdio" ? appServer.start.env?.CODEX_HOME ?? resolveCodexAppServerHomeDir(agentDir) : void 0;
-	registerCodexNativeSubagentMonitor({
+	nativeSubagentMonitorRef.current = registerCodexNativeSubagentMonitor({
 		client,
 		parentThreadId: thread.threadId,
 		requesterSessionKey: params.sessionKey,
@@ -8971,8 +6970,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		agentId: params.agentId,
 		codexHome: nativeSubagentCodexHome
 	});
-	const notificationCleanup = client.addNotificationHandler(enqueueNotification);
-	const requestCleanup = client.addRequestHandler(async (request) => {
+	const handleServerRequest = async (request, scope) => {
 		const turnId = turnIdRef.current;
 		const userInputBridge = userInputBridgeRef.current;
 		const projector = projectorRef.current;
@@ -8986,14 +6984,9 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			turnWatches.touchActivity(`request:${request.method}:start`, { attemptProgress: true });
 		};
 		try {
-			if (request.method === "account/chatgptAuthTokens/refresh") return refreshCodexAppServerAuthTokens({
-				agentDir,
-				authProfileId: startupAuthProfileId,
-				config: params.config
-			});
 			if (!turnId) return;
 			if (request.method === "mcpServer/elicitation/request") {
-				if (isCurrentThreadOptionalTurnRequestParams(request.params, thread.threadId, turnId)) {
+				if (!scope.turnId || scope.turnId === turnId) {
 					armCompletionWatchOnResponse = true;
 					markCurrentTurnRequestProgress();
 				}
@@ -9008,7 +7001,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				});
 			}
 			if (request.method === "item/tool/requestUserInput") {
-				if (isCurrentThreadTurnRequestParams(request.params, thread.threadId, turnId)) {
+				if (scope.turnId === turnId) {
 					armCompletionWatchOnResponse = true;
 					markCurrentTurnRequestProgress();
 				}
@@ -9019,7 +7012,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			}
 			if (request.method !== "item/tool/call") {
 				if (isCodexAppServerApprovalRequest(request.method)) {
-					if (isCurrentApprovalTurnRequestParams(request.params, thread.threadId, turnId)) {
+					if (scope.turnId === turnId) {
 						armCompletionWatchOnResponse = true;
 						markCurrentTurnRequestProgress();
 					}
@@ -9034,7 +7027,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 						execReviewerAgentId: sessionAgentId,
 						internalExecAutoReview: appServer.approvalsReviewer === "user",
 						autoApprove: shouldAutoApproveCodexAppServerApprovals(appServer),
-						signal: runAbortController.signal
+						signal: runAbortController.signal,
+						onNativeToolFailureDisposition: (itemId, disposition) => projector?.recordNativeToolApprovalFailure(itemId, disposition)
 					});
 				}
 				return;
@@ -9065,6 +7059,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			});
 			emitDynamicToolStartedDiagnostic({
 				call,
+				agentId: sessionAgentId,
 				runId: params.runId,
 				sessionId: params.sessionId,
 				sessionKey: params.sessionKey
@@ -9172,6 +7167,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				})) emitDynamicToolTerminalDiagnostic({
 					response,
 					call,
+					agentId: sessionAgentId,
 					runId: params.runId,
 					sessionId: params.sessionId,
 					sessionKey: params.sessionKey,
@@ -9198,6 +7194,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 					sessionKey: params.sessionKey
 				})) emitDynamicToolErrorDiagnostic({
 					call,
+					agentId: sessionAgentId,
 					runId: params.runId,
 					sessionId: params.sessionId,
 					sessionKey: params.sessionKey,
@@ -9221,7 +7218,63 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				scheduleTerminalDynamicToolReleaseCheck();
 			} else turnWatches.scheduleProgressWatches();
 		}
-	});
+	};
+	const attachRouteAbort = (route) => {
+		const onAbort = () => {
+			if (completed || terminalTurnNotificationQueued || runAbortController.signal.aborted) return;
+			const reasonText = formatErrorMessage(route.signal.reason);
+			const closedClient = reasonText.includes("turn router closed");
+			clientClosedPromptError = closedClient ? "codex app-server client closed before turn completed" : `codex app-server turn route closed before turn completed: ${reasonText}`;
+			clientClosedAbort = closedClient;
+			const activeTurnId = turnIdRef.current;
+			if (activeTurnId) trajectoryRecorder?.recordEvent("turn.client_closed", {
+				threadId: thread.threadId,
+				turnId: activeTurnId
+			});
+			embeddedAgentLog.warn(clientClosedPromptError, {
+				threadId: thread.threadId,
+				turnId: activeTurnId
+			});
+			runAbortController.abort(closedClient ? "client_closed" : "turn_route_closed");
+			completed = true;
+			turnWatches.clearAllTimers();
+			resolveCompletion?.();
+		};
+		route.signal.addEventListener("abort", onAbort, { once: true });
+		if (route.signal.aborted) onAbort();
+		return () => route.signal.removeEventListener("abort", onAbort);
+	};
+	const ensureCurrentThreadRoute = async () => {
+		if (turnRoute?.threadId !== thread.threadId) {
+			releaseCurrentRoute();
+			turnRoute = turnRouter.reserveThread({
+				threadId: thread.threadId,
+				releaseOn: runAbortController.signal
+			});
+		}
+		if (!turnRoute) throw new Error("codex app-server turn route was not reserved");
+		if (!routeActivated) {
+			detachRouteAbort = attachRouteAbort(turnRoute);
+			await turnRoute.activate({
+				onNotificationReceived: noteNotificationReceived,
+				onNotification: enqueueNotification,
+				onRequest: handleServerRequest
+			});
+			routeActivated = true;
+		}
+		return turnRoute;
+	};
+	try {
+		await ensureCurrentThreadRoute();
+	} catch (error) {
+		activateNativePreToolUseFailureFallback();
+		releaseCurrentRoute();
+		nativeHookRelay?.unregister();
+		await releaseSandboxExecEnvironment();
+		releaseSharedClientLeaseOnce();
+		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
+		throw error;
+	}
 	const buildLlmInputEvent = () => ({
 		runId: params.runId,
 		sessionId: params.sessionId,
@@ -9268,6 +7321,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		throw error;
 	};
 	const startCodexTurn = async () => {
+		const activeTurnRoute = await ensureCurrentThreadRoute();
 		const turnAppServer = withCodexAppServerFastModeServiceTier(pluginAppServer, params);
 		pluginAppServer = turnAppServer;
 		const turnStartParams = buildTurnStartParams(params, {
@@ -9285,31 +7339,42 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			heartbeatCollaborationInstructions: workspaceBootstrapContext.heartbeatCollaborationInstructions
 		});
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
-		const startedTurn = assertCodexTurnStartResponse(await client.request("turn/start", turnStartParams, {
-			timeoutMs: params.timeoutMs,
-			signal: runAbortController.signal
-		}));
-		throwIfTurnStartAcceptedAfterAbort();
-		return startedTurn;
+		latestStartupErrorNotification = void 0;
+		rateLimitsRevisionBeforeLastTurnStart = readCodexRateLimitsRevision(client);
+		activeTurnRoute.armTurn();
+		let acceptedTurnId;
+		try {
+			const startedTurn = assertCodexTurnStartResponse(await client.request("turn/start", turnStartParams, {
+				timeoutMs: params.timeoutMs,
+				signal: runAbortController.signal
+			}));
+			acceptedTurnId = startedTurn.turn.id;
+			throwIfTurnStartAcceptedAfterAbort();
+			return startedTurn;
+		} catch (error) {
+			if (acceptedTurnId) {
+				interruptCodexTurnBestEffort(client, {
+					threadId: thread.threadId,
+					turnId: acceptedTurnId,
+					timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS
+				});
+				releaseCurrentRoute();
+			} else await activeTurnRoute.cancelTurn();
+			throw error;
+		}
 	};
-	const activeNativeTurnIds = thread.lifecycle.action === "resumed" ? thread.lifecycle.activeTurnIds ?? [] : [];
-	if (activeNativeTurnIds.length > 0) {
-		embeddedAgentLog.info("codex app-server resumed thread has active native turn; waiting before turn/start", {
-			threadId: thread.threadId,
-			activeTurnIds: activeNativeTurnIds
-		});
+	if (thread.lifecycle.action === "resumed" && (thread.lifecycle.activeTurnIds?.length ?? 0) > 0) {
+		embeddedAgentLog.info("codex app-server resumed thread has active native turn; waiting before turn/start", { threadId: thread.threadId });
 		emitCodexAppServerEvent(params, {
 			stream: "codex_app_server.lifecycle",
 			data: {
 				phase: "turn_start_waiting_for_native_turn",
-				threadId: thread.threadId,
-				activeTurnIds: activeNativeTurnIds
+				threadId: thread.threadId
 			}
 		});
-		if (!await waitForActiveNativeTurnCompletion(activeNativeTurnIds) && !runAbortController.signal.aborted) embeddedAgentLog.warn("codex app-server active native turn did not complete before turn/start wait timed out", {
-			threadId: thread.threadId,
-			activeTurnIds: activeNativeTurnIds
-		});
+		const nativeTurnCompleted = await waitForActiveNativeTurnCompletion();
+		if (nativeTurnCompleted) await turnRoute?.drain();
+		if (!nativeTurnCompleted && !runAbortController.signal.aborted) embeddedAgentLog.warn("codex app-server active native turn did not complete before turn/start wait timed out", { threadId: thread.threadId });
 	}
 	try {
 		codexModelCallDiagnostics.emitStarted();
@@ -9355,25 +7420,25 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				error: formatErrorMessage(turnStartError)
 			});
 			try {
-				const preRetrySessionFile = activeSessionFile;
-				const clearedPreRetryBinding = await clearCodexAppServerBindingForThread(preRetrySessionFile, thread.threadId);
-				const clearedActiveBinding = activeSessionFile !== preRetrySessionFile ? await clearCodexAppServerBindingForThread(activeSessionFile, thread.threadId) : false;
-				if (!clearedPreRetryBinding && !clearedActiveBinding) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
+				if (!await bindingStore.mutate(bindingIdentity, {
+					kind: "clear",
+					threadId: thread.threadId
+				})) embeddedAgentLog.warn("codex app-server preserved newer context-engine binding after resume overflow; skipping fresh retry", {
 					threadId: thread.threadId,
 					error: formatErrorMessage(turnStartError)
 				});
 				else {
 					thread = await restartContextEngineCodexThread();
 					{
-						const retryBinding = await readCodexAppServerBinding(activeSessionFile);
+						const retryBinding = await bindingStore.read(bindingIdentity);
 						if (retryBinding && retryBinding.threadId === thread.threadId && retryBinding.contextEngine?.projection) {
-							const { schemaVersion: _schemaVersion, sessionFile: _boundSessionFile, updatedAt: _updatedAt, ...bindingForWrite } = retryBinding;
-							await writeCodexAppServerBinding(activeSessionFile, {
-								...bindingForWrite,
-								contextEngine: bindingForWrite.contextEngine ? {
-									...bindingForWrite.contextEngine,
+							await bindingStore.mutate(bindingIdentity, {
+								kind: "patch",
+								threadId: retryBinding.threadId,
+								patch: { contextEngine: retryBinding.contextEngine ? {
+									...retryBinding.contextEngine,
 									projection: void 0
-								} : void 0
+								} : void 0 }
 							});
 							embeddedAgentLog.info("codex app-server cleared stale context-engine projection after overflow retry", {
 								threadId: thread.threadId,
@@ -9402,12 +7467,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			const usageLimitError = await formatCodexTurnStartUsageLimitError({
 				client,
 				error: turnStartError,
-				pendingNotifications,
+				errorNotification: latestStartupErrorNotification,
+				rateLimitsRevisionBeforeTurnStart: rateLimitsRevisionBeforeLastTurnStart,
 				timeoutMs: appServer.requestTimeoutMs,
 				signal: runAbortController.signal
 			});
 			const turnStartErrorMessage = usageLimitError?.message ?? formatErrorMessage(turnStartError);
-			if (isInvalidCodexImagePayloadError(turnStartErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(activeSessionFile, {
+			if (isInvalidCodexImagePayloadError(turnStartErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 				phase: "turn_start",
 				threadId: thread.threadId,
 				error: turnStartErrorMessage
@@ -9469,8 +7535,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				threadId: thread.threadId,
 				timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
 			});
-			notificationCleanup();
-			requestCleanup();
+			releaseCurrentRoute();
+			activateNativePreToolUseFailureFallback();
 			nativeHookRelay?.unregister();
 			await releaseSandboxExecEnvironment();
 			await runAgentCleanupStep({
@@ -9501,6 +7567,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		}
 	}
 	if (!turn) {
+		activateNativePreToolUseFailureFallback();
 		await releaseSharedClientLeaseAndRetireOneShotClient();
 		throw new Error("codex app-server turn/start failed without an error");
 	}
@@ -9532,27 +7599,12 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		}
 	}, thread.threadId, activeTurnId, {
 		nativePostToolUseRelayEnabled: nativeHookRelay?.allowedEvents.includes("post_tool_use") === true && nativeHookRelay.shouldRelayEvent("post_tool_use"),
+		readRecentRateLimits: () => readRecentCodexRateLimits(client),
+		runAbortSignal: runAbortController.signal,
 		trajectoryRecorder,
 		onNativeToolResultRecorded: maybeAnnounceFastModeAutoOff
 	});
-	if (isTerminalTurnStatus(turn.turn.status) || pendingNotifications.some((notification) => isTerminalTurnNotificationForTurn(notification, activeTurnId))) terminalTurnNotificationQueued = true;
-	const closeCleanup = client.addCloseHandler?.(() => {
-		if (completed || terminalTurnNotificationQueued || runAbortController.signal.aborted) return;
-		clientClosedPromptError = "codex app-server client closed before turn completed";
-		trajectoryRecorder?.recordEvent("turn.client_closed", {
-			threadId: thread.threadId,
-			turnId: activeTurnId
-		});
-		embeddedAgentLog.warn("codex app-server client closed before turn completed", {
-			threadId: thread.threadId,
-			turnId: activeTurnId
-		});
-		clientClosedAbort = true;
-		runAbortController.abort("client_closed");
-		completed = true;
-		turnWatches.clearAllTimers();
-		resolveCompletion?.();
-	});
+	if (isTerminalTurnStatus(turn.turn.status)) terminalTurnNotificationQueued = true;
 	emitLifecycleStart();
 	const activeProjector = projectorRef.current;
 	if (!activeProjector) throw new Error("codex app-server projector was not initialized");
@@ -9560,7 +7612,17 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	turnWatches.touchActivity("turn:start", { arm: true });
 	turnWatches.armAttemptIdleWatch();
 	turnWatches.touchActivity("turn:start", { attemptProgress: true });
-	for (const notification of pendingNotifications.splice(0)) await enqueueNotification(notification);
+	for (const failure of pendingNativePreToolUseFailures.splice(0)) activeProjector.recordNativeToolPreToolUseFailure(failure);
+	if (turnRoute) try {
+		await turnRoute.bindTurn(activeTurnId);
+	} catch (error) {
+		if (!terminalTurnNotificationQueued) throw error;
+		await turnRoute.drain();
+		if (!completed) {
+			turnWatches.clearAllTimers();
+			throw error;
+		}
+	}
 	if (!completed && isTerminalTurnStatus(turn.turn.status)) await enqueueNotification({
 		method: "turn/completed",
 		params: {
@@ -9568,6 +7630,9 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			turnId: activeTurnId,
 			turn: turn.turn
 		}
+	}, {
+		threadId: thread.threadId,
+		turnId: activeTurnId
 	});
 	const activeSteeringQueue = createCodexSteeringQueue({
 		client,
@@ -9579,15 +7644,23 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	steeringQueueRef.current = activeSteeringQueue;
 	const handle = {
 		kind: "embedded",
+		runId: params.runId,
 		queueMessage: async (text, optionsLocal) => activeSteeringQueue.queue(text, optionsLocal),
 		isStreaming: () => !completed && !runAbortController.signal.aborted,
 		isStopped: () => completed || timedOut || runAbortController.signal.aborted,
+		isAbortable: () => !terminalOutcomeFrozen || sharedAbortAllowedAfterTerminalOutcome,
 		isCompacting: () => projectorRef.current?.isCompacting() ?? false,
 		sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
-		cancel: () => runAbortController.abort("cancelled"),
-		abort: () => runAbortController.abort("aborted")
+		cancel: () => abortExplicitly("cancelled"),
+		abort: () => abortExplicitly("aborted")
 	};
+	params.replyOperation?.attachBackend(handle);
 	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile);
+	const freezeRunTerminalOutcome = () => {
+		if (terminalOutcomeFrozen) return;
+		terminalOutcomeFrozen = true;
+		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
+	};
 	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
 	mirrorPromptAtTurnStartBestEffort({
 		params,
@@ -9601,7 +7674,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	const abortListener = () => {
 		if (timedOut) {
 			(async () => {
-				await clearCodexAppServerBindingForThread(activeSessionFile, thread.threadId);
+				await bindingStore.mutate(bindingIdentity, {
+					kind: "clear",
+					threadId: thread.threadId
+				});
 				await retireCodexAppServerClientAfterTimedOutTurn(client, {
 					threadId: thread.threadId,
 					turnId: activeTurnId,
@@ -9622,14 +7698,34 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	if (runAbortController.signal.aborted) abortListener();
 	try {
 		await completion;
-		await notificationQueue;
+		await drainNotificationQueue();
+		const hasQuiescentCompletedAssistant = activeProjector.hasCompletedTerminalAssistantText() && activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && activeCompletionBlockerItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0 && activeFinalizationHookRunIds.size === 0 && unsettledFinalizationHookCount === 0 && rejectedFinalizationHookAssistant === void 0;
+		const hasRecoverableCompletedAssistant = !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && turnWatches.isAssistantCompletionIdleWatchArmed() && hasQuiescentCompletedAssistant;
+		const recoveredTurnWatchTimeout = turnCompletionIdleTimedOut && !explicitCancellationObserved && !terminalTurnNotificationQueued && hasRecoverableCompletedAssistant && activeProjector.recoverCompletedTerminalAssistantAfterTurnWatchTimeout();
+		if (recoveredTurnWatchTimeout) {
+			embeddedAgentLog.warn("codex app-server recovered completed assistant output after missing turn completion", {
+				threadId: thread.threadId,
+				turnId: activeTurnId,
+				timeoutKind: turnWatchTimeoutKind,
+				idleMs: turnWatchTimeoutIdleMs,
+				timeoutMs: turnWatchTimeoutMs
+			});
+			trajectoryRecorder?.recordEvent("turn.watch_timeout_recovered", {
+				threadId: thread.threadId,
+				turnId: activeTurnId,
+				timeoutKind: turnWatchTimeoutKind,
+				idleMs: turnWatchTimeoutIdleMs,
+				timeoutMs: turnWatchTimeoutMs
+			});
+		}
 		const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected });
-		const finalAborted = result.aborted || runAbortController.signal.aborted && !clientClosedAbort;
-		const canUseCompletedAssistantTextAfterClientClose = activeProjector.hasCompletedTerminalAssistantText() && activeAppServerTurnRequests === 0 && activeTurnItemIds.size === 0 && pendingOpenClawDynamicToolCompletionIds.size === 0;
-		const clientClosedPromptErrorForFinal = clientClosedPromptError && canUseCompletedAssistantTextAfterClientClose ? void 0 : clientClosedPromptError;
-		let finalPromptError = clientClosedPromptErrorForFinal ?? (turnCompletionIdleTimedOut ? turnCompletionIdleTimeoutMessage : timedOut ? "codex app-server attempt timed out" : result.promptError);
+		const effectiveTimedOut = timedOut && !recoveredTurnWatchTimeout;
+		const effectiveTurnCompletionIdleTimedOut = turnCompletionIdleTimedOut && !recoveredTurnWatchTimeout;
+		const isFinalAborted = () => result.aborted || explicitCancellationObserved || runAbortController.signal.aborted && !clientClosedAbort && !recoveredTurnWatchTimeout;
+		const clientClosedPromptErrorForFinal = clientClosedPromptError && hasRecoverableCompletedAssistant ? void 0 : clientClosedPromptError;
+		let finalPromptError = clientClosedPromptErrorForFinal ?? (effectiveTurnCompletionIdleTimedOut ? turnCompletionIdleTimeoutMessage : effectiveTimedOut ? "codex app-server attempt timed out" : result.promptError);
 		const finalPromptErrorMessage = typeof finalPromptError === "string" ? finalPromptError : finalPromptError ? formatErrorMessage(finalPromptError) : void 0;
-		if (isInvalidCodexImagePayloadError(finalPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(activeSessionFile, {
+		if (isInvalidCodexImagePayloadError(finalPromptErrorMessage)) await clearCodexBindingAfterInvalidImagePayload(bindingStore, bindingIdentity, {
 			phase: "turn_completed",
 			threadId: thread.threadId,
 			turnId: activeTurnId,
@@ -9645,9 +7741,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				turnId: activeTurnId,
 				error: finalPromptErrorMessage
 			});
-			const preClearSessionFile = activeSessionFile;
-			await clearCodexAppServerBindingForThread(preClearSessionFile, thread.threadId);
-			if (activeSessionFile !== preClearSessionFile) await clearCodexAppServerBindingForThread(activeSessionFile, thread.threadId);
+			await bindingStore.mutate(bindingIdentity, {
+				kind: "clear",
+				threadId: thread.threadId
+			});
 		}
 		const refreshedUsageLimitPromptError = await refreshCodexUsageLimitPromptError({
 			client,
@@ -9656,12 +7753,12 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			signal: runAbortController.signal
 		});
 		if (refreshedUsageLimitPromptError) finalPromptError = refreshedUsageLimitPromptError;
-		const finalPromptErrorSource = timedOut || clientClosedPromptErrorForFinal ? "prompt" : result.promptErrorSource;
-		const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : turnCompletionIdleTimedOut ? "turn_completion_idle_timeout" : void 0;
+		const finalPromptErrorSource = effectiveTimedOut || clientClosedPromptErrorForFinal ? "prompt" : result.promptErrorSource;
+		const codexAppServerFailureKind = clientClosedPromptErrorForFinal ? "client_closed_before_turn_completed" : effectiveTurnCompletionIdleTimedOut ? "turn_completion_idle_timeout" : void 0;
 		const codexAppServerReplayBlockedReason = codexAppServerFailureKind ? resolveCodexAppServerReplayBlockedReason(result) : void 0;
 		const promptTimeoutOutcome = buildCodexAppServerPromptTimeoutOutcome({
 			result,
-			turnCompletionIdleTimedOut,
+			turnCompletionIdleTimedOut: effectiveTurnCompletionIdleTimedOut,
 			turnWatchTimeoutKind
 		});
 		const codexAppServerFailureDiagnostics = codexAppServerFailureKind === "turn_completion_idle_timeout" && turnWatchTimeoutKind === "completion" ? buildCodexAppServerTimeoutDiagnostics({
@@ -9670,36 +7767,40 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			lastActivityReason: turnWatchTimeoutLastActivityReason,
 			details: turnWatchTimeoutDetails
 		}) : void 0;
+		const codexAppServerFailure = codexAppServerFailureKind ? {
+			kind: codexAppServerFailureKind,
+			...codexAppServerFailureKind === "turn_completion_idle_timeout" && turnWatchTimeoutKind ? { turnWatchTimeoutKind } : {},
+			transport: appServer.start.transport,
+			threadId: thread.threadId,
+			turnId: activeTurnId,
+			replaySafe: codexAppServerReplayBlockedReason === void 0,
+			...codexAppServerReplayBlockedReason ? { replayBlockedReason: codexAppServerReplayBlockedReason } : {},
+			...codexAppServerFailureDiagnostics ? { diagnostics: codexAppServerFailureDiagnostics } : {}
+		} : void 0;
+		const finalAborted = isFinalAborted();
+		const completedTurnStatus = activeProjector.getCompletedTurnStatus();
+		const completedWithoutTerminalNotification = completed && !terminalTurnNotificationQueued && !timedOut && clientClosedPromptErrorForFinal === void 0;
+		const attemptSucceeded = !finalAborted && !effectiveTimedOut && (finalPromptError === null || finalPromptError === void 0) && result.agentHarnessResultClassification === void 0 && (completedTurnStatus === "completed" || recoveredTurnWatchTimeout || completedWithoutTerminalNotification);
+		sharedAbortAllowedAfterTerminalOutcome = shouldKeepCodexSharedAbortOpen({
+			trigger: params.trigger,
+			result,
+			attemptSucceeded,
+			explicitCancellationObserved
+		});
+		freezeRunTerminalOutcome();
 		const modelCallFailureKind = classifyCodexModelCallFailureKind({
 			error: finalPromptError,
-			timedOut,
-			turnCompletionIdleTimedOut,
-			runAborted: runAbortController.signal.aborted,
-			abortReason: runAbortController.signal.reason,
+			timedOut: effectiveTimedOut,
+			turnCompletionIdleTimedOut: effectiveTurnCompletionIdleTimedOut,
+			runAborted: finalAborted,
+			abortReason: explicitCancellationReason ?? runAbortController.signal.reason,
 			clientClosedAbort,
 			formatError: formatErrorMessage
 		}) ?? (finalAborted ? "aborted" : void 0);
 		if (modelCallFailureKind) codexModelCallDiagnostics.emitError(finalPromptError ?? "codex app-server attempt interrupted", { failureKind: modelCallFailureKind });
 		else if (finalPromptError) codexModelCallDiagnostics.emitError(finalPromptError);
 		else codexModelCallDiagnostics.emitCompleted(result);
-		recordCodexTrajectoryCompletion(trajectoryRecorder, {
-			attempt: params,
-			result,
-			threadId: thread.threadId,
-			turnId: activeTurnId,
-			timedOut,
-			yieldDetected
-		});
-		trajectoryRecorder?.recordEvent("session.ended", {
-			status: finalPromptError ? "error" : finalAborted || timedOut ? "interrupted" : "success",
-			threadId: thread.threadId,
-			turnId: activeTurnId,
-			timedOut,
-			yieldDetected,
-			promptError: normalizeCodexTrajectoryError(finalPromptError)
-		});
-		markTrajectoryEndRecorded();
-		await mirrorTranscriptBestEffort({
+		const assistantTranscriptOwned = await mirrorTranscriptBestEffort({
 			params,
 			agentId: sessionAgentId,
 			notifyUserMessagePersisted,
@@ -9709,19 +7810,6 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			threadId: thread.threadId,
 			turnId: activeTurnId
 		});
-		const terminalAssistantText = collectTerminalAssistantText(result);
-		if (terminalAssistantText && (!assistantStreamEventEmitted || assistantStreamNeedsTerminalSnapshot) && !finalAborted && !finalPromptError) emitCodexAppServerEvent(params, {
-			stream: "assistant",
-			data: { text: terminalAssistantText }
-		});
-		if (finalPromptError) emitLifecycleTerminal({
-			phase: "error",
-			error: formatErrorMessage(finalPromptError)
-		});
-		else emitLifecycleTerminal({
-			phase: "end",
-			...finalAborted ? { aborted: true } : {}
-		});
 		if (activeContextEngine) {
 			const activeContextEnginePluginIdLocal = resolveContextEngineOwnerPluginId(activeContextEngine);
 			const isHeartbeatLifecycleRun = params.bootstrapContextRunKind === "heartbeat" || params.bootstrapContextRunKind === "commitment-only";
@@ -9786,31 +7874,70 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			ctx: hookContext,
 			hookRunner
 		});
-		shouldDelayNativeHookRelayUnregister = activeProjector.getCompletedTurnStatus() === "completed" && !timedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
-		if (shouldDelayNativeHookRelayUnregister) await markCodexAppServerBindingCoveredThroughTurn({
-			sessionFile: params.sessionFile,
+		shouldDelayNativeHookRelayUnregister = completedTurnStatus === "completed" && !effectiveTimedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
+		if (shouldDelayNativeHookRelayUnregister) try {
+			await markCodexAppServerBindingCoveredThroughTurn({
+				bindingStore,
+				identity: bindingIdentity,
+				threadId: thread.threadId
+			});
+		} catch (error) {
+			if (!await bindingStore.mutate(bindingIdentity, {
+				kind: "clear",
+				threadId: thread.threadId
+			})) throw error;
+			embeddedAgentLog.warn("codex app-server binding coverage update failed after completed turn; cleared stale binding", {
+				threadId: thread.threadId,
+				turnId: activeTurnId,
+				error
+			});
+		}
+		recordCodexTrajectoryCompletion(trajectoryRecorder, {
+			attempt: params,
+			result,
 			threadId: thread.threadId,
-			authProfileStore: params.authProfileStore,
-			agentDir: params.agentDir,
-			config: params.config
+			turnId: activeTurnId,
+			timedOut: effectiveTimedOut,
+			yieldDetected
+		});
+		trajectoryRecorder?.recordEvent("session.ended", {
+			status: finalPromptError ? "error" : finalAborted || effectiveTimedOut ? "interrupted" : "success",
+			threadId: thread.threadId,
+			turnId: activeTurnId,
+			timedOut: effectiveTimedOut,
+			yieldDetected,
+			promptError: normalizeCodexTrajectoryError(finalPromptError)
+		});
+		markTrajectoryEndRecorded();
+		const terminalAssistantText = collectTerminalAssistantText(result);
+		if (terminalAssistantText && (!assistantStreamEventEmitted || assistantStreamNeedsTerminalSnapshot) && !finalAborted && !finalPromptError) emitCodexAppServerEvent(params, {
+			stream: "assistant",
+			data: { text: terminalAssistantText }
+		});
+		if (finalPromptError) emitLifecycleTerminal({
+			phase: "error",
+			error: formatErrorMessage(finalPromptError),
+			...buildLifecycleTerminalMeta({
+				aborted: finalAborted,
+				timedOut: effectiveTimedOut
+			})
+		});
+		else emitLifecycleTerminal({
+			phase: "end",
+			...buildLifecycleTerminalMeta({
+				aborted: finalAborted,
+				timedOut: effectiveTimedOut
+			})
 		});
 		return {
 			...result,
-			timedOut,
+			timedOut: effectiveTimedOut,
 			aborted: finalAborted,
 			promptError: finalPromptError,
 			promptErrorSource: finalPromptErrorSource,
-			...codexAppServerFailureKind ? { codexAppServerFailure: {
-				kind: codexAppServerFailureKind,
-				...codexAppServerFailureKind === "turn_completion_idle_timeout" && turnWatchTimeoutKind ? { turnWatchTimeoutKind } : {},
-				transport: appServer.start.transport,
-				threadId: thread.threadId,
-				turnId: activeTurnId,
-				replaySafe: codexAppServerReplayBlockedReason === void 0,
-				...codexAppServerReplayBlockedReason ? { replayBlockedReason: codexAppServerReplayBlockedReason } : {},
-				...codexAppServerFailureDiagnostics ? { diagnostics: codexAppServerFailureDiagnostics } : {}
-			} } : {},
+			...codexAppServerFailure ? { codexAppServerFailure } : {},
 			...promptTimeoutOutcome ? { promptTimeoutOutcome } : {},
+			...assistantTranscriptOwned ? { assistantTranscriptOwned: true } : {},
 			systemPromptReport
 		};
 	} finally {
@@ -9818,7 +7945,11 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		codexModelCallDiagnostics.emitError("codex app-server run completed without model-call terminal event");
 		emitLifecycleTerminal({
 			phase: "error",
-			error: "codex app-server run completed without lifecycle terminal event"
+			error: "codex app-server run completed without lifecycle terminal event",
+			...buildLifecycleTerminalMeta({
+				aborted: runAbortController.signal.aborted && !clientClosedAbort,
+				timedOut
+			})
 		});
 		if (trajectoryRecorder && !trajectoryEndRecorded) trajectoryRecorder.recordEvent("session.ended", {
 			status: timedOut || runAbortController.signal.aborted && !clientClosedAbort ? "interrupted" : "cleanup",
@@ -9837,16 +7968,21 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			}
 		});
 		if (!timedOut && !runAbortController.signal.aborted) await steeringQueueRef.current?.flushPending();
-		if (!timedOut) await unsubscribeCodexThreadBestEffort(client, {
+		const yieldedOneShotCleanupDeferred = !timedOut && params.cleanupBundleMcpOnRunEnd === true && yieldDetected && nativeSubagentMonitorRef.current?.deferUntilParentSettles(thread.threadId, async () => {
+			await unsubscribeCodexThreadBestEffort(client, {
+				threadId: thread.threadId,
+				timeoutMs: 5e3
+			});
+			await releaseSharedClientLeaseAndRetireOneShotClient();
+		});
+		if (!timedOut && !yieldedOneShotCleanupDeferred) await unsubscribeCodexThreadBestEffort(client, {
 			threadId: thread.threadId,
 			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
 		});
 		userInputBridgeRef.current?.cancelPending();
 		turnWatches.clearAllTimers();
-		notificationCleanup();
-		requestCleanup();
-		closeCleanup?.();
-		await releaseSharedClientLeaseAndRetireOneShotClient();
+		releaseCurrentRoute();
+		if (!yieldedOneShotCleanupDeferred) await releaseSharedClientLeaseAndRetireOneShotClient();
 		if (nativeHookRelay) if (shouldDelayNativeHookRelayUnregister) scheduleCodexNativeHookRelayUnregister({
 			relay: nativeHookRelay,
 			hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
@@ -9854,17 +7990,20 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		else nativeHookRelay.unregister();
 		await releaseSandboxExecEnvironment();
 		runAbortController.signal.removeEventListener("abort", abortListener);
-		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 		steeringQueueRef.current?.cancel();
+		freezeRunTerminalOutcome();
+		params.replyOperation?.detachBackend(handle);
 		clearActiveEmbeddedRun(params.sessionId, handle, params.sessionKey, params.sessionFile);
 	}
 }
 function readDynamicToolCallParams(value) {
 	return readCodexDynamicToolCallParams(value);
 }
-async function clearCodexBindingAfterInvalidImagePayload(sessionFile, fields) {
-	const currentBinding = await readCodexAppServerBinding(sessionFile);
-	if (fields.threadId && currentBinding && currentBinding.threadId !== fields.threadId) {
+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
@@ -9872,32 +8011,21 @@ async function clearCodexBindingAfterInvalidImagePayload(sessionFile, fields) {
 		return;
 	}
 	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
-	await clearCodexAppServerBinding(sessionFile);
+	await bindingStore.mutate(identity, {
+		kind: "clear",
+		threadId: expectedThreadId
+	});
 }
 async function markCodexAppServerBindingCoveredThroughTurn(params) {
-	const currentBinding = await readCodexAppServerBinding(params.sessionFile, {
-		authProfileStore: params.authProfileStore,
-		agentDir: params.agentDir,
-		config: params.config
-	});
-	if (!currentBinding || currentBinding.threadId !== params.threadId) return;
-	const { schemaVersion: _schemaVersion, sessionFile: _boundSessionFile, updatedAt: _updatedAt, ...bindingForWrite } = currentBinding;
-	await writeCodexAppServerBinding(params.sessionFile, bindingForWrite, {
-		authProfileStore: params.authProfileStore,
-		agentDir: params.agentDir,
-		config: params.config
+	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 canAttributeUnscopedNativeResponseDeltaToThisTurn(client) {
-	const activeLeases = client.getActiveSharedLeaseCountForUnscopedNotifications?.();
-	return activeLeases === void 0 || activeLeases <= 1;
-}
-function isUnscopedCodexNotification(correlation) {
-	return !correlation.threadId && !correlation.turnId && !correlation.nestedTurnThreadId && !correlation.nestedTurnId;
-}
 function shouldUseFreshCodexThreadAfterContextEngineOverflow(params) {
 	if (!params.contextEngineActive || params.thread.lifecycle.action !== "resumed") return false;
 	return isCodexContextWindowError(params.error);
@@ -9912,12 +8040,20 @@ function isCodexActiveCompactTurnError(error) {
 	const codexErrorInfo = isJsonObject(data?.codexErrorInfo) ? data.codexErrorInfo : void 0;
 	return (isJsonObject(codexErrorInfo?.activeTurnNotSteerable) ? codexErrorInfo.activeTurnNotSteerable : void 0)?.turnKind === "compact";
 }
-function isCodexThreadTurnCompletedNotification(notification, threadId, turnIds) {
-	if (notification.method !== "turn/completed") return false;
-	const correlation = describeCodexNotificationCorrelation(notification, { threadId });
-	if (!correlation.matchesActiveThread) return false;
-	const turnId = correlation.turnId ?? correlation.nestedTurnId;
-	return !turnIds || turnId !== void 0 && turnIds.has(turnId);
+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");
@@ -9973,12 +8109,15 @@ function handleApprovalRequest(params) {
 		execReviewerAgentId: params.execReviewerAgentId,
 		internalExecAutoReview: params.internalExecAutoReview,
 		autoApprove: params.autoApprove,
-		signal: params.signal
+		signal: params.signal,
+		onNativeToolFailureDisposition: params.onNativeToolFailureDisposition
 	});
 }
 function resolveCodexDynamicToolDirectNames(params) {
-	if (params.sourceReplyDeliveryMode !== "message_tool_only") return [];
-	return ["message"];
+	const names = [];
+	if (params.crestodianTool) names.push("crestodian");
+	if (params.sourceReplyDeliveryMode === "message_tool_only") names.push("message");
+	return names;
 }
 //#endregion
 export { runCodexAppServerAttempt };