@openclaw/codex 2026.9.6 → 2026.9.7

package/dist/.setup/{session-catalog-native-projection-DowriLid.mjs → session-catalog-parsing-CPGaPYr-.mjs}

@@ -1,24 +1,11 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { n as defineCodexBuildState } from "./build-state-C7EnDVgr.mjs";
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import "./protocol-CANUwXJ3.mjs";
+import { n as detachCodexCatalogString } from "./session-catalog-limits-DDxOsQeC.mjs";
 import { asFiniteNumber, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/protocol-session-source.ts
 const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
 const CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES = ["atlas", "chatgpt"];
 //#endregion
-//#region extensions/codex/src/session-catalog-limits.ts
-var session_catalog_limits_exports = /* @__PURE__ */ __exportAll({
-	CODEX_CATALOG_MAX_ROWS: () => CODEX_CATALOG_MAX_ROWS,
-	CODEX_CATALOG_MAX_STATE_KEY_BYTES: () => 512,
-	detachCodexCatalogString: () => detachCodexCatalogString
-});
-const CODEX_CATALOG_MAX_ROWS = 2e4;
-/** Preserve UTF-16 code units without retaining an oversized source string. */
-function detachCodexCatalogString(value) {
-	return Buffer.from(value, "utf16le").toString("utf16le");
-}
-//#endregion
 //#region extensions/codex/src/session-catalog-parsing.ts
 const DEFAULT_PAGE_LIMIT = 50;
 const CODEX_APP_SERVER_THREADS_CAPABILITY = "codex-app-server-threads";
@@ -67,8 +54,7 @@ function truncateCodexCatalogPreview(value, sanitize) {
 	return Buffer.from(catalogPreview(value, sanitize) ?? "", "utf8").toString("utf8");
 }
 function normalizeInteractiveThreadSource(source) {
-	if (CODEX_INTERACTIVE_THREAD_SOURCE_KINDS.some((kind) => kind === source) || CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES.some((kind) => kind === source)) return source;
-	if (isRecord(source) && CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES.some((kind) => kind === source.custom)) return source.custom;
+	return CODEX_INTERACTIVE_THREAD_SOURCE_KINDS.find((kind) => kind === source) ?? CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES.find((kind) => kind === source) ?? (isRecord(source) ? CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES.find((kind) => kind === source.custom) : void 0);
 }
 function isInteractiveThreadSource(source) {
 	return normalizeInteractiveThreadSource(source) !== void 0;
@@ -118,9 +104,9 @@ function toCatalogSession(thread, archived, sanitize, preparedPreview) {
 		...gitBranch ? { gitBranch } : {}
 	};
 }
-function normalizeLimit(value, key) {
-	if (value === void 0) return DEFAULT_PAGE_LIMIT;
-	if (!Number.isInteger(value) || value < 1 || value > 100) throw new CatalogParamsError(`${key} must be an integer from 1 to 100`);
+function normalizeLimit(value, key, fallback = DEFAULT_PAGE_LIMIT, max = 100) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > max) throw new CatalogParamsError(`${key} must be an integer from 1 to ${max}`);
 	return value;
 }
 function readBoundedOptionalString(params, key, maxLength) {
@@ -157,7 +143,7 @@ function readPageParams(value) {
 }
 function readGatewayParams(value) {
 	if (value !== void 0 && !isRecord(value)) throw new CatalogParamsError("Codex session catalog parameters must be an object");
-	const params = isRecord(value) ? value : {};
+	const params = value ?? {};
 	requireOnlyKeys(params, /* @__PURE__ */ new Set([
 		"search",
 		"limitPerHost",
@@ -177,8 +163,7 @@ function readGatewayParams(value) {
 		if (entries.length > MAX_CURSOR_COUNT) throw new CatalogParamsError(`cursors may contain at most ${MAX_CURSOR_COUNT} hosts`);
 		cursors = {};
 		for (const [hostId, cursor] of entries) {
-			const normalizedHostId = hostId.trim();
-			if (normalizedHostId.length === 0 || normalizedHostId.length > MAX_HOST_ID_LENGTH || !normalizedHostId.startsWith("gateway:") && !normalizedHostId.startsWith("node:")) throw new CatalogParamsError(`invalid Codex session catalog host id: ${hostId}`);
+			const normalizedHostId = readHostId(hostId);
 			if (typeof cursor !== "string" || !cursor.trim() || cursor.trim().length > 4096) throw new CatalogParamsError(`invalid cursor for Codex session catalog host: ${hostId}`);
 			cursors[normalizedHostId] = cursor.trim();
 		}
@@ -271,12 +256,12 @@ function filterCatalogPageByTitle(page, searchTerm) {
 		sessions: page.sessions.filter((session) => (session.name ?? session.fallbackName)?.toLocaleLowerCase().includes(searchTerm.toLocaleLowerCase()))
 	};
 }
-function unwrapNodeInvokePayload(value) {
+function unwrapNodeInvokePayload(value, malformedMessage = "Codex node returned malformed session catalog JSON") {
 	if (!isRecord(value)) return value;
 	if (typeof value.payloadJSON === "string" && value.payloadJSON.trim()) try {
 		return JSON.parse(value.payloadJSON);
 	} catch (error) {
-		throw new Error("Codex node returned malformed session catalog JSON", { cause: error });
+		throw new Error(malformedMessage, { cause: error });
 	}
 	return "payload" in value ? value.payload : value;
 }
@@ -318,172 +303,4 @@ function requireBoundThread(entry) {
 	return entry.boundThreadId;
 }
 //#endregion
-//#region extensions/codex/src/session-catalog-source.ts
-const getSources = defineCodexBuildState("openclaw.codexCatalogSources", () => ({
-	clients: /* @__PURE__ */ new WeakMap(),
-	values: /* @__PURE__ */ new WeakMap()
-}));
-const getEphemeralObservers = defineCodexBuildState("openclaw.codexCatalogEphemeralObservers", () => /* @__PURE__ */ new WeakMap());
-/** A passive lifetime fact; the token never retains its client or a lease. */
-function codexCatalogSourceForClient(client) {
-	const { clients } = getSources();
-	let source = clients.get(client);
-	if (!source) {
-		source = { closed: false };
-		clients.set(client, source);
-	}
-	return source;
-}
-function closeCodexCatalogClientSource(client) {
-	const { clients } = getSources();
-	const source = clients.get(client);
-	if (source) {
-		source.closed = true;
-		getEphemeralObservers().delete(source);
-	} else clients.set(client, { closed: true });
-}
-/** The catalog observer is bound once per physical source and released on closure. */
-function observeCodexCatalogEphemeralThreads(source, observer) {
-	getEphemeralObservers().set(source, observer);
-}
-function getCodexCatalogSource(value) {
-	return value !== null && typeof value === "object" ? getSources().values.get(value) : void 0;
-}
-function setCodexCatalogSource(value, source) {
-	if (source) getSources().values.set(value, source);
-	return value;
-}
-/** Source attribution survives projection without becoming serialized row data. */
-function copyCodexCatalogSource(from, to) {
-	return setCodexCatalogSource(to, getCodexCatalogSource(from));
-}
-/** Stamp the final decoded objects, including any bounded catalog DTO replacement. */
-function recordCodexCatalogResponseSource(method, result, source) {
-	if (result === null || typeof result !== "object") return;
-	if (method === "thread/list" && "data" in result && Array.isArray(result.data)) {
-		setCodexCatalogSource(result, source);
-		for (const thread of result.data) if (thread !== null && typeof thread === "object") setCodexCatalogSource(thread, source);
-	} else if ((method === "thread/read" || method === "thread/start" || method === "thread/fork" || method === "thread/resume") && "thread" in result && result.thread !== null && typeof result.thread === "object") {
-		setCodexCatalogSource(result, source);
-		setCodexCatalogSource(result.thread, source);
-		if ("ephemeral" in result.thread && result.thread.ephemeral === true && "id" in result.thread && typeof result.thread.id === "string") getEphemeralObservers().get(source)?.(result.thread.id);
-	}
-}
-//#endregion
-//#region extensions/codex/src/session-catalog-native-projection.ts
-var session_catalog_native_projection_exports = /* @__PURE__ */ __exportAll({
-	CODEX_CATALOG_NATIVE_PAGE_LIMIT: () => 64,
-	projectCodexCatalogNativeResponse: () => projectCodexCatalogNativeResponse,
-	projectCodexCatalogNativeThread: () => projectCodexCatalogNativeThread,
-	reuseCodexCatalogPreview: () => reuseCodexCatalogPreview
-});
-const CODEX_CATALOG_NATIVE_PAGE_LIMIT = 64;
-const STRING_FIELDS = [
-	[
-		"name",
-		500,
-		"truncate"
-	],
-	[
-		"cwd",
-		MAX_CWD_LENGTH,
-		"omit"
-	],
-	[
-		"modelProvider",
-		500,
-		"truncate"
-	],
-	[
-		"cliVersion",
-		500,
-		"truncate"
-	]
-];
-/** Drop unused native fields before catalog-owned asynchronous work can retain them. */
-function projectCodexCatalogNativeThread(thread, sanitize, cachedPreview) {
-	if (!isJsonObject(thread)) throw new Error("Codex catalog response contains an invalid thread");
-	const id = boundedCatalogString(thread.id, 256);
-	if (!id) throw new Error("Codex catalog response contains an invalid thread id");
-	const row = {
-		id,
-		projectId: boundedCatalogString(thread.projectId, 256, "omit") ?? null
-	};
-	const sessionId = boundedCatalogString(thread.sessionId, 256, "omit");
-	if (sessionId) row.sessionId = sessionId;
-	if (thread.ephemeral === true) return copyCodexCatalogSource(thread, {
-		...row,
-		ephemeral: true
-	});
-	for (const [field, limit, overflow] of STRING_FIELDS) {
-		const value = thread[field];
-		const bounded = boundedCatalogString(value, limit, overflow);
-		if (value === null || bounded !== void 0) row[field] = bounded ?? null;
-	}
-	if (typeof thread.path === "string") {
-		if (thread.path.length > 4096) throw new Error("Codex catalog rollout path exceeds its length limit");
-		row.path = detachCodexCatalogString(thread.path);
-	} else if (thread.path === null) row.path = null;
-	if (typeof thread.originator === "string") row.originator = detachCodexCatalogString(thread.originator.slice(0, 500));
-	for (const field of [
-		"createdAt",
-		"updatedAt",
-		"recencyAt"
-	]) {
-		const value = thread[field];
-		if (value === null || typeof value === "number" && Number.isFinite(value)) row[field] = value;
-	}
-	const rawPreview = thread.preview;
-	const preview = reuseCodexCatalogPreview(row, typeof rawPreview === "string" ? Boolean(rawPreview) : void 0, cachedPreview);
-	if (preview !== void 0) row.preview = preview;
-	else if (typeof rawPreview === "string") row.preview = rawPreview ? truncateCodexCatalogPreview(selectCodexCatalogPreviewInput(rawPreview), sanitize) : "";
-	else if (rawPreview === null) row.preview = null;
-	const source = typeof thread.source === "string" ? detachCodexCatalogString(thread.source.slice(0, 500)) : void 0;
-	if (source === "cli" || source === "vscode" || source === "exec" || source === "appServer" || source === "unknown") row.source = source;
-	else if (isJsonObject(thread.source) && typeof thread.source.custom === "string" && thread.source.custom.length <= 500) row.source = { custom: detachCodexCatalogString(thread.source.custom) };
-	if (isJsonObject(thread.gitInfo)) {
-		const branch = boundedCatalogString(thread.gitInfo.branch, 500, "truncate");
-		if (branch !== void 0) row.gitInfo = { branch };
-	}
-	if (isJsonObject(thread.status)) {
-		const type = boundedCatalogString(thread.status.type, 64);
-		if (type === "active" || type === "idle" || type === "notLoaded" || type === "systemError") {
-			const activeFlags = type === "active" && Array.isArray(thread.status.activeFlags) ? thread.status.activeFlags.slice(0, 16).flatMap((flag) => {
-				const bounded = boundedCatalogString(flag, 128, "omit");
-				return bounded ? [bounded] : [];
-			}) : void 0;
-			row.status = type === "active" ? {
-				type,
-				...activeFlags ? { activeFlags } : {}
-			} : { type };
-		}
-	}
-	return copyCodexCatalogSource(thread, row);
-}
-/** Keep only the admitted prefix before an RPC promise retains its response. */
-function projectCodexCatalogNativeResponse(response, sanitize, cachedPreview, remainingRows = 64) {
-	if (!Array.isArray(response.data) || response.data.length > 64) throw new Error("Codex catalog response exceeds its native page limit");
-	const limit = Number.isFinite(remainingRows) ? Math.max(0, Math.min(64, Math.floor(remainingRows))) : 0;
-	const page = { data: response.data.slice(0, limit).map((thread) => projectCodexCatalogNativeThread(thread, sanitize, cachedPreview)) };
-	for (const field of ["nextCursor", "backwardsCursor"]) {
-		const value = response[field];
-		if (value === null) page[field] = null;
-		else if (value !== void 0) {
-			if (typeof value !== "string" || value.length > 4096) throw new Error("Codex catalog response contains an invalid cursor");
-			page[field] = detachCodexCatalogString(value);
-		}
-	}
-	return page;
-}
-/** Reuse resident text without transferring a cache or an unbounded native preview. */
-function reuseCodexCatalogPreview(thread, rawPreviewNonempty, cachedPreview) {
-	const preview = cachedPreview?.({
-		id: thread.id,
-		path: typeof thread.path === "string" ? thread.path : null,
-		updatedAt: typeof thread.updatedAt === "number" ? thread.updatedAt : null,
-		recencyAt: typeof thread.recencyAt === "number" ? thread.recencyAt : null
-	});
-	return preview !== void 0 && preview.length <= 500 && (rawPreviewNonempty === void 0 || rawPreviewNonempty === Boolean(preview)) ? preview : void 0;
-}
-//#endregion
-export { parseCatalogPage as A, toCatalogSession as B, boundedCatalogString as C, filterCatalogPageByTitle as D, codexCatalogThreadStatus as E, readGatewayParams as F, session_catalog_limits_exports as G, unwrapNodeInvokePayload as H, readPageParams as I, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as K, requireBoundThread as L, parseTranscriptPage as M, readBoundedOptionalString as N, isInteractiveThreadSource as O, readControlCursor as P, requireOnlyKeys as R, NODE_INVOKE_TIMEOUT_MS as S, codexCatalogThreadName as T, CODEX_CATALOG_MAX_ROWS as U, truncateCodexCatalogPreview as V, detachCodexCatalogString as W, CODEX_LOCAL_SESSION_HOST_ID as _, session_catalog_native_projection_exports as a, MAX_CWD_LENGTH as b, copyCodexCatalogSource as c, recordCodexCatalogResponseSource as d, setCodexCatalogSource as f, CODEX_CATALOG_TRANSCRIPT_READ_COMMAND as g, CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND as h, reuseCodexCatalogPreview as i, parseJsonParams as j, normalizeLimit as k, getCodexCatalogSource as l, CODEX_APP_SERVER_THREADS_LIST_COMMAND as m, projectCodexCatalogNativeResponse as n, closeCodexCatalogClientSource as o, CODEX_APP_SERVER_THREADS_CAPABILITY as p, projectCodexCatalogNativeThread as r, codexCatalogSourceForClient as s, CODEX_CATALOG_NATIVE_PAGE_LIMIT as t, observeCodexCatalogEphemeralThreads as u, CatalogParamsError as v, catalogError as w, MAX_TRANSCRIPT_PAGE_BYTES as x, MAX_CURSOR_LENGTH as y, selectCodexCatalogPreviewInput as z };
+export { unwrapNodeInvokePayload as A, readGatewayParams as C, selectCodexCatalogPreviewInput as D, requireOnlyKeys as E, toCatalogSession as O, readControlCursor as S, requireBoundThread as T, normalizeLimit as _, CODEX_LOCAL_SESSION_HOST_ID as a, parseTranscriptPage as b, MAX_CWD_LENGTH as c, boundedCatalogString as d, catalogError as f, isInteractiveThreadSource as g, filterCatalogPageByTitle as h, CODEX_CATALOG_TRANSCRIPT_READ_COMMAND as i, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as j, truncateCodexCatalogPreview as k, MAX_TRANSCRIPT_PAGE_BYTES as l, codexCatalogThreadStatus as m, CODEX_APP_SERVER_THREADS_LIST_COMMAND as n, CatalogParamsError as o, codexCatalogThreadName as p, CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND as r, MAX_CURSOR_LENGTH as s, CODEX_APP_SERVER_THREADS_CAPABILITY as t, NODE_INVOKE_TIMEOUT_MS as u, parseCatalogPage as v, readPageParams as w, readBoundedOptionalString as x, parseJsonParams as y };

package/dist/.setup/{session-catalog-projection-zK_PUsiE.mjs → session-catalog-projection-Cr5qP5Dj.mjs}

@@ -1,11 +1,13 @@
-import { B as toCatalogSession, C as boundedCatalogString, P as readControlCursor, V as truncateCodexCatalogPreview, W as detachCodexCatalogString, c as copyCodexCatalogSource, f as setCodexCatalogSource, l as getCodexCatalogSource, r as projectCodexCatalogNativeThread, z as selectCodexCatalogPreviewInput } from "./session-catalog-native-projection-DowriLid.mjs";
-import { a as isOpenClawManagedCodexThread } from "./session-catalog-events-Bj6j94E_.mjs";
-import { n as codexCatalogRowRecency } from "./session-catalog-index-order-hcdz07yN.mjs";
+import { D as selectCodexCatalogPreviewInput, O as toCatalogSession, S as readControlCursor, d as boundedCatalogString, k as truncateCodexCatalogPreview } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { n as detachCodexCatalogString } from "./session-catalog-limits-DDxOsQeC.mjs";
+import { n as codexCatalogRowRecency } from "./session-catalog-index-order-BcQpHks3.mjs";
+import { t as isOpenClawManagedCodexThread } from "./session-catalog-provenance-DoAvktcj.mjs";
+import { c as copyCodexCatalogSource, l as getCodexCatalogSource, p as setCodexCatalogSource, r as projectCodexCatalogNativeThread } from "./session-catalog-native-projection-DjhwGL6x.mjs";
 import { asFiniteNumber, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path from "node:path";
 import fs from "node:fs/promises";
-import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import { extractErrorCode, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import { constants, createZstdDecompress } from "node:zlib";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 //#region extensions/codex/src/session-catalog-rollouts.ts

package/dist/.setup/session-catalog-provenance-DoAvktcj.mjs

@@ -0,0 +1,95 @@
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import path from "node:path";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
+import { createZstdDecompress } from "node:zlib";
+//#region extensions/codex/src/session-catalog-provenance.ts
+const MAX_SESSION_META_BYTES = 1048576;
+const SESSION_META_READ_CHUNK_BYTES = 65536;
+const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
+const provenanceByPath = /* @__PURE__ */ new Map();
+function cacheProvenance(key, value) {
+	provenanceByPath.delete(key);
+	provenanceByPath.set(key, value);
+	if (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) provenanceByPath.delete(provenanceByPath.keys().next().value);
+}
+/** Undefined means the metadata line is not durable enough to cache yet. */
+async function readCodexSessionMeta(sessionsRoot, rolloutPath, threadId) {
+	let safeRoot;
+	try {
+		safeRoot = await root(sessionsRoot, {
+			hardlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER,
+			symlinks: "reject"
+		});
+	} catch {
+		return;
+	}
+	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
+	for (const candidate of candidates) {
+		let opened;
+		try {
+			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
+		} catch {
+			continue;
+		}
+		const input = opened.handle.createReadStream({
+			autoClose: false,
+			highWaterMark: SESSION_META_READ_CHUNK_BYTES
+		});
+		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
+		try {
+			const chunks = [];
+			let bytesReadTotal = 0;
+			let line;
+			for await (const value of reader) {
+				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
+				if (remaining <= 0) break;
+				const bounded = chunk.subarray(0, remaining);
+				bytesReadTotal += bounded.length;
+				const newline = bounded.indexOf(10);
+				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
+				if (newline >= 0) {
+					line = Buffer.concat(chunks).toString("utf8");
+					break;
+				}
+			}
+			if (!line) continue;
+			const parsed = JSON.parse(line);
+			if (!isJsonObject(parsed) || parsed.type !== "session_meta" || !isJsonObject(parsed.payload)) return null;
+			const payload = parsed.payload;
+			return payload.id === threadId ? payload : null;
+		} catch {
+			continue;
+		} finally {
+			reader.destroy();
+			input.destroy();
+			await opened.handle.close().catch(() => void 0);
+		}
+	}
+}
+/** Passive local listing uses native creation provenance, with rollout fallback for older records. */
+async function isOpenClawManagedCodexThread(thread, localSessionsRoot, diagnostics) {
+	const started = diagnostics ? performance.now() : 0;
+	if (diagnostics) diagnostics.fields.provenanceChecks++;
+	try {
+		const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+		if (!localSessionsRoot || !rolloutPath) return false;
+		if (typeof thread.originator === "string" && thread.originator.length > 0) return thread.originator === "openclaw";
+		const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
+		const cached = provenanceByPath.get(cacheKey);
+		if (cached !== void 0) {
+			if (diagnostics) diagnostics.fields.provenanceCacheHits++;
+			return cached;
+		}
+		if (diagnostics) diagnostics.fields.provenanceReadCalls++;
+		const metadata = await readCodexSessionMeta(localSessionsRoot, rolloutPath, thread.id);
+		const managed = metadata === void 0 ? void 0 : metadata?.originator === "openclaw";
+		if (managed !== void 0) cacheProvenance(cacheKey, managed);
+		return managed ?? false;
+	} finally {
+		if (diagnostics) diagnostics.fields.provenanceMs = (diagnostics.fields.provenanceMs ?? 0) + performance.now() - started;
+	}
+}
+//#endregion
+export { readCodexSessionMeta as n, isOpenClawManagedCodexThread as t };

package/dist/.setup/{session-cli-irrD-uo7.mjs → session-cli-Cn_nCqfq.mjs}

@@ -1,5 +1,5 @@
-import "./session-catalog-native-projection-DowriLid.mjs";
-import "./session-catalog-Pno1xGcl.mjs";
+import "./session-catalog-parsing-CPGaPYr-.mjs";
+import "./session-catalog-4sCdv5qx.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -79,12 +79,6 @@ function writeHost(host) {
 	}
 	if (host.nextCursor) writeLine(`  More sessions: repeat the same filters with --host ${quoteShellArgument(host.hostId)} --cursor ${quoteShellArgument(host.nextCursor)}`);
 }
-function filterHosts(result, selector) {
-	return selector ? {
-		...result,
-		hosts: result.hosts.filter((host) => host.hostId === selector)
-	} : result;
-}
 async function listCodexSessions(options) {
 	const agentId = requestedAgentId(options);
 	const host = options.host?.trim() || void 0;
@@ -93,23 +87,22 @@ async function listCodexSessions(options) {
 	const search = options.search?.trim() || void 0;
 	const limitPerHost = parsePageLimit(options.limit);
 	const params = {
+		catalogId: "codex",
 		...agentId ? { agentId } : {},
 		...search ? { search } : {},
 		...limitPerHost !== void 0 ? { limitPerHost } : {},
 		...host ? { hostIds: [host] } : {},
 		...cursor && host ? { cursors: { [host]: cursor } } : {}
 	};
-	const raw = await callGatewayFromCli("sessions.catalog.list", gatewayOptions(options), {
-		catalogId: "codex",
-		...params
-	}, {
+	const raw = await callGatewayFromCli("sessions.catalog.list", gatewayOptions(options), params, {
 		mode: "cli",
 		scopes: ["operator.write"]
 	});
 	if (!isRecord(raw) || !Array.isArray(raw.catalogs)) throw new Error("Codex session catalog returned an invalid result");
 	const catalog = raw.catalogs.find((candidate) => isRecord(candidate) && candidate.id === "codex" && Array.isArray(candidate.hosts));
 	if (!isRecord(catalog)) throw new Error("Codex session catalog is unavailable on this Gateway");
-	const result = filterHosts({ hosts: catalog.hosts }, host);
+	const hosts = catalog.hosts;
+	const result = { hosts: host ? hosts.filter((entry) => entry.hostId === host) : hosts };
 	if (options.json) {
 		writeJson(result);
 		return;
@@ -175,15 +168,9 @@ async function archiveCodexSession(threadIdValue, options) {
 /** Registers the plugin-owned Codex session supervision CLI. */
 function registerCodexSessionCli(program) {
 	const codex = program.command("codex").description("Inspect and branch from Codex sessions through the Gateway");
-	addGatewayClientOptions(codex.command("sessions").description("List non-archived Codex app-server sessions across connected hosts").option("--agent <id>", "Agent id that owns the Codex sessions").option("--search <text>", "Search session titles (case-insensitive)").option("--host <id>", "Filter by stable host id").option("--limit <count>", "Maximum sessions returned per host").option("--cursor <cursor>", "Continue one host page (requires --host)").option("--json", "Print the structured catalog response", false), { timeoutMs: CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS }).action(async (options) => {
-		await listCodexSessions(options);
-	});
-	addGatewayClientOptions(codex.command("continue <thread-id>").description("Continue a Gateway-local Codex thread as an OpenClaw branch").option("--agent <id>", "Agent id that owns the Codex session").option("--host <id>", "Stable local host id from codex sessions").option("--json", "Print the structured response", false)).action(async (threadId, options) => {
-		await continueCodexSession(threadId, options);
-	});
-	addGatewayClientOptions(codex.command("archive <thread-id>").description("Archive a stored or idle Gateway-local Codex thread").option("--agent <id>", "Agent id that owns the Codex session").option("--host <id>", "Stable local host id from codex sessions").option("--confirm-no-other-runner", "Confirm no other Codex client or OpenClaw runner is using this thread", false).option("--json", "Print the structured response", false)).action(async (threadId, options) => {
-		await archiveCodexSession(threadId, options);
-	});
+	addGatewayClientOptions(codex.command("sessions").description("List non-archived Codex app-server sessions across connected hosts").option("--agent <id>", "Agent id that owns the Codex sessions").option("--search <text>", "Search session titles (case-insensitive)").option("--host <id>", "Filter by stable host id").option("--limit <count>", "Maximum sessions returned per host").option("--cursor <cursor>", "Continue one host page (requires --host)").option("--json", "Print the structured catalog response", false), { timeoutMs: CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS }).action(listCodexSessions);
+	addGatewayClientOptions(codex.command("continue <thread-id>").description("Continue a Gateway-local Codex thread as an OpenClaw branch").option("--agent <id>", "Agent id that owns the Codex session").option("--host <id>", "Stable local host id from codex sessions").option("--json", "Print the structured response", false)).action(continueCodexSession);
+	addGatewayClientOptions(codex.command("archive <thread-id>").description("Archive a stored or idle Gateway-local Codex thread").option("--agent <id>", "Agent id that owns the Codex session").option("--host <id>", "Stable local host id from codex sessions").option("--confirm-no-other-runner", "Confirm no other Codex client or OpenClaw runner is using this thread", false).option("--json", "Print the structured response", false)).action(archiveCodexSession);
 }
 //#endregion
 export { registerCodexSessionCli };

package/dist/.setup/{session-history-BrqhSCf9.mjs → session-history-D83lJWHG.mjs}

@@ -1,7 +1,9 @@
-import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-B3ZfSUbF.mjs";
+import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-Ov3StuL4.mjs";
+import { resolveAgentHarnessHistoryLimits } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
 import { SessionManager } from "openclaw/plugin-sdk/agent-sessions";
 import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-history.ts
+/** Reads bounded model context from the Codex transcript mirror. */
 function resolveCodexHistoryTarget(target, admission) {
 	if (target.sessionTarget) {
 		const { agentId, sessionId, sessionKey, storePath } = target.sessionTarget;
@@ -58,11 +60,7 @@ async function readCodexMirroredSessionHistoryMessages(target, admission, signal
 			const loaded = await SessionManager.openModelContextAsync(resolved.target, {
 				admission,
 				signal,
-				limits: {
-					maxBytes: Math.min(67108864, Math.max(1024, Math.floor((contextTokenBudget ?? 128e3) * 8))),
-					maxEvents: 1e4,
-					toolResultOverflow: "omit"
-				}
+				limits: resolveAgentHarnessHistoryLimits(contextTokenBudget)
 			});
 			result = consumeCodexHistory(loaded.buildSessionContext().messages, loaded.getHeader(), target.sessionId, read, "codex mirrored model context");
 		} else {

package/dist/.setup/{session-history-import-D-3wAgOP.mjs → session-history-import-WhX-X33a.mjs}

@@ -1,19 +1,20 @@
-import { m as sessionBindingIdentity } from "./session-binding-record-BGoz8wOK.mjs";
-import "./session-binding-Cm0apEbd.mjs";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-BtHDBp1G.mjs";
-import { n as prepareCodexSessionInitialization } from "./session-initialization-rcgbZiid.mjs";
+import { v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
+import "./session-binding-DGCYAfvD.mjs";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-kxmCYsuF.mjs";
+import { n as prepareCodexSessionInitialization } from "./session-initialization-6aveB9qb.mjs";
 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. */
 async function createImportedCodexSession(params) {
 	const spawnedCwd = params.thread.cwd?.trim() || void 0;
-	const createParams = {
+	return await params.runtime.agent.session.createSessionEntry({
 		cfg: params.config,
 		key: params.key,
 		agentId: params.agentId,
 		...params.displayName !== void 0 ? { displayName: params.displayName } : {},
 		...spawnedCwd ? { spawnedCwd } : {},
 		initialEntry: params.initialEntry,
+		...params.recoverMatchingInitialEntry ? { recoverMatchingInitialEntry: true } : {},
 		afterCreate: async (entry) => {
 			if (!entry.initialization) throw new Error("Codex history initialization requires host creation authority");
 			const initialization = prepareCodexSessionInitialization({
@@ -43,11 +44,7 @@ async function createImportedCodexSession(params) {
 			entry.initialization.assertCurrent();
 			return await params.afterImport(entry, initialization);
 		}
-	};
-	return params.recoverMatchingInitialEntry ? await params.runtime.agent.session.createSessionEntry({
-		...createParams,
-		recoverMatchingInitialEntry: true
-	}) : await params.runtime.agent.session.createSessionEntry(createParams);
+	});
 }
 //#endregion
 export { createImportedCodexSession };

package/dist/.setup/session-history-read-Ov3StuL4.mjs

@@ -0,0 +1,133 @@
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs/promises";
+import { SessionTranscriptReadFenceError, readCodexSessionContext } from "openclaw/plugin-sdk/codex-session-transcript-runtime";
+import { INLINE_IMAGE_DATA_URL_PREFIX, sanitizeInlineImageDataUrl } from "openclaw/plugin-sdk/inline-image-data-url-runtime";
+//#region extensions/codex/src/app-server/history-rejection.ts
+/** Only an owning rejection site can supply a diagnostic; exception text is never evidence. */
+var CodexHistoryRejection = class extends Error {
+	constructor(reason) {
+		super(`Codex history rejected: ${reason}`);
+		this.reason = reason;
+	}
+};
+function codexHistoryRejectionReason(error) {
+	return error instanceof CodexHistoryRejection ? error.reason : "history_read_failed";
+}
+//#endregion
+//#region extensions/codex/src/app-server/image-payload-sanitizer.ts
+/**
+* Sanitizes inline image payloads mirrored through Codex history so invalid
+* base64 data becomes readable text instead of poisoning replayed transcripts.
+*/
+const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
+/** Builds the replacement text inserted when an inline image payload is invalid. */
+function invalidInlineImageText(label) {
+	return `[${label}] ${IMAGE_OMITTED_TEXT}`;
+}
+function sanitizeImageContentRecord(record, label) {
+	if (record.type === "image" && typeof record.data === "string") {
+		const mimeType = typeof record.mimeType === "string" ? record.mimeType : "image/png";
+		const imageUrl = sanitizeInlineImageDataUrl(`data:${mimeType};base64,${record.data}`);
+		if (!imageUrl) return {
+			type: "text",
+			text: invalidInlineImageText(label)
+		};
+		const commaIndex = imageUrl.indexOf(",");
+		const mime = imageUrl.slice(INLINE_IMAGE_DATA_URL_PREFIX.length, commaIndex).split(";")[0] ?? mimeType;
+		const data = imageUrl.slice(commaIndex + 1);
+		return mime === record.mimeType && data === record.data ? record : {
+			...record,
+			mimeType: mime,
+			data
+		};
+	}
+	if (record.type === "inputImage" && typeof record.imageUrl === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl(record.imageUrl);
+		if (!imageUrl) return {
+			type: "inputText",
+			text: invalidInlineImageText(label)
+		};
+		return imageUrl === record.imageUrl ? record : {
+			...record,
+			imageUrl
+		};
+	}
+	if (record.type === "input_image" && typeof record.image_url === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl(record.image_url);
+		if (!imageUrl) return {
+			type: "input_text",
+			text: invalidInlineImageText(label)
+		};
+		return imageUrl === record.image_url ? record : {
+			...record,
+			image_url: imageUrl
+		};
+	}
+}
+/** Sanitizes images without copying unchanged history or mutating its owned snapshot. */
+function sanitizeCodexHistoryImagePayloads(value, label) {
+	if (Array.isArray(value)) {
+		let next;
+		for (let index = 0; index < value.length; index++) {
+			const child = sanitizeCodexHistoryImagePayloads(value[index], label);
+			if (child !== value[index]) (next ??= value.slice())[index] = child;
+		}
+		return next ?? value;
+	}
+	if (!isRecord(value)) return value;
+	const imageRecord = sanitizeImageContentRecord(value, label);
+	if (imageRecord) return imageRecord;
+	let next;
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		const child = sanitizeCodexHistoryImagePayloads(value[key], label);
+		if (child !== value[key]) (next ??= { ...value })[key] = child;
+	}
+	return next ?? value;
+}
+//#endregion
+//#region extensions/codex/src/app-server/session-history-read.ts
+function consumeCodexHistory(messages, header, sessionId, read, imageLabel = "codex mirrored history") {
+	if (!isRecord(header) || header.type !== "session") return read([]);
+	if (typeof header.id !== "string") throw new CodexHistoryRejection("malformed_header");
+	if (header.id !== sessionId) return read([]);
+	return read((function* () {
+		for (const message of messages) yield sanitizeCodexHistoryImagePayloads(message, imageLabel);
+	})());
+}
+/** Keeps native evidence and its synchronous consumer inside the same readonly snapshot. */
+async function readCodexNativeHistory(target, sessionId, read, admission, onSnapshot) {
+	const consume = (messages, header, version) => {
+		try {
+			onSnapshot?.(version);
+			return {
+				status: "ok",
+				value: consumeCodexHistory(messages, header, sessionId, read)
+			};
+		} catch (error) {
+			return {
+				status: "rejected",
+				reason: codexHistoryRejectionReason(error)
+			};
+		}
+	};
+	try {
+		if (target.kind === "empty") return consume([], void 0);
+		if (target.kind === "sqlite") return readCodexSessionContext(target.target, consume, admission);
+		const { buildSessionContext, migrateSessionEntries, parseSessionEntries } = await import("openclaw/plugin-sdk/agent-sessions");
+		const entries = parseSessionEntries(await fs.readFile(target.sessionFile, "utf-8"));
+		return consume((function* () {
+			migrateSessionEntries(entries);
+			const sessionEntries = entries.filter((entry) => isRecord(entry) && entry.type !== "session");
+			yield* buildSessionContext(sessionEntries).messages;
+		})(), entries[0]);
+	} catch (error) {
+		if (isRecord(error) && error.code === "ENOENT") return consume([], void 0);
+		return {
+			status: "rejected",
+			reason: error instanceof SessionTranscriptReadFenceError || isRecord(error) && (error.code === "EACCES" || error.code === "EPERM") ? "access_rejected" : codexHistoryRejectionReason(error)
+		};
+	}
+}
+//#endregion
+export { CodexHistoryRejection as a, sanitizeInlineImageDataUrl as i, readCodexNativeHistory as n, codexHistoryRejectionReason as o, invalidInlineImageText as r, consumeCodexHistory as t };