@openclaw/codex 2026.9.4 → 2026.9.6

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

@@ -0,0 +1,48 @@
+import { U as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-native-projection-DowriLid.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()].filter((row) => !row.archived && row.page.sessions.length > 0).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-Dgh8ORJm.mjs

@@ -0,0 +1,183 @@
+import { A as parseCatalogPage, W as detachCodexCatalogString } from "./session-catalog-native-projection-DowriLid.mjs";
+import { i as retainCodexCatalogRow } from "./session-catalog-index-order-hcdz07yN.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;
+	}
+	hasActiveWork() {
+		return this.writing !== void 0 || this.pending.size > 0;
+	}
+	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-DowriLid.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-C7EnDVgr.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.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 } : {},
@@ -216,9 +254,12 @@ function parseCatalogSession(value, options = {}) {
 function parseCatalogPage(value, options = {}) {
 	if (!isRecord(value) || !Array.isArray(value.sessions) || value.sessions.length > 100) throw new Error("Codex session catalog returned an invalid page");
 	const nextCursor = parseOptionalCatalogString(value.nextCursor, "next cursor", MAX_CURSOR_LENGTH);
+	const sourceHomeId = parseOptionalCatalogString(value.sourceHomeId, "source home id", 256);
 	const backwardsCursor = parseOptionalCatalogString(value.backwardsCursor, "backwards cursor", MAX_CURSOR_LENGTH);
 	return {
 		sessions: value.sessions.map((session) => parseCatalogSession(session, options)),
+		...sourceHomeId ? { sourceHomeId } : {},
+		...typeof value.canContinueCodex === "boolean" ? { canContinueCodex: value.canContinueCodex } : {},
 		...nextCursor ? { nextCursor } : {},
 		...backwardsCursor ? { backwardsCursor } : {}
 	};
@@ -277,85 +318,172 @@ 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()
+}));
+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);
 	}
-	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]
-	};
+	return source;
 }
-/** 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 } : {}
-		};
+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
 	};
-	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;
 	}
-	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;
+	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 { 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 { 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 };