@openclaw/codex 2026.9.5 → 2026.9.6

package/dist/.setup/{transport-stdio-Cmx94Oiy.mjs → transport-stdio-h2VHOskC.mjs}

@@ -1,11 +1,18 @@
-import { r as normalizeCodexAppServerArgs } from "./launch-args-DnMak49W.mjs";
+import { r as normalizeCodexAppServerArgs } from "./launch-args-DbFCehO7.mjs";
+import { i as resolveManagedCodexNativeCommand } from "./managed-binary-BnshlFag.mjs";
+import { i as recordCodexAppServerSpawnFailure, r as getCodexAppServerSpawnFailure } from "./spawn-error-CL3n6MAa.mjs";
 import { createHash, randomUUID } from "node:crypto";
+import { stripVTControlCharacters } from "node:util";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
 import { z } from "zod";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { closeSync, constants, openSync, readSync } from "node:fs";
 import path from "node:path";
 import { readFile, readdir } from "node:fs/promises";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { once } from "node:events";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { execFile, spawn } from "node:child_process";
 import { setImmediate } from "node:timers/promises";
 import { finished } from "node:stream/promises";
@@ -302,6 +309,8 @@ const MAX_PROCESS_QUIESCE_PASSES = 16;
 /** Discharges the registered root obligation, including an already-obsolete PID. */
 async function terminateCodexAppServerOrphan(expected) {
 	const deadline = Date.now() + MAX_PROCESS_CONTAINMENT_MS;
+	const initial = (await readCodexAppServerProcessSnapshot(deadline, [expected.pid])).find((row) => row.pid === expected.pid);
+	if (!initial || !hasSameIdentity(initial, expected) || isDeadProcessState(initial.state)) return true;
 	const result = await terminateCodexAppServerDescendants({
 		pid: expected.pid,
 		kill: (signal) => signalProcess(expected.pid, signal ?? "SIGTERM")
@@ -314,7 +323,7 @@ async function terminateCodexAppServerOrphan(expected) {
 			if (current && isSameLiveRoot(current, contained.root, true)) signalProcess(current.pgid === current.pid ? -current.pid : current.pid, "SIGKILL");
 		}
 		while (Date.now() < deadline) {
-			const snapshot = await readCodexAppServerProcessSnapshot(deadline).catch(() => void 0);
+			const snapshot = await readCodexAppServerProcessSnapshot(deadline, [expected.pid]).catch(() => void 0);
 			if (!snapshot?.some((row) => row.pid === process.pid)) return false;
 			const current = snapshot.find((row) => row.pid === expected.pid);
 			if (!current || !hasSameIdentity(current, expected) || isDeadProcessState(current.state)) {
@@ -531,21 +540,37 @@ const registrationSchema = z.object({
 	parent: processIdentity,
 	child: childIdentity
 }).strict();
+const registrationCleanup = /* @__PURE__ */ new WeakMap();
+const processReaper = resolveGlobalSingleton(Symbol.for("openclaw.codexAppServerProcessReaper"), () => new KeyedAsyncQueue());
+/** Join bookkeeping after the transport owner has observed physical exit. */
+async function waitForCodexAppServerProcessRegistrationCleanup(child) {
+	await registrationCleanup.get(child);
+}
 function fingerprintProcessCommand(command) {
 	return createHash("sha256").update(command).digest("hex");
 }
 async function openProcessRegistrationStore() {
-	const { createPluginStateSyncKeyedStore } = await import("openclaw/plugin-sdk/plugin-state-store-runtime");
-	return createPluginStateSyncKeyedStore("codex", {
+	const env = {
+		...process.env,
+		OPENCLAW_STATE_DIR: resolveStateDir()
+	};
+	const { createPluginStateKeyedStore } = await import("openclaw/plugin-sdk/plugin-state-store-runtime");
+	return createPluginStateKeyedStore("codex", {
 		namespace: "app-server-processes",
 		maxEntries: 512,
-		overflowPolicy: "reject-new"
+		overflowPolicy: "reject-new",
+		env
 	});
 }
 async function reapRegisteredCodexAppServerOrphans() {
 	const store = await openProcessRegistrationStore();
+	await processReaper.enqueue("orphans", () => sweepRegisteredCodexAppServerOrphans(store));
+	return store;
+}
+async function sweepRegisteredCodexAppServerOrphans(store) {
+	const entries = await store.entries();
 	const deadline = Date.now() + PROCESS_REGISTRATION_INSPECTION_MS;
-	for (const entry of store.entries()) {
+	for (const entry of entries) {
 		if (Date.now() >= deadline) throw new Error("Codex orphan cleanup exceeded its startup budget. Retry to finish cleanup.");
 		const registration = registrationSchema.parse(entry.value);
 		const snapshot = await readCodexAppServerProcessSnapshot(deadline, [registration.parent.pid, registration.child.pid]);
@@ -557,29 +582,34 @@ async function reapRegisteredCodexAppServerOrphans() {
 			try {
 				command = await readCodexAppServerProcessCommand(child, deadline);
 			} catch (error) {
-				if ((await readCodexAppServerProcessSnapshot(deadline, [registration.child.pid])).find((row) => row.pid === registration.child.pid)?.startedAt === registration.child.startedAt) throw error;
+				const current = (await readCodexAppServerProcessSnapshot(deadline, [registration.child.pid])).find((row) => row.pid === registration.child.pid);
+				if (current?.startedAt === registration.child.startedAt && !isDeadProcessState(current.state)) throw error;
 			}
 			if (command !== void 0 && fingerprintProcessCommand(command) !== registration.child.commandFingerprint) {
-				store.delete(entry.key);
+				await store.delete(entry.key);
 				continue;
 			}
 		}
 		if (!await terminateCodexAppServerOrphan(registration.child)) throw new Error(`Cannot reap registered Codex process ${registration.child.pid}. Stop it before retrying.`);
-		store.delete(entry.key);
+		await store.delete(entry.key);
 	}
 }
 function createCodexAppServerProcessReaperService() {
+	let pendingSweep;
 	return {
 		id: "codex-app-server-process-reaper",
 		start(ctx) {
 			if (process.platform === "win32") return;
-			(async () => {
+			pendingSweep = (async () => {
 				try {
 					await reapRegisteredCodexAppServerOrphans();
 				} catch (error) {
 					ctx.logger.warn(`Codex app-server orphan cleanup failed: ${String(error)}`);
 				}
 			})();
+		},
+		async stop() {
+			await pendingSweep;
 		}
 	};
 }
@@ -588,8 +618,7 @@ async function prepareCodexAppServerProcessRegistration() {
 	if (process.platform === "win32") return async (child) => {
 		await once(child, "spawn");
 	};
-	await reapRegisteredCodexAppServerOrphans();
-	const store = await openProcessRegistrationStore();
+	const store = await reapRegisteredCodexAppServerOrphans();
 	return async (child) => {
 		await once(child, "spawn");
 		if (!child.pid) throw new ProcessInspectionError("unavailable");
@@ -601,21 +630,63 @@ async function prepareCodexAppServerProcessRegistration() {
 		const command = await readCodexAppServerProcessCommand(spawned, deadline);
 		if (child.exitCode !== null || child.signalCode !== null) throw new Error("Cannot register the Codex child process command: the child exited during inspection. Retry.");
 		const key = randomUUID();
-		store.register(key, {
+		const value = {
 			parent: processIdentity.parse(parent),
 			child: childIdentity.parse({
 				...spawned,
 				commandFingerprint: fingerprintProcessCommand(command)
 			})
+		};
+		const exited = new Promise((resolve) => {
+			child.once("exit", () => resolve());
 		});
-		child.once("exit", () => {
+		const registered = store.register(key, value);
+		const cleanup = (async () => {
+			await exited;
+			await registered.catch(() => void 0);
 			try {
-				store.delete(key);
+				await store.delete(key);
 			} catch {}
-		});
+		})();
+		registrationCleanup.set(child, cleanup);
+		await registered;
+		if (child.exitCode !== null || child.signalCode !== null) {
+			await cleanup;
+			throw new Error("Cannot register the Codex child process: the child exited during registration. Retry.");
+		}
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/managed-launcher-failure.ts
+/** The official npm launcher prints Node's native spawn error and exits before initialization. */
+function observeManagedCodexLauncherFailure(child, nativeCommand) {
+	let prefix = "";
+	let launchCode;
+	const startupFailure = { complete() {
+		child.stderr.off("data", onData);
+		child.off("exit", onExit);
+		prefix = "";
+	} };
+	const onData = (chunk) => {
+		if (launchCode || prefix.length >= 16384) return;
+		prefix = (prefix + stripVTControlCharacters(chunk.toString())).slice(0, 16384);
+		if (/\bError: spawn\b/u.test(prefix) && /syscall: ['"]spawn(?: [^'"\r\n]*)?['"]/u.test(prefix)) launchCode = /\bcode: ['"](ENOENT|EACCES|EBADARCH|Unknown system error -86)['"]/u.exec(prefix)?.[1];
+		else if (/Error: Missing optional dependency @openai\/codex-[\w-]+\. Reinstall Codex:/u.test(prefix)) launchCode = "ENOENT";
+	};
+	const onExit = (code) => {
+		startupFailure.complete();
+		if (code !== 1 || !launchCode) return;
+		const described = recordCodexAppServerSpawnFailure(Object.assign(/* @__PURE__ */ new Error(`spawn ${launchCode}`), {
+			code: launchCode,
+			syscall: "spawn"
+		}), nativeCommand, nativeCommand);
+		if (described instanceof Error) startupFailure.error = described;
+	};
+	child.stderr.on("data", onData);
+	child.once("exit", onExit);
+	Object.assign(child, { startupFailure });
+}
+//#endregion
 //#region extensions/codex/src/app-server/transport.ts
 /**
 * Shared transport lifecycle helpers for stdio and WebSocket Codex app-server
@@ -696,6 +767,7 @@ async function closeCodexAppServerTransportAndWait(child, options = {}) {
 	const closure = beginCodexAppServerTransportClose(child, options);
 	const containment = await closure.closing;
 	const settled = await waitForCodexAppServerTransportExit(child, options.exitTimeoutMs ?? 2e3, drained);
+	if (settled) await waitForCodexAppServerProcessRegistrationCleanup(child);
 	closure.naturalExit = containment === "natural" && settled;
 	if (options.drainStdio) {
 		child.stdout.destroy?.();
@@ -756,39 +828,29 @@ const RUNTIME_INJECTION_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
 	"LD_PRELOAD"
 ]);
 const QA_PARENT_PID_ENV = "OPENCLAW_QA_PARENT_PID";
-const DEFAULT_SPAWN_RUNTIME = {
-	platform: process.platform,
-	env: process.env,
-	execPath: process.execPath,
-	isBun: typeof process.versions.bun === "string"
-};
 /** Resolves the concrete command/argv/shell settings used to spawn Codex app-server. */
-function resolveCodexAppServerSpawnInvocation(options, runtime = DEFAULT_SPAWN_RUNTIME) {
+function resolveCodexAppServerSpawnInvocation(options, env) {
 	if (options.commandSource === "managed") throw new Error("Managed Codex app-server start options must be resolved before spawn.");
 	const program = resolveWindowsSpawnProgram({
 		command: options.command,
-		platform: runtime.platform,
-		env: runtime.env,
-		execPath: runtime.execPath,
+		platform: process.platform,
+		env,
+		execPath: process.execPath,
 		packageName: "@openai/codex"
 	});
 	const args = normalizeCodexAppServerArgs(options.args);
 	const resolved = materializeWindowsSpawnProgram(program, args);
-	if (runtime.isBun && options.commandSource === "resolved-managed" && resolved.resolution === "direct" && [
+	if (options.commandSource === "resolved-managed" && resolved.resolution === "direct" && [
 		".cjs",
 		".js",
 		".mjs"
 	].includes(path.extname(resolved.command).toLowerCase())) return {
-		command: runtime.execPath,
-		args: [resolved.command, ...resolved.argv],
-		windowsHide: resolved.windowsHide
-	};
-	return {
-		command: resolved.command,
-		args: resolved.argv,
-		shell: resolved.shell,
-		windowsHide: resolved.windowsHide
+		...resolved,
+		command: process.execPath,
+		argv: [resolved.command, ...resolved.argv],
+		resolution: "node-entrypoint"
 	};
+	return resolved;
 }
 /** Merges app-server environment overrides while honoring clearEnv and unsafe key filtering. */
 function resolveCodexAppServerSpawnEnv(options, baseEnv = process.env, platform = process.platform) {
@@ -828,27 +890,45 @@ function copySafeEnvironmentEntries(target, source) {
 /** Spawns the Codex app-server process and returns the shared transport interface. */
 async function createStdioTransport(options, baseEnv = process.env, assertCurrent, onSpawn) {
 	const env = resolveCodexAppServerSpawnEnv(options, baseEnv);
-	const invocation = resolveCodexAppServerSpawnInvocation(options, {
-		platform: process.platform,
-		env,
-		execPath: process.execPath,
-		isBun: typeof process.versions.bun === "string"
-	});
+	const invocation = resolveCodexAppServerSpawnInvocation(options, env);
+	const nativeCommand = options.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(options.command, { pathExists: () => true }) : void 0;
+	const launchKey = JSON.stringify([
+		invocation.command,
+		options.cwd ?? process.cwd(),
+		nativeCommand ?? null,
+		path.isAbsolute(invocation.command) ? null : env.PATH ?? env.Path
+	]);
+	const previousFailure = getCodexAppServerSpawnFailure(launchKey) ?? (nativeCommand ? getCodexAppServerSpawnFailure(nativeCommand) : void 0);
+	if (previousFailure) throw previousFailure;
 	const register = await prepareCodexAppServerProcessRegistration();
 	assertCurrent?.();
-	const child = spawn(invocation.command, invocation.args, {
-		...options.cwd !== void 0 ? { cwd: options.cwd } : {},
-		env,
-		detached: resolveCodexAppServerDetachedMode(env),
-		shell: invocation.shell,
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		],
-		windowsHide: invocation.windowsHide
+	embeddedAgentLog.debug("Codex app-server spawn", {
+		command: invocation.command,
+		launcher: options.command,
+		...options.cwd ? { cwd: options.cwd } : {},
+		...nativeCommand ? { nativeCommand } : {},
+		platform: process.platform,
+		arch: process.arch
 	});
+	let child;
+	try {
+		child = spawn(invocation.command, invocation.argv, {
+			...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+			env,
+			detached: resolveCodexAppServerDetachedMode(env),
+			shell: invocation.shell,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: invocation.windowsHide
+		});
+	} catch (error) {
+		throw recordCodexAppServerSpawnFailure(error, invocation.command, launchKey);
+	}
 	try {
+		if (nativeCommand && invocation.resolution === "node-entrypoint") observeManagedCodexLauncherFailure(child, nativeCommand);
 		onSpawn?.(child);
 		await register(child);
 		assertCurrent?.();
@@ -856,8 +936,8 @@ async function createStdioTransport(options, baseEnv = process.env, assertCurren
 	} catch (error) {
 		await closeCodexAppServerTransportAndWait(child, { drainStdio: true });
 		assertCurrent?.();
-		throw error;
+		throw child.startupFailure?.error ?? recordCodexAppServerSpawnFailure(error, invocation.command, launchKey);
 	}
 }
 //#endregion
-export { hasCodexAppServerNaturalExit as a, closeCodexAppServerTransportAndWait as i, resolveCodexAppServerSpawnEnv as n, createCodexAppServerProcessReaperService as o, closeCodexAppServerTransport as r, createStdioTransport as t };
+export { closeCodexAppServerTransportAndWait as a, closeCodexAppServerTransport as i, resolveCodexAppServerSpawnEnv as n, hasCodexAppServerNaturalExit as o, resolveCodexAppServerSpawnInvocation as r, createCodexAppServerProcessReaperService as s, createStdioTransport as t };

package/dist/.setup/{upstream-session-fork-D3UKxgVD.mjs → upstream-session-fork-BUr4OUbC.mjs}

@@ -1,35 +1,35 @@
-import { p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
-import { m as isJsonObject, p as flattenCodexDynamicToolFunctions } from "./config-security-BRQ2mgW9.mjs";
+import { m as sessionBindingIdentity } from "./session-binding-record-BGoz8wOK.mjs";
 import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
-import { _ as assertCodexThreadAcceptsDirectInput, v as assertCodexThreadForkResponse } from "./client-vXs2929Q.mjs";
-import { s as assertCodexModelBackedReviewerEffectiveConfig } from "./config-options-BsanJ8QG.mjs";
+import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
+import { s as assertCodexModelBackedReviewerEffectiveConfig } from "./config-options-BvaRs51b.mjs";
+import { o as readCodexSessionMeta } from "./session-catalog-events-Bj6j94E_.mjs";
 import { n as withCodexAppServerThreadMutation } from "./incognito-session-uhrBF6wJ.mjs";
 import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
-import { i as projectCodexUserItemText } from "./transcript-history-projection-DHNBDhCU.mjs";
+import { i as projectCodexUserItemText } from "./transcript-history-projection-ZZpkFkJ_.mjs";
 import { n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.mjs";
-import { r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BOxKP7db.mjs";
-import { c as readCodexSessionMeta } from "./session-catalog-events-jMcYfQyd.mjs";
-import { t as CodexAppServerScopedRequestRejectedError } from "./request-BioXJLYa.mjs";
-import { n as resolveOpenClawExecPolicyForCodexAppServer } from "./config-CedDWjM-.mjs";
-import { r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
+import { r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-B2CsSdnV.mjs";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-D2L0zMrq.mjs";
+import { n as resolveOpenClawExecPolicyForCodexAppServer } from "./config-BoTP_mrL.mjs";
+import { r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
 import { a as fingerprintCodexMirrorSourceMessage, c as readCodexMirrorSourceFingerprint } from "./transcript-mirror-attestation-CzM-94NC.mjs";
-import { I as hasCodexAppServerLiveThread, M as claimCodexAppServerLiveThread, f as readCodexAppServerClientDesktopGenerationFingerprint } from "./shared-client-BpTtuLQ5.mjs";
-import { At as shouldBuildCodexPluginThreadConfig, B as buildCodexNativeHookRelayId, K as checkCodexThreadAppAvailability, L as assertCodexNativeHookRelayAllowed, Ot as mergeCodexThreadConfigs, Q as resolveCodexNativeSkillIsolation, R as buildCodexNativeHookRelayConfig, T as buildDeveloperInstructions, U as resolveCodexNativeHookRelayEvents, X as parseCodexNativeToolCatalog, Z as applyCodexNativeSkillIsolation, et as codexDynamicToolsFingerprint, nt as fingerprintJsonObject, rt as fingerprintUserMcpServersConfigPatch, w as resolveCodexWebSearchPlan, wt as buildCodexPluginThreadConfig, x as buildCodexThreadConfiguration } from "./thread-lifecycle-Cik28qWn.mjs";
-import "./session-binding-_0W_fHRr.mjs";
-import { i as refreshCodexThreadPolicy, n as CodexThreadPolicyHandoffError } from "./thread-policy-Cjs4B8xf.mjs";
-import "./thread-ownership-skomxnIt.mjs";
-import { n as resolveCodexNativeExecutionPolicy } from "./native-execution-policy-YBMHSzC4.mjs";
-import { l as isCodexDynamicToolExcluded, n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-B8J4Dy-O.mjs";
-import { o as prepareCodexWorkspaceDeveloperInstructions } from "./attempt-context-VXVwTCfS.mjs";
-import { n as prepareCodexSessionInitialization } from "./session-initialization-DH1z6fXn.mjs";
-import { createImportedCodexSession } from "./session-history-import-JHXT5Xfi.mjs";
+import { I as hasCodexAppServerLiveThread, M as claimCodexAppServerLiveThread, f as readCodexAppServerClientDesktopGenerationFingerprint } from "./shared-client-DA4VR4Eb.mjs";
+import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError, v as assertCodexThreadAcceptsDirectInput, y as assertCodexThreadForkResponse } from "./client-Cs08OXVQ.mjs";
+import { B as parseCodexNativeToolCatalog, Ct as shouldBuildCodexPluginThreadConfig, E as buildCodexNativeHookRelayConfig, F as checkCodexThreadAppAvailability, H as resolveCodexNativeSkillIsolation, K as codexDynamicToolsFingerprint, O as buildCodexNativeHookRelayId, T as assertCodexNativeHookRelayAllowed, V as applyCodexNativeSkillIsolation, X as fingerprintJsonObject, Z as fingerprintUserMcpServersConfigPatch, a as buildCodexThreadConfiguration, j as resolveCodexNativeHookRelayEvents, m as buildDeveloperInstructions, mt as buildCodexPluginThreadConfig, p as resolveCodexWebSearchPlan, xt as mergeCodexThreadConfigs } from "./thread-requests-BLvGkP2R.mjs";
+import "./session-binding-Cm0apEbd.mjs";
+import { a as refreshCodexThreadPolicy, n as CodexThreadPolicyHandoffError } from "./thread-policy-DGuQsuFC.mjs";
+import "./thread-ownership-DcTtAcXj.mjs";
+import { n as resolveCodexNativeExecutionPolicy } from "./native-execution-policy-umd0tgh4.mjs";
+import { d as isCodexDynamicToolExcluded, n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-BfE88FZ5.mjs";
+import { u as prepareCodexWorkspaceDeveloperInstructions } from "./attempt-workspace-context-DUVEn_CS.mjs";
+import { n as prepareCodexSessionInitialization } from "./session-initialization-rcgbZiid.mjs";
+import { createImportedCodexSession } from "./session-history-import-D-3wAgOP.mjs";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import path from "node:path";
 import { lstat } from "node:fs/promises";
-import { constants, createZstdDecompress } from "node:zlib";
 import { root } from "openclaw/plugin-sdk/file-access-runtime";
+import { constants, createZstdDecompress } from "node:zlib";
 import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
 import { loadCodexBundleMcpThreadConfig } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
@@ -259,7 +259,7 @@ async function prepareCanonicalCodexFork(params) {
 	const nativeSkillIsolation = await resolveCodexNativeSkillIsolation({
 		client: context.client,
 		cwd,
-		codexHome: appServer.start.env?.CODEX_HOME,
+		codexHome: appServer.start.codexHome ?? appServer.start.env?.CODEX_HOME,
 		home: appServer.start.env?.HOME,
 		userProfile: appServer.start.env?.USERPROFILE
 	});
@@ -375,15 +375,15 @@ function resolveCodexUpstreamForkBoundaryFromTurns(params) {
 			if (item.type !== "userMessage") continue;
 			const isSteer = userMessagesInTurn > 0;
 			userMessagesInTurn += 1;
+			const local = params.localPrefix[localIndex];
+			const identity = local && readMirrorIdentity(local.message);
+			const matchesIdentity = identity === `${turn.id}:${item.id}` || !isSteer && identity === `${turn.id}:prompt`;
+			if (!matchedPrefix && !matchesIdentity) continue;
 			const nativeText = textOnlyMessage(item.content);
 			if (nativeText === void 0) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
-			const local = params.localPrefix[localIndex];
 			const upstreamText = local && readUpstreamUserText(local.message);
 			const text = upstreamText ? nativeText : projectCodexUserItemText(item);
 			if (!text) continue;
-			const identity = local && readMirrorIdentity(local.message);
-			const matchesIdentity = identity === `${turn.id}:${item.id}` || !isSteer && identity === `${turn.id}:prompt`;
-			if (!matchedPrefix && !matchesIdentity) continue;
 			matchedPrefix = true;
 			const localText = textOnlyMessage(local && "content" in local.message ? local.message.content : void 0);
 			const upstreamPromptVerified = !upstreamText || local?.message.role === "user" && readCodexMirrorSourceFingerprint(local.message) === fingerprintCodexMirrorSourceMessage(local.message);
@@ -567,6 +567,7 @@ async function forkCanonicalCodexSession(params) {
 						}
 					});
 					const assertCurrent = () => {
+						fork.assertCurrent();
 						initialization.assertCurrent();
 						if (ownership && !subscriptionReleased) ownership.assertCurrent();
 					};
@@ -797,16 +798,23 @@ async function forkCodexUpstreamSession(params, options) {
 				code: precheck.code,
 				message: precheck.message
 			};
-			const rawResponse = await control.forkThread({
-				threadId: sourceThreadId,
-				beforeTurnId: resolved.boundary.beforeTurnId,
-				...params.sandbox === "required" ? { sandbox: "workspace-write" } : {},
-				excludeTurns: true
-			});
-			const response = assertCodexThreadForkResponse(rawResponse);
-			const threadId = response.thread.id.trim();
-			if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
-			if (threadId === sourceThreadId || threadId === sourceBinding?.threadId) throw new Error("Codex thread/fork response reused the source thread id");
+			let response;
+			let threadId;
+			try {
+				const rawResponse = await control.forkThread({
+					threadId: sourceThreadId,
+					beforeTurnId: resolved.boundary.beforeTurnId,
+					...params.sandbox === "required" ? { sandbox: "workspace-write" } : {},
+					excludeTurns: true
+				}, params.assertCurrent);
+				response = assertCodexThreadForkResponse(rawResponse);
+				threadId = response.thread.id.trim();
+				if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
+				if (threadId === sourceThreadId || threadId === sourceBinding?.threadId) throw new Error("Codex thread/fork response reused the source thread id");
+			} catch (error) {
+				if (!(error instanceof CodexAppServerScopedRequestRejectedError) && !isCodexAppServerPrewriteRequestCancellationError(error) && !isCodexAppServerOverloadError(error)) control.retireConnection?.();
+				throw error;
+			}
 			const forkedThreadId = threadId;
 			try {
 				const connectionFingerprint = normalizeOptionalString(control.connectionFingerprint);

package/dist/.setup/{usage-BOgBEKso.mjs → usage-BML0r-ua.mjs}

@@ -1,7 +1,7 @@
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-DOEGYRNs.mjs";
-import { n as readCodexAppServerUsage } from "./request-BioXJLYa.mjs";
-import "./config-CedDWjM-.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
+import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-CMU3DUD0.mjs";
+import { n as readCodexAppServerUsage } from "./request-D2L0zMrq.mjs";
+import "./config-BoTP_mrL.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
 import { CODEX_APP_SERVER_AUTH_MARKER } from "openclaw/plugin-sdk/agent-runtime";
 //#region extensions/codex/src/app-server/usage.ts
 /** Handles the synthetic usage credential for a Codex-backed OpenAI route. */
@@ -10,6 +10,7 @@ async function fetchCodexAppServerUsageSnapshot(ctx, options = {}) {
 	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
 	const usage = await (options.readUsage ?? readCodexAppServerUsage)({
 		timeoutMs: ctx.timeoutMs,
+		signal: ctx.signal,
 		agentDir: ctx.agentDir,
 		...ctx.authProfileId ? { authProfileId: ctx.authProfileId } : {},
 		config: ctx.config,

package/dist/.setup/{usage-limit-error-C0ow7DOc.mjs → usage-limit-error-DUMbefVY.mjs}

@@ -1,7 +1,7 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-DOEGYRNs.mjs";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-_vXcZGSx.mjs";
-import { J as rememberCodexRateLimitsRead, K as readCodexRateLimitsRevision, q as readRecentCodexRateLimits } from "./shared-client-BpTtuLQ5.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CMU3DUD0.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-CDXOOFdZ.mjs";
+import { J as rememberCodexRateLimitsRead, K as readCodexRateLimitsRevision, q as readRecentCodexRateLimits } from "./shared-client-DA4VR4Eb.mjs";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { markAuthProfileBlockedUntil } from "openclaw/plugin-sdk/agent-runtime";
 import { embeddedAgentLog, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";

package/dist/.setup/{web-search-provider.runtime-CTGuJt6i.mjs → web-search-provider.runtime-CDKlN-Rv.mjs}

@@ -1,6 +1,6 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
-import { C as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-Cik28qWn.mjs";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-BtlZcivC.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { f as buildCodexNativeWebSearchThreadConfig } from "./thread-requests-BLvGkP2R.mjs";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-B2HScEgT.mjs";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readStringParam, resolveSearchTimeoutSeconds, wrapWebContent } from "openclaw/plugin-sdk/provider-web-search";
 //#region extensions/codex/src/web-search-provider.runtime.ts
@@ -13,6 +13,7 @@ async function executeCodexWebSearchProviderTool(ctx, args, executionContext, op
 		modelProvider: "openai",
 		timeoutMs: resolveSearchTimeoutSeconds(ctx.searchConfig) * 1e3,
 		signal: executionContext?.signal,
+		assertCurrent: executionContext?.assertCurrent,
 		agentDir: ctx.agentDir,
 		options,
 		taskLabel: "hosted search",

package/dist/api.js

@@ -1,8 +1,10 @@
-import { a as resolveCodexAppServerStartOptionsForAgent } from "./.setup/config-options-BsanJ8QG.mjs";
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./.setup/managed-binary-DP6Rib3P.mjs";
-import { t as CODEX_APP_SERVER_VERSION } from "./.setup/version-CoqzXPgK.mjs";
-import "./.setup/config-CedDWjM-.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./.setup/config-runtime-CeAhl_h4.mjs";
+import { d as readCodexPluginConfig } from "./.setup/config-parsing-CcB9iPoq.mjs";
+import { a as resolveCodexAppServerStartOptionsForAgent } from "./.setup/config-options-BvaRs51b.mjs";
+import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, s as CODEX_APP_SERVER_VERSION, t as isManagedCodexDesktopCommand } from "./.setup/managed-binary-BnshlFag.mjs";
+import { t as codexNativeProfileRecoveryHealthCheck } from "./.setup/auth-profile-health-oHizqgye.mjs";
+import { n as findCodexAppServerSpawnError, t as describeCodexSpawnError } from "./.setup/spawn-error-CL3n6MAa.mjs";
+import "./.setup/config-BoTP_mrL.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./.setup/config-runtime-C8Rw1m1m.mjs";
 import { listAgentIds, resolveAgentDir } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import path from "node:path";
@@ -67,7 +69,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 			const isFinalization = ctx.mode === "fix" && env.OPENCLAW_UPDATE_POST_CORE === "1";
 			const versionFailureSeverity = isFinalization ? "warning" : "error";
 			const versionFailureHint = isFinalization ? "Codex readiness will be rechecked by its plugin after restart; inspect the Codex plugin if the warning persists." : void 0;
-			let resolved;
+			const candidates = [];
 			for (const agentId of listAgentIds(ctx.cfg)) {
 				const model = resolveDefaultModelForAgent({
 					cfg: ctx.cfg,
@@ -79,13 +81,20 @@ function createCodexManagedAppServerHealthCheck(params) {
 					modelId: model.model,
 					agentId
 				}) !== "codex") continue;
-				const agentStart = resolveAgentStartOptions({
+				candidates.push(resolveAgentStartOptions({
 					startOptions: start,
 					agentDir: resolveAgentDir(ctx.cfg, agentId, env),
 					env
-				});
+				}));
+			}
+			if (ctx.cfg.plugins?.entries?.codex?.enabled === true && readCodexPluginConfig(pluginConfig).sessionCatalog?.enabled !== false) candidates.push({
+				...start,
+				managedCommandOrder: "package-only"
+			});
+			let resolved;
+			for (const candidate of candidates) {
 				try {
-					resolved = await resolveStartOptions(agentStart, { pluginRoot: params.pluginRoot });
+					resolved = await resolveStartOptions(candidate, { pluginRoot: params.pluginRoot });
 				} catch (error) {
 					return [managedCodexFinding({
 						message: `Managed Codex app-server could not be resolved: ${readErrorMessage(error)}`,
@@ -109,16 +118,17 @@ function createCodexManagedAppServerHealthCheck(params) {
 			try {
 				output = await (params.deps?.runVersionCommand ? params.deps.runVersionCommand(nativeCommand) : runVersionCommand(nativeCommand, env));
 			} catch (error) {
+				const spawnFailure = findCodexAppServerSpawnError(describeCodexSpawnError(error, nativeCommand));
 				return [managedCodexFinding({
-					message: `Managed Codex app-server version check failed: ${readErrorMessage(error)}`,
-					severity: versionFailureSeverity,
+					message: spawnFailure?.message ?? `Managed Codex app-server version check failed: ${readErrorMessage(error)}`,
+					severity: spawnFailure && resolved.managedCommandOrder === "package-only" ? "warning" : versionFailureSeverity,
 					path: nativeCommand,
 					requirement: `Codex ${CODEX_APP_SERVER_VERSION} must report its version within ${CODEX_VERSION_TIMEOUT_MS} ms`,
 					fixHint: versionFailureHint ?? "Repair or reinstall the staged OpenClaw package, then rerun the candidate check before cutover."
 				})];
 			}
 			const detectedVersion = parseCodexVersion(`${output.stdout}\n${output.stderr}`);
-			if (detectedVersion !== "0.154.0") return [managedCodexFinding({
+			if (detectedVersion !== "0.155.1") return [managedCodexFinding({
 				severity: versionFailureSeverity,
 				message: detectedVersion ? `Managed Codex app-server version mismatch: expected ${CODEX_APP_SERVER_VERSION}, detected ${detectedVersion}.` : `Managed Codex app-server did not report a parseable version; expected ${CODEX_APP_SERVER_VERSION}.`,
 				path: nativeCommand,
@@ -144,6 +154,7 @@ function registerCodexManagedAppServerDoctorChecks(host) {
 		...host,
 		pluginRoot: CODEX_PLUGIN_ROOT
 	});
+	if (!host.getHealthCheck(codexNativeProfileRecoveryHealthCheck.id)) host.registerHealthCheck(codexNativeProfileRecoveryHealthCheck);
 }
 //#endregion
 export { CODEX_MANAGED_APP_SERVER_CHECK_ID, registerCodexManagedAppServerDoctorChecks };

package/dist/catalog-page-worker-entrypoint.js

@@ -0,0 +1,12 @@
+//#region extensions/codex/catalog-page-worker-entrypoint.ts
+const codexCatalogPageWorkerEntrypoint = {
+	currentModuleUrl: import.meta.url,
+	sourceWorkerName: "catalog-page.worker",
+	distWorkerPath: "extensions/codex/catalog-page.worker.js",
+	package: {
+		name: "@openclaw/codex",
+		distWorkerPath: "catalog-page.worker.js"
+	}
+};
+//#endregion
+export { codexCatalogPageWorkerEntrypoint };

package/dist/catalog-page.worker.js

@@ -0,0 +1,9 @@
+import { t as createCodexCatalogDecoder } from "./.setup/client-catalog-response-BMgt_4q4.mjs";
+import { serveWorkerTasks } from "openclaw/plugin-sdk/worker-task-server";
+//#region extensions/codex/catalog-page.worker.ts
+const decode = createCodexCatalogDecoder();
+serveWorkerTasks((input) => {
+	return decode(input);
+});
+//#endregion
+export {};

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./.setup/session-cli-DIj-IE-E.mjs");
+		const { registerCodexSessionCli } = await import("./.setup/session-cli-irrD-uo7.mjs");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/doctor-contract-api.js

@@ -228,8 +228,8 @@ function normalizeCompatibilityConfig({ cfg }) {
 const stateMigrations = [{
 	id: "codex-app-server-sidecars-to-plugin-state",
 	label: "Codex app-server thread bindings",
-	detectLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-CKYEcfNn.mjs")).detectLegacySessionBindingSidecars(params),
-	migrateLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-CKYEcfNn.mjs")).migrateLegacySessionBindingSidecars(params)
+	detectLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-BlB5EvIS.mjs")).detectLegacySessionBindingSidecars(params),
+	migrateLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-BlB5EvIS.mjs")).migrateLegacySessionBindingSidecars(params)
 }, codexOrphanedSessionBindingMigration];
 //#endregion
 export { legacyConfigRules, normalizeCompatibilityConfig, stateMigrations };