@openclaw/codex 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/{session-catalog-DsKaezgR.js → session-catalog-DyOgR4WH.js}

@@ -1,30 +1,128 @@
-import { J as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, Q as isJsonObject, R as CodexAppServerRpcError, Y as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, a as getLeasedSharedCodexAppServerClient, c as releaseLeasedSharedCodexAppServerClient, m as withTimeout, q as resolveCodexAppServerClientInstanceId } from "./shared-client-wmgNFNYp.js";
-import { D as resolveCodexSupervisionAppServerRuntimeOptions, c as reclaimCurrentCodexSessionGeneration, l as sessionBindingIdentity, x as resolveCodexAppServerRuntimeOptions } from "./session-binding-ZSMX1omP.js";
-import { m as assertCodexThreadForkParams, r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-2p7kl6e4.js";
-import { n as listCodexAppServerModels } from "./models-BNeMlHgg.js";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-CvzvmBRz.js";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-CLICvTxf.js";
-import { r as formatCodexDisplayText } from "./command-formatters-DgADqnHa.js";
+import { B as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, D as resolveCodexAppServerClientInstanceId, V as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, W as isJsonObject, a as getLeasedSharedCodexAppServerClient, g as withTimeout, l as releaseLeasedSharedCodexAppServerClient, v as CodexAppServerRpcError } from "./shared-client-DTbvH-XV.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, g as resolveCodexAppServerRuntimeOptions, y as resolveCodexSupervisionAppServerRuntimeOptions } from "./session-binding-BXpo9ymA.js";
+import { m as assertCodexThreadForkParams, r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-DzsdNCf5.js";
+import { n as listCodexAppServerModels } from "./models-BBMKU4jA.js";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DztPafOA.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-BFDTVYr4.js";
+import { r as formatCodexDisplayText } from "./command-formatters-C336eRVS.js";
 import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-BHRpYbX3.js";
-import { n as requestCodexAppServerClientJson, r as requestCodexAppServerJson } from "./request-BTccUTD3.js";
-import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-D7XlI9us.js";
+import { n as requestCodexAppServerClientJson, r as requestCodexAppServerJson } from "./request-qKh331yu.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-B6U7tLw5.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
-import os from "node:os";
 import { listAgentIds, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import os from "node:os";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
-import { spawn } from "node:child_process";
 import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { spawn } from "node:child_process";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import process$1 from "node:process";
+import { listSessionCatalogEntries } from "openclaw/plugin-sdk/session-catalog";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { decodeNodePtyResumeParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
+//#region extensions/codex/src/jsonl-lines.ts
+const JSONL_STREAM_THRESHOLD_BYTES = 4 * 1024 * 1024;
+const JSONL_READ_CHUNK_BYTES = 1024 * 1024;
+async function visitJsonlLines(file, visitor, chunkBytes = JSONL_READ_CHUNK_BYTES) {
+	let size;
+	try {
+		size = (await fs.stat(file)).size;
+	} catch {
+		return {
+			ok: false,
+			lineCount: 0
+		};
+	}
+	if (size <= JSONL_STREAM_THRESHOLD_BYTES) {
+		let content;
+		try {
+			content = await fs.readFile(file, "utf8");
+		} catch {
+			return {
+				ok: false,
+				lineCount: 0
+			};
+		}
+		if (content.length === 0) return {
+			ok: true,
+			lineCount: 0
+		};
+		let lineCount = 0;
+		for (const line of content.split(/\r?\n/u)) {
+			lineCount += 1;
+			if (visitor(line) === false) break;
+		}
+		return {
+			ok: true,
+			lineCount
+		};
+	}
+	let handle;
+	try {
+		handle = await fs.open(file, "r");
+	} catch {
+		return {
+			ok: false,
+			lineCount: 0
+		};
+	}
+	const buffer = Buffer.allocUnsafe(chunkBytes);
+	const decoder = new TextDecoder();
+	let pendingFragments = [];
+	let lineCount = 0;
+	try {
+		while (true) {
+			const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+			if (bytesRead === 0) break;
+			const content = decoder.decode(buffer.subarray(0, bytesRead), { stream: true });
+			let lineStart = 0;
+			while (true) {
+				const newline = content.indexOf("\n", lineStart);
+				if (newline === -1) break;
+				let rawLine = content.slice(lineStart, newline);
+				if (pendingFragments.length > 0) {
+					pendingFragments.push(rawLine);
+					rawLine = pendingFragments.join("");
+					pendingFragments = [];
+				}
+				const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+				lineCount += 1;
+				if (visitor(line) === false) return {
+					ok: true,
+					lineCount
+				};
+				lineStart = newline + 1;
+			}
+			if (lineStart < content.length) pendingFragments.push(content.slice(lineStart));
+		}
+		const decoderTail = decoder.decode();
+		if (decoderTail.length > 0) pendingFragments.push(decoderTail);
+		if (pendingFragments.length > 0) {
+			const rawLine = pendingFragments.join("");
+			const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+			lineCount += 1;
+			visitor(line);
+		}
+		return {
+			ok: true,
+			lineCount
+		};
+	} catch {
+		return {
+			ok: false,
+			lineCount: 0
+		};
+	} finally {
+		await handle.close().catch(() => void 0);
+	}
+}
+//#endregion
 //#region extensions/codex/src/node-cli-sessions.ts
 const CODEX_CLI_SESSIONS_LIST_COMMAND = "codex.cli.sessions.list";
 const CODEX_CLI_SESSION_RESUME_COMMAND = "codex.cli.session.resume";
@@ -247,20 +345,18 @@ function resolveCodexCliResumeSpawnInvocation(args, runtime = DEFAULT_RESUME_SPA
 }
 async function readHistorySessions(codexHome) {
 	const summaries = /* @__PURE__ */ new Map();
-	const content = await readFileIfExists(path.join(codexHome, "history.jsonl"));
-	if (!content) return summaries;
-	for (const line of content.split(/\r?\n/u)) {
+	if (!(await visitJsonlLines(path.join(codexHome, "history.jsonl"), (line) => {
 		const trimmed = line.trim();
-		if (!trimmed) continue;
+		if (!trimmed) return;
 		let parsed;
 		try {
 			parsed = JSON.parse(trimmed);
 		} catch {
-			continue;
+			return;
 		}
-		if (!isRecord(parsed) || typeof parsed.session_id !== "string") continue;
+		if (!isRecord(parsed) || typeof parsed.session_id !== "string") return;
 		const sessionId = parsed.session_id.trim();
-		if (!sessionId) continue;
+		if (!sessionId) return;
 		const entry = summaries.get(sessionId) ?? {
 			sessionId,
 			messageCount: 0
@@ -269,7 +365,7 @@ async function readHistorySessions(codexHome) {
 		if (typeof parsed.text === "string" && parsed.text.trim()) entry.lastMessage = truncateText(parsed.text.trim(), 140);
 		if (typeof parsed.ts === "number") entry.updatedAt = timestampMsToIsoString(parsed.ts * 1e3) ?? entry.updatedAt;
 		summaries.set(sessionId, entry);
-	}
+	})).ok) return /* @__PURE__ */ new Map();
 	return summaries;
 }
 async function hydrateSessionFiles(codexHome, summaries) {
@@ -307,35 +403,35 @@ async function hydrateSessionsFromSessionFiles(codexHome, summaries) {
 	}
 }
 async function readSessionFileSummary(file) {
-	const content = await readFileIfExists(file);
-	if (!content) return null;
 	let sessionId = "";
 	let cwd;
 	let updatedAt;
 	let lastMessage;
 	let messageCount = 0;
-	for (const line of content.split(/\r?\n/u)) {
+	const result = await visitJsonlLines(file, (line) => {
 		const trimmed = line.trim();
-		if (!trimmed) continue;
+		if (!trimmed) return;
 		let parsed;
 		try {
 			parsed = JSON.parse(trimmed);
 		} catch {
-			continue;
+			return;
 		}
-		if (!isRecord(parsed)) continue;
+		if (!isRecord(parsed)) return;
 		if (typeof parsed.timestamp === "string" && parsed.timestamp.trim()) updatedAt = parsed.timestamp.trim();
 		if (parsed.type === "session_meta" && isRecord(parsed.payload)) {
 			if (typeof parsed.payload.id === "string" && parsed.payload.id.trim()) sessionId = parsed.payload.id.trim();
 			if (typeof parsed.payload.cwd === "string" && parsed.payload.cwd.trim()) cwd = parsed.payload.cwd.trim();
-			continue;
+			return;
 		}
 		const messageText = readResponseItemMessageText(parsed);
 		if (messageText) {
 			messageCount += 1;
 			lastMessage = truncateText(messageText, 140);
 		}
-	}
+	});
+	if (!result.ok) return null;
+	if (result.lineCount === 0) return null;
 	if (!sessionId) sessionId = readSessionIdFromFilename(file) ?? "";
 	if (!sessionId) return null;
 	return {
@@ -443,15 +539,12 @@ function readRecordParam(paramsJSON) {
 function resolveCodexHome() {
 	return process$1.env.CODEX_HOME?.trim() || path.join(os.homedir(), ".codex");
 }
-async function readFileIfExists(file) {
-	try {
-		return await fs.readFile(file, "utf8");
-	} catch {
-		return;
-	}
-}
 async function readFirstLine(file) {
-	return (await readFileIfExists(file))?.split(/\r?\n/u)[0];
+	let firstLine;
+	return (await visitJsonlLines(file, (line) => {
+		firstLine = line;
+		return false;
+	}, 65536)).ok ? firstLine : void 0;
 }
 async function readFileMtimeIso(file) {
 	try {
@@ -965,9 +1058,10 @@ function readNodeSessionMarker(entry) {
 }
 function listNodeAdoptedSessionEntries(params) {
 	const adopted = /* @__PURE__ */ new Map();
-	for (const agentId of listSupervisionAgentIds(params.config ?? {})) for (const { entry, sessionKey } of params.runtime.agent.session.listSessionEntries({
-		agentId,
-		readOnly: true
+	for (const { agentId, entry, sessionKey } of listSessionCatalogEntries({
+		config: params.config ?? {},
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
 	})) {
 		const marker = readNodeSessionMarker(entry);
 		const sessionId = entry.sessionId?.trim();
@@ -1336,12 +1430,20 @@ function codexNodeTerminalCapability(node) {
 	return node.connected === true && commands?.includes("codex.terminal.resume.v1") === true ? { canOpenTerminalCodex: true } : {};
 }
 async function requireCatalogEligibleThread(control, threadId) {
+	const cached = await findCatalogEligibleThread(control, threadId, false);
+	if (cached) return cached;
+	const refreshed = await findCatalogEligibleThread(control, threadId, true);
+	if (refreshed) return refreshed;
+	throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+}
+async function findCatalogEligibleThread(control, threadId, forceRefresh) {
 	let cursor;
 	const seenCursors = /* @__PURE__ */ new Set();
 	for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
 		const page = await control.listPage({
 			limit: 100,
-			...cursor ? { cursor } : {}
+			...cursor ? { cursor } : {},
+			...forceRefresh ? { forceRefresh: true } : {}
 		});
 		const candidate = page.sessions.find((session) => session.threadId === threadId);
 		if (candidate) {
@@ -1349,7 +1451,7 @@ async function requireCatalogEligibleThread(control, threadId) {
 			throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
 		}
 		const nextCursor = page.nextCursor?.trim();
-		if (!nextCursor) throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+		if (!nextCursor) return;
 		if (seenCursors.has(nextCursor)) throw new CatalogParamsError("Codex session eligibility could not be verified");
 		seenCursors.add(nextCursor);
 		cursor = nextCursor;
@@ -1615,6 +1717,16 @@ function createChecker(params) {
 //#region extensions/codex/src/session-catalog.ts
 const boundCatalogSessionId = (value) => boundedCatalogString(value, 256);
 const CODEX_SUPERVISION_SESSION_KEY_PREFIX = "harness:codex:supervision:";
+const CODEX_SESSION_CATALOG_LIST_TTL_MS = 32e3;
+const CODEX_SESSION_CATALOG_LIST_CACHE_MAX_ENTRIES = 32;
+function codexCatalogPageCacheKey(params) {
+	return JSON.stringify([
+		params.cursor ?? null,
+		params.limit ?? null,
+		params.searchTerm?.trim().toLocaleLowerCase() || null,
+		params.cwd?.trim() || null
+	]);
+}
 function createCodexSessionCatalogControlFromRequests(params) {
 	return {
 		...params.clientId ? { clientId: params.clientId } : {},
@@ -1684,13 +1796,27 @@ function createCodexSessionCatalogControlFromRequests(params) {
 function createCodexSessionCatalogControl(params) {
 	const now = params.now ?? Date.now;
 	const getPluginConfig = () => params.getPluginConfig();
+	const requestOptionsByConfig = /* @__PURE__ */ new WeakMap();
+	const catalogPagesByConfig = /* @__PURE__ */ new WeakMap();
+	const resolveRequestOptions = (startOptions) => {
+		const runtimeConfig = params.getRuntimeConfig();
+		if (!runtimeConfig) return {
+			config: void 0,
+			startOptions: structuredClone(startOptions)
+		};
+		const cached = requestOptionsByConfig.get(runtimeConfig);
+		if (cached) return cached;
+		const resolved = {
+			config: structuredClone(runtimeConfig),
+			startOptions: structuredClone(startOptions)
+		};
+		requestOptionsByConfig.set(runtimeConfig, resolved);
+		return resolved;
+	};
 	const createRequestSnapshot = () => {
 		const pluginConfig = getPluginConfig();
 		const runtime = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig });
-		const requestOptions = {
-			config: structuredClone(params.getRuntimeConfig()),
-			startOptions: structuredClone(runtime.start)
-		};
+		const requestOptions = resolveRequestOptions(runtime.start);
 		return {
 			requestTimeoutMs: runtime.requestTimeoutMs,
 			listThreads: async (listParams, timeoutMs) => await codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listThreads, listParams, {
@@ -1710,10 +1836,10 @@ function createCodexSessionCatalogControl(params) {
 	};
 	const withPinnedConnection = async (run) => {
 		const runtime = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: getPluginConfig() });
-		const runtimeConfig = structuredClone(params.getRuntimeConfig());
+		const { config: runtimeConfig, startOptions } = resolveRequestOptions(runtime.start);
 		const client = await getLeasedSharedCodexAppServerClient({
 			config: runtimeConfig,
-			startOptions: structuredClone(runtime.start),
+			startOptions,
 			timeoutMs: runtime.requestTimeoutMs
 		});
 		try {
@@ -1772,11 +1898,112 @@ function createCodexSessionCatalogControl(params) {
 			releaseLeasedSharedCodexAppServerClient(client);
 		}
 	};
-	return createCodexSessionCatalogControlFromRequests({
+	const control = createCodexSessionCatalogControlFromRequests({
 		createRequestSnapshot,
 		now,
 		withPinnedConnection
 	});
+	return {
+		...control,
+		async listPage(pageParams) {
+			const runtimeConfig = params.getRuntimeConfig();
+			if (!runtimeConfig) return await control.listPage(pageParams);
+			let cache = catalogPagesByConfig.get(runtimeConfig);
+			if (!cache) {
+				cache = /* @__PURE__ */ new Map();
+				catalogPagesByConfig.set(runtimeConfig, cache);
+			}
+			const key = codexCatalogPageCacheKey(pageParams);
+			const cached = cache.get(key);
+			if (pageParams.forceRefresh !== true && cached) {
+				cache.delete(key);
+				cache.set(key, cached);
+				if (cached.stalePage) return await cached.stalePage;
+				if (cached.expiresAt > now()) return await cached.page;
+				const stalePage = cached.settledPage;
+				if (!stalePage) return await cached.page;
+				const page = control.listPage(pageParams);
+				const entry = {
+					expiresAt: Number.POSITIVE_INFINITY,
+					page,
+					settledPage: stalePage,
+					stalePage
+				};
+				cache.set(key, entry);
+				page.then(() => {
+					if (cache.get(key) === entry) {
+						delete entry.stalePage;
+						entry.settledPage = page;
+						entry.expiresAt = now() + CODEX_SESSION_CATALOG_LIST_TTL_MS;
+					}
+				}, async () => {
+					let stale;
+					try {
+						stale = await stalePage;
+					} catch {}
+					if (cache.get(key) !== entry) return;
+					if (stale) {
+						cache.delete(key);
+						const settledPage = Promise.resolve(stale);
+						cache.set(key, {
+							expiresAt: now(),
+							page: settledPage,
+							settledPage
+						});
+					} else cache.delete(key);
+				});
+				return await stalePage;
+			}
+			if (cached) cache.delete(key);
+			const serveStaleOnError = pageParams.forceRefresh !== true;
+			const page = control.listPage(pageParams);
+			const stalePage = cached?.settledPage;
+			const entry = {
+				expiresAt: Number.POSITIVE_INFINITY,
+				page,
+				...stalePage ? {
+					stalePage,
+					settledPage: stalePage
+				} : {}
+			};
+			cache.set(key, entry);
+			while (cache.size > CODEX_SESSION_CATALOG_LIST_CACHE_MAX_ENTRIES) {
+				const oldest = cache.keys().next();
+				if (oldest.done) break;
+				cache.delete(oldest.value);
+			}
+			try {
+				const result = await page;
+				if (cache.get(key) === entry) {
+					delete entry.stalePage;
+					entry.settledPage = page;
+					entry.expiresAt = now() + CODEX_SESSION_CATALOG_LIST_TTL_MS;
+				}
+				return result;
+			} catch (error) {
+				if (stalePage) {
+					let stale;
+					try {
+						stale = await stalePage;
+					} catch {}
+					if (stale) {
+						if (cache.get(key) === entry) {
+							cache.delete(key);
+							const settledPage = Promise.resolve(stale);
+							cache.set(key, {
+								expiresAt: now(),
+								page: settledPage,
+								settledPage
+							});
+						}
+						if (serveStaleOnError) return stale;
+					}
+				}
+				if (cache.get(key) === entry) cache.delete(key);
+				throw error;
+			}
+		}
+	};
 }
 async function listGatewayHost(params) {
 	try {
@@ -1788,7 +2015,8 @@ async function listGatewayHost(params) {
 		const adoptedSessions = await listAdoptedSessionEntries({
 			bindingStore: params.bindingStore,
 			config: params.config,
-			runtime: params.runtime
+			runtime: params.runtime,
+			sessionEntries: params.sessionEntries
 		});
 		return {
 			hostId: CODEX_LOCAL_SESSION_HOST_ID,
@@ -1821,13 +2049,14 @@ async function listCodexSessionCatalog(params) {
 		config: params.config,
 		control: params.control,
 		query,
-		runtime: params.runtime
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
 	})] : [];
 	for (const host of localHosts) if (params.onHost) host.then(params.onHost).catch(() => void 0);
 	if (!(!requestedHostIds || query.hostIds?.some((hostId) => hostId.startsWith("node:")))) return { hosts: await Promise.all(localHosts) };
 	let nodes;
 	try {
-		nodes = (await params.runtime.nodes.list()).nodes.filter((node) => node.commands?.includes("codex.appServer.threads.list.v1") && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - localHosts.length);
+		nodes = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes.filter((node) => node.gatewayLocal !== true && node.commands?.includes("codex.appServer.threads.list.v1") && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - localHosts.length);
 	} catch (error) {
 		const registryHost = {
 			hostId: "node:registry",
@@ -1842,7 +2071,8 @@ async function listCodexSessionCatalog(params) {
 	}
 	const adoptedNodeSessions = listNodeAdoptedSessionEntries({
 		config: params.config,
-		runtime: params.runtime
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
 	});
 	const nodeHosts = nodes.toSorted(compareNodeLabels).map(async (node) => {
 		const host = await listPairedNode({
@@ -1979,9 +2209,10 @@ function isAdoptionSessionKeyForThread(sessionKey, threadId) {
 }
 async function listAdoptedSessionEntries(params) {
 	const adopted = /* @__PURE__ */ new Map();
-	for (const agentId of listSupervisionAgentIds(params.config ?? {})) for (const { entry, sessionKey } of params.runtime.agent.session.listSessionEntries({
-		agentId,
-		readOnly: true
+	for (const { agentId, entry, sessionKey } of listSessionCatalogEntries({
+		config: params.config ?? {},
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
 	})) {
 		const sessionKeyRest = adoptionSessionKeyRest(sessionKey);
 		if (!sessionKeyRest.startsWith(CODEX_SUPERVISION_SESSION_KEY_PREFIX) || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) continue;
@@ -2351,7 +2582,7 @@ function registerCodexSessionCatalog(params) {
 		resolveCreateSession: ({ agentId }) => resolveCodexCatalogCreateSession(params.getRuntimeConfig() ?? params.api.config, agentId),
 		list: async (query) => {
 			const localTerminalAvailable = resolveLocalCodexTerminalExecutable() !== void 0;
-			const { onHost, ...gatewayQuery } = query;
+			const { listNodes, onHost, sessionEntries, ...gatewayQuery } = query;
 			const mapHost = (host) => toGenericCatalogHost(host, localTerminalAvailable);
 			return (await listCodexSessionCatalog({
 				bindingStore: params.bindingStore,
@@ -2359,6 +2590,8 @@ function registerCodexSessionCatalog(params) {
 				runtime: params.api.runtime,
 				control: params.control,
 				query: gatewayQuery,
+				listNodes,
+				sessionEntries,
 				...onHost ? { onHost: (host) => onHost(mapHost(host)) } : {}
 			})).hosts.map(mapHost);
 		},

package/dist/{session-cli-CYJTfRLG.js → session-cli-2PZaFLRh.js}

@@ -1,6 +1,6 @@
-import { a as CODEX_LOCAL_SESSION_HOST_ID } from "./session-catalog-DsKaezgR.js";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { a as CODEX_LOCAL_SESSION_HOST_ID } from "./session-catalog-DyOgR4WH.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { addGatewayClientOptions, callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
 //#region extensions/codex/src/session-cli.ts

package/dist/{session-upstream-marker-D7XlI9us.js → session-upstream-marker-B6U7tLw5.js}

@@ -1,4 +1,4 @@
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-2p7kl6e4.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-DzsdNCf5.js";
 import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-history-import.ts
 /** Creates a session whose transcript is derived from one verified Codex thread snapshot. */

package/dist/{settled-turn-finalizer-DHltNgtF.js → settled-turn-finalizer-CXY2Z9dT.js}

@@ -1,6 +1,8 @@
-import { c as fingerprintCodexMirrorSourceMessage, d as attachCodexMirrorIdentity, f as readMirrorIdentity, l as readCodexMirrorSourceFingerprint, p as readUpstreamUserText, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-2p7kl6e4.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-CaQL96kg.js";
+import { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
+import { c as fingerprintCodexMirrorSourceMessage, d as attachCodexMirrorIdentity, f as readMirrorIdentity, l as readCodexMirrorSourceFingerprint, p as readUpstreamUserText, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-DzsdNCf5.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-D2ZAgZVz.js";
 import { n as createAssistantMessage } from "./event-projector-assistant-message-DTgnPPVF.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { Buffer } from "node:buffer";
 import { isSilentReplyText } from "openclaw/plugin-sdk/reply-runtime";
 //#region extensions/codex/src/app-server/settled-turn-projection.ts
@@ -9,9 +11,6 @@ const MAX_PROJECTION_BYTES = 512 * 1024;
 const MAX_TEXT_BYTES = 64 * 1024;
 const TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/u;
 const TOOL_ERROR_STATUS_PREFIX = "[Tool result status: error]\n";
-function isRecord(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 function readNonEmptyString(value) {
 	return typeof value === "string" ? value.trim() || void 0 : void 0;
 }
@@ -265,7 +264,21 @@ async function runCodexSettledTurnFinalization(operation, options) {
 		historyItems,
 		requireNoExternalCapabilities: true
 	});
-	const unexpectedItem = bounded.items.find((item) => !FINALIZER_PASSIVE_ITEM_TYPES.has(item.type));
+	let promptEchoSeen = false;
+	let unexpectedItem;
+	for (const item of bounded.items) {
+		if (FINALIZER_PASSIVE_ITEM_TYPES.has(item.type)) continue;
+		if (item.type === "userMessage" && !promptEchoSeen) {
+			const content = Array.isArray(item.content) ? item.content : [];
+			const input = content[0];
+			if (content.length === 1 && isJsonObject(input) && input.type === "text" && input.text === attempt.prompt) {
+				promptEchoSeen = true;
+				continue;
+			}
+		}
+		unexpectedItem = item;
+		break;
+	}
 	if (unexpectedItem) throw new Error(`Codex settled-turn finalization returned unexpected native item: ${unexpectedItem.type}`);
 	const text = bounded.text.trim();
 	if (!text || isSilentReplyText(text)) throw new Error("Codex settled-turn finalization completed without a visible answer");