@openclaw/codex 2026.5.28 → 2026.5.31-beta.1

package/dist/{run-attempt-CuhGEh0u.js → run-attempt-CgaY9r5u.js}

@@ -1,16 +1,17 @@
-import { n as defaultLeasedCodexAppServerClientFactory } from "./client-factory-qZvhyyXr.js";
-import { c as readCodexPluginConfig, d as resolveCodexPluginsPolicy, f as resolveOpenClawExecPolicyForCodexAppServer, i as isCodexAppServerApprovalPolicyAllowedByRequirements, l as resolveCodexAppServerRuntimeOptions, m as withMcpElicitationsApprovalPolicy, o as isCodexSandboxExecServerEnabled, p as shouldAutoApproveCodexAppServerApprovals, u as resolveCodexComputerUseConfig } from "./config--tW89bHH.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-DMXvboVu.js";
-import { C as sanitizeCodexHistoryImagePayloads, D as resolveCodexContextEngineProjectionReserveTokens, E as resolveCodexContextEngineProjectionMaxChars, T as projectContextEngineAssemblyForCodex, _ as shouldBuildCodexPluginThreadConfig, a as buildDeveloperInstructions, c as codexDynamicToolsFingerprint, f as startOrResumeThread, g as mergeCodexThreadConfigs, h as buildCodexPluginThreadConfigInputFingerprint, i as buildContextEngineBinding, l as isContextEngineBindingCompatible, m as buildCodexPluginThreadConfig, n as areCodexDynamicToolFingerprintsCompatible, o as buildTurnCollaborationMode, p as isCodexAppServerProfilerEnabled, s as buildTurnStartParams, x as defaultCodexAppInventoryCache } from "./thread-lifecycle-Dv9Npl7a.js";
-import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-ueMCn4om.js";
-import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./request-CF4f5hWY.js";
-import { _ as shouldRefreshCodexRateLimitsForUsageLimitMessage, g as resolveCodexUsageLimitResetAtMs, h as formatCodexUsageLimitErrorMessage, i as readCodexNotificationTurnId, n as isCodexNotificationForTurn, r as readCodexNotificationThreadId, s as formatCodexDisplayText, t as describeCodexNotificationCorrelation } from "./notification-correlation-BDakP_d3.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-Duh1bHaP.js";
-import { i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-mXE4_vE_.js";
-import { _ as normalizeCodexDynamicToolName$1, a as createCodexNativeHookRelay, c as scheduleCodexNativeHookRelayUnregister, d as emitDynamicToolErrorDiagnostic, f as emitDynamicToolStartedDiagnostic, g as isForcedPrivateQaCodexRuntime, h as filterCodexDynamicTools, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerElicitationRequest, m as filterToolsForVisionInputs, n as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, o as resolveCodexNativeHookRelayEvents, p as emitDynamicToolTerminalDiagnostic, r as buildCodexNativeHookRelayConfig, s as resolveCodexNativeHookRelayTtlMs, u as createCodexDynamicToolBridge, v as resolveCodexDynamicToolsLoading, y as handleCodexAppServerApprovalRequest } from "./native-hook-relay-B8qM8ZwR.js";
-import { t as ensureCodexComputerUse } from "./computer-use-Ba4vW9fO.js";
+import { a as isCodexAppServerApprovalPolicyAllowedByRequirements, c as isCodexSandboxExecServerEnabled, d as resolveCodexAppServerRuntimeOptions, f as resolveCodexComputerUseConfig, g as withMcpElicitationsApprovalPolicy, h as shouldAutoApproveCodexAppServerApprovals, m as resolveOpenClawExecPolicyForCodexAppServer, p as resolveCodexPluginsPolicy, u as readCodexPluginConfig } from "./config-AlzuNKCY.js";
+import { a as readCodexDynamicToolCallParams, c as readCodexTurn, i as assertCodexTurnStartResponse } from "./protocol-validators-DIt7cXIp.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-BnOmn0y-.js";
+import { C as sanitizeCodexHistoryImagePayloads, D as resolveCodexContextEngineProjectionReserveTokens, E as resolveCodexContextEngineProjectionMaxChars, T as projectContextEngineAssemblyForCodex, _ as shouldBuildCodexPluginThreadConfig, a as buildDeveloperInstructions, c as codexDynamicToolsFingerprint, f as startOrResumeThread, g as mergeCodexThreadConfigs, h as buildCodexPluginThreadConfigInputFingerprint, i as buildContextEngineBinding, l as isContextEngineBindingCompatible, m as buildCodexPluginThreadConfig, n as areCodexDynamicToolFingerprintsCompatible, o as buildTurnCollaborationMode, p as isCodexAppServerProfilerEnabled, s as buildTurnStartParams, x as defaultCodexAppInventoryCache } from "./thread-lifecycle-Bnlv_Q8u.js";
+import { a as readCodexAppServerBinding, n as clearCodexAppServerBindingForThread, s as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-BXJAV_xy.js";
+import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./request-DuFgTwRU.js";
+import { _ as shouldRefreshCodexRateLimitsForUsageLimitMessage, g as resolveCodexUsageLimitResetAtMs, h as formatCodexUsageLimitErrorMessage, i as readCodexNotificationTurnId, n as isCodexNotificationForTurn, r as readCodexNotificationThreadId, s as formatCodexDisplayText, t as describeCodexNotificationCorrelation } from "./notification-correlation-BykOI_jh.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-DBlR-rV2.js";
+import { i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-DMCJlzmz.js";
+import { n as defaultLeasedCodexAppServerClientFactory } from "./client-factory-B8dh39UW.js";
+import { C as resolveCodexTurnAssistantCompletionIdleTimeoutMs, E as withCodexStartupTimeout, S as resolveCodexStartupTimeoutMs, T as resolveCodexTurnTerminalIdleTimeoutMs, _ as normalizeCodexDynamicToolName$1, a as createCodexNativeHookRelay, b as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, c as scheduleCodexNativeHookRelayUnregister, d as emitDynamicToolErrorDiagnostic, f as emitDynamicToolStartedDiagnostic, g as isForcedPrivateQaCodexRuntime, h as filterCodexDynamicTools, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerElicitationRequest, m as filterToolsForVisionInputs, n as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, o as resolveCodexNativeHookRelayEvents, p as emitDynamicToolTerminalDiagnostic, r as buildCodexNativeHookRelayConfig, s as resolveCodexNativeHookRelayTtlMs, u as createCodexDynamicToolBridge, v as resolveCodexDynamicToolsLoading, w as resolveCodexTurnCompletionIdleTimeoutMs, x as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, y as handleCodexAppServerApprovalRequest } from "./native-hook-relay-DCxPRaBN.js";
+import { t as ensureCodexComputerUse } from "./computer-use-D-0EFJBJ.js";
 import { n as rememberCodexRateLimits, t as readRecentCodexRateLimits } from "./rate-limit-cache-N66I-Rd7.js";
+import { asDateTimestampMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { createHash, randomUUID } from "node:crypto";
 import fsSync from "node:fs";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
@@ -26,9 +27,10 @@ import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent
 import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
 import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";
 import { appendRegularFile, pathExists } from "openclaw/plugin-sdk/security-runtime";
-import { parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "openclaw/plugin-sdk/agent-sessions";
 import { isIP } from "node:net";
+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/app-server-policy.ts
 function resolveCodexAppServerForOpenClawToolPolicy(params) {
@@ -155,37 +157,6 @@ async function readMirroredSessionHistoryMessages(sessionFile) {
 	if (!messages) embeddedAgentLog.warn("failed to read mirrored session history for codex harness hooks", { sessionFile });
 	return messages;
 }
-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();
@@ -284,6 +255,10 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 			promptContext: renderCodexWorkspaceBootstrapPromptContext(promptContextFiles),
 			developerInstructions: renderCodexWorkspaceThreadDeveloperInstructions(developerInstructionFiles),
 			turnScopedDeveloperInstructions: renderCodexWorkspaceCollaborationDeveloperInstructions(turnScopedDeveloperInstructionFiles),
+			memoryCollaborationInstructions: shouldInjectCodexOpenClawPromptContext(params.params) ? renderCodexWorkspaceMemoryReference({
+				files: memoryReferenceFiles,
+				toolNames: params.memoryToolNames
+			}) : void 0,
 			heartbeatCollaborationInstructions: renderCodexWorkspaceHeartbeatReference(heartbeatReferenceFiles)
 		};
 	} catch (error) {
@@ -454,19 +429,11 @@ function readNonEmptyString$1(value) {
 }
 function buildCodexOpenClawPromptContext(params) {
 	if (!shouldInjectCodexOpenClawPromptContext(params.params)) return;
-	const sections = [
-		params.skillsPrompt?.trim() ? [
-			"## OpenClaw Skills",
-			"",
-			params.skillsPrompt.trim()
-		].join("\n") : void 0,
-		params.workspaceMemoryReference?.trim() ? params.workspaceMemoryReference.trim() : void 0,
-		params.workspacePromptContext?.trim() ? [
-			"## OpenClaw Workspace Context",
-			"",
-			params.workspacePromptContext.trim()
-		].join("\n") : void 0
-	].filter(isNonEmptyString$2);
+	const sections = [params.workspacePromptContext?.trim() ? [
+		"## OpenClaw Workspace Context",
+		"",
+		params.workspacePromptContext.trim()
+	].join("\n") : void 0].filter(isNonEmptyString$2);
 	if (sections.length === 0) return;
 	return [
 		"OpenClaw runtime context for this turn:",
@@ -478,9 +445,17 @@ function buildCodexOpenClawPromptContext(params) {
 function shouldInjectCodexOpenClawPromptContext(params) {
 	return !(params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron");
 }
-function prependCodexOpenClawPromptContext(prompt, context) {
-	if (!context?.trim()) return prompt;
+function renderCodexSkillsCollaborationInstructions(params) {
+	if (!shouldInjectCodexOpenClawPromptContext(params.attempt)) return;
+	return params.skillsPrompt?.trim() ? [
+		"## OpenClaw Skills",
+		"",
+		params.skillsPrompt.trim()
+	].join("\n") : void 0;
+}
+function prependCodexOpenClawPromptContext(prompt, context, options = {}) {
 	const { deliveryHint, prompt: promptWithoutDeliveryHint } = splitLeadingCodexDeliveryHint(prompt);
+	if (!context?.trim() && (!deliveryHint || options.preservePromptWithoutContext)) return prompt;
 	const promptSection = promptWithoutDeliveryHint.startsWith("OpenClaw assembled context for this turn:") ? promptWithoutDeliveryHint : ["Current user request:", promptWithoutDeliveryHint].join("\n");
 	const deliverySection = deliveryHint ? [
 		"OpenClaw delivery metadata:",
@@ -488,7 +463,7 @@ function prependCodexOpenClawPromptContext(prompt, context) {
 		deliveryHint
 	].join("\n") : void 0;
 	return [
-		context.trim(),
+		context?.trim(),
 		deliverySection,
 		promptSection
 	].filter(Boolean).join("\n\n");
@@ -550,11 +525,12 @@ function renderCodexWorkspaceCollaborationDeveloperInstructions(files) {
 	return renderCodexWorkspaceDeveloperInstructions({
 		files,
 		header: "## OpenClaw Agent Soul",
-		preamble: "OpenClaw loaded these workspace instruction files from the active agent workspace. They are the canonical definitions of who you are, how you think and work, and the human you work alongside. Internalize and follow them accordingly."
+		preamble: "OpenClaw loaded these workspace instruction files from the active agent workspace. They are the canonical definitions of who you are, how you think and work, and the human you work alongside. Internalize and follow them accordingly.",
+		wrapperTag: "AGENT_SOUL"
 	});
 }
 function renderCodexWorkspaceDeveloperInstructions(params) {
-	const { files, header, preamble } = params;
+	const { files, header, preamble, wrapperTag } = params;
 	if (files.length === 0) return;
 	const lines = [
 		header,
@@ -562,7 +538,9 @@ function renderCodexWorkspaceDeveloperInstructions(params) {
 		preamble,
 		""
 	];
+	if (wrapperTag) lines.push(`<${wrapperTag}>`, "");
 	for (const file of files) lines.push(`### ${file.path}`, "", file.content, "");
+	if (wrapperTag) lines.push(`</${wrapperTag}>`);
 	return lines.join("\n").trim();
 }
 function selectCodexWorkspaceHeartbeatReferenceFiles(contextFiles) {
@@ -594,7 +572,7 @@ function renderCodexWorkspaceMemoryReference(params) {
 	const lines = [
 		"## OpenClaw Workspace Memory",
 		"",
-		`MEMORY.md exists in the active agent workspace. OpenClaw does not paste its contents into native Codex turns; use ${(params.toolNames?.length ? params.toolNames : Array.from(CODEX_MEMORY_TOOL_NAMES)).join(" or ")} when durable memory is relevant and the tools are available.`,
+		`MEMORY.md exists in the active agent workspace as a memory file, not an instruction file. OpenClaw does not paste its contents into native Codex turns; use ${(params.toolNames?.length ? params.toolNames : Array.from(CODEX_MEMORY_TOOL_NAMES)).join(" or ")} when durable memory is relevant and the tools are available.`,
 		""
 	];
 	for (const file of params.files) lines.push(`- ${file.path}`);
@@ -825,6 +803,11 @@ function isReasoningItemCompletionNotification(notification) {
 	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
 	return item ? readString$6(item, "type") === "reasoning" : false;
 }
+function isAssistantCommentaryCompletionNotification(notification) {
+	if (!isJsonObject(notification.params) || notification.method !== "item/completed") return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	return Boolean(item && readString$6(item, "type") === "agentMessage" && readString$6(item, "phase") === "commentary");
+}
 function isRawReasoningCompletionNotification(notification) {
 	if (!isJsonObject(notification.params) || notification.method !== "rawResponseItem/completed") return false;
 	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
@@ -870,10 +853,21 @@ function isNativeToolProgressNotification(notification) {
 		default: return false;
 	}
 }
-function isRawAssistantCompletionNotification(notification) {
+function isNativeResponseStreamDeltaNotification(notification) {
+	return notification.method.startsWith("response.") && notification.method.endsWith(".delta");
+}
+function isFileChangePatchUpdatedNotification(notification) {
+	return notification.method === "item/fileChange/patchUpdated" && isJsonObject(notification.params);
+}
+function isRawAssistantProgressNotification(notification) {
 	if (notification.method !== "rawResponseItem/completed" || !isJsonObject(notification.params)) return false;
 	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
-	return Boolean(item && readString$6(item, "type") === "message" && readString$6(item, "role") === "assistant" && readString$6(item, "phase") !== "commentary" && readRawAssistantTextPreview(item));
+	return Boolean(item && readString$6(item, "type") === "message" && readString$6(item, "role") === "assistant" && readRawAssistantTextPreview(item));
+}
+function isRawAssistantCompletionNotification(notification) {
+	if (!isRawAssistantProgressNotification(notification) || !isJsonObject(notification.params)) return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	return Boolean(item && readString$6(item, "phase") !== "commentary");
 }
 function readRawAssistantTextPreview(item) {
 	if (readString$6(item, "role") !== "assistant" || !Array.isArray(item.content)) return;
@@ -964,67 +958,6 @@ function codexExecutionToolName(item) {
 function isNonEmptyString$1(value) {
 	return typeof value === "string" && value.length > 0;
 }
-const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
-const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
-const CODEX_POST_REASONING_SOURCE_REPLY_IDLE_TIMEOUT_MS = 5 * 6e4;
-const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
-function resolvePositiveIntegerTimeoutMs(value, fallbackMs) {
-	return resolveTimerTimeoutMs(value, resolveTimerTimeoutMs(fallbackMs, 1));
-}
-async function withCodexStartupTimeout(params) {
-	if (params.signal.aborted) throw new Error("codex app-server startup aborted");
-	let timeout;
-	let abortCleanup;
-	let timeoutError;
-	let timeoutCleanup;
-	try {
-		return await Promise.race([params.operation(), new Promise((_, reject) => {
-			const rejectOnce = (error) => {
-				if (timeout) {
-					clearTimeout(timeout);
-					timeout = void 0;
-				}
-				reject(error);
-			};
-			timeout = setTimeout(() => {
-				timeoutError = /* @__PURE__ */ new Error("codex app-server startup timed out");
-				timeoutCleanup = Promise.resolve(params.onTimeout?.()).then(() => void 0, () => void 0);
-				timeoutCleanup.finally(() => {
-					rejectOnce(timeoutError);
-				});
-			}, params.timeoutMs);
-			const abortListener = () => rejectOnce(/* @__PURE__ */ new Error("codex app-server startup aborted"));
-			params.signal.addEventListener("abort", abortListener, { once: true });
-			abortCleanup = () => params.signal.removeEventListener("abort", abortListener);
-		})]);
-	} catch (error) {
-		if (timeoutError) {
-			await timeoutCleanup;
-			throw timeoutError;
-		}
-		throw error;
-	} finally {
-		if (timeout) clearTimeout(timeout);
-		abortCleanup?.();
-	}
-}
-function resolveCodexStartupTimeoutMs(params) {
-	const timeoutFloorMs = resolvePositiveIntegerTimeoutMs(params.timeoutFloorMs, 100);
-	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
-	return Math.max(timeoutFloorMs, timeoutMs);
-}
-function resolveCodexTurnCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS);
-}
-function resolveCodexTurnAssistantCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS);
-}
-function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallbackMs) {
-	return resolvePositiveIntegerTimeoutMs(value, fallbackMs);
-}
-function resolveCodexTurnTerminalIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
-}
 //#endregion
 //#region extensions/codex/src/app-server/attempt-notification-state.ts
 function reportCodexExecutionNotification(params) {
@@ -1055,8 +988,9 @@ function applyCodexTurnNotificationState(params) {
 	const { notification, turnWatches } = params;
 	const isCurrentTurnNotification = isTurnNotification(notification.params, params.threadId, params.turnId);
 	const isTurnCompletion = notification.method === "turn/completed" && isCurrentTurnNotification;
+	const isNativeResponseStreamDelta = isNativeResponseStreamDeltaNotification(notification);
 	let turnCrossedToolHandoff = params.turnCrossedToolHandoff;
-	if (isCurrentTurnNotification) {
+	if (isCurrentTurnNotification && !isNativeResponseStreamDelta) {
 		turnWatches.touchActivity(`notification:${notification.method}`, {
 			details: describeNotificationActivity(notification),
 			attemptProgress: true
@@ -1070,25 +1004,37 @@ function applyCodexTurnNotificationState(params) {
 	const rawToolOutputCompletion = isRawToolOutputCompletionNotification(notification);
 	if (isCurrentTurnNotification && (rawToolOutputCompletion || isNativeToolProgressNotification(notification))) turnCrossedToolHandoff = true;
 	const assistantCompletionCanRelease = isAssistantCompletionReleaseNotification(notification, turnCrossedToolHandoff);
-	const postToolRawAssistantCompletionNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && isRawAssistantCompletionNotification(notification) && params.activeTurnItemIds.size === 0;
-	const rawResponseItemCompletedWithNoActiveItems = isCurrentTurnNotification && notification.method === "rawResponseItem/completed" && params.activeTurnItemIds.size === 0 && params.activeAppServerTurnRequests === 0 && !assistantCompletionCanRelease && !postToolRawAssistantCompletionNeedsTerminalGuard;
-	const shouldArmPostReasoningSourceReplyWatch = isCurrentTurnNotification && isReasoningItemCompletionNotification(notification) && params.activeTurnItemIds.size === 0 && params.sourceReplyDeliveryMode === "message_tool_only";
-	const shouldArmPostRawReasoningSourceReplyWatch = rawResponseItemCompletedWithNoActiveItems && isRawReasoningCompletionNotification(notification) && params.sourceReplyDeliveryMode === "message_tool_only";
-	const shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem = isCurrentTurnNotification && notification.method === "item/completed" && params.activeTurnItemIds.size === 0 && !trackedDynamicToolCompletion && !assistantCompletionCanRelease && !shouldArmPostReasoningSourceReplyWatch;
+	const postToolRawAssistantCompletionNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && isRawAssistantProgressNotification(notification) && params.activeTurnItemIds.size === 0;
+	const postToolPatchUpdateNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && isFileChangePatchUpdatedNotification(notification);
+	const rawResponseItemCompletedWithNoActiveItems = isCurrentTurnNotification && notification.method === "rawResponseItem/completed" && params.activeTurnItemIds.size === 0 && params.activeAppServerTurnRequests === 0 && !assistantCompletionCanRelease && !postToolRawAssistantCompletionNeedsTerminalGuard && !rawToolOutputCompletion;
+	const shouldArmNoToolPostProgressReplyWatch = isCurrentTurnNotification && !turnCrossedToolHandoff && params.activeTurnItemIds.size === 0 && (isReasoningItemCompletionNotification(notification) || isAssistantCommentaryCompletionNotification(notification));
+	const shouldArmNoToolPostRawProgressReplyWatch = !turnCrossedToolHandoff && rawResponseItemCompletedWithNoActiveItems && (isRawReasoningCompletionNotification(notification) || isRawAssistantProgressNotification(notification));
+	const shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem = isCurrentTurnNotification && notification.method === "item/completed" && params.activeTurnItemIds.size === 0 && !trackedDynamicToolCompletion && !assistantCompletionCanRelease && !shouldArmNoToolPostProgressReplyWatch;
+	const shouldUsePostToolContinuationWatch = turnCrossedToolHandoff && (postToolRawAssistantCompletionNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard || rawToolOutputCompletion || trackedDynamicToolCompletion || shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem);
+	const armPostToolContinuationWatch = () => {
+		turnWatches.armCompletionIdleWatch({ timeoutMs: params.postToolRawAssistantCompletionIdleTimeoutMs });
+		turnWatches.extendAttemptIdleWatch(params.postToolRawAssistantCompletionIdleTimeoutMs);
+	};
+	const armPostProgressReplyWatch = () => {
+		turnWatches.armCompletionIdleWatch({ timeoutMs: CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS });
+		turnWatches.extendAttemptIdleWatch(CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS);
+	};
 	if (isCurrentTurnNotification && notification.method === "error") {
 		if (isRetryableErrorNotification(notification.params)) turnWatches.disarmCompletionIdleWatch();
 		else turnWatches.armCompletionIdleWatch({ pinnedByTerminalError: true });
 		turnWatches.disarmAssistantCompletionIdleWatch();
 	} else if (isTurnCompletion) turnWatches.disarmAssistantCompletionIdleWatch();
 	else if (isCurrentTurnNotification && assistantCompletionCanRelease) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
-	else if (postToolRawAssistantCompletionNeedsTerminalGuard) turnWatches.armCompletionIdleWatch({ timeoutMs: params.postToolRawAssistantCompletionIdleTimeoutMs });
-	else if (shouldArmPostReasoningSourceReplyWatch || shouldArmPostRawReasoningSourceReplyWatch) turnWatches.armCompletionIdleWatch({ timeoutMs: CODEX_POST_REASONING_SOURCE_REPLY_IDLE_TIMEOUT_MS });
+	else if (postToolRawAssistantCompletionNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard) armPostToolContinuationWatch();
+	else if (shouldArmNoToolPostProgressReplyWatch || shouldArmNoToolPostRawProgressReplyWatch) armPostProgressReplyWatch();
+	else if (trackedDynamicToolCompletion) armPostToolContinuationWatch();
 	else if (unblockedAssistantCompletionRelease) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
-	else if (shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.armCompletionIdleWatch();
+	else if (shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) if (shouldUsePostToolContinuationWatch) armPostToolContinuationWatch();
+	else turnWatches.armCompletionIdleWatch();
 	else if (rawResponseItemCompletedWithNoActiveItems) turnWatches.armCompletionIdleWatch();
-	else if (isCurrentTurnNotification && rawToolOutputCompletion) turnWatches.armCompletionIdleWatch();
+	else if (isCurrentTurnNotification && rawToolOutputCompletion) armPostToolContinuationWatch();
 	else if (isCurrentTurnNotification && shouldDisarmAssistantCompletionIdleWatch(notification)) turnWatches.disarmAssistantCompletionIdleWatch();
-	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolRawAssistantCompletionNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmPostReasoningSourceReplyWatch && !shouldArmPostRawReasoningSourceReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
+	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !isNativeResponseStreamDelta && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolRawAssistantCompletionNeedsTerminalGuard && !postToolPatchUpdateNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmNoToolPostProgressReplyWatch && !shouldArmNoToolPostRawProgressReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
 	if (trackedDynamicToolCompletion) {
 		const itemId = readNotificationItemId(notification);
 		if (itemId) {
@@ -1120,7 +1066,8 @@ function hasCodexAppServerPotentialSideEffectEvidence(result) {
 }
 function buildCodexAppServerPromptTimeoutOutcome(params) {
 	const completionIdleTimeoutHadPotentialSideEffects = hasCodexAppServerPotentialSideEffectEvidence(params.result);
-	if (!params.turnCompletionIdleTimedOut || params.result.itemLifecycle.completedCount === 0 && !completionIdleTimeoutHadPotentialSideEffects) return;
+	const replayBlockedReason = resolveCodexAppServerReplayBlockedReason(params.result);
+	if (!params.turnCompletionIdleTimedOut || params.result.itemLifecycle.completedCount === 0 && !completionIdleTimeoutHadPotentialSideEffects && replayBlockedReason === void 0) return;
 	return {
 		message: completionIdleTimeoutHadPotentialSideEffects ? CODEX_APP_SERVER_MISSING_TERMINAL_EVENT_SIDE_EFFECT_USER_MESSAGE : CODEX_APP_SERVER_MISSING_TERMINAL_EVENT_USER_MESSAGE,
 		...completionIdleTimeoutHadPotentialSideEffects ? {
@@ -3013,9 +2960,16 @@ function createCodexAttemptTurnWatchController(params) {
 	let completionLastActivityAt = Date.now();
 	let completionLastActivityReason = "startup";
 	let completionLastActivityDetails;
+	let attemptIdleTimeoutOverrideMs;
 	let attemptLastProgressAt = Date.now();
 	let attemptLastProgressReason = "startup";
 	let attemptLastProgressDetails;
+	const turnCompletionIdleTimeoutMs = resolveTimerTimeoutMs(params.turnCompletionIdleTimeoutMs, 1);
+	const turnAssistantCompletionIdleTimeoutMs = resolveTimerTimeoutMs(params.turnAssistantCompletionIdleTimeoutMs, 1);
+	const turnAttemptIdleTimeoutMs = resolveTimerTimeoutMs(params.turnAttemptIdleTimeoutMs, 1);
+	const turnTerminalIdleTimeoutMs = resolveTimerTimeoutMs(params.turnTerminalIdleTimeoutMs, 1);
+	const interruptTimeoutMs = resolveTimerTimeoutMs(params.interruptTimeoutMs, 1);
+	const resolveWatchTimeoutMs = (timeoutMs) => resolveTimerTimeoutMs(timeoutMs, 1);
 	const clearCompletionIdleTimer = () => {
 		if (completionIdleTimer) {
 			clearTimeout(completionIdleTimer);
@@ -3050,8 +3004,7 @@ function createCodexAttemptTurnWatchController(params) {
 		clearCompletionIdleTimer();
 		if (params.isCompleted() || params.signal.aborted || !completionIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0) return;
 		const elapsedMs = Math.max(0, Date.now() - completionLastActivityAt);
-		const timeoutMs = completionIdleTimeoutOverrideMs ?? params.turnCompletionIdleTimeoutMs;
-		const delayMs = Math.max(1, timeoutMs - elapsedMs);
+		const delayMs = Math.max(1, (completionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs) - elapsedMs);
 		completionIdleTimer = setTimeout(fireCompletionIdleTimeout, delayMs);
 		completionIdleTimer.unref?.();
 	}
@@ -3059,7 +3012,7 @@ function createCodexAttemptTurnWatchController(params) {
 		clearAssistantCompletionIdleTimer();
 		if (params.isCompleted() || params.signal.aborted || !assistantCompletionIdleWatchArmed) return;
 		const elapsedMs = Math.max(0, Date.now() - assistantCompletionLastActivityAt);
-		const delayMs = Math.max(1, params.turnAssistantCompletionIdleTimeoutMs - elapsedMs);
+		const delayMs = Math.max(1, turnAssistantCompletionIdleTimeoutMs - elapsedMs);
 		assistantCompletionIdleTimer = setTimeout(fireAssistantCompletionIdleRelease, delayMs);
 		assistantCompletionIdleTimer.unref?.();
 	}
@@ -3067,7 +3020,7 @@ function createCodexAttemptTurnWatchController(params) {
 		clearAttemptIdleTimer();
 		if (params.isCompleted() || params.signal.aborted || !attemptIdleWatchArmed) return;
 		const elapsedMs = Math.max(0, Date.now() - attemptLastProgressAt);
-		const delayMs = Math.max(1, params.turnAttemptIdleTimeoutMs - elapsedMs);
+		const delayMs = Math.max(1, (attemptIdleTimeoutOverrideMs ?? turnAttemptIdleTimeoutMs) - elapsedMs);
 		attemptIdleTimer = setTimeout(fireAttemptIdleTimeout, delayMs);
 		attemptIdleTimer.unref?.();
 	}
@@ -3075,7 +3028,7 @@ function createCodexAttemptTurnWatchController(params) {
 		clearTerminalIdleTimer();
 		if (params.isCompleted() || params.signal.aborted || !terminalIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0) return;
 		const elapsedMs = Math.max(0, Date.now() - completionLastActivityAt);
-		const delayMs = Math.max(1, params.turnTerminalIdleTimeoutMs - elapsedMs);
+		const delayMs = Math.max(1, turnTerminalIdleTimeoutMs - elapsedMs);
 		terminalIdleTimer = setTimeout(fireTerminalIdleTimeout, delayMs);
 		terminalIdleTimer.unref?.();
 	}
@@ -3084,6 +3037,14 @@ function createCodexAttemptTurnWatchController(params) {
 		scheduleCompletionIdleWatch();
 		scheduleTerminalIdleWatch();
 	}
+	function recordAttemptProgress(reason, options) {
+		attemptIdleTimeoutOverrideMs = options?.attemptTimeoutMs !== void 0 ? resolveWatchTimeoutMs(options.attemptTimeoutMs) : void 0;
+		attemptLastProgressAt = completionLastActivityAt;
+		attemptLastProgressReason = reason;
+		attemptLastProgressDetails = options?.details;
+		params.onAttemptProgress(reason, options?.details);
+		scheduleAttemptIdleWatch();
+	}
 	function fireAssistantCompletionIdleRelease() {
 		if (params.isCompleted() || params.signal.aborted || !assistantCompletionIdleWatchArmed) return;
 		if (params.getActiveAppServerTurnRequests() > 0 || params.getActiveTurnItemCount() > 0) {
@@ -3091,7 +3052,7 @@ function createCodexAttemptTurnWatchController(params) {
 			return;
 		}
 		const idleMs = Math.max(0, Date.now() - assistantCompletionLastActivityAt);
-		if (idleMs < params.turnAssistantCompletionIdleTimeoutMs) {
+		if (idleMs < turnAssistantCompletionIdleTimeoutMs) {
 			scheduleAssistantCompletionIdleWatch();
 			return;
 		}
@@ -3103,20 +3064,20 @@ function createCodexAttemptTurnWatchController(params) {
 			threadId: params.threadId,
 			turnId,
 			idleMs,
-			timeoutMs: params.turnAssistantCompletionIdleTimeoutMs,
+			timeoutMs: turnAssistantCompletionIdleTimeoutMs,
 			...assistantCompletionLastActivityDetails
 		});
 		embeddedAgentLog.warn("codex app-server turn released after completed assistant item without terminal event", {
 			threadId: params.threadId,
 			turnId,
 			idleMs,
-			timeoutMs: params.turnAssistantCompletionIdleTimeoutMs,
+			timeoutMs: turnAssistantCompletionIdleTimeoutMs,
 			...assistantCompletionLastActivityDetails
 		});
 		if (turnId) params.onInterruptTurn({
 			threadId: params.threadId,
 			turnId,
-			timeoutMs: params.interruptTimeoutMs
+			timeoutMs: interruptTimeoutMs
 		});
 		params.onCompleted();
 		params.onResolveCompletion();
@@ -3124,14 +3085,15 @@ function createCodexAttemptTurnWatchController(params) {
 	function fireAttemptIdleTimeout() {
 		if (params.isCompleted() || params.signal.aborted || !attemptIdleWatchArmed) return;
 		const idleMs = Math.max(0, Date.now() - attemptLastProgressAt);
-		if (idleMs < params.turnAttemptIdleTimeoutMs) {
+		const timeoutMs = attemptIdleTimeoutOverrideMs ?? turnAttemptIdleTimeoutMs;
+		if (idleMs < timeoutMs) {
 			scheduleAttemptIdleWatch();
 			return;
 		}
 		const timeout = {
 			kind: "progress",
 			idleMs,
-			timeoutMs: params.turnAttemptIdleTimeoutMs,
+			timeoutMs,
 			lastActivityReason: attemptLastProgressReason,
 			details: attemptLastProgressDetails
 		};
@@ -3157,7 +3119,7 @@ function createCodexAttemptTurnWatchController(params) {
 	}
 	function fireCompletionIdleTimeout() {
 		if (params.isCompleted() || params.isTerminalTurnNotificationQueued() || params.signal.aborted || !completionIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0) return;
-		const timeoutMs = completionIdleTimeoutOverrideMs ?? params.turnCompletionIdleTimeoutMs;
+		const timeoutMs = completionIdleTimeoutOverrideMs ?? turnCompletionIdleTimeoutMs;
 		const idleMs = Math.max(0, Date.now() - completionLastActivityAt);
 		if (idleMs < timeoutMs) {
 			scheduleCompletionIdleWatch();
@@ -3193,14 +3155,14 @@ function createCodexAttemptTurnWatchController(params) {
 	function fireTerminalIdleTimeout() {
 		if (params.isCompleted() || params.isTerminalTurnNotificationQueued() || params.signal.aborted || !terminalIdleWatchArmed || params.getActiveAppServerTurnRequests() > 0) return;
 		const idleMs = Math.max(0, Date.now() - completionLastActivityAt);
-		if (idleMs < params.turnTerminalIdleTimeoutMs) {
+		if (idleMs < turnTerminalIdleTimeoutMs) {
 			scheduleTerminalIdleWatch();
 			return;
 		}
 		const timeout = {
 			kind: "terminal",
 			idleMs,
-			timeoutMs: params.turnTerminalIdleTimeoutMs,
+			timeoutMs: turnTerminalIdleTimeoutMs,
 			lastActivityReason: completionLastActivityReason,
 			details: completionLastActivityDetails
 		};
@@ -3239,7 +3201,7 @@ function createCodexAttemptTurnWatchController(params) {
 		armCompletionIdleWatch: (options) => {
 			completionIdleWatchArmed = true;
 			completionIdleWatchPinnedByTerminalError = options?.pinnedByTerminalError === true;
-			completionIdleTimeoutOverrideMs = options?.timeoutMs !== void 0 ? Math.max(1, Math.floor(options.timeoutMs)) : void 0;
+			completionIdleTimeoutOverrideMs = options?.timeoutMs !== void 0 ? resolveWatchTimeoutMs(options.timeoutMs) : void 0;
 			scheduleCompletionIdleWatch();
 		},
 		disarmCompletionIdleWatch: () => {
@@ -3264,12 +3226,7 @@ function createCodexAttemptTurnWatchController(params) {
 			completionLastActivityReason = reason;
 			completionLastActivityDetails = options?.details;
 			completionIdleTimeoutOverrideMs = void 0;
-			if (options?.attemptProgress) {
-				attemptLastProgressAt = completionLastActivityAt;
-				attemptLastProgressReason = reason;
-				attemptLastProgressDetails = options.details;
-				params.onAttemptProgress(reason, options.details);
-			}
+			if (options?.attemptProgress) recordAttemptProgress(reason, options);
 			params.onProgressDiagnostic(reason);
 			if (options?.arm) {
 				completionIdleWatchArmed = true;
@@ -3277,9 +3234,15 @@ function createCodexAttemptTurnWatchController(params) {
 			}
 			scheduleProgressWatches();
 		},
-		noteNotificationReceived: (method) => {
+		noteNotificationReceived: (method, options) => {
 			completionLastActivityAt = Date.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,
@@ -3348,7 +3311,7 @@ async function handleDynamicToolCallWithTimeout(params) {
 	let resolveAbort;
 	const abortFromRun = () => {
 		const message = "OpenClaw dynamic tool call aborted.";
-		controller.abort(params.signal.reason ?? new Error(message));
+		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
 		resolveAbort?.(failedDynamicToolResponse(message, { sideEffectEvidence: true }));
 	};
 	const abortPromise = new Promise((resolve) => {
@@ -3428,6 +3391,9 @@ function toCodexDynamicToolProgressResponse(response, protocolResponse) {
 function shouldReleaseTurnAfterTerminalDynamicTool(state) {
 	return !state.completed && !state.aborted && state.responseSuccess && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && state.activeTurnItemIdsCount === 0 && state.pendingOpenClawDynamicToolCompletionIdsCount === 0;
 }
+function shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response) {
+	return response.asyncStarted !== true;
+}
 function resolveTerminalDynamicToolBatchAction(state) {
 	if (state.activeAppServerTurnRequests > 0 || state.activeTurnItemIdsCount > 0 || state.pendingOpenClawDynamicToolCompletionIdsCount > 0) return "wait";
 	if (state.currentTurnHadNonTerminalDynamicToolResult) return "clear-nonterminal-batch";
@@ -3486,15 +3452,14 @@ function clampDynamicToolTimeoutMs(timeoutMs) {
 //#region extensions/codex/src/app-server/local-runtime-attribution.ts
 const OPENAI_PROVIDER_ID = "openai";
 const OPENAI_RESPONSES_API = "openai-responses";
-const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
-const OPENAI_CODEX_RESPONSES_API = "openai-codex-responses";
+const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
 function normalizeRuntimeId(value) {
 	return value?.trim().toLowerCase() ?? "";
 }
 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_CODEX_PROVIDER_ID,
+		provider: OPENAI_PROVIDER_ID,
 		api: OPENAI_CODEX_RESPONSES_API
 	};
 	return {
@@ -3754,6 +3719,7 @@ async function mirrorCodexAppServerTranscript(params) {
 	for (const update of appendedUpdates) emitSessionTranscriptUpdate({
 		sessionFile: params.sessionFile,
 		...params.sessionKey ? { sessionKey: params.sessionKey } : {},
+		...params.agentId ? { agentId: params.agentId } : {},
 		message: update.message,
 		messageId: update.messageId,
 		messageSeq: update.messageSeq
@@ -3826,6 +3792,9 @@ const CODEX_PROMPT_TOTAL_INPUT_KEYS = [
 ];
 const MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM = 20;
 const TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS = 12e3;
+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",
@@ -3871,6 +3840,8 @@ var CodexAppServerEventProjector = class {
 		this.toolTranscriptResultIds = /* @__PURE__ */ new Set();
 		this.transcriptToolProgressCallIds = /* @__PURE__ */ new Set();
 		this.nativeGeneratedMediaUrls = /* @__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;
@@ -3936,7 +3907,7 @@ var CodexAppServerEventProjector = class {
 				await this.handleTurnCompleted(params);
 				break;
 			case "rawResponseItem/completed":
-				this.handleRawResponseItemCompleted(params);
+				await this.handleRawResponseItemCompleted(params);
 				break;
 			case "error":
 				if (readBooleanAlias(params, ["willRetry", "will_retry"]) === true) break;
@@ -3967,7 +3938,7 @@ var CodexAppServerEventProjector = class {
 			turnCompleted: Boolean(this.completedTurn)
 		});
 		const toolMetas = [...this.toolMetas.values()];
-		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || (toolTelemetry.successfulCronAdds ?? 0) > 0 || this.sideEffectingToolItemIds.size > 0 || this.sideEffectingDynamicToolCallIds.size > 0;
+		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,
@@ -4388,9 +4359,11 @@ var CodexAppServerEventProjector = class {
 			text: formatToolOutput(toolName, void 0, reachedLimit ? `${chunk}\n...(truncated)...` : chunk)
 		});
 	}
-	handleRawResponseItemCompleted(params) {
+	async handleRawResponseItemCompleted(params) {
 		const item = isJsonObject(params.item) ? params.item : void 0;
-		if (!item || readString$5(item, "role") !== "assistant") return;
+		if (!item) return;
+		await this.recordRawGeneratedImageMedia(item);
+		if (readString$5(item, "role") !== "assistant") return;
 		const text = extractRawAssistantText(item);
 		if (!text) return;
 		const itemId = readString$5(item, "id") ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
@@ -4406,7 +4379,56 @@ var CodexAppServerEventProjector = class {
 	recordNativeGeneratedMedia(item) {
 		if (item?.type !== "imageGeneration") return;
 		const savedPath = readItemString(item, "savedPath")?.trim();
-		if (savedPath) this.nativeGeneratedMediaUrls.add(savedPath);
+		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
+			});
+		} catch (error) {
+			embeddedAgentLog.warn("codex app-server raw image generation result save failed", {
+				itemId,
+				error
+			});
+		}
+	}
+	recordNativeGeneratedMediaUrl(params) {
+		if (this.nativeGeneratedMediaUrlsByItemId.has(params.itemId)) {
+			this.nativeGeneratedMediaItemIds.add(params.itemId);
+			return;
+		}
+		this.nativeGeneratedMediaUrlsByItemId.set(params.itemId, params.mediaUrl);
+		this.nativeGeneratedMediaUrls.add(params.mediaUrl);
+		this.nativeGeneratedMediaItemIds.add(params.itemId);
 	}
 	buildToolMediaUrls(toolTelemetry) {
 		const mediaUrls = new Set(toolTelemetry.toolMediaUrls?.map((url) => url.trim()).filter(Boolean) ?? []);
@@ -4617,7 +4639,7 @@ var CodexAppServerEventProjector = class {
 		this.afterToolCallObservedItemIds.add(item.id);
 		const result = itemToolResult(item).result;
 		const error = itemToolError(item, status, this.toolResultOutputTextByItem);
-		const startedAt = typeof item.durationMs === "number" ? Date.now() - Math.max(0, item.durationMs) : void 0;
+		const startedAt = resolveStartedAtFromDurationMs(item.durationMs);
 		const hookParams = {
 			toolName: name,
 			toolCallId: item.id,
@@ -4833,7 +4855,7 @@ var CodexAppServerEventProjector = class {
 				type: "text",
 				text
 			}],
-			api: attribution.api ?? "openai-codex-responses",
+			api: attribution.api ?? "openai-chatgpt-responses",
 			provider: attribution.provider,
 			model: this.params.modelId,
 			usage,
@@ -4850,7 +4872,7 @@ var CodexAppServerEventProjector = class {
 				type: "text",
 				text: `${title}:\n${text}`
 			}],
-			api: attribution.api ?? "openai-codex-responses",
+			api: attribution.api ?? "openai-chatgpt-responses",
 			provider: attribution.provider,
 			model: this.params.modelId,
 			usage: ZERO_USAGE,
@@ -4870,7 +4892,7 @@ var CodexAppServerEventProjector = class {
 				arguments: args,
 				input: args
 			}],
-			api: attribution.api ?? "openai-codex-responses",
+			api: attribution.api ?? "openai-chatgpt-responses",
 			provider: attribution.provider,
 			model: this.params.modelId,
 			usage: ZERO_USAGE,
@@ -4920,6 +4942,30 @@ 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;
@@ -4946,6 +4992,10 @@ 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;
@@ -6349,6 +6399,9 @@ function unrefTimer(timer) {
 //#endregion
 //#region extensions/codex/src/app-server/startup-binding.ts
 const CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS = 3e5;
+const CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS = 2e4;
+const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_TOKENS = 8e3;
+const CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_RATIO = .5;
 const CODEX_APP_SERVER_BYTE_UNITS = {
 	b: 1,
 	k: 1024,
@@ -6364,6 +6417,7 @@ const CODEX_APP_SERVER_BYTE_UNITS = {
 	tb: 1024 * 1024 * 1024 * 1024,
 	tib: 1024 * 1024 * 1024 * 1024
 };
+const codexSessionRecordCache = /* @__PURE__ */ new Map();
 function parseCodexAppServerByteLimit(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
 	if (typeof value !== "string") return;
@@ -6419,22 +6473,44 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 }
 async function readCodexSessionRecordForSessionFile(sessionFile) {
 	const sessionsFile = path.join(path.dirname(sessionFile), "sessions.json");
+	const resolvedSessionFile = path.resolve(sessionFile);
+	let stat;
+	try {
+		stat = await fs.stat(sessionsFile);
+	} catch {
+		codexSessionRecordCache.delete(resolvedSessionFile);
+		return;
+	}
+	const cached = codexSessionRecordCache.get(resolvedSessionFile);
+	if (cached?.sessionsFile === sessionsFile && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.record;
 	let store;
 	try {
 		store = JSON.parse(await fs.readFile(sessionsFile, "utf8"));
 	} catch {
+		codexSessionRecordCache.delete(resolvedSessionFile);
 		return;
 	}
-	if (!isJsonObject(store)) return;
-	const resolvedSessionFile = path.resolve(sessionFile);
+	if (!isJsonObject(store)) {
+		codexSessionRecordCache.delete(resolvedSessionFile);
+		return;
+	}
+	let found;
 	for (const [sessionKey, record] of Object.entries(store)) {
 		if (!isJsonObject(record) || typeof record.sessionFile !== "string") continue;
 		if (path.resolve(record.sessionFile) !== resolvedSessionFile) continue;
-		return {
+		found = {
 			sessionKey,
 			...record
 		};
+		break;
 	}
+	codexSessionRecordCache.set(resolvedSessionFile, {
+		sessionsFile,
+		mtimeMs: stat.mtimeMs,
+		size: stat.size,
+		record: found
+	});
+	return found;
 }
 async function readCodexAppServerRolloutTokenSnapshot(file) {
 	let handle;
@@ -6478,52 +6554,75 @@ function readCodexAppServerRolloutTokenSnapshotLine(line) {
 		return;
 	}
 }
-function resolveCodexAppServerNativeThreadTokenFuse(modelContextWindow) {
-	return modelContextWindow ?? CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS;
+function toNonNegativeInt(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return;
+	return Math.floor(value);
+}
+function readCompactionConfig(config) {
+	return isJsonObject(config?.agents?.defaults?.compaction) ? config.agents.defaults.compaction : void 0;
+}
+function resolveCodexAppServerNativeThreadReserveTokens(config) {
+	const compaction = readCompactionConfig(config);
+	const reserveTokens = toNonNegativeInt(compaction?.reserveTokens);
+	const reserveTokensFloor = toNonNegativeInt(compaction?.reserveTokensFloor);
+	if (reserveTokens !== void 0) return Math.max(reserveTokens, reserveTokensFloor ?? CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS);
+	return reserveTokensFloor ?? CODEX_APP_SERVER_NATIVE_THREAD_DEFAULT_RESERVE_TOKENS;
+}
+function resolveCodexAppServerNativeThreadTokenFuse(params) {
+	const projectedTurnTokens = typeof params.projectedTurnTokens === "number" && Number.isFinite(params.projectedTurnTokens) && params.projectedTurnTokens > 0 ? Math.floor(params.projectedTurnTokens) : 0;
+	const contextWindow = params.modelContextWindow ?? CODEX_APP_SERVER_NATIVE_THREAD_FALLBACK_MAX_TOKENS;
+	const minPromptBudget = Math.min(CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_TOKENS, Math.max(1, Math.floor(contextWindow * CODEX_APP_SERVER_NATIVE_THREAD_MIN_PROMPT_BUDGET_RATIO)));
+	const effectiveReserveTokens = Math.min(params.reserveTokens, Math.max(0, contextWindow - minPromptBudget));
+	return Math.max(1, contextWindow - effectiveReserveTokens - projectedTurnTokens);
 }
 function maxFiniteNumber(values) {
 	const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value));
 	if (nums.length === 0) return;
 	return Math.max(...nums);
 }
+function minFiniteNumber(values) {
+	const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+	if (nums.length === 0) return;
+	return Math.min(...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);
-	if (maxBytes !== void 0) {
-		const oversizedFiles = rolloutFiles.filter((file) => file.bytes >= maxBytes);
-		if (oversizedFiles.length > 0) {
-			embeddedAgentLog.warn("codex app-server native transcript exceeded active byte limit; starting a fresh thread", {
-				threadId: binding.threadId,
-				maxBytes,
-				files: oversizedFiles.map((file) => ({
-					path: file.path,
-					bytes: file.bytes
-				}))
-			});
-			await clearCodexAppServerBinding(params.sessionFile);
-			return;
+	const compaction = readCompactionConfig(params.config);
+	const shouldDeferByteGuard = compaction?.truncateAfterCompaction === true && params.contextEngineActive === true && hasContextEngineThreadBootstrapProjection(binding);
+	if (compaction?.truncateAfterCompaction === true && !shouldDeferByteGuard) {
+		const maxBytes = parseCodexAppServerByteLimit(compaction.maxActiveTranscriptBytes);
+		if (maxBytes !== void 0) {
+			const oversizedFiles = rolloutFiles.filter((file) => file.bytes >= maxBytes);
+			if (oversizedFiles.length > 0) {
+				embeddedAgentLog.warn("codex app-server native transcript exceeded active byte limit; starting a fresh thread", {
+					threadId: binding.threadId,
+					maxBytes,
+					files: oversizedFiles.map((file) => ({
+						path: file.path,
+						bytes: file.bytes
+					}))
+				});
+				await clearCodexAppServerBinding(params.sessionFile);
+				return;
+			}
 		}
 	}
 	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 sessionModelContextWindow = typeof sessionRecord?.contextTokens === "number" && Number.isFinite(sessionRecord.contextTokens) && sessionRecord.contextTokens > 0 ? Math.floor(sessionRecord.contextTokens) : void 0;
+	const reserveTokens = resolveCodexAppServerNativeThreadReserveTokens(params.config);
+	const maxTokens = resolveCodexAppServerNativeThreadTokenFuse({
+		modelContextWindow: minFiniteNumber([nativeModelContextWindow, sessionModelContextWindow]),
+		reserveTokens,
+		projectedTurnTokens: params.projectedTurnTokens
+	});
 	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 >= maxTokens) {
@@ -6533,11 +6632,24 @@ async function rotateOversizedCodexAppServerStartupBinding(params) {
 			sessionKey: sessionRecord?.sessionKey,
 			sessionTokens,
 			nativeTokens,
-			nativeModelContextWindow
+			nativeModelContextWindow,
+			sessionModelContextWindow,
+			reserveTokens,
+			projectedTurnTokens: params.projectedTurnTokens
 		});
 		await clearCodexAppServerBinding(params.sessionFile);
 		return;
 	}
+	if (compaction?.truncateAfterCompaction !== true) return binding;
+	if (shouldDeferByteGuard) {
+		embeddedAgentLog.debug("codex app-server deferring native transcript byte guard for context-engine thread bootstrap", {
+			threadId: binding.threadId,
+			engineId: binding.contextEngine?.engineId,
+			epoch: binding.contextEngine?.projection?.epoch,
+			fingerprint: binding.contextEngine?.projection?.fingerprint
+		});
+		return binding;
+	}
 	return binding;
 }
 //#endregion
@@ -7056,7 +7168,12 @@ function readRequestId(record) {
 //#endregion
 //#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 ensuredCodexWorkspaceDirs = /* @__PURE__ */ new Set();
+function estimateCodexAppServerProjectedTurnTokens(params) {
+	const inputChars = params.prompt.length + (params.developerInstructions?.length ?? 0);
+	return Math.max(1, Math.ceil(inputChars / CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN));
+}
 async function ensureCodexWorkspaceDirOnce(workspaceDir) {
 	const normalized = path.resolve(workspaceDir);
 	if (ensuredCodexWorkspaceDirs.has(normalized)) {
@@ -7202,8 +7319,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		sessionKey: contextSessionKey,
 		...startupAuthProfileId ? { authProfileId: startupAuthProfileId } : {}
 	};
-	let activeSessionId = params.sessionId;
-	let activeSessionFile = params.sessionFile;
+	const activeSessionId = params.sessionId;
+	const activeSessionFile = params.sessionFile;
 	const buildActiveRunAttemptParams = () => ({
 		...runtimeParams,
 		sessionId: activeSessionId,
@@ -7363,17 +7480,27 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	const baseDeveloperInstructions = joinPresentSections(buildDeveloperInstructions(params, { dynamicTools: toolBridge.availableSpecs }), workspaceBootstrapContext.developerInstructions);
 	const openClawPromptContext = buildCodexOpenClawPromptContext({
 		params,
-		skillsPrompt: params.skillsSnapshot?.prompt,
-		workspacePromptContext: workspaceBootstrapContext.promptContext,
-		workspaceMemoryReference: renderCodexWorkspaceMemoryReference({
-			files: workspaceBootstrapContext.memoryReferenceFiles ?? [],
-			toolNames: workspaceBootstrapContext.memoryToolNames
-		})
+		workspacePromptContext: workspaceBootstrapContext.promptContext
+	});
+	const skillsCollaborationInstructions = renderCodexSkillsCollaborationInstructions({
+		attempt: params,
+		skillsPrompt: params.skillsSnapshot?.prompt
 	});
 	let promptText = params.prompt;
 	let developerInstructions = baseDeveloperInstructions;
 	let prePromptMessageCount = historyMessages.length;
 	let contextEngineProjection;
+	let precomputedStaleBindingContinuityProjectionApplied = false;
+	let staleBindingContinuityForcedFreshStart = false;
+	const applyFreshThreadContinuityProjection = () => {
+		const projection = projectContextEngineAssemblyForCodex({
+			assembledMessages: historyMessages,
+			originalHistoryMessages: historyMessages,
+			prompt: params.prompt
+		});
+		promptText = projection.promptText;
+		prePromptMessageCount = projection.prePromptMessageCount;
+	};
 	const applyActiveContextEngineProjection = async (decisionStartupBinding) => {
 		if (!activeContextEngine) return;
 		const assembled = await assembleHarnessContextEngine({
@@ -7435,41 +7562,125 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	} catch (assembleErr) {
 		embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 	}
-	else if (shouldProjectMirroredHistoryForCodexStart({
-		startupBinding,
-		dynamicToolsFingerprint: codexDynamicToolsFingerprint(toolBridge.specs),
-		historyMessages,
-		forceProject: !nativeToolSurfaceEnabled
-	})) {
-		const projection = projectContextEngineAssemblyForCodex({
-			assembledMessages: historyMessages,
-			originalHistoryMessages: historyMessages,
-			prompt: params.prompt
-		});
-		promptText = projection.promptText;
-		prePromptMessageCount = projection.prePromptMessageCount;
-	}
+	const codexModelInputHistoryMessages = [];
 	const buildPromptFromCurrentInputs = () => resolveAgentHarnessBeforePromptBuildResult({
 		prompt: prependCurrentInboundContext(promptText, params.currentInboundContext),
 		developerInstructions,
-		messages: historyMessages,
+		messages: codexModelInputHistoryMessages,
 		ctx: hookContext
 	});
 	let promptBuild = await buildPromptFromCurrentInputs();
-	const decorateCodexTurnPromptText = (prompt) => prependCodexOpenClawPromptContext(prompt, openClawPromptContext);
+	const decorateCodexTurnPromptText = (prompt) => prependCodexOpenClawPromptContext(prompt, openClawPromptContext, { preservePromptWithoutContext: params.bootstrapContextMode === "lightweight" && params.bootstrapContextRunKind === "cron" });
 	let codexTurnPromptText = decorateCodexTurnPromptText(promptBuild.prompt);
 	const buildCodexTurnCollaborationDeveloperInstructions = () => buildTurnCollaborationMode(params, {
 		turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
+		skillsCollaborationInstructions,
+		memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
 		heartbeatCollaborationInstructions: workspaceBootstrapContext.heartbeatCollaborationInstructions
 	}).settings.developer_instructions ?? void 0;
 	const buildRenderedCodexDeveloperInstructions = () => joinPresentSections(promptBuild.developerInstructions, buildCodexTurnCollaborationDeveloperInstructions());
+	const rebuildCodexPromptBuildFromCurrentProjection = async () => {
+		promptBuild = await buildPromptFromCurrentInputs();
+		codexTurnPromptText = decorateCodexTurnPromptText(promptBuild.prompt);
+	};
+	const rebuildCodexTurnPromptTextFromCurrentProjection = async () => {
+		const nextPromptBuild = await buildPromptFromCurrentInputs();
+		promptBuild = {
+			...promptBuild,
+			prompt: nextPromptBuild.prompt
+		};
+		codexTurnPromptText = decorateCodexTurnPromptText(nextPromptBuild.prompt);
+	};
+	const selectNewerVisibleHistoryAfterBinding = (binding) => {
+		const bindingUpdatedAt = Date.parse(binding.updatedAt);
+		if (!Number.isFinite(bindingUpdatedAt)) return [];
+		return historyMessages.filter((message) => {
+			if (message.role !== "user" && message.role !== "assistant") return false;
+			const record = message;
+			const idempotencyKey = record.idempotencyKey;
+			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 (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;
+		});
+	};
+	const applyResumeStaleBindingContinuityProjection = (binding) => {
+		const newerVisibleMessages = selectNewerVisibleHistoryAfterBinding(binding);
+		if (newerVisibleMessages.length === 0) return false;
+		const projection = projectContextEngineAssemblyForCodex({
+			assembledMessages: newerVisibleMessages,
+			originalHistoryMessages: historyMessages,
+			prompt: params.prompt
+		});
+		promptText = projection.promptText;
+		prePromptMessageCount = projection.prePromptMessageCount;
+		return true;
+	};
+	const precomputeNoContextEngineStaleBindingProjection = (binding) => {
+		precomputedStaleBindingContinuityProjectionApplied = false;
+		staleBindingContinuityForcedFreshStart = false;
+		if (activeContextEngine || !binding?.threadId) return false;
+		const projected = applyResumeStaleBindingContinuityProjection(binding);
+		precomputedStaleBindingContinuityProjectionApplied = projected;
+		return projected;
+	};
+	const applyNoContextEngineContinuityProjection = (action, binding) => {
+		if (activeContextEngine || !historyMessages.some((message) => message.role === "user")) return false;
+		if (action === "resumed" && precomputedStaleBindingContinuityProjectionApplied) return true;
+		if (action === "started" && staleBindingContinuityForcedFreshStart) return true;
+		if (action === "resumed" && binding) return applyResumeStaleBindingContinuityProjection(binding);
+		if (action === "started") {
+			applyFreshThreadContinuityProjection();
+			return true;
+		}
+		return false;
+	};
+	if (precomputeNoContextEngineStaleBindingProjection(startupBinding)) await rebuildCodexPromptBuildFromCurrentProjection();
+	const rotateStartupBindingForProjectedTurn = async () => {
+		if (!startupBinding?.threadId) return;
+		const previousThreadId = startupBinding.threadId;
+		const projectedTurnTokens = estimateCodexAppServerProjectedTurnTokens({
+			prompt: codexTurnPromptText,
+			developerInstructions: buildRenderedCodexDeveloperInstructions()
+		});
+		startupBinding = await rotateOversizedCodexAppServerStartupBinding({
+			binding: startupBinding,
+			sessionFile: params.sessionFile,
+			agentDir,
+			codexHome: appServer.start.env?.CODEX_HOME,
+			config: params.config,
+			contextEngineActive: Boolean(activeContextEngine),
+			projectedTurnTokens
+		});
+		if (startupBinding?.threadId) return;
+		staleBindingContinuityForcedFreshStart = precomputedStaleBindingContinuityProjectionApplied;
+		if (activeContextEngine) {
+			contextEngineProjection = void 0;
+			try {
+				await applyActiveContextEngineProjection(void 0);
+			} catch (assembleErr) {
+				embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
+			}
+		}
+		await rebuildCodexPromptBuildFromCurrentProjection();
+		embeddedAgentLog.info("codex app-server rebuilt turn prompt after native thread rotation", {
+			sessionId: params.sessionId,
+			sessionKey: contextSessionKey,
+			previousThreadId,
+			promptChars: codexTurnPromptText.length,
+			developerInstructionChars: buildRenderedCodexDeveloperInstructions()?.length ?? 0
+		});
+	};
+	await rotateStartupBindingForProjectedTurn();
 	const systemPromptReport = buildCodexSystemPromptReport({
 		attempt: params,
 		sessionKey: contextSessionKey,
 		workspaceDir: effectiveWorkspace,
 		developerInstructions: buildRenderedCodexDeveloperInstructions(),
 		workspaceBootstrapContext,
-		skillsPrompt: openClawPromptContext ? params.skillsSnapshot?.prompt ?? "" : "",
+		skillsPrompt: skillsCollaborationInstructions ? params.skillsSnapshot?.prompt ?? "" : "",
 		tools: toolBridge.availableSpecs
 	});
 	const trajectoryRecorder = createCodexTrajectoryRecorder({
@@ -7582,6 +7793,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
 		throw error;
 	}
+	if (applyNoContextEngineContinuityProjection(thread.lifecycle.action, thread)) await rebuildCodexTurnPromptTextFromCurrentProjection();
 	trajectoryRecorder?.recordEvent("session.started", {
 		sessionFile: params.sessionFile,
 		threadId: thread.threadId,
@@ -7592,19 +7804,16 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	recordCodexTrajectoryContext(trajectoryRecorder, {
 		attempt: params,
 		cwd: effectiveCwd,
-		developerInstructions: promptBuild.developerInstructions,
+		developerInstructions: buildRenderedCodexDeveloperInstructions(),
 		prompt: codexTurnPromptText,
 		tools: toolBridge.availableSpecs
 	});
-	let projector;
-	let turnId;
 	const pendingNotifications = [];
-	let userInputBridge;
-	let steeringQueue;
 	let completed = false;
 	let terminalTurnNotificationQueued = false;
 	let timedOut = false;
 	let turnCompletionIdleTimedOut = false;
+	let turnWatchTimeoutKind;
 	let turnCompletionIdleTimeoutMessage;
 	let clientClosedPromptError;
 	let clientClosedAbort = false;
@@ -7629,6 +7838,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	let pendingTerminalDynamicToolRelease;
 	let terminalDynamicToolReleaseCheckScheduled = false;
 	let currentTurnHadNonTerminalDynamicToolResult = false;
+	const turnIdRef = {};
+	const projectorRef = {};
+	const userInputBridgeRef = {};
+	const steeringQueueRef = {};
 	const renewNativeHookRelayForTurnProgress = () => {
 		if (!nativeHookRelay || options.nativeHookRelay?.ttlMs !== void 0) return;
 		const now = Date.now();
@@ -7646,7 +7859,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	const turnWatches = createCodexAttemptTurnWatchController({
 		threadId: thread.threadId,
 		signal: runAbortController.signal,
-		getTurnId: () => turnId,
+		getTurnId: () => turnIdRef.current,
 		isCompleted: () => completed,
 		isTerminalTurnNotificationQueued: () => terminalTurnNotificationQueued,
 		getActiveAppServerTurnRequests: () => activeAppServerTurnRequests,
@@ -7657,12 +7870,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		turnTerminalIdleTimeoutMs,
 		interruptTimeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS,
 		onInterruptTurn: (input) => interruptCodexTurnBestEffort(client, input),
-		onTimeout: () => {
+		onTimeout: (timeout) => {
 			timedOut = true;
 			turnCompletionIdleTimedOut = true;
+			turnWatchTimeoutKind = timeout.kind;
 			turnCompletionIdleTimeoutMessage = "codex app-server turn idle timed out waiting for turn/completed";
 		},
-		onMarkTimedOut: () => projector?.markTimedOut(),
+		onMarkTimedOut: () => projectorRef.current?.markTimedOut(),
 		onAbort: (reason) => runAbortController.abort(reason),
 		onCompleted: () => {
 			completed = true;
@@ -7793,6 +8007,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		currentPromptTexts: [codexTurnPromptText]
 	});
 	const handleNotification = async (notification) => {
+		const projector = projectorRef.current;
+		const turnId = turnIdRef.current;
+		const userInputBridge = userInputBridgeRef.current;
+		const steeringQueue = steeringQueueRef.current;
 		userInputBridge?.handleNotification(notification);
 		if (!projector || !turnId) {
 			pendingNotifications.push(notification);
@@ -7803,7 +8021,6 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			threadId: thread.threadId,
 			turnId,
 			currentPromptTexts: [codexTurnPromptText],
-			sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
 			turnWatches,
 			activeTurnItemIds,
 			activeAppServerTurnRequests,
@@ -7836,6 +8053,9 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		}
 	};
 	const enqueueNotification = (notification) => {
+		const projector = projectorRef.current;
+		const turnId = turnIdRef.current;
+		const userInputBridge = userInputBridgeRef.current;
 		const correlation = describeCodexNotificationCorrelation(notification, {
 			threadId: thread.threadId,
 			...turnId ? { turnId } : {}
@@ -7850,7 +8070,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			return Promise.resolve();
 		}
 		if (isTerminalTurnNotificationForTurn(notification, turnId)) terminalTurnNotificationQueued = true;
-		if (correlation.matchesActiveTurn !== false) turnWatches.noteNotificationReceived(notification.method);
+		const isNativeResponseStreamDelta = isNativeResponseStreamDeltaNotification(notification);
+		const nativeResponseStreamDeltaMatchesActiveTurn = isNativeResponseStreamDelta && (correlation.matchesActiveTurn === true || isUnscopedCodexNotification(correlation) && canAttributeUnscopedNativeResponseDeltaToThisTurn(client));
+		if (correlation.matchesActiveTurn === true || !isNativeResponseStreamDelta && correlation.matchesActiveTurn !== false || nativeResponseStreamDeltaMatchesActiveTurn) 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;
 	};
@@ -7864,6 +8090,9 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	});
 	const notificationCleanup = client.addNotificationHandler(enqueueNotification);
 	const requestCleanup = client.addRequestHandler(async (request) => {
+		const turnId = turnIdRef.current;
+		const userInputBridge = userInputBridgeRef.current;
+		const projector = projectorRef.current;
 		let armCompletionWatchOnResponse = false;
 		let requestCountsAsTurnActivity = false;
 		const markCurrentTurnRequestProgress = () => {
@@ -8045,19 +8274,20 @@ async function runCodexAppServerAttempt(params, options = {}) {
 					sessionKey: params.sessionKey,
 					durationMs: toolDurationMs
 				});
-				if (response.terminate === true) {
-					pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
-					scheduleTurnReleaseAfterTerminalDynamicTool({
-						call,
-						response,
-						durationMs: toolDurationMs
-					});
-				} else {
+				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
+				if (response.terminate === true) scheduleTurnReleaseAfterTerminalDynamicTool({
+					call,
+					response,
+					durationMs: toolDurationMs
+				});
+				else if (!shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response)) scheduleTerminalDynamicToolReleaseCheck();
+				else {
 					currentTurnHadNonTerminalDynamicToolResult = true;
 					pendingTerminalDynamicToolRelease = void 0;
 				}
 				return protocolResponse;
 			} catch (error) {
+				pendingOpenClawDynamicToolCompletionIds.delete(call.callId);
 				if (!terminalDiagnosticObserved && !hasPendingDynamicToolTerminalDiagnostic({
 					call,
 					runId: params.runId,
@@ -8077,15 +8307,17 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		} finally {
 			if (requestCountsAsTurnActivity) {
 				activeAppServerTurnRequests = Math.max(0, activeAppServerTurnRequests - 1);
+				const postToolContinuationTimeoutMs = request.method === "item/tool/call" && turnCrossedToolHandoff ? postToolRawAssistantCompletionIdleTimeoutMs : void 0;
 				turnWatches.touchActivity(`request:${request.method}:response`, {
 					arm: armCompletionWatchOnResponse,
-					attemptProgress: true
+					attemptProgress: true,
+					...postToolContinuationTimeoutMs !== void 0 ? { attemptTimeoutMs: postToolContinuationTimeoutMs } : {}
 				});
+				if (armCompletionWatchOnResponse && postToolContinuationTimeoutMs !== void 0) turnWatches.armCompletionIdleWatch({ timeoutMs: postToolContinuationTimeoutMs });
 				scheduleTerminalDynamicToolReleaseCheck();
 			} else turnWatches.scheduleProgressWatches();
 		}
 	});
-	let closeCleanup;
 	const buildLlmInputEvent = () => ({
 		runId: params.runId,
 		sessionId: params.sessionId,
@@ -8093,11 +8325,11 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		model: params.modelId,
 		systemPrompt: buildRenderedCodexDeveloperInstructions(),
 		prompt: codexTurnPromptText,
-		historyMessages,
+		historyMessages: codexModelInputHistoryMessages,
 		imagesCount: params.images?.length ?? 0,
 		tools
 	});
-	const buildTurnStartFailureMessages = () => [...historyMessages, buildCodexUserPromptMessage({
+	const buildCodexModelInputMessages = () => [...codexModelInputHistoryMessages, buildCodexUserPromptMessage({
 		...params,
 		prompt: codexTurnPromptText
 	})];
@@ -8116,7 +8348,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		},
 		capture: codexModelContentCapture,
 		tools,
-		buildInputMessages: buildTurnStartFailureMessages,
+		buildInputMessages: buildCodexModelInputMessages,
 		buildSystemPrompt: buildRenderedCodexDeveloperInstructions,
 		onErrorDiagnostic: (error) => {
 			embeddedAgentLog.debug("codex app-server model call diagnostic ended with error", { error: formatErrorMessage(error) });
@@ -8132,6 +8364,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			sandboxPolicy: codexSandboxPolicy,
 			environmentSelection: codexEnvironmentSelection,
 			turnScopedDeveloperInstructions: workspaceBootstrapContext.turnScopedDeveloperInstructions,
+			skillsCollaborationInstructions,
+			memoryCollaborationInstructions: workspaceBootstrapContext.memoryCollaborationInstructions,
 			heartbeatCollaborationInstructions: workspaceBootstrapContext.heartbeatCollaborationInstructions
 		});
 		codexModelCallDiagnostics.setRequestPayloadBytes(utf8JsonByteLength(turnStartParams));
@@ -8157,7 +8391,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		turn = await startCodexTurn();
 	} catch (error) {
 		let turnStartError = error;
-		if (shouldRetryContextEngineTurnOnFreshCodexThread({
+		if (shouldUseFreshCodexThreadAfterContextEngineOverflow({
 			error: turnStartError,
 			contextEngineActive: Boolean(activeContextEngine),
 			thread
@@ -8168,20 +8402,26 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			});
 			try {
 				const preRetrySessionFile = activeSessionFile;
-				await clearCodexAppServerBinding(preRetrySessionFile);
-				if (activeSessionFile !== preRetrySessionFile) await clearCodexAppServerBinding(activeSessionFile);
-				thread = await restartContextEngineCodexThread();
-				emitCodexAppServerEvent(params, {
-					stream: "codex_app_server.lifecycle",
-					data: {
-						phase: "thread_ready_retry",
-						threadId: thread.threadId
-					}
+				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", {
+					threadId: thread.threadId,
+					error: formatErrorMessage(turnStartError)
 				});
-				try {
-					turn = await startCodexTurn();
-				} catch (retryError) {
-					turnStartError = retryError;
+				else {
+					thread = await restartContextEngineCodexThread();
+					emitCodexAppServerEvent(params, {
+						stream: "codex_app_server.lifecycle",
+						data: {
+							phase: "thread_ready_retry",
+							threadId: thread.threadId
+						}
+					});
+					try {
+						turn = await startCodexTurn();
+					} catch (retryError) {
+						turnStartError = retryError;
+					}
 				}
 			} catch (retrySetupError) {
 				turnStartError = retrySetupError;
@@ -8240,9 +8480,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				formatError: formatErrorMessage
 			});
 			codexModelCallDiagnostics.emitError(turnStartErrorMessage, turnStartFailureKind ? { failureKind: turnStartFailureKind } : {});
+			const turnStartFailureMessages = [...historyMessages, buildCodexUserPromptMessage({
+				...params,
+				prompt: codexTurnPromptText
+			})];
 			await runCodexAgentEndHook(params, {
 				event: {
-					messages: buildTurnStartFailureMessages(),
+					messages: turnStartFailureMessages,
 					success: false,
 					error: turnStartErrorMessage,
 					durationMs: Date.now() - attemptStartedAt
@@ -8279,7 +8523,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				return { ...buildCodexTurnStartFailureResult({
 					params,
 					message: usageLimitError.message,
-					messagesSnapshot: buildTurnStartFailureMessages(),
+					messagesSnapshot: turnStartFailureMessages,
 					systemPromptReport
 				}) };
 			}
@@ -8291,10 +8535,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		releaseSharedClientLease = void 0;
 		throw new Error("codex app-server turn/start failed without an error");
 	}
-	turnId = turn.turn.id;
+	turnIdRef.current = turn.turn.id;
 	const activeTurnId = turn.turn.id;
 	emitExecutionPhaseOnce("turn_accepted", { phase: "turn_accepted" });
-	userInputBridge = createCodexUserInputBridge({
+	userInputBridgeRef.current = createCodexUserInputBridge({
 		paramsForRun: params,
 		threadId: thread.threadId,
 		turnId: activeTurnId,
@@ -8306,12 +8550,12 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		prompt: codexTurnPromptText,
 		imagesCount: params.images?.length ?? 0
 	});
-	projector = new CodexAppServerEventProjector(params, thread.threadId, activeTurnId, {
+	projectorRef.current = new CodexAppServerEventProjector(params, thread.threadId, activeTurnId, {
 		nativePostToolUseRelayEnabled: nativeHookRelay?.allowedEvents.includes("post_tool_use") === true && nativeHookRelay.shouldRelayEvent("post_tool_use"),
 		trajectoryRecorder
 	});
 	if (isTerminalTurnStatus(turn.turn.status) || pendingNotifications.some((notification) => isTerminalTurnNotificationForTurn(notification, activeTurnId))) terminalTurnNotificationQueued = true;
-	closeCleanup = client.addCloseHandler?.(() => {
+	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", {
@@ -8329,9 +8573,12 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		resolveCompletion?.();
 	});
 	emitLifecycleStart();
-	const activeProjector = projector;
+	const activeProjector = projectorRef.current;
+	if (!activeProjector) throw new Error("codex app-server projector was not initialized");
 	turnWatches.armTerminalIdleWatch();
 	turnWatches.touchActivity("turn:start", { arm: true });
+	turnWatches.armAttemptIdleWatch();
+	turnWatches.touchActivity("turn:start", { attemptProgress: true });
 	for (const notification of pendingNotifications.splice(0)) await enqueueNotification(notification);
 	if (!completed && isTerminalTurnStatus(turn.turn.status)) await enqueueNotification({
 		method: "turn/completed",
@@ -8345,15 +8592,15 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		client,
 		threadId: thread.threadId,
 		turnId: activeTurnId,
-		answerPendingUserInput: (text) => userInputBridge?.handleQueuedMessage(text) ?? false,
+		answerPendingUserInput: (text) => userInputBridgeRef.current?.handleQueuedMessage(text) ?? false,
 		signal: runAbortController.signal
 	});
-	steeringQueue = activeSteeringQueue;
+	steeringQueueRef.current = activeSteeringQueue;
 	const handle = {
 		kind: "embedded",
 		queueMessage: async (text, options) => activeSteeringQueue.queue(text, options),
 		isStreaming: () => !completed,
-		isCompacting: () => projector?.isCompacting() ?? false,
+		isCompacting: () => projectorRef.current?.isCompacting() ?? false,
 		sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
 		cancel: () => runAbortController.abort("cancelled"),
 		abort: () => runAbortController.abort("aborted")
@@ -8369,16 +8616,16 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		threadId: thread.threadId,
 		turnId: activeTurnId
 	});
-	turnWatches.armAttemptIdleWatch();
-	turnWatches.armTerminalIdleWatch();
-	turnWatches.touchActivity("turn:start", { attemptProgress: true });
 	const abortListener = () => {
 		if (timedOut) {
-			retireCodexAppServerClientAfterTimedOutTurn(client, {
-				threadId: thread.threadId,
-				turnId: activeTurnId,
-				reason: String(runAbortController.signal.reason ?? "timeout")
-			}).finally(() => {
+			(async () => {
+				await clearCodexAppServerBindingForThread(activeSessionFile, thread.threadId);
+				await retireCodexAppServerClientAfterTimedOutTurn(client, {
+					threadId: thread.threadId,
+					turnId: activeTurnId,
+					reason: String(runAbortController.signal.reason ?? "timeout")
+				});
+			})().finally(() => {
 				resolveCompletion?.();
 			});
 			return;
@@ -8393,6 +8640,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	if (runAbortController.signal.aborted) abortListener();
 	try {
 		await completion;
+		await notificationQueue;
 		const result = activeProjector.buildResult(toolBridge.telemetry, { yieldDetected });
 		const finalAborted = result.aborted || runAbortController.signal.aborted && !clientClosedAbort;
 		let finalPromptError = clientClosedPromptError ?? (turnCompletionIdleTimedOut ? turnCompletionIdleTimeoutMessage : timedOut ? "codex app-server attempt timed out" : result.promptError);
@@ -8403,6 +8651,20 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			turnId: activeTurnId,
 			error: finalPromptErrorMessage
 		});
+		if (shouldUseFreshCodexThreadAfterContextEngineOverflow({
+			error: finalPromptError,
+			contextEngineActive: Boolean(activeContextEngine),
+			thread
+		})) {
+			embeddedAgentLog.warn("codex app-server context-engine turn overflowed after resume; clearing thread binding for recovery", {
+				threadId: thread.threadId,
+				turnId: activeTurnId,
+				error: finalPromptErrorMessage
+			});
+			const preClearSessionFile = activeSessionFile;
+			await clearCodexAppServerBindingForThread(preClearSessionFile, thread.threadId);
+			if (activeSessionFile !== preClearSessionFile) await clearCodexAppServerBindingForThread(activeSessionFile, thread.threadId);
+		}
 		const refreshedUsageLimitPromptError = await refreshCodexUsageLimitPromptError({
 			client,
 			message: finalPromptErrorMessage,
@@ -8526,6 +8788,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			hookRunner
 		});
 		shouldDelayNativeHookRelayUnregister = activeProjector.getCompletedTurnStatus() === "completed" && !timedOut && !runAbortController.signal.aborted && !finalAborted && !finalPromptError;
+		if (shouldDelayNativeHookRelayUnregister) await markCodexAppServerBindingCoveredThroughTurn({
+			sessionFile: params.sessionFile,
+			threadId: thread.threadId,
+			authProfileStore: params.authProfileStore,
+			agentDir: params.agentDir,
+			config: params.config
+		});
 		return {
 			...result,
 			timedOut,
@@ -8534,6 +8803,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			promptErrorSource: finalPromptErrorSource,
 			...codexAppServerFailureKind ? { codexAppServerFailure: {
 				kind: codexAppServerFailureKind,
+				...codexAppServerFailureKind === "turn_completion_idle_timeout" && turnWatchTimeoutKind ? { turnWatchTimeoutKind } : {},
 				transport: appServer.start.transport,
 				threadId: thread.threadId,
 				turnId: activeTurnId,
@@ -8565,12 +8835,12 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				await trajectoryRecorder?.flush();
 			}
 		});
-		if (!timedOut && !runAbortController.signal.aborted) await steeringQueue?.flushPending();
+		if (!timedOut && !runAbortController.signal.aborted) await steeringQueueRef.current?.flushPending();
 		if (!timedOut) await unsubscribeCodexThreadBestEffort(client, {
 			threadId: thread.threadId,
 			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
 		});
-		userInputBridge?.cancelPending();
+		userInputBridgeRef.current?.cancelPending();
 		turnWatches.clearAllTimers();
 		notificationCleanup();
 		requestCleanup();
@@ -8584,7 +8854,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		await releaseSandboxExecEnvironment();
 		runAbortController.signal.removeEventListener("abort", abortListener);
 		params.abortSignal?.removeEventListener("abort", abortFromUpstream);
-		steeringQueue?.cancel();
+		steeringQueueRef.current?.cancel();
 		clearActiveEmbeddedRun(params.sessionId, handle, params.sessionKey);
 	}
 }
@@ -8603,10 +8873,31 @@ async function clearCodexBindingAfterInvalidImagePayload(sessionFile, fields) {
 	embeddedAgentLog.warn("codex app-server image payload error detected; clearing thread binding", fields);
 	await clearCodexAppServerBinding(sessionFile);
 }
+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
+	});
+}
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
-function shouldRetryContextEngineTurnOnFreshCodexThread(params) {
+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);
 }