@openclaw/codex 2026.9.4 → 2026.9.6

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

@@ -1,8 +1,8 @@
-import { c as CatalogParamsError } from "./thread-history-page-D0JIp48V.js";
+import { v as CatalogParamsError } from "./session-catalog-native-projection-DowriLid.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();
@@ -21,17 +21,25 @@ function adoptionSessionKeyRest(sessionKey) {
 	const trimmed = sessionKey.trim();
 	return parseAgentSessionKey(trimmed)?.rest ?? trimmed;
 }
-function nodeAdoptionSessionKey(hostId, threadId) {
-	const source = JSON.stringify([hostId, threadId]);
+function nodeAdoptedSourceKey(hostId, threadId, sourceHomeId) {
+	return sessionCatalogAdoptedSourceKey(JSON.stringify([hostId, sourceHomeId]), threadId);
+}
+function nodeAdoptionSessionKey(hostId, threadId, sourceHomeId) {
+	const source = JSON.stringify([
+		hostId,
+		sourceHomeId,
+		threadId
+	]);
 	return sessionCatalogAdoptedSessionKey(CODEX_NODE_SESSION_KEY_PREFIX, source);
 }
 function readNodeSessionMarker(entry) {
 	const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : void 0;
 	const marker = codex && isRecord(codex.sessionCatalog) ? codex.sessionCatalog : void 0;
-	if (!marker || typeof marker.sourceHostId !== "string" || !marker.sourceHostId.startsWith("node:") || typeof marker.sourceThreadId !== "string" || !marker.sourceThreadId.trim() || typeof marker.nodeId !== "string" || !marker.nodeId.trim()) return;
+	if (!marker || typeof marker.sourceHostId !== "string" || !marker.sourceHostId.startsWith("node:") || typeof marker.sourceThreadId !== "string" || !marker.sourceThreadId.trim() || typeof marker.nodeId !== "string" || !marker.nodeId.trim() || marker.sourceHomeId !== void 0 && (typeof marker.sourceHomeId !== "string" || !marker.sourceHomeId.trim() || marker.sourceHomeId.length > 256)) return;
 	return {
 		sourceHostId: marker.sourceHostId,
 		sourceThreadId: marker.sourceThreadId,
+		...typeof marker.sourceHomeId === "string" ? { sourceHomeId: marker.sourceHomeId } : {},
 		nodeId: marker.nodeId,
 		...marker.initializing === true ? { initializing: true } : {}
 	};
@@ -46,8 +54,8 @@ function listNodeAdoptedSessionEntries(params) {
 	})) {
 		const marker = readNodeSessionMarker(entry);
 		const sessionId = entry.sessionId?.trim();
-		if (!marker || marker.initializing === true && params.includeInitializing !== true || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !sessionId || adoptionSessionKeyRest(sessionKey) !== nodeAdoptionSessionKey(marker.sourceHostId, marker.sourceThreadId) || marker.sourceHostId !== `node:${marker.nodeId}`) continue;
-		const sourceKey = sessionCatalogAdoptedSourceKey(marker.sourceHostId, marker.sourceThreadId);
+		if (!marker || !marker.sourceHomeId || marker.initializing === true && params.includeInitializing !== true || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !sessionId || adoptionSessionKeyRest(sessionKey) !== nodeAdoptionSessionKey(marker.sourceHostId, marker.sourceThreadId, marker.sourceHomeId) || marker.sourceHostId !== `node:${marker.nodeId}`) continue;
+		const sourceKey = nodeAdoptedSourceKey(marker.sourceHostId, marker.sourceThreadId, marker.sourceHomeId);
 		if (adopted.has(sourceKey)) throw new Error(`multiple OpenClaw sessions adopt Codex thread ${marker.sourceThreadId} on ${marker.sourceHostId}`);
 		adopted.set(sourceKey, {
 			key: sessionKey,
@@ -59,12 +67,13 @@ function listNodeAdoptedSessionEntries(params) {
 	return adopted;
 }
 function findNodeAdoptedSessionEntry(params) {
-	return listNodeAdoptedSessionEntries(params).get(sessionCatalogAdoptedSourceKey(params.hostId, params.threadId));
+	return listNodeAdoptedSessionEntries(params).get(nodeAdoptedSourceKey(params.hostId, params.threadId, params.sourceHomeId));
 }
 function nodeSessionMarker(params) {
 	return {
 		sourceHostId: params.hostId,
 		sourceThreadId: params.threadId,
+		sourceHomeId: params.sourceHomeId,
 		nodeId: params.nodeId,
 		...params.initializing === true ? { initializing: true } : {}
 	};
@@ -79,7 +88,7 @@ async function finalizeNodeAdoptedSession(params) {
 			preserveActivity: true,
 			update: (entry) => {
 				const current = readNodeSessionMarker(entry);
-				if (entry.sessionId?.trim() !== params.adopted.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !current || current.sourceHostId !== params.marker.sourceHostId || current.sourceThreadId !== params.marker.sourceThreadId || current.nodeId !== params.marker.nodeId) throw changedError();
+				if (entry.sessionId?.trim() !== params.adopted.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !current || current.sourceHostId !== params.marker.sourceHostId || current.sourceThreadId !== params.marker.sourceThreadId || current.sourceHomeId !== params.marker.sourceHomeId || current.nodeId !== params.marker.nodeId) throw changedError();
 				if (current.initializing !== true) return {
 					archivedAt: void 0,
 					archivedBy: void 0,
@@ -106,7 +115,7 @@ async function finalizeNodeAdoptedSession(params) {
 			readConsistency: "latest"
 		});
 		const current = currentEntry ? readNodeSessionMarker(currentEntry) : void 0;
-		if (currentEntry?.sessionId?.trim() === params.adopted.sessionId && current?.initializing !== true && current?.sourceHostId === params.marker.sourceHostId && current.sourceThreadId === params.marker.sourceThreadId && current.nodeId === params.marker.nodeId) return;
+		if (currentEntry?.sessionId?.trim() === params.adopted.sessionId && current?.initializing !== true && current?.sourceHostId === params.marker.sourceHostId && current.sourceThreadId === params.marker.sourceThreadId && current.sourceHomeId === params.marker.sourceHomeId && current.nodeId === params.marker.nodeId) return;
 		throw error;
 	}
 	if (!finalized) throw changedError();
@@ -118,6 +127,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 		runtime: params.api.runtime,
 		hostId: params.hostId,
 		threadId: params.record.threadId,
+		sourceHomeId: params.sourceHomeId,
 		includeInitializing: true
 	});
 	if (existing) return existing;
@@ -125,6 +135,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 		...nodeSessionMarker({
 			hostId: params.hostId,
 			threadId: params.record.threadId,
+			sourceHomeId: params.sourceHomeId,
 			nodeId: params.nodeId
 		}),
 		initializing: true
@@ -132,7 +143,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 	try {
 		const created = await params.api.runtime.agent.session.createSessionEntry({
 			cfg: params.config,
-			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId),
+			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId, params.sourceHomeId),
 			agentId: params.agentId,
 			recoverMatchingInitialEntry: true,
 			displayName: params.record.name ?? void 0,
@@ -144,7 +155,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-BtHDBp1G.mjs").then((n) => n.a);
 				await importCodexThreadHistoryToTranscript({
 					thread: params.history.thread,
 					throughTurnId: params.history.throughTurnId,
@@ -172,6 +183,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 			runtime: params.api.runtime,
 			hostId: params.hostId,
 			threadId: params.record.threadId,
+			sourceHomeId: params.sourceHomeId,
 			includeInitializing: true
 		});
 		if (raced) return raced;
@@ -179,4 +191,4 @@ async function createOrReuseNodeAdoptedSession(params) {
 	}
 }
 //#endregion
-export { adoptionSessionKeyRest, continueOperations, createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, listNodeAdoptedSessionEntries, nodeSessionMarker, runSessionActionExclusive };
+export { CODEX_NODE_SESSION_KEY_PREFIX, adoptionSessionKeyRest, continueOperations, createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, listNodeAdoptedSessionEntries, nodeAdoptedSourceKey, nodeSessionMarker, readNodeSessionMarker, runSessionActionExclusive };

package/dist/{session-catalog-node-continue-Ci-DXyJP.js → .setup/session-catalog-node-continue-6g6qi4A9.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 parseCatalogPage, C as boundedCatalogString, D as filterCatalogPageByTitle, H as unwrapNodeInvokePayload, M as parseTranscriptPage, O as isInteractiveThreadSource, S as NODE_INVOKE_TIMEOUT_MS, h as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, m as CODEX_APP_SERVER_THREADS_LIST_COMMAND, v as CatalogParamsError, w as catalogError } from "./session-catalog-native-projection-DowriLid.mjs";
+import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-CrcyZk6O.mjs";
+import { i as withTimeout } from "./timeout-C910MdAB.mjs";
+import { r as CODEX_CLI_SESSION_SOURCE_UPGRADE_MESSAGE, t as CODEX_CLI_SESSION_RESUME_COMMAND } from "./node-cli-sessions-r3avj02l.mjs";
+import { o as lookupNodeCodexCatalogRecord } from "./session-catalog-Pno1xGcl.mjs";
+import { t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.mjs";
+import { createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, nodeAdoptedSourceKey, nodeSessionMarker, runSessionActionExclusive } from "./session-catalog-node-adoption-ITddWx_X.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
@@ -26,7 +26,7 @@ function compareNodeLabels(left, right) {
 	return 0;
 }
 function canContinueCodexOnNode(node) {
-	return node.connected === true && CODEX_NODE_CONTINUE_COMMANDS.every((command) => node.commands?.includes(command) === true && node.invocableCommands?.includes(command) === true);
+	return node.connected === true && node.caps?.includes("codex-cli-session-source") === true && CODEX_NODE_CONTINUE_COMMANDS.every((command) => node.commands?.includes(command) === true && node.invocableCommands?.includes(command) === true);
 }
 async function listPairedNode(params) {
 	const hostId = `node:${params.node.nodeId}`;
@@ -79,10 +79,8 @@ async function listPairedNode(params) {
 			...common,
 			connected: true,
 			...page,
-			sessions: page.sessions.map((session) => {
-				const adopted = params.adoptedSessions.get(sessionCatalogAdoptedSourceKey(hostId, session.threadId));
-				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
-			})
+			canContinueCodex: common.canContinueCodex && page.canContinueCodex === true && Boolean(page.sourceHomeId),
+			sessions: page.sessions.map((session) => Object.assign({}, session, page.sourceHomeId ? { sourceHomeId: page.sourceHomeId } : {}))
 		};
 	}).catch((error) => ({
 		...common,
@@ -106,7 +104,10 @@ async function requireNodeForCodexContinue(params) {
 	const nodeId = params.hostId.slice(5).trim();
 	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
 	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId);
-	if (!node || !canContinueCodexOnNode(node)) throw new CatalogParamsError("paired node does not permit Codex session continuation");
+	if (!node || !canContinueCodexOnNode(node)) {
+		if (node?.connected && !node.caps?.includes("codex-cli-session-source")) throw new CatalogParamsError(CODEX_CLI_SESSION_SOURCE_UPGRADE_MESSAGE);
+		throw new CatalogParamsError("paired node does not permit Codex session continuation");
+	}
 	return {
 		node,
 		nodeId
@@ -125,6 +126,7 @@ async function readNodeCodexHistory(params) {
 		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
 		params: {
 			agentId: params.agentId,
+			sourceHomeId: params.sourceHomeId,
 			threadId: params.record.threadId,
 			limit: 50
 		},
@@ -153,9 +155,12 @@ async function continueNodeCodexSessionInner(params) {
 		agentId: params.agentId,
 		runtime: params.api.runtime,
 		nodeId,
-		threadId: params.threadId
+		threadId: params.threadId,
+		sourceHomeId: params.sourceHomeId
 	});
 	if (lookup.kind !== "found") throw new CatalogParamsError(lookup.kind === "cursor-cycle" ? "Codex session eligibility could not be verified" : "Codex session is unavailable on the paired node");
+	if (lookup.canContinueCodex !== true || !lookup.sourceHomeId) throw new CatalogParamsError("Codex session source does not support Chat continuation; use a local stdio source or update the node.");
+	const sourceHomeId = lookup.sourceHomeId;
 	const record = lookup.record;
 	requireContinuableNodeRecord(record);
 	const existing = findNodeAdoptedSessionEntry({
@@ -164,6 +169,7 @@ async function continueNodeCodexSessionInner(params) {
 		runtime: params.api.runtime,
 		hostId: params.hostId,
 		threadId: params.threadId,
+		sourceHomeId,
 		includeInitializing: true
 	});
 	let adopted;
@@ -176,6 +182,7 @@ async function continueNodeCodexSessionInner(params) {
 			agentId: params.agentId,
 			runtime: params.api.runtime,
 			nodeId,
+			sourceHomeId,
 			record
 		});
 		adopted = await createOrReuseNodeAdoptedSession({
@@ -184,6 +191,7 @@ async function continueNodeCodexSessionInner(params) {
 			config: params.config,
 			hostId: params.hostId,
 			nodeId,
+			sourceHomeId,
 			record,
 			history
 		});
@@ -192,6 +200,7 @@ async function continueNodeCodexSessionInner(params) {
 	const marker = nodeSessionMarker({
 		hostId: params.hostId,
 		threadId: params.threadId,
+		sourceHomeId,
 		nodeId
 	});
 	return {
@@ -223,7 +232,7 @@ async function continueNodeCodexSession(params) {
 		agentId: params.agentId
 	}).sessionAgentId;
 	const sourceKey = sessionCatalogAdoptedSourceKey(`node:${nodeId}`, params.threadId);
-	const operationKey = sessionCatalogAdoptedSourceKey(agentId, sourceKey);
+	const operationKey = sessionCatalogAdoptedSourceKey(agentId, params.sourceHomeId ? nodeAdoptedSourceKey(`node:${nodeId}`, params.threadId, params.sourceHomeId) : sourceKey);
 	return await continueNodeAdoption({
 		sourceKey: operationKey,
 		findExisting: () => void 0,

package/dist/.setup/session-catalog-projection-zK_PUsiE.mjs

@@ -0,0 +1,422 @@
+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 { 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 { constants, createZstdDecompress } from "node:zlib";
+import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
+//#region extensions/codex/src/session-catalog-rollouts.ts
+const WINDOW_BYTES = 131072;
+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 ROLLOUT_SOURCE_DENIAL_CODES = /* @__PURE__ */ new Set([
+	"symlink",
+	"hardlink",
+	"outside-workspace",
+	"invalid-path",
+	"device-path",
+	"not-file",
+	"path-alias"
+]);
+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);
+	}
+};
+/** Codex returns the plain logical path for either rollout representation. */
+function codexCatalogRolloutLogicalPath(rolloutPath) {
+	return rolloutPath.replace(/\.zst$/u, "");
+}
+function resolveCodexCatalogRolloutFingerprint(rolloutPath, previous, files) {
+	const logicalPath = rolloutPath && codexCatalogRolloutLogicalPath(rolloutPath);
+	if (!logicalPath) return;
+	return files?.get(logicalPath) ?? files?.get(`${logicalPath}.zst`) ?? (previous?.rolloutPath && codexCatalogRolloutLogicalPath(previous.rolloutPath) === logicalPath ? previous.fingerprint : void 0);
+}
+function indexCodexCatalogRowsByRollout(rows) {
+	return new Map([...rows].flatMap((row) => row.rolloutPath ? [[codexCatalogRolloutLogicalPath(row.rolloutPath), row]] : []));
+}
+/** 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 (isRecord(error) && error.code === "ENOENT") return;
+		throw error;
+	}
+}
+/** Stat-only currency scan. Content is read separately, only for changed fingerprints. */
+async function scanCodexCatalogRollouts(sessionsRoot, trackedPaths) {
+	const present = /* @__PURE__ */ new Set();
+	const rootStat = await unlessMissing(fs.lstat(sessionsRoot));
+	if (!rootStat?.isDirectory() || rootStat.isSymbolicLink()) return {
+		files: /* @__PURE__ */ new Map(),
+		present
+	};
+	const rootReal = await unlessMissing(fs.realpath(sessionsRoot));
+	if (!rootReal) return {
+		files: /* @__PURE__ */ new Map(),
+		present
+	};
+	const candidates = new NewestRolloutCandidates();
+	const scan = async (directory, depth) => {
+		if (await unlessMissing(fs.realpath(directory)) !== directory) return;
+		const entries = await unlessMissing(fs.opendir(directory));
+		if (!entries) return;
+		const directoryPattern = DIRECTORY_PARTS[depth];
+		for await (const entry of entries) {
+			const file = path.join(directory, entry.name);
+			if (directoryPattern) {
+				if (entry.isDirectory() && directoryPattern.test(entry.name)) await scan(file, depth + 1);
+			} else if (entry.isFile() && ROLLOUT_FILE_NAME.test(entry.name)) {
+				const stat = await unlessMissing(fs.lstat(file));
+				if (stat?.isFile() && stat.nlink === 1) {
+					const physicalPath = path.join(sessionsRoot, path.relative(rootReal, file));
+					if (physicalPath.length > 4096) continue;
+					const logicalPath = codexCatalogRolloutLogicalPath(physicalPath);
+					if (trackedPaths.has(logicalPath)) present.add(logicalPath);
+					if (physicalPath !== logicalPath) {
+						const plain = await unlessMissing(fs.lstat(codexCatalogRolloutLogicalPath(file)));
+						if (plain?.isFile() && plain.nlink === 1) continue;
+					}
+					candidates.offer([detachCodexCatalogString(physicalPath), {
+						mtimeMs: stat.mtimeMs,
+						size: stat.size
+					}]);
+				}
+			}
+		}
+	};
+	await scan(rootReal, 0);
+	return {
+		files: candidates.finish(),
+		present
+	};
+}
+function records(bytes, skipFirst) {
+	const text = bytes.toString("utf8");
+	const lines = text.slice(0, text.lastIndexOf("\n") + 1).split("\n");
+	if (skipFirst) lines.shift();
+	return lines.flatMap((line) => {
+		try {
+			const value = JSON.parse(line);
+			return isRecord(value) ? [value] : [];
+		} catch {
+			return [];
+		}
+	});
+}
+function sourceFromMetadata(value) {
+	if (value === void 0) return "vscode";
+	if (value === "cli" || value === "vscode" || value === "exec") return value;
+	if (value === "mcp") return "appServer";
+	if (isRecord(value)) {
+		const custom = boundedCatalogString(value.custom, 500);
+		if (custom) return { custom };
+	}
+	return "unknown";
+}
+function previewFromEvent(payload, sanitize) {
+	let message;
+	let image = false;
+	let audio = false;
+	if (payload.type === "user_message") {
+		message = typeof payload.message === "string" ? payload.message : void 0;
+		image = [payload.images, payload.local_images].some((items) => Array.isArray(items) && items.length > 0);
+		audio = [payload.audio, payload.local_audio].some((items) => Array.isArray(items) && items.length > 0);
+	} else if (payload.type === "item_completed" && isRecord(payload.item) && payload.item.type === "UserMessage" && Array.isArray(payload.item.content)) {
+		const content = payload.item.content.filter(isRecord);
+		message = content.flatMap((item) => item.type === "text" && typeof item.text === "string" ? [item.text] : []).join("");
+		image = content.some((item) => item.type === "image" || item.type === "local_image");
+		audio = content.some((item) => item.type === "audio" || item.type === "local_audio");
+	}
+	const prefix = "## My request for Codex:";
+	if (message?.includes(prefix)) message = message.slice(message.indexOf(prefix) + 24);
+	return truncateCodexCatalogPreview(selectCodexCatalogPreviewInput(message ?? ""), sanitize) || (image ? "[Image]" : audio ? "[Audio]" : void 0);
+}
+async function compressedHead(handle, size) {
+	const input = Buffer.alloc(Math.min(size, WINDOW_BYTES));
+	const { bytesRead } = await handle.read(input, 0, input.length, 0);
+	const decoder = createZstdDecompress({
+		chunkSize: 16384,
+		params: { [constants.ZSTD_d_windowLogMax]: 25 }
+	});
+	decoder.end(input.subarray(0, bytesRead));
+	const timer = setTimeout(() => decoder.destroy(/* @__PURE__ */ new Error("Rollout read timed out")), 5e3);
+	const chunks = [];
+	let sizeRead = 0;
+	try {
+		for await (const chunk of decoder) {
+			const bounded = (Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)).subarray(0, WINDOW_BYTES - sizeRead);
+			chunks.push(bounded);
+			sizeRead += bounded.length;
+			if (sizeRead === WINDOW_BYTES) break;
+		}
+		return Buffer.concat(chunks);
+	} finally {
+		clearTimeout(timer);
+		decoder.destroy();
+	}
+}
+/** Background-only display projection; never reads an entire large rollout. */
+async function readCodexCatalogRollout(sessionsRoot, rolloutPath) {
+	let opened;
+	try {
+		const rootStat = await fs.lstat(sessionsRoot);
+		if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) return;
+		opened = await (await root(sessionsRoot, {
+			hardlinks: "reject",
+			symlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER
+		})).open(path.relative(sessionsRoot, rolloutPath));
+		const { handle, stat } = opened;
+		if (!stat.size) return;
+		const compressed = rolloutPath.endsWith(".zst");
+		const head = compressed ? await compressedHead(handle, stat.size) : Buffer.alloc(Math.min(stat.size, WINDOW_BYTES));
+		if (!compressed) await handle.read(head, 0, head.length, 0);
+		const first = records(head, false);
+		const envelope = records(head.subarray(0, head.indexOf(10) + 1), false)[0];
+		if (envelope?.type !== "session_meta" || !isRecord(envelope.payload)) return;
+		const metadata = envelope.payload;
+		const id = boundedCatalogString(metadata.id, 256);
+		const createdAt = typeof metadata.timestamp === "string" ? Date.parse(metadata.timestamp) : NaN;
+		if (!id || !Number.isFinite(createdAt)) return;
+		let tail = first;
+		if (!compressed && stat.size > head.length) {
+			const offset = Math.max(head.length, stat.size - WINDOW_BYTES);
+			const bytes = Buffer.alloc(stat.size - offset);
+			await handle.read(bytes, 0, bytes.length, offset);
+			tail = records(bytes, true);
+		}
+		const current = await handle.stat();
+		if (stat.size !== current.size || stat.mtimeMs !== current.mtimeMs) return;
+		const thread = {
+			id,
+			projectId: null,
+			path: detachCodexCatalogString(rolloutPath),
+			source: sourceFromMetadata(metadata.source),
+			createdAt: createdAt / 1e3,
+			updatedAt: stat.mtimeMs / 1e3,
+			cwd: boundedCatalogString(metadata.cwd, 4096),
+			originator: typeof metadata.originator === "string" && metadata.originator.length <= 500 ? detachCodexCatalogString(metadata.originator) : void 0,
+			sessionId: boundedCatalogString(metadata.session_id, 256)
+		};
+		const { sanitizeTerminalText } = await import("openclaw/plugin-sdk/text-chunking");
+		for (const record of first) if (record.type === "event_msg" && isRecord(record.payload)) {
+			const preview = previewFromEvent(record.payload, sanitizeTerminalText);
+			if (preview) {
+				thread.preview = preview;
+				break;
+			}
+		}
+		for (const record of tail === first ? first : [...first, ...tail]) {
+			if (record.type !== "event_msg" || !isRecord(record.payload)) continue;
+			const payload = record.payload;
+			if (payload.type === "task_started" || payload.type === "turn_started") {
+				const startedAt = typeof payload.started_at === "number" ? payload.started_at : typeof record.timestamp === "string" ? Date.parse(record.timestamp) / 1e3 : NaN;
+				if (Number.isFinite(startedAt)) thread.recencyAt = Math.max(thread.recencyAt ?? Number.NEGATIVE_INFINITY, Math.floor(startedAt));
+			}
+			if (payload.type === "thread_settings_applied" && isRecord(payload.thread_settings)) thread.cwd = boundedCatalogString(payload.thread_settings.cwd, 4096) ?? thread.cwd;
+		}
+		return thread;
+	} catch (error) {
+		const code = extractErrorCode(error);
+		if (code && ROLLOUT_SOURCE_DENIAL_CODES.has(code)) return;
+		throw error;
+	} finally {
+		await opened?.handle.close().catch(() => void 0);
+	}
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-projection.ts
+/** Single-thread responses remain owned by their native consumers. */
+function projectCodexCatalogThread(thread, localSessionsRoot) {
+	try {
+		const prepared = projectCodexCatalogNativeThread(thread, sanitizeTerminalText);
+		return projectCodexCatalogPage({ data: [prepared] }, {
+			localSessionsRoot,
+			sanitize: sanitizeTerminalText,
+			source: getCodexCatalogSource(prepared)
+		});
+	} catch (error) {
+		return Promise.reject(toErrorObject(error, "Codex catalog projection failed"));
+	}
+}
+var CodexCatalogProjectionCapacityError = class extends Error {
+	constructor() {
+		super("Codex catalog projection queue reached its resident row limit");
+	}
+};
+/** Direct mutations and events share one bound across asynchronous projection work. */
+var CodexCatalogProjections = class {
+	constructor() {
+		this.active = 0;
+	}
+	run(work) {
+		if (this.active >= 2e4) return Promise.reject(new CodexCatalogProjectionCapacityError());
+		this.active++;
+		try {
+			return work().finally(() => {
+				this.active--;
+			});
+		} catch (error) {
+			this.active--;
+			return Promise.reject(toErrorObject(error, "Codex catalog projection failed"));
+		}
+	}
+};
+async function projectCodexCatalogPage(response, params) {
+	const { diagnostics, sanitize } = params;
+	const responseStarted = performance.now();
+	const rows = [];
+	const excludedThreadIds = [];
+	try {
+		readControlCursor(response.backwardsCursor, "backwards response");
+		for (const thread of response.data) if (typeof thread.preview === "string" && thread.preview) thread.preview = truncateCodexCatalogPreview(selectCodexCatalogPreviewInput(thread.preview), sanitize);
+		for (const thread of response.data) {
+			if (thread.ephemeral === true) {
+				excludedThreadIds.push(thread.id);
+				continue;
+			}
+			const page = { sessions: [] };
+			if (await isOpenClawManagedCodexThread(thread, params.localSessionsRoot, diagnostics ?? void 0)) {
+				const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+				page.managedThreads = [{
+					threadId: thread.id,
+					...rolloutPath ? { rolloutPath } : {}
+				}];
+			} else {
+				const session = toCatalogSession(thread, false, sanitize, { value: typeof thread.preview === "string" ? thread.preview : void 0 });
+				if (session) page.sessions.push(session);
+			}
+			rows.push(setCodexCatalogSource({
+				threadId: thread.id,
+				archived: false,
+				nativeMetadata: true,
+				...typeof thread.preview === "string" ? { preview: thread.preview } : {},
+				...thread.path ? { rolloutPath: thread.path } : {},
+				updatedAt: asFiniteNumber(thread.updatedAt) ?? null,
+				recencyAt: asFiniteNumber(thread.recencyAt) ?? null,
+				page
+			}, params.source ?? getCodexCatalogSource(thread)));
+		}
+		return {
+			rows,
+			...excludedThreadIds.length ? { excludedThreadIds } : {},
+			nextCursor: readControlCursor(response.nextCursor, "next response"),
+			backwardsCursor: readControlCursor(response.backwardsCursor, "backwards response")
+		};
+	} finally {
+		if (diagnostics) diagnostics.fields.postResponseMs = (diagnostics.fields.postResponseMs ?? 0) + performance.now() - responseStarted;
+	}
+}
+/** Native activity/path changes invalidate the retained first-user preview. */
+function canReuseCodexCatalogPreview(row, thread) {
+	return Boolean(row && !row.archived && row.updatedAt === (asFiniteNumber(thread.updatedAt) ?? null) && row.recencyAt === (asFiniteNumber(thread.recencyAt) ?? null) && (row.rolloutPath ? codexCatalogRolloutLogicalPath(row.rolloutPath) : void 0) === (thread.path ? codexCatalogRolloutLogicalPath(thread.path) : void 0));
+}
+async function projectCodexCatalogDeltaPage(response, params) {
+	const reusable = response.data.map((thread) => {
+		const row = params.getRow(thread.id);
+		if (thread.ephemeral === true || !row || !canReuseCodexCatalogPreview(row, thread)) return;
+		if (row.page.sessions.length === 0) return copyCodexCatalogSource(thread, {
+			...row,
+			nativeMetadata: true
+		});
+		if (typeof thread.preview === "string" && Boolean(thread.preview) !== Boolean(row.preview)) return;
+		const session = toCatalogSession(thread, false, params.sanitize, { value: row.preview });
+		return copyCodexCatalogSource(thread, {
+			...row,
+			nativeMetadata: true,
+			page: { sessions: session ? [session] : [] }
+		});
+	});
+	const changed = await projectCodexCatalogPage({
+		...response,
+		data: response.data.filter((_thread, index) => !reusable[index])
+	}, params);
+	let changedIndex = 0;
+	return {
+		...changed,
+		rows: reusable.flatMap((row, index) => response.data[index]?.ephemeral === true ? [] : [row ?? changed.rows[changedIndex++]])
+	};
+}
+/** Sampled rollout content cannot supersede authoritative native settings. */
+function mergeCodexCatalogRolloutRow(row, existing, fingerprint) {
+	const recencyAt = row.recencyAt === null ? existing?.recencyAt ?? null : Math.max(row.recencyAt, existing?.recencyAt ?? row.recencyAt);
+	const metadata = existing?.nativeMetadata ? existing : row;
+	const preview = row.preview ?? metadata.preview;
+	const sessions = metadata.page.sessions.map((session) => {
+		const updated = Object.assign({}, session);
+		delete updated.fallbackName;
+		if (!session.name && preview) updated.fallbackName = preview;
+		if (recencyAt !== null) updated.recencyAt = recencyAt;
+		return updated;
+	});
+	const merged = {
+		...metadata,
+		nativeMetadata: existing?.nativeMetadata ?? false,
+		archived: existing?.archived ?? false,
+		recencyAt,
+		fingerprint,
+		...preview !== void 0 ? { preview } : {},
+		page: {
+			...metadata.page,
+			sessions
+		}
+	};
+	if (existing && codexCatalogRowRecency(merged) > codexCatalogRowRecency(existing)) delete merged.sourceOrder;
+	return merged;
+}
+//#endregion
+export { CodexCatalogProjectionCapacityError, CodexCatalogProjections, resolveCodexCatalogRolloutFingerprint as a, canReuseCodexCatalogPreview, readCodexCatalogRollout as i, mergeCodexCatalogRolloutRow, indexCodexCatalogRowsByRollout as n, scanCodexCatalogRollouts as o, projectCodexCatalogDeltaPage, projectCodexCatalogPage, projectCodexCatalogThread, isCodexCatalogRolloutPathCovered as r, codexCatalogRolloutLogicalPath as t };