@openclaw/codex 2026.5.12 → 2026.5.14-beta.1

package/dist/{client-iRf11BEu.js → client-CoctX13d.js}

@@ -201,6 +201,7 @@ const CODEX_APP_SERVER_PARSE_BUFFER_MAX = 1e6;
 const CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES = 1e3;
 const CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS = 6e5;
 const CODEX_APP_SERVER_STDERR_TAIL_MAX = 2e3;
+const UNPAIRED_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
 var CodexAppServerRpcError = class extends Error {
 	constructor(error, method) {
 		super(formatCodexAppServerRpcErrorMessage(error, method));
@@ -370,7 +371,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		if (this.closed) return;
 		const id = "id" in message ? message.id : void 0;
 		const method = "method" in message ? message.method : void 0;
-		this.child.stdin.write(`${JSON.stringify(message)}\n`, (error) => {
+		this.child.stdin.write(`${stringifyCodexAppServerMessage(message)}\n`, (error) => {
 			if (error) embeddedAgentLog.warn("codex app-server write failed", {
 				error,
 				id,
@@ -551,6 +552,9 @@ function defaultServerRequestResponse(request) {
 	if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
 	return {};
 }
+function stringifyCodexAppServerMessage(message) {
+	return JSON.stringify(message, (_key, value) => typeof value === "string" ? value.replace(UNPAIRED_SURROGATE_RE, "") : value) ?? "null";
+}
 function timeoutServerRequestResponse(request) {
 	if (request.method !== "item/tool/call") return;
 	return {

package/dist/{client-factory-DfnbdQv7.js → client-factory-BB5hgnWH.js}

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

package/dist/{command-formatters-Ttwc_kgX.js → command-formatters-CJH9-hFT.js}

@@ -2,6 +2,7 @@ import { t as isJsonObject } from "./protocol-C9UWI98H.js";
 //#region extensions/codex/src/app-server/rate-limits.ts
 const CODEX_LIMIT_ID = "codex";
 const LIMIT_WINDOW_KEYS = ["primary", "secondary"];
+const ONE_SECOND_MS = 1e3;
 const ONE_MINUTE_MS = 6e4;
 const ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
 const ONE_DAY_MS = 24 * ONE_HOUR_MS;
@@ -85,7 +86,7 @@ function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	});
 	const reachedType = readString$1(snapshot, "rateLimitReachedType") ?? readString$1(snapshot, "rate_limit_reached_type");
 	const suffix = reachedType ? ` (${formatReachedType(reachedType)})` : "";
-	return `${label}: ${windows.join(", ") || "available"}${suffix}`;
+	return `${label}: ${windows.join(" · ") || "available"}${suffix}`;
 }
 function collectCodexRateLimitSnapshots(value) {
 	const snapshots = [];
@@ -151,7 +152,7 @@ function formatRateLimitWindow(key, window, nowMs) {
 	return `${key} ${formatRateLimitWindowDetails(window, nowMs)}`;
 }
 function formatRateLimitWindowDetails(window, nowMs) {
-	return `${window.usedPercent === void 0 ? "usage unknown" : `${Math.round(window.usedPercent)}%`}${window.resetsAtMs > nowMs ? `, resets ${formatResetTime(window.resetsAtMs, nowMs)}` : ""}`;
+	return `${window.usedPercent === void 0 ? "usage unknown" : `${Math.max(0, 100 - Math.round(window.usedPercent))}% left`}${window.resetsAtMs > nowMs ? ` ⏱${formatResetDuration(window.resetsAtMs, nowMs)}` : ""}`;
 }
 function formatLimitLabel(snapshot) {
 	const label = readNullableString(snapshot, "limitName") ?? readNullableString(snapshot, "limit_name") ?? readNullableString(snapshot, "limitId") ?? readNullableString(snapshot, "limit_id");
@@ -249,6 +250,17 @@ function formatRelativeDuration(durationMs) {
 	const days = Math.ceil(safeMs / ONE_DAY_MS);
 	return `${days} ${days === 1 ? "day" : "days"}`;
 }
+function formatResetDuration(resetsAtMs, nowMs) {
+	const durationMs = Math.round(Math.max(ONE_SECOND_MS, resetsAtMs - nowMs) / ONE_SECOND_MS) * ONE_SECOND_MS;
+	const days = Math.floor(durationMs / ONE_DAY_MS);
+	const hours = Math.floor(durationMs % ONE_DAY_MS / ONE_HOUR_MS);
+	const minutes = Math.floor(durationMs % ONE_HOUR_MS / ONE_MINUTE_MS);
+	const seconds = Math.floor(durationMs % ONE_MINUTE_MS / ONE_SECOND_MS);
+	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+	return `${seconds}s`;
+}
 function formatWindowSignature(value) {
 	if (!isJsonObject(value)) return "";
 	return `${readNumber(value, "usedPercent") ?? readNumber(value, "used_percent") ?? ""}:${readNumber(value, "resetsAt") ?? readNumber(value, "resets_at") ?? ""}`;
@@ -410,7 +422,9 @@ function buildHelp() {
 		"- /codex status",
 		"- /codex models",
 		"- /codex threads [filter]",
+		"- /codex sessions --host <node> [filter]",
 		"- /codex resume <thread-id>",
+		"- /codex resume <session-id> --host <node> --bind here",
 		"- /codex bind [thread-id] [--cwd <path>] [--model <model>] [--provider <provider>]",
 		"- /codex binding",
 		"- /codex stop",

package/dist/{command-handlers-BYf_veEb.js → command-handlers-DIXo49aO.js}

@@ -1,11 +1,11 @@
 import { i as isCodexFastServiceTier, s as resolveCodexAppServerRuntimeOptions } from "./config-0rd3LnKg.js";
-import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-BmLfrDci.js";
+import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-GCYf5s8J.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { n as CODEX_CONTROL_METHODS, r as describeControlFailure, t as requestCodexAppServerJson } from "./request-ohCy5ASa.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-Ttwc_kgX.js";
+import { n as CODEX_CONTROL_METHODS, r as describeControlFailure, t as requestCodexAppServerJson } from "./request-BxAP1uyw.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-CJH9-hFT.js";
 import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-CMTXuyoz.js";
-import { a as parseCodexFastModeArg, c as setCodexConversationFastMode, d as steerCodexConversationTurn, f as stopCodexConversationTurn, i as formatPermissionsMode, l as setCodexConversationModel, m as resolveCodexDefaultWorkspaceDir, o as parseCodexPermissionsModeArg, p as readCodexConversationBindingData, r as startCodexConversationThread, s as readCodexConversationActiveTurn, u as setCodexConversationPermissions } from "./conversation-binding-CKofEetY.js";
-import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-Ct3ngNBt.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-CV5Kmdwt.js";
+import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-DFdLwPQa.js";
 import { n as rememberCodexRateLimits } from "./rate-limit-cache-BFi-50LG.js";
 import crypto from "node:crypto";
 import { ensureAuthProfileStore, findNormalizedProviderValue, resolveAuthProfileEligibility, resolveAuthProfileOrder, resolveDefaultAgentDir, resolveProfileUnusableUntilForDisplay } from "openclaw/plugin-sdk/agent-runtime";
@@ -366,7 +366,13 @@ const defaultCodexCommandDeps = {
 	setCodexConversationModel,
 	setCodexConversationPermissions,
 	steerCodexConversationTurn,
-	stopCodexConversationTurn
+	stopCodexConversationTurn,
+	listCodexCliSessionsOnNode: async () => {
+		throw new Error("Codex CLI node sessions require Gateway node runtime.");
+	},
+	resolveCodexCliSessionForBindingOnNode: async () => {
+		throw new Error("Codex CLI node sessions require Gateway node runtime.");
+	}
 };
 const CODEX_DIAGNOSTICS_SOURCE = "openclaw-diagnostics";
 const CODEX_DIAGNOSTICS_REASON_MAX_CHARS = 2048;
@@ -400,6 +406,7 @@ async function handleCodexSubcommand(ctx, options) {
 		return { text: formatModels(await deps.listCodexAppServerModels(deps.requestOptions(options.pluginConfig, 100, ctx.config))) };
 	}
 	if (normalized === "threads") return { text: await buildThreads(deps, options.pluginConfig, rest.join(" ")) };
+	if (normalized === "sessions") return { text: await buildCodexCliSessions(deps, rest) };
 	if (normalized === "resume") return { text: await resumeThread(deps, ctx, options.pluginConfig, rest) };
 	if (normalized === "bind") return await bindConversation(deps, ctx, options.pluginConfig, rest);
 	if (normalized === "detach" || normalized === "unbind") {
@@ -493,7 +500,7 @@ async function bindConversation(deps, ctx, pluginConfig, args) {
 async function detachConversation(deps, ctx) {
 	const data = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
 	const detached = await ctx.detachConversationBinding();
-	if (data) await deps.clearCodexAppServerBinding(data.sessionFile);
+	if (data?.kind === "codex-app-server-session") await deps.clearCodexAppServerBinding(data.sessionFile);
 	else if (ctx.sessionFile) await deps.clearCodexAppServerBinding(ctx.sessionFile);
 	return detached.removed ? "Detached this conversation from Codex." : "No Codex conversation binding was attached.";
 }
@@ -501,6 +508,14 @@ async function describeConversationBinding(deps, ctx) {
 	const current = await ctx.getCurrentConversationBinding();
 	const data = readCodexConversationBindingData(current);
 	if (!current || !data) return "No Codex conversation binding is attached.";
+	if (data.kind === "codex-cli-node-session") return [
+		"Codex conversation binding:",
+		"- Mode: Codex CLI node session",
+		`- Node: ${formatCodexDisplayText(data.nodeId)}`,
+		`- Session: ${formatCodexDisplayText(data.sessionId)}`,
+		`- Workspace: ${formatCodexDisplayText(data.cwd ?? "unknown")}`,
+		"- Active run: not tracked"
+	].join("\n");
 	const threadBinding = await deps.readCodexAppServerBinding(data.sessionFile);
 	const active = deps.readCodexConversationActiveTurn(data.sessionFile);
 	return [
@@ -520,9 +535,20 @@ async function buildThreads(deps, pluginConfig, filter) {
 		...filter.trim() ? { searchTerm: filter.trim() } : {}
 	}));
 }
+async function buildCodexCliSessions(deps, args) {
+	const parsed = parseCodexCliSessionsArgs(args);
+	if (parsed.help || !parsed.host) return "Usage: /codex sessions --host <node> [filter] [--limit <n>]";
+	return formatCodexCliSessions(await deps.listCodexCliSessionsOnNode({
+		requestedNode: parsed.host,
+		filter: parsed.filter,
+		limit: parsed.limit
+	}));
+}
 async function resumeThread(deps, ctx, pluginConfig, args) {
-	const [threadId] = args;
-	const normalizedThreadId = threadId?.trim();
+	const parsed = parseResumeArgs(args);
+	const normalizedThreadId = parsed.threadId?.trim();
+	if (parsed.help) return args.includes("--help") || args.includes("-h") || parsed.host ? "Usage: /codex resume <thread-id>\nUsage: /codex resume <session-id> --host <node> --bind here" : "Usage: /codex resume <thread-id>";
+	if (parsed.host) return await bindCodexCliNodeSession(deps, ctx, parsed);
 	if (!normalizedThreadId || args.length !== 1) return "Usage: /codex resume <thread-id>";
 	if (!ctx.sessionFile) return "Cannot attach a Codex thread because this command did not include an OpenClaw session file.";
 	const response = await deps.codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.resumeThread, {
@@ -539,6 +565,30 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 	});
 	return `Attached this OpenClaw session to Codex thread ${formatCodexDisplayText(effectiveThreadId)}.`;
 }
+async function bindCodexCliNodeSession(deps, ctx, parsed) {
+	if (!parsed.threadId || !parsed.host || parsed.bindHere !== true) return "Usage: /codex resume <session-id> --host <node> --bind here";
+	const resolved = await deps.resolveCodexCliSessionForBindingOnNode({
+		requestedNode: parsed.host,
+		sessionId: parsed.threadId
+	});
+	if (!resolved.session) return `No Codex CLI session ${formatCodexDisplayText(parsed.threadId)} was found on ${formatCodexDisplayText(parsed.host)}.`;
+	const nodeId = resolved.node.nodeId;
+	if (!nodeId) return "Cannot bind Codex CLI session because the selected node did not include a node id.";
+	const data = createCodexCliNodeConversationBindingData({
+		nodeId,
+		sessionId: parsed.threadId,
+		cwd: resolved.session?.cwd
+	});
+	const summary = `Codex CLI session ${formatCodexDisplayText(parsed.threadId)} on ${formatCodexDisplayText(nodeId)}`;
+	const request = await ctx.requestConversationBinding({
+		summary,
+		detachHint: "/codex detach",
+		data
+	});
+	if (request.status === "bound") return `Bound this conversation to Codex CLI session ${formatCodexDisplayText(parsed.threadId)} on ${formatCodexDisplayText(nodeId)}.`;
+	if (request.status === "pending") return request.reply.text ?? "Codex CLI session binding is pending approval.";
+	return formatCodexDisplayText(request.message);
+}
 async function stopConversationTurn(deps, ctx, pluginConfig) {
 	const sessionFile = await resolveControlSessionFile(ctx);
 	if (!sessionFile) return "Cannot stop Codex because this command did not include an OpenClaw session file.";
@@ -599,7 +649,8 @@ async function setConversationPermissions(deps, ctx, pluginConfig, args) {
 	});
 }
 async function resolveControlSessionFile(ctx) {
-	return readCodexConversationBindingData(await ctx.getCurrentConversationBinding())?.sessionFile ?? ctx.sessionFile;
+	const data = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
+	return data?.kind === "codex-app-server-session" ? data.sessionFile : ctx.sessionFile;
 }
 async function handleCodexDiagnosticsFeedback(deps, ctx, pluginConfig, args, commandPrefix) {
 	if (ctx.senderIsOwner !== true) return { text: "Only an owner can send Codex diagnostics." };
@@ -1175,6 +1226,83 @@ function parseBindArgs(args) {
 	parsed.provider = normalizeOptionalString(parsed.provider);
 	return parsed;
 }
+function parseCodexCliSessionsArgs(args) {
+	const parsed = { filter: "" };
+	const filter = [];
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h") {
+			parsed.help = true;
+			continue;
+		}
+		if (arg === "--host" || arg === "--node") {
+			const value = readRequiredOptionValue(args, index);
+			if (!value || parsed.host !== void 0) {
+				parsed.help = true;
+				continue;
+			}
+			parsed.host = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "--limit") {
+			const value = readRequiredOptionValue(args, index);
+			const parsedLimit = value ? Number.parseInt(value, 10) : NaN;
+			if (!Number.isFinite(parsedLimit) || parsedLimit <= 0) {
+				parsed.help = true;
+				continue;
+			}
+			parsed.limit = parsedLimit;
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("-")) {
+			parsed.help = true;
+			continue;
+		}
+		filter.push(arg);
+	}
+	parsed.host = normalizeOptionalString(parsed.host);
+	parsed.filter = filter.join(" ").trim();
+	return parsed;
+}
+function parseResumeArgs(args) {
+	const parsed = {};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--help" || arg === "-h") {
+			parsed.help = true;
+			continue;
+		}
+		if (arg === "--host" || arg === "--node") {
+			const value = readRequiredOptionValue(args, index);
+			if (!value || parsed.host !== void 0) {
+				parsed.help = true;
+				continue;
+			}
+			parsed.host = value;
+			index += 1;
+			continue;
+		}
+		if (arg === "--bind") {
+			if (readRequiredOptionValue(args, index) !== "here" || parsed.bindHere !== void 0) {
+				parsed.help = true;
+				continue;
+			}
+			parsed.bindHere = true;
+			index += 1;
+			continue;
+		}
+		if (!arg.startsWith("-") && !parsed.threadId) {
+			parsed.threadId = arg;
+			continue;
+		}
+		parsed.help = true;
+	}
+	parsed.threadId = normalizeOptionalString(parsed.threadId);
+	parsed.host = normalizeOptionalString(parsed.host);
+	return parsed;
+}
 function parseComputerUseArgs(args) {
 	const parsed = {
 		action: "status",

package/dist/{compact-Bl8jRPk4.js → compact-Ck9ckRkJ.js}

@@ -1,7 +1,7 @@
 import { s as resolveCodexAppServerRuntimeOptions } from "./config-0rd3LnKg.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
 import { i as readCodexAppServerBinding } from "./session-binding-CMTXuyoz.js";
-import { n as defaultCodexAppServerClientFactory, t as createCodexAppServerClientFactoryTestHooks } from "./client-factory-DfnbdQv7.js";
+import { n as defaultCodexAppServerClientFactory, t as createCodexAppServerClientFactoryTestHooks } from "./client-factory-BB5hgnWH.js";
 import { embeddedAgentLog, formatErrorMessage, isActiveHarnessContextEngine, 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;

package/dist/{computer-use-Ct3ngNBt.js → computer-use-DFdLwPQa.js}

@@ -1,5 +1,5 @@
 import { c as resolveCodexComputerUseConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-0rd3LnKg.js";
-import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-ohCy5ASa.js";
+import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-BxAP1uyw.js";
 import { existsSync } from "node:fs";
 //#region extensions/codex/src/app-server/computer-use.ts
 var CodexComputerUseSetupError = class extends Error {

package/dist/harness.js

@@ -18,15 +18,15 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-4t06MuNr.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-CN9AS7qv.js");
 			return runCodexAppServerAttempt(params, { pluginConfig: options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-DV7KYIB8.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-BsBqLpar.js");
 			return runCodexAppServerSideQuestion(params, { pluginConfig: options?.pluginConfig });
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-Bl8jRPk4.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-Ck9ckRkJ.js");
 			return maybeCompactCodexAppServerSession(params, { pluginConfig: options?.pluginConfig });
 		},
 		reset: async (params) => {
@@ -36,7 +36,7 @@ function createCodexAppServerAgentHarness(options) {
 			}
 		},
 		dispose: async () => {
-			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-Cr6W-a2G.js").then((n) => n.i);
+			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-BwUqd3lh.js").then((n) => n.a);
 			await clearSharedCodexAppServerClientAndWait();
 		}
 	};

package/dist/index.js

@@ -2,12 +2,12 @@ import { createCodexAppServerAgentHarness } from "./harness.js";
 import { o as readCodexPluginConfig, s as resolveCodexAppServerRuntimeOptions, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-0rd3LnKg.js";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
 import { buildCodexProvider } from "./provider.js";
-import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-ohCy5ASa.js";
-import { r as formatCodexDisplayText } from "./command-formatters-Ttwc_kgX.js";
-import { l as resolveCodexAppServerAuthProfileIdForAgent, s as resolveCodexAppServerAuthAccountCacheKey, u as resolveCodexAppServerEnvApiKeyCacheKey } from "./shared-client-Cr6W-a2G.js";
-import { n as handleCodexConversationInboundClaim, t as handleCodexConversationBindingResolved } from "./conversation-binding-CKofEetY.js";
+import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-BxAP1uyw.js";
+import { r as formatCodexDisplayText } from "./command-formatters-CJH9-hFT.js";
+import { c as resolveCodexAppServerAuthAccountCacheKey, d as resolveCodexAppServerEnvApiKeyCacheKey, i as getSharedCodexAppServerClient, t as clearSharedCodexAppServerClientAndWait, u as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-BwUqd3lh.js";
+import { a as resolveCodexCliSessionForBindingOnNode, c as handleCodexConversationInboundClaim, i as listCodexCliSessionsOnNode, n as createCodexCliSessionNodeInvokePolicies, o as resumeCodexCliSessionOnNode, s as handleCodexConversationBindingResolved, t as createCodexCliSessionNodeHostCommands } from "./node-cli-sessions-CV5Kmdwt.js";
 import { a as defaultCodexAppInventoryCache, n as pluginReadParams, t as ensureCodexPluginActivation } from "./plugin-activation-PXGqUjwY.js";
-import { t as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-B7eU8fNZ.js";
+import { t as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-DBlqE0gO.js";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import os from "node:os";
@@ -39,7 +39,7 @@ async function handleCodexCommand(ctx, options = {}) {
 	}
 }
 async function loadDefaultCodexSubcommandHandler() {
-	const { handleCodexSubcommand } = await import("./command-handlers-BYf_veEb.js");
+	const { handleCodexSubcommand } = await import("./command-handlers-DIXo49aO.js");
 	return handleCodexSubcommand;
 }
 //#endregion
@@ -124,7 +124,7 @@ async function discoverPluginDirs(codexHome) {
 				manifestPath,
 				sourceKind: "cache",
 				migratable: false,
-				message: "Cached Codex plugin bundle found. Review manually unless the plugin is also installed in the source Codex app-server inventory."
+				message: "Cached Codex plugin bundle found. Review manually unless the plugin is also installed in the source Codex app-server inventory"
 			});
 			return;
 		}
@@ -412,7 +412,7 @@ async function discoverCodexSource(inputOrOptions) {
 	const hooksPath = path.join(codexHome, "hooks", "hooks.json");
 	const codexSkills = await discoverSkillDirs({
 		root: codexSkillsDir,
-		sourceLabel: "Codex CLI skill",
+		sourceLabel: "Codex skill",
 		excludeSystem: true
 	});
 	const personalAgentSkills = await discoverSkillDirs({
@@ -431,13 +431,13 @@ async function discoverCodexSource(inputOrOptions) {
 		id: "archive:config.toml",
 		path: configPath,
 		relativePath: "config.toml",
-		message: "Codex config is archived for manual review; it is not activated automatically."
+		message: "Codex config is archived for manual review; it is not activated automatically"
 	});
 	if (await exists(hooksPath)) archivePaths.push({
 		id: "archive:hooks/hooks.json",
 		path: hooksPath,
 		relativePath: "hooks/hooks.json",
-		message: "Codex native hooks are archived for manual review because they can execute commands."
+		message: "Codex native hooks are archived for manual review because they can execute commands"
 	});
 	const skills = [...codexSkills, ...personalAgentSkills].toSorted((a, b) => a.source.localeCompare(b.source));
 	const high = Boolean(codexSkills.length || plugins.length || archivePaths.length);
@@ -727,7 +727,6 @@ async function buildCodexMigrationPlan(ctx) {
 		...items.some((item) => item.status === "conflict") ? ["Conflicts were found. Re-run with --overwrite to replace conflicting migration targets after item-level backups."] : [],
 		...source.plugins.some((plugin) => plugin.migratable) ? ["Codex source-installed openai-curated plugins are planned for native activation; cached plugin bundles remain manual-review only."] : [],
 		...source.plugins.some((plugin) => plugin.migratable && plugin.apps && plugin.apps.length > 0) && !shouldVerifyPluginApps(ctx) ? ["Codex app-backed plugins were planned without source app accessibility verification. Re-run with --verify-plugin-apps to force a fresh source app/list check before planning native plugin activation."] : [],
-		...source.plugins.some((plugin) => plugin.sourceKind === "cache") ? ["Codex cached plugin bundles remain manual-review only."] : [],
 		...source.pluginDiscoveryError ? [`Codex app-server plugin inventory discovery failed: ${source.pluginDiscoveryError}. Cached plugin bundles, if any, are advisory only.`] : [],
 		...source.plugins.some((plugin) => plugin.migrationBlock?.code === "codex_subscription_required") ? [codexPluginMigrationSubscriptionWarning()] : [],
 		...source.archivePaths.length > 0 ? ["Codex config and hook files are archive-only. They are preserved in the migration report, not loaded into OpenClaw automatically."] : []
@@ -752,6 +751,11 @@ async function buildCodexMigrationPlan(ctx) {
 //#region extensions/codex/src/migration/apply.ts
 const CODEX_PLUGIN_AUTH_REQUIRED_REASON = "auth_required";
 const CODEX_PLUGIN_NOT_SELECTED_REASON = "not selected for migration";
+const CODEX_CONFIG_PATCH_MODE_RETURN = "return";
+const CODEX_PLUGIN_LOAD_WARNING = "Some Codex plugins could not be migrated. Run `openclaw migrate codex` after onboarding.";
+const TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS = 250;
+const TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_MS = 3e4;
+const TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_ENV = "OPENCLAW_CODEX_MIGRATION_PLUGIN_LIST_TIMEOUT_MS";
 var CodexPluginConfigConflictError = class extends Error {
 	constructor(reason) {
 		super(reason);
@@ -759,6 +763,26 @@ var CodexPluginConfigConflictError = class extends Error {
 		this.name = "CodexPluginConfigConflictError";
 	}
 };
+function shouldReturnCodexPluginConfigPatch(ctx) {
+	return ctx.providerOptions?.configPatchMode === CODEX_CONFIG_PATCH_MODE_RETURN;
+}
+function prepareTargetCodexAppServer(ctx) {
+	const appServer = resolveTargetCodexAppServer(ctx);
+	const targets = resolveCodexMigrationTargets(ctx);
+	const ready = getSharedCodexAppServerClient({
+		startOptions: appServer.start,
+		timeoutMs: 6e4,
+		agentDir: targets.agentDir,
+		config: ctx.config
+	}).then(() => void 0, () => void 0);
+	return { async dispose() {
+		await ready;
+		await clearSharedCodexAppServerClientAndWait({
+			exitTimeoutMs: 2e3,
+			forceKillDelayMs: 250
+		});
+	} };
+}
 async function applyCodexMigrationPlan(params) {
 	const plan = params.plan ?? await buildCodexMigrationPlan(params.ctx);
 	const reportDir = params.ctx.reportDir ?? path.join(params.ctx.stateDir, "migration", "codex");
@@ -786,6 +810,10 @@ async function applyCodexMigrationPlan(params) {
 		backupPath: params.ctx.backupPath,
 		reportDir
 	};
+	if (items.some(isCodexPluginLoadWarningItem)) {
+		result.warnings = [...new Set([...result.warnings ?? [], CODEX_PLUGIN_LOAD_WARNING])];
+		result.nextSteps = [...new Set([CODEX_PLUGIN_LOAD_WARNING, ...result.nextSteps ?? []])];
+	}
 	await writeMigrationReport(result, { title: "Codex Migration Report" });
 	return result;
 }
@@ -804,14 +832,14 @@ async function applyCodexPluginInstallItem(ctx, item) {
 		const result = await ensureCodexPluginActivation({
 			identity: policy,
 			installEvenIfActive: true,
-			request: async (method, requestParams) => await requestCodexAppServerJson({
+			request: async (method, requestParams) => await requestTargetCodexAppServerJson({
 				method,
 				requestParams,
 				timeoutMs: 6e4,
 				startOptions: appServer.start,
 				agentDir: resolveCodexMigrationTargets(ctx).agentDir,
 				config: ctx.config,
-				isolated: true
+				isolated: false
 			}),
 			appCache: defaultCodexAppInventoryCache,
 			appCacheKey
@@ -839,6 +867,16 @@ async function applyCodexPluginInstallItem(ctx, item) {
 				appsNeedingAuth: sanitizeAppsNeedingAuth(result.installResponse?.appsNeedingAuth ?? [])
 			}
 		};
+		if (result.reason === "plugin_missing" || result.reason === "marketplace_missing") return {
+			...item,
+			status: "warning",
+			reason: result.reason,
+			message: `Codex plugin "${policy.pluginName}" could not be migrated automatically`,
+			details: {
+				...baseDetails,
+				warningReason: CODEX_PLUGIN_LOAD_WARNING
+			}
+		};
 		return {
 			...item,
 			status: "error",
@@ -846,10 +884,22 @@ async function applyCodexPluginInstallItem(ctx, item) {
 			details: baseDetails
 		};
 	} catch (error) {
+		if (isCodexPluginInventoryLoadError(error)) return {
+			...item,
+			status: "warning",
+			reason: "plugin_inventory_unavailable",
+			message: `Codex plugin "${policy.pluginName}" could not be migrated automatically`,
+			details: {
+				...item.details,
+				code: "plugin_inventory_unavailable",
+				warningReason: CODEX_PLUGIN_LOAD_WARNING,
+				diagnostic: formatCodexMigrationError(error)
+			}
+		};
 		return {
 			...item,
 			status: "error",
-			reason: error instanceof Error ? error.message : String(error),
+			reason: formatCodexMigrationError(error),
 			details: {
 				...item.details,
 				code: "plugin_install_failed"
@@ -857,9 +907,51 @@ async function applyCodexPluginInstallItem(ctx, item) {
 		};
 	}
 }
+function isCodexPluginInventoryLoadError(error) {
+	return formatCodexMigrationError(error).includes("codex app-server plugin/list timed out");
+}
+function formatCodexMigrationError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 function resolveTargetCodexAppServer(ctx) {
 	return resolveCodexAppServerRuntimeOptions({ pluginConfig: readCodexPluginConfig(ctx.config) });
 }
+async function requestTargetCodexAppServerJson(params) {
+	if (params.method !== "plugin/list") return await requestCodexAppServerJson(params);
+	const deadline = Date.now() + params.timeoutMs;
+	const discoveryTimeoutMs = targetCodexMarketplaceDiscoveryTimeoutMs();
+	const discoveryDeadline = Math.min(deadline, Date.now() + discoveryTimeoutMs);
+	let lastResponse;
+	let attempt = 0;
+	do {
+		attempt += 1;
+		const remainingMs = Math.max(1, discoveryDeadline - Date.now());
+		lastResponse = await requestCodexAppServerJson({
+			...params,
+			timeoutMs: remainingMs
+		});
+		if (hasOpenAiCuratedMarketplace(lastResponse)) return lastResponse;
+		if (Date.now() >= discoveryDeadline) return lastResponse;
+		await sleep(Math.min(TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS, discoveryDeadline - Date.now()));
+	} while (Date.now() < discoveryDeadline);
+	return lastResponse;
+}
+function hasOpenAiCuratedMarketplace(response) {
+	if (!response || typeof response !== "object" || !("marketplaces" in response)) return false;
+	const marketplaces = response.marketplaces;
+	return Array.isArray(marketplaces) && marketplaces.some((marketplace) => marketplace && typeof marketplace === "object" && marketplace.name === "openai-curated");
+}
+function targetCodexMarketplaceDiscoveryTimeoutMs() {
+	const configured = Number(process.env[TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_ENV]);
+	if (Number.isFinite(configured) && configured >= 0) return configured;
+	return TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_MS;
+}
+function isCodexPluginLoadWarningItem(item) {
+	return item.kind === "plugin" && item.action === "install" && item.status === "warning" && item.details?.warningReason === CODEX_PLUGIN_LOAD_WARNING;
+}
+async function sleep(ms) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function buildTargetCodexPluginAppCacheKey(ctx) {
 	const targets = resolveCodexMigrationTargets(ctx);
 	const appServer = resolveTargetCodexAppServer(ctx);
@@ -884,11 +976,23 @@ async function buildTargetCodexPluginAppCacheKey(ctx) {
 async function applyCodexPluginConfigItem(ctx, item, appliedItems) {
 	const entries = appliedItems.map(readAppliedPluginConfigEntry).filter((entry) => entry !== void 0);
 	if (entries.length === 0) return markMigrationItemSkipped(item, "no selected Codex plugins");
+	const returnPatch = shouldReturnCodexPluginConfigPatch(ctx);
 	const configApi = ctx.runtime?.config;
-	if (!configApi?.current || !configApi.mutateConfigFile) return markMigrationItemError(item, "config runtime unavailable");
-	const currentConfig = configApi.current();
+	const currentConfig = returnPatch ? ctx.config : configApi?.current?.();
+	if (!currentConfig) return markMigrationItemError(item, "config runtime unavailable");
 	const value = buildCodexPluginsConfigValue(entries, { config: currentConfig });
 	if (!ctx.overwrite && hasCodexPluginConfigConflict(currentConfig, value)) return markMigrationItemConflict(item, MIGRATION_REASON_TARGET_EXISTS);
+	const migratedItem = {
+		...item,
+		status: "migrated",
+		details: {
+			...item.details,
+			path: [...CODEX_PLUGIN_CONFIG_PATH],
+			value
+		}
+	};
+	if (returnPatch) return migratedItem;
+	if (!configApi?.mutateConfigFile) return markMigrationItemError(item, "config runtime unavailable");
 	try {
 		await configApi.mutateConfigFile({
 			base: "runtime",
@@ -898,15 +1002,7 @@ async function applyCodexPluginConfigItem(ctx, item, appliedItems) {
 				writeMigrationConfigPath(draft, CODEX_PLUGIN_CONFIG_PATH, value);
 			}
 		});
-		return {
-			...item,
-			status: "migrated",
-			details: {
-				...item.details,
-				path: [...CODEX_PLUGIN_CONFIG_PATH],
-				value
-			}
-		};
+		return migratedItem;
 	} catch (error) {
 		if (error instanceof CodexPluginConfigConflictError) return markMigrationItemConflict(item, error.reason);
 		return markMigrationItemError(item, error instanceof Error ? error.message : String(error));
@@ -979,6 +1075,9 @@ function buildCodexMigrationProvider(params = {}) {
 			};
 		},
 		plan: buildCodexMigrationPlan,
+		prepareApply(ctx) {
+			return prepareTargetCodexAppServer(ctx);
+		},
 		async apply(ctx, plan) {
 			return await applyCodexMigrationPlan({
 				ctx,
@@ -1000,8 +1099,28 @@ var codex_default = definePluginEntry({
 		api.registerProvider(buildCodexProvider({ pluginConfig: api.pluginConfig }));
 		api.registerMediaUnderstandingProvider(buildCodexMediaUnderstandingProvider({ pluginConfig: api.pluginConfig }));
 		api.registerMigrationProvider(buildCodexMigrationProvider({ runtime: api.runtime }));
-		api.registerCommand(createCodexCommand({ pluginConfig: api.pluginConfig }));
-		api.on("inbound_claim", (event, ctx) => handleCodexConversationInboundClaim(event, ctx, { pluginConfig: resolveCurrentPluginConfig() }));
+		for (const command of createCodexCliSessionNodeHostCommands()) api.registerNodeHostCommand(command);
+		for (const policy of createCodexCliSessionNodeInvokePolicies()) api.registerNodeInvokePolicy(policy);
+		api.registerCommand(createCodexCommand({
+			pluginConfig: api.pluginConfig,
+			deps: {
+				listCodexCliSessionsOnNode: (params) => listCodexCliSessionsOnNode({
+					runtime: api.runtime,
+					...params
+				}),
+				resolveCodexCliSessionForBindingOnNode: (params) => resolveCodexCliSessionForBindingOnNode({
+					runtime: api.runtime,
+					...params
+				})
+			}
+		}));
+		api.on("inbound_claim", (event, ctx) => handleCodexConversationInboundClaim(event, ctx, {
+			pluginConfig: resolveCurrentPluginConfig(),
+			resumeCodexCliSessionOnNode: (params) => resumeCodexCliSessionOnNode({
+				runtime: api.runtime,
+				...params
+			})
+		}));
 		api.onConversationBindingResolved?.(handleCodexConversationBindingResolved);
 	}
 });