@openclaw/codex 2026.5.20-beta.2 → 2026.5.22

package/dist/{client-Ab4Fw77C.js → client-D3SUwPFl.js}

@@ -1,9 +1,9 @@
-import { c as resolveCodexAppServerRuntimeOptions } from "./config-DqIp6oTk.js";
+import { l as resolveCodexAppServerRuntimeOptions } from "./config-DDMrwfJl.js";
 import { n as isRpcResponse } from "./protocol-oeJQu4rs.js";
-import { createInterface } from "node:readline";
+import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { createInterface } from "node:readline";
 import { spawn } from "node:child_process";
-import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import WebSocket from "ws";
@@ -193,6 +193,7 @@ function signalCodexAppServerTransport(child, signal) {
 //#endregion
 //#region extensions/codex/src/app-server/version.ts
 const MIN_CODEX_APP_SERVER_VERSION = "0.125.0";
+const MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION = "0.132.0";
 const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
 //#endregion
 //#region extensions/codex/src/app-server/client.ts
@@ -271,17 +272,21 @@ var CodexAppServerClient = class CodexAppServerClient {
 	}
 	async initialize() {
 		if (this.initialized) return;
-		assertSupportedCodexAppServerVersion(await this.request("initialize", {
+		const response = await this.request("initialize", {
 			clientInfo: {
 				name: "openclaw",
 				title: "OpenClaw",
 				version: OPENCLAW_VERSION
 			},
 			capabilities: { experimentalApi: true }
-		}));
+		});
+		this.serverVersion = assertSupportedCodexAppServerVersion(response);
 		this.notify("initialized");
 		this.initialized = true;
 	}
+	getServerVersion() {
+		return this.serverVersion;
+	}
 	request(method, params, options) {
 		options ??= {};
 		if (this.closed) return Promise.reject(this.closeError ?? /* @__PURE__ */ new Error("codex app-server client is closed"));
@@ -568,12 +573,13 @@ function timeoutServerRequestResponse(request) {
 function assertSupportedCodexAppServerVersion(response) {
 	const detectedVersion = readCodexVersionFromUserAgent(response.userAgent);
 	if (!detectedVersion) throw new Error(`Codex app-server ${MIN_CODEX_APP_SERVER_VERSION} or newer is required, but OpenClaw could not determine the running Codex version. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
-	if (compareVersions(detectedVersion, "0.125.0") < 0) throw new Error(`Codex app-server ${MIN_CODEX_APP_SERVER_VERSION} or newer is required, but detected ${detectedVersion}. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
+	if (compareCodexAppServerVersions(detectedVersion, "0.125.0") < 0) throw new Error(`Codex app-server ${MIN_CODEX_APP_SERVER_VERSION} or newer is required, but detected ${detectedVersion}. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
+	return detectedVersion;
 }
 function readCodexVersionFromUserAgent(userAgent) {
 	return (userAgent?.match(/^[^/]+\/(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)(?:[\s(]|$)/))?.[1];
 }
-function compareVersions(left, right) {
+function compareCodexAppServerVersions(left, right) {
 	const leftVersion = parseVersionForComparison(left);
 	const rightVersion = parseVersionForComparison(right);
 	const leftParts = leftVersion.parts;
@@ -639,4 +645,4 @@ function formatExitValue(value) {
 	return "unknown";
 }
 //#endregion
-export { MANAGED_CODEX_APP_SERVER_PACKAGE as a, isCodexAppServerConnectionClosedError as i, CodexAppServerRpcError as n, resolveCodexAppServerSpawnEnv as o, isCodexAppServerApprovalRequest as r, CodexAppServerClient as t };
+export { isCodexAppServerConnectionClosedError as a, resolveCodexAppServerSpawnEnv as c, isCodexAppServerApprovalRequest as i, CodexAppServerRpcError as n, MANAGED_CODEX_APP_SERVER_PACKAGE as o, compareCodexAppServerVersions as r, MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION as s, CodexAppServerClient as t };

package/dist/{client-factory-BbesECdh.js → client-factory-DdrIY1lw.js}

@@ -1,5 +1,5 @@
 //#region extensions/codex/src/app-server/client-factory.ts
-const defaultCodexAppServerClientFactory = (startOptions, authProfileId, agentDir, config) => import("./shared-client-DCxJx5QU.js").then((n) => n.a).then(({ getSharedCodexAppServerClient }) => getSharedCodexAppServerClient({
+const defaultCodexAppServerClientFactory = (startOptions, authProfileId, agentDir, config) => import("./shared-client-C_RbGxW8.js").then((n) => n.a).then(({ getSharedCodexAppServerClient }) => getSharedCodexAppServerClient({
 	startOptions,
 	authProfileId,
 	agentDir,

package/dist/{command-handlers-Gceg_rBZ.js → command-handlers-DsB0GYd2.js}

@@ -1,11 +1,12 @@
-import { a as isCodexFastServiceTier, c as resolveCodexAppServerRuntimeOptions } from "./config-DqIp6oTk.js";
-import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-C8MdOXGD.js";
+import { a as isCodexFastServiceTier, l as resolveCodexAppServerRuntimeOptions } from "./config-DDMrwfJl.js";
+import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-B_uo1pf5.js";
 import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
-import { i as describeControlFailure, r as CODEX_CONTROL_METHODS, t as requestCodexAppServerJson } from "./request-BePR77QD.js";
-import { a as formatComputerUseStatus, c as formatThreads, i as formatCodexStatus, l as readString$1, n as formatAccount, o as formatList, p as summarizeCodexAccountUsage, r as formatCodexDisplayText, s as formatModels, t as buildHelp } from "./command-formatters-BVBnEgyA.js";
-import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-DEiYHgJ_.js";
-import { _ as steerCodexConversationTurn, b as readCodexConversationBindingData, d as parseCodexFastModeArg, f as parseCodexPermissionsModeArg, g as setCodexConversationPermissions, h as setCodexConversationModel, l as startCodexConversationThread, m as setCodexConversationFastMode, p as readCodexConversationActiveTurn, r as formatCodexCliSessions, u as formatPermissionsMode, v as stopCodexConversationTurn, x as resolveCodexDefaultWorkspaceDir, y as createCodexCliNodeConversationBindingData } from "./node-cli-sessions-T1olB1SH.js";
-import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-B4iTog6z.js";
+import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-Bw_mfIW2.js";
+import { i as describeControlFailure, r as CODEX_CONTROL_METHODS, t as requestCodexAppServerJson } from "./request-NklFaHM4.js";
+import { _ as summarizeCodexAccountUsage, a as buildHelp, c as formatCodexStatus, d as formatModels, f as formatThreads, l as formatComputerUseStatus, o as formatAccount, p as readString$1, s as formatCodexDisplayText, u as formatList } from "./notification-correlation-qKY_sgga.js";
+import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-CTnEWuor.js";
+import { _ as steerCodexConversationTurn, b as readCodexConversationBindingData, d as parseCodexFastModeArg, f as parseCodexPermissionsModeArg, g as setCodexConversationPermissions, h as setCodexConversationModel, l as startCodexConversationThread, m as setCodexConversationFastMode, p as readCodexConversationActiveTurn, r as formatCodexCliSessions, u as formatPermissionsMode, v as stopCodexConversationTurn, x as resolveCodexDefaultWorkspaceDir, y as createCodexCliNodeConversationBindingData } from "./node-cli-sessions-yVCifOyG.js";
+import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-BMMwWwno.js";
 import { n as rememberCodexRateLimits } from "./rate-limit-cache-N66I-Rd7.js";
 import crypto from "node:crypto";
 import { ensureAuthProfileStore, findNormalizedProviderValue, resolveAgentDir, resolveAuthProfileEligibility, resolveAuthProfileOrder, resolveDefaultAgentDir, resolveProfileUnusableUntilForDisplay, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
@@ -398,6 +399,8 @@ async function codexControlRequest(pluginConfig, method, requestParams, options
 		timeoutMs: runtime.requestTimeoutMs,
 		startOptions: runtime.start,
 		config: options.config,
+		sessionKey: options.sessionKey,
+		sessionId: options.sessionId,
 		authProfileId: options.authProfileId,
 		agentDir: options.agentDir,
 		isolated: options.isolated
@@ -477,6 +480,16 @@ const CODEX_DIAGNOSTICS_CONFIRMATION_MAX_REQUESTS_PER_SCOPE = 100;
 const CODEX_DIAGNOSTICS_CONFIRMATION_MAX_SCOPES = 100;
 const CODEX_DIAGNOSTICS_SCOPE_FIELD_MAX_CHARS = 128;
 const CODEX_RESUME_SAFE_THREAD_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
+const CODEX_NATIVE_EXECUTION_SUBCOMMANDS = new Set([
+	"bind",
+	"resume",
+	"steer",
+	"model",
+	"fast",
+	"permissions",
+	"compact",
+	"review"
+]);
 const lastCodexDiagnosticsUploadByThread = /* @__PURE__ */ new Map();
 const lastCodexDiagnosticsUploadByScope = /* @__PURE__ */ new Map();
 const pendingCodexDiagnosticsConfirmations = /* @__PURE__ */ new Map();
@@ -489,6 +502,8 @@ async function handleCodexSubcommand(ctx, options) {
 	const [subcommand = "status", ...rest] = splitArgs(ctx.args);
 	const normalized = subcommand.toLowerCase();
 	if (normalized === "help") return { text: buildHelp() };
+	const sandboxBlock = resolveCodexNativeCommandSandboxBlock(ctx, normalized, rest);
+	if (sandboxBlock) return { text: sandboxBlock };
 	if (normalized === "plugins") {
 		if (!deps.codexPluginsManagementIo) return { text: "Codex sub-plugin management is not wired up (codexPluginsManagementIo dep is undefined). Edit ~/.openclaw/openclaw.json or use `openclaw config patch` until the runtime exposes the IO." };
 		return await handleCodexPluginsSubcommand(ctx, rest, deps.codexPluginsManagementIo);
@@ -547,6 +562,48 @@ async function handleCodexSubcommand(ctx, options) {
 	}
 	return { text: `Unknown Codex command: ${formatCodexDisplayText(subcommand)}\n\n${buildHelp()}` };
 }
+function resolveCodexNativeCommandSandboxBlock(ctx, subcommand, args) {
+	if (!CODEX_NATIVE_EXECUTION_SUBCOMMANDS.has(subcommand)) return;
+	if (returnsBeforeNativeCodexExecution(subcommand, args)) return;
+	if (isCodexCliNodeResumeBind(subcommand, args)) return resolveCodexNativeSandboxBlock({
+		config: ctx.config,
+		sessionKey: ctx.sessionKey,
+		sessionId: ctx.sessionId,
+		surface: `/${["codex", subcommand].join(" ")}`
+	});
+	return resolveCodexNativeExecutionBlock({
+		config: ctx.config,
+		sessionKey: ctx.sessionKey,
+		sessionId: ctx.sessionId,
+		surface: `/${["codex", subcommand].join(" ")}`
+	});
+}
+function returnsBeforeNativeCodexExecution(subcommand, args) {
+	switch (subcommand) {
+		case "bind": return parseBindArgs([...args]).help === true;
+		case "resume": return returnsBeforeNativeCodexResume(args);
+		case "steer": return args.join(" ").trim() === "";
+		case "model": return args.length === 0 || args.length > 1;
+		case "fast": return args.length === 0 || args.length > 1 || parseCodexFastModeArg(args[0]) === void 0;
+		case "permissions": return args.length === 0 || args.length > 1 || parseCodexPermissionsModeArg(args[0]) === void 0;
+		case "compact":
+		case "review":
+		case "stop": return args.length > 0;
+		default: return false;
+	}
+}
+function isCodexCliNodeResumeBind(subcommand, args) {
+	if (subcommand !== "resume") return false;
+	const parsed = parseResumeArgs([...args]);
+	return Boolean(parsed.host && parsed.threadId && parsed.bindHere === true && !parsed.help);
+}
+function returnsBeforeNativeCodexResume(args) {
+	const parsed = parseResumeArgs([...args]);
+	const normalizedThreadId = parsed.threadId?.trim();
+	if (parsed.help) return true;
+	if (parsed.host) return !normalizedThreadId || parsed.bindHere !== true;
+	return !normalizedThreadId || args.length !== 1;
+}
 async function handleComputerUseCommand(deps, pluginConfig, args) {
 	const parsed = parseComputerUseArgs(args);
 	if (parsed.help) return ["Usage: /codex computer-use [status|install] [--source <marketplace-source>] [--marketplace-path <path>] [--marketplace <name>]", "Checks or installs the configured Codex Computer Use plugin through app-server."].join("\n");

package/dist/{compact-BaSDurdH.js → compact-BwQn7jKq.js}

@@ -1,11 +1,20 @@
-import { c as resolveCodexAppServerRuntimeOptions } from "./config-DqIp6oTk.js";
+import { l as resolveCodexAppServerRuntimeOptions } from "./config-DDMrwfJl.js";
 import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
-import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-DEiYHgJ_.js";
-import { t as defaultCodexAppServerClientFactory } from "./client-factory-BbesECdh.js";
+import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-Bw_mfIW2.js";
+import { n as resolveCodexNativeExecutionBlock } from "./sandbox-guard-CTnEWuor.js";
+import { t as defaultCodexAppServerClientFactory } from "./client-factory-DdrIY1lw.js";
 import { compactContextEngineWithSafetyTimeout, embeddedAgentLog, formatErrorMessage, isActiveHarnessContextEngine, resolveCompactionTimeoutMs, resolveContextEngineOwnerPluginId, runHarnessContextEngineMaintenance } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/compact.ts
 const DEFAULT_CODEX_COMPACTION_WAIT_TIMEOUT_MS = 300 * 1e3;
+const CODEX_COMPACTION_TOKEN_USAGE_GRACE_MS = 250;
+const MAX_CODEX_NATIVE_COMPACTION_ATTEMPTS = 2;
 const warnedIgnoredCompactionOverrides = /* @__PURE__ */ new Set();
+var CodexNativeCompactionTimeoutError = class extends Error {
+	constructor(threadId) {
+		super(`timed out waiting for codex app-server compaction for ${threadId}`);
+		this.threadId = threadId;
+	}
+};
 async function maybeCompactCodexAppServerSession(params, options = {}) {
 	const activeContextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
 	if (activeContextEngine?.info.ownsCompaction) return await compactOwningContextEngine(params, activeContextEngine);
@@ -31,6 +40,8 @@ async function maybeCompactCodexAppServerSession(params, options = {}) {
 	return nativeResult;
 }
 async function compactOwningContextEngine(params, contextEngine) {
+	const compactionTarget = params.trigger === "manual" ? "threshold" : "budget";
+	const force = params.force === true || params.trigger === "manual";
 	embeddedAgentLog.info("starting context-engine-owned Codex app-server compaction", {
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
@@ -38,8 +49,8 @@ async function compactOwningContextEngine(params, contextEngine) {
 		tokenBudget: params.contextTokenBudget,
 		currentTokenCount: params.currentTokenCount,
 		trigger: params.trigger,
-		compactionTarget: params.trigger === "manual" ? "threshold" : "budget",
-		force: params.trigger === "manual"
+		compactionTarget,
+		force
 	});
 	let result;
 	try {
@@ -49,9 +60,9 @@ async function compactOwningContextEngine(params, contextEngine) {
 			sessionFile: params.sessionFile,
 			tokenBudget: params.contextTokenBudget,
 			currentTokenCount: params.currentTokenCount,
-			compactionTarget: params.trigger === "manual" ? "threshold" : "budget",
+			compactionTarget,
 			customInstructions: params.customInstructions,
-			force: params.trigger === "manual",
+			force,
 			runtimeContext: params.contextEngineRuntimeContext
 		}, resolveCompactionTimeoutMs(params.config), params.abortSignal);
 	} catch (error) {
@@ -87,8 +98,8 @@ async function compactOwningContextEngine(params, contextEngine) {
 				error: formatErrorMessage(error)
 			});
 		}
-		await clearCodexAppServerBinding(params.sessionFile);
-		if (compactedSessionFile !== params.sessionFile) await clearCodexAppServerBinding(compactedSessionFile);
+		await clearCodexAppServerBinding(params.sessionFile, { config: params.config });
+		if (compactedSessionFile !== params.sessionFile) await clearCodexAppServerBinding(compactedSessionFile, { config: params.config });
 	}
 	embeddedAgentLog.info("completed context-engine-owned Codex app-server compaction", {
 		sessionId: params.sessionId,
@@ -191,45 +202,92 @@ function readStringPath(value, path) {
 	return typeof current === "string" && current.trim() ? current.trim() : void 0;
 }
 async function compactCodexNativeThread(params, options = {}) {
-	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
-	const binding = await readCodexAppServerBinding(params.sessionFile, { config: params.config });
-	if (!binding?.threadId) return {
+	const nativeExecutionBlock = resolveCodexNativeExecutionBlock({
+		config: params.config,
+		sessionKey: params.sandboxSessionKey ?? params.sessionKey,
+		sessionId: params.sessionId,
+		surface: "native compaction"
+	});
+	if (nativeExecutionBlock) return {
 		ok: false,
 		compacted: false,
-		reason: "no codex app-server thread binding"
+		reason: nativeExecutionBlock
 	};
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+	const binding = await readCodexAppServerBinding(params.sessionFile, { config: params.config });
+	if (!binding?.threadId) return failedCodexThreadBindingCompactionResult(params, {
+		reason: "no codex app-server thread binding",
+		recovery: "missing_thread_binding"
+	});
 	const requestedAuthProfileId = params.authProfileId?.trim() || void 0;
 	if (requestedAuthProfileId && binding.authProfileId && binding.authProfileId !== requestedAuthProfileId) return {
 		ok: false,
 		compacted: false,
 		reason: "auth profile mismatch for session binding"
 	};
-	const client = await (options.clientFactory ?? defaultCodexAppServerClientFactory)(appServer.start, requestedAuthProfileId ?? binding.authProfileId, params.agentDir, params.config);
-	const waiter = createCodexNativeCompactionWaiter(client, binding.threadId);
+	const clientFactory = options.clientFactory ?? defaultCodexAppServerClientFactory;
 	let completion;
-	try {
-		await client.request("thread/compact/start", { threadId: binding.threadId });
-		embeddedAgentLog.info("started codex app-server compaction", {
-			sessionId: params.sessionId,
-			threadId: binding.threadId
-		});
-		waiter.startTimeout();
-		completion = await waiter.promise;
-	} catch (error) {
-		waiter.cancel();
-		return {
-			ok: false,
-			compacted: false,
-			reason: formatCompactionError(error)
-		};
+	let attempt = 0;
+	for (attempt = 1; attempt <= MAX_CODEX_NATIVE_COMPACTION_ATTEMPTS; attempt += 1) {
+		const client = await clientFactory(appServer.start, requestedAuthProfileId ?? binding.authProfileId, params.agentDir, params.config);
+		const waiter = createCodexNativeCompactionWaiter(client, binding.threadId);
+		try {
+			await client.request("thread/compact/start", { threadId: binding.threadId });
+			embeddedAgentLog.info("started codex app-server compaction", {
+				sessionId: params.sessionId,
+				threadId: binding.threadId,
+				attempt
+			});
+			waiter.startTimeout();
+			completion = await waiter.promise;
+			break;
+		} catch (error) {
+			waiter.cancel();
+			if (isCodexThreadNotFoundError(error)) {
+				await clearCodexAppServerBinding(params.sessionFile, { config: params.config });
+				return failedCodexThreadBindingCompactionResult(params, {
+					threadId: binding.threadId,
+					reason: formatCompactionError(error),
+					recovery: "stale_thread_binding"
+				});
+			}
+			if (isCodexNativeCompactionTimeoutError(error, binding.threadId) && attempt < MAX_CODEX_NATIVE_COMPACTION_ATTEMPTS) {
+				restartCodexAppServerAfterNativeCompactionTimeout(client, params, binding.threadId, attempt);
+				continue;
+			}
+			if (isCodexNativeCompactionTimeoutError(error, binding.threadId)) restartCodexAppServerAfterNativeCompactionTimeout(client, params, binding.threadId, attempt);
+			return {
+				ok: false,
+				compacted: false,
+				reason: formatCompactionError(error)
+			};
+		}
 	}
+	if (!completion) return {
+		ok: false,
+		compacted: false,
+		reason: `codex app-server compaction did not complete for ${binding.threadId}`
+	};
 	embeddedAgentLog.info("completed codex app-server compaction", {
 		sessionId: params.sessionId,
 		threadId: binding.threadId,
 		signal: completion.signal,
 		turnId: completion.turnId,
-		itemId: completion.itemId
+		itemId: completion.itemId,
+		tokensAfter: completion.tokensAfter
 	});
+	const resultDetails = {
+		backend: "codex-app-server",
+		threadId: binding.threadId,
+		signal: completion.signal
+	};
+	if (completion.turnId) resultDetails.turnId = completion.turnId;
+	if (completion.itemId) resultDetails.itemId = completion.itemId;
+	if (completion.tokensAfter !== void 0) resultDetails.tokenUsageSource = "thread/tokenUsage/updated";
+	if (attempt > 1) {
+		resultDetails.compactionAttempts = attempt;
+		resultDetails.recoveredAfterAppServerRestart = true;
+	}
 	return {
 		ok: true,
 		compacted: true,
@@ -237,26 +295,57 @@ async function compactCodexNativeThread(params, options = {}) {
 			summary: "",
 			firstKeptEntryId: "",
 			tokensBefore: params.currentTokenCount ?? 0,
-			details: {
-				backend: "codex-app-server",
-				threadId: binding.threadId,
-				signal: completion.signal,
-				turnId: completion.turnId,
-				itemId: completion.itemId
-			}
+			...completion.tokensAfter !== void 0 ? { tokensAfter: completion.tokensAfter } : {},
+			details: resultDetails
+		}
+	};
+}
+function failedCodexThreadBindingCompactionResult(params, recovery) {
+	embeddedAgentLog.warn("codex app-server compaction could not use thread binding", {
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		threadId: recovery.threadId,
+		reason: recovery.reason,
+		recovery: recovery.recovery
+	});
+	return {
+		ok: false,
+		compacted: false,
+		reason: recovery.reason,
+		failure: {
+			reason: recovery.recovery,
+			rawError: recovery.reason
 		}
 	};
 }
+function isCodexThreadNotFoundError(error) {
+	return formatCompactionError(error).toLowerCase().includes("thread not found");
+}
+function isCodexNativeCompactionTimeoutError(error, threadId) {
+	return error instanceof CodexNativeCompactionTimeoutError && error.threadId === threadId;
+}
+function restartCodexAppServerAfterNativeCompactionTimeout(client, params, threadId, attempt) {
+	embeddedAgentLog.warn("codex app-server compaction timed out; restarting app-server", {
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		threadId,
+		attempt,
+		maxAttempts: MAX_CODEX_NATIVE_COMPACTION_ATTEMPTS
+	});
+	client.close();
+}
 function createCodexNativeCompactionWaiter(client, threadId) {
 	let settled = false;
 	let removeHandler = () => {};
 	let timeout;
+	let tokenUsageGraceTimeout;
 	let failWaiter = () => {};
 	return {
 		promise: new Promise((resolve, reject) => {
 			const cleanup = () => {
 				removeHandler();
 				if (timeout) clearTimeout(timeout);
+				if (tokenUsageGraceTimeout) clearTimeout(tokenUsageGraceTimeout);
 			};
 			const complete = (completion) => {
 				if (settled) return;
@@ -270,17 +359,50 @@ function createCodexNativeCompactionWaiter(client, threadId) {
 				cleanup();
 				reject(error);
 			};
+			let latestTokensAfter;
+			const completionWithLatestTokenUsage = (completion) => latestTokensAfter === void 0 ? completion : {
+				...completion,
+				tokensAfter: latestTokensAfter
+			};
+			const completeAfterTokenUsageGrace = (completion) => {
+				if (settled || tokenUsageGraceTimeout) return;
+				if (timeout) {
+					clearTimeout(timeout);
+					timeout = void 0;
+				}
+				tokenUsageGraceTimeout = setTimeout(() => complete(completionWithLatestTokenUsage(observedCompletion ?? completion)), CODEX_COMPACTION_TOKEN_USAGE_GRACE_MS);
+				tokenUsageGraceTimeout.unref?.();
+			};
 			failWaiter = fail;
+			let observedCompletion;
 			const handler = (notification) => {
+				const tokensAfter = readNativeCompactionTokenUsage(notification, threadId);
+				if (tokensAfter !== void 0) {
+					latestTokensAfter = tokensAfter;
+					if (observedCompletion) {
+						complete(completionWithLatestTokenUsage(observedCompletion));
+						return;
+					}
+				}
 				const completion = readNativeCompactionCompletion(notification, threadId);
-				if (completion) complete(completion);
+				if (completion) {
+					observedCompletion = completionWithLatestTokenUsage({
+						...observedCompletion,
+						...completion
+					});
+					if (latestTokensAfter !== void 0) {
+						complete(observedCompletion);
+						return;
+					}
+					completeAfterTokenUsageGrace(observedCompletion);
+				}
 			};
 			removeHandler = client.addNotificationHandler(handler);
 		}),
 		startTimeout() {
 			if (settled || timeout) return;
 			timeout = setTimeout(() => {
-				failWaiter(/* @__PURE__ */ new Error(`timed out waiting for codex app-server compaction for ${threadId}`));
+				failWaiter(new CodexNativeCompactionTimeoutError(threadId));
 			}, resolveCompactionWaitTimeoutMs());
 			timeout.unref?.();
 		},
@@ -292,6 +414,30 @@ function createCodexNativeCompactionWaiter(client, threadId) {
 		}
 	};
 }
+function readNativeCompactionTokenUsage(notification, threadId) {
+	const params = notification.params;
+	if (!isJsonObject(params) || readString(params, "threadId", "thread_id") !== threadId) return;
+	if (notification.method !== "thread/tokenUsage/updated") return;
+	return readCodexTotalTokens(readCodexCurrentTokenUsage(isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0) ?? readCodexCurrentTokenUsage(params));
+}
+function readCodexCurrentTokenUsage(value) {
+	if (!value) return;
+	for (const key of [
+		"last",
+		"current",
+		"lastCall",
+		"lastCallUsage",
+		"lastTokenUsage",
+		"last_token_usage"
+	]) {
+		const usage = value[key];
+		if (isJsonObject(usage)) return usage;
+	}
+}
+function readCodexTotalTokens(value) {
+	const totalTokens = value?.total_tokens ?? value?.totalTokens ?? value?.total;
+	return typeof totalTokens === "number" && Number.isFinite(totalTokens) && totalTokens > 0 ? Math.floor(totalTokens) : void 0;
+}
 function readNativeCompactionCompletion(notification, threadId) {
 	const params = notification.params;
 	if (!isJsonObject(params) || readString(params, "threadId", "thread_id") !== threadId) return;

package/dist/{computer-use-B4iTog6z.js → computer-use-BMMwWwno.js}

@@ -1,5 +1,5 @@
-import { c as resolveCodexAppServerRuntimeOptions, l as resolveCodexComputerUseConfig } from "./config-DqIp6oTk.js";
-import { i as describeControlFailure, t as requestCodexAppServerJson } from "./request-BePR77QD.js";
+import { l as resolveCodexAppServerRuntimeOptions, u as resolveCodexComputerUseConfig } from "./config-DDMrwfJl.js";
+import { i as describeControlFailure, t as requestCodexAppServerJson } from "./request-NklFaHM4.js";
 import { existsSync } from "node:fs";
 //#region extensions/codex/src/app-server/computer-use.ts
 var CodexComputerUseSetupError = class extends Error {

package/dist/{config-DqIp6oTk.js → config-DDMrwfJl.js}

@@ -1,6 +1,7 @@
 import { createHmac, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { hostname } from "node:os";
+import { detectWindowsSpawnCommandInlineArgs } from "openclaw/plugin-sdk/windows-spawn";
 import { z } from "zod";
 //#region extensions/codex/src/app-server/config.ts
 const START_OPTIONS_KEY_SECRET_SYMBOL = Symbol.for("openclaw.codexAppServerStartOptionsKeySecret");
@@ -31,6 +32,7 @@ const codexAppServerApprovalsReviewerSchema = z.enum([
 ]);
 const codexDynamicToolsLoadingSchema = z.enum(["searchable", "direct"]);
 const codexAppServerServiceTierSchema = z.preprocess((value) => value === null ? null : normalizeCodexServiceTier(value), z.string().trim().min(1).nullable().optional()).optional();
+const codexAppServerExperimentalSchema = z.object({ sandboxExecServer: z.boolean().optional() }).strict();
 const codexPluginEntryConfigSchema = z.object({
 	enabled: z.boolean().optional(),
 	marketplaceName: z.literal(CODEX_PLUGINS_MARKETPLACE_NAME).optional(),
@@ -72,11 +74,13 @@ const codexPluginConfigSchema = z.object({
 		codeModeOnly: z.boolean().optional(),
 		requestTimeoutMs: z.number().positive().optional(),
 		turnCompletionIdleTimeoutMs: z.number().positive().optional(),
+		postToolRawAssistantCompletionIdleTimeoutMs: z.number().positive().optional(),
 		approvalPolicy: codexAppServerApprovalPolicySchema.optional(),
 		sandbox: codexAppServerSandboxSchema.optional(),
 		approvalsReviewer: codexAppServerApprovalsReviewerSchema.optional(),
 		serviceTier: codexAppServerServiceTierSchema,
-		defaultWorkspaceDir: z.string().optional()
+		defaultWorkspaceDir: z.string().optional(),
+		experimental: codexAppServerExperimentalSchema.optional()
 	}).strict().optional()
 }).strict();
 function readCodexPluginConfig(value) {
@@ -90,6 +94,16 @@ function readCodexPluginConfig(value) {
 		...plugins.data ? { codexPlugins: plugins.data } : {}
 	};
 }
+function isCodexSandboxExecServerEnabled(pluginConfig) {
+	return readCodexPluginConfig(pluginConfig).appServer?.experimental?.sandboxExecServer === true;
+}
+function assertCodexAppServerCommandHasNoInlineArgs(params) {
+	const inlineArgs = detectWindowsSpawnCommandInlineArgs(params.command);
+	if (!inlineArgs) return;
+	const sourceLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_BIN" : "plugins.entries.codex.config.appServer.command";
+	const argsLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_ARGS" : "plugins.entries.codex.config.appServer.args";
+	throw new Error(`${sourceLabel} must be only the Codex app-server executable path; "${inlineArgs.executable}" was configured with inline arguments "${inlineArgs.arguments}". Move those arguments to ${argsLabel}, or remove the override to use the managed Codex startup path.`);
+}
 function resolveCodexPluginsPolicy(pluginConfig) {
 	const config = readCodexPluginConfig(pluginConfig).codexPlugins;
 	const configured = config !== void 0;
@@ -119,6 +133,10 @@ function resolveCodexAppServerRuntimeOptions(params = {}) {
 	const envCommand = readNonEmptyString(env.OPENCLAW_CODEX_APP_SERVER_BIN);
 	const command = configCommand ?? envCommand ?? "codex";
 	const commandSource = configCommand ? "config" : envCommand ? "env" : "managed";
+	if (commandSource === "config" || commandSource === "env") assertCodexAppServerCommandHasNoInlineArgs({
+		command,
+		source: commandSource
+	});
 	const args = resolveArgs(config.args, env.OPENCLAW_CODEX_APP_SERVER_ARGS);
 	const headers = normalizeHeaders(config.headers);
 	const clearEnv = normalizeStringList(config.clearEnv);
@@ -155,6 +173,7 @@ function resolveCodexAppServerRuntimeOptions(params = {}) {
 		codeModeOnly: config.codeModeOnly === true,
 		requestTimeoutMs: normalizePositiveNumber(config.requestTimeoutMs, 6e4),
 		turnCompletionIdleTimeoutMs: normalizePositiveNumber(config.turnCompletionIdleTimeoutMs, 6e4),
+		...config.postToolRawAssistantCompletionIdleTimeoutMs !== void 0 ? { postToolRawAssistantCompletionIdleTimeoutMs: normalizePositiveNumber(config.postToolRawAssistantCompletionIdleTimeoutMs, 6e4) } : {},
 		approvalPolicy: resolveApprovalPolicy(config.approvalPolicy) ?? resolveApprovalPolicy(env.OPENCLAW_CODEX_APP_SERVER_APPROVAL_POLICY) ?? defaultPolicy?.approvalPolicy ?? (policyMode === "guardian" ? "on-request" : "never"),
 		sandbox: resolveSandbox(config.sandbox) ?? resolveSandbox(env.OPENCLAW_CODEX_APP_SERVER_SANDBOX) ?? defaultPolicy?.sandbox ?? (policyMode === "guardian" ? "workspace-write" : "danger-full-access"),
 		approvalsReviewer: resolveApprovalsReviewer(config.approvalsReviewer) ?? defaultPolicy?.approvalsReviewer ?? (policyMode === "guardian" ? "auto_review" : "user"),
@@ -507,4 +526,4 @@ function splitShellWords(value) {
 	return words;
 }
 //#endregion
-export { isCodexFastServiceTier as a, resolveCodexAppServerRuntimeOptions as c, withMcpElicitationsApprovalPolicy as d, isCodexAppServerApprovalPolicyAllowedByRequirements as i, resolveCodexComputerUseConfig as l, codexAppServerStartOptionsKey as n, normalizeCodexServiceTier as o, codexSandboxPolicyForTurn as r, readCodexPluginConfig as s, CODEX_PLUGINS_MARKETPLACE_NAME as t, resolveCodexPluginsPolicy as u };
+export { isCodexFastServiceTier as a, readCodexPluginConfig as c, resolveCodexPluginsPolicy as d, withMcpElicitationsApprovalPolicy as f, isCodexAppServerApprovalPolicyAllowedByRequirements as i, resolveCodexAppServerRuntimeOptions as l, codexAppServerStartOptionsKey as n, isCodexSandboxExecServerEnabled as o, codexSandboxPolicyForTurn as r, normalizeCodexServiceTier as s, CODEX_PLUGINS_MARKETPLACE_NAME as t, resolveCodexComputerUseConfig as u };