@openclaw/codex 2026.5.25-beta.1 → 2026.5.26-beta.2

package/dist/{run-attempt-BjoI3hUJ.js → run-attempt-D8Vxo-Jm.js}

@@ -1,19 +1,19 @@
-import { t as defaultCodexAppServerClientFactory } from "./client-factory-A7DQkSLq.js";
-import { c as readCodexPluginConfig, d as resolveCodexPluginsPolicy, f as shouldAutoApproveCodexAppServerApprovals, i as isCodexAppServerApprovalPolicyAllowedByRequirements, l as resolveCodexAppServerRuntimeOptions, o as isCodexSandboxExecServerEnabled, p as withMcpElicitationsApprovalPolicy, u as resolveCodexComputerUseConfig } from "./config-D6TUuyo2.js";
-import { a as readCodexDynamicToolCallParams, c as readCodexTurn, i as assertCodexTurnStartResponse } from "./protocol-validators-_gKDcd0x.js";
-import { a as isCodexAppServerConnectionClosedError, i as isCodexAppServerApprovalRequest, l as isJsonObject, r as compareCodexAppServerVersions, s as MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION } from "./client-SrtuTTVa.js";
-import { D as resolveCodexContextEngineProjectionMaxChars, E as projectContextEngineAssemblyForCodex, O as resolveCodexContextEngineProjectionReserveTokens, S as defaultCodexAppInventoryCache, _ as mergeCodexThreadConfigs, a as buildDeveloperInstructions, c as buildTurnCollaborationMode, d as isContextEngineBindingCompatible, g as buildCodexPluginThreadConfigInputFingerprint, h as buildCodexPluginThreadConfig, i as buildContextEngineBinding, l as buildTurnStartParams, m as startOrResumeThread, n as areCodexDynamicToolFingerprintsCompatible, u as codexDynamicToolsFingerprint, v as shouldBuildCodexPluginThreadConfig, w as sanitizeCodexHistoryImagePayloads } from "./thread-lifecycle-CXMd9UgJ.js";
-import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-CwNOIDP2.js";
-import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./request-BO0z3vA8.js";
-import { g as shouldRefreshCodexRateLimitsForUsageLimitMessage, h as resolveCodexUsageLimitResetAtMs, i as readCodexNotificationTurnId, m as formatCodexUsageLimitErrorMessage, n as isCodexNotificationForTurn, r as readCodexNotificationThreadId, s as formatCodexDisplayText, t as describeCodexNotificationCorrelation } from "./notification-correlation-D7tJW3FW.js";
-import { c as resolveCodexAppServerAuthAccountCacheKey, d as resolveCodexAppServerEnvApiKeyCacheKey, f as resolveCodexAppServerHomeDir, l as resolveCodexAppServerAuthProfileId, s as refreshCodexAppServerAuthTokens, t as clearSharedCodexAppServerClientIfCurrent, u as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-CZP1DjaN.js";
+import { n as defaultLeasedCodexAppServerClientFactory } from "./client-factory-fW4Hh9q_.js";
+import { c as readCodexPluginConfig, d as resolveCodexPluginsPolicy, f as shouldAutoApproveCodexAppServerApprovals, i as isCodexAppServerApprovalPolicyAllowedByRequirements, l as resolveCodexAppServerRuntimeOptions, o as isCodexSandboxExecServerEnabled, p as withMcpElicitationsApprovalPolicy, u as resolveCodexComputerUseConfig } from "./config-0-UN67Qg.js";
+import { a as readCodexDynamicToolCallParams, c as readCodexTurn, i as assertCodexTurnStartResponse } from "./protocol-validators-DtjYmUw_.js";
+import { a as isCodexAppServerConnectionClosedError, i as isCodexAppServerApprovalRequest, l as isJsonObject, r as compareCodexAppServerVersions, s as MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION } from "./client-BVK_jmHW.js";
+import { C as defaultCodexAppInventoryCache, D as projectContextEngineAssemblyForCodex, O as resolveCodexContextEngineProjectionMaxChars, T as sanitizeCodexHistoryImagePayloads, _ as buildCodexPluginThreadConfigInputFingerprint, a as buildDeveloperInstructions, c as buildTurnCollaborationMode, d as isContextEngineBindingCompatible, g as buildCodexPluginThreadConfig, h as isCodexAppServerProfilerEnabled, i as buildContextEngineBinding, k as resolveCodexContextEngineProjectionReserveTokens, l as buildTurnStartParams, m as startOrResumeThread, n as areCodexDynamicToolFingerprintsCompatible, u as codexDynamicToolsFingerprint, v as mergeCodexThreadConfigs, y as shouldBuildCodexPluginThreadConfig } from "./thread-lifecycle-CUXQezJL.js";
+import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-UFjjws4k.js";
+import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./request-OaxhR46w.js";
+import { g as shouldRefreshCodexRateLimitsForUsageLimitMessage, h as resolveCodexUsageLimitResetAtMs, i as readCodexNotificationTurnId, m as formatCodexUsageLimitErrorMessage, n as isCodexNotificationForTurn, r as readCodexNotificationThreadId, s as formatCodexDisplayText, t as describeCodexNotificationCorrelation } from "./notification-correlation-YINts3PA.js";
+import { a as releaseLeasedSharedCodexAppServerClient, d as resolveCodexAppServerAuthProfileId, f as resolveCodexAppServerAuthProfileIdForAgent, l as refreshCodexAppServerAuthTokens, m as resolveCodexAppServerHomeDir, o as retireSharedCodexAppServerClientIfCurrent, p as resolveCodexAppServerFallbackApiKeyCacheKey, t as clearSharedCodexAppServerClientIfCurrent, u as resolveCodexAppServerAuthAccountCacheKey } from "./shared-client-8kIrP817.js";
 import { i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-CTnEWuor.js";
-import { a as resolveCodexDynamicToolsLoading, i as normalizeCodexDynamicToolName, n as filterCodexDynamicTools, r as isForcedPrivateQaCodexRuntime, t as createCodexDynamicToolBridge } from "./dynamic-tools-BXAE1U1-.js";
-import { a as handleCodexAppServerElicitationRequest, c as emitDynamicToolTerminalDiagnostic, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerApprovalRequest, n as CODEX_NATIVE_HOOK_RELAY_EVENTS, o as emitDynamicToolErrorDiagnostic, r as buildCodexNativeHookRelayConfig, s as emitDynamicToolStartedDiagnostic, t as filterToolsForVisionInputs } from "./vision-tools-CETeQgze.js";
-import { t as ensureCodexComputerUse } from "./computer-use-CVfE2Vfb.js";
+import { a as resolveCodexDynamicToolsLoading, i as normalizeCodexDynamicToolName, n as filterCodexDynamicTools, r as isForcedPrivateQaCodexRuntime, t as createCodexDynamicToolBridge } from "./dynamic-tools-DlEefKNQ.js";
+import { a as handleCodexAppServerElicitationRequest, c as emitDynamicToolTerminalDiagnostic, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerApprovalRequest, n as CODEX_NATIVE_HOOK_RELAY_EVENTS, o as emitDynamicToolErrorDiagnostic, r as buildCodexNativeHookRelayConfig, s as emitDynamicToolStartedDiagnostic, t as filterToolsForVisionInputs } from "./vision-tools-DqpLmF5H.js";
+import { t as ensureCodexComputerUse } from "./computer-use-DSdj1hJY.js";
 import { n as rememberCodexRateLimits, t as readRecentCodexRateLimits } from "./rate-limit-cache-N66I-Rd7.js";
 import { createHash, randomUUID } from "node:crypto";
-import nodeFs from "node:fs";
+import fsSync from "node:fs";
 import { asBoolean, asFiniteNumber, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { CODEX_APP_SERVER_CONTEXT_ENGINE_HOST, TOOL_PROGRESS_OUTPUT_MAX_CHARS, acquireSessionWriteLock, appendSessionTranscriptMessage, assembleHarnessContextEngine, assertContextEngineHostSupport, awaitAgentHarnessAgentEndHook, bootstrapHarnessContextEngine, buildAgentHookContextChannelFields, buildEmbeddedAttemptToolRunContext, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, embeddedAgentLog, emitAgentEvent, emitSessionTranscriptUpdate, finalizeHarnessContextEngineTurn, formatErrorMessage, formatToolAggregate, formatToolProgressOutput, getBeforeToolCallPolicyDiagnosticState, inferToolMetaFromArgs, isActiveHarnessContextEngine, isSubagentSessionKey, loadCodexBundleMcpThreadConfig, normalizeAgentRuntimeTools, normalizeUsage, registerNativeHookRelay, resolveAgentHarnessBeforePromptBuildResult, resolveAttemptSpawnWorkspaceDir, resolveBootstrapContextForRun, resolveContextEngineOwnerPluginId, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, resolveSessionWriteLockOptions, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessAgentEndHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessBeforeMessageWriteHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { spawn } from "node:child_process";
@@ -22,10 +22,10 @@ import { WebSocketServer } from "ws";
 import { redactSensitiveFieldValue, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import fs from "node:fs/promises";
 import path, { posix } from "node:path";
+import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, hasPendingInternalDiagnosticEvent, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
 import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";
 import { appendRegularFile, pathExists } from "openclaw/plugin-sdk/security-runtime";
-import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, hasPendingInternalDiagnosticEvent, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "@earendil-works/pi-coding-agent";
 import { createAgentHarnessTaskRuntime, deliverAgentHarnessTaskCompletion, isDurableAgentHarnessCompletionDelivery } from "openclaw/plugin-sdk/agent-harness-task-runtime";
 import { isIP } from "node:net";
@@ -108,7 +108,7 @@ function buildSenderLabel(params) {
 	if (!params.senderId || label.includes(params.senderId)) return label;
 	return `${label} (${params.senderId})`;
 }
-function buildCodexUserPromptMessage(params) {
+function buildCodexUserPromptMessageFromPrepared(params, preparedUserMessage) {
 	const senderId = normalizeOptionalString(params.senderId);
 	const senderName = normalizeOptionalString(params.senderName);
 	const senderUsername = normalizeOptionalString(params.senderUsername);
@@ -120,6 +120,18 @@ function buildCodexUserPromptMessage(params) {
 		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,
@@ -133,6 +145,12 @@ function buildCodexUserPromptMessage(params) {
 		...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);
+}
 /**
 * 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
@@ -174,24 +192,30 @@ function buildMirrorDedupeIdentity(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;
+	if (messages.length === 0) return { userMessagesPresent: [] };
 	const lock = await acquireSessionWriteLock({
 		sessionFile: params.sessionFile,
 		...resolveSessionWriteLockOptions(params.config)
 	});
 	const appendedUpdates = [];
+	const userMessagesPresent = [];
 	try {
 		const mirrorState = await readTranscriptMirrorState(params.sessionFile);
 		let nextMessageSeq = mirrorState.messageCount;
 		for (const message of messages) {
 			const dedupeIdentity = buildMirrorDedupeIdentity(message);
 			const idempotencyKey = params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0;
-			if (idempotencyKey && mirrorState.idempotencyKeys.has(idempotencyKey)) continue;
+			const transcriptMessage = {
+				...message,
+				...idempotencyKey ? { idempotencyKey } : {}
+			};
+			if (idempotencyKey && mirrorState.idempotencyKeys.has(idempotencyKey)) {
+				const persistedUserMessage = mirrorState.userMessagesByIdempotencyKey.get(idempotencyKey);
+				if (persistedUserMessage) userMessagesPresent.push(persistedUserMessage);
+				continue;
+			}
 			const nextMessage = runAgentHarnessBeforeMessageWriteHook({
-				message: {
-					...message,
-					...idempotencyKey ? { idempotencyKey } : {}
-				},
+				message: transcriptMessage,
 				agentId: params.agentId,
 				sessionKey: params.sessionKey
 			});
@@ -203,8 +227,13 @@ async function mirrorCodexAppServerTranscript(params) {
 			const { messageId, message: appendedMessage } = await appendSessionTranscriptMessage({
 				transcriptPath: params.sessionFile,
 				message: messageToAppend,
+				idempotencyLookup: idempotencyKey ? "caller-checked" : "scan",
 				config: params.config
 			});
+			if (appendedMessage.role === "user") {
+				userMessagesPresent.push(appendedMessage);
+				if (idempotencyKey) mirrorState.userMessagesByIdempotencyKey.set(idempotencyKey, appendedMessage);
+			}
 			nextMessageSeq += 1;
 			appendedUpdates.push({
 				messageId,
@@ -223,9 +252,11 @@ async function mirrorCodexAppServerTranscript(params) {
 		messageId: update.messageId,
 		messageSeq: update.messageSeq
 	});
+	return { userMessagesPresent };
 }
 async function readTranscriptMirrorState(sessionFile) {
 	const idempotencyKeys = /* @__PURE__ */ new Set();
+	const userMessagesByIdempotencyKey = /* @__PURE__ */ new Map();
 	let messageCount = 0;
 	let raw;
 	try {
@@ -234,7 +265,8 @@ async function readTranscriptMirrorState(sessionFile) {
 		if (error.code !== "ENOENT") throw error;
 		return {
 			idempotencyKeys,
-			messageCount
+			messageCount,
+			userMessagesByIdempotencyKey
 		};
 	}
 	for (const line of raw.split(/\r?\n/)) {
@@ -242,14 +274,18 @@ async function readTranscriptMirrorState(sessionFile) {
 		try {
 			const parsed = JSON.parse(line);
 			if (parsed.type === "message") messageCount += 1;
-			if (typeof parsed.message?.idempotencyKey === "string") idempotencyKeys.add(parsed.message.idempotencyKey);
+			if (typeof parsed.message?.idempotencyKey === "string") {
+				idempotencyKeys.add(parsed.message.idempotencyKey);
+				if (parsed.message.role === "user") userMessagesByIdempotencyKey.set(parsed.message.idempotencyKey, parsed.message);
+			}
 		} catch {
 			continue;
 		}
 	}
 	return {
 		idempotencyKeys,
-		messageCount
+		messageCount,
+		userMessagesByIdempotencyKey
 	};
 }
 //#endregion
@@ -3946,7 +3982,7 @@ const JWT_VALUE_RE = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]
 const COOKIE_PAIR_RE = /\b([A-Za-z][A-Za-z0-9_.-]{1,64})=([A-Za-z0-9+/._~%=-]{16,})(?=;|\s|$)/gu;
 const TRAJECTORY_RUNTIME_FILE_MAX_BYTES = 50 * 1024 * 1024;
 const TRAJECTORY_RUNTIME_EVENT_MAX_BYTES = 256 * 1024;
-function resolveCodexTrajectoryPointerFlags(constants = nodeFs.constants) {
+function resolveCodexTrajectoryPointerFlags(constants = fsSync.constants) {
 	const noFollow = constants.O_NOFOLLOW;
 	return constants.O_CREAT | constants.O_TRUNC | constants.O_WRONLY | (typeof noFollow === "number" ? noFollow : 0);
 }
@@ -3980,23 +4016,23 @@ function writeTrajectoryPointerBestEffort(params) {
 	const pointerPath = resolveTrajectoryPointerFilePath(params.sessionFile);
 	try {
 		const pointerDir = path.resolve(path.dirname(pointerPath));
-		if (nodeFs.lstatSync(pointerDir).isSymbolicLink()) return;
+		if (fsSync.lstatSync(pointerDir).isSymbolicLink()) return;
 		try {
-			if (nodeFs.lstatSync(pointerPath).isSymbolicLink()) return;
+			if (fsSync.lstatSync(pointerPath).isSymbolicLink()) return;
 		} catch (error) {
 			if (error.code !== "ENOENT") return;
 		}
-		const fd = nodeFs.openSync(pointerPath, resolveCodexTrajectoryPointerFlags(), 384);
+		const fd = fsSync.openSync(pointerPath, resolveCodexTrajectoryPointerFlags(), 384);
 		try {
-			nodeFs.writeFileSync(fd, `${JSON.stringify({
+			fsSync.writeFileSync(fd, `${JSON.stringify({
 				traceSchema: "openclaw-trajectory-pointer",
 				schemaVersion: 1,
 				sessionId: params.sessionId,
 				runtimeFile: params.filePath
 			}, null, 2)}\n`, "utf8");
-			nodeFs.fchmodSync(fd, 384);
+			fsSync.fchmodSync(fd, 384);
 		} finally {
-			nodeFs.closeSync(fd);
+			fsSync.closeSync(fd);
 		}
 	} catch {}
 }
@@ -4312,7 +4348,7 @@ function readRequestId(record) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/run-attempt.ts
-const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 3e4;
+const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 9e4;
 const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 6e5;
 const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12e4;
 const CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS = 6e4;
@@ -4361,6 +4397,7 @@ const CODEX_BOOTSTRAP_CONTEXT_ORDER = new Map([
 	["memory.md", 60],
 	["heartbeat.md", 70]
 ]);
+const ensuredCodexWorkspaceDirs = /* @__PURE__ */ new Set();
 const pendingCodexNativeHookRelayUnregisters = /* @__PURE__ */ new Set();
 function scheduleCodexNativeHookRelayUnregister(params) {
 	let pending;
@@ -4383,6 +4420,19 @@ function resolveCodexNativeHookRelayUnregisterGraceMs(hookTimeoutSec) {
 	const hookTimeoutMs = typeof hookTimeoutSec === "number" && Number.isFinite(hookTimeoutSec) && hookTimeoutSec > 0 ? Math.ceil(hookTimeoutSec) * 1e3 : 0;
 	return Math.max(CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS, hookTimeoutMs + CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS);
 }
+async function ensureCodexWorkspaceDirOnce(workspaceDir) {
+	const normalized = path.resolve(workspaceDir);
+	if (ensuredCodexWorkspaceDirs.has(normalized)) {
+		try {
+			if ((await fs.stat(normalized)).isDirectory()) return;
+		} catch (error) {
+			if ((typeof error === "object" && error ? error.code : void 0) !== "ENOENT") throw error;
+		}
+		ensuredCodexWorkspaceDirs.delete(normalized);
+	}
+	await fs.mkdir(normalized, { recursive: true });
+	ensuredCodexWorkspaceDirs.add(normalized);
+}
 function emitCodexAppServerEvent(params, event) {
 	try {
 		emitAgentEvent({
@@ -4565,7 +4615,7 @@ function isCodexAppServerPolicyMode(value) {
 function isCodexAppServerApprovalPolicy(value) {
 	return value === "never" || value === "on-request" || value === "on-failure" || value === "untrusted";
 }
-const CODEX_APP_SERVER_NATIVE_THREAD_MAX_TOKENS = 7e4;
+const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
 const CODEX_APP_SERVER_BYTE_UNITS = {
 	b: 1,
 	k: 1024,
@@ -4653,25 +4703,29 @@ async function readCodexSessionRecordForSessionFile(sessionFile) {
 		};
 	}
 }
-async function readCodexAppServerRolloutTokenUsage(file) {
+async function readCodexAppServerRolloutTokenSnapshot(file) {
 	let handle;
 	try {
 		handle = await fs.open(file, "r");
 	} catch {
 		return;
 	}
-	let totalTokens;
+	let snapshot;
 	try {
 		for await (const line of handle.readLines()) {
-			const lineTokens = readCodexAppServerRolloutTokenUsageLine(line);
-			if (lineTokens !== void 0) totalTokens = lineTokens;
+			const lineSnapshot = readCodexAppServerRolloutTokenSnapshotLine(line);
+			if (lineSnapshot !== void 0) {
+				snapshot ??= {};
+				if (lineSnapshot.totalTokens !== void 0) snapshot.totalTokens = lineSnapshot.totalTokens;
+				if (lineSnapshot.modelContextWindow !== void 0) snapshot.modelContextWindow = lineSnapshot.modelContextWindow;
+			}
 		}
 	} finally {
 		await handle.close();
 	}
-	return totalTokens;
+	return snapshot;
 }
-function readCodexAppServerRolloutTokenUsageLine(line) {
+function readCodexAppServerRolloutTokenSnapshotLine(line) {
 	if (!line.trim()) return;
 	try {
 		const parsed = JSON.parse(line);
@@ -4680,11 +4734,20 @@ function readCodexAppServerRolloutTokenUsageLine(line) {
 		if (!info) return;
 		const usage = isJsonObject(info.last_token_usage) ? info.last_token_usage : isJsonObject(info.total_token_usage) ? info.total_token_usage : void 0;
 		const value = usage?.total_tokens ?? usage?.totalTokens;
-		return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+		const totalTokens = typeof value === "number" && Number.isFinite(value) ? value : void 0;
+		const windowValue = info.model_context_window ?? info.modelContextWindow;
+		const modelContextWindow = typeof windowValue === "number" && Number.isFinite(windowValue) && windowValue > 0 ? Math.floor(windowValue) : void 0;
+		const snapshot = {};
+		if (totalTokens !== void 0) snapshot.totalTokens = totalTokens;
+		if (modelContextWindow !== void 0) snapshot.modelContextWindow = modelContextWindow;
+		return snapshot.totalTokens !== void 0 || snapshot.modelContextWindow !== void 0 ? snapshot : void 0;
 	} catch {
 		return;
 	}
 }
+function resolveCodexAppServerNativeThreadTokenFuse(modelContextWindow) {
+	return modelContextWindow ?? CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS;
+}
 function utf8JsonByteLength(value) {
 	try {
 		return Buffer.byteLength(JSON.stringify(value), "utf8");
@@ -4697,10 +4760,22 @@ function maxFiniteNumber(values) {
 	if (nums.length === 0) return;
 	return Math.max(...nums);
 }
+function hasContextEngineThreadBootstrapProjection(binding) {
+	return binding.contextEngine?.projection?.mode === "thread_bootstrap";
+}
 async function rotateOversizedCodexAppServerStartupBinding(params) {
 	const binding = params.binding;
 	if (!binding?.threadId) return binding;
 	if (params.config?.agents?.defaults?.compaction?.truncateAfterCompaction !== true) return binding;
+	if (params.contextEngineActive === true && hasContextEngineThreadBootstrapProjection(binding)) {
+		embeddedAgentLog.debug("codex app-server deferring native transcript size guard for context-engine thread bootstrap", {
+			threadId: binding.threadId,
+			engineId: binding.contextEngine?.engineId,
+			epoch: binding.contextEngine?.projection?.epoch,
+			fingerprint: binding.contextEngine?.projection?.fingerprint
+		});
+		return binding;
+	}
 	const sessionRecord = await readCodexSessionRecordForSessionFile(params.sessionFile);
 	const maxBytes = parseCodexAppServerByteLimit(params.config?.agents?.defaults?.compaction?.maxActiveTranscriptBytes);
 	const rolloutFiles = await listCodexAppServerRolloutFilesForThread(params.agentDir, binding.threadId, params.codexHome);
@@ -4719,16 +4794,20 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 			return;
 		}
 	}
-	const nativeTokens = maxFiniteNumber(await Promise.all(rolloutFiles.map(async (file) => readCodexAppServerRolloutTokenUsage(file.path))));
+	const nativeTokenSnapshots = await Promise.all(rolloutFiles.map(async (file) => readCodexAppServerRolloutTokenSnapshot(file.path)));
+	const nativeTokens = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.totalTokens));
+	const nativeModelContextWindow = maxFiniteNumber(nativeTokenSnapshots.map((snapshot) => snapshot?.modelContextWindow));
+	const maxTokens = resolveCodexAppServerNativeThreadTokenFuse(nativeModelContextWindow);
 	const sessionTokens = sessionRecord?.totalTokensFresh !== false && typeof sessionRecord?.totalTokens === "number" && Number.isFinite(sessionRecord.totalTokens) ? sessionRecord.totalTokens : void 0;
 	const tokenCount = maxFiniteNumber([sessionTokens, nativeTokens]);
-	if (tokenCount !== void 0 && tokenCount >= CODEX_APP_SERVER_NATIVE_THREAD_MAX_TOKENS) {
+	if (tokenCount !== void 0 && tokenCount >= maxTokens) {
 		embeddedAgentLog.warn("codex app-server native transcript exceeded active token limit; starting a fresh thread", {
 			threadId: binding.threadId,
-			maxTokens: CODEX_APP_SERVER_NATIVE_THREAD_MAX_TOKENS,
+			maxTokens,
 			sessionKey: sessionRecord?.sessionKey,
 			sessionTokens,
-			nativeTokens
+			nativeTokens,
+			nativeModelContextWindow
 		});
 		await clearCodexAppServerBinding(params.sessionFile);
 		return;
@@ -4747,6 +4826,7 @@ async function runCodexAgentEndHook(params, hookParams) {
 }
 async function runCodexAppServerAttempt(params, options = {}) {
 	const attemptStartedAt = Date.now();
+	const profilerEnabled = isCodexAppServerProfilerEnabled(params.config);
 	const codexModelCallTrace = freezeDiagnosticTraceContext(createDiagnosticTraceContextFromActiveScope());
 	const codexModelContentCapture = resolveDiagnosticModelContentCapturePolicy(params.config);
 	const codexModelCallId = `${params.runId}:codex-model:1`;
@@ -4754,13 +4834,16 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	let codexModelCallStarted = false;
 	let codexModelCallTerminalEmitted = false;
 	let codexModelCallRequestPayloadBytes;
-	const attemptClientFactory = options.clientFactory ?? defaultCodexAppServerClientFactory;
+	const preDynamicStartupStages = createCodexDynamicToolBuildStageTracker({ enabled: profilerEnabled });
+	const attemptClientFactory = options.clientFactory ?? defaultLeasedCodexAppServerClientFactory;
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
 	const configuredAppServer = resolveCodexAppServerRuntimeOptions({ pluginConfig });
 	const beforeToolCallPolicy = getBeforeToolCallPolicyDiagnosticState();
+	preDynamicStartupStages.mark("config");
 	const resolvedWorkspace = resolveUserPath(params.workspaceDir);
-	await fs.mkdir(resolvedWorkspace, { recursive: true });
+	await ensureCodexWorkspaceDirOnce(resolvedWorkspace);
+	preDynamicStartupStages.mark("workspace");
 	const sandboxSessionKey = params.sandboxSessionKey?.trim() || params.sessionKey?.trim() || params.sessionId;
 	const contextSessionKey = params.sessionKey?.trim() || sandboxSessionKey;
 	const sandbox = await resolveSandboxContext({
@@ -4768,8 +4851,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		sessionKey: sandboxSessionKey,
 		workspaceDir: resolvedWorkspace
 	});
+	preDynamicStartupStages.mark("sandbox");
 	const effectiveWorkspace = sandbox?.enabled ? sandbox.workspaceAccess === "rw" ? resolvedWorkspace : sandbox.workspaceDir : resolvedWorkspace;
-	await fs.mkdir(effectiveWorkspace, { recursive: true });
+	await ensureCodexWorkspaceDirOnce(effectiveWorkspace);
+	preDynamicStartupStages.mark("effective-workspace");
 	const appServer = resolveCodexAppServerForOpenClawToolPolicy({
 		appServer: configuredAppServer,
 		pluginConfig,
@@ -4783,11 +4868,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		beforeToolCallHook: beforeToolCallPolicy.hasBeforeToolCallHook,
 		trustedToolPolicies: beforeToolCallPolicy.trustedToolPolicies
 	});
+	preDynamicStartupStages.mark("app-server-policy");
 	let pluginAppServer = appServer;
 	const nativeHookRelayEvents = resolveCodexNativeHookRelayEvents({
 		configuredEvents: options.nativeHookRelay?.events,
 		appServer
 	});
+	preDynamicStartupStages.mark("native-hook-relay");
 	const runAbortController = new AbortController();
 	const abortFromUpstream = () => {
 		runAbortController.abort(params.abortSignal?.reason ?? "upstream_abort");
@@ -4800,15 +4887,19 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		agentId: params.agentId
 	});
 	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, sessionAgentId);
+	preDynamicStartupStages.mark("session-agent");
 	let startupBinding = await readCodexAppServerBinding(params.sessionFile);
+	preDynamicStartupStages.mark("read-binding");
 	const startupBindingAuthProfileId = startupBinding?.authProfileId;
 	startupBinding = await rotateOversizedCodexAppServerStartupBinding({
 		binding: startupBinding,
 		sessionFile: params.sessionFile,
 		agentDir,
 		codexHome: appServer.start.env?.CODEX_HOME,
-		config: params.config
+		config: params.config,
+		contextEngineActive: isActiveHarnessContextEngine(params.contextEngine)
 	});
+	preDynamicStartupStages.mark("rotate-binding");
 	const startupAuthProfileCandidate = params.runtimePlan?.auth.forwardedAuthProfileId ?? params.authProfileId ?? startupBinding?.authProfileId ?? startupBindingAuthProfileId;
 	const startupAuthProfileId = params.authProfileStore ? resolveCodexAppServerAuthProfileId({
 		authProfileId: startupAuthProfileCandidate,
@@ -4819,6 +4910,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		agentDir,
 		config: params.config
 	});
+	preDynamicStartupStages.mark("auth-profile");
 	const runtimeParams = {
 		...params,
 		sessionKey: contextSessionKey,
@@ -4837,12 +4929,14 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		agentDir,
 		config: params.config
 	});
-	const startupEnvApiKeyCacheKey = startupAuthProfileId ? void 0 : resolveCodexAppServerEnvApiKeyCacheKey({ startOptions: appServer.start });
+	const startupEnvApiKeyCacheKey = startupAuthProfileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start });
+	preDynamicStartupStages.mark("auth-cache");
 	const nodeExecBlocksNativeExecution = isCodexNativeExecutionBlockedByNodeExecHost(params, {
 		agentId: sessionAgentId,
 		runtimeSessionKey: sandboxSessionKey,
 		sandbox
 	});
+	preDynamicStartupStages.mark("native-exec-policy");
 	const bundleMcpThreadConfig = await loadCodexBundleMcpThreadConfig({
 		workspaceDir: effectiveWorkspace,
 		cfg: params.config,
@@ -4850,12 +4944,14 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		disableTools: params.disableTools,
 		toolsAllow: nodeExecBlocksNativeExecution ? [] : params.toolsAllow
 	});
+	preDynamicStartupStages.mark("bundle-mcp");
 	const sandboxExecServerEnabled = isCodexSandboxExecServerEnabled(pluginConfig);
 	const nativeToolSurfaceEnabled = shouldEnableCodexAppServerNativeToolSurface(params, sandbox, {
 		agentId: sessionAgentId,
 		runtimeSessionKey: sandboxSessionKey,
 		sandboxExecServerEnabled
 	});
+	preDynamicStartupStages.mark("native-tool-surface");
 	for (const diagnostic of bundleMcpThreadConfig.diagnostics) embeddedAgentLog.warn(`bundle-mcp: ${diagnostic.pluginId}: ${diagnostic.message}`);
 	const activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
 	if (activeContextEngine) assertContextEngineHostSupport({
@@ -4864,6 +4960,18 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		host: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST
 	});
 	const hookChannelId = resolveCodexAppServerHookChannelId(params, sandboxSessionKey);
+	preDynamicStartupStages.mark("context-engine-support");
+	const preDynamicSummary = preDynamicStartupStages.snapshot();
+	if (shouldWarnCodexDynamicToolBuildStageSummary(preDynamicSummary)) embeddedAgentLog.warn(`codex app-server pre-dynamic startup timings runId=${params.runId} sessionId=${params.sessionId} totalMs=${preDynamicSummary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(preDynamicSummary)}`, {
+		runId: params.runId,
+		sessionId: params.sessionId,
+		totalMs: preDynamicSummary.totalMs,
+		stages: preDynamicSummary.stages,
+		hasStartupBinding: Boolean(startupBinding?.threadId),
+		startupAuthProfileId: startupAuthProfileId ?? null,
+		bundleMcpDiagnosticCount: bundleMcpThreadConfig.diagnostics.length,
+		nativeToolSurfaceEnabled
+	});
 	let yieldDetected = false;
 	const tools = await buildDynamicTools({
 		params,
@@ -4875,6 +4983,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		runAbortController,
 		sessionAgentId,
 		pluginConfig,
+		profilerEnabled,
 		onYieldDetected: () => {
 			yieldDetected = true;
 		}
@@ -4891,6 +5000,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			runAbortController,
 			sessionAgentId,
 			pluginConfig,
+			profilerEnabled,
 			forceHeartbeatTool: true,
 			ignoreRuntimePlan: true,
 			onYieldDetected: () => {
@@ -5076,6 +5186,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	let thread;
 	let trajectoryEndRecorded = false;
 	let nativeHookRelay;
+	let releaseSharedClientLease;
 	let startupClientForCleanup;
 	let sandboxExecEnvironmentAcquired = false;
 	const releaseSandboxExecEnvironment = async () => {
@@ -5159,106 +5270,120 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			operation: async () => {
 				let attemptedClient;
 				const startupAttempt = async () => {
-					const startupClient = await attemptClientFactory(appServer.start, startupAuthProfileId, agentDir, params.config);
-					attemptedClient = startupClient;
-					startupClientForCleanup = startupClient;
-					await ensureCodexComputerUse({
-						client: startupClient,
-						pluginConfig,
-						timeoutMs: appServer.requestTimeoutMs,
-						signal: runAbortController.signal
-					});
-					let startupSandboxEnvironment;
-					let startupSandboxEnvironmentAcquired = false;
-					const releaseStartupSandboxEnvironment = async () => {
-						if (startupSandboxEnvironmentAcquired) {
-							startupSandboxEnvironmentAcquired = false;
-							await releaseCodexSandboxExecServerEnvironment(sandbox);
-						}
-					};
-					releaseStartupResourcesOnTimeout = releaseStartupSandboxEnvironment;
+					let startupClientLease;
+					let startupAttemptSucceeded = false;
 					try {
-						startupSandboxEnvironment = shouldRequireCodexSandboxExecServerEnvironment({
-							sandbox,
-							nativeToolSurfaceEnabled,
-							sandboxExecServerEnabled
-						}) ? await ensureCodexSandboxExecServerEnvironment({
+						const startupClient = await attemptClientFactory(appServer.start, startupAuthProfileId, agentDir, params.config);
+						startupClientLease = () => {
+							releaseLeasedSharedCodexAppServerClient(startupClient);
+						};
+						releaseSharedClientLease = startupClientLease;
+						attemptedClient = startupClient;
+						startupClientForCleanup = startupClient;
+						await ensureCodexComputerUse({
 							client: startupClient,
-							sandbox: sandbox ?? null,
-							appServerStartOptions: appServer.start,
+							pluginConfig,
 							timeoutMs: appServer.requestTimeoutMs,
 							signal: runAbortController.signal
-						}) : void 0;
-						startupSandboxEnvironmentAcquired = Boolean(startupSandboxEnvironment);
-						if (runAbortController.signal.aborted) {
-							await releaseStartupSandboxEnvironment();
-							throw new Error("codex app-server startup aborted");
-						}
-						if (sandbox?.enabled && nativeToolSurfaceEnabled && sandboxExecServerEnabled && !startupSandboxEnvironment) throw new Error("Codex app-server did not register an OpenClaw sandbox exec-server environment.");
-					} catch (error) {
-						await releaseStartupSandboxEnvironment();
-						throw error;
-					}
-					const startupEnvironmentSelection = resolveCodexSandboxEnvironmentSelection(startupSandboxEnvironment, nativeToolSurfaceEnabled);
-					const startupExecutionCwd = resolveCodexAppServerExecutionCwd({
-						effectiveWorkspace,
-						environment: startupSandboxEnvironment,
-						nativeToolSurfaceEnabled
-					});
-					const startupSandboxPolicy = startupSandboxEnvironment ? resolveCodexExternalSandboxPolicyForOpenClawSandbox(sandbox) : void 0;
-					const buildThreadLifecycleParams = () => ({
-						client: startupClient,
-						params: buildActiveRunAttemptParams(),
-						agentId: sessionAgentId,
-						cwd: startupExecutionCwd,
-						dynamicTools: toolBridge.specs,
-						appServer: pluginAppServer,
-						developerInstructions: promptBuild.developerInstructions,
-						config: threadConfig,
-						finalConfigPatch: nativeHookRelayConfig,
-						nativeCodeModeEnabled: nativeToolSurfaceEnabled,
-						nativeCodeModeOnlyEnabled: appServer.codeModeOnly,
-						userMcpServersEnabled: nativeToolSurfaceEnabled,
-						mcpServersFingerprint: bundleMcpThreadConfig.fingerprint,
-						mcpServersFingerprintEvaluated: bundleMcpThreadConfig.evaluated,
-						environmentSelection: startupEnvironmentSelection,
-						contextEngineProjection,
-						pluginThreadConfig: pluginThreadConfigRequired ? {
-							enabled: true,
-							inputFingerprint: pluginThreadConfigInputFingerprint,
-							enabledPluginConfigKeys,
-							build: () => buildCodexPluginThreadConfig({
-								pluginConfig: pluginThreadConfigPluginConfig,
-								request: (method, requestParams) => startupClient.request(method, requestParams, {
-									timeoutMs: appServer.requestTimeoutMs,
-									signal: runAbortController.signal
-								}),
-								appCache: defaultCodexAppInventoryCache,
-								appCacheKey: pluginAppCacheKey
-							})
-						} : void 0
-					});
-					try {
-						restartContextEngineCodexThread = () => startOrResumeThread(buildThreadLifecycleParams());
-						const startupThread = await startOrResumeThread(buildThreadLifecycleParams());
-						if (runAbortController.signal.aborted) {
+						});
+						let startupSandboxEnvironment;
+						let startupSandboxEnvironmentAcquired = false;
+						const releaseStartupSandboxEnvironment = async () => {
+							if (startupSandboxEnvironmentAcquired) {
+								startupSandboxEnvironmentAcquired = false;
+								await releaseCodexSandboxExecServerEnvironment(sandbox);
+							}
+						};
+						releaseStartupResourcesOnTimeout = releaseStartupSandboxEnvironment;
+						try {
+							startupSandboxEnvironment = shouldRequireCodexSandboxExecServerEnvironment({
+								sandbox,
+								nativeToolSurfaceEnabled,
+								sandboxExecServerEnabled
+							}) ? await ensureCodexSandboxExecServerEnvironment({
+								client: startupClient,
+								sandbox: sandbox ?? null,
+								appServerStartOptions: appServer.start,
+								timeoutMs: appServer.requestTimeoutMs,
+								signal: runAbortController.signal
+							}) : void 0;
+							startupSandboxEnvironmentAcquired = Boolean(startupSandboxEnvironment);
+							if (runAbortController.signal.aborted) {
+								await releaseStartupSandboxEnvironment();
+								throw new Error("codex app-server startup aborted");
+							}
+							if (sandbox?.enabled && nativeToolSurfaceEnabled && sandboxExecServerEnabled && !startupSandboxEnvironment) throw new Error("Codex app-server did not register an OpenClaw sandbox exec-server environment.");
+						} catch (error) {
 							await releaseStartupSandboxEnvironment();
-							throw new Error("codex app-server startup aborted");
+							throw error;
 						}
-						startupSandboxEnvironmentAcquired = false;
-						return {
+						const startupEnvironmentSelection = resolveCodexSandboxEnvironmentSelection(startupSandboxEnvironment, nativeToolSurfaceEnabled);
+						const startupExecutionCwd = resolveCodexAppServerExecutionCwd({
+							effectiveWorkspace,
+							environment: startupSandboxEnvironment,
+							nativeToolSurfaceEnabled
+						});
+						const startupSandboxPolicy = startupSandboxEnvironment ? resolveCodexExternalSandboxPolicyForOpenClawSandbox(sandbox) : void 0;
+						const buildThreadLifecycleParams = () => ({
 							client: startupClient,
-							thread: startupThread,
-							sandboxEnvironment: startupSandboxEnvironment,
+							params: buildActiveRunAttemptParams(),
+							agentId: sessionAgentId,
+							cwd: startupExecutionCwd,
+							dynamicTools: toolBridge.specs,
+							appServer: pluginAppServer,
+							developerInstructions: promptBuild.developerInstructions,
+							config: threadConfig,
+							finalConfigPatch: nativeHookRelayConfig,
+							nativeCodeModeEnabled: nativeToolSurfaceEnabled,
+							nativeCodeModeOnlyEnabled: appServer.codeModeOnly,
+							userMcpServersEnabled: nativeToolSurfaceEnabled,
+							mcpServersFingerprint: bundleMcpThreadConfig.fingerprint,
+							mcpServersFingerprintEvaluated: bundleMcpThreadConfig.evaluated,
 							environmentSelection: startupEnvironmentSelection,
-							executionCwd: startupExecutionCwd,
-							sandboxPolicy: startupSandboxPolicy
-						};
-					} catch (error) {
-						await releaseStartupSandboxEnvironment();
-						throw error;
+							contextEngineProjection,
+							pluginThreadConfig: pluginThreadConfigRequired ? {
+								enabled: true,
+								inputFingerprint: pluginThreadConfigInputFingerprint,
+								enabledPluginConfigKeys,
+								build: () => buildCodexPluginThreadConfig({
+									pluginConfig: pluginThreadConfigPluginConfig,
+									request: (method, requestParams) => startupClient.request(method, requestParams, {
+										timeoutMs: appServer.requestTimeoutMs,
+										signal: runAbortController.signal
+									}),
+									appCache: defaultCodexAppInventoryCache,
+									appCacheKey: pluginAppCacheKey
+								})
+							} : void 0
+						});
+						try {
+							restartContextEngineCodexThread = () => startOrResumeThread(buildThreadLifecycleParams());
+							const startupThread = await startOrResumeThread(buildThreadLifecycleParams());
+							if (runAbortController.signal.aborted) {
+								await releaseStartupSandboxEnvironment();
+								throw new Error("codex app-server startup aborted");
+							}
+							startupSandboxEnvironmentAcquired = false;
+							startupAttemptSucceeded = true;
+							return {
+								client: startupClient,
+								thread: startupThread,
+								sandboxEnvironment: startupSandboxEnvironment,
+								environmentSelection: startupEnvironmentSelection,
+								executionCwd: startupExecutionCwd,
+								sandboxPolicy: startupSandboxPolicy
+							};
+						} catch (error) {
+							await releaseStartupSandboxEnvironment();
+							throw error;
+						} finally {
+							if (releaseStartupResourcesOnTimeout === releaseStartupSandboxEnvironment) releaseStartupResourcesOnTimeout = void 0;
+						}
 					} finally {
-						if (releaseStartupResourcesOnTimeout === releaseStartupSandboxEnvironment) releaseStartupResourcesOnTimeout = void 0;
+						if (!startupAttemptSucceeded) {
+							if (releaseSharedClientLease === startupClientLease) releaseSharedClientLease = void 0;
+							startupClientLease?.();
+						}
 					}
 				};
 				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS; attempt += 1) try {
@@ -5465,7 +5590,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		runAbortController.abort("turn_progress_idle_timeout");
 	};
 	const fireTurnCompletionIdleTimeout = () => {
-		if (completed || runAbortController.signal.aborted || !turnCompletionIdleWatchArmed || activeAppServerTurnRequests > 0) return;
+		if (completed || terminalTurnNotificationQueued || runAbortController.signal.aborted || !turnCompletionIdleWatchArmed || activeAppServerTurnRequests > 0) return;
 		const timeoutMs = turnCompletionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs;
 		const idleMs = Math.max(0, Date.now() - turnCompletionLastActivityAt);
 		if (idleMs < timeoutMs) {
@@ -5495,7 +5620,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		runAbortController.abort("turn_completion_idle_timeout");
 	};
 	const fireTurnTerminalIdleTimeout = () => {
-		if (completed || runAbortController.signal.aborted || !turnTerminalIdleWatchArmed || activeAppServerTurnRequests > 0) return;
+		if (completed || terminalTurnNotificationQueued || runAbortController.signal.aborted || !turnTerminalIdleWatchArmed || activeAppServerTurnRequests > 0) return;
 		const idleMs = Math.max(0, Date.now() - turnCompletionLastActivityAt);
 		if (idleMs < turnTerminalIdleTimeoutMs) {
 			scheduleTurnTerminalIdleWatch();
@@ -5817,14 +5942,23 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			threadId: thread.threadId,
 			...turnId ? { turnId } : {}
 		});
-		embeddedAgentLog.debug("codex app-server raw notification received", correlation);
-		if (notification.method === "turn/completed" && correlation.matchesActiveTurn === false) embeddedAgentLog.warn("codex app-server turn/completed did not match active turn", correlation);
+		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 (isCodexNotificationOutsideActiveRun(correlation)) return Promise.resolve();
 		if (!projector || !turnId) {
 			userInputBridge?.handleNotification(notification);
 			pendingNotifications.push(notification);
 			return Promise.resolve();
 		}
 		if (isTerminalTurnNotificationForTurn(notification, turnId)) terminalTurnNotificationQueued = true;
+		if (correlation.matchesActiveTurn !== false) {
+			const now = Date.now();
+			turnCompletionLastActivityAt = now;
+			turnCompletionLastActivityReason = `notification:${notification.method}`;
+			turnAttemptLastProgressAt = now;
+			turnAttemptLastProgressReason = `notification:${notification.method}`;
+		}
 		notificationQueue = notificationQueue.then(() => handleNotification(notification), () => handleNotification(notification));
 		return notificationQueue;
 	};
@@ -6276,6 +6410,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				}
 			});
 			params.abortSignal?.removeEventListener("abort", abortFromUpstream);
+			releaseSharedClientLease?.();
+			releaseSharedClientLease = void 0;
 			if (usageLimitError) {
 				await markCodexAuthProfileBlockedFromRateLimits({
 					params,
@@ -6292,7 +6428,11 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			throw turnStartError;
 		}
 	}
-	if (!turn) throw new Error("codex app-server turn/start failed without an error");
+	if (!turn) {
+		releaseSharedClientLease?.();
+		releaseSharedClientLease = void 0;
+		throw new Error("codex app-server turn/start failed without an error");
+	}
 	turnId = turn.turn.id;
 	const activeTurnId = turn.turn.id;
 	emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
@@ -6364,9 +6504,11 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		abort: () => runAbortController.abort("aborted")
 	};
 	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey);
+	const notifyUserMessagePersisted = createCodexAppServerUserMessagePersistenceNotifier(params);
 	mirrorPromptAtTurnStartBestEffort({
 		params,
 		agentId: sessionAgentId,
+		notifyUserMessagePersisted,
 		sessionKey: sandboxSessionKey,
 		threadId: thread.threadId,
 		turnId: activeTurnId
@@ -6375,16 +6517,19 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	turnTerminalIdleWatchArmed = true;
 	touchTurnCompletionActivity("turn:start", { attemptProgress: true });
 	const abortListener = () => {
-		const shouldRetireClient = timedOut;
+		if (timedOut) {
+			retireCodexAppServerClientAfterTimedOutTurn(client, {
+				threadId: thread.threadId,
+				turnId: activeTurnId,
+				reason: String(runAbortController.signal.reason ?? "timeout")
+			}).finally(() => {
+				resolveCompletion?.();
+			});
+			return;
+		}
 		interruptCodexTurnBestEffort(client, {
 			threadId: thread.threadId,
-			turnId: activeTurnId,
-			timeoutMs: shouldRetireClient ? CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS : void 0
-		});
-		if (shouldRetireClient) retireCodexAppServerClientAfterTimedOutTurn(client, {
-			threadId: thread.threadId,
-			turnId: activeTurnId,
-			reason: String(runAbortController.signal.reason ?? "timeout")
+			turnId: activeTurnId
 		});
 		resolveCompletion?.();
 	};
@@ -6443,6 +6588,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		await mirrorTranscriptBestEffort({
 			params,
 			agentId: sessionAgentId,
+			notifyUserMessagePersisted,
 			result,
 			sessionKey: contextSessionKey,
 			threadId: thread.threadId,
@@ -6567,6 +6713,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		notificationCleanup();
 		requestCleanup();
 		closeCleanup?.();
+		releaseSharedClientLease?.();
 		if (nativeHookRelay) if (shouldDelayNativeHookRelayUnregister) scheduleCodexNativeHookRelayUnregister({
 			relay: nativeHookRelay,
 			hookTimeoutSec: options.nativeHookRelay?.hookTimeoutSec
@@ -6799,7 +6946,10 @@ function createCodexNativeHookRelay(params) {
 			turnStartTimeoutMs: params.turnStartTimeoutMs
 		}),
 		signal: params.signal,
-		command: { timeoutMs: params.options?.gatewayTimeoutMs }
+		command: {
+			nice: 10,
+			timeoutMs: params.options?.gatewayTimeoutMs
+		}
 	});
 }
 function resolveCodexNativeHookRelayEvents(params) {
@@ -6867,17 +7017,39 @@ async function unsubscribeCodexThreadBestEffort(client, params) {
 		});
 	}
 }
-function retireCodexAppServerClientAfterTimedOutTurn(client, params) {
-	const clearedSharedClient = clearSharedCodexAppServerClientIfCurrent(client);
-	if (!clearedSharedClient) {
+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") close.call(client);
+		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,
-		clearedSharedClient
+		detachedSharedClient,
+		closedClient,
+		activeSharedClientLeases: retiredSharedClient?.activeLeases ?? 0
 	});
 }
 function resolveOpenClawCodingToolsSessionKeys(params, sandboxSessionKey) {
@@ -6895,12 +7067,54 @@ function resolveCodexAppServerHookChannelId(params, sandboxSessionKey) {
 		messageTo: params.messageTo
 	}).channelId;
 }
+const CODEX_DYNAMIC_TOOL_BUILD_WARN_TOTAL_MS = 1e3;
+const CODEX_DYNAMIC_TOOL_BUILD_WARN_STAGE_MS = 500;
+function createCodexDynamicToolBuildStageTracker(options = {}) {
+	if (!options.enabled) return {
+		mark() {},
+		snapshot() {
+			return {
+				totalMs: 0,
+				stages: []
+			};
+		}
+	};
+	const startedAt = Date.now();
+	let previousAt = startedAt;
+	const stages = [];
+	const toMs = (value) => Math.max(0, Math.round(value));
+	return {
+		mark(name) {
+			const currentAt = Date.now();
+			stages.push({
+				name,
+				durationMs: toMs(currentAt - previousAt),
+				elapsedMs: toMs(currentAt - startedAt)
+			});
+			previousAt = currentAt;
+		},
+		snapshot() {
+			return {
+				totalMs: toMs(Date.now() - startedAt),
+				stages: stages.slice()
+			};
+		}
+	};
+}
+function shouldWarnCodexDynamicToolBuildStageSummary(summary) {
+	return summary.totalMs >= CODEX_DYNAMIC_TOOL_BUILD_WARN_TOTAL_MS || summary.stages.some((stage) => stage.durationMs >= CODEX_DYNAMIC_TOOL_BUILD_WARN_STAGE_MS);
+}
+function formatCodexDynamicToolBuildStageSummary(summary) {
+	return summary.stages.length > 0 ? summary.stages.map((stage) => `${stage.name}:${stage.durationMs}ms@${stage.elapsedMs}ms`).join(",") : "none";
+}
 async function buildDynamicTools(input) {
 	const { params } = input;
 	if (params.disableTools || !supportsModelTools(params.model)) return [];
+	const toolBuildStages = createCodexDynamicToolBuildStageTracker({ enabled: input.profilerEnabled });
 	const modelHasVision = params.model.input?.includes("image") ?? false;
 	const agentDir = params.agentDir ?? resolveAgentDir$1(params.config ?? {}, input.sessionAgentId);
 	const createOpenClawCodingTools = (await import("openclaw/plugin-sdk/agent-harness")).createOpenClawCodingTools;
+	toolBuildStages.mark("load-agent-harness-tools");
 	const sessionKeys = resolveOpenClawCodingToolsSessionKeys(params, input.sandboxSessionKey);
 	const allTools = createOpenClawCodingTools({
 		agentId: input.sessionAgentId,
@@ -6941,7 +7155,7 @@ async function buildDynamicTools(input) {
 		modelCompat: params.model.compat && typeof params.model.compat === "object" ? params.model.compat : void 0,
 		modelApi: params.model.api,
 		modelContextWindowTokens: params.model.contextWindow,
-		modelAuthMode: resolveModelAuthMode(params.model.provider, params.config, void 0, { workspaceDir: input.effectiveWorkspace }),
+		modelAuthMode: resolveModelAuthMode(params.model.provider, params.config, params.toolAuthProfileStore ?? params.authProfileStore, { workspaceDir: input.effectiveWorkspace }),
 		suppressManagedWebSearch: false,
 		currentChannelId: params.currentChannelId,
 		hookChannelId: resolveCodexAppServerHookChannelId(params, input.sandboxSessionKey),
@@ -6965,13 +7179,22 @@ async function buildDynamicTools(input) {
 					message
 				}
 			});
+		},
+		recordToolPrepStage: (name) => {
+			toolBuildStages.mark(name);
 		}
 	});
-	const filteredTools = filterCodexDynamicToolsForAllowlist(filterToolsForVisionInputs(addNodeShellDynamicToolsIfNeeded(addSandboxShellDynamicToolsIfAvailable(isCodexMemoryFlushRun(params) ? filterCodexMemoryFlushDynamicTools(allTools) : filterCodexDynamicTools(allTools, input.pluginConfig), allTools, input), allTools, input), {
+	toolBuildStages.mark("create-openclaw-coding-tools");
+	const codexFilteredTools = addNodeShellDynamicToolsIfNeeded(addSandboxShellDynamicToolsIfAvailable(isCodexMemoryFlushRun(params) ? filterCodexMemoryFlushDynamicTools(allTools) : filterCodexDynamicTools(allTools, input.pluginConfig), allTools, input), allTools, input);
+	toolBuildStages.mark("codex-filtering");
+	const visionFilteredTools = filterToolsForVisionInputs(codexFilteredTools, {
 		modelHasVision,
 		hasInboundImages: (params.images?.length ?? 0) > 0
-	}), includeForcedCodexDynamicToolAllow(params.toolsAllow, params));
-	return normalizeAgentRuntimeTools({
+	});
+	toolBuildStages.mark("vision-filtering");
+	const filteredTools = filterCodexDynamicToolsForAllowlist(visionFilteredTools, includeForcedCodexDynamicToolAllow(params.toolsAllow, params));
+	toolBuildStages.mark("allowlist-filter");
+	const normalizedTools = normalizeAgentRuntimeTools({
 		runtimePlan: input.ignoreRuntimePlan ? void 0 : params.runtimePlan,
 		tools: filteredTools,
 		provider: params.provider,
@@ -6982,6 +7205,27 @@ async function buildDynamicTools(input) {
 		modelApi: params.model.api,
 		model: params.model
 	});
+	toolBuildStages.mark("runtime-normalization");
+	const summary = toolBuildStages.snapshot();
+	if (shouldWarnCodexDynamicToolBuildStageSummary(summary)) {
+		const phase = input.forceHeartbeatTool ? "registered-tools" : "runtime-tools";
+		embeddedAgentLog.warn(`codex app-server dynamic tool build timings runId=${params.runId} sessionId=${params.sessionId} phase=${phase} totalMs=${summary.totalMs} stages=${formatCodexDynamicToolBuildStageSummary(summary)}`, {
+			runId: params.runId,
+			sessionId: params.sessionId,
+			phase,
+			totalMs: summary.totalMs,
+			stages: summary.stages,
+			allToolCount: allTools.length,
+			codexFilteredToolCount: codexFilteredTools.length,
+			visionFilteredToolCount: visionFilteredTools.length,
+			filteredToolCount: filteredTools.length,
+			normalizedToolCount: normalizedTools.length,
+			forceHeartbeatTool: input.forceHeartbeatTool === true,
+			ignoreRuntimePlan: input.ignoreRuntimePlan === true,
+			nativeToolSurfaceEnabled: input.nativeToolSurfaceEnabled === true
+		});
+	}
+	return normalizedTools;
 }
 function includeForcedCodexDynamicToolAllow(toolsAllow, params) {
 	if (toolsAllow === void 0 || hasWildcardCodexToolsAllow(toolsAllow)) return toolsAllow;
@@ -7151,11 +7395,33 @@ function shouldProjectMirroredHistoryForCodexStart(params) {
 	if (!params.historyMessages.some((message) => message.role === "user")) return false;
 	if (params.forceProject) return true;
 	if (!params.startupBinding?.threadId) return true;
+	if (hasUserVisibleHistoryAfterCodexBinding({
+		startupBinding: params.startupBinding,
+		historyMessages: params.historyMessages
+	})) return true;
 	return !areCodexDynamicToolFingerprintsCompatible({
 		previous: params.startupBinding.dynamicToolsFingerprint,
 		next: params.dynamicToolsFingerprint
 	});
 }
+function hasUserVisibleHistoryAfterCodexBinding(params) {
+	const bindingUpdatedAt = Date.parse(params.startupBinding.updatedAt);
+	if (!Number.isFinite(bindingUpdatedAt)) return false;
+	return params.historyMessages.some((message) => {
+		if (message.role !== "user" && message.role !== "assistant") return false;
+		if (isCodexAppServerMirroredTranscriptMessage(message)) 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;
+	});
+}
+function isCodexAppServerMirroredTranscriptMessage(message) {
+	const record = message;
+	const idempotencyKey = record.idempotencyKey;
+	if (typeof idempotencyKey === "string" && idempotencyKey.startsWith("codex-app-server:")) return true;
+	const meta = record["__openclaw"];
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return false;
+	return typeof meta.mirrorIdentity === "string";
+}
 function readContextEngineThreadBootstrapProjection(projection) {
 	if (projection?.mode !== "thread_bootstrap") return;
 	const epoch = projection.epoch?.trim();
@@ -7473,6 +7739,11 @@ function readRawAssistantTextPreview(item) {
 function isTurnNotification(value, threadId, turnId) {
 	return isCodexNotificationForTurn(value, threadId, turnId);
 }
+function isCodexNotificationOutsideActiveRun(correlation) {
+	if (!Boolean(correlation.threadId || correlation.nestedTurnThreadId)) return false;
+	if (!correlation.matchesActiveThread) return true;
+	return Boolean(correlation.turnId || correlation.nestedTurnId) && correlation.matchesActiveTurn === false;
+}
 function isCurrentThreadTurnRequestParams(value, threadId, turnId) {
 	if (!isJsonObject(value)) return false;
 	return readString(value, "threadId") === threadId && readString(value, "turnId") === turnId;
@@ -7742,6 +8013,16 @@ function readPositiveNumber(value) {
 function readNonEmptyString(value) {
 	return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
+const CODEX_DELIVERY_HINT_LINES = ["Delivery: to send a message, use the `message` tool.", "Delivery: Final assistant text is not automatically delivered in this run. Use the `message` tool to send user-visible output."];
+function splitLeadingCodexDeliveryHint(prompt) {
+	const trimmedStart = prompt.trimStart();
+	const matchedHint = CODEX_DELIVERY_HINT_LINES.find((hint) => trimmedStart.startsWith(hint));
+	if (!matchedHint) return { prompt };
+	return {
+		deliveryHint: matchedHint,
+		prompt: trimmedStart.slice(matchedHint.length).replace(/^\s*\n/, "").trimStart()
+	};
+}
 function buildCodexOpenClawPromptContext(params) {
 	if (!shouldInjectCodexOpenClawPromptContext(params.params)) return;
 	const sections = [params.skillsPrompt?.trim() ? [
@@ -7766,12 +8047,18 @@ function shouldInjectCodexOpenClawPromptContext(params) {
 }
 function prependCodexOpenClawPromptContext(prompt, context) {
 	if (!context?.trim()) return prompt;
-	const promptSection = prompt.startsWith("OpenClaw assembled context for this turn:") ? prompt : ["Current user request:", prompt].join("\n");
+	const { deliveryHint, prompt: promptWithoutDeliveryHint } = splitLeadingCodexDeliveryHint(prompt);
+	const promptSection = promptWithoutDeliveryHint.startsWith("OpenClaw assembled context for this turn:") ? promptWithoutDeliveryHint : ["Current user request:", promptWithoutDeliveryHint].join("\n");
+	const deliverySection = deliveryHint ? [
+		"OpenClaw delivery metadata:",
+		"This delivery metadata is runtime routing guidance, not the user's request.",
+		deliveryHint
+	].join("\n") : void 0;
 	return [
 		context.trim(),
-		"",
+		deliverySection,
 		promptSection
-	].join("\n");
+	].filter(Boolean).join("\n\n");
 }
 function renderCodexWorkspaceBootstrapPromptContext(contextFiles) {
 	const files = selectCodexWorkspacePromptContextFiles(contextFiles);
@@ -7882,29 +8169,63 @@ function getCodexContextFileBasename(filePath) {
 }
 async function mirrorTranscriptBestEffort(params) {
 	try {
-		await mirrorCodexAppServerTranscript({
+		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,
-			messages: params.result.messagesSnapshot,
+			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 {
-		await mirrorCodexAppServerTranscript({
-			sessionFile: params.params.sessionFile,
-			agentId: params.agentId,
-			sessionKey: params.sessionKey,
-			messages: [attachCodexMirrorIdentity(buildCodexUserPromptMessage(params.params), `${params.turnId}:prompt`)],
-			idempotencyScope: `codex-app-server:${params.threadId}`,
-			config: params.params.config
-		});
+		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,
+				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 });
 	}