@openclaw/codex 2026.9.8 → 2026.10.1-beta.1

package/dist/.setup/{session-catalog-index-DwJjnF5k.mjs → session-catalog-index-DPICGlxr.mjs}

@@ -1,17 +1,19 @@
-import { S as readControlCursor, _ as normalizeLimit, c as MAX_CWD_LENGTH, d as boundedCatalogString, h as filterCatalogPageByTitle, m as codexCatalogThreadStatus, o as CatalogParamsError, p as codexCatalogThreadName } from "./session-catalog-parsing-CPGaPYr-.mjs";
-import { t as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-limits-DDxOsQeC.mjs";
-import { i as retainCodexCatalogRow, n as codexCatalogRowRecency, r as compareCodexCatalogRows, t as CodexCatalogOrdering } from "./session-catalog-index-order-BcQpHks3.mjs";
-import { n as CodexCatalogPersistence, r as codexCatalogMetadataPage } from "./session-catalog-index-state-TeO7EyO-.mjs";
-import { i as CodexCatalogAvailability, r as withCodexCatalogListRequest } from "./session-catalog-list-request-CvtxrYSe.mjs";
-import { l as getCodexCatalogSource, p as setCodexCatalogSource, r as projectCodexCatalogNativeThread, u as hasLiveCodexCatalogSource } from "./session-catalog-native-projection-CuaFZuQE.mjs";
-import { i as subscribeCodexCatalogEvents } from "./session-catalog-events-BMCFMZw-.mjs";
+import { S as readControlCursor, _ as normalizeLimit, c as MAX_CWD_LENGTH, d as boundedCatalogString, h as filterCatalogPageByTitle, m as codexCatalogThreadStatus, o as CatalogParamsError, p as codexCatalogThreadName } from "./session-catalog-parsing-B-qWJh2x.mjs";
+import { n as detachCodexCatalogString, t as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-limits-DEU36Qlo.mjs";
+import { i as retainCodexCatalogRow, n as codexCatalogRowRecency, r as compareCodexCatalogRows, t as CodexCatalogOrdering } from "./session-catalog-index-order-nhyO0wdW.mjs";
+import { c as codexCatalogMetadataPage, i as CodexCatalogAvailability, r as withCodexCatalogListRequest, s as CodexCatalogPersistence } from "./session-catalog-list-request-tXephOB4.mjs";
+import { l as getCodexCatalogSource, p as setCodexCatalogSource, r as projectCodexCatalogNativeThread, u as hasLiveCodexCatalogSource } from "./session-catalog-native-projection-CTBd4EUm.mjs";
+import { i as subscribeCodexCatalogEvents } from "./session-catalog-events-KIXOoSnQ.mjs";
 import { a as reportCodexCatalogSpawnFailure, n as findCodexAppServerSpawnError } from "./spawn-error-CL3n6MAa.mjs";
-import { CodexCatalogProjectionCapacityError, CodexCatalogProjections, a as resolveCodexCatalogRolloutFingerprint, i as readCodexCatalogRollout, mergeCodexCatalogRolloutRow, n as indexCodexCatalogRowsByRollout, o as scanCodexCatalogRollouts, projectCodexCatalogThread, r as isCodexCatalogRolloutPathCovered, t as codexCatalogRolloutLogicalPath } from "./session-catalog-projection-CGfzfP93.mjs";
+import { CodexCatalogProjectionCapacityError, CodexCatalogProjections, mergeCodexCatalogRolloutRow, n as readCodexCatalogRollout, projectCodexCatalogThread, r as resolveCodexCatalogRolloutFingerprint, t as codexCatalogRolloutLogicalPath } from "./session-catalog-projection-CE0_Hffi.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
-import { coerceErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import { coerceErrorMessage, extractErrorCode, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { setImmediate as setImmediate$1 } from "node:timers/promises";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 //#region extensions/codex/src/session-catalog-currency.ts
@@ -349,6 +351,318 @@ var CodexCatalogField = class {
 	}
 };
 //#endregion
+//#region extensions/codex/src/session-catalog-rollout-scanner.ts
+const DIRECTORY_PARTS = [
+	/^\d{4}$/,
+	/^(?:0[1-9]|1[0-2])$/,
+	/^(?:0[1-9]|[12]\d|3[01])$/
+];
+const ROLLOUT_FILE_NAME = /\.jsonl(?:\.zst)?$/;
+const MAX_WATCHED_DIRECTORIES = 256;
+const SCAN_BATCH_SIZE = 64;
+const DARWIN_WATCH_ARM_MS = 250;
+function compareRolloutCandidates(left, right) {
+	return left[1].mtimeMs - right[1].mtimeMs || (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0);
+}
+/** Retain only the newest fingerprints while streaming an arbitrarily large home. */
+var NewestRolloutCandidates = class {
+	constructor() {
+		this.heap = [];
+	}
+	offer(candidate) {
+		if (this.heap.length < 2e4) {
+			let childIndex = this.heap.length;
+			this.heap.push(candidate);
+			while (childIndex > 0) {
+				const parentIndex = Math.floor((childIndex - 1) / 2);
+				const parent = this.heap[parentIndex];
+				if (!parent || compareRolloutCandidates(parent, candidate) <= 0) break;
+				this.heap[childIndex] = parent;
+				childIndex = parentIndex;
+			}
+			this.heap[childIndex] = candidate;
+			return;
+		}
+		const oldest = this.heap[0];
+		if (!oldest || compareRolloutCandidates(candidate, oldest) <= 0) return;
+		let parentIndex = 0;
+		while (true) {
+			let childIndex = parentIndex * 2 + 1;
+			let child = this.heap[childIndex];
+			if (!child) break;
+			const right = this.heap[childIndex + 1];
+			if (right && compareRolloutCandidates(right, child) < 0) {
+				child = right;
+				childIndex++;
+			}
+			if (compareRolloutCandidates(candidate, child) <= 0) break;
+			this.heap[parentIndex] = child;
+			parentIndex = childIndex;
+		}
+		this.heap[parentIndex] = candidate;
+	}
+	finish() {
+		this.heap.sort((left, right) => compareRolloutCandidates(right, left));
+		return new Map(this.heap);
+	}
+};
+/** Absence is meaningful only inside the layout visited by the currency scan. */
+function isCodexCatalogRolloutPathCovered(sessionsRoot, rolloutPath) {
+	const directories = path.relative(sessionsRoot, rolloutPath).split(path.sep);
+	const fileName = directories.pop();
+	return fileName !== void 0 && ROLLOUT_FILE_NAME.test(fileName) && directories.length === DIRECTORY_PARTS.length && directories.every((part, index) => DIRECTORY_PARTS[index]?.test(part) === true);
+}
+async function unlessMissing(operation) {
+	try {
+		return await operation;
+	} catch (error) {
+		if (extractErrorCode(error) === "ENOENT") return;
+		throw error;
+	}
+}
+function sameDirectory(left, right) {
+	return left.dev === right.dev && left.ino === right.ino && left.ctimeMs === right.ctimeMs && left.mtimeMs === right.mtimeMs;
+}
+/** The resident home owns a bounded watcher cache; unwatchable leaves are scanned in full. */
+var CodexCatalogRolloutScanner = class {
+	constructor(sessionsRoot) {
+		this.sessionsRoot = sessionsRoot;
+		this.directories = /* @__PURE__ */ new Map();
+		this.cachedFiles = 0;
+		this.closed = false;
+	}
+	scan(trackedPaths) {
+		const previous = this.running;
+		const running = (async () => {
+			await previous?.catch(() => void 0);
+			await setImmediate$1();
+			return this.walk(trackedPaths);
+		})();
+		this.running = running;
+		return running.finally(() => {
+			if (this.running === running) this.running = void 0;
+		});
+	}
+	forget(directory) {
+		const cached = this.directories.get(directory);
+		if (cached) {
+			this.cachedFiles -= cached.files.size;
+			this.directories.delete(directory);
+			cached.watcher.close();
+		}
+	}
+	watch(directory, stat) {
+		if (this.closed || directory.length > 4096 || this.directories.size >= MAX_WATCHED_DIRECTORIES) return;
+		try {
+			const watcher = fs.watch(directory, { persistent: false });
+			const cached = {
+				watcher,
+				stat,
+				revision: 0,
+				armAt: process.platform === "darwin" ? performance.now() + DARWIN_WATCH_ARM_MS : 0,
+				files: /* @__PURE__ */ new Map()
+			};
+			watcher.on("change", () => {
+				cached.revision++;
+			});
+			const withdraw = () => {
+				if (this.directories.get(directory) === cached) this.forget(directory);
+			};
+			watcher.on("error", withdraw);
+			watcher.on("close", withdraw);
+			this.directories.set(directory, cached);
+			return cached;
+		} catch {
+			return;
+		}
+	}
+	async walk(trackedPaths, reuseCache = true) {
+		if (this.closed) throw new Error("Codex catalog rollout scanner is closed");
+		const present = /* @__PURE__ */ new Set();
+		const unvisited = new Set(this.directories.keys());
+		const candidates = new NewestRolloutCandidates();
+		const reused = /* @__PURE__ */ new Map();
+		let cacheWithdrawn = false;
+		let processed = 0;
+		const offer = (file, fingerprint) => {
+			if (trackedPaths.has(codexCatalogRolloutLogicalPath(file))) present.add(codexCatalogRolloutLogicalPath(file));
+			candidates.offer([file, fingerprint]);
+		};
+		const scan = async (directory, depth, rootReal) => {
+			if (this.closed) throw new Error("Codex catalog rollout scanner is closed");
+			if (await unlessMissing(fs$1.realpath(directory)) !== directory) return;
+			const directoryPattern = DIRECTORY_PARTS[depth];
+			const stat = !directoryPattern ? await unlessMissing(fs$1.lstat(directory)) : void 0;
+			let cached = this.directories.get(directory);
+			if (!directoryPattern) {
+				if (!stat?.isDirectory() || stat.isSymbolicLink()) return;
+				unvisited.delete(directory);
+				if (cached && !sameDirectory(cached.stat, stat)) {
+					this.forget(directory);
+					cached = void 0;
+				}
+				if (reuseCache && cached && cached.scannedRevision === cached.revision) {
+					const revision = cached.revision;
+					reused.set(directory, {
+						cached,
+						revision
+					});
+					for (const [file, fingerprint] of cached.files) {
+						offer(file, fingerprint);
+						if (++processed % SCAN_BATCH_SIZE === 0) {
+							await setImmediate$1();
+							if (this.directories.get(directory) !== cached || cached.revision !== revision) {
+								cacheWithdrawn = true;
+								return;
+							}
+						}
+					}
+					return;
+				}
+				cached ??= this.watch(directory, stat);
+			}
+			if (cached) cached.scannedRevision = void 0;
+			const revision = cached?.revision;
+			const armed = cached && performance.now() >= cached.armAt;
+			const retained = cached ? /* @__PURE__ */ new Map() : void 0;
+			let cacheable = true;
+			const entries = await unlessMissing(fs$1.opendir(directory));
+			if (!entries) {
+				this.forget(directory);
+				return;
+			}
+			for await (const entry of entries) {
+				if (cacheWithdrawn) return;
+				if (this.closed) throw new Error("Codex catalog rollout scanner is closed");
+				if (++processed % SCAN_BATCH_SIZE === 0) await setImmediate$1();
+				const file = path.join(directory, entry.name);
+				if (directoryPattern) {
+					if (entry.isDirectory() && directoryPattern.test(entry.name)) await scan(file, depth + 1, rootReal);
+				} else if (entry.isFile() && ROLLOUT_FILE_NAME.test(entry.name)) {
+					const fileStat = await unlessMissing(fs$1.lstat(file));
+					if (!fileStat?.isFile() || fileStat.nlink !== 1) continue;
+					const physicalPath = path.join(this.sessionsRoot, path.relative(rootReal, file));
+					if (physicalPath.length > 4096) continue;
+					if (physicalPath !== codexCatalogRolloutLogicalPath(physicalPath)) {
+						const plain = await unlessMissing(fs$1.lstat(codexCatalogRolloutLogicalPath(file)));
+						if (plain?.isFile() && plain.nlink === 1) continue;
+					}
+					const fingerprint = {
+						mtimeMs: fileStat.mtimeMs,
+						size: fileStat.size
+					};
+					const detached = detachCodexCatalogString(physicalPath);
+					offer(detached, fingerprint);
+					if (retained && cacheable) {
+						retained.set(detached, fingerprint);
+						if (this.cachedFiles - (cached?.files.size ?? 0) + retained.size > 2e4) {
+							cacheable = false;
+							retained.clear();
+						}
+					}
+				}
+			}
+			if (cached && retained && stat) {
+				const current = await unlessMissing(fs$1.lstat(directory));
+				if (cacheable && !this.closed && this.directories.get(directory) === cached && current?.isDirectory() && sameDirectory(stat, current)) {
+					this.cachedFiles += retained.size - cached.files.size;
+					cached.files = retained;
+					cached.stat = stat;
+					cached.scannedRevision = armed && cached.revision === revision ? revision : void 0;
+				} else this.forget(directory);
+			}
+		};
+		const rootStat = await unlessMissing(fs$1.lstat(this.sessionsRoot));
+		if (rootStat?.isDirectory() && !rootStat.isSymbolicLink()) {
+			const rootReal = await unlessMissing(fs$1.realpath(this.sessionsRoot));
+			if (rootReal) await scan(rootReal, 0, rootReal);
+		}
+		if (cacheWithdrawn || [...reused].some(([directory, { cached, revision }]) => this.directories.get(directory) !== cached || cached.revision !== revision)) return this.walk(trackedPaths, false);
+		for (const directory of unvisited) this.forget(directory);
+		return {
+			files: candidates.finish(),
+			present
+		};
+	}
+	close() {
+		this.closed = true;
+		for (const directory of this.directories.keys()) this.forget(directory);
+	}
+};
+//#endregion
+//#region extensions/codex/src/session-catalog-index-files.ts
+/** Plan file reconciliation; the index retains every publication and lifetime decision. */
+async function reconcileCodexCatalogFiles(root, isCurrent, owner) {
+	const byPath = /* @__PURE__ */ new Map();
+	let processed = 0;
+	for (const row of owner.rows.values()) {
+		if (row.rolloutPath) byPath.set(codexCatalogRolloutLogicalPath(row.rolloutPath), row);
+		if (++processed % 128 === 0) {
+			await setImmediate$1();
+			owner.assertCurrent();
+		}
+	}
+	const { files, present } = await owner.scanner.scan(new Set(byPath.keys()));
+	owner.assertCurrent();
+	const observed = new Map(files);
+	for (const [file, fingerprint] of files) {
+		if (++processed % 128 === 0) {
+			await setImmediate$1();
+			owner.assertCurrent();
+		}
+		const previous = byPath.get(codexCatalogRolloutLogicalPath(file));
+		const known = owner.observedFiles.get(file) ?? previous?.fingerprint;
+		if (known?.mtimeMs === fingerprint.mtimeMs && known.size === fingerprint.size) continue;
+		owner.requestNativeRefresh();
+		observed.delete(file);
+		if (known) observed.set(file, known);
+		let thread;
+		try {
+			thread = await readCodexCatalogRollout(root, file);
+		} catch (error) {
+			owner.assertCurrent();
+			owner.report(error);
+			continue;
+		}
+		owner.assertCurrent();
+		if (!thread) {
+			observed.set(file, fingerprint);
+			continue;
+		}
+		if (!isCurrent(thread.id)) continue;
+		const existing = owner.rows.get(thread.id);
+		if (existing?.rolloutPath && codexCatalogRolloutLogicalPath(existing.rolloutPath) !== codexCatalogRolloutLogicalPath(file)) {
+			observed.set(file, fingerprint);
+			continue;
+		}
+		if (!existing && !thread.preview) {
+			observed.set(file, fingerprint);
+			continue;
+		}
+		thread.preview ||= existing?.preview;
+		const projected = await projectCodexCatalogThread(thread, root);
+		owner.assertCurrent();
+		if (!isCurrent(thread.id)) continue;
+		observed.set(file, fingerprint);
+		const row = projected.rows[0];
+		if (!row) continue;
+		owner.mark(row.threadId);
+		owner.put(mergeCodexCatalogRolloutRow(row, existing, fingerprint));
+		await setImmediate$1();
+	}
+	for (const row of byPath.values()) {
+		if (++processed % 128 === 0) {
+			await setImmediate$1();
+			owner.assertCurrent();
+		}
+		if (row.rolloutPath && isCodexCatalogRolloutPathCovered(root, row.rolloutPath) && !present.has(codexCatalogRolloutLogicalPath(row.rolloutPath)) && owner.rows.get(row.threadId) === row) {
+			owner.requestNativeRefresh();
+			owner.remove(row.threadId);
+		}
+	}
+	return observed;
+}
+//#endregion
 //#region extensions/codex/src/session-catalog-index-names.ts
 function applyCodexCatalogName(row, name) {
 	if (name === void 0) return row;
@@ -729,6 +1043,7 @@ var CodexCatalogIndex = class {
 		this.sourceRevision = 0;
 		this.ordering = new CodexCatalogOrdering();
 		this.observations = new CodexCatalogObservations();
+		this.rolloutScanner = options.localSessionsRoot ? new CodexCatalogRolloutScanner(options.localSessionsRoot) : void 0;
 		this.currency = new CodexCatalogCurrency({
 			local: Boolean(options.localSessionsRoot),
 			reconcileFiles: () => this.reconcile(),
@@ -879,16 +1194,23 @@ var CodexCatalogIndex = class {
 				this.assertCurrent();
 				if (snapshot.cleanupIncomplete) this.persistence.invalidate(/* @__PURE__ */ new Error("Codex catalog obsolete snapshot exceeds its cleanup limit"));
 				for (const key of snapshot.obsolete) this.obsoleteStoredKeys.add(key);
-				for (const row of snapshot.rows) if (isCurrent(row.threadId)) {
-					const restored = row.rolloutPath ? {
-						...row,
-						rolloutPath: codexCatalogRolloutLogicalPath(row.rolloutPath)
-					} : row;
-					const patched = this.withName(restored);
-					if (patched !== restored) this.persistence.put(patched);
-					const evicted = retainCodexCatalogRow(this.rows, patched);
-					if (evicted) this.evict(evicted.threadId);
-					this.ordering.restore(row);
+				let restoredRows = 0;
+				for (const row of snapshot.rows) {
+					if (++restoredRows % 128 === 0) {
+						await setImmediate$1();
+						this.assertCurrent();
+					}
+					if (isCurrent(row.threadId)) {
+						const restored = row.rolloutPath ? {
+							...row,
+							rolloutPath: codexCatalogRolloutLogicalPath(row.rolloutPath)
+						} : row;
+						const patched = this.withName(restored);
+						if (patched !== restored) this.persistence.put(patched);
+						const evicted = retainCodexCatalogRow(this.rows, patched);
+						if (evicted) this.evict(evicted.threadId);
+						this.ordering.restore(row);
+					}
 				}
 				this.overflow ||= snapshot.overflow || this.rows.size >= 2e4;
 				if (snapshot.complete) {
@@ -936,7 +1258,8 @@ var CodexCatalogIndex = class {
 	}
 	async hydratePages(isCurrent, useStateDbOnly, incremental) {
 		this.assertCurrent();
-		const files = this.options.localSessionsRoot && !useStateDbOnly ? (await scanCodexCatalogRollouts(this.options.localSessionsRoot, /* @__PURE__ */ new Set())).files : /* @__PURE__ */ new Map();
+		const files = this.rolloutScanner && !useStateDbOnly ? (await this.rolloutScanner.scan(/* @__PURE__ */ new Set())).files : /* @__PURE__ */ new Map();
+		this.assertCurrent();
 		let observedRevision;
 		let frontier;
 		const batchOrder = this.ordering.captureBatch(this.availability.complete);
@@ -980,7 +1303,11 @@ var CodexCatalogIndex = class {
 				frontier = this.rows.get(row.threadId) ?? frontier;
 			}
 			if (incremental && (!changed && page.rows.length > 0 || sourceOrder >= 2e4)) break;
-			if (page.nextCursor) this.availability.publish(frontier);
+			if (page.nextCursor) {
+				this.availability.publish(frontier);
+				await setImmediate$1();
+				this.assertCurrent();
+			}
 		}
 		if (remaining && (!useStateDbOnly || !this.options.localSessionsRoot)) {
 			for (const [id, row] of remaining) if (isCurrent(id) && this.rows.get(id) === row) this.remove(id);
@@ -997,58 +1324,19 @@ var CodexCatalogIndex = class {
 	}
 	async reconcileFiles(isCurrent) {
 		const root = this.options.localSessionsRoot;
-		if (!root || !this.initialized || this.closed) return;
-		this.assertCurrent();
-		const byPath = indexCodexCatalogRowsByRollout(this.rows.values());
-		const { files, present } = await scanCodexCatalogRollouts(root, new Set(byPath.keys()));
+		if (!root || !this.rolloutScanner || !this.initialized || this.closed) return;
 		this.assertCurrent();
-		const observed = new Map(files);
-		for (const [file, fingerprint] of files) {
-			const previous = byPath.get(codexCatalogRolloutLogicalPath(file));
-			const known = this.observedFiles.get(file) ?? previous?.fingerprint;
-			if (known?.mtimeMs === fingerprint.mtimeMs && known.size === fingerprint.size) continue;
-			this.currency.requestNativeRefresh();
-			observed.delete(file);
-			if (known) observed.set(file, known);
-			let thread;
-			try {
-				thread = await readCodexCatalogRollout(root, file);
-			} catch (error) {
-				this.assertCurrent();
-				this.report(error);
-				continue;
-			}
-			this.assertCurrent();
-			if (!thread) {
-				observed.set(file, fingerprint);
-				continue;
-			}
-			if (!isCurrent(thread.id)) continue;
-			const existing = this.rows.get(thread.id);
-			if (existing?.rolloutPath && codexCatalogRolloutLogicalPath(existing.rolloutPath) !== codexCatalogRolloutLogicalPath(file)) {
-				observed.set(file, fingerprint);
-				continue;
-			}
-			if (!existing && !thread.preview) {
-				observed.set(file, fingerprint);
-				continue;
-			}
-			thread.preview ||= existing?.preview;
-			const projected = await projectCodexCatalogThread(thread, root);
-			this.assertCurrent();
-			if (!isCurrent(thread.id)) continue;
-			observed.set(file, fingerprint);
-			const row = projected.rows[0];
-			if (!row) continue;
-			this.observations.mark(row.threadId);
-			this.put(mergeCodexCatalogRolloutRow(row, existing, fingerprint));
-			await setImmediate$1();
-		}
-		for (const row of byPath.values()) if (row.rolloutPath && isCodexCatalogRolloutPathCovered(root, row.rolloutPath) && !present.has(codexCatalogRolloutLogicalPath(row.rolloutPath)) && this.rows.get(row.threadId) === row) {
-			this.currency.requestNativeRefresh();
-			this.remove(row.threadId);
-		}
-		this.observedFiles = observed;
+		this.observedFiles = await reconcileCodexCatalogFiles(root, isCurrent, {
+			rows: this.rows,
+			observedFiles: this.observedFiles,
+			scanner: this.rolloutScanner,
+			assertCurrent: () => this.assertCurrent(),
+			requestNativeRefresh: () => this.currency.requestNativeRefresh(),
+			report: (error) => this.report(error),
+			mark: (id) => this.observations.mark(id),
+			put: (row) => this.put(row),
+			remove: (id) => this.remove(id)
+		});
 	}
 	upsertThread(thread) {
 		if (this.closed) return Promise.resolve();
@@ -1151,6 +1439,7 @@ var CodexCatalogIndex = class {
 		this.liveStatus.invalidate();
 		this.liveSettings.invalidate();
 		this.unsubscribe();
+		this.rolloutScanner?.close();
 		this.currency.close();
 		return this.persistence.retire();
 	}

package/dist/.setup/{session-catalog-index-order-BcQpHks3.mjs → session-catalog-index-order-nhyO0wdW.mjs}

@@ -1,4 +1,4 @@
-import { t as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-limits-DDxOsQeC.mjs";
+import { t as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-limits-DEU36Qlo.mjs";
 //#region extensions/codex/src/session-catalog-index-order.ts
 function codexCatalogRowRecency(row) {
 	return row.recencyAt ?? row.updatedAt ?? 0;

package/dist/.setup/{session-catalog-limits-DDxOsQeC.mjs → session-catalog-limits-DEU36Qlo.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
 //#region extensions/codex/src/session-catalog-limits.ts
 var session_catalog_limits_exports = /* @__PURE__ */ __exportAll({
 	CODEX_CATALOG_MAX_ROWS: () => CODEX_CATALOG_MAX_ROWS,