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

package/dist/{dynamic-tools-BMLoaTeG.js → dynamic-tools-C_1tEs34.js}

@@ -1,18 +1,16 @@
-import { i as isJsonObject, n as CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE } from "./protocol-BMifTfdW.js";
-import { d as readCodexPluginConfig } from "./config-c48K5HP9.js";
-import { c as readCodexTurn } from "./protocol-validators-dZQ-UTOa.js";
-import { c as releaseLeasedSharedCodexAppServerClient } from "./shared-client-D4mFI9al.js";
-import { C as sanitizeInlineImageDataUrl, D as normalizeCodexDynamicToolName, E as isSystemAgentOnlyCodexDynamicToolAllowlist, S as sanitizeCodexHistoryImagePayloads, T as isForcedPrivateQaCodexRuntime, v as resolveCodexWebSearchPlan, w as filterCodexDynamicTools, x as invalidInlineImageText } from "./thread-lifecycle-BgLXzjvV.js";
-import { n as formatCodexUsageLimitErrorMessage } from "./rate-limits-Dhp04Rqo.js";
-import { c as attachCodexMirrorIdentity, s as promptSnapshot } from "./transcript-mirror-DhLwFIL4.js";
-import { r as formatCodexDisplayText } from "./command-formatters-D6ZlGNmb.js";
+import { Y as CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE, Z as isJsonObject, _ as readCodexRateLimitsRevision, c as releaseLeasedSharedCodexAppServerClient, j as resolveCodexGatewayTimeoutWithGraceMs, v as readRecentCodexRateLimits, y as rememberCodexRateLimitsRead } from "./shared-client-JiAnW6pc.js";
+import { y as readCodexPluginConfig } from "./session-binding-h1mmCGnl.js";
+import { c as attachCodexMirrorIdentity, g as readCodexTurn, s as promptSnapshot } from "./transcript-mirror-D9rTxx2P.js";
+import { C as isForcedPrivateQaCodexRuntime, S as filterCodexDynamicToolsWithOpenClawShell, T as normalizeCodexDynamicToolName, a as sanitizeCodexHistoryImagePayloads, d as resolveCodexWebSearchPlan, i as invalidInlineImageText, o as sanitizeInlineImageDataUrl, w as isSystemAgentOnlyCodexDynamicToolAllowlist, x as filterCodexDynamicTools } from "./thread-lifecycle-CN_pPtPh.js";
+import { d as CODEX_CONTROL_METHODS, r as formatCodexDisplayText } from "./command-formatters-Dq9InZUK.js";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-DyXaYAxU.js";
 import { a as resolveCodexNodeExecToolOverrides, i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-D1Wky__S.js";
-import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-DfaCm0mx.js";
+import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-KmfV4EkP.js";
 import fs from "node:fs/promises";
-import { addTimerTimeoutGraceMs, asDateTimestampMs, finiteSecondsToTimerSafeMilliseconds, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { addTimerTimeoutGraceMs, asDateTimestampMs, finiteSecondsToTimerSafeMilliseconds, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
-import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
+import { markAuthProfileBlockedUntil, resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { asOptionalRecord, isRecord, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { HEARTBEAT_RESPONSE_TOOL_NAME, TOOL_PROGRESS_OUTPUT_MAX_CHARS, buildAgentHookContextChannelFields, buildEmbeddedAttemptToolRunContext, callGatewayTool, classifyAgentHarnessTerminalOutcome, consumeAdjustedParamsForToolCall, consumePreExecutionBlockedToolCall, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, emitAgentEvent, extractMessagingToolSend, extractMessagingToolSendResult, extractToolResultMediaArtifact, filterProviderNormalizableTools, filterToolResultMediaUrls, finalizeToolTerminalPresentation, formatApprovalDisplayPath, formatErrorMessage, formatToolAggregate, formatToolExecutionErrorMessage, formatToolProgressOutput, getBeforeToolCallFailureDisposition, getChannelAgentToolMeta, getPluginToolMeta, hasNativeHookRelayInvocation, inferToolMetaFromArgs, invokeNativeHookRelay, isDeliveredMessageToolOnlySourceReplyResult, isDeliveredMessagingToolResult, isHostScopedAgentToolActive, isMessagingTool, isMessagingToolSendAction, isReplaySafeToolCall, isSubagentSessionKey, isToolResultError, isToolWrappedWithBeforeToolCallHook, normalizeAgentRuntimeTools, normalizeHeartbeatToolResponse, normalizeUsage, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveNativeHookRelayDeferredToolApproval, resolveToolExecutionErrorKind, resolveToolResultFailureKind, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runBeforeToolCallHook, sanitizeToolResult, setBeforeToolCallDiagnosticsEnabled, supportsModelTools, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
@@ -25,6 +23,7 @@ import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";
 import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "openclaw/plugin-sdk/agent-sessions";
 import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+import { normalizeOpenAIToolSchemas } from "openclaw/plugin-sdk/provider-tools";
 //#region extensions/codex/src/app-server/local-runtime-attribution.ts
 const OPENAI_PROVIDER_ID = "openai";
 const OPENAI_RESPONSES_API = "openai-responses";
@@ -67,6 +66,7 @@ function createAssistantMessage(params, text, options) {
 		output: options.tokenUsage.output ?? 0,
 		cacheRead: options.tokenUsage.cacheRead ?? 0,
 		cacheWrite: options.tokenUsage.cacheWrite ?? 0,
+		...options.tokenUsage.contextUsage ? { contextUsage: options.tokenUsage.contextUsage } : {},
 		totalTokens: options.tokenUsage.total ?? (options.tokenUsage.input ?? 0) + (options.tokenUsage.output ?? 0) + (options.tokenUsage.cacheRead ?? 0) + (options.tokenUsage.cacheWrite ?? 0),
 		cost: ZERO_USAGE$1.cost
 	} : ZERO_USAGE$1;
@@ -103,7 +103,7 @@ function createAssistantMirrorMessage(params, title, text) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-values.ts
-function readString$2(record, key) {
+function readString$3(record, key) {
 	const value = record[key];
 	return typeof value === "string" ? value : void 0;
 }
@@ -139,15 +139,15 @@ function readNonNegativeInteger(record, key) {
 }
 function readCodexErrorNotificationMessage(record) {
 	const error = record.error;
-	return isJsonObject(error) ? readString$2(error, "message") : void 0;
+	return isJsonObject(error) ? readString$3(error, "message") : void 0;
 }
 function readHookOutputEntries(value) {
 	if (!Array.isArray(value)) return [];
 	return value.flatMap((entry) => {
 		if (!isJsonObject(entry)) return [];
-		const text = readString$2(entry, "text");
+		const text = readString$3(entry, "text");
 		if (!text) return [];
-		const kind = readString$2(entry, "kind");
+		const kind = readString$3(entry, "kind");
 		return [{
 			...kind ? { kind } : {},
 			text
@@ -160,9 +160,9 @@ function splitPlanText(text) {
 function extractRawAssistantText(item) {
 	return (Array.isArray(item.content) ? item.content : []).flatMap((entry) => {
 		if (!isJsonObject(entry)) return [];
-		const type = readString$2(entry, "type");
+		const type = readString$3(entry, "type");
 		if (type !== "output_text" && type !== "text") return [];
-		const value = readString$2(entry, "text");
+		const value = readString$3(entry, "text");
 		return value ? [value] : [];
 	}).join("").trim() || void 0;
 }
@@ -218,8 +218,8 @@ var CodexAssistantProjection = class {
 		return this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff && this.hasLatestTerminalAssistantCandidateText();
 	}
 	async handleAssistantDelta(params) {
-		const itemId = readString$2(params, "itemId") ?? "assistant";
-		const delta = readString$2(params, "delta") ?? "";
+		const itemId = readString$3(params, "itemId") ?? "assistant";
+		const delta = readString$3(params, "delta") ?? "";
 		if (!delta) return;
 		if (itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
 		const isCommentary = this.isCommentaryAssistantItem(itemId);
@@ -299,9 +299,9 @@ var CodexAssistantProjection = class {
 		}
 	}
 	handleRawResponseItemCompleted(item, activeItemIds) {
-		const role = readString$2(item, "role");
-		const phase = readString$2(item, "phase");
-		const rawItemId = readString$2(item, "id");
+		const role = readString$3(item, "role");
+		const phase = readString$3(item, "phase");
+		const rawItemId = readString$3(item, "id");
 		const candidateWasSupersededBeforeRaw = this.latestTerminalAssistantCandidateSuperseded;
 		const pendingTerminalAssistantEchoItemId = this.pendingRawTerminalAssistantEchoItemId;
 		const isPendingTerminalAssistantEcho = role === "assistant" && phase !== "commentary" && pendingTerminalAssistantEchoItemId !== void 0 && (rawItemId === void 0 || rawItemId === pendingTerminalAssistantEchoItemId);
@@ -607,7 +607,7 @@ function collectDynamicToolContentText(contentItems) {
 	if (!Array.isArray(contentItems)) return "";
 	return contentItems.flatMap((entry) => {
 		if (!isJsonObject(entry)) return [];
-		const text = readString$2(entry, "text");
+		const text = readString$3(entry, "text");
 		return text ? [text] : [];
 	}).join("\n");
 }
@@ -956,7 +956,29 @@ var CodexToolProgressProjection = class {
 		return this.sideEffectingNativeIds.size > 0 || this.sideEffectingDynamicIds.size > 0;
 	}
 	setLastToolError(error) {
-		this.lastNativeToolError = error;
+		if (!error) {
+			this.lastNativeToolError = void 0;
+			return;
+		}
+		const terminalResolution = this.params.observeToolTerminal?.({
+			toolName: error.toolName,
+			...error.meta ? { meta: error.meta } : {},
+			outcome: "failure",
+			failure: {
+				...error.errorCode ? { errorCode: error.errorCode } : {},
+				...error.error ? { error: error.error } : {},
+				...error.validationErrorSummary ? { validationErrorSummary: error.validationErrorSummary } : {},
+				...error.timedOut ? { timedOut: true } : {},
+				...error.middlewareError ? { middlewareError: true } : {}
+			},
+			nativeMutation: {
+				mutatingAction: error.mutatingAction === true,
+				replaySafe: error.mutatingAction !== true,
+				...error.actionFingerprint ? { actionFingerprint: error.actionFingerprint } : {},
+				...error.fileTarget ? { fileTarget: error.fileTarget } : {}
+			}
+		});
+		this.lastNativeToolError = terminalResolution?.lastToolError ?? (this.lastNativeToolError?.mutatingAction && error.mutatingAction !== true ? this.lastNativeToolError : error);
 	}
 	recordDynamicToolResult(params) {
 		const resultText = collectDynamicToolContentText(params.contentItems);
@@ -967,16 +989,17 @@ var CodexToolProgressProjection = class {
 			...params.asyncStarted === true ? { asyncStarted: true } : {},
 			...!params.success ? { isError: true } : {}
 		});
-		if (!params.success && params.terminalType === "blocked") this.lastNativeToolError = {
+		if (params.terminalResolution) this.lastNativeToolError = params.terminalResolution.lastToolError;
+		else if (!params.success) this.lastNativeToolError = {
 			toolName: params.tool,
-			error: resultText || "codex dynamic tool blocked"
+			error: resultText || (params.terminalType === "blocked" ? "codex dynamic tool blocked" : "codex dynamic tool failed")
 		};
-		else if (params.success && this.lastNativeToolError && !this.lastNativeToolError.mutatingAction) this.lastNativeToolError = void 0;
+		else if (this.lastNativeToolError?.mutatingAction !== true) this.lastNativeToolError = void 0;
 		if (params.sideEffectEvidence === true) this.sideEffectingDynamicIds.add(params.callId);
 	}
 	handleOutputDelta(params, toolName) {
-		const itemId = readString$2(params, "itemId");
-		const delta = readString$2(params, "delta");
+		const itemId = readString$3(params, "itemId");
+		const delta = readString$3(params, "delta");
 		if (!itemId || !delta) return;
 		const storedOutput = this.output.append(itemId, delta);
 		this.rememberEcho(itemId, {
@@ -1017,25 +1040,37 @@ var CodexToolProgressProjection = class {
 		});
 	}
 	recordNativeToolError(params) {
-		if (!isNonSuccessItemStatus(params.status)) {
-			if (!this.lastNativeToolError) return;
-			if (!this.lastNativeToolError.mutatingAction) {
-				this.lastNativeToolError = void 0;
-				return;
+		const executionStarted = params.status !== "blocked";
+		const mutatingAction = executionStarted && isMutatingNativeToolItem(params.item);
+		const actionFingerprint = mutatingAction ? nativeToolActionFingerprint(params.item) : void 0;
+		const isFailure = isNonSuccessItemStatus(params.status);
+		const error = isFailure ? itemToolError(params.item, params.status, this.output.textByItem) : void 0;
+		const terminalResolution = this.params.observeToolTerminal?.({
+			toolCallId: params.item.id,
+			toolName: params.name,
+			arguments: itemToolArgs(params.item),
+			...params.meta ? { meta: params.meta } : {},
+			executionStarted,
+			outcome: isFailure ? "failure" : "success",
+			...isFailure ? { failure: error ? { error } : {} } : {},
+			nativeMutation: {
+				mutatingAction,
+				replaySafe: !mutatingAction,
+				...actionFingerprint ? { actionFingerprint } : {}
 			}
-			const actionFingerprint = nativeToolActionFingerprint(params.item);
-			if (this.lastNativeToolError.actionFingerprint && actionFingerprint && this.lastNativeToolError.actionFingerprint === actionFingerprint) this.lastNativeToolError = void 0;
+		});
+		if (terminalResolution) {
+			this.lastNativeToolError = terminalResolution.lastToolError;
 			return;
 		}
-		const error = itemToolError(params.item, params.status, this.output.textByItem);
-		const actionFingerprint = nativeToolActionFingerprint(params.item);
-		this.lastNativeToolError = {
+		if (isFailure) this.lastNativeToolError = {
 			toolName: params.name,
 			...params.meta ? { meta: params.meta } : {},
 			...error ? { error } : {},
-			...isMutatingNativeToolItem(params.item) ? { mutatingAction: true } : {},
+			...mutatingAction ? { mutatingAction: true } : {},
 			...actionFingerprint ? { actionFingerprint } : {}
 		};
+		else if (this.lastNativeToolError?.mutatingAction !== true) this.lastNativeToolError = void 0;
 	}
 	emitToolResultSummary(item) {
 		if (!item || !this.params.onToolResult || !this.shouldEmitToolResult()) return;
@@ -1202,7 +1237,8 @@ async function readCodexMirroredSessionHistoryMessages(target) {
 		const entries = await readCodexMirroredSessionEntries(target);
 		if (entries.length === 0) return [];
 		const firstEntry = entries[0];
-		if (firstEntry?.type !== "session" || typeof firstEntry.id !== "string") return;
+		if (firstEntry?.type !== "session") return [];
+		if (typeof firstEntry.id !== "string") return;
 		migrateSessionEntries(entries);
 		return sanitizeCodexHistoryImagePayloads(buildSessionContext(entries.filter((entry) => {
 			return entry !== null && typeof entry === "object" && !Array.isArray(entry) && entry.type !== "session";
@@ -1533,14 +1569,14 @@ var CodexEventProjection = class {
 			data: {
 				method,
 				phase: method.endsWith("/started") ? "started" : "completed",
-				reviewId: readString$2(params, "reviewId"),
+				reviewId: readString$3(params, "reviewId"),
 				targetItemId: readNullableString(params, "targetItemId"),
-				decisionSource: readString$2(params, "decisionSource"),
-				status: review ? readString$2(review, "status") : void 0,
-				riskLevel: review ? readString$2(review, "riskLevel") : void 0,
-				userAuthorization: review ? readString$2(review, "userAuthorization") : void 0,
+				decisionSource: readString$3(params, "decisionSource"),
+				status: review ? readString$3(review, "status") : void 0,
+				riskLevel: review ? readString$3(review, "riskLevel") : void 0,
+				userAuthorization: review ? readString$3(review, "userAuthorization") : void 0,
 				rationale: review ? readNullableString(review, "rationale") : void 0,
-				actionType: action ? readString$2(action, "type") : void 0
+				actionType: action ? readString$3(action, "type") : void 0
 			}
 		});
 	}
@@ -1549,7 +1585,7 @@ var CodexEventProjection = class {
 			stream: "codex_app_server.guardian",
 			data: {
 				phase: "warning",
-				message: readString$2(params, "message")
+				message: readString$3(params, "message")
 			}
 		});
 	}
@@ -1565,14 +1601,14 @@ var CodexEventProjection = class {
 				phase: method === "hook/started" ? "started" : "completed",
 				threadId: this.threadId,
 				turnId: hookTurnId === void 0 ? this.turnId : hookTurnId,
-				hookRunId: readString$2(run, "id"),
-				eventName: readString$2(run, "eventName"),
-				handlerType: readString$2(run, "handlerType"),
-				executionMode: readString$2(run, "executionMode"),
-				scope: readString$2(run, "scope"),
-				source: readString$2(run, "source"),
-				sourcePath: readString$2(run, "sourcePath"),
-				status: readString$2(run, "status"),
+				hookRunId: readString$3(run, "id"),
+				eventName: readString$3(run, "eventName"),
+				handlerType: readString$3(run, "handlerType"),
+				executionMode: readString$3(run, "executionMode"),
+				scope: readString$3(run, "scope"),
+				source: readString$3(run, "source"),
+				sourcePath: readString$3(run, "sourcePath"),
+				status: readString$3(run, "status"),
 				statusMessage: readNullableString(run, "statusMessage"),
 				...durationMs !== void 0 ? { durationMs } : {},
 				...entries.length > 0 ? { entries } : {}
@@ -1673,10 +1709,10 @@ var CodexGeneratedMediaProjection = class {
 		});
 	}
 	async recordRaw(item) {
-		if (readString$2(item, "type") !== "image_generation_call") return;
-		const result = readString$2(item, "result");
+		if (readString$3(item, "type") !== "image_generation_call") return;
+		const result = readString$3(item, "result");
 		if (!result) return;
-		const itemId = readString$2(item, "id") ?? `raw-image-${this.itemIds.size}`;
+		const itemId = readString$3(item, "id") ?? `raw-image-${this.itemIds.size}`;
 		this.itemIds.add(itemId);
 		const maxBytes = resolveGeneratedImageMaxBytes(this.config);
 		const estimatedDecodedBytes = estimateBase64DecodedBytes(result);
@@ -1691,7 +1727,7 @@ var CodexGeneratedMediaProjection = class {
 		const asset = generatedImageAssetFromBase64({
 			base64: result,
 			index: this.itemIds.size,
-			revisedPrompt: readString$2(item, "revised_prompt") ?? readString$2(item, "revisedPrompt"),
+			revisedPrompt: readString$3(item, "revised_prompt") ?? readString$3(item, "revisedPrompt"),
 			fileNamePrefix: "codex-image-generation",
 			sniffMimeType: true
 		});
@@ -1749,6 +1785,90 @@ function resolveGeneratedImageMaxBytes(config) {
 	return DEFAULT_GENERATED_IMAGE_MAX_BYTES;
 }
 //#endregion
+//#region extensions/codex/src/app-server/dynamic-tool-response-state.ts
+function withDynamicToolTerminalResolution(response, terminalResolution) {
+	if (terminalResolution) {
+		Object.defineProperties(response, {
+			terminalResolution: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution
+			},
+			executionStarted: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution.executionStarted
+			},
+			...terminalResolution.executedArguments ? { executedArguments: {
+				configurable: true,
+				enumerable: false,
+				value: terminalResolution.executedArguments
+			} } : {}
+		});
+		withDynamicToolSideEffectEvidence(response, terminalResolution.sideEffectEvidence);
+	}
+	return response;
+}
+function withDynamicToolExecutionState(response, state) {
+	Object.defineProperties(response, {
+		executedArguments: {
+			configurable: true,
+			enumerable: false,
+			value: state.executedArguments
+		},
+		executionStarted: {
+			configurable: true,
+			enumerable: false,
+			value: state.executionStarted
+		}
+	});
+	return withDynamicToolSideEffectEvidence(response, state.sideEffectEvidence === true);
+}
+function withDynamicToolSideEffectEvidence(response, sideEffectEvidence) {
+	if (!sideEffectEvidence) {
+		delete response.sideEffectEvidence;
+		return response;
+	}
+	Object.defineProperty(response, "sideEffectEvidence", {
+		configurable: true,
+		enumerable: false,
+		value: true
+	});
+	return response;
+}
+function createFailedDynamicToolResponse(message, options) {
+	const response = {
+		contentItems: [{
+			type: "inputText",
+			text: message
+		}],
+		success: false
+	};
+	Object.defineProperties(response, {
+		diagnosticTerminalReason: {
+			configurable: true,
+			enumerable: false,
+			value: options?.terminalReason ?? "failed"
+		},
+		diagnosticTerminalType: {
+			configurable: true,
+			enumerable: false,
+			value: "error"
+		}
+	});
+	if (options?.executionStarted !== void 0) Object.defineProperty(response, "executionStarted", {
+		configurable: true,
+		enumerable: false,
+		value: options.executionStarted
+	});
+	if (options?.executedArguments !== void 0) Object.defineProperty(response, "executedArguments", {
+		configurable: true,
+		enumerable: false,
+		value: options.executedArguments
+	});
+	return withDynamicToolSideEffectEvidence(response, options?.sideEffectEvidence === true);
+}
+//#endregion
 //#region extensions/codex/src/app-server/tool-abort-terminal-reason.ts
 /** Leaf helper shared by native and dynamic tool diagnostics. */
 const CODEX_TIMEOUT_ABORT_REASONS = /* @__PURE__ */ new Set([
@@ -1846,6 +1966,30 @@ function formatDynamicToolTimeoutDetails(params) {
 */
 async function handleDynamicToolCallWithTimeout(params) {
 	let didNotifyAgentToolResult = false;
+	const conservativeRaceResponses = /* @__PURE__ */ new WeakSet();
+	const finalizeTerminal = (response) => {
+		const executionSnapshot = params.toolBridge.consumeToolExecutionSnapshot?.(params.call.callId);
+		const observedExecutionStarted = executionSnapshot?.executionStarted ?? (conservativeRaceResponses.has(response) ? void 0 : response.executionStarted);
+		const terminalResolution = params.observeToolTerminal?.({
+			toolCallId: params.call.callId,
+			toolName: params.call.tool,
+			arguments: response.executedArguments ?? executionSnapshot?.executedArguments ?? params.call.arguments,
+			...params.toolMeta ? { meta: params.toolMeta } : {},
+			...observedExecutionStarted !== void 0 ? { executionStarted: observedExecutionStarted } : {},
+			outcome: response.success ? "success" : "failure",
+			...!response.success ? { failure: { error: readDynamicToolResponseText(response) } } : {}
+		});
+		return withDynamicToolTerminalResolution(response, terminalResolution);
+	};
+	const createFailedAfterPossibleDispatch = (message, terminalReason) => {
+		const response = createFailedDynamicToolResponse(message, {
+			executionStarted: true,
+			sideEffectEvidence: true,
+			terminalReason
+		});
+		conservativeRaceResponses.add(response);
+		return response;
+	};
 	const notifyAgentToolResult = (event) => {
 		if (didNotifyAgentToolResult) return;
 		didNotifyAgentToolResult = true;
@@ -1876,7 +2020,10 @@ async function handleDynamicToolCallWithTimeout(params) {
 		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
 		params.onFallbackSelected?.();
 		notifyFailedToolResult(message, terminalReason);
-		return failedDynamicToolResponse(message, { terminalReason });
+		return finalizeTerminal(createFailedDynamicToolResponse(message, {
+			executionStarted: false,
+			terminalReason
+		}));
 	}
 	const controller = new AbortController();
 	let timeout;
@@ -1888,10 +2035,7 @@ async function handleDynamicToolCallWithTimeout(params) {
 		params.onFallbackSelected?.();
 		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
 		notifyFailedToolResult(message, terminalReason);
-		resolveAbort?.(failedDynamicToolResponse(message, {
-			sideEffectEvidence: true,
-			terminalReason
-		}));
+		resolveAbort?.(createFailedAfterPossibleDispatch(message, terminalReason));
 	};
 	const abortPromise = new Promise((resolve) => {
 		resolveAbort = resolve;
@@ -1912,10 +2056,7 @@ async function handleDynamicToolCallWithTimeout(params) {
 				consoleMessage: timeoutDetails.consoleMessage
 			});
 			notifyFailedToolResult(timeoutDetails.responseMessage, "timed_out");
-			resolve(failedDynamicToolResponse(timeoutDetails.responseMessage, {
-				sideEffectEvidence: true,
-				terminalReason: "timed_out"
-			}));
+			resolve(createFailedAfterPossibleDispatch(timeoutDetails.responseMessage, "timed_out"));
 		}, timeoutMs);
 		timeout.unref?.();
 	});
@@ -1926,21 +2067,19 @@ async function handleDynamicToolCallWithTimeout(params) {
 			params.toolBridge.handleToolCall(params.call, {
 				signal: controller.signal,
 				onAgentToolResult: notifyAgentToolResult,
-				toolCallOrdinal: params.toolCallOrdinal
+				toolCallOrdinal: params.toolCallOrdinal,
+				retainExecutionSnapshot: true
 			}),
 			abortPromise,
 			timeoutPromise
 		]);
 		if (!response.success && !didNotifyAgentToolResult) notifyFailedToolResult(readDynamicToolResponseText(response), response.diagnosticTerminalReason ?? "failed");
-		return response;
+		return finalizeTerminal(response);
 	} catch (error) {
 		const terminalReason = params.signal.aborted ? resolveCodexToolAbortTerminalReason(params.signal) : resolveToolExecutionErrorKind(error);
 		const message = formatToolExecutionErrorMessage(error, "OpenClaw dynamic tool call failed.");
 		notifyFailedToolResult(message, terminalReason);
-		return failedDynamicToolResponse(message, {
-			sideEffectEvidence: true,
-			terminalReason
-		});
+		return finalizeTerminal(createFailedAfterPossibleDispatch(message, terminalReason));
 	} finally {
 		if (timeout) clearTimeout(timeout);
 		params.signal.removeEventListener("abort", abortFromRun);
@@ -1951,31 +2090,6 @@ async function handleDynamicToolCallWithTimeout(params) {
 function readDynamicToolResponseText(response) {
 	return response.contentItems.flatMap((item) => item.type === "inputText" && typeof item.text === "string" ? [item.text] : []).join("\n").trim() || "OpenClaw dynamic tool call failed.";
 }
-function failedDynamicToolResponse(message, options) {
-	const response = {
-		contentItems: [{
-			type: "inputText",
-			text: message
-		}],
-		success: false
-	};
-	Object.defineProperty(response, "diagnosticTerminalType", {
-		configurable: true,
-		enumerable: false,
-		value: "error"
-	});
-	Object.defineProperty(response, "diagnosticTerminalReason", {
-		configurable: true,
-		enumerable: false,
-		value: options?.terminalReason ?? "failed"
-	});
-	if (options?.sideEffectEvidence === true) Object.defineProperty(response, "sideEffectEvidence", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
-}
 /** Strips OpenClaw-only metadata before sending a dynamic tool response to Codex. */
 function toCodexDynamicToolProtocolResponse(response) {
 	return {
@@ -2181,6 +2295,7 @@ function createCodexNativeHookRelay(params) {
 		runId: params.runId,
 		...params.channelId ? { channelId: params.channelId } : {},
 		allowedEvents: params.events,
+		preToolUseLoopDetection: params.loopDetectionPreToolUseRelay,
 		ttlMs: resolveCodexNativeHookRelayTtlMs({
 			explicitTtlMs: params.options?.ttlMs,
 			attemptTimeoutMs: params.attemptTimeoutMs,
@@ -2239,7 +2354,8 @@ function buildCodexNativeHookRelayConfig(params) {
 		const codexEvent = CODEX_HOOK_EVENT_BY_NATIVE_EVENT[event];
 		const selected = selectedEvents.has(event);
 		const shouldRelay = params.relay.shouldRelayEvent(event);
-		if (!selected || !shouldRelay && !(selected && event === "pre_tool_use" && !shouldRelay)) {
+		const selectedNoopPreToolUse = selected && event === "pre_tool_use" && !shouldRelay && params.loopDetectionPreToolUseRelay;
+		if (!selected || !shouldRelay && !selectedNoopPreToolUse) {
 			if (selected || params.clearOmittedEvents) config[`hooks.${codexEvent}`] = [];
 			if (params.clearOmittedEvents) for (const sourcePath of CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS) hookState[`${sourcePath}:${CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[event]}:0:0`] = { enabled: false };
 			continue;
@@ -2382,12 +2498,12 @@ var CodexNativeToolLifecycleProjector = class {
 		this.preToolUseFailureByItem.set(failure.toolCallId, record);
 	}
 	recordRawWebSearchResult(item) {
-		if (readString$2(item, "type") !== "web_search_call") return;
-		const toolCallId = readString$2(item, "id");
+		if (readString$3(item, "type") !== "web_search_call") return;
+		const toolCallId = readString$3(item, "id");
 		if (!toolCallId || this.completedItemIds.has(toolCallId)) return;
 		const toolName = "web_search";
 		this.recordStarted(toolCallId, toolName, "unknown");
-		const rawStatus = readString$2(item, "status");
+		const rawStatus = readString$3(item, "status");
 		if (rawStatus === "in_progress" || rawStatus === "running") return;
 		const status = rawStatus === "completed" ? "completed" : rawStatus === "cancelled" ? "cancelled" : rawStatus === "failed" || rawStatus === "error" || rawStatus === "incomplete" ? "failed" : "unknown";
 		this.recordTerminal(toolCallId, toolName, status, { sourceTimestampMs: this.webSearchCompletionByItem.get(toolCallId)?.sourceTimestampMs });
@@ -2512,8 +2628,8 @@ var CodexReasoningProjection = class {
 		this.reasoningEnded = false;
 	}
 	async handleReasoningDelta(method, params) {
-		const itemId = readString$2(params, "itemId") ?? "reasoning";
-		const delta = readString$2(params, "delta") ?? "";
+		const itemId = readString$3(params, "itemId") ?? "reasoning";
+		const delta = readString$3(params, "delta") ?? "";
 		if (!delta) return;
 		this.reasoningStarted = true;
 		if (!this.reasoningItemOrder.has(itemId)) this.reasoningItemOrder.set(itemId, this.reasoningItemOrder.size);
@@ -2532,24 +2648,29 @@ var CodexReasoningProjection = class {
 		});
 	}
 	handlePlanDelta(params) {
-		const itemId = readString$2(params, "itemId") ?? "plan";
-		const delta = readString$2(params, "delta") ?? "";
+		const itemId = readString$3(params, "itemId") ?? "plan";
+		const delta = readString$3(params, "delta") ?? "";
 		if (!delta) return;
 		const text = `${this.planTextByItem.get(itemId) ?? ""}${delta}`;
 		this.planTextByItem.set(itemId, text);
 		this.emitPlanUpdate({
 			explanation: void 0,
-			steps: splitPlanText(text)
+			steps: splitPlanText(text).map((step) => ({
+				step,
+				status: "pending"
+			}))
 		});
 	}
 	handleTurnPlanUpdated(params) {
 		const plan = Array.isArray(params.plan) ? params.plan.flatMap((entry) => {
 			if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
 			const record = entry;
-			const step = readString$2(record, "step");
-			const status = readString$2(record, "status");
+			const step = readString$3(record, "step");
 			if (!step) return [];
-			return status ? [`${step} (${status})`] : [step];
+			return [{
+				step,
+				status: normalizePlanStepStatus(readString$3(record, "status"))
+			}];
 		}) : void 0;
 		this.emitPlanUpdate({
 			explanation: readNullableString(params, "explanation"),
@@ -2561,7 +2682,10 @@ var CodexReasoningProjection = class {
 			this.planTextByItem.set(item.id, item.text);
 			this.emitPlanUpdate({
 				explanation: void 0,
-				steps: splitPlanText(item.text)
+				steps: splitPlanText(item.text).map((step) => ({
+					step,
+					status: "pending"
+				}))
 			});
 		}
 	}
@@ -2590,6 +2714,10 @@ var CodexReasoningProjection = class {
 		});
 	}
 };
+function normalizePlanStepStatus(status) {
+	if (status === "inProgress" || status === "in_progress") return "in_progress";
+	return status === "completed" ? "completed" : "pending";
+}
 function collectReasoningTextValues(groups, itemOrder) {
 	return [...groups.values()].toSorted((left, right) => {
 		const itemDelta = (itemOrder.get(left.itemId) ?? Number.MAX_SAFE_INTEGER) - (itemOrder.get(right.itemId) ?? Number.MAX_SAFE_INTEGER);
@@ -2603,15 +2731,187 @@ function reasoningMethodOrder(method) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-usage.ts
-function normalizeCodexTokenUsage(record) {
+function readTokenCount(record, key) {
+	const value = readNonNegativeInteger(record, key);
+	return value !== void 0 && Number.isSafeInteger(value) ? value : void 0;
+}
+function normalizeCodexThreadTokenUsage(record) {
 	const inputTokens = readNumber(record, "inputTokens");
 	const cacheRead = readNumber(record, "cachedInputTokens");
-	return normalizeUsage({
+	const usage = normalizeUsage({
 		input: inputTokens !== void 0 && cacheRead !== void 0 ? Math.max(0, inputTokens - cacheRead) : inputTokens,
 		output: readNumber(record, "outputTokens"),
 		cacheRead,
 		total: readNumber(record, "totalTokens")
 	});
+	return usage ? {
+		...usage,
+		contextUsage: { state: "unavailable" }
+	} : void 0;
+}
+function normalizeCodexResponseTokenUsage(record) {
+	const totalTokens = readTokenCount(record, "totalTokens");
+	const inputTokens = readTokenCount(record, "inputTokens");
+	const cacheRead = readTokenCount(record, "cachedInputTokens");
+	const output = readTokenCount(record, "outputTokens");
+	const reasoningOutput = readTokenCount(record, "reasoningOutputTokens");
+	const cacheWrite = record.cacheWriteInputTokens === void 0 ? 0 : readTokenCount(record, "cacheWriteInputTokens");
+	if (totalTokens === void 0 || inputTokens === void 0 || cacheRead === void 0 || cacheWrite === void 0 || output === void 0 || reasoningOutput === void 0 || cacheRead + cacheWrite > inputTokens || totalTokens !== inputTokens + output) return;
+	const usage = normalizeUsage({
+		input: inputTokens - cacheRead - cacheWrite,
+		output,
+		cacheRead,
+		cacheWrite,
+		total: totalTokens
+	});
+	if (!usage) return;
+	return {
+		...usage,
+		contextUsage: {
+			state: "available",
+			promptTokens: inputTokens,
+			totalTokens
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/usage-limit-error.ts
+/**
+* Enriches Codex usage-limit failures with current rate-limit information and
+* marks blocked auth profiles when Codex exposes a reset time.
+*/
+const CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS = 5e3;
+function createCodexUsageLimitPromptError(message) {
+	return Object.assign(new Error(message), { status: 429 });
+}
+function isCodexUsageLimitPromptError(error) {
+	return error instanceof Error && "status" in error && error.status === 429;
+}
+/** Marks a Codex auth profile blocked until the reset time advertised by rate limits. */
+async function markCodexAuthProfileBlockedFromRateLimits(params) {
+	const authProfileId = params.authProfileId?.trim();
+	if (!authProfileId || !params.params.authProfileStore) return;
+	const blockedUntil = resolveCodexUsageLimitResetAtMs(params.rateLimits);
+	if (!blockedUntil) return;
+	try {
+		await markAuthProfileBlockedUntil({
+			store: params.params.authProfileStore,
+			profileId: authProfileId,
+			blockedUntil,
+			source: "codex_rate_limits",
+			agentDir: params.params.agentDir,
+			runId: params.params.runId,
+			modelId: params.params.modelId
+		});
+	} catch (error) {
+		embeddedAgentLog.debug("failed to mark Codex auth profile blocked from app-server limits", {
+			authProfileId,
+			error: formatErrorMessage(error)
+		});
+	}
+}
+/** Formats a turn-start usage-limit error, refreshing rate limits when needed. */
+async function formatCodexTurnStartUsageLimitError(params) {
+	return refreshCodexUsageLimitError({
+		client: params.client,
+		source: readCodexTurnStartUsageLimitErrorSource(params.client, params.error, params.errorNotification, params.rateLimitsRevisionBeforeTurnStart),
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+}
+/** Refreshes a generic prompt usage-limit message into a reset-aware message. */
+async function refreshCodexUsageLimitPromptError(params) {
+	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(params.message)) return;
+	return refreshCodexUsageLimitError({
+		client: params.client,
+		source: {
+			message: params.message,
+			codexErrorInfo: "usageLimitExceeded",
+			rateLimits: readRecentCodexRateLimits(params.client)
+		},
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+}
+async function refreshCodexUsageLimitError(params) {
+	const initialMessage = formatCodexUsageLimitErrorMessage(params.source);
+	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(initialMessage)) return initialMessage ? {
+		message: initialMessage,
+		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
+	} : void 0;
+	const rateLimits = await readCodexRateLimitsFromAppServerForUsageLimitError({
+		client: params.client,
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+	if (!rateLimits) return initialMessage ? {
+		message: initialMessage,
+		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
+	} : void 0;
+	const message = formatCodexUsageLimitErrorMessage({
+		message: params.source.message,
+		codexErrorInfo: params.source.codexErrorInfo,
+		rateLimits
+	}) ?? initialMessage;
+	return message ? {
+		message,
+		rateLimitsForProfile: rateLimits
+	} : void 0;
+}
+async function readCodexRateLimitsFromAppServerForUsageLimitError(params) {
+	if (params.signal?.aborted) return;
+	try {
+		const rateLimits = await params.client.request(CODEX_CONTROL_METHODS.rateLimits, void 0, {
+			timeoutMs: resolveCodexUsageLimitRateLimitRefreshTimeoutMs(params.timeoutMs),
+			signal: params.signal
+		});
+		rememberCodexRateLimitsRead(params.client, rateLimits);
+		return rateLimits;
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server rate-limit refresh failed after usage-limit error", { error: formatErrorMessage(error) });
+		return;
+	}
+}
+function resolveCodexUsageLimitRateLimitRefreshTimeoutMs(timeoutMs) {
+	if (timeoutMs === void 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS;
+	return Math.max(100, Math.min(timeoutMs, CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS));
+}
+function readCodexTurnStartUsageLimitErrorSource(client, error, errorNotification, rateLimitsRevisionBeforeTurnStart) {
+	const notificationError = readCodexErrorNotification(errorNotification);
+	const errorPayload = readCodexErrorPayload(error);
+	const rateLimits = errorPayload.rateLimits ?? readRecentCodexRateLimits(client);
+	const cacheUpdatedDuringTurnStart = rateLimitsRevisionBeforeTurnStart !== void 0 && readCodexRateLimitsRevision(client) > rateLimitsRevisionBeforeTurnStart;
+	return {
+		message: notificationError?.message ?? errorPayload.message ?? formatErrorMessage(error),
+		codexErrorInfo: notificationError?.codexErrorInfo ?? errorPayload.codexErrorInfo,
+		rateLimits,
+		rateLimitsTrustedForProfile: errorPayload.rateLimits !== void 0 || cacheUpdatedDuringTurnStart
+	};
+}
+function readCodexErrorNotification(notification) {
+	if (notification?.method !== "error" || !isJsonObject(notification.params)) return;
+	const error = notification.params.error;
+	return isJsonObject(error) ? {
+		message: readString$2(error, "message"),
+		codexErrorInfo: error.codexErrorInfo
+	} : void 0;
+}
+function readCodexErrorPayload(error) {
+	const message = error instanceof Error ? error.message : void 0;
+	if (!error || typeof error !== "object" || !("data" in error)) return { message };
+	const data = error.data;
+	if (!isJsonObject(data)) return { message };
+	const nestedError = isJsonObject(data.error) ? data.error : data;
+	const rateLimits = nestedError.rateLimits ?? data.rateLimits;
+	return {
+		message: readString$2(nestedError, "message") ?? message,
+		codexErrorInfo: nestedError.codexErrorInfo,
+		rateLimits
+	};
+}
+function readString$2(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector.ts
@@ -2725,10 +3025,14 @@ var CodexAppServerEventProjector = class {
 			case "turn/completed":
 				await this.handleTurnCompleted(params);
 				break;
+			case "rawResponse/completed":
+				this.handleRawResponseCompleted(params);
+				break;
 			case "rawResponseItem/completed":
 				await this.handleRawResponseItemCompleted(params);
 				break;
 			case "error":
+				this.responseUsage = void 0;
 				if (params.willRetry === true) break;
 				this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
 				this.promptErrorSource = "prompt";
@@ -2741,6 +3045,7 @@ var CodexAppServerEventProjector = class {
 		const assistantTexts = this.assistantProjection.collectAssistantTexts();
 		const reasoningText = this.reasoningProjection.reasoningText();
 		const planText = this.reasoningProjection.planText();
+		const projectedUsage = this.aborted ? this.tokenUsage : this.responseUsage ?? this.tokenUsage;
 		const hasAssistantItemText = this.assistantProjection.hasAssistantItemTextForSynthesis();
 		const legacyFailClosed = !this.completedTurn || this.completedTurn.status !== "completed" || hasAssistantItemText;
 		const hasDeliverableAssistantOnCompletedTurn = this.completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
@@ -2753,7 +3058,7 @@ var CodexAppServerEventProjector = class {
 			this.promptErrorSource = this.promptErrorSource ?? "prompt";
 		}
 		const assistantMessageOptions = {
-			tokenUsage: this.tokenUsage,
+			tokenUsage: projectedUsage,
 			aborted: this.aborted,
 			promptError: this.promptError
 		};
@@ -2806,7 +3111,7 @@ var CodexAppServerEventProjector = class {
 			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
 			successfulCronAdds: toolTelemetry.successfulCronAdds,
 			cloudCodeAssistFormatError: false,
-			attemptUsage: this.tokenUsage,
+			attemptUsage: projectedUsage,
 			replayMetadata: {
 				hadPotentialSideEffects,
 				replaySafe: !hadPotentialSideEffects
@@ -2835,13 +3140,14 @@ var CodexAppServerEventProjector = class {
 	}
 	markAborted() {
 		this.aborted = true;
+		this.responseUsage = void 0;
 	}
 	isCompacting() {
 		return this.activeCompactionItemIds.size > 0;
 	}
 	async handleItemStarted(params) {
 		const item = readItem(params.item);
-		const itemId = item?.id ?? readString$2(params, "itemId");
+		const itemId = item?.id ?? readString$3(params, "itemId");
 		this.assistantProjection.recordItemStarted(item, itemId);
 		if (itemId) this.activeItemIds.add(itemId);
 		this.recordNativeToolOutcome(item);
@@ -2896,7 +3202,7 @@ var CodexAppServerEventProjector = class {
 		const item = readItem(params.item);
 		this.recordNativeToolOutcome(item);
 		this.clearTerminalPresentationForNativeItem(item);
-		const itemId = item?.id ?? readString$2(params, "itemId");
+		const itemId = item?.id ?? readString$3(params, "itemId");
 		if (itemId) {
 			this.activeItemIds.delete(itemId);
 			this.completedItemIds.add(itemId);
@@ -2962,19 +3268,25 @@ var CodexAppServerEventProjector = class {
 		const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
 		const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
 		if (!last) return;
-		const usage = normalizeCodexTokenUsage(last);
+		const usage = normalizeCodexThreadTokenUsage(last);
 		if (usage) this.tokenUsage = usage;
 	}
+	handleRawResponseCompleted(params) {
+		const usage = isJsonObject(params.usage) ? params.usage : void 0;
+		this.responseUsage = usage ? normalizeCodexResponseTokenUsage(usage) : void 0;
+	}
 	async handleTurnCompleted(params) {
 		const turn = readCodexTurn(params.turn);
 		if (!turn || turn.id !== this.turnId) return;
 		this.completedTurn = turn;
+		if (turn.status !== "completed") this.responseUsage = void 0;
 		if (turn.status === "failed") {
-			this.promptError = formatCodexUsageLimitErrorMessage({
+			const usageLimitMessage = formatCodexUsageLimitErrorMessage({
 				message: turn.error?.message,
 				codexErrorInfo: turn.error?.codexErrorInfo,
 				rateLimits: this.options.readRecentRateLimits?.()
-			}) ?? turn.error?.message ?? "codex app-server turn failed";
+			});
+			this.promptError = usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : turn.error?.message ?? "codex app-server turn failed";
 			this.promptErrorSource = "prompt";
 		}
 		const turnItems = turn.items ?? [];
@@ -3051,11 +3363,12 @@ var CodexAppServerEventProjector = class {
 	}
 	formatCodexErrorMessage(params) {
 		const error = isJsonObject(params.error) ? params.error : void 0;
-		return formatCodexUsageLimitErrorMessage({
-			message: error ? readString$2(error, "message") : void 0,
+		const usageLimitMessage = formatCodexUsageLimitErrorMessage({
+			message: error ? readString$3(error, "message") : void 0,
 			codexErrorInfo: error?.codexErrorInfo,
 			rateLimits: this.options.readRecentRateLimits?.()
-		}) ?? readCodexErrorNotificationMessage(params);
+		});
+		return usageLimitMessage ? createCodexUsageLimitPromptError(usageLimitMessage) : readCodexErrorNotificationMessage(params);
 	}
 	emitAgentEvent(event) {
 		try {
@@ -3083,7 +3396,7 @@ var CodexAppServerEventProjector = class {
 		return threadId === this.threadId && turnId === this.turnId;
 	}
 	isHookNotificationForCurrentThread(params) {
-		const threadId = readString$2(params, "threadId");
+		const threadId = readString$3(params, "threadId");
 		const turnId = params.turnId;
 		return threadId === this.threadId && (turnId === this.turnId || turnId === null);
 	}
@@ -3121,12 +3434,72 @@ function addCodexMessageToolOnlyFinalParameter(parameters) {
 			...rawProperties,
 			final: {
 				type: "boolean",
-				description: "Set true only when this message is intended to complete the reply to the current source conversation. OpenClaw stops after confirming delivery."
+				description: "Set false for progress or true to complete the current source reply. If omitted, OpenClaw continues and resolves the latest omitted source reply when the turn ends."
 			}
 		}
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/shell-dynamic-tools.ts
+const CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME = "node_exec";
+const CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME = "node_process";
+const CODEX_NODE_EXEC_POLICY_PARAMETER_NAMES = /* @__PURE__ */ new Set([
+	"host",
+	"security",
+	"ask"
+]);
+/** Returns true when plugin config explicitly removes any named dynamic tool. */
+function isCodexDynamicToolExcluded(config, names) {
+	const normalizedNames = new Set(names.map((name) => normalizeCodexDynamicToolName(name)));
+	return (config.codexDynamicToolsExclude ?? []).some((name) => normalizedNames.has(normalizeCodexDynamicToolName(name)));
+}
+function createNodeExecDynamicTool(execTool, configuredNode) {
+	const pinnedNode = configuredNode?.trim();
+	return {
+		...execTool,
+		name: CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME,
+		description: pinnedNode ? "Run a shell command on the OpenClaw configured remote node for this session. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Use node_process for follow-up on backgrounded node_exec sessions. Use Codex's native shell for local app-server work." : "Run a shell command on an OpenClaw remote node. Select the node by name or id when multiple nodes are available. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Use node_process for follow-up on backgrounded node_exec sessions. Use Codex's native shell for local app-server work.",
+		parameters: hideNodeExecDynamicToolParameters(execTool.parameters, { hideNode: Boolean(pinnedNode) }),
+		execute: async (toolCallId, args, signal, onUpdate) => {
+			const result = await execTool.execute(toolCallId, pinNodeExecDynamicToolArgs(args, pinnedNode), signal, onUpdate);
+			return {
+				...result,
+				content: result.content.map((item) => item.type === "text" ? Object.assign({}, item, { text: item.text.replace("Use process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.", "Use node_process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.") }) : item)
+			};
+		}
+	};
+}
+function createNodeProcessDynamicTool(processTool) {
+	return {
+		...processTool,
+		name: CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME,
+		description: "Manage node_exec sessions that were started on OpenClaw remote nodes: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use only for node_exec follow-up; use Codex's native shell session handling for local app-server work."
+	};
+}
+function pinNodeExecDynamicToolArgs(args, configuredNode) {
+	const { host: _host, security: _security, ask: _ask, node: requestedNode, ...rest } = args && typeof args === "object" && !Array.isArray(args) ? args : {};
+	const node = configuredNode ?? (typeof requestedNode === "string" ? requestedNode.trim() : "");
+	return {
+		...rest,
+		host: "node",
+		...node ? { node } : {}
+	};
+}
+function hideNodeExecDynamicToolParameters(parameters, options) {
+	if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) return parameters;
+	const schema = parameters;
+	const rawProperties = schema.properties;
+	if (!rawProperties || typeof rawProperties !== "object" || Array.isArray(rawProperties)) return parameters;
+	const nextProperties = Object.fromEntries(Object.entries(rawProperties).filter(([name]) => !CODEX_NODE_EXEC_POLICY_PARAMETER_NAMES.has(normalizeCodexDynamicToolName(name)) && !(options.hideNode && normalizeCodexDynamicToolName(name) === "node")));
+	const rawRequired = schema.required;
+	const nextRequired = Array.isArray(rawRequired) ? rawRequired.filter((name) => typeof name !== "string" || !CODEX_NODE_EXEC_POLICY_PARAMETER_NAMES.has(normalizeCodexDynamicToolName(name)) && !(options.hideNode && normalizeCodexDynamicToolName(name) === "node")) : rawRequired;
+	return {
+		...schema,
+		properties: nextProperties,
+		...Array.isArray(rawRequired) ? { required: nextRequired } : {}
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/vision-tools.ts
 /**
 * Filters Codex dynamic tools for turns that already contain image inputs so
@@ -3153,13 +3526,6 @@ const CODEX_NATIVE_SANDBOX_TOOL_REQUIREMENTS = [
 	"apply_patch"
 ];
 const CODEX_MEMORY_FLUSH_DYNAMIC_TOOL_ALLOW = /* @__PURE__ */ new Set(["read", "write"]);
-const CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME = "node_exec";
-const CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME = "node_process";
-const CODEX_NODE_EXEC_POLICY_PARAMETER_NAMES = /* @__PURE__ */ new Set([
-	"host",
-	"security",
-	"ask"
-]);
 function preserveRingZeroSystemAgentTool(allTools, filteredTools) {
 	const openclaw = allTools.find((tool) => tool.name === "openclaw" && tool.catalogMode === "direct-only");
 	if (!openclaw) return filteredTools;
@@ -3248,8 +3614,8 @@ async function buildDynamicTools(input) {
 	const toolBuildStages = createCodexDynamicToolBuildStageTracker({ enabled: input.profilerEnabled });
 	const modelHasVision = params.model.input?.includes("image") ?? false;
 	const agentDir = params.agentDir ?? resolveAgentDir(params.config ?? {}, input.sessionAgentId);
-	const agentHarness = await import("openclaw/plugin-sdk/agent-harness");
-	const createOpenClawCodingTools = dynamicToolBuildState.openClawCodingToolsFactory ?? agentHarness.createOpenClawCodingTools;
+	const { createOpenClawCodingTools: defaultCreateOpenClawCodingTools, resolveWebSearchToolPolicy } = await import("openclaw/plugin-sdk/agent-harness");
+	const createOpenClawCodingTools = dynamicToolBuildState.openClawCodingToolsFactory ?? defaultCreateOpenClawCodingTools;
 	toolBuildStages.mark("load-agent-harness-tools");
 	const sessionKeys = resolveOpenClawCodingToolsSessionKeys(params, input.sandboxSessionKey);
 	const nativeExecutionPolicy = resolveCodexNativeExecutionPolicyForDynamicTools(input);
@@ -3346,7 +3712,7 @@ async function buildDynamicTools(input) {
 		nativeProviderWebSearchSupport: input.nativeProviderWebSearchSupport
 	});
 	const readableAllTools = [...readableAllToolProjection.tools];
-	const normallyProfiledTools = filterCodexDynamicTools(readableAllTools, input.pluginConfig);
+	const normallyProfiledTools = shouldKeepOpenClawShellDynamicTools(input, nativeExecutionPolicy) ? filterCodexDynamicToolsWithOpenClawShell(readableAllTools, input.pluginConfig) : filterCodexDynamicTools(readableAllTools, input.pluginConfig);
 	const profileFilteredTools = (input.isHostScopedToolActive?.("openclaw") ?? isHostScopedAgentToolActive("openclaw")) && isSystemAgentOnlyCodexDynamicToolAllowlist(params.toolsAllow) ? preserveRingZeroSystemAgentTool(readableAllTools, normallyProfiledTools) : normallyProfiledTools;
 	const codexFilteredTools = addNodeShellDynamicToolsIfNeeded(addSandboxShellDynamicToolsIfAvailable(isCodexMemoryFlushRun(params) ? filterCodexMemoryFlushDynamicTools(readableAllTools) : profileFilteredTools, readableAllTools, input), readableAllTools, input, nativeExecutionPolicy);
 	toolBuildStages.mark("codex-filtering");
@@ -3356,7 +3722,7 @@ async function buildDynamicTools(input) {
 	});
 	toolBuildStages.mark("vision-filtering");
 	const webSearchPresent = visionFilteredTools.some((tool) => tool.name === "web_search");
-	const webSearchPolicy = agentHarness.resolveWebSearchToolPolicy({
+	const webSearchPolicy = resolveWebSearchToolPolicy({
 		config: params.config,
 		modelProvider: params.model.provider,
 		modelId: params.modelId,
@@ -3570,13 +3936,6 @@ function shouldExposeSandboxExecDynamicTool(input) {
 	const backendId = input.sandbox?.enabled ? input.sandbox.backendId.trim().toLowerCase() : "";
 	return Boolean(backendId && input.nativeToolSurfaceEnabled === false);
 }
-function isCodexDynamicToolExcluded(config, names) {
-	const normalizedNames = new Set(names.map((name) => normalizeCodexDynamicToolName(name)));
-	return (config.codexDynamicToolsExclude ?? []).some((name) => {
-		const normalized = normalizeCodexDynamicToolName(name);
-		return normalizedNames.has(normalized);
-	});
-}
 function isSandboxShellDynamicToolExcluded(config) {
 	return isCodexDynamicToolExcluded(config, [
 		"exec",
@@ -3594,55 +3953,12 @@ function addNodeShellDynamicToolsIfNeeded(filteredTools, allTools, input, nodePo
 	const processTool = allTools.find((tool) => normalizeCodexDynamicToolName(tool.name) === "process");
 	if (!execTool || !processTool) return filteredTools;
 	const toolsToAppend = [];
-	if (!isCodexDynamicToolExcluded(input.pluginConfig, ["exec", CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME]) && !filteredTools.some((tool) => normalizeCodexDynamicToolName(tool.name) === CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME)) toolsToAppend.push(createNodeExecDynamicTool(execTool, nodePolicy.node));
-	if (!isCodexDynamicToolExcluded(input.pluginConfig, ["process", CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME]) && !filteredTools.some((tool) => normalizeCodexDynamicToolName(tool.name) === CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME)) toolsToAppend.push(createNodeProcessDynamicTool(processTool));
+	if (!isCodexDynamicToolExcluded(input.pluginConfig, ["exec", "node_exec"]) && !filteredTools.some((tool) => normalizeCodexDynamicToolName(tool.name) === "node_exec")) toolsToAppend.push(createNodeExecDynamicTool(execTool, nodePolicy.node));
+	if (!isCodexDynamicToolExcluded(input.pluginConfig, ["process", "node_process"]) && !filteredTools.some((tool) => normalizeCodexDynamicToolName(tool.name) === "node_process")) toolsToAppend.push(createNodeProcessDynamicTool(processTool));
 	return toolsToAppend.length > 0 ? [...filteredTools, ...toolsToAppend] : filteredTools;
 }
-function createNodeExecDynamicTool(execTool, configuredNode) {
-	const pinnedNode = configuredNode?.trim();
-	return {
-		...execTool,
-		name: CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME,
-		description: pinnedNode ? "Run a shell command on the OpenClaw configured remote node for this session. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Use node_process for follow-up on backgrounded node_exec sessions. Use Codex's native shell for local app-server work." : "Run a shell command on an OpenClaw remote node. Select the node by name or id when multiple nodes are available. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Use node_process for follow-up on backgrounded node_exec sessions. Use Codex's native shell for local app-server work.",
-		parameters: hideNodeExecDynamicToolParameters(execTool.parameters, { hideNode: Boolean(pinnedNode) }),
-		execute: async (toolCallId, args, signal, onUpdate) => {
-			const result = await execTool.execute(toolCallId, pinNodeExecDynamicToolArgs(args, pinnedNode), signal, onUpdate);
-			return {
-				...result,
-				content: result.content.map((item) => item.type === "text" ? Object.assign({}, item, { text: item.text.replace("Use process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.", "Use node_process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.") }) : item)
-			};
-		}
-	};
-}
-function createNodeProcessDynamicTool(processTool) {
-	return {
-		...processTool,
-		name: CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME,
-		description: "Manage node_exec sessions that were started on OpenClaw remote nodes: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use only for node_exec follow-up; use Codex's native shell session handling for local app-server work."
-	};
-}
-function pinNodeExecDynamicToolArgs(args, configuredNode) {
-	const { host: _host, security: _security, ask: _ask, node: requestedNode, ...rest } = args && typeof args === "object" && !Array.isArray(args) ? args : {};
-	const node = configuredNode ?? (typeof requestedNode === "string" ? requestedNode.trim() : "");
-	return {
-		...rest,
-		host: "node",
-		...node ? { node } : {}
-	};
-}
-function hideNodeExecDynamicToolParameters(parameters, options) {
-	if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) return parameters;
-	const schema = parameters;
-	const rawProperties = schema.properties;
-	if (!rawProperties || typeof rawProperties !== "object" || Array.isArray(rawProperties)) return parameters;
-	const nextProperties = Object.fromEntries(Object.entries(rawProperties).filter(([name]) => !CODEX_NODE_EXEC_POLICY_PARAMETER_NAMES.has(normalizeCodexDynamicToolName(name)) && !(options.hideNode && normalizeCodexDynamicToolName(name) === "node")));
-	const rawRequired = schema.required;
-	const nextRequired = Array.isArray(rawRequired) ? rawRequired.filter((name) => typeof name !== "string" || !CODEX_NODE_EXEC_POLICY_PARAMETER_NAMES.has(normalizeCodexDynamicToolName(name)) && !(options.hideNode && normalizeCodexDynamicToolName(name) === "node")) : rawRequired;
-	return {
-		...schema,
-		properties: nextProperties,
-		...Array.isArray(rawRequired) ? { required: nextRequired } : {}
-	};
+function shouldKeepOpenClawShellDynamicTools(input, nodePolicy) {
+	return !isCodexMemoryFlushRun(input.params) && input.nativeToolSurfaceEnabled === false && input.sandbox?.enabled !== true && nodePolicy.effectiveExecHost !== "node";
 }
 function resolveCodexNativeExecutionPolicyForDynamicTools(input) {
 	return resolveCodexNativeExecutionPolicy({
@@ -3663,7 +3979,7 @@ function filterCodexDynamicToolsForAllowlist(tools, toolsAllow) {
 	const allowSet = new Set(toolsAllow.map((name) => normalizeCodexDynamicToolName(name)).filter(Boolean));
 	return tools.filter((tool) => {
 		const normalized = normalizeCodexDynamicToolName(tool.name);
-		return allowSet.has(normalized) || normalized === "sandbox_exec" && allowSet.has("exec") || normalized === "sandbox_process" && (allowSet.has("exec") || allowSet.has("process")) || normalized === CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME && allowSet.has("exec") || normalized === CODEX_NODE_PROCESS_DYNAMIC_TOOL_NAME && (allowSet.has("exec") || allowSet.has("process"));
+		return allowSet.has(normalized) || normalized === "sandbox_exec" && allowSet.has("exec") || normalized === "sandbox_process" && (allowSet.has("exec") || allowSet.has("process")) || normalized === "node_exec" && allowSet.has("exec") || normalized === "node_process" && (allowSet.has("exec") || allowSet.has("process"));
 	});
 }
 /** Detects the wildcard allowlist marker after Codex tool-name normalization. */
@@ -3675,90 +3991,28 @@ function shouldForceMessageTool(params) {
 	return params.disableMessageTool !== true && params.sourceReplyDeliveryMode === "message_tool_only";
 }
 //#endregion
-//#region extensions/codex/src/app-server/attempt-timeouts.ts
-/**
-* Timeout defaults and normalizers for Codex app-server startup and turn
-* liveness watches.
-*/
-/** Minimum startup timeout accepted by the Codex app-server harness. */
-const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;
-/** Default idle timeout while waiting for app-server turn completion. */
-const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
-/** Short guard after apparent assistant completion. */
-const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
-const CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 5 * 6e4;
-/** Guard after reasoning/commentary progress when no tool handoff occurred. */
-const CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS = 5 * 6e4;
-/** Long terminal idle watch for app-server turns that never send completion. */
-const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
-function resolvePositiveIntegerTimeoutMs(value, fallbackMs) {
-	return resolveTimerTimeoutMs(value, resolveTimerTimeoutMs(fallbackMs, 1));
-}
-/** Runs startup work with abort and timeout handling plus optional cleanup. */
-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?.();
+//#region extensions/codex/src/app-server/source-reply-finality.ts
+const sourceReplyDeliveryIntents = /* @__PURE__ */ new WeakMap();
+/** Retain source-reply intent until the owning Codex turn has an authoritative outcome. */
+function recordCodexSourceReplyDeliveryIntent(owner, intent) {
+	const intents = sourceReplyDeliveryIntents.get(owner);
+	if (intents) {
+		intents.push(intent);
+		return;
 	}
+	sourceReplyDeliveryIntents.set(owner, [intent]);
 }
-/** Resolves startup timeout while honoring the configured floor. */
-function resolveCodexStartupTimeoutMs(params) {
-	const timeoutFloorMs = resolvePositiveIntegerTimeoutMs(params.timeoutFloorMs, CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS);
-	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
-	return Math.max(timeoutFloorMs, timeoutMs);
-}
-/** Resolves the completion-idle timeout for an active turn. */
-function resolveCodexTurnCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the short assistant-completion release timeout. */
-function resolveCodexTurnAssistantCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the conservative post-tool raw assistant guard timeout. */
-function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallbackMs) {
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(resolvePositiveIntegerTimeoutMs(void 0, fallbackMs), CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS));
-}
-/** Resolves the long terminal turn idle timeout. */
-function resolveCodexTurnTerminalIdleTimeoutMs(value, runTimeoutOverrideMs) {
-	const explicitRunBudgetMs = resolvePositiveIntegerTimeoutMs(runTimeoutOverrideMs, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS, explicitRunBudgetMs));
-}
-/** Adds gateway grace time to a caller timeout without overflowing invalid values. */
-function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
-	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
-	return addTimerTimeoutGraceMs(timeout, resolveTimerTimeoutMs(graceMs, 0, 0)) ?? timeout;
+/** Resolve omitted finality without changing explicit progress or final markers. */
+function settleCodexSourceReplyFinality(owner, turnSucceeded) {
+	const intents = sourceReplyDeliveryIntents.get(owner);
+	if (!intents) return false;
+	const lastIntent = intents.at(-1);
+	for (const intent of intents) {
+		if (intent.final !== void 0) continue;
+		intent.record.sourceReplyFinal = turnSucceeded && intent === lastIntent;
+	}
+	sourceReplyDeliveryIntents.delete(owner);
+	return turnSucceeded && intents.some((intent) => intent.record.sourceReplyFinal === true);
 }
 //#endregion
 //#region extensions/codex/src/app-server/provider-capabilities.ts
@@ -4580,6 +4834,7 @@ async function handleCodexAppServerApprovalRequest(params) {
 			paramsForRun: params.paramsForRun,
 			context,
 			nativeHookRelay: params.nativeHookRelay,
+			autoApprove: params.autoApprove,
 			signal: params.signal
 		});
 		if (policyOutcome?.outcome === "denied") {
@@ -4759,6 +5014,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 		context: params.context,
 		policyRequest,
 		nativeHookRelay: params.nativeHookRelay,
+		autoApprove: params.autoApprove,
 		cwd,
 		signal: params.signal
 	});
@@ -4867,6 +5123,11 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 		};
 		return { handled: true };
 	} catch (error) {
+		if (params.autoApprove === true && !hasNativeHookRelayInvocation({
+			relayId: params.nativeHookRelay.relayId,
+			event: "pre_tool_use",
+			toolUseId: params.context.approvalId
+		})) return;
 		return {
 			handled: true,
 			blocked: true,
@@ -5539,6 +5800,7 @@ function createCodexDynamicToolBridge(params) {
 		return getChannelAgentToolMeta(tool) === void 0;
 	};
 	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
+	const executionSnapshotStates = /* @__PURE__ */ new Map();
 	const directToolNames = /* @__PURE__ */ new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
 	return {
 		availableSpecs: createCodexDynamicToolSpecs({
@@ -5552,9 +5814,16 @@ function createCodexDynamicToolBridge(params) {
 			directToolNames
 		}),
 		telemetry,
+		consumeToolExecutionSnapshot: (toolCallId) => {
+			const state = executionSnapshotStates.get(toolCallId);
+			executionSnapshotStates.delete(toolCallId);
+			if (state) state.consumed = true;
+			return state?.snapshot;
+		},
 		handleToolCall: async (call, options) => {
 			const toolEntry = toolMap.get(call.tool);
 			if (!toolEntry) {
+				const executedArguments = jsonObjectToRecord(call.arguments);
 				const message = registeredToolNames.has(call.tool) ? `OpenClaw tool is not available for this turn: ${call.tool}` : `Unknown OpenClaw tool: ${call.tool}`;
 				finalizeToolTerminalPresentation({
 					toolCallId: call.callId,
@@ -5566,28 +5835,34 @@ function createCodexDynamicToolBridge(params) {
 					toolCallOrdinal: options?.toolCallOrdinal
 				});
 				notifyAgentToolResult(options?.onAgentToolResult, call.tool, failedToolResult(message), true);
-				if (registeredToolNames.has(call.tool)) return {
-					contentItems: [{
-						type: "inputText",
-						text: message
-					}],
-					success: false
-				};
-				return {
-					contentItems: [{
-						type: "inputText",
-						text: message
-					}],
-					success: false
-				};
+				return createFailedDynamicToolResponse(message, {
+					executedArguments,
+					executionStarted: false
+				});
 			}
 			const { tool, name: toolName } = toolEntry;
 			const args = jsonObjectToRecord(call.arguments);
 			const startedAt = Date.now();
 			const signal = composeAbortSignals(params.signal, options?.signal);
 			let didStartExecution = false;
+			let didDispatchExecution = false;
 			let executionPrevented = false;
 			let executedArgs = structuredClone(args);
+			const executionSnapshotState = {
+				consumed: false,
+				retainAfterCompletion: options?.retainExecutionSnapshot === true
+			};
+			executionSnapshotStates.set(call.callId, executionSnapshotState);
+			const captureExecutionBoundary = () => {
+				didStartExecution ||= didDispatchExecution;
+				executionPrevented = executionPrevented || consumePreExecutionBlockedToolCall(call.callId, toolResultHookContext.runId);
+				const adjustedExecutedArgs = consumeAdjustedParamsForToolCall(call.callId, toolResultHookContext.runId);
+				if (isRecord(adjustedExecutedArgs)) executedArgs = adjustedExecutedArgs;
+				if (!executionSnapshotState.consumed) executionSnapshotState.snapshot = {
+					executedArguments: structuredClone(executedArgs),
+					executionStarted: didStartExecution && !executionPrevented
+				};
+			};
 			try {
 				const preparedArgs = tool.prepareArguments ? tool.prepareArguments(args) : args;
 				const telemetryArgs = isRecord(preparedArgs) ? preparedArgs : args;
@@ -5600,13 +5875,11 @@ function createCodexDynamicToolBridge(params) {
 					replyToMode: params.hookContext?.replyToMode,
 					hasRepliedRef: params.hookContext?.hasRepliedRef ? { value: params.hookContext.hasRepliedRef.value } : void 0
 				};
-				didStartExecution = true;
+				didDispatchExecution = true;
 				const rawResult = await tool.execute(call.callId, preparedArgs, signal);
-				const adjustedExecutedArgs = consumeAdjustedParamsForToolCall(call.callId, toolResultHookContext.runId);
-				if (isRecord(adjustedExecutedArgs)) executedArgs = structuredClone(adjustedExecutedArgs);
-				executionPrevented = consumePreExecutionBlockedToolCall(call.callId, toolResultHookContext.runId);
+				captureExecutionBoundary();
 				const telemetryRawResult = sanitizeToolResult(rawResult);
-				const rawIsError = isCodexToolResultError(rawResult);
+				const rawIsError = isToolResultError(rawResult);
 				const rawResultFailureKind = resolveToolResultFailureKind(rawResult);
 				const middlewareResult = await middlewareRunner.applyToolResultMiddleware({
 					threadId: call.threadId,
@@ -5625,7 +5898,7 @@ function createCodexDynamicToolBridge(params) {
 					args: structuredClone(executedArgs),
 					result: middlewareResult
 				});
-				const resultIsError = rawIsError || isCodexToolResultError(result);
+				const resultIsError = rawIsError || isToolResultError(result);
 				const finalResultFailureKind = resolveToolResultFailureKind(result);
 				const resultFailureKind = rawResultFailureKind ?? finalResultFailureKind;
 				const observerResult = rawResultFailureKind && finalResultFailureKind !== rawResultFailureKind ? {
@@ -5689,8 +5962,9 @@ function createCodexDynamicToolBridge(params) {
 				}) && (replyReceiptMatchesCurrentMessage(rawResult, params.hookContext) || replyReceiptMatchesCurrentMessage(result, params.hookContext));
 				const toolConfirmedSourceReply = params.hookContext?.sourceReplyDeliveryMode === "message_tool_only" && toolName === "message" && !resultIsError && (rawResult.terminate === true || result.terminate === true);
 				const hasExplicitFinalControl = typeof executedArgs.final === "boolean";
-				const sourceReplyFinal = params.hookContext?.sourceReplyDeliveryMode === "message_tool_only" && toolName === "message" && (toolConfirmedSourceReply || deliveredSourceReply || receiptConfirmedSourceReply) ? hasExplicitFinalControl ? executedArgs.final === true : true : void 0;
-				collectToolTelemetry({
+				const confirmedSourceReply = params.hookContext?.sourceReplyDeliveryMode === "message_tool_only" && toolName === "message" && (toolConfirmedSourceReply || deliveredSourceReply || receiptConfirmedSourceReply);
+				const sourceReplyFinal = confirmedSourceReply ? hasExplicitFinalControl ? executedArgs.final === true : void 0 : void 0;
+				const sourceReplyRecord = collectToolTelemetry({
 					toolName,
 					args: executedArgs,
 					result,
@@ -5700,17 +5974,26 @@ function createCodexDynamicToolBridge(params) {
 					messagingTarget: confirmedMessagingTarget,
 					sourceReplyFinal
 				});
+				if (confirmedSourceReply && sourceReplyRecord) recordCodexSourceReplyDeliveryIntent(telemetry, {
+					record: sourceReplyRecord,
+					final: sourceReplyFinal
+				});
 				if (deliveredSourceReply || receiptConfirmedSourceReply || toolConfirmedSourceReply) telemetry.didDeliverSourceReplyViaMessageTool = true;
-				withDynamicToolTermination(response, (rawResult.terminate === true || result.terminate === true) && !(params.hookContext?.sourceReplyDeliveryMode === "message_tool_only" && toolName === "message" && executedArgs.final === false) || isToolResultYield(rawResult) || isToolResultYield(result) || (deliveredSourceReply || receiptConfirmedSourceReply) && executedArgs.final !== false);
+				const defersInferredSourceReplyTermination = confirmedSourceReply && executedArgs.final !== true;
+				withDynamicToolTermination(response, (rawResult.terminate === true || result.terminate === true) && !defersInferredSourceReplyTermination || isToolResultYield(rawResult) || isToolResultYield(result) || confirmedSourceReply && executedArgs.final === true);
 				const asyncStarted = isAsyncStartedToolResult(rawResult) || isAsyncStartedToolResult(result);
 				withDynamicToolAsyncStarted(response, asyncStarted);
-				return withSideEffectEvidence(response, !(executionPrevented || !asyncStarted && isReplaySafeToolInstance(toolEntry.tool) && isReplaySafeToolCall(toolName, executedArgs)));
+				const replaySafe = executionPrevented || !asyncStarted && isReplaySafeToolInstance(toolEntry.tool) && isReplaySafeToolCall(toolName, executedArgs);
+				return withDynamicToolExecutionState(response, {
+					executedArguments: executedArgs,
+					executionStarted: didStartExecution && !executionPrevented,
+					sideEffectEvidence: !replaySafe
+				});
 			} catch (error) {
+				captureExecutionBoundary();
 				if (toolName === "computer" && params.computerContextEpoch?.frameToolCallId === call.callId) invalidateComputerFrame(params.computerContextEpoch);
 				const executionDisposition = getBeforeToolCallFailureDisposition(error) ?? (signal.aborted ? resolveCodexToolAbortTerminalReason(signal) : resolveToolExecutionErrorKind(error));
 				const errorMessage = formatToolExecutionErrorMessage(error, "OpenClaw dynamic tool call failed.");
-				const adjustedExecutedArgs = consumeAdjustedParamsForToolCall(call.callId, toolResultHookContext.runId);
-				if (isRecord(adjustedExecutedArgs)) executedArgs = structuredClone(adjustedExecutedArgs);
 				executionPrevented = executionPrevented || consumePreExecutionBlockedToolCall(call.callId, toolResultHookContext.runId);
 				const failedResult = failedToolResult(errorMessage, executionDisposition);
 				finalizeToolTerminalPresentation({
@@ -5743,13 +6026,20 @@ function createCodexDynamicToolBridge(params) {
 					startedAt
 				});
 				const replaySafe = !didStartExecution || executionPrevented || isReplaySafeToolInstance(toolEntry.tool) && isReplaySafeToolCall(toolName, executedArgs);
-				return withSideEffectEvidence(withDiagnosticFailureDisposition({
+				return withDynamicToolExecutionState(withDiagnosticFailureDisposition({
 					contentItems: [{
 						type: "inputText",
 						text: errorMessage
 					}],
 					success: false
-				}, executionDisposition), didStartExecution && !replaySafe);
+				}, executionDisposition), {
+					executedArguments: executedArgs,
+					executionStarted: didStartExecution && !executionPrevented,
+					sideEffectEvidence: didStartExecution && !replaySafe
+				});
+			} finally {
+				if (executionSnapshotStates.get(call.callId) === executionSnapshotState && (executionSnapshotState.consumed || !executionSnapshotState.retainAfterCompletion)) executionSnapshotStates.delete(call.callId);
+				consumeAdjustedParamsForToolCall(call.callId, toolResultHookContext.runId);
 			}
 		}
 	};
@@ -5877,7 +6167,12 @@ function projectCodexDynamicTools(tools) {
 			quarantinedTools.push(descriptor.diagnostic);
 			continue;
 		}
-		const projection = projectRuntimeToolInputSchema(descriptor.parameters, `${descriptor.name}.inputSchema`);
+		const normalizedParameters = normalizeOpenAIToolSchemas({
+			provider: "openai",
+			modelApi: "openai-chatgpt-responses",
+			tools: [{ parameters: descriptor.parameters }]
+		})[0]?.parameters;
+		const projection = projectRuntimeToolInputSchema(normalizedParameters ?? descriptor.parameters, `${descriptor.name}.inputSchema`);
 		if (projection.violations.length > 0) {
 			quarantinedTools.push({
 				tool: descriptor.name,
@@ -6032,11 +6327,12 @@ function collectToolTelemetry(params) {
 	params.telemetry.didSendViaMessagingTool = true;
 	const sourceReplyPayload = extractInternalSourceReplyPayload(params.result?.details);
 	if (sourceReplyPayload) {
-		params.telemetry.messagingToolSourceReplyPayloads.push({
+		const record = {
 			...sourceReplyPayload,
 			...params.sourceReplyFinal !== void 0 ? { sourceReplyFinal: params.sourceReplyFinal } : {}
-		});
-		return;
+		};
+		params.telemetry.messagingToolSourceReplyPayloads.push(record);
+		return record;
 	}
 	const text = readFirstString(params.args, [
 		"text",
@@ -6047,7 +6343,7 @@ function collectToolTelemetry(params) {
 	if (text) params.telemetry.messagingToolSentTexts.push(text);
 	const mediaUrls = collectMediaUrls(params.args);
 	params.telemetry.messagingToolSentMediaUrls.push(...mediaUrls);
-	params.telemetry.messagingToolSentTargets.push({
+	const record = {
 		...params.messagingTarget ?? {
 			tool: params.toolName,
 			provider: readFirstString(params.args, ["provider", "channel"]) ?? params.toolName,
@@ -6066,7 +6362,9 @@ function collectToolTelemetry(params) {
 		...text ? { text } : {},
 		...mediaUrls.length > 0 ? { mediaUrls } : {},
 		...params.sourceReplyFinal !== void 0 ? { sourceReplyFinal: params.sourceReplyFinal } : {}
-	});
+	};
+	params.telemetry.messagingToolSentTargets.push(record);
+	return record;
 }
 function extractInternalSourceReplyPayload(details) {
 	if (!isRecord(details) || details.sourceReplySink !== "internal-ui") return;
@@ -6087,17 +6385,6 @@ function extractInternalSourceReplyPayload(details) {
 	};
 	return text || mediaUrls.length > 0 || payload.presentation || payload.interactive ? payload : void 0;
 }
-function isCodexToolResultError(result) {
-	if (isToolResultError(result)) return true;
-	const details = result.details;
-	if (!isRecord(details)) return false;
-	if (details.ok === true || details.success === true) return false;
-	if (details.timedOut === true) return true;
-	if (typeof details.exitCode === "number" && details.exitCode !== 0) return true;
-	if (typeof details.status !== "string") return false;
-	const status = details.status.trim().toLowerCase();
-	return status !== "" && status !== "0" && status !== "ok" && status !== "success" && status !== "completed" && status !== "recorded" && status !== "created" && status !== "updated" && status !== "accepted" && status !== "found" && status !== "missing" && status !== "pending" && status !== "started" && status !== "running" && status !== "yielded";
-}
 function isToolResultYield(result) {
 	const details = result.details;
 	if (!isRecord(details) || typeof details.status !== "string") return false;
@@ -6125,15 +6412,6 @@ function withDiagnosticFailureDisposition(response, disposition) {
 	});
 	return response;
 }
-function withSideEffectEvidence(response, sideEffectEvidence) {
-	if (!sideEffectEvidence) return response;
-	Object.defineProperty(response, "sideEffectEvidence", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
-}
 function withDynamicToolTermination(response, terminate) {
 	if (!terminate) return response;
 	Object.defineProperty(response, "terminate", {
@@ -6274,4 +6552,4 @@ function isCronAddAction(args) {
 	return typeof action === "string" && action.trim().toLowerCase() === "add";
 }
 //#endregion
-export { inferCodexDynamicToolMeta as $, CodexNativeToolLifecycleProjector as A, handleDynamicToolCallWithTimeout as B, resolveCodexMessageToolProvider as C, shouldWarnCodexDynamicToolBuildStageSummary as D, shouldRequireCodexSandboxExecServerEnvironment as E, createCodexNativeHookRelay as F, resolveTerminalDynamicToolBatchAction as G, isDynamicToolTerminalDiagnosticEvent as H, emitCodexNativePreToolUseFailureDiagnostic as I, toCodexDynamicToolProgressResponse as J, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as K, resolveCodexNativeHookRelayEvents as L, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as M, buildCodexNativeHookRelayConfig as N, filterToolsForVisionInputs as O, buildCodexNativeHookRelayDisabledConfig as P, shouldEmitTranscriptToolProgress as Q, resolveCodexNativeHookRelayTtlMs as R, resolveCodexExternalSandboxPolicyForOpenClawSandbox as S, shouldEnableCodexAppServerNativeToolSurface as T, isMatchingDynamicToolTerminalDiagnostic as U, hasPendingDynamicToolTerminalDiagnostic as V, resolveDynamicToolCallTimeoutMs as W, resolveCodexToolAbortTerminalReason as X, toCodexDynamicToolProtocolResponse as Y, readCodexMirroredSessionHistoryMessages as Z, createCodexDynamicToolBuildStageTracker as _, emitDynamicToolStartedDiagnostic as a, resolveCodexAppServerExecutionCwd as b, resolveCodexProviderWebSearchSupportForClient as c, resolveCodexStartupTimeoutMs as d, resolveCodexToolProgressDetailMode as et, resolveCodexTurnAssistantCompletionIdleTimeoutMs as f, buildDynamicTools as g, withCodexStartupTimeout as h, emitDynamicToolErrorDiagnostic as i, CODEX_NATIVE_HOOK_RELAY_EVENTS as j, CodexAppServerEventProjector as k, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as l, resolveCodexTurnTerminalIdleTimeoutMs as m, handleCodexAppServerApprovalRequest as n, sanitizeCodexToolResponse as nt, emitDynamicToolTerminalDiagnostic as o, resolveCodexTurnCompletionIdleTimeoutMs as p, shouldReleaseTurnAfterTerminalDynamicTool as q, handleCodexAppServerElicitationRequest as r, resolveCodexLocalRuntimeAttribution as rt, resolveCodexProviderWebSearchSupport as s, createCodexDynamicToolBridge as t, sanitizeCodexToolArguments as tt, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as u, disableCodexPluginThreadConfig as v, resolveCodexSandboxEnvironmentSelection as w, resolveCodexAppServerHookChannelId as x, formatCodexDynamicToolBuildStageSummary as y, scheduleCodexNativeHookRelayUnregister as z };
+export { resolveCodexToolProgressDetailMode as $, CODEX_NATIVE_HOOK_RELAY_EVENTS as A, hasPendingDynamicToolTerminalDiagnostic as B, CodexAppServerEventProjector as C, markCodexAuthProfileBlockedFromRateLimits as D, isCodexUsageLimitPromptError as E, emitCodexNativePreToolUseFailureDiagnostic as F, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as G, isMatchingDynamicToolTerminalDiagnostic as H, resolveCodexNativeHookRelayEvents as I, toCodexDynamicToolProtocolResponse as J, shouldReleaseTurnAfterTerminalDynamicTool as K, resolveCodexNativeHookRelayTtlMs as L, buildCodexNativeHookRelayConfig as M, buildCodexNativeHookRelayDisabledConfig as N, refreshCodexUsageLimitPromptError as O, createCodexNativeHookRelay as P, inferCodexDynamicToolMeta as Q, scheduleCodexNativeHookRelayUnregister as R, filterToolsForVisionInputs as S, formatCodexTurnStartUsageLimitError as T, resolveDynamicToolCallTimeoutMs as U, isDynamicToolTerminalDiagnosticEvent as V, resolveTerminalDynamicToolBatchAction as W, readCodexMirroredSessionHistoryMessages as X, resolveCodexToolAbortTerminalReason as Y, shouldEmitTranscriptToolProgress as Z, resolveCodexMessageToolProvider as _, emitDynamicToolStartedDiagnostic as a, shouldRequireCodexSandboxExecServerEnvironment as b, resolveCodexProviderWebSearchSupportForClient as c, createCodexDynamicToolBuildStageTracker as d, sanitizeCodexToolArguments as et, disableCodexPluginThreadConfig as f, resolveCodexExternalSandboxPolicyForOpenClawSandbox as g, resolveCodexAppServerHookChannelId as h, emitDynamicToolErrorDiagnostic as i, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as j, CodexNativeToolLifecycleProjector as k, settleCodexSourceReplyFinality as l, resolveCodexAppServerExecutionCwd as m, handleCodexAppServerApprovalRequest as n, resolveCodexLocalRuntimeAttribution as nt, emitDynamicToolTerminalDiagnostic as o, formatCodexDynamicToolBuildStageSummary as p, toCodexDynamicToolProgressResponse as q, handleCodexAppServerElicitationRequest as r, resolveCodexProviderWebSearchSupport as s, createCodexDynamicToolBridge as t, sanitizeCodexToolResponse as tt, buildDynamicTools as u, resolveCodexSandboxEnvironmentSelection as v, createCodexUsageLimitPromptError as w, shouldWarnCodexDynamicToolBuildStageSummary as x, shouldEnableCodexAppServerNativeToolSurface as y, handleDynamicToolCallWithTimeout as z };