@openclaw/codex 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/{session-catalog-CP2oCcEb.js → session-catalog-xwNi_SDM.js}

@@ -1,32 +1,129 @@
-import { E as resolveCodexAppServerClientInstanceId, L as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, R as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, V as isJsonObject, _ as CodexAppServerRpcError, a as getLeasedSharedCodexAppServerClient, h as withTimeout, l as releaseLeasedSharedCodexAppServerClient } from "./shared-client-BVKE40c-.js";
-import { c as reclaimCurrentCodexSessionGeneration, g as resolveCodexSupervisionAppServerRuntimeOptions, l as sessionBindingIdentity, p as resolveCodexAppServerRuntimeOptions } from "./session-binding-DlVQ-Pxs.js";
-import { t as assertCodexThreadForkParams } from "./protocol-validators-Dm4eXZmt.js";
-import { n as listCodexAppServerModels } from "./models-BA01NEez.js";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DSXX-rXO.js";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-uKA-A4tB.js";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-BHRSI6Cn.js";
-import { r as formatCodexDisplayText } from "./command-formatters-ico4ZFnk.js";
-import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-BHRpYbX3.js";
-import { n as requestCodexAppServerClientJson, r as requestCodexAppServerJson } from "./request-CXpPennK.js";
-import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-QE-m5QFG.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, g as resolveCodexAppServerRuntimeOptions, y as resolveCodexSupervisionAppServerRuntimeOptions } from "./session-binding-DPxIvMgE.js";
+import { R as resolveCodexAppServerClientInstanceId, _ as withTimeout, a as getLeasedSharedCodexAppServerClient, at as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, ct as isJsonObject, dt as resolveCodexAppServerLocalHomeDir, it as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, l as releaseLeasedSharedCodexAppServerClient, z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
+import { n as assertCodexThreadForkParams } from "./protocol-validators-B4F7L8Rf.js";
+import { n as listCodexAppServerModels } from "./models-BFlpn1Ex.js";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-C3H2CVp6.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-B9gGgnJS.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-CybGI1oz.js";
+import { r as formatCodexDisplayText } from "./command-formatters-B1AEz8ZA.js";
+import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-CW2GuupV.js";
+import { i as withCodexAppServerJsonClient, n as requestCodexAppServerClientJson, r as requestCodexAppServerJson } from "./request-BRl5_UfX.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-CrIFX06J.js";
+import { asFiniteNumber, isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 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 { createHash } from "node:crypto";
-import { listAgentIds, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
 import os from "node:os";
+import { listAgentIds, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
 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 { 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 { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 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";
@@ -249,20 +346,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
@@ -271,7 +366,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) {
@@ -309,35 +404,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 {
@@ -445,15 +540,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 {
@@ -487,61 +579,6 @@ function formatNodeLabel(node) {
 	].filter(Boolean).join(" / ") || "node";
 }
 //#endregion
-//#region extensions/codex/src/app-server/thread-archive-guard.ts
-const DESCENDANT_PAGE_LIMIT = 100;
-const MAX_DESCENDANT_PAGES = 100;
-const MAX_THREAD_ID_LENGTH = 256;
-const MAX_CURSOR_LENGTH$1 = 4096;
-function readBoundedId(value) {
-	if (typeof value !== "string") return;
-	const normalized = value.trim();
-	return normalized && normalized.length <= MAX_THREAD_ID_LENGTH ? normalized : void 0;
-}
-function readNextCursor(value) {
-	if (value === void 0 || value === null) return;
-	if (typeof value !== "string" || !value.trim() || value.length > MAX_CURSOR_LENGTH$1) throw new Error("Codex app-server returned an invalid descendant-list cursor");
-	return value;
-}
-/**
-* Native archive includes the spawned subtree. Enumerate that same subtree first so an
-* OpenClaw-owned descendant cannot be stopped as an undocumented side effect.
-*/
-async function assertCodexArchiveDescendantsUnowned(params) {
-	const ancestorThreadId = readBoundedId(params.threadId);
-	if (!ancestorThreadId) throw new Error("cannot verify Codex archive descendants for an invalid thread id");
-	const seenCursors = /* @__PURE__ */ new Set();
-	const seenThreadIds = /* @__PURE__ */ new Set([ancestorThreadId]);
-	let cursor;
-	for (let pageIndex = 0; pageIndex < MAX_DESCENDANT_PAGES; pageIndex += 1) {
-		const response = await params.listPage({
-			ancestorThreadId,
-			archived: false,
-			limit: DESCENDANT_PAGE_LIMIT,
-			sortKey: "created_at",
-			sortDirection: "desc",
-			useStateDbOnly: true,
-			...cursor ? { cursor } : {}
-		});
-		if (!isJsonObject(response) || !Array.isArray(response.data)) throw new Error("Codex app-server returned an invalid descendant-list response");
-		if (response.data.length > DESCENDANT_PAGE_LIMIT) throw new Error("Codex app-server exceeded the descendant-list page limit");
-		for (const value of response.data) {
-			if (!isJsonObject(value)) throw new Error("Codex app-server returned an invalid descendant thread");
-			const descendantThreadId = readBoundedId(value.id);
-			if (!descendantThreadId) throw new Error("Codex app-server returned a descendant without a valid thread id");
-			if (seenThreadIds.has(descendantThreadId)) throw new Error("Codex app-server returned a cyclic descendant thread list");
-			seenThreadIds.add(descendantThreadId);
-			await params.assertDescendantIdle(descendantThreadId);
-			if (await params.bindingStore.hasOtherThreadOwner(descendantThreadId)) throw new Error("cannot archive a Codex thread while a spawned descendant is owned by an OpenClaw session");
-		}
-		const nextCursor = readNextCursor(response.nextCursor);
-		if (!nextCursor) return;
-		if (seenCursors.has(nextCursor)) throw new Error("Codex app-server returned a repeated descendant-list cursor");
-		seenCursors.add(nextCursor);
-		cursor = nextCursor;
-	}
-	throw new Error("Codex descendant enumeration exceeded its safety limit");
-}
-//#endregion
 //#region extensions/codex/src/command-rpc.ts
 function requestOptions(pluginConfig, limit, config, agentDir) {
 	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
@@ -554,10 +591,8 @@ function requestOptions(pluginConfig, limit, config, agentDir) {
 	};
 }
 async function codexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	return await requestCodexAppServerJson({
-		method,
-		requestParams,
+	const runtime = options.startOptions ? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig }) : resolveCodexAppServerRuntimeOptions({ pluginConfig });
+	const controlRequestOptions = {
 		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
 		startOptions: options.startOptions ?? runtime.start,
 		config: options.config,
@@ -566,6 +601,19 @@ async function codexControlRequest(pluginConfig, method, requestParams, options
 		authProfileId: options.authProfileId,
 		agentDir: options.agentDir,
 		isolated: options.isolated
+	};
+	if (options.onResponse) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client) => {
+		const response = await request({
+			method,
+			requestParams
+		});
+		await options.onResponse(response, client);
+		return response;
+	});
+	return await requestCodexAppServerJson({
+		method,
+		requestParams,
+		...controlRequestOptions
 	});
 }
 async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
@@ -616,6 +664,56 @@ async function safeValue(read) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/app-server/thread-archive-guard.ts
+const DESCENDANT_PAGE_LIMIT = 100;
+const MAX_DESCENDANT_PAGES = 100;
+const MAX_THREAD_ID_LENGTH = 256;
+const MAX_CURSOR_LENGTH$1 = 4096;
+function readNextCursor(value) {
+	if (value === void 0 || value === null) return;
+	if (typeof value !== "string" || !value.trim() || value.length > MAX_CURSOR_LENGTH$1) throw new Error("Codex app-server returned an invalid descendant-list cursor");
+	return value;
+}
+/**
+* Native archive includes the spawned subtree. Enumerate that same subtree first so an
+* OpenClaw-owned descendant cannot be stopped as an undocumented side effect.
+*/
+async function assertCodexArchiveDescendantsUnowned(params) {
+	const ancestorThreadId = normalizeBoundedOptionalString(params.threadId, MAX_THREAD_ID_LENGTH);
+	if (!ancestorThreadId) throw new Error("cannot verify Codex archive descendants for an invalid thread id");
+	const seenCursors = /* @__PURE__ */ new Set();
+	const seenThreadIds = /* @__PURE__ */ new Set([ancestorThreadId]);
+	let cursor;
+	for (let pageIndex = 0; pageIndex < MAX_DESCENDANT_PAGES; pageIndex += 1) {
+		const response = await params.listPage({
+			ancestorThreadId,
+			archived: false,
+			limit: DESCENDANT_PAGE_LIMIT,
+			sortKey: "created_at",
+			sortDirection: "desc",
+			useStateDbOnly: true,
+			...cursor ? { cursor } : {}
+		});
+		if (!isJsonObject(response) || !Array.isArray(response.data)) throw new Error("Codex app-server returned an invalid descendant-list response");
+		if (response.data.length > DESCENDANT_PAGE_LIMIT) throw new Error("Codex app-server exceeded the descendant-list page limit");
+		for (const value of response.data) {
+			if (!isJsonObject(value)) throw new Error("Codex app-server returned an invalid descendant thread");
+			const descendantThreadId = normalizeBoundedOptionalString(value.id, MAX_THREAD_ID_LENGTH);
+			if (!descendantThreadId) throw new Error("Codex app-server returned a descendant without a valid thread id");
+			if (seenThreadIds.has(descendantThreadId)) throw new Error("Codex app-server returned a cyclic descendant thread list");
+			seenThreadIds.add(descendantThreadId);
+			await params.assertDescendantIdle(descendantThreadId);
+			if (await params.bindingStore.hasOtherThreadOwner(descendantThreadId)) throw new Error("cannot archive a Codex thread while a spawned descendant is owned by an OpenClaw session");
+		}
+		const nextCursor = readNextCursor(response.nextCursor);
+		if (!nextCursor) return;
+		if (seenCursors.has(nextCursor)) throw new Error("Codex app-server returned a repeated descendant-list cursor");
+		seenCursors.add(nextCursor);
+		cursor = nextCursor;
+	}
+	throw new Error("Codex descendant enumeration exceeded its safety limit");
+}
+//#endregion
 //#region extensions/codex/src/session-catalog-create.ts
 const CODEX_AGENT_RUNTIME_ID = "codex";
 const CODEX_CATALOG_DEFAULT_MODEL_REF = "openai/gpt-5.6-sol";
@@ -722,7 +820,7 @@ function normalizeLimit(value, key) {
 	if (!Number.isInteger(value) || value < 1 || value > 100) throw new CatalogParamsError(`${key} must be an integer from 1 to 100`);
 	return value;
 }
-function readOptionalString(params, key, maxLength) {
+function readBoundedOptionalString(params, key, maxLength) {
 	const value = params[key];
 	if (value === void 0) return;
 	if (typeof value !== "string") throw new CatalogParamsError(`${key} must be a string`);
@@ -744,9 +842,9 @@ function readPageParams(value) {
 		"searchTerm",
 		"cwd"
 	]));
-	const cursor = readOptionalString(params, "cursor", MAX_CURSOR_LENGTH);
-	const searchTerm = readOptionalString(params, "searchTerm", MAX_SEARCH_LENGTH);
-	const cwd = readOptionalString(params, "cwd", MAX_CWD_LENGTH);
+	const cursor = readBoundedOptionalString(params, "cursor", MAX_CURSOR_LENGTH);
+	const searchTerm = readBoundedOptionalString(params, "searchTerm", MAX_SEARCH_LENGTH);
+	const cwd = readBoundedOptionalString(params, "cwd", MAX_CWD_LENGTH);
 	return {
 		limit: normalizeLimit(params.limit, "limit"),
 		...cursor ? { cursor } : {},
@@ -763,7 +861,7 @@ function readGatewayParams(value) {
 		"hostIds",
 		"cursors"
 	]));
-	const search = readOptionalString(params, "search", MAX_SEARCH_LENGTH);
+	const search = readBoundedOptionalString(params, "search", MAX_SEARCH_LENGTH);
 	let hostIds;
 	if (params.hostIds !== void 0) {
 		if (!Array.isArray(params.hostIds) || params.hostIds.length > 100) throw new CatalogParamsError(`hostIds must contain at most 100 host ids`);
@@ -803,9 +901,6 @@ function parseJsonParams(paramsJSON) {
 		throw new Error("Codex session catalog parameters must be valid JSON", { cause: error });
 	}
 }
-function readFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
 function parseOptionalCatalogString(value, field, maxLength) {
 	if (value === void 0) return;
 	if (typeof value !== "string" || value.length > maxLength) throw new Error(`Codex session catalog returned an invalid ${field}`);
@@ -831,9 +926,9 @@ function parseCatalogSession(value, options = {}) {
 	const cliVersion = parseOptionalCatalogString(value.cliVersion, "CLI version", MAX_METADATA_LENGTH);
 	const gitBranch = parseOptionalCatalogString(value.gitBranch, "Git branch", MAX_METADATA_LENGTH);
 	const sessionKey = options.allowSessionKey ? parseOptionalCatalogString(value.sessionKey, "OpenClaw session key", MAX_SESSION_KEY_LENGTH) : void 0;
-	const createdAt = readFiniteNumber(value.createdAt);
-	const updatedAt = readFiniteNumber(value.updatedAt);
-	const recencyAt = value.recencyAt === null ? null : readFiniteNumber(value.recencyAt);
+	const createdAt = asFiniteNumber(value.createdAt);
+	const updatedAt = asFiniteNumber(value.updatedAt);
+	const recencyAt = value.recencyAt === null ? null : asFiniteNumber(value.recencyAt);
 	return {
 		threadId: value.threadId,
 		status,
@@ -1324,6 +1419,12 @@ async function continueNodeCodexSession(params) {
 //#endregion
 //#region extensions/codex/src/session-catalog-terminal.ts
 const CODEX_TERMINAL_RESUME_COMMAND = "codex.terminal.resume.v1";
+function resolveCodexCatalogTerminalHome(sources) {
+	const runtimeConfig = sources.getRuntimeConfig();
+	if (!runtimeConfig) throw new Error("OpenClaw runtime config is unavailable");
+	const startOptions = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: sources.getPluginConfig() }).start;
+	return resolveCodexAppServerLocalHomeDir(startOptions, resolveDefaultAgentDir(runtimeConfig));
+}
 function resolveLocalCodexTerminalExecutable(env = process.env) {
 	return resolveLocalCodexTerminalResolution(env)?.executable;
 }
@@ -1339,12 +1440,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) {
@@ -1352,14 +1461,14 @@ 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;
 	}
 	throw new CatalogParamsError("Codex session eligibility could not be verified");
 }
-function createCodexTerminalNodeHostCommand(control) {
+function createCodexTerminalNodeHostCommand(control, configSources) {
 	return {
 		command: CODEX_TERMINAL_RESUME_COMMAND,
 		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
@@ -1387,6 +1496,7 @@ function createCodexTerminalNodeHostCommand(control) {
 				file: resolution.executable,
 				args: ["resume", resume.threadId],
 				cwd: record.cwd,
+				env: { CODEX_HOME: resolveCodexCatalogTerminalHome(configSources) },
 				cols: resume.cols,
 				rows: resume.rows
 			}, io));
@@ -1434,6 +1544,7 @@ async function openCodexCatalogTerminal(params) {
 				params.threadId
 			],
 			...record.cwd ? { cwd: record.cwd } : {},
+			env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
 			...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
 			title
 		};
@@ -1459,6 +1570,19 @@ async function openCodexCatalogTerminal(params) {
 		title
 	};
 }
+async function startCodexCatalogTerminal(params) {
+	if (params.nodeId) throw new CatalogParamsError("Paired-node Codex terminal start is unavailable; omit hostId to start on the gateway host");
+	const resolution = resolveLocalCodexTerminalResolution();
+	if (!resolution) throw new CatalogParamsError("Codex CLI is unavailable; install Codex or add codex to PATH, then try again");
+	return {
+		kind: "local",
+		argv: [resolution.executable, ...params.initialMessage !== void 0 ? ["--", params.initialMessage] : []],
+		cwd: params.cwd,
+		env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
+		...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
+		title: "codex"
+	};
+}
 //#endregion
 //#region extensions/codex/src/session-catalog-transcript-item.ts
 const CODEX_MESSAGE_TYPES = /* @__PURE__ */ new Map([
@@ -1618,6 +1742,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 } : {},
@@ -1687,13 +1821,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, {
@@ -1713,10 +1861,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 {
@@ -1775,11 +1923,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 {
@@ -1820,7 +2069,7 @@ async function listGatewayHost(params) {
 async function listCodexSessionCatalog(params) {
 	const query = readGatewayParams(params.query);
 	const requestedHostIds = query.hostIds ? new Set(query.hostIds) : void 0;
-	const localHosts = !requestedHostIds || requestedHostIds.has("gateway:local") ? [listGatewayHost({
+	const localHosts = params.includeLocal !== false && (!requestedHostIds || requestedHostIds.has("gateway:local")) ? [listGatewayHost({
 		bindingStore: params.bindingStore,
 		config: params.config,
 		control: params.control,
@@ -1832,7 +2081,7 @@ async function listCodexSessionCatalog(params) {
 	if (!(!requestedHostIds || query.hostIds?.some((hostId) => hostId.startsWith("node:")))) return { hosts: await Promise.all(localHosts) };
 	let nodes;
 	try {
-		nodes = (await (params.listNodes?.() ?? 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",
@@ -1863,7 +2112,7 @@ async function listCodexSessionCatalog(params) {
 	return { hosts: await Promise.all([...localHosts, ...nodeHosts]) };
 }
 /** Builds the node-local read-only Codex app-server catalog command. */
-function createCodexSessionCatalogNodeHostCommands(control) {
+function createCodexSessionCatalogNodeHostCommands(control, configSources) {
 	return [
 		{
 			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
@@ -1901,7 +2150,7 @@ function createCodexSessionCatalogNodeHostCommands(control) {
 				}
 			}
 		},
-		createCodexTerminalNodeHostCommand(control)
+		createCodexTerminalNodeHostCommand(control, configSources)
 	];
 }
 function readNodeTranscriptParams(value) {
@@ -1911,9 +2160,9 @@ function readNodeTranscriptParams(value) {
 		"cursor",
 		"limit"
 	]));
-	const threadId = readOptionalString(value, "threadId", 256);
+	const threadId = readBoundedOptionalString(value, "threadId", 256);
 	if (!threadId) throw new CatalogParamsError("threadId is required");
-	const cursor = readOptionalString(value, "cursor", MAX_CURSOR_LENGTH);
+	const cursor = readBoundedOptionalString(value, "cursor", MAX_CURSOR_LENGTH);
 	return {
 		threadId,
 		limit: readBoundedLimit(value.limit, "limit", 20, 50),
@@ -2015,7 +2264,6 @@ async function listAdoptedSessionEntries(params) {
 async function findAdoptedSessionEntry(params) {
 	return (await listAdoptedSessionEntries(params)).get(params.threadId);
 }
-var CodexAdoptionBindingCleanupError = class extends AggregateError {};
 async function clearCreatedAdoptionBinding(params) {
 	let cleared = false;
 	let clearError;
@@ -2033,14 +2281,14 @@ async function clearCreatedAdoptionBinding(params) {
 	try {
 		current = await params.bindingStore.read(params.identity);
 	} catch (readError) {
-		throw new CodexAdoptionBindingCleanupError([
+		throw new AggregateError([
 			params.cause,
 			...clearError ? [clearError] : [],
 			readError
-		], `OpenClaw session creation failed and the Codex binding could not be verified for ${params.sourceThreadId}`);
+		], `OpenClaw session creation failed and the Codex binding could not be verified for ${params.sourceThreadId}`, { cause: readError });
 	}
 	if (!matchesPendingSupervisionOwner(current, params.expectedPending)) return;
-	throw new CodexAdoptionBindingCleanupError([params.cause, ...clearError ? [clearError] : []], `OpenClaw session creation failed and the Codex binding could not be cleared for ${params.sourceThreadId}`);
+	throw new AggregateError([params.cause, ...clearError ? [clearError] : []], `OpenClaw session creation failed and the Codex binding could not be cleared for ${params.sourceThreadId}`, { cause: params.cause });
 }
 function matchesPendingAdoptionBinding(binding, expected) {
 	const historyCoveredThrough = binding?.historyCoveredThrough;
@@ -2352,13 +2600,22 @@ function toGenericCatalogHost(host, localTerminalAvailable) {
 	};
 }
 function registerCodexSessionCatalog(params) {
-	const provider = {
+	const usesProcessHomeFallback = () => {
+		const start = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: params.getPluginConfig() }).start;
+		return start.transport === "stdio" && start.homeScope === "user" && !process.env.CODEX_HOME?.trim();
+	};
+	const assertLocalAccess = (hostId, allowProcessHomeFallback) => {
+		if (hostId === "gateway:local" && allowProcessHomeFallback === false && usesProcessHomeFallback()) throw new CatalogParamsError("local Codex sessions are unavailable in isolated state");
+	};
+	const checkUpstreamActivity = createChecker(params);
+	params.api.registerSessionCatalog({
 		id: "codex",
 		label: "Codex",
+		supportsProcessHomeIsolation: true,
 		resolveCreateSession: ({ agentId }) => resolveCodexCatalogCreateSession(params.getRuntimeConfig() ?? params.api.config, agentId),
 		list: async (query) => {
 			const localTerminalAvailable = resolveLocalCodexTerminalExecutable() !== void 0;
-			const { listNodes, onHost, sessionEntries, ...gatewayQuery } = query;
+			const { allowProcessHomeFallback, listNodes, onHost, sessionEntries, ...gatewayQuery } = query;
 			const mapHost = (host) => toGenericCatalogHost(host, localTerminalAvailable);
 			return (await listCodexSessionCatalog({
 				bindingStore: params.bindingStore,
@@ -2368,17 +2625,20 @@ function registerCodexSessionCatalog(params) {
 				query: gatewayQuery,
 				listNodes,
 				sessionEntries,
+				includeLocal: allowProcessHomeFallback !== false || !usesProcessHomeFallback(),
 				...onHost ? { onHost: (host) => onHost(mapHost(host)) } : {}
 			})).hosts.map(mapHost);
 		},
 		read: async (request) => {
+			const { allowProcessHomeFallback, ...catalogRequest } = request;
+			assertLocalAccess(catalogRequest.hostId, allowProcessHomeFallback);
 			const page = await readCodexSessionTranscript({
 				runtime: params.api.runtime,
 				control: params.control,
-				hostId: request.hostId,
-				threadId: request.threadId,
-				cursor: request.cursor,
-				limit: request.limit ?? 20
+				hostId: catalogRequest.hostId,
+				threadId: catalogRequest.threadId,
+				cursor: catalogRequest.cursor,
+				limit: catalogRequest.limit ?? 20
 			});
 			return {
 				...page,
@@ -2386,6 +2646,7 @@ function registerCodexSessionCatalog(params) {
 			};
 		},
 		continueSession: async (request) => {
+			assertLocalAccess(request.hostId, request.allowProcessHomeFallback);
 			const config = params.getRuntimeConfig();
 			if (!config) throw new Error("OpenClaw runtime config is unavailable");
 			if (request.hostId.startsWith("node:")) return await continueNodeCodexSession({
@@ -2408,8 +2669,9 @@ function registerCodexSessionCatalog(params) {
 				}
 			})).sessionKey, request.threadId, upstreamBaseline);
 		},
-		checkUpstreamActivity: createChecker(params),
+		checkUpstreamActivity: (probes, policy) => checkUpstreamActivity(probes.filter((probe) => probe.hostId !== "gateway:local" || policy?.allowProcessHomeFallback !== false || !usesProcessHomeFallback())),
 		archive: async (request) => {
+			assertLocalAccess(request.hostId, request.allowProcessHomeFallback);
 			if (request.confirmNoOtherRunner !== true) throw new CatalogParamsError("archive requires confirmation that no other runner is active");
 			if (request.hostId !== "gateway:local") throw new CatalogParamsError("paired-node Codex sessions are view-only");
 			const config = params.getRuntimeConfig();
@@ -2423,14 +2685,26 @@ function registerCodexSessionCatalog(params) {
 			});
 			return { ok: true };
 		},
-		openTerminal: (request) => openCodexCatalogTerminal({
-			api: params.api,
-			control: params.control,
-			parseCatalogPage,
-			...request
-		})
-	};
-	params.api.registerSessionCatalog(provider);
+		openTerminal: async (request) => {
+			assertLocalAccess(request.hostId, request.allowProcessHomeFallback);
+			return await openCodexCatalogTerminal({
+				api: params.api,
+				control: params.control,
+				getPluginConfig: params.getPluginConfig,
+				getRuntimeConfig: params.getRuntimeConfig,
+				parseCatalogPage,
+				...request
+			});
+		},
+		startTerminalSession: async (request) => {
+			assertLocalAccess(request.nodeId ? `node:${request.nodeId}` : CODEX_LOCAL_SESSION_HOST_ID, request.allowProcessHomeFallback);
+			return await startCodexCatalogTerminal({
+				getPluginConfig: params.getPluginConfig,
+				getRuntimeConfig: params.getRuntimeConfig,
+				...request
+			});
+		}
+	});
 }
 const codexSessionCatalogRuntime = {
 	register: registerCodexSessionCatalog,
@@ -2441,4 +2715,4 @@ const codexSessionCatalogRuntime = {
 	archiveLocal: archiveLocalCodexSession
 };
 //#endregion
-export { CODEX_LOCAL_SESSION_HOST_ID as a, requestOptions as c, createCodexCliSessionNodeHostCommands as d, createCodexCliSessionNodeInvokePolicies as f, resumeCodexCliSessionOnNode as g, resolveCodexCliSessionForBindingOnNode as h, createCodexSessionCatalogNodeInvokePolicies as i, safeCodexControlRequest as l, listCodexCliSessionsOnNode as m, createCodexSessionCatalogControl as n, codexControlRequest as o, formatCodexCliSessions as p, createCodexSessionCatalogNodeHostCommands as r, readCodexStatusProbes as s, codexSessionCatalogRuntime as t, assertCodexArchiveDescendantsUnowned as u };
+export { CODEX_LOCAL_SESSION_HOST_ID as a, readCodexStatusProbes as c, createCodexCliSessionNodeHostCommands as d, createCodexCliSessionNodeInvokePolicies as f, resumeCodexCliSessionOnNode as g, resolveCodexCliSessionForBindingOnNode as h, createCodexSessionCatalogNodeInvokePolicies as i, requestOptions as l, listCodexCliSessionsOnNode as m, createCodexSessionCatalogControl as n, assertCodexArchiveDescendantsUnowned as o, formatCodexCliSessions as p, createCodexSessionCatalogNodeHostCommands as r, codexControlRequest as s, codexSessionCatalogRuntime as t, safeCodexControlRequest as u };