@openclaw/codex 2026.9.4 → 2026.9.5

package/dist/.setup/session-catalog-index-order-Cc5BzlQr.mjs

@@ -0,0 +1,48 @@
+import { V as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+//#region extensions/codex/src/session-catalog-index-order.ts
+function codexCatalogRowRecency(row) {
+	return row.recencyAt ?? row.updatedAt ?? 0;
+}
+function compareCodexCatalogRows(a, b) {
+	return codexCatalogRowRecency(b) - codexCatalogRowRecency(a) || (a.sourceOrder ?? 0) - (b.sourceOrder ?? 0) || (a.threadId < b.threadId ? 1 : a.threadId > b.threadId ? -1 : 0);
+}
+/** Admission and restoration share the archived-oldest eviction policy. */
+function retainCodexCatalogRow(rows, candidate) {
+	rows.set(candidate.threadId, candidate);
+	if (rows.size <= 2e4) return;
+	let oldest;
+	for (const row of rows.values()) if (!oldest || (row.archived !== oldest.archived ? row.archived : compareCodexCatalogRows(row, oldest) > 0)) oldest = row;
+	if (oldest) rows.delete(oldest.threadId);
+	return oldest;
+}
+/** Stable positions keep issued cursors independent of later native page offsets. */
+var CodexCatalogOrdering = class {
+	constructor() {
+		this.nextEventOrder = -1;
+	}
+	read(rows) {
+		return this.ordered ??= [...rows.values()].toSorted(compareCodexCatalogRows);
+	}
+	invalidate() {
+		this.ordered = void 0;
+	}
+	restore(row) {
+		this.nextEventOrder = Math.min(this.nextEventOrder, (row.sourceOrder ?? 0) - 1);
+	}
+	reserveEvent() {
+		return this.nextEventOrder--;
+	}
+	unchangedPosition(row, previous) {
+		return previous && codexCatalogRowRecency(row) <= codexCatalogRowRecency(previous) ? previous.sourceOrder : void 0;
+	}
+	position(row, previous) {
+		return row.sourceOrder ?? this.unchangedPosition(row, previous) ?? this.reserveEvent();
+	}
+	captureBatch(hasCompleteSnapshot) {
+		const base = hasCompleteSnapshot ? this.nextEventOrder - CODEX_CATALOG_MAX_ROWS : 0;
+		if (hasCompleteSnapshot) this.nextEventOrder = base - 1;
+		return (row, previous, position) => this.unchangedPosition(row, previous) ?? base + position;
+	}
+};
+//#endregion
+export { retainCodexCatalogRow as i, codexCatalogRowRecency as n, compareCodexCatalogRows as r, CodexCatalogOrdering as t };

package/dist/.setup/session-catalog-index-state-BAuDztHN.mjs

@@ -0,0 +1,180 @@
+import { H as detachCodexCatalogString, O as parseCatalogPage } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+import { i as retainCodexCatalogRow } from "./session-catalog-index-order-Cc5BzlQr.mjs";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+import { setImmediate } from "node:timers/promises";
+//#region extensions/codex/src/session-catalog-index-state.ts
+const CODEX_CATALOG_STATE_NAMESPACE = "session-catalog-resident";
+/** Durable metadata never asserts that a native process is still running. */
+function codexCatalogMetadataPage(page) {
+	return { sessions: page.sessions.map(({ status: _status, activeFlags: _flags, ...session }) => ({
+		...session,
+		status: "notLoaded"
+	})) };
+}
+function readStoredCodexCatalogRow(value) {
+	if (!isRecord(value) || value.version !== 1 || value.kind !== "row" || !isRecord(value.row)) return;
+	const row = value.row;
+	if (typeof row.threadId !== "string" || !row.threadId || row.threadId.length > 256 || typeof row.archived !== "boolean" || typeof row.nativeMetadata !== "boolean" || row.preview !== void 0 && (typeof row.preview !== "string" || row.preview.length > 500) || row.sourceOrder !== void 0 && (typeof row.sourceOrder !== "number" || !Number.isSafeInteger(row.sourceOrder)) || row.rolloutPath !== void 0 && (typeof row.rolloutPath !== "string" || row.rolloutPath.length > 4096) || !(row.updatedAt === null || typeof row.updatedAt === "number" && Number.isFinite(row.updatedAt)) || !(row.recencyAt === null || typeof row.recencyAt === "number" && Number.isFinite(row.recencyAt))) return;
+	try {
+		const page = parseCatalogPage(row.page);
+		if (page.sessions.length > 1 || page.sessions.some((session) => session.threadId !== row.threadId)) return;
+		const fingerprint = isRecord(row.fingerprint) && typeof row.fingerprint.mtimeMs === "number" && Number.isFinite(row.fingerprint.mtimeMs) && typeof row.fingerprint.size === "number" && Number.isFinite(row.fingerprint.size) ? {
+			mtimeMs: row.fingerprint.mtimeMs,
+			size: row.fingerprint.size
+		} : void 0;
+		return {
+			threadId: detachCodexCatalogString(row.threadId),
+			updatedAt: row.updatedAt,
+			recencyAt: row.recencyAt,
+			archived: row.archived,
+			nativeMetadata: row.nativeMetadata,
+			page: codexCatalogMetadataPage(page),
+			...typeof row.preview === "string" ? { preview: detachCodexCatalogString(row.preview) } : {},
+			...typeof row.sourceOrder === "number" ? { sourceOrder: row.sourceOrder } : {},
+			...typeof row.rolloutPath === "string" ? { rolloutPath: detachCodexCatalogString(row.rolloutPath) } : {},
+			...fingerprint ? { fingerprint } : {}
+		};
+	} catch {
+		return;
+	}
+}
+/** An incomplete cache cannot prove which native rows precede an issued cursor. */
+async function readCodexCatalogSnapshot(state) {
+	const entries = await state?.entries() ?? [];
+	const rows = /* @__PURE__ */ new Map();
+	const keys = /* @__PURE__ */ new Map();
+	const obsolete = /* @__PURE__ */ new Set();
+	let cleanupIncomplete = false;
+	let valid = true;
+	const discard = (key) => {
+		if (obsolete.has(key)) return;
+		if ((key === "complete" || obsolete.size - Number(obsolete.has("complete")) < 2e4) && Buffer.byteLength(key) <= 512) obsolete.add(detachCodexCatalogString(key));
+		else {
+			cleanupIncomplete = true;
+			obsolete.add("complete");
+		}
+	};
+	let complete = false;
+	let overflow = false;
+	for (const entry of entries) {
+		if (Buffer.byteLength(entry.key) > 512) {
+			valid = false;
+			discard(entry.key);
+			continue;
+		}
+		if (entry.value?.version === 1 && entry.value.kind === "complete") {
+			complete = true;
+			overflow ||= entry.value.overflow === true;
+			continue;
+		}
+		const row = readStoredCodexCatalogRow(entry.value);
+		if (row) {
+			const evicted = retainCodexCatalogRow(rows, row);
+			if (evicted) {
+				discard(evicted === row ? entry.key : keys.get(evicted.threadId));
+				keys.delete(evicted.threadId);
+			}
+			if (evicted !== row) keys.set(row.threadId, detachCodexCatalogString(entry.key));
+		} else {
+			valid = false;
+			discard(entry.key);
+		}
+	}
+	complete &&= valid;
+	if (!complete) {
+		rows.clear();
+		for (const entry of entries) discard(entry.key);
+		if (entries.length) obsolete.add("complete");
+	}
+	return {
+		rows: [...rows.values()],
+		complete,
+		overflow,
+		obsolete,
+		cleanupIncomplete
+	};
+}
+/** Serializes reconstructible cache writes without blocking resident queries. */
+var CodexCatalogPersistence = class {
+	invalidate(error) {
+		if (!this.failed) this.report(error);
+		this.failed = true;
+		this.queue("complete", void 0);
+	}
+	constructor(state, report) {
+		this.state = state;
+		this.report = report;
+		this.pending = /* @__PURE__ */ new Map();
+		this.failed = false;
+		this.retired = false;
+	}
+	async readSnapshot() {
+		await this.drain();
+		return await readCodexCatalogSnapshot(this.state);
+	}
+	key(threadId) {
+		return `thread:${createHash("sha256").update(threadId).digest("hex")}`;
+	}
+	put(row) {
+		if (!this.state || this.retired) return;
+		this.queue(this.key(row.threadId), {
+			version: 1,
+			kind: "row",
+			row
+		});
+	}
+	remove(threadId) {
+		this.queue(this.key(threadId), void 0);
+	}
+	async pruneObsolete(keys, currentRows) {
+		const currentKeys = new Set(Array.from(currentRows, (row) => this.key(row.threadId)));
+		for (const key of keys) if (!currentKeys.has(key)) this.queue(key, void 0);
+		await this.drain();
+	}
+	async finishHydration(overflow = false) {
+		await this.drain();
+		if (!this.failed) {
+			this.queue("complete", {
+				version: 1,
+				kind: "complete",
+				...overflow ? { overflow: true } : {}
+			});
+			await this.drain();
+		}
+	}
+	async drain() {
+		while (this.writing) await this.writing;
+	}
+	retire() {
+		this.retired = true;
+		return this.drain();
+	}
+	queue(key, value) {
+		if (!this.state || this.retired && (!this.writing || key !== "complete" || value !== void 0)) return;
+		if (key !== "complete" && !this.pending.has(key) && this.pending.size - Number(this.pending.has("complete")) >= 2e4) {
+			this.invalidate(/* @__PURE__ */ new Error("Codex catalog persistence queue reached its resident row limit"));
+			return;
+		}
+		this.pending.set(key, value);
+		this.writing ??= this.writePending();
+	}
+	async writePending() {
+		try {
+			await setImmediate();
+			for (const [key, value] of this.pending) {
+				this.pending.delete(key);
+				try {
+					if (value) await this.state.register(key, value);
+					else await this.state.delete(key);
+				} catch (error) {
+					if (!this.failed) this.invalidate(error);
+				}
+			}
+		} finally {
+			this.writing = void 0;
+		}
+	}
+};
+//#endregion
+export { CodexCatalogPersistence as n, codexCatalogMetadataPage as r, CODEX_CATALOG_STATE_NAMESPACE as t };

package/dist/{thread-history-page-D0JIp48V.js → .setup/session-catalog-native-projection-ChV3cCtm.mjs}

@@ -1,6 +1,24 @@
-import { n as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, t as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES } from "./protocol-5bh1G-H7.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { n as defineCodexBuildState } from "./build-state-Xx9ybZqa.mjs";
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.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";
@@ -16,6 +34,7 @@ const MAX_HOST_ID_LENGTH = 256;
 const MAX_CWD_LENGTH = 4096;
 const MAX_SESSION_NAME_LENGTH = 500;
 const MAX_SESSION_PREVIEW_LENGTH = 500;
+const SESSION_PREVIEW_PREFIX_LENGTH = 2048;
 const MAX_SESSION_KEY_LENGTH = 1024;
 const MAX_METADATA_LENGTH = 500;
 const MAX_ACTIVE_FLAGS = 16;
@@ -24,19 +43,29 @@ var CatalogParamsError = class extends Error {};
 function readControlCursor(value, label) {
 	if (value === void 0 || value === null) return;
 	if (typeof value !== "string" || !value.trim() || value.length > 4096) throw new CatalogParamsError(`invalid Codex session catalog ${label} cursor`);
-	return value;
+	return detachCodexCatalogString(value);
 }
 function boundedCatalogString(value, maxLength, overflow = "omit") {
 	if (typeof value !== "string") return;
 	const normalized = value.trim();
 	if (!normalized) return;
-	if (normalized.length <= maxLength) return normalized;
-	return overflow === "truncate" ? truncateUtf16Safe(normalized, maxLength) : void 0;
+	if (normalized.length <= maxLength) return detachCodexCatalogString(normalized);
+	return overflow === "truncate" ? detachCodexCatalogString(truncateUtf16Safe(normalized, maxLength)) : void 0;
 }
 function catalogPreview(value, sanitize) {
 	if (typeof value !== "string") return;
 	return boundedCatalogString(sanitize(value.replace(/\s+/g, " ")), MAX_SESSION_PREVIEW_LENGTH, "truncate");
 }
+/** Select a bounded input only for the canonical terminal sanitizer. */
+function selectCodexCatalogPreviewInput(value) {
+	if (value.length <= SESSION_PREVIEW_PREFIX_LENGTH) return value;
+	const prefix = value.slice(0, SESSION_PREVIEW_PREFIX_LENGTH).replace(/\s+/g, " ").trim();
+	return prefix.length > MAX_SESSION_PREVIEW_LENGTH && !/\p{Cc}/u.test(prefix) ? prefix : value;
+}
+/** Detach the small preview from V8's potentially large sliced-string backing store. */
+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;
@@ -44,36 +73,45 @@ function normalizeInteractiveThreadSource(source) {
 function isInteractiveThreadSource(source) {
 	return normalizeInteractiveThreadSource(source) !== void 0;
 }
-function toCatalogSession(thread, archived, sanitize) {
+function codexCatalogThreadName(value) {
+	return value === null ? null : boundedCatalogString(value, MAX_SESSION_NAME_LENGTH, "truncate");
+}
+function codexCatalogThreadStatus(status) {
+	const activeFlags = [];
+	if (status?.type === "active" && Array.isArray(status.activeFlags)) for (const flag of status.activeFlags) {
+		const normalized = boundedCatalogString(flag, 128);
+		if (normalized) activeFlags.push(normalized);
+		if (activeFlags.length === MAX_ACTIVE_FLAGS) break;
+	}
+	return {
+		status: boundedCatalogString(status?.type, 64) ?? "notLoaded",
+		...activeFlags.length ? { activeFlags } : {}
+	};
+}
+function toCatalogSession(thread, archived, sanitize, preparedPreview) {
 	const source = normalizeInteractiveThreadSource(thread.source);
 	if (!source) return;
-	const record = thread;
 	const threadId = boundedCatalogString(thread.id, 256);
 	if (!threadId) return;
-	const activeFlags = thread.status?.type === "active" ? thread.status.activeFlags?.flatMap((flag) => {
-		const normalized = boundedCatalogString(flag, 128);
-		return normalized ? [normalized] : [];
-	}).slice(0, MAX_ACTIVE_FLAGS) : void 0;
-	const gitInfo = isRecord(record.gitInfo) ? record.gitInfo : void 0;
+	const gitInfo = isRecord(thread.gitInfo) ? thread.gitInfo : void 0;
 	const sessionId = boundedCatalogString(thread.sessionId, 256);
-	const name = boundedCatalogString(thread.name, MAX_SESSION_NAME_LENGTH, "truncate");
-	const fallbackName = name ? void 0 : catalogPreview(thread.preview, sanitize);
+	const name = codexCatalogThreadName(thread.name);
+	const fallbackName = name ? void 0 : preparedPreview ? preparedPreview.value : catalogPreview(thread.preview, sanitize);
 	const cwd = boundedCatalogString(thread.cwd, MAX_CWD_LENGTH);
-	const modelProvider = boundedCatalogString(record.modelProvider, MAX_METADATA_LENGTH, "truncate");
-	const cliVersion = boundedCatalogString(record.cliVersion, MAX_METADATA_LENGTH, "truncate");
+	const modelProvider = boundedCatalogString(thread.modelProvider, MAX_METADATA_LENGTH, "truncate");
+	const cliVersion = boundedCatalogString(thread.cliVersion, MAX_METADATA_LENGTH, "truncate");
 	const gitBranch = boundedCatalogString(gitInfo?.branch, MAX_METADATA_LENGTH, "truncate");
 	return {
 		threadId,
-		status: thread.status?.type ?? "notLoaded",
+		...codexCatalogThreadStatus(thread.status),
 		archived,
 		...sessionId ? { sessionId } : {},
 		...thread.name === null ? { name: null } : name ? { name } : {},
 		...fallbackName ? { fallbackName } : {},
 		...cwd ? { cwd } : {},
-		...activeFlags?.length ? { activeFlags } : {},
 		...typeof thread.createdAt === "number" && Number.isFinite(thread.createdAt) ? { createdAt: thread.createdAt } : {},
 		...typeof thread.updatedAt === "number" && Number.isFinite(thread.updatedAt) ? { updatedAt: thread.updatedAt } : {},
-		...typeof record.recencyAt === "number" && Number.isFinite(record.recencyAt) ? { recencyAt: record.recencyAt } : record.recencyAt === null ? { recencyAt: null } : {},
+		...typeof thread.recencyAt === "number" && Number.isFinite(thread.recencyAt) ? { recencyAt: thread.recencyAt } : thread.recencyAt === null ? { recencyAt: null } : {},
 		source,
 		...modelProvider ? { modelProvider } : {},
 		...cliVersion ? { cliVersion } : {},
@@ -169,7 +207,7 @@ function parseJsonParams(paramsJSON) {
 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}`);
-	return value;
+	return detachCodexCatalogString(value);
 }
 function parseCatalogSession(value, options = {}) {
 	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.threadId.length > 256 || value.archived !== false) throw new Error("Codex session catalog returned an invalid session");
@@ -195,7 +233,7 @@ function parseCatalogSession(value, options = {}) {
 	const updatedAt = asFiniteNumber(value.updatedAt);
 	const recencyAt = value.recencyAt === null ? null : asFiniteNumber(value.recencyAt);
 	return {
-		threadId: value.threadId,
+		threadId: detachCodexCatalogString(value.threadId),
 		status,
 		archived: value.archived,
 		...sessionId !== void 0 ? { sessionId } : {},
@@ -277,85 +315,158 @@ function requireBoundThread(entry) {
 	return entry.boundThreadId;
 }
 //#endregion
-//#region extensions/codex/src/app-server/thread-history-page.ts
-const TURN_ITEM_CURSOR_PREFIX = "turn-item:";
-function encodeTurnItemCursor(turnCursor, itemId) {
-	return TURN_ITEM_CURSOR_PREFIX + Buffer.from(JSON.stringify([turnCursor, itemId])).toString("base64url");
-}
-function decodeTurnItemCursor(cursor) {
-	if (!cursor?.startsWith(TURN_ITEM_CURSOR_PREFIX)) return { turnCursor: cursor };
-	let value;
-	try {
-		value = JSON.parse(Buffer.from(cursor.slice(10), "base64url").toString());
-	} catch {
-		throw new CatalogParamsError("invalid Codex transcript item cursor");
+//#region extensions/codex/src/session-catalog-source.ts
+const getSources = defineCodexBuildState("openclaw.codexCatalogSources", () => ({
+	clients: /* @__PURE__ */ new WeakMap(),
+	values: /* @__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;
+	else clients.set(client, { closed: true });
+}
+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 (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !value[0] || typeof value[1] !== "string" || !value[1]) throw new CatalogParamsError("invalid Codex transcript item cursor");
-	return {
-		turnCursor: value[0],
-		itemId: value[1]
-	};
 }
-/** Legacy stores expose only turn cursors; an item identity preserves paging across appends. */
-async function readLegacyCodexHistoryPage(readTurns, request, projection) {
-	const { turnCursor, itemId } = decodeTurnItemCursor(request.cursor);
-	const page = parseTranscriptPage(await readTurns({
-		threadId: request.threadId,
-		limit: 1,
-		sortDirection: "desc",
-		itemsView: "full",
-		...turnCursor ? { cursor: turnCursor } : {}
-	}));
-	const source = page.data.flatMap(({ items, ...turn }) => items.toReversed().map((item) => ({
-		turnId: turn.id,
-		item,
-		turn
-	})));
-	const anchorIndex = itemId ? source.findIndex(({ item }) => item.id === itemId) : -1;
-	if (itemId && anchorIndex < 0) throw new CatalogParamsError("Codex transcript changed; refresh the session before loading older items");
-	const remaining = source.slice(anchorIndex + 1);
-	const items = projection.project(remaining.slice(0, request.limit), request.limit);
-	const result = () => {
-		const lastSource = remaining[items.length - 1];
-		const partial = lastSource !== void 0 && items.length < remaining.length;
-		const nativeCursor = partial ? page.backwardsCursor : page.nextCursor;
-		const cursor = nativeCursor ? partial ? encodeTurnItemCursor(nativeCursor, lastSource.item.id) : nativeCursor : void 0;
-		if (partial && !cursor) throw new Error("Codex app-server did not provide a transcript continuation anchor");
-		return {
-			items,
-			...cursor ? { nextCursor: cursor } : {}
-		};
+//#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
+});
+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
 	};
-	let bounded = result();
-	while (!projection.fits(bounded)) {
-		if (items.length <= 1) throw new Error("Codex transcript item exceeds the safe response size");
-		items.pop();
-		bounded = result();
+	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 preview = cachedPreview?.({
+		id,
+		path: typeof row.path === "string" ? row.path : null,
+		updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : null,
+		recencyAt: typeof row.recencyAt === "number" ? row.recencyAt : null
+	});
+	const rawPreview = thread.preview;
+	if (preview !== void 0 && preview.length <= 500 && !(typeof rawPreview === "string" && Boolean(rawPreview) !== Boolean(preview))) 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 bounded;
-}
-/** Callers authorize the thread; this reader owns native cursor and response-size semantics. */
-async function readCodexThreadHistoryPage(control, thread, request, projection) {
-	if (thread.historyMode !== "paginated") return readLegacyCodexHistoryPage((params) => control.listTurnPage(params), request, projection);
-	let limit = request.limit;
-	for (;;) {
-		const page = await control.listItemPage({
-			threadId: request.threadId,
-			limit,
-			sortDirection: "desc",
-			...request.cursor ? { cursor: request.cursor } : {}
-		});
-		const nextCursor = readControlCursor(page.nextCursor, "transcript next response");
-		const items = projection.project(page.data, limit);
-		const result = {
-			items,
-			...nextCursor ? { nextCursor } : {}
-		};
-		const fittingCount = items.length - (projection.fits(result) ? 0 : 1);
-		if (fittingCount === page.data.length) return result;
-		if (fittingCount < 1) throw new Error("Codex transcript item exceeds the safe response size");
-		limit = fittingCount;
+	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;
 }
 //#endregion
-export { readPageParams as C, unwrapNodeInvokePayload as D, toCatalogSession as E, readGatewayParams as S, requireOnlyKeys as T, parseCatalogPage as _, CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND as a, readBoundedOptionalString as b, CatalogParamsError as c, NODE_INVOKE_TIMEOUT_MS as d, boundedCatalogString as f, normalizeLimit as g, isInteractiveThreadSource as h, CODEX_APP_SERVER_THREADS_LIST_COMMAND as i, MAX_CURSOR_LENGTH as l, filterCatalogPageByTitle as m, readLegacyCodexHistoryPage as n, CODEX_CATALOG_TRANSCRIPT_READ_COMMAND as o, catalogError as p, CODEX_APP_SERVER_THREADS_CAPABILITY as r, CODEX_LOCAL_SESSION_HOST_ID as s, readCodexThreadHistoryPage as t, MAX_TRANSCRIPT_PAGE_BYTES as u, parseJsonParams as v, requireBoundThread as w, readControlCursor as x, parseTranscriptPage as y };
+export { parseTranscriptPage as A, unwrapNodeInvokePayload as B, codexCatalogThreadName as C, normalizeLimit as D, isInteractiveThreadSource as E, requireBoundThread as F, detachCodexCatalogString as H, requireOnlyKeys as I, selectCodexCatalogPreviewInput as L, readControlCursor as M, readGatewayParams as N, parseCatalogPage as O, readPageParams as P, toCatalogSession as R, catalogError as S, filterCatalogPageByTitle as T, session_catalog_limits_exports as U, CODEX_CATALOG_MAX_ROWS as V, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as W, MAX_CURSOR_LENGTH as _, closeCodexCatalogClientSource as a, NODE_INVOKE_TIMEOUT_MS as b, getCodexCatalogSource as c, CODEX_APP_SERVER_THREADS_CAPABILITY as d, CODEX_APP_SERVER_THREADS_LIST_COMMAND as f, CatalogParamsError as g, CODEX_LOCAL_SESSION_HOST_ID as h, session_catalog_native_projection_exports as i, readBoundedOptionalString as j, parseJsonParams as k, recordCodexCatalogResponseSource as l, CODEX_CATALOG_TRANSCRIPT_READ_COMMAND as m, projectCodexCatalogNativeResponse as n, codexCatalogSourceForClient as o, CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND as p, projectCodexCatalogNativeThread as r, copyCodexCatalogSource as s, CODEX_CATALOG_NATIVE_PAGE_LIMIT as t, setCodexCatalogSource as u, MAX_CWD_LENGTH as v, codexCatalogThreadStatus as w, boundedCatalogString as x, MAX_TRANSCRIPT_PAGE_BYTES as y, truncateCodexCatalogPreview as z };

package/dist/{session-catalog-node-adoption-B1tgDW-m.js → .setup/session-catalog-node-adoption-BVRsYOSh.mjs}

@@ -1,8 +1,8 @@
-import { c as CatalogParamsError } from "./thread-history-page-D0JIp48V.js";
+import { g as CatalogParamsError } from "./session-catalog-native-projection-ChV3cCtm.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
-import { resolveStorePath } from "openclaw/plugin-sdk/session-store-paths";
 import { listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
+import { resolveStorePath } from "openclaw/plugin-sdk/session-store-paths";
 //#region extensions/codex/src/session-catalog-node-adoption.ts
 const CODEX_NODE_SESSION_KEY_PREFIX = "harness:codex:node-session:";
 const continueOperations = /* @__PURE__ */ new Map();
@@ -144,7 +144,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 			},
 			afterCreate: async (entry) => {
 				const storePath = resolveStorePath(params.config.session?.store, { agentId: entry.agentId });
-				const { importCodexThreadHistoryToTranscript } = await import("./transcript-mirror-C5CKgNy6.js").then((n) => n.a);
+				const { importCodexThreadHistoryToTranscript } = await import("./transcript-mirror-D4qp_leP.mjs").then((n) => n.a);
 				await importCodexThreadHistoryToTranscript({
 					thread: params.history.thread,
 					throughTurnId: params.history.throughTurnId,

package/dist/{session-catalog-node-continue-Ci-DXyJP.js → .setup/session-catalog-node-continue-Dowv8osw.mjs}

@@ -1,10 +1,10 @@
-import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-BiodpIzq.js";
-import { t as CODEX_CLI_SESSION_RESUME_COMMAND } from "./node-cli-sessions-DKaOmVUh.js";
-import { a as lookupNodeCodexCatalogRecord } from "./session-catalog-ct-AH01I.js";
-import { D as unwrapNodeInvokePayload, _ as parseCatalogPage, a as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, c as CatalogParamsError, d as NODE_INVOKE_TIMEOUT_MS, f as boundedCatalogString, h as isInteractiveThreadSource, i as CODEX_APP_SERVER_THREADS_LIST_COMMAND, m as filterCatalogPageByTitle, p as catalogError, y as parseTranscriptPage } from "./thread-history-page-D0JIp48V.js";
-import { t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.js";
-import { n as withTimeout } from "./timeout-BVw8aaM1.js";
-import { createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, nodeSessionMarker, runSessionActionExclusive } from "./session-catalog-node-adoption-B1tgDW-m.js";
+import { A as parseTranscriptPage, B as unwrapNodeInvokePayload, E as isInteractiveThreadSource, O as parseCatalogPage, S as catalogError, T as filterCatalogPageByTitle, b as NODE_INVOKE_TIMEOUT_MS, f as CODEX_APP_SERVER_THREADS_LIST_COMMAND, g as CatalogParamsError, p as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, x as boundedCatalogString } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-CrcyZk6O.mjs";
+import { n as withTimeout } from "./timeout-DZF05XrR.mjs";
+import { t as CODEX_CLI_SESSION_RESUME_COMMAND } from "./node-cli-sessions-Cl8b2ZF3.mjs";
+import { o as lookupNodeCodexCatalogRecord } from "./session-catalog-fUdWDx-U.mjs";
+import { t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.mjs";
+import { createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, nodeSessionMarker, runSessionActionExclusive } from "./session-catalog-node-adoption-BVRsYOSh.mjs";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { createSessionCatalogAdoptionCoordinator, publishSessionCatalogHost, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 //#region extensions/codex/src/session-catalog-node-continue.ts