@openclaw/codex 2026.10.5-beta.4 → 2026.10.10-beta.2

package/dist/.setup/{dynamic-tools-CnQFnNKH.mjs → dynamic-tools-Us5mvq_N.mjs}

@@ -1,21 +1,21 @@
-import { i as isJsonObject, r as flattenCodexDynamicToolFunctions, t as CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE } from "./protocol-CANUwXJ3.mjs";
-import { n as codexSandboxPolicyForTurn } from "./config-options-DDzeNQ8m.mjs";
-import { o as formatCodexDisplayText } from "./command-formatters-xW9KpoSZ.mjs";
-import { o as readItem } from "./event-projector-values-CLvG1Hil.mjs";
-import { s as codexAppIdentityKey } from "./plugin-app-cache-key-Bg9DbDI6.mjs";
-import "./config-C1YVVLEA.mjs";
+import { n as flattenCodexDynamicToolFunctions, r as isJsonObject, t as CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE } from "./protocol-CaPAVwe9.mjs";
+import { n as codexSandboxPolicyForTurn } from "./config-options-DMFZkd3X.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-B_7-QZ1c.mjs";
+import { o as readItem } from "./event-projector-values-yf4us9Pf.mjs";
+import { s as codexAppIdentityKey } from "./plugin-app-cache-key-DRb-niJc.mjs";
+import "./config-BfrAlTMT.mjs";
 import { r as invalidInlineImageText } from "./session-history-read-BI_2jRED.mjs";
-import { o as neutralizeCodexExplicitMentionSigils } from "./context-engine-projection-ps-yn_ci.mjs";
-import { W as protectCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientIfCurrent } from "./shared-client-BCx1wbyA.mjs";
-import { A as createFailedDynamicToolResponse, j as failedToolResult, k as resolveCodexToolAbortTerminalReason, l as CodexServerRequestResolvedError, w as createCodexElicitationResponse, x as readCodexTurnCompletedNotification } from "./client-D93nbdB8.mjs";
+import { o as neutralizeCodexExplicitMentionSigils } from "./context-engine-projection-PIeLSnR-.mjs";
+import { I as protectCodexAppServerLiveThread, p as retainSharedCodexAppServerClientIfCurrent } from "./shared-client-CkyTrNB8.mjs";
+import { A as failedToolResult, C as createCodexElicitationResponse, O as resolveCodexToolAbortTerminalReason, b as readCodexTurnCompletedNotification, c as CodexServerRequestResolvedError, k as createFailedDynamicToolResponse } from "./client--P8jwXvA.mjs";
 import { t as codexWebSocketDataToBuffer } from "./websocket-data-XlRvt8Ys.mjs";
-import { S as shouldClearTerminalPresentationForNativeItem, _ as itemName, a as isCodexNotificationForTurn, c as readCodexNotificationTurnId, d as auditNativeToolUnfinishedStatus, l as auditNativeToolName, s as readCodexNotificationThreadId, u as auditNativeToolTerminalStatus, v as itemStatus } from "./turn-router-DBVMToGo.mjs";
+import { S as shouldClearTerminalPresentationForNativeItem, _ as itemName, a as isCodexNotificationForTurn, c as readCodexNotificationTurnId, d as auditNativeToolUnfinishedStatus, l as auditNativeToolName, s as readCodexNotificationThreadId, u as auditNativeToolTerminalStatus, v as itemStatus } from "./turn-router-BGj67FMK.mjs";
 import { n as resolveCodexAppServerReasoningEffort, t as readCodexSupportedReasoningEfforts } from "./reasoning-effort-CS9kKWB9.mjs";
-import { V as joinPresentSections } from "./thread-requests-BgzJwJtS.mjs";
-import { r as resolveCodexAppServerRequestModelSelection, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-model-selection-DcVebr8N.mjs";
-import { a as requestPluginApprovalOutcome, c as truncateCodexApprovalDisplayText, i as requestPluginApproval, l as waitForPluginApprovalDecision, n as codexApprovalTimeoutText, o as sanitizeCodexApprovalVisibleText, r as mapExecDecisionToOutcome, s as stripDanglingCodexApprovalTerminalSequence, t as approvalRequestExplicitlyUnavailable } from "./plugin-approval-roundtrip-CD88q3yx.mjs";
-import { d as isCodexPassThroughMediaSource, f as mapCodexAppServerLocalWorkspacePath, p as mapCodexAppServerRemoteWorkspacePath } from "./dynamic-tool-build-DcaPmBlE.mjs";
-import { c as emitCodexNativePreToolUseFailureDiagnostic } from "./native-hook-relay-wq7jrNLk.mjs";
+import { V as joinPresentSections } from "./thread-requests-BjawdIVV.mjs";
+import { r as resolveCodexAppServerRequestModelSelection, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-model-selection-DxposL4X.mjs";
+import { a as requestPluginApprovalOutcome, c as truncateCodexApprovalDisplayText, i as requestPluginApproval, l as waitForPluginApprovalDecision, n as codexApprovalTimeoutText, o as sanitizeCodexApprovalVisibleText, r as mapExecDecisionToOutcome, s as stripDanglingCodexApprovalTerminalSequence, t as approvalRequestExplicitlyUnavailable } from "./plugin-approval-roundtrip-CGEiG7hG.mjs";
+import { d as isCodexPassThroughMediaSource, f as mapCodexAppServerLocalWorkspacePath, p as mapCodexAppServerRemoteWorkspacePath } from "./dynamic-tool-build-DOub3CB5.mjs";
+import { c as emitCodexNativePreToolUseFailureDiagnostic } from "./native-hook-relay-CocOW9YS.mjs";
 import { createRequire } from "node:module";
 import { asNonArrayRecord, asOptionalRecord, filterStringEntries, isRecord, normalizeOptionalString, normalizeTrimmedStringList, readNonBlankString, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash, randomUUID } from "node:crypto";
@@ -26,19 +26,19 @@ import { DEFAULT_MAX_LIVE_TOOL_RESULT_CHARS, estimateToolResultTextChars, resolv
 import path, { posix } from "node:path";
 import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { createBoundedRemoteFileReader, isPathStrictlyInside, root } from "openclaw/plugin-sdk/file-access-runtime";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
 import { once } from "node:events";
 import { spawn } from "node:child_process";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { emitTrustedDiagnosticEvent, hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { buildHarnessVisibleReplyGuidance, buildTemporalContextText, captureToolAuthoredSourceReply, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractMessagingToolSend, extractMessagingToolSendResult, finalizeAgentToolAvailability, finalizeToolTerminalPresentation, formatApprovalDisplayPath, formatToolExecutionErrorMessage, getBeforeToolCallFailureDisposition, getChannelAgentToolMeta, getPluginToolMeta, getPluginToolSideEffectOwnerKey, hasNativeHookRelayInvocation, invokeNativeHookRelay, isDeliveredMessageToolOnlySourceReplyResult, isDeliveredMessagingToolResult, isDeliveredMessagingToolSendToCurrentSource, isMessagingTool, isReplaySafeToolCall, isToolResultError, isToolWrappedWithBeforeToolCallHook, projectPluginMessageDeliveryFact, projectRuntimeToolInputSchema, readEmbeddedMessageDeliveryFact, readToolOperatorHint, resolveNativeHookRelayDeferredToolApproval, resolveToolExecutionErrorKind, runAgentHarnessAfterToolCallHook, sanitizeToolResult, setBeforeToolCallDiagnosticsEnabled, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { sanitizeInlineImageDataUrl } from "openclaw/plugin-sdk/inline-image-data-url-runtime";
-import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
-import { formatErrorMessage as formatErrorMessage$2, redactSensitiveText as redactSensitiveText$1 } from "openclaw/plugin-sdk/security-runtime";
+import { formatErrorMessage as formatErrorMessage$2, redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
 import { collectAgentHarnessMessagingMediaUrls, copyInternalToolResultState, createAgentHarnessToolExecutionBoundaryRegistry, extractMessagingToolSourceReplyPayload, getCoreTtsToolResultMediaUrls, mapAgentHarnessMessagingMediaValues, normalizeAcceptedSessionSpawnResult, recordAgentHarnessToolResultTelemetry, runAgentHarnessToolInvocation } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
 import { isIP } from "node:net";
+import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { SANDBOX_COMMAND_MAX_BUFFER_BYTES, buildRemoteCommand, prepareSandboxProcessCleanup, sanitizeEnvVars } from "openclaw/plugin-sdk/sandbox";
 import { formatMcpCodexApprovalRemedy, requiresMcpCodexToolApproval, resolveProjectedMcpCodexToolApprovalMode } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { SsrFBlockedError, isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
@@ -423,6 +423,13 @@ function invalidateCodexComputerFrame(contextEpoch) {
 	delete contextEpoch.frameToolCallId;
 	delete contextEpoch.frameImageIdentity;
 }
+function computerFrameImageIdentity(content) {
+	if (!Array.isArray(content)) return;
+	const images = content.filter((block) => block.type === "image");
+	if (images.length !== 1) return;
+	const image = expectDefined(images[0], "single Codex computer frame image");
+	return createHash("sha256").update(JSON.stringify([image.mimeType, image.data])).digest("hex");
+}
 //#endregion
 //#region extensions/codex/src/app-server/user-input.ts
 /** Builds ordered Codex user input for both new turns and same-turn steering. */
@@ -765,8 +772,8 @@ function buildCodexHistoryProvenancePrefix(params) {
 	const sender = readCodexCurrentSender(params);
 	return sender?.id ? neutralizeCodexExplicitMentionSigils(`[OpenClaw conversation info: sender=${JSON.stringify(sender)}]\n`) : void 0;
 }
-function buildTurnStartParams(params, options) {
-	const modelSelection = options.preserveNativeTurnSettings ? void 0 : resolveCodexAppServerRequestModelSelection({
+async function buildTurnStartParams(params, options) {
+	const modelSelection = options.preserveNativeTurnSettings ? void 0 : await resolveCodexAppServerRequestModelSelection({
 		homeScope: options.appServer.start.homeScope,
 		model: options.model ?? params.modelId,
 		modelProvider: options.modelProvider,
@@ -926,7 +933,7 @@ var CodexNodeExecServerDisconnectedError = class extends Error {
 };
 /** Produces the bounded, redacted terminal failure shared by pending and claimed node leases. */
 function createCodexNodeExecServerDisconnectError(reason, cause) {
-	return new CodexNodeExecServerDisconnectedError(`Codex execution node disconnected; start a fresh attempt. (${reason}${cause === void 0 ? "" : `: ${truncateUtf16Safe(redactSensitiveText$1(formatErrorMessage$2(cause), { mode: "tools" }), CODEX_NODE_EXEC_SERVER_MAX_FAILURE_DETAIL_CHARS)}`})`);
+	return new CodexNodeExecServerDisconnectedError(`Codex execution node disconnected; start a fresh attempt. (${reason}${cause === void 0 ? "" : `: ${truncateUtf16Safe(redactSensitiveText(formatErrorMessage$2(cause), { mode: "tools" }), CODEX_NODE_EXEC_SERVER_MAX_FAILURE_DETAIL_CHARS)}`})`);
 }
 /** Relays one authorized, single-use Codex exec-server channel without interpreting its protocol. */
 async function startCodexNodeExecServerRelay(params) {
@@ -1193,6 +1200,9 @@ const sandboxExecServerRegistry = {
 				lease.channel.close();
 			}
 			server.node.leases.clear();
+		} else {
+			for (const { unsubscribe } of server.processAuthorities?.values() ?? []) unsubscribe();
+			server.processAuthorities?.clear();
 		}
 		for (const client of server.server.clients) client.close(1001, "shutdown");
 		await new Promise((resolve) => {
@@ -1352,7 +1362,7 @@ function resolveFsSandboxEntry(entry, cwd) {
 		return {
 			kind: "glob",
 			pattern: absolutePattern,
-			matcher: compileSandboxGlobPattern(absolutePattern),
+			matcher: compileSandboxGlobMatcher(absolutePattern),
 			literalPrefix: sandboxGlobLiteralPrefix(absolutePattern),
 			access
 		};
@@ -1386,7 +1396,7 @@ function resolveFsAccess(policy, rawPath) {
 	const target = normalizeSandboxAbsolutePath(rawPath, "fs path");
 	let selected;
 	for (const entry of policy.entries) {
-		if (!(entry.kind === "path" ? pathContains(entry.path, target) : entry.matcher.test(target))) continue;
+		if (!(entry.kind === "path" ? pathContains(entry.path, target) : entry.matcher(target))) continue;
 		const candidate = {
 			specificity: (entry.kind === "path" ? entry.path : entry.literalPrefix).split("/").filter(Boolean).length,
 			rank: FS_ACCESS_RANK[entry.access],
@@ -1423,27 +1433,285 @@ function normalizeSandboxGlobPattern(pattern) {
 	if (!pattern || pattern.includes("\0") || !pattern.startsWith("/")) throw new Error("fs sandbox glob pattern must be absolute.");
 	return pattern.replace(/\/{2,}/gu, "/");
 }
-function compileSandboxGlobPattern(pattern) {
-	let source = "^";
+function compileSandboxGlobLiteral(text) {
+	const points = Array.from(text);
+	const fallback = Array.from({ length: points.length }, () => 0);
+	let matched = 0;
+	for (let index = 1; index < points.length; index += 1) {
+		while (matched > 0 && points[index] !== points[matched]) matched = fallback[matched - 1] ?? 0;
+		if (points[index] === points[matched]) matched += 1;
+		fallback[index] = matched;
+	}
+	return {
+		kind: "literal",
+		points,
+		fallback
+	};
+}
+function tokenizeSandboxGlobPattern(pattern) {
+	const tokens = [];
+	let literal = "";
+	const flushLiteral = () => {
+		if (literal) {
+			tokens.push(compileSandboxGlobLiteral(literal));
+			literal = "";
+		}
+	};
 	for (let index = 0; index < pattern.length; index += 1) {
 		const char = pattern[index];
 		const next = pattern[index + 1];
 		if (char === "*" && next === "*" && pattern[index + 2] === "/") {
-			source += "(?:.*/)?";
+			flushLiteral();
+			tokens.push({ kind: "globstarSlash" });
 			index += 2;
 		} else if (char === "*" && next === "*") {
-			source += ".*";
+			flushLiteral();
+			tokens.push({ kind: "globstar" });
 			index += 1;
-		} else if (char === "*") source += "[^/]*";
-		else if (char === "?") source += "[^/]";
-		else if (char === "[") {
+		} else if (char === "*") {
+			flushLiteral();
+			tokens.push({ kind: "star" });
+		} else if (char === "?") {
+			flushLiteral();
+			tokens.push({
+				kind: "single",
+				matches: (targetChar) => targetChar !== "/"
+			});
+		} else if (char === "[") {
+			flushLiteral();
 			const compiledClass = compileSandboxGlobCharacterClass(pattern, index);
-			source += compiledClass.source;
+			const classPattern = new RegExp(compiledClass.source, "u");
+			tokens.push({
+				kind: "single",
+				matches: (targetChar) => classPattern.test(targetChar)
+			});
 			index = compiledClass.endIndex;
-		} else source += char?.replace(/[\\^$+?.()|[\]{}]/gu, "\\$&") ?? "";
+		} else literal += char ?? "";
+	}
+	flushLiteral();
+	return tokens;
+}
+function isSandboxGlobLineTerminator(point) {
+	return point === "\n" || point === "\r" || point === "\u2028" || point === "\u2029";
+}
+function firstLineTerminatorAtOrAfter(target, index) {
+	let low = 0;
+	let high = target.lineTerminators.length;
+	while (low < high) {
+		const mid = low + high >> 1;
+		if ((target.lineTerminators[mid] ?? 0) < index) low = mid + 1;
+		else high = mid;
+	}
+	return low < target.lineTerminators.length ? target.lineTerminators[low] ?? 0 : target.points.length;
+}
+function createSandboxGlobTarget(url) {
+	const points = Array.from(url);
+	const slashFollows = [];
+	const lineTerminators = [];
+	for (let index = 0; index < points.length; index += 1) {
+		const point = points[index] ?? "";
+		if (point === "/") slashFollows.push(index + 1);
+		else if (isSandboxGlobLineTerminator(point)) lineTerminators.push(index);
+	}
+	const slashFollowRanges = [];
+	for (const follow of slashFollows) {
+		const last = slashFollowRanges.at(-1);
+		if (last !== void 0 && follow === last.end + 1) last.end = follow;
+		else slashFollowRanges.push({
+			start: follow,
+			end: follow
+		});
 	}
-	source += "$";
-	return new RegExp(source, "u");
+	return {
+		points,
+		slashFollowRanges,
+		lineTerminators
+	};
+}
+function mergeSortedSandboxGlobRanges(left, right) {
+	const merged = [];
+	let leftIndex = 0;
+	let rightIndex = 0;
+	while (leftIndex < left.length || rightIndex < right.length) {
+		const leftRange = left[leftIndex];
+		const rightRange = right[rightIndex];
+		const range = rightRange === void 0 || leftRange !== void 0 && (leftRange.start < rightRange.start || leftRange.start === rightRange.start && leftRange.end <= rightRange.end) ? leftRange : rightRange;
+		if (range === void 0) break;
+		if (range === leftRange) leftIndex += 1;
+		else rightIndex += 1;
+		const last = merged.at(-1);
+		if (last !== void 0 && range.start <= last.end + 1) {
+			if (range.end > last.end) last.end = range.end;
+		} else merged.push({
+			start: range.start,
+			end: range.end
+		});
+	}
+	return merged;
+}
+function mergeSandboxGlobRanges(ranges) {
+	if (ranges.length === 0) return [];
+	const sorted = ranges.toSorted((left, right) => left.start - right.start || left.end - right.end);
+	const merged = [];
+	for (const range of sorted) {
+		const last = merged.at(-1);
+		if (last !== void 0 && range.start <= last.end + 1) {
+			if (range.end > last.end) last.end = range.end;
+			continue;
+		}
+		merged.push({
+			start: range.start,
+			end: range.end
+		});
+	}
+	return merged;
+}
+function literalSandboxGlobRanges(target, literal, ranges) {
+	const next = [];
+	const first = ranges[0];
+	const last = ranges.at(-1);
+	if (!first || !last) return next;
+	const limit = Math.min(target.points.length, last.end + literal.points.length);
+	let matched = 0;
+	let rangeIndex = 0;
+	for (let pos = first.start; pos < limit; pos += 1) {
+		const point = target.points[pos];
+		while (matched > 0 && point !== literal.points[matched]) matched = literal.fallback[matched - 1] ?? 0;
+		if (point === literal.points[matched]) matched += 1;
+		if (matched !== literal.points.length) continue;
+		const start = pos + 1 - matched;
+		matched = literal.fallback[matched - 1] ?? 0;
+		while (rangeIndex < ranges.length && (ranges[rangeIndex]?.end ?? -1) < start) rangeIndex += 1;
+		const range = ranges[rangeIndex];
+		if (!range || start < range.start) continue;
+		const previous = next.at(-1);
+		if (previous && previous.end === pos) previous.end = pos + 1;
+		else next.push({
+			start: pos + 1,
+			end: pos + 1
+		});
+	}
+	return next;
+}
+function starSandboxGlobRanges(points, ranges) {
+	const next = [];
+	let coveredThrough = -1;
+	for (const range of mergeSandboxGlobRanges(ranges.map((item) => ({
+		start: item.start,
+		end: item.end
+	})))) {
+		let cursor = range.start;
+		if (cursor <= coveredThrough) cursor = coveredThrough + 1;
+		while (cursor <= range.end) {
+			let far = cursor;
+			while (far < points.length && points[far] !== "/") far += 1;
+			next.push({
+				start: cursor,
+				end: far
+			});
+			coveredThrough = far;
+			if (far >= range.end) break;
+			cursor = far + 1;
+		}
+	}
+	return mergeSandboxGlobRanges(next);
+}
+function globstarSandboxGlobRanges(target, ranges) {
+	const next = [];
+	for (const range of ranges) next.push({
+		start: range.start,
+		end: firstLineTerminatorAtOrAfter(target, range.end)
+	});
+	return mergeSandboxGlobRanges(next);
+}
+function globstarSlashSandboxGlobRanges(target, ranges) {
+	const follows = target.slashFollowRanges;
+	const next = [];
+	const emitted = [];
+	let followIndex = 0;
+	const sortedRanges = ranges.toSorted((left, right) => left.start - right.start || left.end - right.end);
+	for (const range of sortedRanges) {
+		next.push({
+			start: range.start,
+			end: range.end
+		});
+		const bound = firstLineTerminatorAtOrAfter(target, range.end);
+		while (followIndex < follows.length) {
+			const follow = follows[followIndex];
+			if (follow === void 0 || follow.start > range.start) break;
+			followIndex += 1;
+		}
+		while (followIndex < follows.length) {
+			const follow = follows[followIndex];
+			if (follow === void 0 || follow.start > bound) break;
+			emitted.push({
+				start: follow.start,
+				end: follow.end
+			});
+			followIndex += 1;
+		}
+	}
+	return mergeSortedSandboxGlobRanges(next, emitted);
+}
+function singleSandboxGlobRanges(points, ranges, matches) {
+	const next = [];
+	for (const range of ranges) {
+		let runStart = -1;
+		let runEnd = -1;
+		const last = Math.min(range.end, points.length - 1);
+		for (let pos = range.start; pos <= last; pos += 1) {
+			const point = points[pos];
+			if (point === void 0 || !matches(point)) continue;
+			const at = pos + 1;
+			if (runStart < 0) {
+				runStart = at;
+				runEnd = at;
+			} else if (at === runEnd + 1) runEnd = at;
+			else {
+				next.push({
+					start: runStart,
+					end: runEnd
+				});
+				runStart = at;
+				runEnd = at;
+			}
+		}
+		if (runStart >= 0) next.push({
+			start: runStart,
+			end: runEnd
+		});
+	}
+	return mergeSandboxGlobRanges(next);
+}
+function matchSandboxGlobTokens(url, tokens) {
+	const target = createSandboxGlobTarget(url);
+	let ranges = [{
+		start: 0,
+		end: 0
+	}];
+	for (let index = 0; index < tokens.length; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === "literal") ranges = literalSandboxGlobRanges(target, token, ranges);
+		else if (token.kind === "star") ranges = starSandboxGlobRanges(target.points, ranges);
+		else if (token.kind === "globstar") ranges = globstarSandboxGlobRanges(target, ranges);
+		else if (token.kind === "globstarSlash") {
+			ranges = globstarSlashSandboxGlobRanges(target, ranges);
+			while (tokens[index + 1]?.kind === "globstarSlash") index += 1;
+		} else ranges = singleSandboxGlobRanges(target.points, ranges, token.matches);
+		if (ranges.length === 0) return false;
+	}
+	return ranges.some((range) => range.start <= target.points.length && target.points.length <= range.end);
+}
+/**
+* Compiles a Codex sandbox glob into a linear matcher. The sandbox context is
+* model-session output and the target path is model-requested, so the matcher
+* must stay free of catastrophic backtracking: each token advances cursor
+* ranges in one pass instead of letting a regex retry overlapping quantifiers.
+*/
+function compileSandboxGlobMatcher(pattern) {
+	const tokens = tokenizeSandboxGlobPattern(pattern);
+	return (target) => matchSandboxGlobTokens(target, tokens);
 }
 function compileSandboxGlobCharacterClass(pattern, startIndex) {
 	let index = startIndex + 1;
@@ -2881,8 +3149,14 @@ async function ensureCodexSandboxExecServerEnvironment(params) {
 	if (processAuthority && !("node" in execServer)) {
 		const authorities = execServer.processAuthorities ??= /* @__PURE__ */ new Map();
 		if (!authorities.has(processAuthority.authPath)) {
-			authorities.set(processAuthority.authPath, processAuthority);
-			params.client.addCloseHandler(() => authorities.delete(processAuthority.authPath));
+			const unsubscribe = params.client.addCloseHandler(() => {
+				unsubscribe();
+				authorities.delete(processAuthority.authPath);
+			});
+			authorities.set(processAuthority.authPath, {
+				authority: processAuthority,
+				unsubscribe
+			});
 		}
 	}
 	const environmentId = nodeLease ? `openclaw-node-${nodeLease.id}` : processAuthority ? `${execServer.environmentId}-${processAuthority.id}` : execServer.environmentId;
@@ -3058,7 +3332,7 @@ async function startOpenClawExecServer(sandbox) {
 			handleNodeConnection(execServer, socket, requestUrl);
 			return;
 		}
-		handleConnection(execServer, socket, execServer.processAuthorities?.get(requestUrl.pathname));
+		handleConnection(execServer, socket, execServer.processAuthorities?.get(requestUrl.pathname)?.authority);
 	});
 	embeddedAgentLog.info("codex sandbox exec-server started", {
 		environmentId,
@@ -4480,29 +4754,7 @@ function createCodexDynamicToolSpecs(params) {
 function projectCodexDynamicTools(tools) {
 	const projectedTools = [];
 	const quarantinedTools = [];
-	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;
-		}
+	for (const [toolIndex, tool] of tools.entries()) {
 		const descriptor = readCodexDynamicToolDescriptor(tool, toolIndex);
 		if ("diagnostic" in descriptor) {
 			quarantinedTools.push(descriptor.diagnostic);
@@ -4608,38 +4860,10 @@ function finalizeCodexToolAvailability(entries) {
 //#region extensions/codex/src/app-server/dynamic-tool-content.ts
 function enforceWholeSkillResult(toolName, result, maxChars) {
 	if (toolName !== "skills_read" || isToolResultError(result)) return result;
-	return sanitizeToolTextRuns(result.content).reduce((total, item) => total + (item.type === "text" ? estimateToolResultTextChars(item.text) : 0), 0) <= maxChars ? result : failedToolResult(`This Codex turn cannot deliver the whole skill within its ${maxChars}-character weighted output budget. No instructions were returned; use a harness with a larger instruction budget.`);
-}
-function sanitizeToolTextRuns(rawContent) {
-	const content = [];
-	for (let index = 0; index < rawContent.length;) {
-		const item = rawContent[index];
-		if (item.type !== "text") {
-			content.push(item);
-			index += 1;
-			continue;
-		}
-		const textRun = [];
-		while (index < rawContent.length) {
-			const next = rawContent[index];
-			if (next.type !== "text") break;
-			textRun.push(next);
-			index += 1;
-		}
-		const sanitizedText = sanitizeToolResult(textRun.map((entry) => entry.text).join(""));
-		let offset = 0;
-		content.push(...textRun.map((entry, runIndex) => {
-			const targetEnd = runIndex === textRun.length - 1 ? sanitizedText.length : Math.min(sanitizedText.length, offset + entry.text.length);
-			const text = sliceUtf16Safe(sanitizedText, offset, targetEnd);
-			const sanitized = Object.assign({}, entry, { text });
-			offset += text.length;
-			return sanitized;
-		}));
-	}
-	return content;
+	return result.content.reduce((total, item) => total + (item.type === "text" ? estimateToolResultTextChars(item.text) : 0), 0) <= maxChars ? result : failedToolResult(`This Codex turn cannot deliver the whole skill within its ${maxChars}-character weighted output budget. No instructions were returned; use a harness with a larger instruction budget.`);
 }
 function convertToolContents(rawContent, maxChars) {
-	const content = sanitizeToolTextRuns(rawContent);
+	const content = rawContent;
 	const totalTextChars = content.reduce((total, item) => total + (item.type === "text" ? item.text.length : 0), 0);
 	if (content.reduce((total, item) => total + (item.type === "text" ? estimateToolResultTextChars(item.text) : 0), 0) <= maxChars) return content.map(convertToolContent);
 	const noticeText = `...(OpenClaw truncated dynamic tool result: original ${totalTextChars} chars, weighted budget ${maxChars}; rerun with narrower args.)`;
@@ -4723,31 +4947,44 @@ function projectCodexExecutableDynamicToolSurface(tools, hookContext) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/dynamic-tool-source-reply.ts
+function applyCurrentMessageProvider(toolName, args, currentProvider) {
+	const hasProvider = typeof args.provider === "string" && args.provider.trim().length > 0 || typeof args.channel === "string" && args.channel.trim().length > 0;
+	const provider = currentProvider?.trim();
+	if (toolName !== "message" || hasProvider || !provider) return args;
+	return {
+		...args,
+		provider
+	};
+}
 /**
 * Resolves the source-reply facts of one Codex dynamic tool result and records whether
 * it ends the Codex turn on `response`. A final reply
 * authored by a `canDeliverSourceReply` tool, read from the result after middleware and
-* extensions, is appended to `payloads`; the host delivers it and writes its transcript
-* row after the send. Only calls in the model-only namespace qualify: Codex never
-* exposes that namespace to Code Mode programs, so a program's intermediate call
+* extensions, stays on the response until batch settlement. The host delivers it
+* and writes its transcript row after the send. Only calls in the model-only
+* namespace qualify: Codex never exposes that namespace to Code Mode programs,
+* so a program's intermediate call
 * cannot end the turn or reach the conversation.
 */
 function resolveCodexToolResultSourceReply(params) {
-	const messageToolOnly = params.sourceReplyDeliveryMode === "message_tool_only" && params.toolName === "message";
-	const toolConfirmed = messageToolOnly && !params.resultIsError && (params.rawResult.terminate === true || params.result.terminate === true);
-	const confirmed = messageToolOnly && (toolConfirmed || params.deliveredSourceReply);
+	const messageTool = params.toolName === "message";
+	const toolConfirmed = messageTool && !params.resultIsError && (params.rawResult.terminate === true || params.result.terminate === true);
+	const confirmed = messageTool && (toolConfirmed || params.deliveredSourceReply);
 	const final = confirmed ? params.executedArgs.final !== false : void 0;
 	const payload = params.canDeliverSourceReply === true && !params.resultIsError && params.call.namespace === "openclaw_direct" ? captureToolAuthoredSourceReply({
 		result: params.result,
 		toolCallId: params.call.callId,
 		idempotencyScope: params.runId ?? params.call.turnId
 	}) : void 0;
-	if (payload) params.payloads.push(payload);
 	const toolAuthoredFinal = Boolean(payload);
 	const continuesSourceReplyProgress = confirmed && final === false;
 	const terminate = toolAuthoredFinal || (params.rawResult.terminate === true || params.result.terminate === true) && !continuesSourceReplyProgress || [params.rawResult, params.result].some(({ details }) => isRecord(details) && typeof details.status === "string" && details.status.trim().toLowerCase() === "yielded") || confirmed && final === true || void 0;
 	params.response.terminate = terminate;
-	if (toolAuthoredFinal) params.response.toolAuthoredFinalReply = true;
+	params.response.finalSourceReplyDelivered = params.deliveredSourceReply && final === true || void 0;
+	if (payload) params.response.toolAuthoredSourceReply = {
+		...payload,
+		toolAuthoredForTurnId: params.call.turnId
+	};
 	return {
 		toolConfirmed,
 		final,
@@ -4775,22 +5012,6 @@ function assertCodexDynamicToolInputMatchesSchema(params) {
 	const omittedSuffix = omitted > 0 ? `; ${omitted} more violation(s) omitted` : "";
 	throw new Error(`Invalid arguments for tool "${params.toolName}": ${details}${omittedSuffix}.`);
 }
-function applyCurrentMessageProvider(toolName, args, currentProvider) {
-	const hasProvider = typeof args.provider === "string" && args.provider.trim().length > 0 || typeof args.channel === "string" && args.channel.trim().length > 0;
-	const provider = currentProvider?.trim();
-	if (toolName !== "message" || hasProvider || !provider) return args;
-	return {
-		...args,
-		provider
-	};
-}
-function computerFrameImageIdentity(content) {
-	if (!Array.isArray(content)) return;
-	const images = content.filter((block) => block.type === "image");
-	if (images.length !== 1) return;
-	const image = expectDefined(images[0], "single Codex computer frame image");
-	return createHash("sha256").update(JSON.stringify([image.mimeType, image.data])).digest("hex");
-}
 function createCodexDynamicToolBridge(params) {
 	const toolResultHookContext = toToolResultHookContext(params.hookContext);
 	const contextWindowTokens = params.hookContext?.contextWindowTokens;
@@ -4919,6 +5140,7 @@ function createCodexDynamicToolBridge(params) {
 			let messagingFacts;
 			let executedArgsForPresentation = args;
 			let rawIsErrorForPresentation = false;
+			let finalSourceReplyDelivered = false;
 			let telemetryRawResultForPresentation;
 			let presentationIsError = false;
 			return runAgentHarnessToolInvocation({
@@ -4933,6 +5155,7 @@ function createCodexDynamicToolBridge(params) {
 				runId: toolResultHookContext.runId,
 				startedAt: invocationStartedAt,
 				signal,
+				assertCurrent: params.assertCurrent,
 				boundaries: executionBoundaries,
 				retainExecutionSnapshot: options?.retainExecutionSnapshot,
 				initialArguments: args,
@@ -4951,7 +5174,8 @@ function createCodexDynamicToolBridge(params) {
 					});
 					return toolArgsRecord;
 				},
-				beforeExecute: () => {
+				beforeExecute: async () => {
+					await params.assertCurrentAsync?.();
 					messagingContext = {
 						config: params.hookContext?.config,
 						currentChannelId: params.hookContext?.currentChannelId,
@@ -5001,6 +5225,8 @@ function createCodexDynamicToolBridge(params) {
 							deliveredPayload: rawResult
 						})
 					});
+					finalSourceReplyDelivered = deliveredSourceReply && executedArgs.final !== false;
+					telemetry.finalSourceReplyDelivered ||= finalSourceReplyDelivered || void 0;
 					if (toolName === "message" && messageDelivery?.sourceReplyDelivered) telemetry.sourceReplyDelivered = true;
 					messagingFacts = {
 						messagingDelivered,
@@ -5063,7 +5289,6 @@ function createCodexDynamicToolBridge(params) {
 						transcriptDetails: asOptionalRecord(sanitizeToolResult(result))?.details
 					};
 					const sourceReply = resolveCodexToolResultSourceReply({
-						sourceReplyDeliveryMode: params.hookContext?.sourceReplyDeliveryMode,
 						canDeliverSourceReply: toolEntry.tool.canDeliverSourceReply,
 						toolName,
 						call,
@@ -5073,7 +5298,6 @@ function createCodexDynamicToolBridge(params) {
 						deliveredSourceReply,
 						executedArgs,
 						runId: toolResultHookContext.runId,
-						payloads: telemetry.messagingToolSourceReplyPayloads,
 						response
 					});
 					const autoDeliveryTtsMediaUrls = getCoreTtsToolResultMediaUrls(rawResult);
@@ -5137,7 +5361,9 @@ function createCodexDynamicToolBridge(params) {
 						executedArguments: executedArgs,
 						executionStarted: executionBoundary.executionStarted,
 						replaySafe,
-						sideEffectEvidence: executionBoundary.didStartExecution && !replaySafe || void 0
+						sideEffectEvidence: executionBoundary.didStartExecution && !replaySafe || void 0,
+						terminate: finalSourceReplyDelivered || void 0,
+						finalSourceReplyDelivered: finalSourceReplyDelivered || void 0
 					};
 				}
 			});