@openclaw/codex 2026.6.5-beta.2 → 2026.6.5-beta.3

package/dist/harness.js

@@ -32,14 +32,14 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-CWfXFq9Q.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-DOr_d98I.js");
 			return runCodexAppServerAttempt(params, {
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				nativeHookRelay: { enabled: true }
 			});
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-BEpALo9c.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-BnvBQPqW.js");
 			return runCodexAppServerSideQuestion(params, {
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				nativeHookRelay: { enabled: true }

package/dist/{native-hook-relay-DZ3Oon0b.js → native-hook-relay-DHwz_ICg.js}

@@ -992,23 +992,17 @@ function createCodexDynamicToolBridge(params) {
 	const toolResultMaxChars = resolveCodexDynamicToolResultMaxChars(params.hookContext);
 	const availableProjection = projectCodexDynamicTools(params.tools);
 	const registeredProjection = params.registeredTools ? projectCodexDynamicTools(params.registeredTools) : availableProjection;
-	const availableTools = availableProjection.tools.map(({ tool, inputSchema }) => {
-		if (isToolWrappedWithBeforeToolCallHook(tool)) {
-			setBeforeToolCallDiagnosticsEnabled(tool, false);
-			return {
-				tool,
-				inputSchema
-			};
-		}
-		return {
-			tool: wrapToolWithBeforeToolCallHook(tool, params.hookContext, { emitDiagnostics: false }),
-			inputSchema
-		};
-	});
-	const toolMap = new Map(availableTools.map(({ tool }) => [tool.name, tool]));
-	const registeredTools = registeredProjection.tools.map(({ tool }) => tool);
-	const registeredToolNames = new Set(registeredTools.map((tool) => tool.name));
-	const quarantinedTools = dedupeQuarantinedDynamicTools([...availableProjection.quarantinedTools, ...registeredProjection.quarantinedTools]);
+	const wrappedAvailableProjection = wrapProjectedCodexDynamicTools(availableProjection.tools, params.hookContext);
+	const availableTools = wrappedAvailableProjection.tools;
+	const quarantinedAvailableToolNames = new Set([...availableProjection.quarantinedTools, ...wrappedAvailableProjection.quarantinedTools].map((tool) => tool.tool));
+	const registeredSpecTools = (params.registeredTools ? registeredProjection.tools : availableTools).filter((entry) => !quarantinedAvailableToolNames.has(entry.name));
+	const toolMap = new Map(availableTools.map((entry) => [entry.name, entry]));
+	const registeredToolNames = new Set(registeredSpecTools.map((entry) => entry.name));
+	const quarantinedTools = dedupeQuarantinedDynamicTools([
+		...availableProjection.quarantinedTools,
+		...registeredProjection.quarantinedTools,
+		...wrappedAvailableProjection.quarantinedTools
+	]);
 	warnQuarantinedDynamicTools(quarantinedTools);
 	emitQuarantinedDynamicToolDiagnostics(quarantinedTools, params.hookContext);
 	const telemetry = {
@@ -1028,22 +1022,20 @@ function createCodexDynamicToolBridge(params) {
 	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
 	const directToolNames = new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
 	return {
-		availableSpecs: availableTools.map(({ tool, inputSchema }) => createCodexDynamicToolSpec({
-			tool,
-			inputSchema,
+		availableSpecs: availableTools.map((entry) => createCodexDynamicToolSpec({
+			entry,
 			loading: params.loading ?? "searchable",
 			directToolNames
 		})),
-		specs: registeredProjection.tools.map(({ tool, inputSchema }) => createCodexDynamicToolSpec({
-			tool,
-			inputSchema,
+		specs: registeredSpecTools.map((entry) => createCodexDynamicToolSpec({
+			entry,
 			loading: params.loading ?? "searchable",
 			directToolNames
 		})),
 		telemetry,
 		handleToolCall: async (call, options) => {
-			const tool = toolMap.get(call.tool);
-			if (!tool) {
+			const toolEntry = toolMap.get(call.tool);
+			if (!toolEntry) {
 				if (registeredToolNames.has(call.tool)) return {
 					contentItems: [{
 						type: "inputText",
@@ -1059,6 +1051,7 @@ function createCodexDynamicToolBridge(params) {
 					success: false
 				};
 			}
+			const { tool, name: toolName } = toolEntry;
 			const args = jsonObjectToRecord(call.arguments);
 			const startedAt = Date.now();
 			const signal = composeAbortSignals(params.signal, options?.signal);
@@ -1072,7 +1065,7 @@ function createCodexDynamicToolBridge(params) {
 					threadId: call.threadId,
 					turnId: call.turnId,
 					toolCallId: call.callId,
-					toolName: tool.name,
+					toolName,
 					args,
 					isError: rawIsError,
 					result: rawResult
@@ -1081,13 +1074,13 @@ function createCodexDynamicToolBridge(params) {
 					threadId: call.threadId,
 					turnId: call.turnId,
 					toolCallId: call.callId,
-					toolName: tool.name,
+					toolName,
 					args,
 					result: middlewareResult
 				});
 				const resultIsError = rawIsError || isToolResultError(result);
 				collectToolTelemetry({
-					toolName: tool.name,
+					toolName,
 					args,
 					result,
 					mediaTrustResult: rawResult,
@@ -1095,7 +1088,7 @@ function createCodexDynamicToolBridge(params) {
 					isError: resultIsError
 				});
 				runAgentHarnessAfterToolCallHook({
-					toolName: tool.name,
+					toolName,
 					toolCallId: call.callId,
 					runId: toolResultHookContext.runId,
 					agentId: toolResultHookContext.agentId,
@@ -1116,14 +1109,14 @@ function createCodexDynamicToolBridge(params) {
 				return withSideEffectEvidence(response, terminalType !== "blocked");
 			} catch (error) {
 				collectToolTelemetry({
-					toolName: tool.name,
+					toolName,
 					args,
 					result: void 0,
 					telemetry,
 					isError: true
 				});
 				runAgentHarnessAfterToolCallHook({
-					toolName: tool.name,
+					toolName,
 					toolCallId: call.callId,
 					runId: toolResultHookContext.runId,
 					agentId: toolResultHookContext.agentId,
@@ -1145,13 +1138,37 @@ function createCodexDynamicToolBridge(params) {
 		}
 	};
 }
+function wrapProjectedCodexDynamicTools(tools, hookContext) {
+	const wrappedTools = [];
+	const quarantinedTools = [];
+	for (const entry of tools) try {
+		if (isToolWrappedWithBeforeToolCallHook(entry.tool)) {
+			setBeforeToolCallDiagnosticsEnabled(entry.tool, false);
+			wrappedTools.push(entry);
+			continue;
+		}
+		wrappedTools.push({
+			...entry,
+			tool: wrapToolWithBeforeToolCallHook(entry.tool, hookContext, { emitDiagnostics: false })
+		});
+	} catch {
+		quarantinedTools.push({
+			tool: entry.name,
+			violations: [`${entry.name} could not be wrapped for before-tool-call hooks`]
+		});
+	}
+	return {
+		tools: wrappedTools,
+		quarantinedTools
+	};
+}
 function createCodexDynamicToolSpec(params) {
 	const base = {
-		name: params.tool.name,
-		description: params.tool.description,
-		inputSchema: params.inputSchema
+		name: params.entry.name,
+		description: params.entry.description,
+		inputSchema: params.entry.inputSchema
 	};
-	if (params.loading === "direct" || params.directToolNames.has(params.tool.name)) return base;
+	if (params.loading === "direct" || params.directToolNames.has(params.entry.name)) return base;
 	return {
 		...base,
 		namespace: CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE,
@@ -1161,17 +1178,46 @@ function createCodexDynamicToolSpec(params) {
 function projectCodexDynamicTools(tools) {
 	const projectedTools = [];
 	const quarantinedTools = [];
-	for (const tool of tools) {
-		const projection = projectRuntimeToolInputSchema(tool.parameters, `${tool.name}.inputSchema`);
+	let length;
+	try {
+		length = tools.length;
+	} catch {
+		return {
+			tools: [],
+			quarantinedTools: [{
+				tool: "tool[0]",
+				violations: ["tool[0] is unreadable"]
+			}]
+		};
+	}
+	for (let toolIndex = 0; toolIndex < length; toolIndex += 1) {
+		let tool;
+		try {
+			tool = tools[toolIndex];
+		} catch {
+			quarantinedTools.push({
+				tool: `tool[${toolIndex}]`,
+				violations: [`tool[${toolIndex}] is unreadable`]
+			});
+			continue;
+		}
+		const descriptor = readCodexDynamicToolDescriptor(tool, toolIndex);
+		if (!descriptor.ok) {
+			quarantinedTools.push(descriptor.diagnostic);
+			continue;
+		}
+		const projection = projectRuntimeToolInputSchema(descriptor.parameters, `${descriptor.name}.inputSchema`);
 		if (projection.violations.length > 0) {
 			quarantinedTools.push({
-				tool: tool.name,
+				tool: descriptor.name,
 				violations: projection.violations
 			});
 			continue;
 		}
 		projectedTools.push({
 			tool,
+			name: descriptor.name,
+			description: descriptor.description,
 			inputSchema: projection.schema
 		});
 	}
@@ -1180,6 +1226,59 @@ function projectCodexDynamicTools(tools) {
 		quarantinedTools
 	};
 }
+function readCodexDynamicToolDescriptor(tool, toolIndex) {
+	const fallbackName = `tool[${toolIndex}]`;
+	let name;
+	try {
+		const rawName = tool.name;
+		if (typeof rawName !== "string" || !rawName) return {
+			ok: false,
+			diagnostic: {
+				tool: fallbackName,
+				violations: [`${fallbackName}.name must be a non-empty string`]
+			}
+		};
+		name = rawName;
+	} catch {
+		return {
+			ok: false,
+			diagnostic: {
+				tool: fallbackName,
+				violations: [`${fallbackName}.name is unreadable`]
+			}
+		};
+	}
+	let description;
+	try {
+		description = typeof tool.description === "string" ? tool.description : "";
+	} catch {
+		return {
+			ok: false,
+			diagnostic: {
+				tool: name,
+				violations: [`${name}.description is unreadable`]
+			}
+		};
+	}
+	let parameters;
+	try {
+		parameters = tool.parameters;
+	} catch {
+		return {
+			ok: false,
+			diagnostic: {
+				tool: name,
+				violations: [`${name}.inputSchema is unreadable`]
+			}
+		};
+	}
+	return {
+		ok: true,
+		name,
+		description,
+		parameters
+	};
+}
 function warnQuarantinedDynamicTools(tools) {
 	if (tools.length === 0) return;
 	const unique = /* @__PURE__ */ new Map();

package/dist/{run-attempt-CWfXFq9Q.js → run-attempt-DOr_d98I.js}

@@ -8,7 +8,7 @@ import { _ as shouldRefreshCodexRateLimitsForUsageLimitMessage, g as resolveCode
 import { d as resolveCodexAppServerAuthAccountCacheKey, f as resolveCodexAppServerAuthProfileId, h as resolveCodexAppServerHomeDir, m as resolveCodexAppServerFallbackApiKeyCacheKey, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, o as releaseLeasedSharedCodexAppServerClient, p as resolveCodexAppServerAuthProfileIdForAgent, s as retireSharedCodexAppServerClientIfCurrent, t as clearSharedCodexAppServerClientIfCurrent, u as refreshCodexAppServerAuthTokens } from "./shared-client-xytpSKD0.js";
 import { i as resolveCodexNativeExecutionPolicy } from "./sandbox-guard-C-Yv9uwY.js";
 import { t as defaultLeasedCodexAppServerClientFactory } from "./client-factory-Bt49r45B.js";
-import { S as withCodexStartupTimeout, _ as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, a as createCodexNativeHookRelay, b as resolveCodexTurnCompletionIdleTimeoutMs, c as scheduleCodexNativeHookRelayUnregister, d as emitDynamicToolErrorDiagnostic, f as emitDynamicToolStartedDiagnostic, g as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, h as handleCodexAppServerApprovalRequest, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerElicitationRequest, m as filterToolsForVisionInputs, n as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, o as resolveCodexNativeHookRelayEvents, p as emitDynamicToolTerminalDiagnostic, r as buildCodexNativeHookRelayConfig, s as resolveCodexNativeHookRelayTtlMs, u as createCodexDynamicToolBridge, v as resolveCodexStartupTimeoutMs, x as resolveCodexTurnTerminalIdleTimeoutMs, y as resolveCodexTurnAssistantCompletionIdleTimeoutMs } from "./native-hook-relay-DZ3Oon0b.js";
+import { S as withCodexStartupTimeout, _ as resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs, a as createCodexNativeHookRelay, b as resolveCodexTurnCompletionIdleTimeoutMs, c as scheduleCodexNativeHookRelayUnregister, d as emitDynamicToolErrorDiagnostic, f as emitDynamicToolStartedDiagnostic, g as CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS, h as handleCodexAppServerApprovalRequest, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerElicitationRequest, m as filterToolsForVisionInputs, n as CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS, o as resolveCodexNativeHookRelayEvents, p as emitDynamicToolTerminalDiagnostic, r as buildCodexNativeHookRelayConfig, s as resolveCodexNativeHookRelayTtlMs, u as createCodexDynamicToolBridge, v as resolveCodexStartupTimeoutMs, x as resolveCodexTurnTerminalIdleTimeoutMs, y as resolveCodexTurnAssistantCompletionIdleTimeoutMs } from "./native-hook-relay-DHwz_ICg.js";
 import { t as ensureCodexComputerUse } from "./computer-use-ClweWaMz.js";
 import { n as rememberCodexRateLimits, t as readRecentCodexRateLimits } from "./rate-limit-cache-C7qmZ0Jh.js";
 import { asDateTimestampMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -25,6 +25,7 @@ import fs from "node:fs/promises";
 import path, { posix } from "node:path";
 import { createDiagnosticTraceContextFromActiveScope, emitTrustedDiagnosticEvent, emitTrustedDiagnosticEventWithPrivateData, freezeDiagnosticTraceContext, hasPendingInternalDiagnosticEvent, onInternalDiagnosticEvent, resolveDiagnosticModelContentCapturePolicy } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { loadSessionStore } from "openclaw/plugin-sdk/session-store-runtime";
 import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";
 import { appendRegularFile, pathExists } from "openclaw/plugin-sdk/security-runtime";
 import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "openclaw/plugin-sdk/agent-sessions";
@@ -893,6 +894,10 @@ function isRawReasoningCompletionNotification(notification) {
 	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
 	return item ? readString$6(item, "type") === "reasoning" : false;
 }
+/** Returns true for streamed app-server reasoning progress. */
+function isReasoningProgressNotification(notification) {
+	return notification.method === "item/reasoning/textDelta" || notification.method === "item/reasoning/summaryTextDelta" || notification.method === "item/reasoning/summaryPartAdded";
+}
 /** Returns true when assistant completion can release the short idle watch. */
 function isAssistantCompletionReleaseNotification(notification, turnCrossedToolHandoff) {
 	if (isCompletedAssistantNotification(notification)) return true;
@@ -1116,13 +1121,13 @@ function applyCodexTurnNotificationState(params) {
 	const rawToolOutputCompletion = isRawToolOutputCompletionNotification(notification);
 	if (isCurrentTurnNotification && (rawToolOutputCompletion || isNativeToolProgressNotification(notification))) turnCrossedToolHandoff = true;
 	const assistantCompletionCanRelease = isAssistantCompletionReleaseNotification(notification, turnCrossedToolHandoff);
-	const postToolRawAssistantCompletionNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && isRawAssistantProgressNotification(notification) && params.activeTurnItemIds.size === 0;
+	const postToolProgressNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && ((isRawAssistantProgressNotification(notification) || isRawReasoningCompletionNotification(notification)) && params.activeTurnItemIds.size === 0 || isReasoningProgressNotification(notification));
 	const postToolPatchUpdateNeedsTerminalGuard = isCurrentTurnNotification && turnCrossedToolHandoff && isFileChangePatchUpdatedNotification(notification);
-	const rawResponseItemCompletedWithNoActiveItems = isCurrentTurnNotification && notification.method === "rawResponseItem/completed" && params.activeTurnItemIds.size === 0 && params.activeAppServerTurnRequests === 0 && !assistantCompletionCanRelease && !postToolRawAssistantCompletionNeedsTerminalGuard && !rawToolOutputCompletion;
+	const rawResponseItemCompletedWithNoActiveItems = isCurrentTurnNotification && notification.method === "rawResponseItem/completed" && params.activeTurnItemIds.size === 0 && params.activeAppServerTurnRequests === 0 && !assistantCompletionCanRelease && !postToolProgressNeedsTerminalGuard && !rawToolOutputCompletion;
 	const shouldArmNoToolPostProgressReplyWatch = isCurrentTurnNotification && !turnCrossedToolHandoff && params.activeTurnItemIds.size === 0 && (isReasoningItemCompletionNotification(notification) || isAssistantCommentaryCompletionNotification(notification));
 	const shouldArmNoToolPostRawProgressReplyWatch = !turnCrossedToolHandoff && rawResponseItemCompletedWithNoActiveItems && (isRawReasoningCompletionNotification(notification) || isRawAssistantProgressNotification(notification));
 	const shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem = isCurrentTurnNotification && notification.method === "item/completed" && params.activeTurnItemIds.size === 0 && !trackedDynamicToolCompletion && !assistantCompletionCanRelease && !shouldArmNoToolPostProgressReplyWatch;
-	const shouldUsePostToolContinuationWatch = turnCrossedToolHandoff && (postToolRawAssistantCompletionNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard || rawToolOutputCompletion || trackedDynamicToolCompletion || shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem);
+	const shouldUsePostToolContinuationWatch = turnCrossedToolHandoff && (postToolProgressNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard || rawToolOutputCompletion || trackedDynamicToolCompletion || shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem);
 	const armPostToolContinuationWatch = () => {
 		turnWatches.armCompletionIdleWatch({ timeoutMs: params.postToolRawAssistantCompletionIdleTimeoutMs });
 		turnWatches.extendAttemptIdleWatch(params.postToolRawAssistantCompletionIdleTimeoutMs);
@@ -1137,7 +1142,7 @@ function applyCodexTurnNotificationState(params) {
 		turnWatches.disarmAssistantCompletionIdleWatch();
 	} else if (isTurnCompletion) turnWatches.disarmAssistantCompletionIdleWatch();
 	else if (isCurrentTurnNotification && assistantCompletionCanRelease) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
-	else if (postToolRawAssistantCompletionNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard) armPostToolContinuationWatch();
+	else if (postToolProgressNeedsTerminalGuard || postToolPatchUpdateNeedsTerminalGuard) armPostToolContinuationWatch();
 	else if (shouldArmNoToolPostProgressReplyWatch || shouldArmNoToolPostRawProgressReplyWatch) armPostProgressReplyWatch();
 	else if (trackedDynamicToolCompletion) armPostToolContinuationWatch();
 	else if (unblockedAssistantCompletionRelease) turnWatches.armAssistantCompletionIdleWatch(describeNotificationActivity(notification));
@@ -1146,7 +1151,7 @@ function applyCodexTurnNotificationState(params) {
 	else if (rawResponseItemCompletedWithNoActiveItems) turnWatches.armCompletionIdleWatch();
 	else if (isCurrentTurnNotification && rawToolOutputCompletion) armPostToolContinuationWatch();
 	else if (isCurrentTurnNotification && shouldDisarmAssistantCompletionIdleWatch(notification)) turnWatches.disarmAssistantCompletionIdleWatch();
-	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !isNativeResponseStreamDelta && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolRawAssistantCompletionNeedsTerminalGuard && !postToolPatchUpdateNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmNoToolPostProgressReplyWatch && !shouldArmNoToolPostRawProgressReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
+	if (turnWatches.isCompletionIdleWatchArmed() && !turnWatches.isCompletionIdleWatchPinnedByTerminalError() && notification.method !== "turn/completed" && isCurrentTurnNotification && !isNativeResponseStreamDelta && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !postToolProgressNeedsTerminalGuard && !postToolPatchUpdateNeedsTerminalGuard && !rawResponseItemCompletedWithNoActiveItems && !shouldArmNoToolPostProgressReplyWatch && !shouldArmNoToolPostRawProgressReplyWatch && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) turnWatches.disarmCompletionIdleWatch();
 	if (trackedDynamicToolCompletion) {
 		const itemId = readNotificationItemId(notification);
 		if (itemId) {
@@ -4233,6 +4238,7 @@ var CodexAppServerEventProjector = class {
 		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.nativeGeneratedMediaUrls = /* @__PURE__ */ new Set();
 		this.nativeGeneratedMediaItemIds = /* @__PURE__ */ new Set();
@@ -4321,7 +4327,13 @@ var CodexAppServerEventProjector = class {
 		const assistantTexts = this.collectAssistantTexts();
 		const reasoningText = collectReasoningTextValues(this.reasoningTextByGroup, this.reasoningItemOrder).join("\n\n");
 		const planText = collectTextValues(this.planTextByItem).join("\n\n");
-		this.synthesizeMissingToolResults({ failClosed: !this.completedTurn || this.completedTurn.status !== "completed" || assistantTexts.length > 0 });
+		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 turnId = this.turnId;
 		const messagesSnapshot = this.params.suppressNextUserMessagePersistence ? [] : [attachCodexMirrorIdentity(buildCodexUserPromptMessage(this.params), `${turnId}:prompt`)];
@@ -4983,6 +4995,7 @@ var CodexAppServerEventProjector = class {
 		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,
@@ -5178,7 +5191,7 @@ var CodexAppServerEventProjector = class {
 		this.toolTranscriptMessages.push(attachCodexMirrorIdentity(this.createToolResultMessage(params), `${this.turnId}:tool:${params.id}:result`));
 	}
 	synthesizeMissingToolResults(params) {
-		if (!params.failClosed) return;
+		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;
@@ -5218,6 +5231,34 @@ var CodexAppServerEventProjector = class {
 				output: text
 			});
 		}
+		if (!params.recordPromptError) {
+			const firstMissingId = missingTranscriptIds.find((id) => {
+				const name = this.toolTranscriptNamesById.get(id) ?? this.toolTrajectoryNamesById.get(id);
+				return Boolean(name);
+			}) ?? missingTrajectoryIds.find((id) => {
+				const name = this.toolTrajectoryNamesById.get(id) ?? this.toolTranscriptNamesById.get(id);
+				return Boolean(name);
+			});
+			if (firstMissingId) {
+				const name = this.toolTranscriptNamesById.get(firstMissingId) ?? this.toolTrajectoryNamesById.get(firstMissingId);
+				if (name) {
+					const item = this.toolTrajectoryItemsById.get(firstMissingId);
+					const meta = item ? itemMeta(item, this.toolProgressDetailMode()) : this.toolMetas.get(firstMissingId)?.meta;
+					const actionFingerprint = item ? nativeToolActionFingerprint(item) : void 0;
+					this.lastNativeToolError = {
+						toolName: name,
+						...meta ? { meta } : {},
+						error: formatMissingToolResultError({
+							id: firstMissingId,
+							name
+						}),
+						...item && isMutatingNativeToolItem(item) ? { mutatingAction: true } : {},
+						...actionFingerprint ? { actionFingerprint } : {}
+					};
+				}
+			}
+			return;
+		}
 		const missingCount = new Set([...missingTranscriptIds, ...missingTrajectoryIds]).size;
 		this.synthesizedMissingToolResultError = missingCount === 1 ? MISSING_TOOL_RESULT_ERROR : `${MISSING_TOOL_RESULT_ERROR} missingToolResultCount=${missingCount}`;
 		this.promptErrorSource = this.promptErrorSource ?? "prompt";
@@ -5283,6 +5324,16 @@ var CodexAppServerEventProjector = class {
 		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;
 	}
@@ -5864,10 +5915,11 @@ function readCompletionStatus(status) {
 	for (const [rawKey, value] of Object.entries(status)) {
 		const mappedStatus = mapCompletionStatus(normalizeStatusKey(rawKey));
 		if (!mappedStatus) continue;
+		const result = stringifyResult(value, mappedStatus);
 		return {
 			status: mappedStatus,
-			label: rawKey,
-			result: stringifyResult(value)
+			label: mappedStatus === "succeeded" && result.kind === "no_final_assistant_message" ? "completed_without_final_message" : rawKey,
+			result: result.text
 		};
 	}
 }
@@ -5876,15 +5928,25 @@ function mapCompletionStatus(value) {
 	if (value === "cancelled" || value === "canceled" || value === "interrupted" || value === "shutdown") return "cancelled";
 	if (value === "failed" || value === "error" || value === "errored" || value === "systemerror" || value === "notfound") return "failed";
 }
-function stringifyResult(value) {
-	if (typeof value === "string") return value.trim() || "(no output)";
-	if (value === null || value === void 0) return "(no output)";
+function stringifyResult(value, status) {
+	if (typeof value === "string") {
+		const text = value.trim();
+		if (text) return { text };
+		return status === "succeeded" ? completedWithoutFinalAssistantMessage() : { text: "(no output)" };
+	}
+	if (value === null || value === void 0) return status === "succeeded" ? completedWithoutFinalAssistantMessage() : { text: "(no output)" };
 	try {
-		return JSON.stringify(value);
+		return { text: JSON.stringify(value) };
 	} catch {
-		return "(unserializable output)";
+		return { text: "(unserializable output)" };
 	}
 }
+function completedWithoutFinalAssistantMessage() {
+	return {
+		text: "Codex native subagent completed without a final assistant message.",
+		kind: "no_final_assistant_message"
+	};
+}
 function readTrustedInterAgentCommunicationContent(item) {
 	const communication = readTrustedInterAgentCommunication(item);
 	return typeof communication?.content === "string" ? communication.content : void 0;
@@ -6415,6 +6477,14 @@ var CodexNativeSubagentMonitor = class {
 				continue;
 			}
 			const completion = toThreadCompletion(nativeCompletion, childState.childThreadId);
+			if (shouldWaitForTranscriptCompletion(completion, this.codexHome)) {
+				const eventAt = Date.now();
+				if (!await this.reconcileChildTranscript(childState.childThreadId)) {
+					this.scheduleTranscriptPoll(childState);
+					this.scheduleNoFinalCompletionFallback(state, childState, completion, eventAt);
+				}
+				continue;
+			}
 			await this.processCompletion(state, completion);
 		}
 	}
@@ -6448,6 +6518,10 @@ var CodexNativeSubagentMonitor = class {
 				clearTimeout(childState.transcriptPollTimer);
 				childState.transcriptPollTimer = void 0;
 			}
+			if (childState.noFinalCompletionFallbackTimer) {
+				clearTimeout(childState.noFinalCompletionFallbackTimer);
+				childState.noFinalCompletionFallbackTimer = void 0;
+			}
 		}
 		if (!state.requesterSessionKey) return;
 		const completionKey = buildCompletionDedupeKey(state.parentThreadId, completion);
@@ -6601,6 +6675,24 @@ var CodexNativeSubagentMonitor = class {
 		}, delayMs);
 		unrefTimer(childState.transcriptPollTimer);
 	}
+	scheduleNoFinalCompletionFallback(state, childState, completion, eventAt) {
+		if (childState.transcriptTerminal || childState.noFinalCompletionFallbackTimer) return;
+		const delayMs = noFinalCompletionFallbackDelayMs(this.transcriptPollDelaysMs);
+		childState.noFinalCompletionFallbackTimer = setTimeout(() => {
+			childState.noFinalCompletionFallbackTimer = void 0;
+			this.deliverNoFinalCompletionFallback(state, childState, completion, eventAt);
+		}, delayMs);
+		unrefTimer(childState.noFinalCompletionFallbackTimer);
+	}
+	async deliverNoFinalCompletionFallback(state, childState, completion, eventAt) {
+		if (!await this.reconcileChildTranscript(childState.childThreadId).catch((error) => {
+			embeddedAgentLog.warn("Failed to reconcile Codex native subagent transcript", {
+				childThreadId: childState.childThreadId,
+				error: formatErrorMessage(error)
+			});
+			return false;
+		}) && !childState.transcriptTerminal) await this.processCompletion(state, completion, eventAt);
+	}
 	clearTimers() {
 		if (this.taskRowReconcileTimer) {
 			clearInterval(this.taskRowReconcileTimer);
@@ -6615,6 +6707,10 @@ var CodexNativeSubagentMonitor = class {
 				clearTimeout(childState.completionDeliveryTimer);
 				childState.completionDeliveryTimer = void 0;
 			}
+			if (childState.noFinalCompletionFallbackTimer) {
+				clearTimeout(childState.noFinalCompletionFallbackTimer);
+				childState.noFinalCompletionFallbackTimer = void 0;
+			}
 		}
 	}
 	startTaskRowReconciler(intervalMs) {
@@ -6748,6 +6844,14 @@ function toThreadCompletion(completion, childThreadId) {
 		result: completion.result
 	};
 }
+function shouldWaitForTranscriptCompletion(completion, codexHome) {
+	return Boolean(codexHome && completion.status === "succeeded" && completion.statusLabel === "completed_without_final_message");
+}
+function noFinalCompletionFallbackDelayMs(delays) {
+	const first = delays[0] ?? 0;
+	const second = delays[1] ?? 0;
+	return Math.max(1, first + second);
+}
 function readSpawnParentThreadId(thread) {
 	const source = isJsonObject(thread?.source) ? thread.source : void 0;
 	const subAgent = isJsonObject(source?.subAgent) ? source.subAgent : void 0;
@@ -6856,15 +6960,17 @@ async function readTranscriptCompletion(transcriptPath, childThreadId) {
 		}
 		if (readString$2(entry, "type") !== "event_msg") continue;
 		const payloadType = readString$2(payload, "type");
-		if (payloadType === "task_complete") completion = {
-			childThreadId,
-			parentThreadId,
-			status: "succeeded",
-			statusLabel: "task_complete",
-			result: readString$2(payload, "last_agent_message")?.trim() || readString$2(payload, "message")?.trim() || "(no output)",
-			completedAt: secondsToMillis(readNumber(payload, "completed_at")) ?? readTimestamp(entry)
-		};
-		else if (payloadType === "task_failed") {
+		if (payloadType === "task_complete") {
+			const result = readString$2(payload, "last_agent_message")?.trim() || readString$2(payload, "message")?.trim();
+			completion = {
+				childThreadId,
+				parentThreadId,
+				status: "succeeded",
+				statusLabel: result ? "task_complete" : "completed_without_final_message",
+				result: result ?? "Codex native subagent completed without a final assistant message.",
+				completedAt: secondsToMillis(readNumber(payload, "completed_at")) ?? readTimestamp(entry)
+			};
+		} else if (payloadType === "task_failed") {
 			const result = readString$2(payload, "last_agent_message")?.trim() || readString$2(payload, "error")?.trim() || readString$2(payload, "message")?.trim() || "Codex native subagent failed.";
 			completion = {
 				childThreadId,
@@ -6919,7 +7025,6 @@ const CODEX_APP_SERVER_BYTE_UNITS = {
 	tb: 1024 * 1024 * 1024 * 1024,
 	tib: 1024 * 1024 * 1024 * 1024
 };
-const codexSessionRecordCache = /* @__PURE__ */ new Map();
 function parseCodexAppServerByteLimit(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
 	if (typeof value !== "string") return;
@@ -6974,45 +7079,22 @@ async function listCodexAppServerRolloutFilesForThread(agentDir, threadId, codex
 	return files;
 }
 async function readCodexSessionRecordForSessionFile(sessionFile) {
-	const sessionsFile = path.join(path.dirname(sessionFile), "sessions.json");
+	const storePath = path.join(path.dirname(sessionFile), "sessions.json");
 	const resolvedSessionFile = path.resolve(sessionFile);
-	let stat;
-	try {
-		stat = await fs.stat(sessionsFile);
-	} catch {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	const cached = codexSessionRecordCache.get(resolvedSessionFile);
-	if (cached?.sessionsFile === sessionsFile && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.record;
 	let store;
 	try {
-		store = JSON.parse(await fs.readFile(sessionsFile, "utf8"));
+		store = loadSessionStore(storePath, { skipCache: true });
 	} catch {
-		codexSessionRecordCache.delete(resolvedSessionFile);
-		return;
-	}
-	if (!isJsonObject(store)) {
-		codexSessionRecordCache.delete(resolvedSessionFile);
 		return;
 	}
-	let found;
 	for (const [sessionKey, record] of Object.entries(store)) {
 		if (!isJsonObject(record) || typeof record.sessionFile !== "string") continue;
 		if (path.resolve(record.sessionFile) !== resolvedSessionFile) continue;
-		found = {
+		return {
 			sessionKey,
 			...record
 		};
-		break;
 	}
-	codexSessionRecordCache.set(resolvedSessionFile, {
-		sessionsFile,
-		mtimeMs: stat.mtimeMs,
-		size: stat.size,
-		record: found
-	});
-	return found;
 }
 async function readCodexAppServerRolloutTokenSnapshot(file) {
 	let handle;

package/dist/{side-question-BEpALo9c.js → side-question-BnvBQPqW.js}

@@ -6,7 +6,7 @@ import { a as readCodexAppServerBinding } from "./session-binding-BgTv_YGm.js";
 import { h as formatCodexUsageLimitErrorMessage, i as readCodexNotificationTurnId, r as readCodexNotificationThreadId } from "./notification-correlation-o8quHmTK.js";
 import { a as getLeasedSharedCodexAppServerClient, o as releaseLeasedSharedCodexAppServerClient, u as refreshCodexAppServerAuthTokens } from "./shared-client-xytpSKD0.js";
 import { n as resolveCodexNativeExecutionBlock } from "./sandbox-guard-C-Yv9uwY.js";
-import { d as emitDynamicToolErrorDiagnostic, f as emitDynamicToolStartedDiagnostic, h as handleCodexAppServerApprovalRequest, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerElicitationRequest, m as filterToolsForVisionInputs, p as emitDynamicToolTerminalDiagnostic, r as buildCodexNativeHookRelayConfig, t as CODEX_NATIVE_HOOK_RELAY_EVENTS, u as createCodexDynamicToolBridge } from "./native-hook-relay-DZ3Oon0b.js";
+import { d as emitDynamicToolErrorDiagnostic, f as emitDynamicToolStartedDiagnostic, h as handleCodexAppServerApprovalRequest, i as buildCodexNativeHookRelayDisabledConfig, l as handleCodexAppServerElicitationRequest, m as filterToolsForVisionInputs, p as emitDynamicToolTerminalDiagnostic, r as buildCodexNativeHookRelayConfig, t as CODEX_NATIVE_HOOK_RELAY_EVENTS, u as createCodexDynamicToolBridge } from "./native-hook-relay-DHwz_ICg.js";
 import { n as rememberCodexRateLimits, t as readRecentCodexRateLimits } from "./rate-limit-cache-C7qmZ0Jh.js";
 import { buildAgentHookContextChannelFields, embeddedAgentLog, formatErrorMessage, registerNativeHookRelay, resolveAgentDir, resolveAttemptSpawnWorkspaceDir, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/side-question.ts

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.6.5-beta.2",
+  "version": "2026.6.5-beta.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/codex",
-      "version": "2026.6.5-beta.2",
+      "version": "2026.6.5-beta.3",
       "dependencies": {
         "@openai/codex": "0.135.0",
         "typebox": "1.1.39",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.6.5-beta.2",
+  "version": "2026.6.5-beta.3",
   "description": "OpenClaw Codex app-server harness and model provider plugin with a Codex-managed GPT catalog.",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
       "minHostVersion": ">=2026.5.1-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.6.5-beta.2"
+      "pluginApi": ">=2026.6.5-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.6.5-beta.2"
+      "openclawVersion": "2026.6.5-beta.3"
     },
     "release": {
       "publishToClawHub": true,
@@ -47,7 +47,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.6.5-beta.2"
+    "openclaw": ">=2026.6.5-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {