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

package/dist/{provider-capabilities-CE5k8cmO.js → provider-capabilities-gTCwjfmh.js}

@@ -1,18 +1,335 @@
-import { n as isJsonObject } from "./protocol-dh-ETiNd.js";
-import { C as isForcedPrivateQaCodexRuntime, S as filterCodexDynamicTools, _ as resolveCodexWebSearchPlan, w as normalizeCodexDynamicToolName, x as sanitizeInlineImageDataUrl, y as invalidInlineImageText } from "./thread-lifecycle-DeSMZSXr.js";
-import { c as isTrustedCodexModelBackedOpenAIProvider, u as readCodexPluginConfig } from "./config-C_whBx3M.js";
-import { a as formatCodexDisplayText } from "./app-server-policy-xi0ZmBGO.js";
-import { o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-rR6TDJA3.js";
-import { i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-pTY2COoC.js";
-import { addTimerTimeoutGraceMs, finiteSecondsToTimerSafeMilliseconds, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { asOptionalRecord, isRecord, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { r as isJsonObject } from "./protocol-2POPqAY4.js";
+import { c as isTrustedCodexModelBackedOpenAIProvider, u as readCodexPluginConfig } from "./config-CYEDnLJ2.js";
+import { c as readCodexTurn } from "./protocol-validators-dZQ-UTOa.js";
+import { C as isForcedPrivateQaCodexRuntime, S as filterCodexDynamicTools, _ as resolveCodexWebSearchPlan, b as sanitizeCodexHistoryImagePayloads, w as normalizeCodexDynamicToolName, x as sanitizeInlineImageDataUrl, y as invalidInlineImageText } from "./thread-lifecycle-BskXnNP-.js";
+import { c as formatCodexUsageLimitErrorMessage } from "./provider-cc_62eQE.js";
+import { o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-4ICy3U6d.js";
+import { a as formatCodexDisplayText } from "./app-server-policy-BUk0GLMy.js";
+import { i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-DA2TQfZW.js";
+import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-Bo7KB3ks.js";
+import fs from "node:fs/promises";
+import { addTimerTimeoutGraceMs, asDateTimestampMs, finiteSecondsToTimerSafeMilliseconds, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } 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 { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-import { HEARTBEAT_RESPONSE_TOOL_NAME, buildAgentHookContextChannelFields, buildEmbeddedAttemptToolRunContext, callGatewayTool, consumeAdjustedParamsForToolCall, consumePreExecutionBlockedToolCall, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractMessagingToolSend, extractMessagingToolSendResult, extractToolResultMediaArtifact, filterProviderNormalizableTools, filterToolResultMediaUrls, finalizeToolTerminalPresentation, formatApprovalDisplayPath, getChannelAgentToolMeta, getPluginToolMeta, hasNativeHookRelayInvocation, invokeNativeHookRelay, isDeliveredMessageToolOnlySourceReplyResult, isDeliveredMessagingToolResult, isMessagingTool, isMessagingToolSendAction, isReplaySafeToolCall, isSubagentSessionKey, isToolResultError, isToolWrappedWithBeforeToolCallHook, normalizeAgentRuntimeTools, normalizeHeartbeatToolResponse, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveNativeHookRelayDeferredToolApproval, runAgentHarnessAfterToolCallHook, runBeforeToolCallHook, sanitizeToolResult, setBeforeToolCallDiagnosticsEnabled, supportsModelTools, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { emitTrustedDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { asOptionalRecord, isRecord, normalizeOptionalString, 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, isMessagingTool, isMessagingToolSendAction, isReplaySafeToolCall, isSubagentSessionKey, isToolResultError, isToolWrappedWithBeforeToolCallHook, normalizeAgentRuntimeTools, normalizeHeartbeatToolResponse, normalizeUsage, projectRuntimeToolInputSchema, registerNativeHookRelay, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveNativeHookRelayDeferredToolApproval, resolveToolExecutionErrorKind, resolveToolResultFailureKind, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessBeforeMessageWriteHook, runBeforeToolCallHook, sanitizeToolResult, setBeforeToolCallDiagnosticsEnabled, supportsModelTools, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { redactSensitiveFieldValue, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
+import { emitTrustedDiagnosticEvent, hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";
 import { buildExecAutoReviewInputForShellCommand, reviewExecRequestWithConfiguredModel } from "openclaw/plugin-sdk/agent-harness-exec-review-runtime";
+import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "openclaw/plugin-sdk/agent-sessions";
+import { publishSessionTranscriptUpdateByIdentity, resolveSessionTranscriptTarget, withSessionTranscriptWriteLock } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { generatedImageAssetFromBase64 } from "openclaw/plugin-sdk/image-generation";
+import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
+//#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([
+	"codex_startup_timeout",
+	"turn_completion_idle_timeout",
+	"turn_progress_idle_timeout",
+	"turn_terminal_idle_timeout"
+]);
+/** Preserves timeout provenance when an enclosing run aborts an active tool. */
+function resolveCodexToolAbortTerminalReason(signal) {
+	try {
+		const reason = signal.reason;
+		if (typeof reason === "string") {
+			if (CODEX_TIMEOUT_ABORT_REASONS.has(reason)) return "timed_out";
+			return reason === "client_closed" ? "failed" : "cancelled";
+		}
+		if (reason && typeof reason === "object") {
+			const record = reason;
+			if (record.name === "TimeoutError" || record.reason === "timeout") return "timed_out";
+		}
+	} catch {
+		return "cancelled";
+	}
+	return "cancelled";
+}
+/** Hard cap for per-call Codex dynamic tool timeout overrides. */
+const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 6e5;
+const CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS = 3e4;
+const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12e4;
+/** Timeout for message-delivery dynamic tool calls. */
+const CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS = 12e4;
+const LOG_FIELD_MAX_LENGTH = 160;
+function normalizeLogField(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.replaceAll(String.fromCharCode(27), " ").replaceAll("\r", " ").replaceAll("\n", " ").replaceAll("	", " ").trim();
+	if (!normalized) return;
+	return normalized.length > LOG_FIELD_MAX_LENGTH ? `${normalized.slice(0, LOG_FIELD_MAX_LENGTH - 3)}...` : normalized;
+}
+function readNumericTimeoutMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return Math.max(0, Math.floor(value));
+	if (typeof value === "string") {
+		const parsed = parseStrictNonNegativeInteger(value);
+		if (parsed !== void 0) return Math.max(0, Math.floor(parsed));
+	}
+}
+function formatDynamicToolTimeoutDetails(params) {
+	const tool = normalizeLogField(params.call.tool) ?? "unknown";
+	const baseMeta = {
+		tool: params.call.tool,
+		toolCallId: params.call.callId,
+		threadId: params.call.threadId,
+		turnId: params.call.turnId,
+		timeoutMs: params.timeoutMs,
+		timeoutKind: "codex_dynamic_tool_rpc"
+	};
+	if (tool !== "process" || !isJsonObject(params.call.arguments)) return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms while running tool ${tool}.`,
+		consoleMessage: `codex dynamic tool timeout: tool=${tool} toolTimeoutMs=${params.timeoutMs}; per-tool-call watchdog, not session idle`,
+		meta: baseMeta
+	};
+	const action = normalizeLogField(params.call.arguments.action);
+	const sessionId = normalizeLogField(params.call.arguments.sessionId);
+	const requestedTimeoutMs = readNumericTimeoutMs(params.call.arguments.timeout);
+	const actionPart = action ? ` action=${action}` : "";
+	const sessionPart = sessionId ? ` sessionId=${sessionId}` : "";
+	const requestedPart = requestedTimeoutMs === void 0 ? "" : ` requestedWaitMs=${requestedTimeoutMs}`;
+	const retryHint = action === "poll" ? "; repeated lines usually mean process-poll retry churn, not model progress" : "";
+	const responseTarget = action || sessionId ? ` while waiting for process${actionPart}${sessionPart}` : " while waiting for the process tool";
+	return {
+		responseMessage: `OpenClaw dynamic tool call timed out after ${params.timeoutMs}ms${responseTarget}. This is a tool RPC timeout, not a session idle timeout.`,
+		consoleMessage: `codex process tool timeout:${actionPart}${sessionPart} toolTimeoutMs=${params.timeoutMs}${requestedPart}; per-tool-call watchdog, not session idle${retryHint}`,
+		meta: {
+			...baseMeta,
+			processAction: action,
+			processSessionId: sessionId,
+			processRequestedTimeoutMs: requestedTimeoutMs
+		}
+	};
+}
+/**
+* Runs a dynamic tool call with run-abort and per-call timeout handling,
+* returning a Codex protocol response instead of throwing.
+*/
+async function handleDynamicToolCallWithTimeout(params) {
+	let didNotifyAgentToolResult = false;
+	const notifyAgentToolResult = (event) => {
+		if (didNotifyAgentToolResult) return;
+		didNotifyAgentToolResult = true;
+		try {
+			params.onAgentToolResult?.(event);
+		} catch (error) {
+			embeddedAgentLog.warn(`onAgentToolResult handler failed: tool=${params.call.tool} error=${String(error)}`);
+		}
+	};
+	const notifyFailedToolResult = (message, terminalReason = "failed") => {
+		notifyAgentToolResult({
+			toolName: params.call.tool,
+			result: {
+				content: [{
+					type: "text",
+					text: message
+				}],
+				details: {
+					status: terminalReason,
+					error: message
+				}
+			},
+			isError: true
+		});
+	};
+	if (params.signal.aborted) {
+		const message = "OpenClaw dynamic tool call aborted before execution.";
+		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
+		params.onFallbackSelected?.();
+		notifyFailedToolResult(message, terminalReason);
+		return failedDynamicToolResponse(message, { terminalReason });
+	}
+	const controller = new AbortController();
+	let timeout;
+	let timedOut = false;
+	let resolveAbort;
+	const abortFromRun = () => {
+		const message = "OpenClaw dynamic tool call aborted.";
+		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
+		params.onFallbackSelected?.();
+		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
+		notifyFailedToolResult(message, terminalReason);
+		resolveAbort?.(failedDynamicToolResponse(message, {
+			sideEffectEvidence: true,
+			terminalReason
+		}));
+	};
+	const abortPromise = new Promise((resolve) => {
+		resolveAbort = resolve;
+	});
+	const timeoutPromise = new Promise((resolve) => {
+		const timeoutMs = clampDynamicToolTimeoutMs(params.timeoutMs);
+		timeout = setTimeout(() => {
+			timedOut = true;
+			const timeoutDetails = formatDynamicToolTimeoutDetails({
+				call: params.call,
+				timeoutMs
+			});
+			params.onFallbackSelected?.();
+			controller.abort(new Error(timeoutDetails.responseMessage));
+			params.onTimeout?.();
+			embeddedAgentLog.warn("codex dynamic tool call timed out", {
+				...timeoutDetails.meta,
+				consoleMessage: timeoutDetails.consoleMessage
+			});
+			notifyFailedToolResult(timeoutDetails.responseMessage, "timed_out");
+			resolve(failedDynamicToolResponse(timeoutDetails.responseMessage, {
+				sideEffectEvidence: true,
+				terminalReason: "timed_out"
+			}));
+		}, timeoutMs);
+		timeout.unref?.();
+	});
+	try {
+		params.signal.addEventListener("abort", abortFromRun, { once: true });
+		if (params.signal.aborted) abortFromRun();
+		const response = await Promise.race([
+			params.toolBridge.handleToolCall(params.call, {
+				signal: controller.signal,
+				onAgentToolResult: notifyAgentToolResult,
+				toolCallOrdinal: params.toolCallOrdinal
+			}),
+			abortPromise,
+			timeoutPromise
+		]);
+		if (!response.success && !didNotifyAgentToolResult) notifyFailedToolResult(readDynamicToolResponseText(response), response.diagnosticTerminalReason ?? "failed");
+		return 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
+		});
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		params.signal.removeEventListener("abort", abortFromRun);
+		resolveAbort = void 0;
+		if (!timedOut && !controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("OpenClaw dynamic tool call finished."));
+	}
+}
+function readDynamicToolResponseText(response) {
+	return response.contentItems.flatMap((item) => item.type === "inputText" && typeof item.text === "string" ? [item.text] : []).join("\n").trim() || "OpenClaw dynamic tool call failed.";
+}
+function failedDynamicToolResponse(message, options) {
+	const response = {
+		contentItems: [{
+			type: "inputText",
+			text: message
+		}],
+		success: false
+	};
+	Object.defineProperty(response, "diagnosticTerminalType", {
+		configurable: true,
+		enumerable: false,
+		value: "error"
+	});
+	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 {
+		contentItems: response.contentItems,
+		success: response.success
+	};
+}
+/** Adds async-started progress details when a tool result continues out of band. */
+function toCodexDynamicToolProgressResponse(response, protocolResponse) {
+	if (response.asyncStarted !== true) return protocolResponse;
+	return {
+		...protocolResponse,
+		details: {
+			async: true,
+			status: "started"
+		}
+	};
+}
+/** Decides whether a terminal dynamic tool response can release the Codex turn. */
+function shouldReleaseTurnAfterTerminalDynamicTool(state) {
+	return !state.completed && !state.aborted && state.responseSuccess && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && state.activeTurnItemIdsCount === 0 && state.pendingOpenClawDynamicToolCompletionIdsCount === 0;
+}
+/** Returns true when a non-async result should block terminal-release shortcuts. */
+function shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response) {
+	return response.asyncStarted !== true;
+}
+/** Resolves whether terminal diagnostic state should release, wait, or stay idle. */
+function resolveTerminalDynamicToolBatchAction(state) {
+	if (state.activeAppServerTurnRequests > 0 || state.activeTurnItemIdsCount > 0 || state.pendingOpenClawDynamicToolCompletionIdsCount > 0) return "wait";
+	if (state.currentTurnHadNonTerminalDynamicToolResult) return "clear-nonterminal-batch";
+	if (state.hasPendingTerminalDynamicToolRelease) return "release-pending-terminal";
+	return "idle";
+}
+/** Returns true for diagnostic events that terminate a dynamic tool call. */
+function isDynamicToolTerminalDiagnosticEvent(event) {
+	return event.type === "tool.execution.completed" || event.type === "tool.execution.error" || event.type === "tool.execution.blocked";
+}
+/** Matches terminal diagnostics to a specific dynamic tool call id/name. */
+function isMatchingDynamicToolTerminalDiagnostic(params) {
+	if (params.event.toolCallId !== params.call.callId || params.event.toolName !== params.call.tool) return false;
+	if (params.runId !== void 0) return params.event.runId === params.runId;
+	if (params.sessionId !== void 0) return params.event.sessionId === params.sessionId;
+	if (params.sessionKey !== void 0) return params.event.sessionKey === params.sessionKey;
+	return params.event.runId === void 0 && params.event.sessionId === void 0 && params.event.sessionKey === void 0;
+}
+/** Checks pending diagnostics for a terminal event matching a tool call. */
+function hasPendingDynamicToolTerminalDiagnostic(params) {
+	return hasPendingInternalDiagnosticEvent((event) => {
+		if (!isDynamicToolTerminalDiagnosticEvent(event)) return false;
+		return isMatchingDynamicToolTerminalDiagnostic({
+			event,
+			call: params.call,
+			runId: params.runId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey
+		});
+	});
+}
+/** Resolves per-tool timeout, applying media/message defaults and hard caps. */
+function resolveDynamicToolCallTimeoutMs(params) {
+	return clampDynamicToolTimeoutMs(readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? 9e4);
+}
+function readDynamicToolCallTimeoutMs(value) {
+	if (!isJsonObject(value)) return;
+	const timeoutMs = readPositiveFiniteTimeoutMs(value.timeoutMs);
+	if (timeoutMs !== void 0) return timeoutMs;
+	const timeoutSecondsMs = readDynamicToolTimeoutSecondsAsMs(value.timeoutSeconds);
+	return timeoutSecondsMs === void 0 ? void 0 : addTimerTimeoutGraceMs(timeoutSecondsMs, CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS);
+}
+function readConfiguredDynamicToolTimeoutMs(toolName, config) {
+	if (toolName === "image_generate") {
+		const imageGenerationModel = config?.agents?.defaults?.imageGenerationModel;
+		if (!imageGenerationModel || typeof imageGenerationModel !== "object") return CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+		return readPositiveFiniteTimeoutMs(imageGenerationModel.timeoutMs) ?? CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS;
+	}
+	if (toolName === "image") return readTimeoutSecondsAsMs(config?.tools?.media?.image?.timeoutSeconds) ?? 6e4;
+	if (toolName === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
+}
+function readTimeoutSecondsAsMs(value) {
+	const seconds = readPositiveFiniteTimeoutMs(value);
+	return seconds === void 0 ? void 0 : seconds * 1e3;
+}
+function readDynamicToolTimeoutSecondsAsMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) return;
+	return value * 1e3;
+}
+function readPositiveFiniteTimeoutMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function clampDynamicToolTimeoutMs(timeoutMs) {
+	return Math.max(1, Math.min(CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS, Math.floor(timeoutMs)));
+}
 /** Default idle timeout while waiting for app-server turn completion. */
 const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
 /** Short guard after apparent assistant completion. */
@@ -159,7 +476,7 @@ function mapExecDecisionToOutcome(decision) {
 	return "denied";
 }
 function truncateForGateway(value, maxLength) {
-	return value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+	return value.length <= maxLength ? value : `${truncateUtf16Safe(value, maxLength - 3)}...`;
 }
 function toLintErrorObject(value, fallbackMessage) {
 	if (value instanceof Error) return value;
@@ -208,6 +525,7 @@ async function handleCodexAppServerApprovalRequest(params) {
 			signal: params.signal
 		});
 		if (policyOutcome?.outcome === "denied") {
+			recordNativeToolFailureDisposition(params, context, policyOutcome.failureDisposition);
 			emitApprovalEvent(params.paramsForRun, {
 				phase: "resolved",
 				kind: context.kind,
@@ -274,6 +592,7 @@ async function handleCodexAppServerApprovalRequest(params) {
 		});
 		const approvalId = requestResult?.id;
 		if (!approvalId) {
+			recordNativeToolFailureDisposition(params, context, "failed");
 			emitApprovalEvent(params.paramsForRun, {
 				phase: "resolved",
 				kind: context.kind,
@@ -295,10 +614,15 @@ async function handleCodexAppServerApprovalRequest(params) {
 			...context.eventDetails,
 			message: "Codex app-server approval requested."
 		});
-		const outcome = mapExecDecisionToOutcome(approvalRequestExplicitlyUnavailable(requestResult) ? null : await waitForPluginApprovalDecision({
+		const requestUnavailable = approvalRequestExplicitlyUnavailable(requestResult);
+		const decision = requestUnavailable ? null : await waitForPluginApprovalDecision({
 			approvalId,
 			signal: params.signal
-		}));
+		});
+		const approvalExpired = !requestUnavailable && decision === null;
+		const outcome = params.signal?.aborted ? "cancelled" : mapExecDecisionToOutcome(decision);
+		if (outcome === "cancelled") recordNativeToolFailureDisposition(params, context, params.signal?.aborted ? resolveCodexToolAbortTerminalReason(params.signal) : "cancelled");
+		else if (outcome === "unavailable") recordNativeToolFailureDisposition(params, context, approvalExpired ? "timed_out" : "failed");
 		emitApprovalEvent(params.paramsForRun, {
 			phase: "resolved",
 			kind: context.kind,
@@ -313,6 +637,7 @@ async function handleCodexAppServerApprovalRequest(params) {
 		return buildApprovalResponse(params.method, context.requestParams, outcome);
 	} catch (error) {
 		const cancelled = params.signal?.aborted === true;
+		recordNativeToolFailureDisposition(params, context, cancelled && params.signal ? resolveCodexToolAbortTerminalReason(params.signal) : "failed");
 		emitApprovalEvent(params.paramsForRun, {
 			phase: "resolved",
 			kind: context.kind,
@@ -325,6 +650,12 @@ async function handleCodexAppServerApprovalRequest(params) {
 		return buildApprovalResponse(params.method, context.requestParams, cancelled ? "cancelled" : "denied");
 	}
 }
+function recordNativeToolFailureDisposition(params, context, disposition) {
+	if (!context.itemId || !disposition) return;
+	try {
+		params.onNativeToolFailureDisposition?.(context.itemId, params.signal?.aborted ? resolveCodexToolAbortTerminalReason(params.signal) : disposition);
+	} catch {}
+}
 /** Converts an OpenClaw approval outcome into the app-server method response. */
 function buildApprovalResponse(method, requestParams, outcome) {
 	if (method === "item/commandExecution/requestApproval") return { decision: commandApprovalDecision(requestParams, outcome) };
@@ -343,12 +674,12 @@ function buildApprovalResponse(method, requestParams, outcome) {
 }
 function matchesCurrentTurn(requestParams, threadId, turnId) {
 	if (!requestParams) return false;
-	const requestThreadId = readString$1(requestParams, "threadId") ?? readString$1(requestParams, "conversationId");
-	const requestTurnId = readString$1(requestParams, "turnId");
+	const requestThreadId = readString$2(requestParams, "threadId");
+	const requestTurnId = readString$2(requestParams, "turnId");
 	return requestThreadId === threadId && requestTurnId === turnId;
 }
 function buildApprovalContext(params) {
-	const itemId = readString$1(params.requestParams, "itemId") ?? readString$1(params.requestParams, "callId") ?? readString$1(params.requestParams, "approvalId");
+	const itemId = readString$2(params.requestParams, "itemId") ?? readString$2(params.requestParams, "callId") ?? readString$2(params.requestParams, "approvalId");
 	const commandDetailLines = params.method === "item/commandExecution/requestApproval" ? describeCommandApprovalDetails(params.requestParams) : [];
 	const commandPreview = sanitizeApprovalPreview(readDisplayCommandPreview(params.requestParams), commandDetailLines.length > 0 ? COMMAND_PREVIEW_WITH_DETAILS_MAX_LENGTH : 180);
 	const reasonPreview = sanitizeApprovalPreview(readStringPreview(params.requestParams, "reason"), 180);
@@ -423,11 +754,11 @@ function toCodexAppServerApprovalCancellationError(reason) {
 	return new Error(typeof reason === "string" && reason.trim() ? reason : "Codex app-server approval cancelled.");
 }
 async function buildAppServerExecAutoReviewInput(params) {
-	const command = readString$1(params.requestParams, "command");
+	const command = readString$2(params.requestParams, "command");
 	if (!command) return;
 	return buildExecAutoReviewInputForShellCommand({
 		command,
-		cwd: readString$1(params.requestParams, "cwd") ?? params.paramsForRun.workspaceDir ?? null,
+		cwd: readString$2(params.requestParams, "cwd") ?? params.paramsForRun.workspaceDir ?? null,
 		host: "codex-app-server",
 		agent: {
 			id: params.paramsForRun.agentId ?? null,
@@ -508,7 +839,7 @@ function readUnknownRecord(value) {
 async function runOpenClawToolPolicyForApprovalRequest(params) {
 	const policyRequest = buildOpenClawToolPolicyRequest(params.method, params.requestParams);
 	if (!policyRequest) return;
-	const cwd = readString$1(params.requestParams, "cwd") ?? params.paramsForRun.workspaceDir;
+	const cwd = readString$2(params.requestParams, "cwd") ?? params.paramsForRun.workspaceDir;
 	const nativeRelayOutcome = await runNativeRelayToolPolicyForApprovalRequest({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -520,7 +851,8 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 	});
 	if (nativeRelayOutcome?.blocked) return {
 		outcome: "denied",
-		reason: nativeRelayOutcome.reason
+		reason: nativeRelayOutcome.reason,
+		...nativeRelayOutcome.failureDisposition ? { failureDisposition: nativeRelayOutcome.failureDisposition } : {}
 	};
 	if (nativeRelayOutcome?.outcome === "approved-once" || nativeRelayOutcome?.outcome === "approved-session") return { outcome: nativeRelayOutcome.outcome };
 	if (nativeRelayOutcome?.handled) return { outcome: "no-decision" };
@@ -541,6 +873,7 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 			...params.paramsForRun.agentId ? { agentId: params.paramsForRun.agentId } : {},
 			...params.paramsForRun.config ? { config: params.paramsForRun.config } : {},
 			...cwd ? { cwd } : {},
+			workspaceDir: params.paramsForRun.workspaceDir,
 			...params.paramsForRun.sessionKey ? { sessionKey: params.paramsForRun.sessionKey } : {},
 			...params.paramsForRun.sessionId ? { sessionId: params.paramsForRun.sessionId } : {},
 			...params.paramsForRun.runId ? { runId: params.paramsForRun.runId } : {},
@@ -549,7 +882,8 @@ async function runOpenClawToolPolicyForApprovalRequest(params) {
 	});
 	if (outcome.blocked) return {
 		outcome: "denied",
-		reason: outcome.reason
+		reason: outcome.reason,
+		...outcome.kind === "failure" && outcome.disposition !== "blocked" ? { failureDisposition: outcome.disposition } : {}
 	};
 	if ("params" in outcome && toolPolicyParamsWereRewritten(policyRequest.params, outcome.params)) return {
 		outcome: "denied",
@@ -579,7 +913,8 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 		if (approvalOutcome?.outcome === "denied") return {
 			handled: true,
 			blocked: true,
-			reason: approvalOutcome.reason
+			reason: approvalOutcome.reason,
+			...approvalOutcome.failureDisposition ? { failureDisposition: approvalOutcome.failureDisposition } : {}
 		};
 		if (approvalOutcome?.outcome === "approved-once") return {
 			handled: true,
@@ -599,7 +934,8 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 		if (decision.blocked) return {
 			handled: true,
 			blocked: true,
-			reason: decision.reason
+			reason: decision.reason,
+			...decision.failureDisposition ? { failureDisposition: decision.failureDisposition } : {}
 		};
 		const approvalOutcome = await resolveNativeHookRelayDeferredToolApproval({
 			relayId: params.nativeHookRelay.relayId,
@@ -609,7 +945,8 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 		if (approvalOutcome?.outcome === "denied") return {
 			handled: true,
 			blocked: true,
-			reason: approvalOutcome.reason
+			reason: approvalOutcome.reason,
+			...approvalOutcome.failureDisposition ? { failureDisposition: approvalOutcome.failureDisposition } : {}
 		};
 		if (approvalOutcome?.outcome === "approved-once") return {
 			handled: true,
@@ -620,14 +957,15 @@ async function runNativeRelayToolPolicyForApprovalRequest(params) {
 		return {
 			handled: true,
 			blocked: true,
-			reason: `OpenClaw native hook relay unavailable for Codex app-server approval: ${formatCodexDisplayText(formatErrorMessage$1(error))}`
+			reason: `OpenClaw native hook relay unavailable for Codex app-server approval: ${formatCodexDisplayText(formatErrorMessage$1(error))}`,
+			failureDisposition: "failed"
 		};
 	}
 }
 function buildNativeRelayPreToolUsePayload(params) {
-	const command = readString$1(params.policyRequest.params, "command");
+	const command = readString$2(params.policyRequest.params, "command");
 	if (!command) return;
-	const turnId = readString$1(params.requestParams, "turnId");
+	const turnId = readString$2(params.requestParams, "turnId");
 	return {
 		hook_event_name: "PreToolUse",
 		openclaw_approval_mode: "report",
@@ -645,7 +983,8 @@ function buildNativeRelayPreToolUsePayload(params) {
 function readNativeRelayPreToolUseDecision(response) {
 	if (!response || response.exitCode !== 0) return {
 		blocked: true,
-		reason: sanitizeRelayDecisionReason(response?.stderr) || sanitizeRelayDecisionReason(response?.stdout) || "OpenClaw native hook relay failed for Codex app-server approval."
+		reason: sanitizeRelayDecisionReason(response?.stderr) || sanitizeRelayDecisionReason(response?.stdout) || "OpenClaw native hook relay failed for Codex app-server approval.",
+		failureDisposition: response?.failureDisposition ?? "failed"
 	};
 	const stdout = response.stdout?.trim();
 	if (!stdout) return { blocked: false };
@@ -653,11 +992,13 @@ function readNativeRelayPreToolUseDecision(response) {
 	const output = isJsonObject(parsed?.hookSpecificOutput) ? parsed.hookSpecificOutput : void 0;
 	if (output?.permissionDecision === "deny") return {
 		blocked: true,
-		reason: readString$1(output, "permissionDecisionReason") || "OpenClaw native hook policy denied Codex app-server approval."
+		reason: readString$2(output, "permissionDecisionReason") || "OpenClaw native hook policy denied Codex app-server approval.",
+		...response.failureDisposition ? { failureDisposition: response.failureDisposition } : {}
 	};
 	return {
 		blocked: true,
-		reason: output ? "OpenClaw native hook relay returned a non-deny Codex app-server approval decision." : "OpenClaw native hook relay returned an unreadable Codex app-server approval result."
+		reason: output ? "OpenClaw native hook relay returned a non-deny Codex app-server approval decision." : "OpenClaw native hook relay returned an unreadable Codex app-server approval result.",
+		failureDisposition: "failed"
 	};
 }
 function parseRelayJsonResponse(text) {
@@ -681,7 +1022,7 @@ function buildOpenClawToolPolicyRequest(method, requestParams) {
 			toolName: "exec",
 			params: {
 				...command ? { command } : {},
-				...readString$1(requestParams, "cwd") ? { cwd: readString$1(requestParams, "cwd") } : {},
+				...readString$2(requestParams, "cwd") ? { cwd: readString$2(requestParams, "cwd") } : {},
 				approval: requestParams ?? {}
 			}
 		};
@@ -981,7 +1322,7 @@ function readPolicyCommand(record) {
 function readCommandActions(record) {
 	const actions = record?.commandActions;
 	if (!Array.isArray(actions)) return [];
-	return actions.map((action) => isJsonObject(action) ? readString$1(action, "command") : void 0).filter((command) => Boolean(command));
+	return actions.map((action) => isJsonObject(action) ? readString$2(action, "command") : void 0).filter((command) => Boolean(command));
 }
 function readCommandActionsPreview(record) {
 	let source;
@@ -1004,19 +1345,19 @@ function readCommandPreview(record) {
 	return source;
 }
 function readStringPreview(record, key) {
-	const value = readString$1(record, key);
+	const value = readString$2(record, key);
 	return value === void 0 ? void 0 : previewSource(value);
 }
-function readString$1(record, key) {
+function readString$2(record, key) {
 	const value = record?.[key];
 	return typeof value === "string" ? value : void 0;
 }
 function truncate(value, maxLength) {
-	return value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+	return value.length <= maxLength ? value : `${truncateUtf16Safe(value, maxLength - 3)}...`;
 }
 function previewSource(value) {
 	return {
-		value: value.slice(0, APPROVAL_PREVIEW_SCAN_MAX_LENGTH),
+		value: sliceUtf16Safe(value, 0, APPROVAL_PREVIEW_SCAN_MAX_LENGTH),
 		clipped: value.length > APPROVAL_PREVIEW_SCAN_MAX_LENGTH
 	};
 }
@@ -1024,7 +1365,7 @@ function appendPreviewPart(source, part, separator) {
 	const value = `${source?.value ? `${source.value}${separator}` : ""}${part}`;
 	const clipped = source?.clipped === true || value.length > APPROVAL_PREVIEW_SCAN_MAX_LENGTH;
 	return {
-		value: value.slice(0, APPROVAL_PREVIEW_SCAN_MAX_LENGTH),
+		value: sliceUtf16Safe(value, 0, APPROVAL_PREVIEW_SCAN_MAX_LENGTH),
 		clipped
 	};
 }
@@ -1063,6 +1404,40 @@ function formatErrorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
+//#region extensions/codex/src/app-server/session-history.ts
+/**
+* Reads OpenClaw session history for Codex transcript mirroring and sanitizes
+* image payloads before replaying messages into the app-server projector.
+*/
+function isMissingFileError(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+/** Returns sanitized session-context messages for a Codex mirrored session file. */
+async function readCodexMirroredSessionHistoryMessages(target) {
+	try {
+		await resolveSessionTranscriptTarget(resolveCodexHistoryTranscriptTarget(target));
+		const entries = parseSessionEntries(await fs.readFile(target.sessionFile, "utf-8"));
+		if (entries.length === 0) return [];
+		const firstEntry = entries[0];
+		if (firstEntry?.type !== "session" || typeof firstEntry.id !== "string") return;
+		migrateSessionEntries(entries);
+		return sanitizeCodexHistoryImagePayloads(buildSessionContext(entries.filter((entry) => {
+			return entry !== null && typeof entry === "object" && !Array.isArray(entry) && entry.type !== "session";
+		})).messages, "codex mirrored history");
+	} catch (error) {
+		if (isMissingFileError(error)) return [];
+		return;
+	}
+}
+function resolveCodexHistoryTranscriptTarget(target) {
+	return {
+		...target.agentId ? { agentId: target.agentId } : {},
+		sessionFile: target.sessionFile,
+		sessionId: target.sessionId,
+		sessionKey: target.sessionKey ?? ""
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/vision-tools.ts
 /**
 * Filters Codex dynamic tools for turns that already contain image inputs so
@@ -1088,10 +1463,10 @@ const CODEX_NATIVE_SANDBOX_TOOL_REQUIREMENTS = [
 	"edit",
 	"apply_patch"
 ];
-const CODEX_MEMORY_FLUSH_DYNAMIC_TOOL_ALLOW = new Set(["read", "write"]);
+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_HIDDEN_PARAMETER_NAMES = new Set([
+const CODEX_NODE_EXEC_HIDDEN_PARAMETER_NAMES = /* @__PURE__ */ new Set([
 	"host",
 	"security",
 	"ask",
@@ -1187,6 +1562,7 @@ async function buildDynamicTools(input) {
 	const nativeExecutionPolicy = resolveCodexNativeExecutionPolicyForDynamicTools(input);
 	const allTools = createOpenClawCodingTools({
 		agentId: input.sessionAgentId,
+		...params.crestodianTool ? { crestodianTool: params.crestodianTool } : {},
 		...buildEmbeddedAttemptToolRunContext(params),
 		exec: {
 			...params.execOverrides,
@@ -1208,6 +1584,7 @@ async function buildDynamicTools(input) {
 		senderName: params.senderName,
 		senderUsername: params.senderUsername,
 		senderE164: params.senderE164,
+		senderIsOwner: params.senderIsOwner,
 		allowGatewaySubagentBinding: params.allowGatewaySubagentBinding || isForcedPrivateQaCodexRuntime(),
 		...sessionKeys,
 		sessionId: params.sessionId,
@@ -1444,7 +1821,7 @@ function codexNetworkAccessForOpenClawSandbox(sandbox) {
 	const network = sandbox?.docker?.network?.trim().toLowerCase();
 	return Boolean(network && network !== "none");
 }
-/** Returns a Codex config copy with app-server Codex plugin loading disabled for thread tools. */
+/** Returns a Codex config copy with all app exposure disabled for restricted thread tools. */
 function disableCodexPluginThreadConfig(pluginConfig) {
 	const config = readCodexPluginConfig(pluginConfig);
 	return {
@@ -1612,6 +1989,7 @@ function shouldForceMessageTool(params) {
 function emitDynamicToolStartedDiagnostic(params) {
 	emitTrustedDiagnosticEvent({
 		type: "tool.execution.started",
+		agentId: params.agentId,
 		runId: params.runId,
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
@@ -1623,13 +2001,15 @@ function emitDynamicToolStartedDiagnostic(params) {
 function emitDynamicToolErrorDiagnostic(params) {
 	emitTrustedDiagnosticEvent({
 		type: "tool.execution.error",
+		agentId: params.agentId,
 		runId: params.runId,
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
 		toolName: params.call.tool,
 		toolCallId: params.call.callId,
 		durationMs: params.durationMs,
-		errorCategory: "codex_dynamic_tool_error"
+		errorCategory: "codex_dynamic_tool_error",
+		terminalReason: params.terminalReason ?? "failed"
 	});
 }
 /** Emits the terminal event matching a dynamic tool response's diagnostic type. */
@@ -1638,6 +2018,7 @@ function emitDynamicToolTerminalDiagnostic(params) {
 	if (terminalType === "completed") {
 		emitTrustedDiagnosticEvent({
 			type: "tool.execution.completed",
+			agentId: params.agentId,
 			runId: params.runId,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -1650,6 +2031,7 @@ function emitDynamicToolTerminalDiagnostic(params) {
 	if (terminalType === "blocked") {
 		emitTrustedDiagnosticEvent({
 			type: "tool.execution.blocked",
+			agentId: params.agentId,
 			runId: params.runId,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -1660,7 +2042,10 @@ function emitDynamicToolTerminalDiagnostic(params) {
 		});
 		return;
 	}
-	emitDynamicToolErrorDiagnostic(params);
+	emitDynamicToolErrorDiagnostic({
+		...params,
+		terminalReason: params.response.diagnosticTerminalReason ?? "failed"
+	});
 }
 //#endregion
 //#region extensions/codex/src/app-server/dynamic-tools.ts
@@ -1784,7 +2169,11 @@ function hasExplicitNonSourceMessageRoute(args, hookContext, messagingTarget) {
 }
 /** Namespace attached to OpenClaw-owned dynamic tools exposed to Codex. */
 const CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE = "openclaw";
-const ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES = new Set(["sessions_yield"]);
+const ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"agents_list",
+	"sessions_spawn",
+	"sessions_yield"
+]);
 const EXPLICIT_MESSAGE_PROVIDER_KEYS = ["channel", "provider"];
 const EXPLICIT_MESSAGE_TARGET_KEYS = [
 	"target",
@@ -1846,7 +2235,7 @@ function createCodexDynamicToolBridge(params) {
 		return getChannelAgentToolMeta(tool) === void 0;
 	};
 	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
-	const directToolNames = new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
+	const directToolNames = /* @__PURE__ */ new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
 	return {
 		availableSpecs: createCodexDynamicToolSpecs({
 			entries: availableTools,
@@ -1914,6 +2303,7 @@ function createCodexDynamicToolBridge(params) {
 				executionPrevented = consumePreExecutionBlockedToolCall(call.callId, toolResultHookContext.runId);
 				const telemetryRawResult = sanitizeToolResult(rawResult);
 				const rawIsError = isCodexToolResultError(rawResult);
+				const rawResultFailureKind = resolveToolResultFailureKind(rawResult);
 				const middlewareResult = await middlewareRunner.applyToolResultMiddleware({
 					threadId: call.threadId,
 					turnId: call.turnId,
@@ -1932,7 +2322,16 @@ function createCodexDynamicToolBridge(params) {
 					result: middlewareResult
 				});
 				const resultIsError = rawIsError || isCodexToolResultError(result);
-				notifyAgentToolResult(options?.onAgentToolResult, toolName, result, resultIsError);
+				const finalResultFailureKind = resolveToolResultFailureKind(result);
+				const resultFailureKind = rawResultFailureKind ?? finalResultFailureKind;
+				const observerResult = rawResultFailureKind && finalResultFailureKind !== rawResultFailureKind ? {
+					...result,
+					details: {
+						...isRecord(result.details) ? result.details : {},
+						status: rawResultFailureKind
+					}
+				} : result;
+				notifyAgentToolResult(options?.onAgentToolResult, toolName, observerResult, resultIsError);
 				runAgentHarnessAfterToolCallHook({
 					toolName,
 					toolCallId: call.callId,
@@ -1966,11 +2365,12 @@ function createCodexDynamicToolBridge(params) {
 					isError: resultIsError,
 					messagingTarget: confirmedMessagingTarget
 				});
-				const terminalType = inferToolResultDiagnosticTerminalType(result, resultIsError);
+				const terminalType = resultFailureKind === "blocked" ? "blocked" : resultIsError ? "error" : "completed";
 				const response = withDiagnosticTerminalType({
 					contentItems: convertToolContents(result.content, toolResultMaxChars),
 					success: !resultIsError
 				}, terminalType);
+				withDiagnosticFailureDisposition(response, resultFailureKind);
 				const blocksSourceReplyTermination = hasExplicitNonSourceMessageRoute(executedArgs, params.hookContext, confirmedMessagingTarget);
 				const deliveredSourceReply = isDeliveredMessageToolOnlySourceReplyResult({
 					sourceReplyDeliveryMode: params.hookContext?.sourceReplyDeliveryMode,
@@ -1995,11 +2395,12 @@ function createCodexDynamicToolBridge(params) {
 				withDynamicToolAsyncStarted(response, asyncStarted);
 				return withSideEffectEvidence(response, !(executionPrevented || !asyncStarted && isReplaySafeToolInstance(toolEntry.tool) && isReplaySafeToolCall(toolName, executedArgs)));
 			} catch (error) {
-				const errorMessage = error instanceof Error ? error.message : String(error);
+				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);
+				const failedResult = failedToolResult(errorMessage, executionDisposition);
 				finalizeToolTerminalPresentation({
 					toolCallId: call.callId,
 					runId: toolResultHookContext.runId,
@@ -2030,13 +2431,13 @@ function createCodexDynamicToolBridge(params) {
 					startedAt
 				});
 				const replaySafe = !didStartExecution || executionPrevented || isReplaySafeToolInstance(toolEntry.tool) && isReplaySafeToolCall(toolName, executedArgs);
-				return withSideEffectEvidence(withDiagnosticTerminalType({
+				return withSideEffectEvidence(withDiagnosticFailureDisposition({
 					contentItems: [{
 						type: "inputText",
 						text: errorMessage
 					}],
 					success: false
-				}, "error"), didStartExecution && !replaySafe);
+				}, executionDisposition), didStartExecution && !replaySafe);
 			}
 		}
 	};
@@ -2052,14 +2453,14 @@ function notifyAgentToolResult(observer, toolName, result, isError) {
 		embeddedAgentLog.warn(`onAgentToolResult handler failed: tool=${toolName} error=${String(error)}`);
 	}
 }
-function failedToolResult(message) {
+function failedToolResult(message, status = "failed") {
 	return {
 		content: [{
 			type: "text",
 			text: message
 		}],
 		details: {
-			status: "failed",
+			status,
 			error: message
 		}
 	};
@@ -2234,6 +2635,7 @@ function warnQuarantinedDynamicTools(tools) {
 function emitQuarantinedDynamicToolDiagnostics(tools, ctx) {
 	for (const tool of tools) emitTrustedDiagnosticEvent({
 		type: "tool.execution.blocked",
+		agentId: ctx?.agentId,
 		runId: ctx?.runId,
 		sessionId: ctx?.sessionId,
 		sessionKey: ctx?.sessionKey,
@@ -2390,13 +2792,6 @@ function isAsyncStartedToolResult(result) {
 	const details = result.details;
 	return isRecord(details) && details.async === true && details.status === "started";
 }
-function inferToolResultDiagnosticTerminalType(result, isError) {
-	const details = result.details;
-	if (isRecord(details) && typeof details.status === "string") {
-		if (details.status.trim().toLowerCase() === "blocked") return "blocked";
-	}
-	return isError ? "error" : "completed";
-}
 function withDiagnosticTerminalType(response, terminalType) {
 	Object.defineProperty(response, "diagnosticTerminalType", {
 		configurable: true,
@@ -2405,6 +2800,16 @@ function withDiagnosticTerminalType(response, terminalType) {
 	});
 	return response;
 }
+function withDiagnosticFailureDisposition(response, disposition) {
+	if (!disposition) return response;
+	withDiagnosticTerminalType(response, disposition === "blocked" ? "blocked" : "error");
+	if (disposition !== "blocked") Object.defineProperty(response, "diagnosticTerminalReason", {
+		configurable: true,
+		enumerable: false,
+		value: disposition
+	});
+	return response;
+}
 function withSideEffectEvidence(response, sideEffectEvidence) {
 	if (!sideEffectEvidence) return response;
 	Object.defineProperty(response, "sideEffectEvidence", {
@@ -2641,7 +3046,7 @@ async function handleCodexAppServerElicitationRequest(params) {
 }
 function matchesCurrentThread(requestParams, threadId) {
 	if (!requestParams) return false;
-	return readString(requestParams, "threadId") === threadId;
+	return readString$1(requestParams, "threadId") === threadId;
 }
 function turnIdMismatches(requestParams, turnId) {
 	const rawTurnId = requestParams?.turnId;
@@ -2656,6 +3061,7 @@ function resolvePluginElicitation(params) {
 	const meta = isJsonObject(requestParams["_meta"]) ? requestParams["_meta"] : {};
 	const context = params.pluginAppPolicyContext;
 	const entries = context ? Object.values(context.apps) : [];
+	const pluginEntries = entries.filter(isPluginAppPolicyContextEntry);
 	const appId = readFirstString(meta, PLUGIN_APP_ID_META_KEYS) ?? readFirstString(requestParams, PLUGIN_APP_ID_META_KEYS);
 	const connectorId = readFirstString(meta, PLUGIN_CONNECTOR_ID_META_KEYS);
 	const isCodexConnectorApproval = isCodexConnectorApprovalElicitation(requestParams, meta);
@@ -2669,6 +3075,10 @@ function resolvePluginElicitation(params) {
 			reason: "missing_policy_context"
 		};
 		const entry = context.apps[appId];
+		if (entry?.source === "account" && !isCodexConnectorApproval) return {
+			kind: "decline",
+			reason: "account_app_source_mismatch"
+		};
 		return uniquePluginMatch(entry ? [entry] : [], "app_id");
 	}
 	if (isCodexConnectorApproval && connectorId) {
@@ -2679,7 +3089,7 @@ function resolvePluginElicitation(params) {
 		const entry = context.apps[connectorId];
 		return uniquePluginMatch(entry ? [entry] : [], "connector_id");
 	}
-	const serverName = readString(requestParams, "serverName");
+	const serverName = readString$1(requestParams, "serverName");
 	if (serverName && context) {
 		const matches = entries.filter((entry) => entry.mcpServerNames.includes(serverName));
 		if (matches.length > 0) return uniquePluginMatch(matches, "server_name");
@@ -2687,7 +3097,7 @@ function resolvePluginElicitation(params) {
 	const metadataResolution = resolvePluginStableMetadataMatch({
 		meta,
 		requestParams,
-		entries,
+		entries: pluginEntries,
 		context
 	});
 	if (metadataResolution.kind !== "not_plugin") return metadataResolution;
@@ -2698,7 +3108,7 @@ function resolvePluginElicitation(params) {
 	return { kind: "not_plugin" };
 }
 function isCodexConnectorApprovalElicitation(requestParams, meta) {
-	return readString(requestParams, "serverName") === CODEX_APPS_SERVER_NAME && readString(meta, MCP_TOOL_APPROVAL_KIND_KEY) === MCP_TOOL_APPROVAL_KIND && readString(meta, MCP_TOOL_APPROVAL_SOURCE_KEY) === MCP_TOOL_APPROVAL_CONNECTOR_SOURCE;
+	return readString$1(requestParams, "serverName") === CODEX_APPS_SERVER_NAME && readString$1(meta, MCP_TOOL_APPROVAL_KIND_KEY) === MCP_TOOL_APPROVAL_KIND && readString$1(meta, MCP_TOOL_APPROVAL_SOURCE_KEY) === MCP_TOOL_APPROVAL_CONNECTOR_SOURCE;
 }
 function resolvePluginStableMetadataMatch(params) {
 	const pluginName = readFirstString(params.meta, PLUGIN_NAME_META_KEYS) ?? readFirstString(params.requestParams, PLUGIN_NAME_META_KEYS);
@@ -2727,10 +3137,16 @@ function uniquePluginMatch(matches, source) {
 	};
 }
 function hasDisplayNameOnlyPluginMatch(meta, entries) {
-	const connectorName = readString(meta, MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY);
+	const connectorName = readString$1(meta, MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY);
 	if (!connectorName) return false;
 	const normalized = normalizePluginIdentityText(connectorName);
-	return entries.some((entry) => normalizePluginIdentityText(entry.pluginName) === normalized || normalizePluginIdentityText(entry.configKey) === normalized);
+	return entries.some((entry) => normalizePluginIdentityText(appPolicyDisplayName(entry)) === normalized || isPluginAppPolicyContextEntry(entry) && normalizePluginIdentityText(entry.configKey) === normalized);
+}
+function isPluginAppPolicyContextEntry(entry) {
+	return entry.source !== "account";
+}
+function appPolicyDisplayName(entry) {
+	return isPluginAppPolicyContextEntry(entry) ? entry.pluginName : entry.appName;
 }
 function normalizePluginIdentityText(value) {
 	return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
@@ -2772,20 +3188,20 @@ function oneShotPluginPolicyApprovalOutcome(mode, outcome) {
 	return mode === "ask" && outcome === "approved-session" ? "approved-once" : outcome;
 }
 function readPluginApprovalElicitation(entry, requestParams) {
-	if (readString(requestParams, "mode") !== "form" || !isJsonObject(requestParams.requestedSchema)) return;
+	if (readString$1(requestParams, "mode") !== "form" || !isJsonObject(requestParams.requestedSchema)) return;
 	const requestedSchema = requestParams.requestedSchema;
-	if (readString(requestedSchema, "type") !== "object" || !isJsonObject(requestedSchema.properties)) return;
+	if (readString$1(requestedSchema, "type") !== "object" || !isJsonObject(requestedSchema.properties)) return;
 	const meta = isJsonObject(requestParams["_meta"]) ? requestParams["_meta"] : {};
-	const title = sanitizeDisplayText(readString(requestParams, "message") ?? "") || "Codex plugin approval";
+	const title = sanitizeDisplayText(readString$1(requestParams, "message") ?? "") || "Codex plugin approval";
 	const descriptionMeta = { ...meta };
-	if (!readString(descriptionMeta, MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY)) descriptionMeta[MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY] = entry.pluginName;
+	if (!readString$1(descriptionMeta, MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY)) descriptionMeta[MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY] = appPolicyDisplayName(entry);
 	return {
 		title,
 		description: buildApprovalDescription({
 			title,
 			meta: descriptionMeta,
 			requestedSchema,
-			serverName: sanitizeOptionalDisplayText(readString(requestParams, "serverName"))
+			serverName: sanitizeOptionalDisplayText(readString$1(requestParams, "serverName"))
 		}),
 		requestedSchema,
 		meta,
@@ -2824,34 +3240,34 @@ function declineElicitationResponse() {
 function logPluginElicitationDecline(reason, requestParams) {
 	embeddedAgentLog.debug("codex plugin elicitation declined", {
 		reason,
-		serverName: readString(requestParams, "serverName"),
-		mode: readString(requestParams, "mode")
+		serverName: readString$1(requestParams, "serverName"),
+		mode: readString$1(requestParams, "mode")
 	});
 }
 function readBridgeableApprovalElicitation(requestParams) {
-	if (!requestParams || readString(requestParams, "mode") !== "form" || !isJsonObject(requestParams["_meta"]) || requestParams["_meta"][MCP_TOOL_APPROVAL_KIND_KEY] !== MCP_TOOL_APPROVAL_KIND || !isJsonObject(requestParams.requestedSchema)) return;
+	if (!requestParams || readString$1(requestParams, "mode") !== "form" || !isJsonObject(requestParams["_meta"]) || requestParams["_meta"][MCP_TOOL_APPROVAL_KIND_KEY] !== MCP_TOOL_APPROVAL_KIND || !isJsonObject(requestParams.requestedSchema)) return;
 	const requestedSchema = requestParams.requestedSchema;
-	if (readString(requestedSchema, "type") !== "object" || !isJsonObject(requestedSchema.properties)) return;
-	const title = sanitizeDisplayText(readString(requestParams, "message") ?? "") || "Codex MCP tool approval";
+	if (readString$1(requestedSchema, "type") !== "object" || !isJsonObject(requestedSchema.properties)) return;
+	const title = sanitizeDisplayText(readString$1(requestParams, "message") ?? "") || "Codex MCP tool approval";
 	return {
 		title,
 		description: buildApprovalDescription({
 			title,
 			meta: requestParams["_meta"],
 			requestedSchema,
-			serverName: sanitizeOptionalDisplayText(readString(requestParams, "serverName"))
+			serverName: sanitizeOptionalDisplayText(readString$1(requestParams, "serverName"))
 		}),
 		requestedSchema,
 		meta: requestParams["_meta"]
 	};
 }
 function readComputerUseApprovalElicitation(requestParams, expectedServerName) {
-	const serverName = readString(requestParams, "serverName");
-	if (!serverName || !expectedServerName || serverName !== expectedServerName || readString(requestParams, "mode") !== "form") return;
+	const serverName = readString$1(requestParams, "serverName");
+	if (!serverName || !expectedServerName || serverName !== expectedServerName || readString$1(requestParams, "mode") !== "form") return;
 	const requestedSchema = isJsonObject(requestParams?.requestedSchema) ? requestParams.requestedSchema : EMPTY_OBJECT_SCHEMA;
-	if (readString(requestedSchema, "type") !== "object" || !isJsonObject(requestedSchema.properties)) return;
+	if (readString$1(requestedSchema, "type") !== "object" || !isJsonObject(requestedSchema.properties)) return;
 	const meta = isJsonObject(requestParams?.["_meta"]) ? requestParams["_meta"] : {};
-	const title = sanitizeDisplayText(readString(requestParams, "message") ?? "") || COMPUTER_USE_APPROVAL_TITLE;
+	const title = sanitizeDisplayText(readString$1(requestParams, "message") ?? "") || COMPUTER_USE_APPROVAL_TITLE;
 	return {
 		title,
 		description: buildApprovalDescription({
@@ -2865,9 +3281,9 @@ function readComputerUseApprovalElicitation(requestParams, expectedServerName) {
 	};
 }
 function buildApprovalDescription(params) {
-	const connectorName = sanitizeOptionalDisplayText(readString(params.meta, MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY));
-	const toolTitle = sanitizeOptionalDisplayText(readString(params.meta, MCP_TOOL_APPROVAL_TOOL_TITLE_KEY));
-	const toolDescription = sanitizeOptionalDisplayText(readString(params.meta, MCP_TOOL_APPROVAL_TOOL_DESCRIPTION_KEY));
+	const connectorName = sanitizeOptionalDisplayText(readString$1(params.meta, MCP_TOOL_APPROVAL_CONNECTOR_NAME_KEY));
+	const toolTitle = sanitizeOptionalDisplayText(readString$1(params.meta, MCP_TOOL_APPROVAL_TOOL_TITLE_KEY));
+	const toolDescription = sanitizeOptionalDisplayText(readString$1(params.meta, MCP_TOOL_APPROVAL_TOOL_DESCRIPTION_KEY));
 	const summaryLines = [
 		connectorName && `App: ${connectorName}`,
 		toolTitle && `Tool: ${toolTitle}`,
@@ -2888,8 +3304,8 @@ function readPropertyDescriptionLines(requestedSchema) {
 	return Object.entries(properties).map(([name, value]) => {
 		const schema = isJsonObject(value) ? value : void 0;
 		if (!schema) return;
-		const propTitle = sanitizeDisplayText(readString(schema, "title") ?? "") || sanitizeDisplayText(name) || "field";
-		const description = sanitizeOptionalDisplayText(readString(schema, "description"));
+		const propTitle = sanitizeDisplayText(readString$1(schema, "title") ?? "") || sanitizeDisplayText(name) || "field";
+		const description = sanitizeOptionalDisplayText(readString$1(schema, "description"));
 		return description ? `- ${propTitle}: ${description}` : `- ${propTitle}`;
 	}).filter((line) => Boolean(line));
 }
@@ -2899,7 +3315,7 @@ function readDisplayParamLines(meta) {
 	const lines = displayParams.slice(0, MAX_DISPLAY_PARAM_ENTRIES).map((entry) => {
 		const param = isJsonObject(entry) ? entry : void 0;
 		if (!param) return;
-		const name = sanitizeOptionalDisplayText(readString(param, "display_name")) ?? sanitizeOptionalDisplayText(readString(param, "name"));
+		const name = sanitizeOptionalDisplayText(readString$1(param, "display_name")) ?? sanitizeOptionalDisplayText(readString$1(param, "name"));
 		if (!name) return;
 		return `- ${name}: ${formatDisplayParamValue(param.value)}`;
 	}).filter((line) => Boolean(line));
@@ -2945,14 +3361,14 @@ function sanitizeOptionalDisplayText(value) {
 	return (value === void 0 ? "" : sanitizeDisplayText(value)) || void 0;
 }
 function sanitizeDisplayText(value) {
-	const scanned = value.slice(0, DISPLAY_TEXT_SCAN_MAX_LENGTH);
+	const scanned = sliceUtf16Safe(value, 0, DISPLAY_TEXT_SCAN_MAX_LENGTH);
 	const clipped = value.length > DISPLAY_TEXT_SCAN_MAX_LENGTH;
 	const sanitized = scanned.replace(ANSI_OSC_SEQUENCE_RE, "").replace(ANSI_CONTROL_SEQUENCE_RE, "").replace(DANGLING_TERMINAL_SEQUENCE_SUFFIX_RE, "").replace(INVISIBLE_FORMATTING_CONTROL_RE, " ").replace(CONTROL_CHARACTER_RE, " ").replace(/\s+/g, " ").trim();
 	const escaped = sanitized ? formatCodexDisplayText(sanitized) : "";
 	return clipped && escaped ? `${escaped}...` : escaped;
 }
 function truncateDisplayText(value, maxLength) {
-	return value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+	return value.length <= maxLength ? value : `${truncateUtf16Safe(value, maxLength - 3)}...`;
 }
 async function requestPluginApprovalOutcome(params) {
 	try {
@@ -3038,7 +3454,7 @@ function buildAcceptedContent(approvalPrompt, outcome) {
 }
 function readApprovalFieldValue(property, outcome) {
 	if (!isApprovalField(property)) return;
-	if (readString(property.schema, "type") === "boolean") return true;
+	if (readString$1(property.schema, "type") === "boolean") return true;
 	const options = readEnumOptions(property.schema);
 	if (options.length === 0) return;
 	const sessionChoice = options.find((option) => isSessionApprovalOption(option));
@@ -3073,8 +3489,8 @@ function isPersistField(property) {
 function propertyText(property) {
 	return [
 		property.name,
-		readString(property.schema, "title"),
-		readString(property.schema, "description")
+		readString$1(property.schema, "title"),
+		readString$1(property.schema, "description")
 	].filter(Boolean).join(" ");
 }
 function readPersistHints(meta, mode = "legacy") {
@@ -3113,11 +3529,11 @@ function readEnumOptions(schema) {
 	}
 	if (Array.isArray(schema.oneOf)) return schema.oneOf.map((entry) => {
 		const option = isJsonObject(entry) ? entry : void 0;
-		const value = readString(option, "const");
+		const value = readString$1(option, "const");
 		if (!value) return;
 		return {
 			value,
-			label: readString(option, "title") ?? value
+			label: readString$1(option, "title") ?? value
 		};
 	}).filter((entry) => Boolean(entry));
 	return [];
@@ -3130,17 +3546,37 @@ function isSessionApprovalOption(option) {
 	const haystack = `${option.value} ${option.label}`.toLowerCase();
 	return /\b(session|always|persistent)\b/.test(haystack) && /\b(allow|approve|accept)\b/.test(haystack);
 }
-function readString(record, key) {
+function readString$1(record, key) {
 	const value = record?.[key];
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 function readFirstString(record, keys) {
 	for (const key of keys) {
-		const value = readString(record, key);
+		const value = readString$1(record, key);
 		if (value) return value;
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/local-runtime-attribution.ts
+const OPENAI_PROVIDER_ID = "openai";
+const OPENAI_RESPONSES_API = "openai-responses";
+const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
+function normalizeRuntimeId(value) {
+	return value?.trim().toLowerCase() ?? "";
+}
+/** Maps local Codex runtime plans onto the provider/api pair exposed to event projection. */
+function resolveCodexLocalRuntimeAttribution(params) {
+	const authProfileProvider = normalizeRuntimeId(params.runtimePlan?.auth?.authProfileProviderForAuth);
+	if (normalizeRuntimeId(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.provider) === OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.api) === OPENAI_RESPONSES_API) return {
+		provider: OPENAI_PROVIDER_ID,
+		api: OPENAI_CODEX_RESPONSES_API
+	};
+	return {
+		provider: params.provider,
+		api: params.model.api
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/native-hook-relay.ts
 /**
 * Bridges Codex native hook callbacks into OpenClaw's native hook relay so
@@ -3159,6 +3595,7 @@ const CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS = 30 * 6e4;
 const CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS = 5 * 6e4;
 const CODEX_NATIVE_HOOK_RELAY_COMMAND_MIN_PARENT_MARGIN_MS = 250;
 const CODEX_NATIVE_HOOK_RELAY_COMMAND_MAX_PARENT_MARGIN_MS = 1e3;
+const CODEX_NATIVE_HOOK_RELAY_DEFAULT_TIMEOUT_SEC = 10;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS = 1e4;
 const CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS = 5e3;
 const pendingCodexNativeHookRelayUnregisters = /* @__PURE__ */ new Set();
@@ -3182,9 +3619,25 @@ function scheduleCodexNativeHookRelayUnregister(params) {
 }
 /** Computes the delayed unregister window from Codex's hook timeout. */
 function resolveCodexNativeHookRelayUnregisterGraceMs(hookTimeoutSec) {
-	const hookTimeoutMs = typeof hookTimeoutSec === "number" && Number.isFinite(hookTimeoutSec) && hookTimeoutSec > 0 ? finiteSecondsToTimerSafeMilliseconds(Math.ceil(hookTimeoutSec)) ?? 0 : 0;
+	const hookTimeoutMs = finiteSecondsToTimerSafeMilliseconds(normalizeHookTimeoutSec(hookTimeoutSec)) ?? 0;
 	return Math.max(CODEX_NATIVE_HOOK_RELAY_UNREGISTER_GRACE_MS, addTimerTimeoutGraceMs(hookTimeoutMs, CODEX_NATIVE_HOOK_RELAY_UNREGISTER_EXTRA_GRACE_MS) ?? 0);
 }
+/** Records a native pre-tool failure that Codex does not project as a tool item. */
+function emitCodexNativePreToolUseFailureDiagnostic(params) {
+	emitTrustedDiagnosticEvent({
+		type: "tool.execution.error",
+		...params.agentId ? { agentId: params.agentId } : {},
+		sessionId: params.sessionId,
+		...params.sessionKey ? { sessionKey: params.sessionKey } : {},
+		runId: params.runId,
+		toolName: params.failure.toolName,
+		toolCallId: params.failure.toolCallId,
+		durationMs: params.failure.durationMs,
+		errorCategory: "before_tool_call",
+		terminalReason: params.terminalReason ?? (params.signal?.aborted ? resolveCodexToolAbortTerminalReason(params.signal) : params.failure.disposition),
+		...params.sourceTimestampMs !== void 0 ? { sourceTimestampMs: params.sourceTimestampMs } : {}
+	});
+}
 /** Registers an OpenClaw native hook relay for a Codex app-server turn. */
 function createCodexNativeHookRelay(params) {
 	if (params.options?.enabled === false) return;
@@ -3211,6 +3664,7 @@ function createCodexNativeHookRelay(params) {
 			turnStartTimeoutMs: params.turnStartTimeoutMs
 		}),
 		signal: params.signal,
+		onPreToolUseFailure: params.onPreToolUseFailure,
 		command: {
 			nice: 10,
 			timeoutMs: params.options?.gatewayTimeoutMs
@@ -3300,7 +3754,7 @@ function buildCodexNativeHookRelayDisabledConfig() {
 	};
 }
 function normalizeHookTimeoutSec(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 5;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : CODEX_NATIVE_HOOK_RELAY_DEFAULT_TIMEOUT_SEC;
 }
 function resolveCodexNativeHookRelayCommandTimeoutMs(hookTimeoutSec) {
 	const parentTimeoutMs = finiteSecondsToTimerSafeMilliseconds(normalizeHookTimeoutSec(hookTimeoutSec)) ?? 5e3;
@@ -3328,27 +3782,2379 @@ function sortJsonValue(value) {
 	return sorted;
 }
 //#endregion
-//#region extensions/codex/src/app-server/provider-capabilities.ts
-async function readConfiguredProviderWebSearchSupport(params) {
-	return (await params.client.request("modelProvider/capabilities/read", {}, {
-		timeoutMs: params.timeoutMs,
-		signal: params.signal
-	})).webSearch ? "supported" : "unsupported";
+//#region extensions/codex/src/app-server/tool-progress-normalization.ts
+/**
+* Normalizes and sanitizes Codex dynamic-tool progress payloads before they are
+* emitted into OpenClaw events or logs.
+*/
+/** Maps OpenClaw tool-progress config to the mode used by Codex progress metadata. */
+function resolveCodexToolProgressDetailMode(value) {
+	return value === "raw" ? "raw" : "explain";
 }
-async function resolveCodexProviderWebSearchSupportForClient(params) {
-	const modelProviderOverride = params.modelProviderOverride?.trim().toLowerCase();
-	if (modelProviderOverride === "openai") return "supported";
-	if (modelProviderOverride) return "unsupported";
+/** Recursively redacts sensitive strings and handles circular values in event payloads. */
+function sanitizeCodexAgentEventValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (typeof value === "string") return redactToolPayloadText(value);
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		return value.map((entry) => sanitizeCodexAgentEventValue(entry, seen));
+	}
+	if (value && typeof value === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		const out = {};
+		for (const [key, child] of Object.entries(value)) out[key] = typeof child === "string" ? redactSensitiveFieldValue(key, child) : sanitizeCodexAgentEventValue(child, seen);
+		return out;
+	}
+	return value;
+}
+/** Sanitizes a record-shaped Codex agent event payload. */
+function sanitizeCodexAgentEventRecord(value) {
+	return sanitizeCodexAgentEventValue(value);
+}
+/** Sanitizes dynamic-tool arguments before diagnostic/event emission. */
+function sanitizeCodexToolArguments(value) {
+	if (!isJsonObject(value)) return;
+	return sanitizeCodexAgentEventRecord(value);
+}
+/** Sanitizes a Codex dynamic-tool response before diagnostic/event emission. */
+function sanitizeCodexToolResponse(response) {
+	return sanitizeCodexAgentEventRecord(response);
+}
+/** Infers compact human-readable tool metadata from Codex dynamic-tool arguments. */
+function inferCodexDynamicToolMeta(call, detailMode) {
+	return inferToolMetaFromArgs(call.tool, call.arguments, { detailMode });
+}
+//#endregion
+//#region extensions/codex/src/app-server/transcript-mirror.ts
+const MIRROR_IDENTITY_META_KEY = "mirrorIdentity";
+const MIRROR_ORIGIN_META_KEY = "mirrorOrigin";
+const CODEX_APP_SERVER_MIRROR_ORIGIN = "codex-app-server";
+function attachCodexMirrorOrigin(message) {
+	const record = message;
+	const existing = record["__openclaw"];
+	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+	return {
+		...record,
+		__openclaw: {
+			...baseMeta,
+			[MIRROR_ORIGIN_META_KEY]: CODEX_APP_SERVER_MIRROR_ORIGIN
+		}
+	};
+}
+function buildSenderLabel(params) {
+	const label = params.senderName ?? params.senderUsername ?? params.senderE164 ?? params.senderId;
+	if (!label) return;
+	if (!params.senderId || label.includes(params.senderId)) return label;
+	return `${label} (${params.senderId})`;
+}
+function buildCodexUserPromptMessageFromPrepared(params, preparedUserMessage) {
+	const senderId = normalizeOptionalString(params.senderId);
+	const senderName = normalizeOptionalString(params.senderName);
+	const senderUsername = normalizeOptionalString(params.senderUsername);
+	const senderE164 = normalizeOptionalString(params.senderE164);
+	const senderLabel = buildSenderLabel({
+		senderId,
+		senderName,
+		senderUsername,
+		senderE164
+	});
+	const sourceChannel = normalizeOptionalString(params.inputProvenance?.sourceChannel ?? params.messageChannel ?? params.messageProvider);
+	if (preparedUserMessage) return {
+		role: "user",
+		timestamp: Date.now(),
+		...params.inputProvenance ? { provenance: params.inputProvenance } : {},
+		...sourceChannel ? { sourceChannel } : {},
+		...senderId ? { senderId } : {},
+		...senderName ? { senderName } : {},
+		...senderUsername ? { senderUsername } : {},
+		...senderE164 ? { senderE164 } : {},
+		...senderLabel ? { senderLabel } : {},
+		...preparedUserMessage
+	};
+	return {
+		role: "user",
+		content: params.prompt,
+		timestamp: Date.now(),
+		...params.inputProvenance ? { provenance: params.inputProvenance } : {},
+		...sourceChannel ? { sourceChannel } : {},
+		...senderId ? { senderId } : {},
+		...senderName ? { senderName } : {},
+		...senderUsername ? { senderUsername } : {},
+		...senderE164 ? { senderE164 } : {},
+		...senderLabel ? { senderLabel } : {}
+	};
+}
+function buildCodexUserPromptMessage(params) {
+	return buildCodexUserPromptMessageFromPrepared(params, params.userTurnTranscriptRecorder?.message);
+}
+async function buildResolvedCodexUserPromptMessage(params) {
+	return buildCodexUserPromptMessageFromPrepared(params, await params.userTurnTranscriptRecorder?.resolveMessage() ?? params.userTurnTranscriptRecorder?.message);
+}
+async function mirrorTranscriptBestEffort(params) {
 	try {
-		return await readConfiguredProviderWebSearchSupport(params);
-	} catch {
-		return "unknown";
+		const messages = await resolveFinalCodexMirrorMessages({
+			params: params.params,
+			messagesSnapshot: params.result.messagesSnapshot,
+			turnId: params.turnId
+		});
+		const mirrorResult = await mirrorCodexAppServerTranscript({
+			sessionFile: params.params.sessionFile,
+			agentId: params.agentId,
+			sessionKey: params.sessionKey,
+			sessionId: params.params.sessionId,
+			cwd: params.cwd,
+			messages,
+			idempotencyScope: `codex-app-server:${params.threadId}`,
+			config: params.params.config
+		});
+		for (const message of mirrorResult.userMessagesPresent) try {
+			params.notifyUserMessagePersisted(message);
+		} catch (error) {
+			embeddedAgentLog.warn("failed to notify codex app-server user-message persistence", { error: formatErrorMessage(error) });
+		}
+		return mirrorResult.assistantMirrorIdentitiesOwned.includes(`${params.turnId}:assistant`);
+	} catch (error) {
+		embeddedAgentLog.warn("failed to mirror codex app-server transcript", { error });
+		return false;
 	}
 }
-async function resolveCodexProviderWebSearchSupport(params) {
-	let client;
+async function resolveFinalCodexMirrorMessages(params) {
+	if (params.params.suppressNextUserMessagePersistence || !params.params.userTurnTranscriptRecorder) return params.messagesSnapshot;
+	const resolvedPrompt = attachCodexMirrorIdentity(await buildResolvedCodexUserPromptMessage(params.params), `${params.turnId}:prompt`);
+	const firstUserIndex = params.messagesSnapshot.findIndex((message) => message.role === "user");
+	if (firstUserIndex === -1) return [resolvedPrompt, ...params.messagesSnapshot];
+	const messages = params.messagesSnapshot.slice();
+	messages[firstUserIndex] = resolvedPrompt;
+	return messages;
+}
+function createCodexAppServerUserMessagePersistenceNotifier(runParams) {
+	let notified = false;
+	return (message) => {
+		if (notified) return;
+		notified = true;
+		runParams.userTurnTranscriptRecorder?.markRuntimePersisted(message);
+		try {
+			runParams.onUserMessagePersisted?.(message);
+		} catch (error) {
+			embeddedAgentLog.warn("codex app-server user persistence notification failed", { error: formatErrorMessage(error) });
+		}
+	};
+}
+async function mirrorPromptAtTurnStartBestEffort(params) {
+	if (params.params.suppressNextUserMessagePersistence) return;
 	try {
-		client = await params.clientFactory(params.appServer.start, params.authProfileId, params.agentDir, params.config, { timeoutMs: params.appServer.requestTimeoutMs });
+		const mirrorPromise = (async () => {
+			const userPromptMessage = attachCodexMirrorIdentity(await buildResolvedCodexUserPromptMessage(params.params), `${params.turnId}:prompt`);
+			const mirrorResult = await mirrorCodexAppServerTranscript({
+				sessionFile: params.params.sessionFile,
+				agentId: params.agentId,
+				sessionKey: params.sessionKey,
+				sessionId: params.params.sessionId,
+				cwd: params.cwd,
+				messages: [userPromptMessage],
+				idempotencyScope: `codex-app-server:${params.threadId}`,
+				config: params.params.config
+			});
+			for (const message of mirrorResult.userMessagesPresent) params.notifyUserMessagePersisted(message);
+		})();
+		params.params.userTurnTranscriptRecorder?.markRuntimePersistencePending(mirrorPromise);
+		await mirrorPromise;
+	} catch (error) {
+		embeddedAgentLog.warn("failed to mirror codex app-server prompt at turn start", { error });
+	}
+}
+/**
+* Tag a message with a stable logical identity for mirror dedupe. Callers
+* should use a value that is invariant for the same logical message across
+* re-emits (e.g. `${turnId}:prompt`, `${turnId}:assistant`) but distinct
+* for genuinely-distinct messages (different turns, different kinds). When
+* present this identity replaces the role/content fingerprint in the
+* idempotency key, so the dedupe survives caller-scope rotation without
+* collapsing distinct same-content turns.
+*/
+function attachCodexMirrorIdentity(message, identity) {
+	const record = message;
+	const existing = record["__openclaw"];
+	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+	return {
+		...record,
+		__openclaw: {
+			...baseMeta,
+			[MIRROR_IDENTITY_META_KEY]: identity
+		}
+	};
+}
+function readMirrorIdentity(message) {
+	const meta = message["__openclaw"];
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
+	const id = meta[MIRROR_IDENTITY_META_KEY];
+	return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function fingerprintMirrorMessageContent(message) {
+	const payload = JSON.stringify({
+		role: message.role,
+		content: message.content
+	});
+	return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+function buildMirrorDedupeIdentity(message) {
+	const explicit = readMirrorIdentity(message);
+	if (explicit) return explicit;
+	return `${message.role}:${fingerprintMirrorMessageContent(message)}`;
+}
+async function mirrorCodexAppServerTranscript(params) {
+	const messages = params.messages.filter((message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
+	if (messages.length === 0) return {
+		assistantMirrorIdentitiesOwned: [],
+		userMessagesPresent: []
+	};
+	const transcriptTarget = resolveCodexMirrorTranscriptTarget(params);
+	const { appendedUpdates, assistantMirrorIdentitiesOwned, userMessagesPresent } = await withSessionTranscriptWriteLock({
+		...transcriptTarget,
+		config: params.config
+	}, async (transcript) => {
+		const nextAppendedUpdates = [];
+		const nextAssistantMirrorIdentitiesOwned = /* @__PURE__ */ new Set();
+		const nextUserMessagesPresent = [];
+		const mirrorState = readTranscriptMirrorState(await transcript.readEvents());
+		let nextMessageSeq = mirrorState.messageCount;
+		for (const message of messages) {
+			const dedupeIdentity = buildMirrorDedupeIdentity(message);
+			const idempotencyKey = (message.role === "user" ? normalizeOptionalString(message.idempotencyKey) : void 0) ?? (params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0);
+			const transcriptMessage = {
+				...attachCodexMirrorOrigin(message),
+				...idempotencyKey ? { idempotencyKey } : {}
+			};
+			if (idempotencyKey && mirrorState.idempotencyKeys.has(idempotencyKey)) {
+				const persistedUserMessage = mirrorState.userMessagesByIdempotencyKey.get(idempotencyKey);
+				if (persistedUserMessage) nextUserMessagesPresent.push(persistedUserMessage);
+				if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
+				continue;
+			}
+			const nextMessage = runAgentHarnessBeforeMessageWriteHook({
+				message: transcriptMessage,
+				agentId: params.agentId,
+				sessionKey: params.sessionKey
+			});
+			if (!nextMessage) {
+				if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
+				continue;
+			}
+			const messageToAppend = idempotencyKey ? {
+				...attachCodexMirrorOrigin(nextMessage),
+				idempotencyKey
+			} : attachCodexMirrorOrigin(nextMessage);
+			const appended = await transcript.appendMessage({
+				message: messageToAppend,
+				idempotencyLookup: idempotencyKey ? "caller-checked" : "scan",
+				cwd: params.cwd
+			});
+			if (!appended) continue;
+			const { messageId, message: appendedMessage } = appended;
+			if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
+			if (appendedMessage.role === "user") {
+				nextUserMessagesPresent.push(appendedMessage);
+				if (idempotencyKey) mirrorState.userMessagesByIdempotencyKey.set(idempotencyKey, appendedMessage);
+			}
+			nextMessageSeq += 1;
+			nextAppendedUpdates.push({
+				messageId,
+				message: appendedMessage,
+				messageSeq: nextMessageSeq
+			});
+			if (idempotencyKey) mirrorState.idempotencyKeys.add(idempotencyKey);
+		}
+		return {
+			appendedUpdates: nextAppendedUpdates,
+			assistantMirrorIdentitiesOwned: [...nextAssistantMirrorIdentitiesOwned],
+			userMessagesPresent: nextUserMessagesPresent
+		};
+	});
+	for (const update of appendedUpdates) try {
+		await publishSessionTranscriptUpdateByIdentity({
+			...transcriptTarget,
+			update: {
+				...params.sessionKey ? { sessionKey: params.sessionKey } : {},
+				...params.agentId ? { agentId: params.agentId } : {},
+				message: update.message,
+				messageId: update.messageId,
+				messageSeq: update.messageSeq
+			}
+		});
+	} catch (error) {
+		embeddedAgentLog.warn("failed to publish codex app-server transcript update", { error: formatErrorMessage(error) });
+	}
+	return {
+		assistantMirrorIdentitiesOwned,
+		userMessagesPresent
+	};
+}
+function resolveCodexMirrorTranscriptTarget(params) {
+	return {
+		...params.agentId ? { agentId: params.agentId } : {},
+		sessionFile: params.sessionFile,
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey ?? ""
+	};
+}
+function readTranscriptMirrorState(events) {
+	const idempotencyKeys = /* @__PURE__ */ new Set();
+	const userMessagesByIdempotencyKey = /* @__PURE__ */ new Map();
+	let messageCount = 0;
+	for (const event of events) {
+		if (!event || typeof event !== "object" || Array.isArray(event)) continue;
+		const parsed = event;
+		if (parsed.type === "message") messageCount += 1;
+		if (typeof parsed.message?.idempotencyKey === "string") {
+			idempotencyKeys.add(parsed.message.idempotencyKey);
+			if (parsed.message.role === "user") userMessagesByIdempotencyKey.set(parsed.message.idempotencyKey, parsed.message);
+		}
+	}
+	return {
+		idempotencyKeys,
+		messageCount,
+		userMessagesByIdempotencyKey
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector.ts
+/** Projects metadata-only lifecycle diagnostics for native tool items. */
+var CodexNativeToolLifecycleProjector = class {
+	constructor(context, threadId, turnId, options = {}) {
+		this.context = context;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.options = options;
+		this.startedAtByItem = /* @__PURE__ */ new Map();
+		this.activeItems = /* @__PURE__ */ new Map();
+		this.webSearchCompletionByItem = /* @__PURE__ */ new Map();
+		this.completedItemIds = /* @__PURE__ */ new Set();
+		this.approvalFailureDispositionByItem = /* @__PURE__ */ new Map();
+		this.preToolUseFailureByItem = /* @__PURE__ */ new Map();
+		this.finalized = false;
+	}
+	handleNotification(notification) {
+		const params = isJsonObject(notification.params) ? notification.params : void 0;
+		if (!params || readCodexNotificationThreadId(params) !== this.threadId || readCodexNotificationTurnId(params) !== this.turnId) return;
+		if (notification.method === "turn/completed") {
+			const turn = readCodexTurn(params.turn);
+			if (!turn || turn.id !== this.turnId) return;
+			for (const item of turn.items ?? []) this.recordSnapshotItem(item);
+			return;
+		}
+		if (notification.method === "rawResponseItem/completed") {
+			const item = isJsonObject(params.item) ? params.item : void 0;
+			if (item) this.recordRawWebSearchResult(item);
+			return;
+		}
+		if (notification.method !== "item/started" && notification.method !== "item/completed") return;
+		const item = readItem(params.item);
+		if (!item) return;
+		this.recordItem({
+			phase: notification.method === "item/started" ? "start" : "result",
+			item,
+			sourceTimestampMs: asDateTimestampMs(notification.method === "item/started" ? params.startedAtMs : params.completedAtMs)
+		});
+	}
+	recordItem(params) {
+		const toolName = auditNativeToolName(params.item);
+		if (!toolName || this.completedItemIds.has(params.item.id)) return;
+		if (params.phase === "start") {
+			this.recordStarted(params.item.id, toolName, auditNativeToolUnfinishedStatus(params.item), params.sourceTimestampMs);
+			return;
+		}
+		if (params.item.type === "webSearch") {
+			this.webSearchCompletionByItem.set(params.item.id, {
+				runWasAborted: this.options.runAbortSignal?.aborted === true,
+				sourceTimestampMs: params.sourceTimestampMs
+			});
+			return;
+		}
+		const itemDurationMs = typeof params.item.durationMs === "number" ? params.item.durationMs : void 0;
+		this.recordTerminal(params.item.id, toolName, auditNativeToolTerminalStatus(params.item), {
+			itemDurationMs,
+			sourceTimestampMs: params.sourceTimestampMs
+		});
+	}
+	recordApprovalFailureDisposition(toolCallId, disposition) {
+		if (!this.completedItemIds.has(toolCallId)) this.approvalFailureDispositionByItem.set(toolCallId, disposition);
+	}
+	recordPreToolUseFailure(failure, runWasAborted = this.options.runAbortSignal?.aborted === true) {
+		if (this.completedItemIds.has(failure.toolCallId)) return;
+		const record = {
+			failure,
+			terminalReason: runWasAborted && this.options.runAbortSignal ? resolveCodexToolAbortTerminalReason(this.options.runAbortSignal) : failure.disposition
+		};
+		if (this.finalized) {
+			this.completedItemIds.add(failure.toolCallId);
+			this.emitPreToolUseFailure(record, failure.toolName, failure.durationMs);
+			return;
+		}
+		this.preToolUseFailureByItem.set(failure.toolCallId, record);
+	}
+	recordRawWebSearchResult(item) {
+		if (readString(item, "type") !== "web_search_call") return;
+		const toolCallId = readString(item, "id");
+		if (!toolCallId || this.completedItemIds.has(toolCallId)) return;
+		const toolName = "web_search";
+		this.recordStarted(toolCallId, toolName, "unknown");
+		const rawStatus = readString(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 });
+	}
+	recordTerminal(toolCallId, toolName, status, options = {}) {
+		const runWasAborted = options.runWasAborted ?? this.options.runAbortSignal?.aborted === true;
+		const preToolUseFailure = this.preToolUseFailureByItem.get(toolCallId);
+		this.preToolUseFailureByItem.delete(toolCallId);
+		const approvalFailureDisposition = this.approvalFailureDispositionByItem.get(toolCallId);
+		this.approvalFailureDispositionByItem.delete(toolCallId);
+		this.completedItemIds.add(toolCallId);
+		this.activeItems.delete(toolCallId);
+		this.webSearchCompletionByItem.delete(toolCallId);
+		const startedAt = this.startedAtByItem.get(toolCallId);
+		this.startedAtByItem.delete(toolCallId);
+		const endedAt = options.sourceTimestampMs ?? Date.now();
+		const durationMs = options.itemDurationMs ?? (startedAt === void 0 ? 0 : Math.max(0, endedAt - startedAt));
+		if (preToolUseFailure) {
+			this.emitPreToolUseFailure(preToolUseFailure, toolName, durationMs, options.sourceTimestampMs);
+			return;
+		}
+		const terminalEvent = approvalFailureDisposition ? {
+			type: "tool.execution.error",
+			durationMs,
+			errorCategory: "codex_native_tool_approval",
+			terminalReason: approvalFailureDisposition
+		} : status === "blocked" ? {
+			type: "tool.execution.blocked",
+			reason: "codex_native_tool_blocked",
+			deniedReason: "codex_native_tool_blocked"
+		} : status === "failed" || status === "cancelled" || status === "unknown" ? {
+			type: "tool.execution.error",
+			durationMs,
+			errorCategory: status === "unknown" ? "codex_native_tool_outcome_unknown" : status === "cancelled" ? "aborted" : "codex_native_tool_error",
+			...status === "unknown" ? { errorCode: "tool_outcome_unknown" } : {},
+			terminalReason: status === "unknown" ? "failed" : runWasAborted && this.options.runAbortSignal ? resolveCodexToolAbortTerminalReason(this.options.runAbortSignal) : status === "cancelled" ? "cancelled" : "failed"
+		} : {
+			type: "tool.execution.completed",
+			durationMs
+		};
+		emitTrustedDiagnosticEvent({
+			...this.buildBase(toolCallId, toolName),
+			...terminalEvent,
+			...options.sourceTimestampMs !== void 0 ? { sourceTimestampMs: options.sourceTimestampMs } : {}
+		});
+	}
+	finalizeActive(runWasAborted = this.options.runAbortSignal?.aborted === true) {
+		this.finalized = true;
+		for (const [toolCallId, { toolName, unfinishedStatus }] of this.activeItems) {
+			const webSearchCompletion = this.webSearchCompletionByItem.get(toolCallId);
+			const itemRunWasAborted = webSearchCompletion ? webSearchCompletion.runWasAborted : runWasAborted;
+			this.recordTerminal(toolCallId, toolName, unfinishedStatus, {
+				runWasAborted: itemRunWasAborted,
+				sourceTimestampMs: webSearchCompletion?.sourceTimestampMs
+			});
+		}
+		for (const [toolCallId, record] of this.preToolUseFailureByItem) if (!this.completedItemIds.has(toolCallId)) this.recordTerminal(toolCallId, record.failure.toolName, "failed", { itemDurationMs: record.failure.durationMs });
+		this.activeItems.clear();
+		this.webSearchCompletionByItem.clear();
+		this.approvalFailureDispositionByItem.clear();
+		this.preToolUseFailureByItem.clear();
+	}
+	emitPreToolUseFailure(record, toolName, durationMs, sourceTimestampMs) {
+		emitCodexNativePreToolUseFailureDiagnostic({
+			agentId: this.context.agentId,
+			sessionId: this.context.sessionId,
+			sessionKey: this.context.sessionKey,
+			runId: this.context.runId,
+			failure: {
+				...record.failure,
+				toolName,
+				durationMs
+			},
+			terminalReason: record.terminalReason,
+			sourceTimestampMs
+		});
+	}
+	recordSnapshotItem(item) {
+		if (!auditNativeToolName(item) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
+		const toolName = auditNativeToolName(item);
+		if (!toolName) return;
+		this.recordStarted(item.id, toolName, auditNativeToolUnfinishedStatus(item));
+		this.recordItem({
+			phase: "result",
+			item
+		});
+	}
+	recordStarted(toolCallId, toolName, unfinishedStatus, sourceTimestampMs) {
+		if (this.activeItems.has(toolCallId)) return;
+		this.startedAtByItem.set(toolCallId, sourceTimestampMs ?? Date.now());
+		this.activeItems.set(toolCallId, {
+			toolName,
+			unfinishedStatus
+		});
+		emitTrustedDiagnosticEvent({
+			type: "tool.execution.started",
+			...this.buildBase(toolCallId, toolName),
+			...sourceTimestampMs !== void 0 ? { sourceTimestampMs } : {}
+		});
+	}
+	buildBase(toolCallId, toolName) {
+		return {
+			agentId: this.context.agentId,
+			runId: this.context.runId,
+			sessionId: this.context.sessionId,
+			sessionKey: this.context.sessionKey,
+			toolName,
+			toolCallId
+		};
+	}
+};
+const ZERO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+const MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM = 20;
+const TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS = 12e3;
+const MISSING_TOOL_RESULT_ERROR = "OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.";
+const GENERATED_IMAGE_MEDIA_SUBDIR = "tool-image-generation";
+const BYTES_PER_MB = 1024 * 1024;
+const DEFAULT_GENERATED_IMAGE_MAX_BYTES = 6 * BYTES_PER_MB;
+const TRANSCRIPT_PROGRESS_SUPPRESSED_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"message",
+	"messages",
+	"reply",
+	"send",
+	"reaction",
+	"react",
+	"typing"
+]);
+function shouldEmitTranscriptToolProgress(toolName, _args) {
+	const normalized = typeof toolName === "string" ? toolName.trim().toLowerCase() : "";
+	return Boolean(normalized && !TRANSCRIPT_PROGRESS_SUPPRESSED_TOOL_NAMES.has(normalized));
+}
+var CodexAppServerEventProjector = class {
+	constructor(params, threadId, turnId, options = {}) {
+		this.params = params;
+		this.threadId = threadId;
+		this.turnId = turnId;
+		this.options = options;
+		this.assistantTextByItem = /* @__PURE__ */ new Map();
+		this.assistantItemOrder = [];
+		this.assistantPhaseByItem = /* @__PURE__ */ new Map();
+		this.latestTerminalAssistantCandidateSuperseded = false;
+		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
+		this.terminalAssistantCandidateEarlierActiveItemIds = /* @__PURE__ */ new Set();
+		this.lastCommentaryProgressTextByItem = /* @__PURE__ */ new Map();
+		this.pendingRawCommentaryEchoes = 0;
+		this.reasoningTextByGroup = /* @__PURE__ */ new Map();
+		this.reasoningItemOrder = /* @__PURE__ */ new Map();
+		this.planTextByItem = /* @__PURE__ */ new Map();
+		this.activeItemIds = /* @__PURE__ */ new Set();
+		this.completedItemIds = /* @__PURE__ */ new Set();
+		this.activeCompactionItemIds = /* @__PURE__ */ new Set();
+		this.toolProgressTexts = /* @__PURE__ */ new Set();
+		this.toolResultSummaryItemIds = /* @__PURE__ */ new Set();
+		this.toolResultOutputItemIds = /* @__PURE__ */ new Set();
+		this.toolResultOutputStreamedItemIds = /* @__PURE__ */ new Set();
+		this.transcriptToolProgressSuppressedIds = /* @__PURE__ */ new Set();
+		this.toolTranscriptArgumentsById = /* @__PURE__ */ new Map();
+		this.toolResultOutputDeltaState = /* @__PURE__ */ new Map();
+		this.toolResultOutputTextByItem = /* @__PURE__ */ new Map();
+		this.toolMetas = /* @__PURE__ */ new Map();
+		this.terminalPresentationClearedItemIds = /* @__PURE__ */ new Set();
+		this.nativeToolOutcomeOrdinals = /* @__PURE__ */ new Map();
+		this.sideEffectingToolItemIds = /* @__PURE__ */ new Set();
+		this.sideEffectingDynamicToolCallIds = /* @__PURE__ */ new Set();
+		this.toolTranscriptMessages = [];
+		this.toolTranscriptCallIds = /* @__PURE__ */ new Set();
+		this.toolTranscriptResultIds = /* @__PURE__ */ new Set();
+		this.toolTranscriptNamesById = /* @__PURE__ */ new Map();
+		this.toolTrajectoryCallIds = /* @__PURE__ */ new Set();
+		this.toolTrajectoryResultIds = /* @__PURE__ */ new Set();
+		this.toolTrajectoryNamesById = /* @__PURE__ */ new Map();
+		this.toolTrajectoryItemsById = /* @__PURE__ */ new Map();
+		this.transcriptToolProgressCallIds = /* @__PURE__ */ new Set();
+		this.nativeGeneratedMediaItemIds = /* @__PURE__ */ new Set();
+		this.nativeGeneratedMediaUrlsByItemId = /* @__PURE__ */ new Map();
+		this.afterToolCallObservedItemIds = /* @__PURE__ */ new Set();
+		this.assistantStarted = false;
+		this.reasoningStarted = false;
+		this.reasoningEnded = false;
+		this.streamedPartialAssistantItemReplaceable = false;
+		this.promptErrorSource = null;
+		this.synthesizedMissingToolResultError = null;
+		this.aborted = false;
+		this.guardianReviewCount = 0;
+		this.completedCompactionCount = 0;
+		this.nativeToolLifecycleProjector = new CodexNativeToolLifecycleProjector(params, threadId, turnId, { runAbortSignal: options.runAbortSignal });
+	}
+	getCompletedTurnStatus() {
+		return this.completedTurn?.status;
+	}
+	hasCompletedTerminalAssistantText() {
+		const latestCompletedItemId = this.latestCompletedTerminalAssistantItemId;
+		if (!latestCompletedItemId) return false;
+		const finalItem = this.resolveFinalAssistantTextItem();
+		return this.latestCompletedItemId === latestCompletedItemId && finalItem?.itemId === latestCompletedItemId && this.completedItemIds.has(latestCompletedItemId);
+	}
+	getLatestTerminalAssistantCandidate() {
+		const itemId = this.latestTerminalAssistantCandidateItemId;
+		if (!itemId) return;
+		const text = this.assistantTextByItem.get(itemId)?.trim();
+		return {
+			itemId,
+			hasText: Boolean(text && !this.toolProgressTexts.has(text))
+		};
+	}
+	hasLatestTerminalAssistantCandidateText() {
+		return !this.latestTerminalAssistantCandidateSuperseded && this.getLatestTerminalAssistantCandidate()?.hasText === true;
+	}
+	canReleaseLatestTerminalAssistantAfterToolHandoff() {
+		return this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff && this.hasLatestTerminalAssistantCandidateText();
+	}
+	/** Restores a completed final item after only the enclosing turn timeout fired. */
+	recoverCompletedTerminalAssistantAfterTurnWatchTimeout() {
+		if (!this.aborted || this.promptError !== "codex app-server attempt timed out" || !this.hasCompletedTerminalAssistantText()) return false;
+		this.aborted = false;
+		this.promptError = void 0;
+		this.promptErrorSource = null;
+		return true;
+	}
+	/** Resolves the shared model-order position for a native tool item. */
+	recordNativeToolOutcome(item) {
+		if (!item || this.nativeToolOutcomeOrdinals.has(item.id) || !shouldClearTerminalPresentationForNativeItem(item)) return;
+		const ordinal = this.params.allocateToolOutcomeOrdinal?.(item.id);
+		if (ordinal !== void 0) this.nativeToolOutcomeOrdinals.set(item.id, ordinal);
+	}
+	recordNativeToolApprovalFailure(toolCallId, disposition) {
+		this.nativeToolLifecycleProjector.recordApprovalFailureDisposition(toolCallId, disposition);
+	}
+	recordNativeToolPreToolUseFailure(failure) {
+		this.nativeToolLifecycleProjector.recordPreToolUseFailure(failure);
+	}
+	async handleNotification(notification) {
+		const params = isJsonObject(notification.params) ? notification.params : void 0;
+		if (!params) return;
+		if (isHookNotificationMethod(notification.method)) {
+			if (!this.isHookNotificationForCurrentThread(params)) return;
+		} else if (notification.method === "guardianWarning") {
+			if (readCodexNotificationThreadId(params) !== this.threadId) return;
+		} else if (!this.isNotificationForTurn(params)) return;
+		this.nativeToolLifecycleProjector.handleNotification(notification);
+		switch (notification.method) {
+			case "item/agentMessage/delta":
+				await this.handleAssistantDelta(params);
+				break;
+			case "item/reasoning/summaryTextDelta":
+			case "item/reasoning/textDelta":
+				await this.handleReasoningDelta(notification.method, params);
+				break;
+			case "item/plan/delta":
+				this.handlePlanDelta(params);
+				break;
+			case "turn/plan/updated":
+				this.handleTurnPlanUpdated(params);
+				break;
+			case "item/started":
+				await this.handleItemStarted(params);
+				break;
+			case "item/completed":
+				await this.handleItemCompleted(params);
+				break;
+			case "item/commandExecution/outputDelta":
+				this.handleOutputDelta(params, "bash");
+				break;
+			case "item/autoApprovalReview/started":
+			case "item/autoApprovalReview/completed":
+				this.handleGuardianReviewNotification(notification.method, params);
+				break;
+			case "guardianWarning":
+				this.handleGuardianWarning(params);
+				break;
+			case "hook/started":
+			case "hook/completed":
+				this.handleHookNotification(notification.method, params);
+				break;
+			case "thread/tokenUsage/updated":
+				this.handleTokenUsage(params);
+				break;
+			case "turn/completed":
+				await this.handleTurnCompleted(params);
+				break;
+			case "rawResponseItem/completed":
+				await this.handleRawResponseItemCompleted(params);
+				break;
+			case "error":
+				if (params.willRetry === true) break;
+				this.promptError = this.formatCodexErrorMessage(params) ?? "codex app-server error";
+				this.promptErrorSource = "prompt";
+				break;
+			default: break;
+		}
+	}
+	buildResult(toolTelemetry, options) {
+		this.nativeToolLifecycleProjector.finalizeActive();
+		const assistantTexts = this.collectAssistantTexts();
+		const reasoningText = collectReasoningTextValues(this.reasoningTextByGroup, this.reasoningItemOrder).join("\n\n");
+		const planText = collectTextValues(this.planTextByItem).join("\n\n");
+		const hasAssistantItemText = this.hasAssistantItemTextForSynthesis();
+		const legacyFailClosed = !this.completedTurn || this.completedTurn.status !== "completed" || hasAssistantItemText;
+		const hasDeliverableAssistantOnCompletedTurn = this.completedTurn?.status === "completed" && assistantTexts.some((text) => text.trim().length > 0);
+		this.synthesizeMissingToolResults({
+			synthesize: legacyFailClosed,
+			recordPromptError: legacyFailClosed && !hasDeliverableAssistantOnCompletedTurn
+		});
+		const lastAssistant = assistantTexts.length > 0 ? this.createAssistantMessage(assistantTexts.join("\n\n")) : void 0;
+		const currentAttemptAssistant = this.createCurrentAttemptAssistantMessage();
+		const turnId = this.turnId;
+		const messagesSnapshot = this.params.suppressNextUserMessagePersistence ? [] : [attachCodexMirrorIdentity(buildCodexUserPromptMessage(this.params), `${turnId}:prompt`)];
+		if (reasoningText) messagesSnapshot.push(attachCodexMirrorIdentity(this.createAssistantMirrorMessage("Codex reasoning", reasoningText), `${turnId}:reasoning`));
+		if (planText) messagesSnapshot.push(attachCodexMirrorIdentity(this.createAssistantMirrorMessage("Codex plan", planText), `${turnId}:plan`));
+		messagesSnapshot.push(...this.toolTranscriptMessages);
+		if (lastAssistant) messagesSnapshot.push(attachCodexMirrorIdentity(lastAssistant, `${turnId}:assistant`));
+		const turnFailed = this.completedTurn?.status === "failed";
+		const promptError = this.promptError ?? this.synthesizedMissingToolResultError ?? (turnFailed ? this.completedTurn?.error?.message ?? "codex app-server turn failed" : null);
+		const agentHarnessResultClassification = classifyAgentHarnessTerminalOutcome({
+			assistantTexts,
+			reasoningText,
+			planText,
+			promptError,
+			turnCompleted: Boolean(this.completedTurn)
+		});
+		const toolMetas = [...this.toolMetas.values()];
+		const hadPotentialSideEffects = toolTelemetry.didSendViaMessagingTool || (toolTelemetry.successfulCronAdds ?? 0) > 0 || this.nativeGeneratedMediaItemIds.size > 0 || this.sideEffectingToolItemIds.size > 0 || this.sideEffectingDynamicToolCallIds.size > 0;
+		return {
+			aborted: this.aborted,
+			externalAbort: false,
+			timedOut: false,
+			idleTimedOut: false,
+			timedOutDuringCompaction: false,
+			timedOutDuringToolExecution: false,
+			promptError,
+			promptErrorSource: promptError ? this.promptErrorSource || "prompt" : null,
+			sessionIdUsed: this.params.sessionId,
+			...agentHarnessResultClassification ? { agentHarnessResultClassification } : {},
+			bootstrapPromptWarningSignaturesSeen: this.params.bootstrapPromptWarningSignaturesSeen,
+			bootstrapPromptWarningSignature: this.params.bootstrapPromptWarningSignature,
+			messagesSnapshot,
+			assistantTexts,
+			toolMetas,
+			lastAssistant,
+			currentAttemptAssistant,
+			...this.lastNativeToolError ? { lastToolError: this.lastNativeToolError } : {},
+			didSendViaMessagingTool: toolTelemetry.didSendViaMessagingTool,
+			didDeliverSourceReplyViaMessageTool: toolTelemetry.didDeliverSourceReplyViaMessageTool === true,
+			messagingToolSentTexts: toolTelemetry.messagingToolSentTexts,
+			messagingToolSentMediaUrls: toolTelemetry.messagingToolSentMediaUrls,
+			messagingToolSentTargets: toolTelemetry.messagingToolSentTargets,
+			messagingToolSourceReplyPayloads: toolTelemetry.messagingToolSourceReplyPayloads ?? [],
+			heartbeatToolResponse: toolTelemetry.heartbeatToolResponse,
+			toolMediaUrls: this.buildToolMediaUrls(toolTelemetry),
+			toolAudioAsVoice: toolTelemetry.toolAudioAsVoice,
+			successfulCronAdds: toolTelemetry.successfulCronAdds,
+			cloudCodeAssistFormatError: false,
+			attemptUsage: this.tokenUsage,
+			replayMetadata: {
+				hadPotentialSideEffects,
+				replaySafe: !hadPotentialSideEffects
+			},
+			itemLifecycle: {
+				startedCount: this.activeItemIds.size + this.completedItemIds.size,
+				completedCount: this.completedItemIds.size,
+				activeCount: this.activeItemIds.size,
+				...this.completedCompactionCount > 0 ? { compactionCount: this.completedCompactionCount } : {}
+			},
+			yieldDetected: options?.yieldDetected || false,
+			didSendDeterministicApprovalPrompt: this.guardianReviewCount > 0 ? false : void 0
+		};
+	}
+	recordDynamicToolCall(params) {
+		const args = sanitizeCodexToolArguments(params.arguments);
+		this.recordToolTranscriptCall({
+			id: params.callId,
+			name: params.tool,
+			arguments: args
+		});
+	}
+	recordDynamicToolResult(params) {
+		const resultText = collectDynamicToolContentText(params.contentItems);
+		if (params.asyncStarted === true) {
+			const existing = this.toolMetas.get(params.callId);
+			this.toolMetas.set(params.callId, {
+				toolName: existing?.toolName ?? params.tool,
+				...existing?.meta ? { meta: existing.meta } : {},
+				asyncStarted: true
+			});
+		}
+		this.recordToolTranscriptResult({
+			id: params.callId,
+			name: params.tool,
+			text: resultText,
+			isError: !params.success
+		});
+		if (!params.success && params.terminalType === "blocked") this.lastNativeToolError = {
+			toolName: params.tool,
+			error: resultText || "codex dynamic tool blocked"
+		};
+		else if (params.success && this.lastNativeToolError && !this.lastNativeToolError.mutatingAction) this.lastNativeToolError = void 0;
+		if (params.sideEffectEvidence === true) this.sideEffectingDynamicToolCallIds.add(params.callId);
+	}
+	markTimedOut() {
+		this.aborted = true;
+		this.promptError = "codex app-server attempt timed out";
+		this.promptErrorSource = "prompt";
+	}
+	markAborted() {
+		this.aborted = true;
+	}
+	isCompacting() {
+		return this.activeCompactionItemIds.size > 0;
+	}
+	async handleAssistantDelta(params) {
+		const itemId = readString(params, "itemId") ?? "assistant";
+		const delta = readString(params, "delta") ?? "";
+		if (!delta) return;
+		if (itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		const isCommentary = this.isCommentaryAssistantItem(itemId);
+		if (!isCommentary && itemId !== this.latestTerminalAssistantCandidateItemId) this.markTerminalAssistantCandidateSupersededBy();
+		if (!this.assistantStarted) {
+			this.assistantStarted = true;
+			await this.params.onAssistantMessageStart?.();
+		}
+		this.rememberAssistantItem(itemId);
+		const text = `${this.assistantTextByItem.get(itemId) ?? ""}${delta}`;
+		this.assistantTextByItem.set(itemId, text);
+		if (isCommentary) this.emitCommentaryProgress({
+			itemId,
+			text
+		});
+		else {
+			const knownFinalAnswer = this.shouldStreamAssistantPartial(itemId);
+			const replace = this.streamedPartialAssistantItemId !== void 0 && this.streamedPartialAssistantItemId !== itemId;
+			if (replace && (!knownFinalAnswer || this.streamedPartialAssistantItemReplaceable)) this.streamedPartialAssistantItemReplaceable = true;
+			else if (this.streamedPartialAssistantItemId === void 0) this.streamedPartialAssistantItemReplaceable = !knownFinalAnswer;
+			this.streamedPartialAssistantItemId = itemId;
+			const replaceable = this.streamedPartialAssistantItemReplaceable;
+			const replacement = replace && replaceable;
+			const streamPayload = {
+				text,
+				delta: replacement ? "" : delta,
+				...replacement ? { replace: true } : {}
+			};
+			this.emitAgentEvent({
+				stream: "assistant",
+				data: {
+					...streamPayload,
+					...replaceable ? { replaceable: true } : {}
+				}
+			});
+			if (knownFinalAnswer && !replaceable) await this.params.onPartialReply?.(streamPayload);
+		}
+	}
+	async handleReasoningDelta(method, params) {
+		const itemId = readString(params, "itemId") ?? "reasoning";
+		const delta = readString(params, "delta") ?? "";
+		if (!delta) return;
+		this.reasoningStarted = true;
+		if (!this.reasoningItemOrder.has(itemId)) this.reasoningItemOrder.set(itemId, this.reasoningItemOrder.size);
+		const groupIndex = method === "item/reasoning/textDelta" ? readNonNegativeInteger(params, "contentIndex") ?? 0 : readNonNegativeInteger(params, "summaryIndex") ?? 0;
+		const groupKey = `${method}\0${itemId}\0${groupIndex}`;
+		const current = this.reasoningTextByGroup.get(groupKey);
+		this.reasoningTextByGroup.set(groupKey, {
+			itemId,
+			method,
+			index: groupIndex,
+			text: `${current?.text ?? ""}${delta}`
+		});
+		await this.params.onReasoningStream?.({
+			text: collectReasoningTextValues(this.reasoningTextByGroup, this.reasoningItemOrder).join("\n\n"),
+			isReasoningSnapshot: true
+		});
+	}
+	handlePlanDelta(params) {
+		const itemId = readString(params, "itemId") ?? "plan";
+		const delta = readString(params, "delta") ?? "";
+		if (!delta) return;
+		const text = `${this.planTextByItem.get(itemId) ?? ""}${delta}`;
+		this.planTextByItem.set(itemId, text);
+		this.emitPlanUpdate({
+			explanation: void 0,
+			steps: splitPlanText(text)
+		});
+	}
+	handleTurnPlanUpdated(params) {
+		const plan = Array.isArray(params.plan) ? params.plan.flatMap((entry) => {
+			if (!isJsonObject(entry)) return [];
+			const step = readString(entry, "step");
+			const status = readString(entry, "status");
+			if (!step) return [];
+			return status ? [`${step} (${status})`] : [step];
+		}) : void 0;
+		this.emitPlanUpdate({
+			explanation: readNullableString(params, "explanation"),
+			steps: plan
+		});
+	}
+	async handleItemStarted(params) {
+		const item = readItem(params.item);
+		const itemId = item?.id ?? readString(params, "itemId");
+		if (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		this.rememberAssistantPhase(item);
+		if (itemId) {
+			this.activeItemIds.add(itemId);
+			if (itemId !== this.latestTerminalAssistantCandidateItemId) {
+				this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
+				if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
+			}
+		}
+		this.recordNativeToolOutcome(item);
+		if (item?.type === "contextCompaction" && itemId) {
+			this.activeCompactionItemIds.add(itemId);
+			await runAgentHarnessBeforeCompactionHook({
+				sessionFile: this.params.sessionFile,
+				messages: await this.readMirroredSessionMessages(),
+				ctx: {
+					runId: this.params.runId,
+					agentId: this.params.agentId,
+					sessionKey: this.params.sessionKey,
+					sessionId: this.params.sessionId,
+					workspaceDir: this.params.workspaceDir,
+					messageProvider: this.params.messageProvider ?? void 0,
+					trigger: this.params.trigger,
+					channelId: this.params.messageChannel ?? this.params.messageProvider ?? void 0
+				}
+			});
+			this.emitAgentEvent({
+				stream: "compaction",
+				data: {
+					phase: "start",
+					backend: "codex-app-server",
+					threadId: this.threadId,
+					turnId: this.turnId,
+					itemId
+				}
+			});
+		}
+		this.recordToolMeta(item);
+		this.emitStandardItemEvent({
+			phase: "start",
+			item
+		});
+		await this.emitNormalizedToolItemEvent({
+			phase: "start",
+			item
+		});
+		this.recordNativeToolTranscriptCall(item);
+		this.emitToolResultSummary(item);
+		this.emitAgentEvent({
+			stream: "codex_app_server.item",
+			data: {
+				phase: "started",
+				itemId,
+				type: item?.type
+			}
+		});
+	}
+	async handleItemCompleted(params) {
+		const item = readItem(params.item);
+		this.recordNativeToolOutcome(item);
+		this.clearTerminalPresentationForNativeItem(item);
+		const itemId = item?.id ?? readString(params, "itemId");
+		if (item?.type === "agentMessage" && itemId && itemId !== this.pendingRawTerminalAssistantEchoItemId) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		if (itemId) {
+			this.activeItemIds.delete(itemId);
+			this.completedItemIds.add(itemId);
+			this.latestCompletedItemId = itemId;
+		}
+		this.rememberAssistantPhase(item);
+		if (item?.type === "agentMessage" && !this.isCommentaryAssistantItem(item.id)) {
+			this.latestCompletedTerminalAssistantItemId = item.id;
+			this.markLatestTerminalAssistantCandidate(item.id);
+			this.pendingRawTerminalAssistantEchoItemId = item.id;
+		} else if (itemId) {
+			this.markTerminalAssistantCandidateSupersededBy(itemId, { preserveEarlierActiveItem: true });
+			if (this.latestTerminalAssistantCandidateSuperseded) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		}
+		if (item?.type === "agentMessage" && typeof item.text === "string") {
+			this.rememberAssistantItem(item.id);
+			this.assistantTextByItem.set(item.id, item.text);
+			if (item.text && this.isCommentaryAssistantItem(item.id)) {
+				this.emitCommentaryProgress({
+					itemId: item.id,
+					text: item.text
+				});
+				this.pendingRawCommentaryEchoes += 1;
+			}
+		}
+		this.recordNativeGeneratedMedia(item);
+		if (item?.type === "plan" && typeof item.text === "string" && item.text) {
+			this.planTextByItem.set(item.id, item.text);
+			this.emitPlanUpdate({
+				explanation: void 0,
+				steps: splitPlanText(item.text)
+			});
+		}
+		if (item?.type === "contextCompaction" && itemId) {
+			this.activeCompactionItemIds.delete(itemId);
+			this.completedCompactionCount += 1;
+			await runAgentHarnessAfterCompactionHook({
+				sessionFile: this.params.sessionFile,
+				messages: await this.readMirroredSessionMessages(),
+				compactedCount: -1,
+				ctx: {
+					runId: this.params.runId,
+					agentId: this.params.agentId,
+					sessionKey: this.params.sessionKey,
+					sessionId: this.params.sessionId,
+					workspaceDir: this.params.workspaceDir,
+					messageProvider: this.params.messageProvider ?? void 0,
+					trigger: this.params.trigger,
+					channelId: this.params.messageChannel ?? this.params.messageProvider ?? void 0
+				}
+			});
+			this.emitAgentEvent({
+				stream: "compaction",
+				data: {
+					phase: "end",
+					backend: "codex-app-server",
+					completed: true,
+					threadId: this.threadId,
+					turnId: this.turnId,
+					itemId
+				}
+			});
+		}
+		this.recordToolMeta(item);
+		this.emitStandardItemEvent({
+			phase: "end",
+			item
+		});
+		await this.emitNormalizedToolItemEvent({
+			phase: "result",
+			item
+		});
+		this.recordNativeToolTranscriptCall(item);
+		this.recordNativeToolTranscriptResult(item);
+		this.emitToolResultSummary(item);
+		this.emitToolResultOutput(item);
+		this.emitAgentEvent({
+			stream: "codex_app_server.item",
+			data: {
+				phase: "completed",
+				itemId,
+				type: item?.type
+			}
+		});
+	}
+	handleTokenUsage(params) {
+		const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
+		const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
+		if (!last) return;
+		const usage = normalizeCodexTokenUsage(last);
+		if (usage) this.tokenUsage = usage;
+	}
+	handleGuardianReviewNotification(method, params) {
+		this.guardianReviewCount += 1;
+		const review = isJsonObject(params.review) ? params.review : void 0;
+		const action = isJsonObject(params.action) ? params.action : void 0;
+		this.emitAgentEvent({
+			stream: "codex_app_server.guardian",
+			data: {
+				method,
+				phase: method.endsWith("/started") ? "started" : "completed",
+				reviewId: readString(params, "reviewId"),
+				targetItemId: readNullableString(params, "targetItemId"),
+				decisionSource: readString(params, "decisionSource"),
+				status: review ? readString(review, "status") : void 0,
+				riskLevel: review ? readString(review, "riskLevel") : void 0,
+				userAuthorization: review ? readString(review, "userAuthorization") : void 0,
+				rationale: review ? readNullableString(review, "rationale") : void 0,
+				actionType: action ? readString(action, "type") : void 0
+			}
+		});
+	}
+	handleGuardianWarning(params) {
+		this.emitAgentEvent({
+			stream: "codex_app_server.guardian",
+			data: {
+				phase: "warning",
+				message: readString(params, "message")
+			}
+		});
+	}
+	handleHookNotification(method, params) {
+		const run = isJsonObject(params.run) ? params.run : void 0;
+		if (!run) return;
+		const durationMs = readNumber(run, "durationMs");
+		const entries = readHookOutputEntries(run.entries);
+		const hookTurnId = readNullableString(params, "turnId");
+		this.emitAgentEvent({
+			stream: "codex_app_server.hook",
+			data: {
+				phase: method === "hook/started" ? "started" : "completed",
+				threadId: this.threadId,
+				turnId: hookTurnId === void 0 ? this.turnId : hookTurnId,
+				hookRunId: readString(run, "id"),
+				eventName: readString(run, "eventName"),
+				handlerType: readString(run, "handlerType"),
+				executionMode: readString(run, "executionMode"),
+				scope: readString(run, "scope"),
+				source: readString(run, "source"),
+				sourcePath: readString(run, "sourcePath"),
+				status: readString(run, "status"),
+				statusMessage: readNullableString(run, "statusMessage"),
+				...durationMs !== void 0 ? { durationMs } : {},
+				...entries.length > 0 ? { entries } : {}
+			}
+		});
+	}
+	async handleTurnCompleted(params) {
+		const turn = readCodexTurn(params.turn);
+		if (!turn || turn.id !== this.turnId) return;
+		this.completedTurn = turn;
+		if (turn.status === "failed") {
+			this.promptError = formatCodexUsageLimitErrorMessage({
+				message: turn.error?.message,
+				codexErrorInfo: turn.error?.codexErrorInfo,
+				rateLimits: this.options.readRecentRateLimits?.()
+			}) ?? turn.error?.message ?? "codex app-server turn failed";
+			this.promptErrorSource = "prompt";
+		}
+		const turnItems = turn.items ?? [];
+		for (let index = turnItems.length - 1; index >= 0; index -= 1) {
+			const item = turnItems[index];
+			if (!item || !this.isCurrentTurnSnapshotItem(item)) continue;
+			if (item?.type === "dynamicToolCall") break;
+			if (shouldClearTerminalPresentationForNativeItem(item)) {
+				this.clearTerminalPresentationForNativeItem(item);
+				break;
+			}
+		}
+		for (const item of turnItems) {
+			this.rememberAssistantPhase(item);
+			if (item.type === "agentMessage" && typeof item.text === "string") {
+				this.rememberAssistantItem(item.id);
+				this.assistantTextByItem.set(item.id, item.text);
+			}
+			this.recordNativeGeneratedMedia(item);
+			if (item.type === "plan" && typeof item.text === "string" && item.text) {
+				this.planTextByItem.set(item.id, item.text);
+				this.emitPlanUpdate({
+					explanation: void 0,
+					steps: splitPlanText(item.text)
+				});
+			}
+			this.recordToolMeta(item);
+			await this.emitSnapshotOnlyNativeToolProgress(item);
+			this.recordNativeToolTranscriptCall(item);
+			this.recordNativeToolTranscriptResult(item);
+			this.emitAfterToolCallObservation(item);
+			this.emitToolResultSummary(item);
+			this.emitToolResultOutput(item);
+		}
+		this.activeCompactionItemIds.clear();
+		await this.maybeEndReasoning();
+	}
+	async emitSnapshotOnlyNativeToolProgress(item) {
+		if (!shouldSynthesizeToolProgressForItem(item) || !this.isCurrentTurnSnapshotItem(item) || this.completedItemIds.has(item.id) || itemStatus(item) === "running") return;
+		if (!this.activeItemIds.has(item.id)) {
+			this.emitStandardItemEvent({
+				phase: "start",
+				item
+			});
+			await this.emitNormalizedToolItemEvent({
+				phase: "start",
+				item
+			});
+		}
+		this.activeItemIds.delete(item.id);
+		this.emitStandardItemEvent({
+			phase: "end",
+			item
+		});
+		await this.emitNormalizedToolItemEvent({
+			phase: "result",
+			item
+		});
+		this.completedItemIds.add(item.id);
+	}
+	isCurrentTurnSnapshotItem(item) {
+		const itemTurnId = readItemString(item, "turnId");
+		return itemTurnId === void 0 || itemTurnId === this.turnId;
+	}
+	handleOutputDelta(params, toolName) {
+		const itemId = readString(params, "itemId");
+		const delta = readString(params, "delta");
+		if (!itemId || !delta) return;
+		appendToolOutputDeltaText(this.toolResultOutputTextByItem, itemId, delta);
+		if (!this.shouldEmitToolOutput()) return;
+		if (this.transcriptToolProgressSuppressedIds.has(itemId) || !shouldEmitTranscriptToolProgress(toolName, this.toolTranscriptArgumentsById.get(itemId))) return;
+		const state = this.toolResultOutputDeltaState.get(itemId) ?? {
+			chars: 0,
+			messages: 0,
+			truncated: false
+		};
+		if (state.truncated) return;
+		const remainingChars = Math.max(0, TOOL_PROGRESS_OUTPUT_MAX_CHARS - state.chars);
+		const remainingMessages = Math.max(0, MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM - state.messages);
+		if (remainingChars === 0 || remainingMessages === 0) {
+			state.truncated = true;
+			this.toolResultOutputDeltaState.set(itemId, state);
+			this.emitToolResultMessage({
+				itemId,
+				text: formatToolOutput(toolName, void 0, "(output truncated)")
+			});
+			return;
+		}
+		const chunk = delta.length > remainingChars ? delta.slice(0, remainingChars) : delta;
+		state.chars += chunk.length;
+		state.messages += 1;
+		const reachedLimit = delta.length > remainingChars || state.chars >= TOOL_PROGRESS_OUTPUT_MAX_CHARS || state.messages >= MAX_TOOL_OUTPUT_DELTA_MESSAGES_PER_ITEM;
+		if (reachedLimit) state.truncated = true;
+		this.toolResultOutputDeltaState.set(itemId, state);
+		this.toolResultOutputStreamedItemIds.add(itemId);
+		this.emitToolResultMessage({
+			itemId,
+			text: formatToolOutput(toolName, void 0, reachedLimit ? `${chunk}\n...(truncated)...` : chunk)
+		});
+	}
+	async handleRawResponseItemCompleted(params) {
+		const item = isJsonObject(params.item) ? params.item : void 0;
+		if (!item) return;
+		const role = readString(item, "role");
+		const phase = readString(item, "phase");
+		const rawItemId = readString(item, "id");
+		const candidateWasSupersededBeforeRaw = this.latestTerminalAssistantCandidateSuperseded;
+		const pendingTerminalAssistantEchoItemId = this.pendingRawTerminalAssistantEchoItemId;
+		const isPendingTerminalAssistantEcho = role === "assistant" && phase !== "commentary" && pendingTerminalAssistantEchoItemId !== void 0 && (rawItemId === void 0 || rawItemId === pendingTerminalAssistantEchoItemId);
+		if (pendingTerminalAssistantEchoItemId !== void 0 && !isPendingTerminalAssistantEcho) this.pendingRawTerminalAssistantEchoItemId = void 0;
+		if (!isPendingTerminalAssistantEcho) {
+			this.latestCompletedItemId = void 0;
+			this.markTerminalAssistantCandidateSupersededBy(rawItemId);
+		}
+		await this.recordRawGeneratedImageMedia(item);
+		if (role !== "assistant") return;
+		if (phase === "commentary" && this.pendingRawCommentaryEchoes > 0) {
+			this.pendingRawCommentaryEchoes -= 1;
+			return;
+		}
+		const text = extractRawAssistantText(item);
+		if (isPendingTerminalAssistantEcho) {
+			const typedItemId = pendingTerminalAssistantEchoItemId;
+			this.pendingRawTerminalAssistantEchoItemId = void 0;
+			if (this.assistantTextByItem.get(typedItemId)?.trim() || !text) return;
+			this.rememberAssistantItem(typedItemId);
+			this.assistantTextByItem.set(typedItemId, text);
+			return;
+		}
+		if (!text) return;
+		const itemId = rawItemId ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
+		const isIdlessTerminalAssistantAfterCompletedWork = candidateWasSupersededBeforeRaw && rawItemId === void 0 && pendingTerminalAssistantEchoItemId === void 0 && this.activeItemIds.size === 0;
+		if (phase !== "commentary" && candidateWasSupersededBeforeRaw && itemId !== this.streamedPartialAssistantItemId && !isIdlessTerminalAssistantAfterCompletedWork) return;
+		if (phase) this.assistantPhaseByItem.set(itemId, phase);
+		this.rememberAssistantItem(itemId);
+		this.assistantTextByItem.set(itemId, text);
+		if (phase === "commentary") this.emitCommentaryProgress({
+			itemId,
+			text
+		});
+		else this.markLatestTerminalAssistantCandidate(itemId, { canReleaseAfterToolHandoff: isIdlessTerminalAssistantAfterCompletedWork });
+	}
+	markLatestTerminalAssistantCandidate(itemId, options) {
+		this.latestTerminalAssistantCandidateItemId = itemId;
+		this.latestTerminalAssistantCandidateSuperseded = false;
+		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = options?.canReleaseAfterToolHandoff === true;
+		this.terminalAssistantCandidateEarlierActiveItemIds = new Set(this.activeItemIds);
+	}
+	markTerminalAssistantCandidateSupersededBy(itemId, options) {
+		if (!this.latestTerminalAssistantCandidateItemId) return;
+		if (itemId && this.terminalAssistantCandidateEarlierActiveItemIds.has(itemId)) {
+			if (!options?.preserveEarlierActiveItem) this.terminalAssistantCandidateEarlierActiveItemIds.delete(itemId);
+			return;
+		}
+		this.latestTerminalAssistantCandidateSuperseded = true;
+		this.latestTerminalAssistantCandidateCanReleaseAfterToolHandoff = false;
+		this.terminalAssistantCandidateEarlierActiveItemIds.clear();
+	}
+	recordNativeGeneratedMedia(item) {
+		if (item?.type !== "imageGeneration") return;
+		const savedPath = readItemString(item, "savedPath")?.trim();
+		if (savedPath) this.recordNativeGeneratedMediaUrl({
+			itemId: item.id,
+			mediaUrl: savedPath
+		});
+	}
+	async recordRawGeneratedImageMedia(item) {
+		if (readString(item, "type") !== "image_generation_call") return;
+		const result = readString(item, "result");
+		if (!result) return;
+		const itemId = readString(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(item, "revised_prompt") ?? readString(item, "revisedPrompt"),
+			fileNamePrefix: "codex-image-generation",
+			sniffMimeType: true
+		});
+		if (!asset) return;
+		try {
+			const saved = await saveMediaBuffer(asset.buffer, asset.mimeType, GENERATED_IMAGE_MEDIA_SUBDIR, maxBytes, asset.fileName);
+			this.recordNativeGeneratedMediaUrl({
+				itemId,
+				mediaUrl: saved.path,
+				replaceExisting: true
+			});
+		} catch (error) {
+			embeddedAgentLog.warn("codex app-server raw image generation result save failed", {
+				itemId,
+				error
+			});
+		}
+	}
+	recordNativeGeneratedMediaUrl(params) {
+		if (this.nativeGeneratedMediaUrlsByItemId.has(params.itemId) && params.replaceExisting !== true) {
+			this.nativeGeneratedMediaItemIds.add(params.itemId);
+			return;
+		}
+		this.nativeGeneratedMediaUrlsByItemId.set(params.itemId, params.mediaUrl);
+		this.nativeGeneratedMediaItemIds.add(params.itemId);
+	}
+	buildToolMediaUrls(toolTelemetry) {
+		const mediaUrls = new Set(toolTelemetry.toolMediaUrls?.map((url) => url.trim()).filter(Boolean) ?? []);
+		if ((toolTelemetry.messagingToolSentMediaUrls?.length ?? 0) === 0) for (const mediaUrl of this.nativeGeneratedMediaUrlsByItemId.values()) mediaUrls.add(mediaUrl);
+		return mediaUrls.size > 0 ? [...mediaUrls] : toolTelemetry.toolMediaUrls;
+	}
+	async maybeEndReasoning() {
+		if (!this.reasoningStarted || this.reasoningEnded) return;
+		this.reasoningEnded = true;
+		await this.params.onReasoningEnd?.();
+	}
+	emitPlanUpdate(params) {
+		if (!params.explanation && (!params.steps || params.steps.length === 0)) return;
+		this.emitAgentEvent({
+			stream: "plan",
+			data: {
+				phase: "update",
+				title: "Plan updated",
+				source: "codex-app-server",
+				...params.explanation ? { explanation: params.explanation } : {},
+				...params.steps && params.steps.length > 0 ? { steps: params.steps } : {}
+			}
+		});
+	}
+	rememberAssistantPhase(item) {
+		if (item?.type !== "agentMessage") return;
+		const phase = readItemString(item, "phase");
+		if (phase) this.assistantPhaseByItem.set(item.id, phase);
+	}
+	isCommentaryAssistantItem(itemId) {
+		return this.assistantPhaseByItem.get(itemId) === "commentary";
+	}
+	shouldStreamAssistantPartial(itemId) {
+		return this.assistantPhaseByItem.get(itemId) === "final_answer";
+	}
+	emitCommentaryProgress(params) {
+		const progressText = params.text.replace(/\s+/g, " ").trim();
+		if (!progressText || this.lastCommentaryProgressTextByItem.get(params.itemId) === progressText) return;
+		this.lastCommentaryProgressTextByItem.set(params.itemId, progressText);
+		this.emitAgentEvent({
+			stream: "item",
+			data: {
+				itemId: params.itemId,
+				kind: "preamble",
+				title: "Preamble",
+				phase: "update",
+				progressText,
+				source: "codex-app-server"
+			}
+		});
+	}
+	emitStandardItemEvent(params) {
+		const { item } = params;
+		if (!item) return;
+		const kind = itemKind(item);
+		if (!kind) return;
+		const meta = itemMeta(item, this.toolProgressDetailMode());
+		const suppressChannelProgress = shouldSuppressChannelProgressForItem(item);
+		this.emitAgentEvent({
+			stream: "item",
+			data: {
+				itemId: item.id,
+				phase: params.phase,
+				kind,
+				title: itemTitle(item),
+				status: params.phase === "start" ? "running" : itemStatus(item),
+				...itemName(item) ? { name: itemName(item) } : {},
+				...meta ? { meta } : {},
+				...suppressChannelProgress ? { suppressChannelProgress: true } : {}
+			}
+		});
+	}
+	async emitNormalizedToolItemEvent(params) {
+		const { item } = params;
+		if (!item || !shouldSynthesizeToolProgressForItem(item)) return;
+		const name = itemName(item);
+		if (!name) return;
+		const status = params.phase === "result" ? itemStatus(item) : "running";
+		const args = itemToolArgs(item);
+		const meta = itemMeta(item, this.toolProgressDetailMode());
+		this.recordToolTrajectoryEvent({
+			phase: params.phase,
+			item,
+			name,
+			args,
+			status
+		});
+		if (params.phase === "result") this.recordNativeToolError({
+			item,
+			name,
+			meta,
+			status
+		});
+		if (!shouldEmitTranscriptToolProgress(name, args)) {
+			if (params.phase === "result") {
+				this.emitAfterToolCallObservation(item);
+				await this.options.onNativeToolResultRecorded?.();
+			}
+			return;
+		}
+		this.emitAgentEvent({
+			stream: "tool",
+			data: {
+				phase: params.phase,
+				name,
+				itemId: item.id,
+				toolCallId: item.id,
+				...meta ? { meta } : {},
+				...params.phase === "start" && args ? { args } : {},
+				...params.phase === "result" ? {
+					status,
+					isError: isNonSuccessItemStatus(status),
+					...itemToolResult(item)
+				} : {}
+			}
+		});
+		if (params.phase === "result") {
+			this.emitAfterToolCallObservation(item);
+			await this.options.onNativeToolResultRecorded?.();
+		}
+	}
+	clearTerminalPresentationForNativeItem(item) {
+		if (!item || this.terminalPresentationClearedItemIds.has(item.id) || !shouldClearTerminalPresentationForNativeItem(item)) return;
+		const toolCallOrdinal = this.nativeToolOutcomeOrdinals.get(item.id);
+		this.terminalPresentationClearedItemIds.add(item.id);
+		this.params.onToolOutcome?.({
+			toolName: itemName(item) ?? item.type,
+			argsHash: "",
+			resultHash: "",
+			...toolCallOrdinal !== void 0 ? { toolCallOrdinal } : {},
+			terminalPresentation: void 0,
+			presentationOnly: true
+		});
+	}
+	recordNativeToolError(params) {
+		if (!isNonSuccessItemStatus(params.status)) {
+			if (!this.lastNativeToolError) return;
+			if (!this.lastNativeToolError.mutatingAction) {
+				this.lastNativeToolError = void 0;
+				return;
+			}
+			const actionFingerprint = nativeToolActionFingerprint(params.item);
+			if (this.lastNativeToolError.actionFingerprint && actionFingerprint && this.lastNativeToolError.actionFingerprint === actionFingerprint) this.lastNativeToolError = void 0;
+			return;
+		}
+		const error = itemToolError(params.item, params.status, this.toolResultOutputTextByItem);
+		const actionFingerprint = nativeToolActionFingerprint(params.item);
+		this.lastNativeToolError = {
+			toolName: params.name,
+			...params.meta ? { meta: params.meta } : {},
+			...error ? { error } : {},
+			...isMutatingNativeToolItem(params.item) ? { mutatingAction: true } : {},
+			...actionFingerprint ? { actionFingerprint } : {}
+		};
+	}
+	recordToolTrajectoryEvent(params) {
+		if (params.phase === "start") {
+			this.toolTrajectoryCallIds.add(params.item.id);
+			this.toolTrajectoryNamesById.set(params.item.id, params.name);
+			this.toolTrajectoryItemsById.set(params.item.id, params.item);
+			this.options.trajectoryRecorder?.recordEvent("tool.call", {
+				threadId: this.threadId,
+				turnId: this.turnId,
+				itemId: params.item.id,
+				toolCallId: params.item.id,
+				name: params.name,
+				arguments: params.args
+			});
+			return;
+		}
+		this.toolTrajectoryResultIds.add(params.item.id);
+		const toolResult = itemToolResult(params.item).result;
+		const output = itemOutputText(params.item, this.toolResultOutputTextByItem);
+		this.options.trajectoryRecorder?.recordEvent("tool.result", {
+			threadId: this.threadId,
+			turnId: this.turnId,
+			itemId: params.item.id,
+			toolCallId: params.item.id,
+			name: params.name,
+			status: params.status,
+			isError: isNonSuccessItemStatus(params.status),
+			...toolResult ? { result: toolResult } : {},
+			...output ? { output } : {}
+		});
+	}
+	emitAfterToolCallObservation(item) {
+		if (!this.shouldEmitAfterToolCallObservation(item)) return;
+		const name = itemName(item);
+		if (!name) return;
+		const status = itemStatus(item);
+		if (status === "running") return;
+		this.afterToolCallObservedItemIds.add(item.id);
+		const result = itemToolResult(item).result;
+		const error = itemToolError(item, status, this.toolResultOutputTextByItem);
+		const startedAt = resolveStartedAtFromDurationMs(item.durationMs);
+		const hookParams = {
+			toolName: name,
+			toolCallId: item.id,
+			runId: this.params.runId,
+			agentId: this.params.agentId,
+			sessionId: this.params.sessionId,
+			sessionKey: this.params.sessionKey,
+			startArgs: itemToolArgs(item) ?? {},
+			...result !== void 0 ? { result } : {},
+			...error ? { error } : {},
+			...startedAt !== void 0 ? { startedAt } : {}
+		};
+		setImmediate(() => {
+			runAgentHarnessAfterToolCallHook(hookParams);
+		});
+	}
+	shouldEmitAfterToolCallObservation(item) {
+		if (!shouldSynthesizeToolProgressForItem(item) || this.afterToolCallObservedItemIds.has(item.id)) return false;
+		if (this.options.nativePostToolUseRelayEnabled && isNativePostToolUseRelayItem(item)) return false;
+		return true;
+	}
+	emitToolResultSummary(item) {
+		if (!item || !this.params.onToolResult || !this.shouldEmitToolResult()) return;
+		const itemId = item.id;
+		if (this.toolResultSummaryItemIds.has(itemId)) return;
+		const toolName = itemName(item);
+		if (!toolName) return;
+		if (!shouldEmitTranscriptToolProgress(toolName, itemToolArgs(item))) return;
+		this.toolResultSummaryItemIds.add(itemId);
+		const meta = itemMeta(item, this.toolProgressDetailMode());
+		this.emitToolResultMessage({
+			itemId,
+			text: formatToolSummary(toolName, meta)
+		});
+	}
+	emitToolResultOutput(item) {
+		if (!item || !this.params.onToolResult || !this.shouldEmitToolOutput()) return;
+		const itemId = item.id;
+		if (this.toolResultOutputItemIds.has(itemId)) return;
+		if (this.toolResultOutputStreamedItemIds.has(itemId)) return;
+		const toolName = itemName(item);
+		const output = itemOutputText(item, this.toolResultOutputTextByItem);
+		if (!toolName || !output) return;
+		if (!shouldEmitTranscriptToolProgress(toolName, itemToolArgs(item))) return;
+		this.emitToolResultMessage({
+			itemId,
+			text: formatToolOutput(toolName, itemMeta(item, this.toolProgressDetailMode()), output),
+			finalOutput: true,
+			isError: isNonSuccessItemStatus(itemStatus(item))
+		});
+	}
+	emitToolResultMessage(params) {
+		const text = params.text.trim();
+		if (!text) return;
+		this.toolProgressTexts.add(text);
+		if (params.finalOutput) this.toolResultOutputItemIds.add(params.itemId);
+		try {
+			Promise.resolve(this.params.onToolResult?.({
+				text,
+				...params.isError === true ? { isError: true } : {}
+			})).catch(() => {});
+		} catch {}
+	}
+	shouldEmitToolResult() {
+		return typeof this.params.shouldEmitToolResult === "function" ? this.params.shouldEmitToolResult() : this.params.verboseLevel === "on" || this.params.verboseLevel === "full";
+	}
+	shouldEmitToolOutput() {
+		return typeof this.params.shouldEmitToolOutput === "function" ? this.params.shouldEmitToolOutput() : this.params.verboseLevel === "full";
+	}
+	toolProgressDetailMode() {
+		return resolveCodexToolProgressDetailMode(this.params.toolProgressDetail);
+	}
+	recordToolMeta(item) {
+		if (!item) return;
+		if (isSideEffectingNativeToolItem(item)) this.sideEffectingToolItemIds.add(item.id);
+		else this.sideEffectingToolItemIds.delete(item.id);
+		const toolName = itemName(item);
+		if (!toolName) return;
+		const meta = itemMeta(item, this.toolProgressDetailMode());
+		const existing = this.toolMetas.get(item.id);
+		this.toolMetas.set(item.id, {
+			toolName,
+			...meta ? { meta } : {},
+			...existing?.asyncStarted ? { asyncStarted: true } : {}
+		});
+	}
+	recordNativeToolTranscriptCall(item) {
+		if (!item || !shouldRecordNativeToolTranscript(item)) return;
+		const name = itemName(item);
+		if (!name) return;
+		this.recordToolTranscriptCall({
+			id: item.id,
+			name,
+			arguments: itemToolArgs(item)
+		});
+	}
+	recordNativeToolTranscriptResult(item) {
+		if (!item || !shouldRecordNativeToolTranscript(item)) return;
+		const name = itemName(item);
+		if (!name) return;
+		this.recordToolTranscriptResult({
+			id: item.id,
+			name,
+			text: itemTranscriptResultText(item, this.toolResultOutputTextByItem),
+			isError: isNonSuccessItemStatus(itemStatus(item))
+		});
+	}
+	recordToolTranscriptCall(params) {
+		if (!params.id || !params.name || this.toolTranscriptCallIds.has(params.id)) return;
+		this.toolTranscriptCallIds.add(params.id);
+		this.toolTranscriptNamesById.set(params.id, params.name);
+		this.toolTranscriptArgumentsById.set(params.id, params.arguments);
+		if (!shouldEmitTranscriptToolProgress(params.name, params.arguments)) this.transcriptToolProgressSuppressedIds.add(params.id);
+		else this.transcriptToolProgressSuppressedIds.delete(params.id);
+		this.emitTranscriptToolCallProgress(params);
+		this.toolTranscriptMessages.push(attachCodexMirrorIdentity(this.createToolCallMessage(params), `${this.turnId}:tool:${params.id}:call`));
+	}
+	recordToolTranscriptResult(params) {
+		if (!params.id || !params.name || this.toolTranscriptResultIds.has(params.id)) return;
+		this.toolTranscriptResultIds.add(params.id);
+		this.emitTranscriptToolResultProgress(params);
+		this.toolTranscriptMessages.push(attachCodexMirrorIdentity(this.createToolResultMessage(params), `${this.turnId}:tool:${params.id}:result`));
+	}
+	synthesizeMissingToolResults(params) {
+		if (!params.synthesize) return;
+		const missingTranscriptIds = [...this.toolTranscriptCallIds].filter((id) => !this.toolTranscriptResultIds.has(id));
+		const missingTrajectoryIds = [...this.toolTrajectoryCallIds].filter((id) => !this.toolTrajectoryResultIds.has(id));
+		if (missingTranscriptIds.length === 0 && missingTrajectoryIds.length === 0) return;
+		for (const id of missingTranscriptIds) {
+			const name = this.toolTranscriptNamesById.get(id) ?? this.toolTrajectoryNamesById.get(id);
+			if (!name) continue;
+			this.recordToolTranscriptResult({
+				id,
+				name,
+				text: formatMissingToolResultError({
+					id,
+					name
+				}),
+				isError: true
+			});
+		}
+		for (const id of missingTrajectoryIds) {
+			const name = this.toolTrajectoryNamesById.get(id) ?? this.toolTranscriptNamesById.get(id);
+			if (!name) continue;
+			this.toolTrajectoryResultIds.add(id);
+			const text = formatMissingToolResultError({
+				id,
+				name
+			});
+			this.options.trajectoryRecorder?.recordEvent("tool.result", {
+				threadId: this.threadId,
+				turnId: this.turnId,
+				itemId: id,
+				toolCallId: id,
+				name,
+				status: "failed",
+				isError: true,
+				result: {
+					status: "failed",
+					reason: "missing_tool_result"
+				},
+				output: text
+			});
+		}
+		if (!params.recordPromptError) {
+			const firstMissingId = missingTranscriptIds.find((id) => {
+				const name = this.toolTranscriptNamesById.get(id) ?? this.toolTrajectoryNamesById.get(id);
+				return Boolean(name);
+			}) ?? missingTrajectoryIds.find((id) => {
+				const name = this.toolTrajectoryNamesById.get(id) ?? this.toolTranscriptNamesById.get(id);
+				return Boolean(name);
+			});
+			if (firstMissingId) {
+				const name = this.toolTranscriptNamesById.get(firstMissingId) ?? this.toolTrajectoryNamesById.get(firstMissingId);
+				if (name) {
+					const item = this.toolTrajectoryItemsById.get(firstMissingId);
+					const meta = item ? itemMeta(item, this.toolProgressDetailMode()) : this.toolMetas.get(firstMissingId)?.meta;
+					const actionFingerprint = item ? nativeToolActionFingerprint(item) : void 0;
+					this.lastNativeToolError = {
+						toolName: name,
+						...meta ? { meta } : {},
+						error: formatMissingToolResultError({
+							id: firstMissingId,
+							name
+						}),
+						...item && isMutatingNativeToolItem(item) ? { mutatingAction: true } : {},
+						...actionFingerprint ? { actionFingerprint } : {}
+					};
+				}
+			}
+			return;
+		}
+		const missingCount = (/* @__PURE__ */ new Set([...missingTranscriptIds, ...missingTrajectoryIds])).size;
+		this.synthesizedMissingToolResultError = missingCount === 1 ? MISSING_TOOL_RESULT_ERROR : `${MISSING_TOOL_RESULT_ERROR} missingToolResultCount=${missingCount}`;
+		this.promptErrorSource = this.promptErrorSource ?? "prompt";
+	}
+	emitTranscriptToolCallProgress(params) {
+		if (!shouldEmitTranscriptToolProgress(params.name, params.arguments)) return;
+		this.transcriptToolProgressCallIds.add(params.id);
+		const args = normalizeToolTranscriptArguments(params.arguments);
+		const meta = inferToolMetaFromArgs(params.name, args, { detailMode: this.toolProgressDetailMode() });
+		if (!this.params.onToolResult || !this.shouldEmitToolResult() || this.toolResultSummaryItemIds.has(params.id) || this.toolResultOutputStreamedItemIds.has(params.id)) return;
+		this.toolResultSummaryItemIds.add(params.id);
+		this.emitToolResultMessage({
+			itemId: params.id,
+			text: formatToolSummary(params.name, meta)
+		});
+	}
+	emitTranscriptToolResultProgress(params) {
+		if (this.transcriptToolProgressSuppressedIds.has(params.id) || !shouldEmitTranscriptToolProgress(params.name, this.toolTranscriptArgumentsById.get(params.id))) return;
+		if (!this.transcriptToolProgressCallIds.has(params.id)) this.emitTranscriptToolCallProgress({
+			id: params.id,
+			name: params.name,
+			arguments: {}
+		});
+		if (!this.params.onToolResult || !this.shouldEmitToolOutput() || this.toolResultOutputItemIds.has(params.id) || this.toolResultOutputStreamedItemIds.has(params.id)) return;
+		const text = params.text?.trim();
+		if (!text) return;
+		this.emitToolResultMessage({
+			itemId: params.id,
+			text: formatToolOutput(params.name, void 0, text),
+			finalOutput: true,
+			isError: params.isError
+		});
+	}
+	formatCodexErrorMessage(params) {
+		const error = isJsonObject(params.error) ? params.error : void 0;
+		return formatCodexUsageLimitErrorMessage({
+			message: error ? readString(error, "message") : void 0,
+			codexErrorInfo: error?.codexErrorInfo,
+			rateLimits: this.options.readRecentRateLimits?.()
+		}) ?? readCodexErrorNotificationMessage(params);
+	}
+	emitAgentEvent(event) {
+		try {
+			emitAgentEvent({
+				runId: this.params.runId,
+				stream: event.stream,
+				data: event.data,
+				...this.params.sessionKey ? { sessionKey: this.params.sessionKey } : {}
+			});
+		} catch (error) {
+			embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
+		}
+		try {
+			const maybePromise = this.params.onAgentEvent?.(event);
+			Promise.resolve(maybePromise).catch((error) => {
+				embeddedAgentLog.debug("codex app-server agent event handler rejected", { error });
+			});
+		} catch (error) {
+			embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
+		}
+	}
+	collectAssistantTexts() {
+		const finalText = this.resolveFinalAssistantText();
+		return finalText ? [finalText] : [];
+	}
+	hasAssistantItemTextForSynthesis() {
+		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
+			const itemId = this.assistantItemOrder[i];
+			if (!itemId) continue;
+			if (this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			const text = this.assistantTextByItem.get(itemId);
+			if (text && text.length > 0) return true;
+		}
+		return false;
+	}
+	resolveFinalAssistantText() {
+		return this.resolveFinalAssistantTextItem()?.text;
+	}
+	resolveFinalAssistantTextItem() {
+		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
+			const itemId = this.assistantItemOrder[i];
+			if (!itemId) continue;
+			const text = this.assistantTextByItem.get(itemId)?.trim();
+			if (this.assistantPhaseByItem.get(itemId) === "commentary") continue;
+			if (text && !this.toolProgressTexts.has(text)) return {
+				itemId,
+				text
+			};
+		}
+	}
+	rememberAssistantItem(itemId) {
+		if (!itemId || this.assistantItemOrder.includes(itemId)) return;
+		this.assistantItemOrder.push(itemId);
+	}
+	createCurrentAttemptAssistantMessage() {
+		for (let i = this.assistantItemOrder.length - 1; i >= 0; i -= 1) {
+			const itemId = this.assistantItemOrder[i];
+			if (!itemId || this.isCommentaryAssistantItem(itemId) || !this.assistantTextByItem.has(itemId)) continue;
+			const text = this.assistantTextByItem.get(itemId) ?? "";
+			const normalizedText = text.trim();
+			if (normalizedText && this.toolProgressTexts.has(normalizedText)) continue;
+			return this.createAssistantMessage(text);
+		}
+	}
+	async readMirroredSessionMessages() {
+		return await readCodexMirroredSessionHistoryMessages({
+			agentId: this.params.agentId,
+			sessionFile: this.params.sessionFile,
+			sessionId: this.params.sessionId,
+			sessionKey: this.params.sessionKey
+		}) ?? [];
+	}
+	createAssistantMessage(text) {
+		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
+		const usage = this.tokenUsage ? {
+			input: this.tokenUsage.input ?? 0,
+			output: this.tokenUsage.output ?? 0,
+			cacheRead: this.tokenUsage.cacheRead ?? 0,
+			cacheWrite: this.tokenUsage.cacheWrite ?? 0,
+			totalTokens: this.tokenUsage.total ?? (this.tokenUsage.input ?? 0) + (this.tokenUsage.output ?? 0) + (this.tokenUsage.cacheRead ?? 0) + (this.tokenUsage.cacheWrite ?? 0),
+			cost: ZERO_USAGE.cost
+		} : ZERO_USAGE;
+		return {
+			role: "assistant",
+			content: [{
+				type: "text",
+				text
+			}],
+			api: attribution.api ?? "openai-chatgpt-responses",
+			provider: attribution.provider,
+			model: this.params.modelId,
+			usage,
+			stopReason: this.aborted ? "aborted" : this.promptError ? "error" : "stop",
+			errorMessage: this.promptError ? formatErrorMessage(this.promptError) : void 0,
+			timestamp: Date.now()
+		};
+	}
+	createAssistantMirrorMessage(title, text) {
+		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
+		return {
+			role: "assistant",
+			content: [{
+				type: "text",
+				text: `${title}:\n${text}`
+			}],
+			api: attribution.api ?? "openai-chatgpt-responses",
+			provider: attribution.provider,
+			model: this.params.modelId,
+			usage: ZERO_USAGE,
+			stopReason: "stop",
+			timestamp: Date.now()
+		};
+	}
+	createToolCallMessage(params) {
+		const args = normalizeToolTranscriptArguments(params.arguments);
+		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
+		return {
+			role: "assistant",
+			content: [{
+				type: "toolCall",
+				id: params.id,
+				name: params.name,
+				arguments: args,
+				input: args
+			}],
+			api: attribution.api ?? "openai-chatgpt-responses",
+			provider: attribution.provider,
+			model: this.params.modelId,
+			usage: ZERO_USAGE,
+			stopReason: "toolUse",
+			timestamp: Date.now()
+		};
+	}
+	createToolResultMessage(params) {
+		const text = truncateToolTranscriptText(params.text?.trim() || toolResultStatusText(params));
+		return {
+			role: "toolResult",
+			toolCallId: params.id,
+			toolName: params.name,
+			isError: params.isError,
+			content: [{
+				type: "toolResult",
+				id: params.id,
+				name: params.name,
+				toolName: params.name,
+				toolCallId: params.id,
+				toolUseId: params.id,
+				tool_use_id: params.id,
+				content: text,
+				text
+			}],
+			timestamp: Date.now()
+		};
+	}
+	isNotificationForTurn(params) {
+		const threadId = readCodexNotificationThreadId(params);
+		const turnId = readCodexNotificationTurnId(params);
+		return threadId === this.threadId && turnId === this.turnId;
+	}
+	isHookNotificationForCurrentThread(params) {
+		const threadId = readString(params, "threadId");
+		const turnId = params.turnId;
+		return threadId === this.threadId && (turnId === this.turnId || turnId === null);
+	}
+};
+function isHookNotificationMethod(method) {
+	return method === "hook/started" || method === "hook/completed";
+}
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+}
+function estimateBase64DecodedBytes(base64) {
+	let nonWhitespaceLength = 0;
+	let previousCode = -1;
+	let lastCode = -1;
+	for (let i = 0; i < base64.length; i += 1) {
+		const code = base64.charCodeAt(i);
+		if (isBase64WhitespaceCode(code)) continue;
+		nonWhitespaceLength += 1;
+		previousCode = lastCode;
+		lastCode = code;
+	}
+	if (nonWhitespaceLength === 0) return;
+	const equalsCode = "=".charCodeAt(0);
+	const padding = lastCode === equalsCode ? previousCode === equalsCode ? 2 : 1 : 0;
+	return Math.max(0, Math.floor(nonWhitespaceLength * 3 / 4) - padding);
+}
+function isBase64WhitespaceCode(code) {
+	return code === 32 || code === 9 || code === 10 || code === 13;
+}
+function resolveGeneratedImageMaxBytes(config) {
+	const configured = config?.agents?.defaults?.mediaMaxMb;
+	if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) return Math.floor(configured * BYTES_PER_MB);
+	return DEFAULT_GENERATED_IMAGE_MAX_BYTES;
+}
+function normalizeNonEmptyString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readNonEmptyString(record, key) {
+	return normalizeNonEmptyString(record[key]);
+}
+function readNonEmptyStringArray(record, key) {
+	const value = record[key];
+	if (!Array.isArray(value)) return [];
+	const entries = [];
+	for (const entry of value) {
+		const normalized = normalizeNonEmptyString(entry);
+		if (normalized) entries.push(normalized);
+	}
+	return entries;
+}
+function readNullableString(record, key) {
+	const value = record[key];
+	if (value === null) return null;
+	return typeof value === "string" ? value : void 0;
+}
+function readNumber(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(record, key);
+	return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function readCodexErrorNotificationMessage(record) {
+	const error = record.error;
+	return isJsonObject(error) ? readString(error, "message") : void 0;
+}
+function readHookOutputEntries(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry) => {
+		if (!isJsonObject(entry)) return [];
+		const text = readString(entry, "text");
+		if (!text) return [];
+		const kind = readString(entry, "kind");
+		return [{
+			...kind ? { kind } : {},
+			text
+		}];
+	});
+}
+function normalizeCodexTokenUsage(record) {
+	const inputTokens = readNumber(record, "inputTokens");
+	const cacheRead = readNumber(record, "cachedInputTokens");
+	return normalizeUsage({
+		input: inputTokens !== void 0 && cacheRead !== void 0 ? Math.max(0, inputTokens - cacheRead) : inputTokens,
+		output: readNumber(record, "outputTokens"),
+		cacheRead,
+		total: readNumber(record, "totalTokens")
+	});
+}
+function splitPlanText(text) {
+	return text.split(/\r?\n/).map((line) => line.trim().replace(/^[-*]\s+/, "")).filter((line) => line.length > 0);
+}
+function collectTextValues(map) {
+	return [...map.values()].filter((text) => text.trim().length > 0);
+}
+function collectReasoningTextValues(groups, itemOrder) {
+	return [...groups.values()].toSorted((left, right) => {
+		const itemDelta = (itemOrder.get(left.itemId) ?? Number.MAX_SAFE_INTEGER) - (itemOrder.get(right.itemId) ?? Number.MAX_SAFE_INTEGER);
+		if (itemDelta !== 0) return itemDelta;
+		const methodDelta = reasoningMethodOrder(left.method) - reasoningMethodOrder(right.method);
+		return methodDelta !== 0 ? methodDelta : left.index - right.index;
+	}).map((group) => group.text).filter((text) => text.trim().length > 0);
+}
+function reasoningMethodOrder(method) {
+	return method === "item/reasoning/summaryTextDelta" ? 0 : 1;
+}
+function extractRawAssistantText(item) {
+	return (Array.isArray(item.content) ? item.content : []).flatMap((entry) => {
+		if (!isJsonObject(entry)) return [];
+		const type = readString(entry, "type");
+		if (type !== "output_text" && type !== "text") return [];
+		const value = readString(entry, "text");
+		return value ? [value] : [];
+	}).join("").trim() || void 0;
+}
+function itemKind(item) {
+	switch (item.type) {
+		case "dynamicToolCall":
+		case "mcpToolCall": return "tool";
+		case "commandExecution": return "command";
+		case "fileChange": return "patch";
+		case "webSearch": return "search";
+		case "reasoning":
+		case "contextCompaction": return "analysis";
+		default: return;
+	}
+}
+function itemTitle(item) {
+	switch (item.type) {
+		case "commandExecution": return "Command";
+		case "fileChange": return "File change";
+		case "mcpToolCall": return "MCP tool";
+		case "dynamicToolCall": return "Tool";
+		case "webSearch": return "Web search";
+		case "contextCompaction": return "Context compaction";
+		case "reasoning": return "Reasoning";
+		default: return item.type;
+	}
+}
+function itemStatus(item) {
+	const status = readItemString(item, "status");
+	if (status === "failed" || status === "error") return "failed";
+	if (status === "declined") return "blocked";
+	if (status === "inProgress" || status === "in_progress" || status === "running") return "running";
+	return "completed";
+}
+function auditNativeToolTerminalStatus(item) {
+	if (item.type === "imageView" || item.type === "sleep") return "completed";
+	const status = readItemString(item, "status");
+	if (status === "completed") return "completed";
+	if (status === "failed" || status === "error") return "failed";
+	if (status === "declined") return "blocked";
+	return "unknown";
+}
+function auditNativeToolUnfinishedStatus(item) {
+	return item.type === "webSearch" || item.type === "imageGeneration" ? "unknown" : "failed";
+}
+function formatMissingToolResultError(params) {
+	return `${MISSING_TOOL_RESULT_ERROR} toolCallId=${params.id}; toolName=${params.name}`;
+}
+function isNonSuccessItemStatus(status) {
+	return status === "failed" || status === "blocked";
+}
+function itemName(item) {
+	if (item.type === "dynamicToolCall" && typeof item.tool === "string") return item.tool;
+	if (item.type === "mcpToolCall" && typeof item.tool === "string") {
+		const server = typeof item.server === "string" ? item.server : void 0;
+		return server ? `${server}.${item.tool}` : item.tool;
+	}
+	if (item.type === "commandExecution") return "bash";
+	if (item.type === "fileChange") return "apply_patch";
+	if (item.type === "webSearch") return "web_search";
+}
+function auditNativeToolName(item) {
+	if (item.type === "dynamicToolCall") return;
+	const progressName = itemName(item);
+	if (progressName) return progressName;
+	if (item.type === "collabAgentToolCall") return typeof item.tool === "string" && item.tool.trim() ? `collab.${item.tool.trim()}` : "collab_agent";
+	if (item.type === "imageGeneration") return "image_generation";
+	if (item.type === "imageView") return "image_view";
+	if (item.type === "sleep") return "sleep";
+}
+function isSideEffectingNativeToolItem(item) {
+	return itemStatus(item) !== "blocked" && (isMutatingNativeToolItem(item) || item.type === "mcpToolCall");
+}
+function shouldSynthesizeToolProgressForItem(item) {
+	switch (item.type) {
+		case "commandExecution":
+		case "fileChange":
+		case "webSearch":
+		case "mcpToolCall": return true;
+		default: return false;
+	}
+}
+function shouldRecordNativeToolTranscript(item) {
+	return shouldSynthesizeToolProgressForItem(item) && item.type !== "webSearch";
+}
+function isMutatingNativeToolItem(item) {
+	if (item.type === "commandExecution") return true;
+	return item.type === "fileChange" || item.type === "collabAgentToolCall" || item.type === "imageGeneration";
+}
+function shouldClearTerminalPresentationForNativeItem(item) {
+	switch (item.type) {
+		case "collabAgentToolCall":
+		case "commandExecution":
+		case "fileChange":
+		case "imageGeneration":
+		case "imageView":
+		case "mcpToolCall":
+		case "webSearch": return true;
+		default: return false;
+	}
+}
+function nativeToolActionFingerprint(item) {
+	if (item.type === "commandExecution" && typeof item.command === "string") return JSON.stringify({
+		type: item.type,
+		command: item.command,
+		cwd: typeof item.cwd === "string" ? item.cwd : ""
+	});
+	if (item.type === "fileChange") return JSON.stringify({
+		type: item.type,
+		changes: itemFileChanges(item)
+	});
+}
+function isNativePostToolUseRelayItem(item) {
+	switch (item.type) {
+		case "commandExecution":
+		case "fileChange":
+		case "mcpToolCall": return true;
+		default: return false;
+	}
+}
+function shouldSuppressChannelProgressForItem(item) {
+	if (shouldSynthesizeToolProgressForItem(item)) return true;
+	return item.type === "dynamicToolCall";
+}
+function itemToolArgs(item) {
+	if (item.type === "commandExecution") return sanitizeCodexAgentEventRecord({
+		command: item.command,
+		...typeof item.cwd === "string" ? { cwd: item.cwd } : {}
+	});
+	if (item.type === "fileChange") return sanitizeCodexAgentEventRecord({ changes: itemFileChanges(item) });
+	if (item.type === "webSearch") return webSearchToolArgs(item);
+	if (item.type === "dynamicToolCall" || item.type === "mcpToolCall") return sanitizeCodexToolArguments(item.arguments);
+}
+function webSearchToolArgs(item) {
+	const action = isJsonObject(item.action) ? item.action : void 0;
+	const actionType = action ? readNonEmptyString(action, "type") : void 0;
+	const queries = action && actionType === "search" ? readNonEmptyStringArray(action, "queries") : [];
+	const query = normalizeNonEmptyString(item.query) ?? (action && actionType === "search" ? readNonEmptyString(action, "query") : void 0) ?? queries[0];
+	const url = action ? readNonEmptyString(action, "url") : void 0;
+	const pattern = action ? readNonEmptyString(action, "pattern") : void 0;
+	const args = {};
+	if (query) args.query = query;
+	if (queries.length > 0) args.queries = queries;
+	if (actionType && actionType !== "search") args.action = actionType;
+	if (url) args.url = url;
+	if (pattern) args.pattern = pattern;
+	if (!query && !url && !pattern) args.queryUnavailable = true;
+	return sanitizeCodexAgentEventRecord(args);
+}
+function itemToolResult(item) {
+	if (item.type === "commandExecution") return { result: sanitizeCodexAgentEventRecord({
+		status: item.status,
+		exitCode: item.exitCode,
+		durationMs: item.durationMs
+	}) };
+	if (item.type === "fileChange") return { result: sanitizeCodexAgentEventRecord({
+		status: item.status,
+		changes: itemFileChanges(item)
+	}) };
+	if (item.type === "mcpToolCall") return { result: sanitizeCodexAgentEventRecord({
+		status: item.status,
+		durationMs: item.durationMs,
+		...item.error ? { error: item.error } : {},
+		...item.result ? { result: item.result } : {}
+	}) };
+	if (item.type === "webSearch") return { result: webSearchToolResult(item) };
+	return {};
+}
+function webSearchToolResult(item) {
+	return sanitizeCodexAgentEventRecord({
+		status: itemStatus(item),
+		...typeof item.durationMs === "number" ? { durationMs: item.durationMs } : {},
+		...webSearchToolArgs(item)
+	});
+}
+function itemFileChanges(item) {
+	return Array.isArray(item.changes) ? item.changes.map((change) => ({
+		path: change.path,
+		kind: change.kind
+	})) : [];
+}
+function itemToolError(item, status, outputTextByItem) {
+	if (status === "blocked") return "codex native tool blocked";
+	if (status !== "failed") return;
+	return itemOutputText(item, outputTextByItem) ?? "codex native tool failed";
+}
+function itemMeta(item, detailMode = "explain") {
+	if (item.type === "commandExecution" && typeof item.command === "string") return inferToolMetaFromArgs("exec", {
+		command: item.command,
+		cwd: typeof item.cwd === "string" ? item.cwd : void 0
+	}, { detailMode });
+	if (item.type === "webSearch") return inferToolMetaFromArgs("web_search", webSearchToolArgs(item), { detailMode });
+	const toolName = itemName(item);
+	if ((item.type === "dynamicToolCall" || item.type === "mcpToolCall") && toolName) return inferToolMetaFromArgs(toolName, item.arguments, { detailMode });
+}
+function itemOutputText(item, outputTextByItem) {
+	if (item.type === "commandExecution") return item.aggregatedOutput?.trim() || outputTextByItem?.get(item.id)?.trim() || void 0;
+	if (item.type === "dynamicToolCall") return collectDynamicToolContentText(item.contentItems).trim() || void 0;
+	if (item.type === "mcpToolCall") {
+		if (item.error) return stringifyJsonValue(item.error);
+		return item.result ? stringifyJsonValue(item.result) : void 0;
+	}
+}
+function itemTranscriptResultText(item, outputTextByItem) {
+	const output = itemOutputText(item, outputTextByItem);
+	if (output) return output;
+	const result = itemToolResult(item).result;
+	return result ? stringifyJsonValue(result) : itemStatus(item);
+}
+function appendToolOutputDeltaText(outputTextByItem, itemId, delta) {
+	const current = outputTextByItem.get(itemId) ?? "";
+	if (current.length >= TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS) return;
+	const remaining = TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS - current.length;
+	const next = current + (delta.length > remaining ? delta.slice(0, remaining) : delta);
+	outputTextByItem.set(itemId, next);
+}
+function normalizeToolTranscriptArguments(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+function collectDynamicToolContentText(contentItems) {
+	if (!Array.isArray(contentItems)) return "";
+	return contentItems.flatMap((entry) => {
+		if (!isJsonObject(entry)) return [];
+		const text = readString(entry, "text");
+		return text ? [text] : [];
+	}).join("\n");
+}
+function truncateToolTranscriptText(text) {
+	if (text.length <= TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS) return text;
+	return `${text.slice(0, TOOL_TRANSCRIPT_OUTPUT_MAX_CHARS)}\n...(truncated)...`;
+}
+function toolResultStatusText(params) {
+	return params.isError ? `${params.name} failed` : `${params.name} completed`;
+}
+function stringifyJsonValue(value) {
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return;
+	}
+}
+function formatToolSummary(toolName, meta) {
+	const trimmedMeta = meta?.trim();
+	return formatToolAggregate(toolName, trimmedMeta ? [trimmedMeta] : void 0, { markdown: true });
+}
+function formatToolOutput(toolName, meta, output) {
+	const formattedOutput = formatToolProgressOutput(output);
+	if (!formattedOutput) return formatToolSummary(toolName, meta);
+	const fence = markdownFenceForText(formattedOutput);
+	return `${formatToolSummary(toolName, meta)}\n${fence}txt\n${formattedOutput}\n${fence}`;
+}
+function markdownFenceForText(text) {
+	return "`".repeat(Math.max(3, longestBacktickRun(text) + 1));
+}
+function longestBacktickRun(value) {
+	let longest = 0;
+	let current = 0;
+	for (const char of value) {
+		if (char === "`") {
+			current += 1;
+			longest = Math.max(longest, current);
+			continue;
+		}
+		current = 0;
+	}
+	return longest;
+}
+function readItemString(item, key) {
+	const value = item[key];
+	return typeof value === "string" ? value : void 0;
+}
+function readItem(value) {
+	if (!isJsonObject(value)) return;
+	const type = typeof value.type === "string" ? value.type : void 0;
+	const id = typeof value.id === "string" ? value.id : void 0;
+	if (!type || !id) return;
+	return value;
+}
+//#endregion
+//#region extensions/codex/src/app-server/provider-capabilities.ts
+async function readConfiguredProviderWebSearchSupport(params) {
+	return (await params.client.request("modelProvider/capabilities/read", {}, {
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	})).webSearch ? "supported" : "unsupported";
+}
+async function resolveCodexProviderWebSearchSupportForClient(params) {
+	const modelProviderOverride = params.modelProviderOverride?.trim().toLowerCase();
+	if (modelProviderOverride === "openai") return "supported";
+	if (modelProviderOverride) return "unsupported";
+	try {
+		return await readConfiguredProviderWebSearchSupport(params);
+	} catch {
+		return "unknown";
+	}
+}
+async function resolveCodexProviderWebSearchSupport(params) {
+	let client;
+	try {
+		client = await params.clientFactory({
+			startOptions: params.appServer.start,
+			authProfileId: params.authProfileId,
+			agentDir: params.agentDir,
+			config: params.config,
+			timeoutMs: params.appServer.requestTimeoutMs
+		});
 		return await resolveCodexProviderWebSearchSupportForClient({
 			client,
 			timeoutMs: params.appServer.requestTimeoutMs,
@@ -3362,4 +6168,4 @@ async function resolveCodexProviderWebSearchSupport(params) {
 	}
 }
 //#endregion
-export { CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as A, resolveCodexMessageToolProvider as C, shouldWarnCodexDynamicToolBuildStageSummary as D, shouldRequireCodexSandboxExecServerEnvironment as E, resolveCodexTurnTerminalIdleTimeoutMs as F, withCodexStartupTimeout as I, resolveCodexStartupTimeoutMs as M, resolveCodexTurnAssistantCompletionIdleTimeoutMs as N, filterToolsForVisionInputs as O, resolveCodexTurnCompletionIdleTimeoutMs as P, resolveCodexExternalSandboxPolicyForOpenClawSandbox as S, shouldEnableCodexAppServerNativeToolSurface as T, createCodexDynamicToolBuildStageTracker as _, buildCodexNativeHookRelayConfig as a, resolveCodexAppServerExecutionCwd as b, resolveCodexNativeHookRelayEvents as c, handleCodexAppServerElicitationRequest as d, createCodexDynamicToolBridge as f, buildDynamicTools as g, emitDynamicToolTerminalDiagnostic as h, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as i, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as j, handleCodexAppServerApprovalRequest as k, resolveCodexNativeHookRelayTtlMs as l, emitDynamicToolStartedDiagnostic as m, resolveCodexProviderWebSearchSupportForClient as n, buildCodexNativeHookRelayDisabledConfig as o, emitDynamicToolErrorDiagnostic as p, CODEX_NATIVE_HOOK_RELAY_EVENTS as r, createCodexNativeHookRelay as s, resolveCodexProviderWebSearchSupport as t, scheduleCodexNativeHookRelayUnregister as u, disableCodexPluginThreadConfig as v, resolveCodexSandboxEnvironmentSelection as w, resolveCodexAppServerHookChannelId as x, formatCodexDynamicToolBuildStageSummary as y };
+export { isDynamicToolTerminalDiagnosticEvent as $, createCodexDynamicToolBuildStageTracker as A, shouldWarnCodexDynamicToolBuildStageSummary as B, resolveCodexLocalRuntimeAttribution as C, emitDynamicToolStartedDiagnostic as D, emitDynamicToolErrorDiagnostic as E, resolveCodexExternalSandboxPolicyForOpenClawSandbox as F, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as G, readCodexMirroredSessionHistoryMessages as H, resolveCodexMessageToolProvider as I, resolveCodexTurnCompletionIdleTimeoutMs as J, resolveCodexStartupTimeoutMs as K, resolveCodexSandboxEnvironmentSelection as L, formatCodexDynamicToolBuildStageSummary as M, resolveCodexAppServerExecutionCwd as N, emitDynamicToolTerminalDiagnostic as O, resolveCodexAppServerHookChannelId as P, hasPendingDynamicToolTerminalDiagnostic as Q, shouldEnableCodexAppServerNativeToolSurface as R, scheduleCodexNativeHookRelayUnregister as S, createCodexDynamicToolBridge as T, handleCodexAppServerApprovalRequest as U, filterToolsForVisionInputs as V, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as W, withCodexStartupTimeout as X, resolveCodexTurnTerminalIdleTimeoutMs as Y, handleDynamicToolCallWithTimeout as Z, buildCodexNativeHookRelayDisabledConfig as _, shouldEmitTranscriptToolProgress as a, toCodexDynamicToolProgressResponse as at, resolveCodexNativeHookRelayEvents as b, mirrorPromptAtTurnStartBestEffort as c, resolveCodexToolProgressDetailMode as d, isMatchingDynamicToolTerminalDiagnostic as et, sanitizeCodexToolArguments as f, buildCodexNativeHookRelayConfig as g, CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS as h, CodexNativeToolLifecycleProjector as i, shouldReleaseTurnAfterTerminalDynamicTool as it, disableCodexPluginThreadConfig as j, buildDynamicTools as k, mirrorTranscriptBestEffort as l, CODEX_NATIVE_HOOK_RELAY_EVENTS as m, resolveCodexProviderWebSearchSupportForClient as n, resolveTerminalDynamicToolBatchAction as nt, buildCodexUserPromptMessage as o, toCodexDynamicToolProtocolResponse as ot, sanitizeCodexToolResponse as p, resolveCodexTurnAssistantCompletionIdleTimeoutMs as q, CodexAppServerEventProjector as r, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as rt, createCodexAppServerUserMessagePersistenceNotifier as s, resolveCodexToolAbortTerminalReason as st, resolveCodexProviderWebSearchSupport as t, resolveDynamicToolCallTimeoutMs as tt, inferCodexDynamicToolMeta as u, createCodexNativeHookRelay as v, handleCodexAppServerElicitationRequest as w, resolveCodexNativeHookRelayTtlMs as x, emitCodexNativePreToolUseFailureDiagnostic as y, shouldRequireCodexSandboxExecServerEnvironment as z };