@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/session-catalog-home-id-CwhLdC03.js

@@ -0,0 +1,18 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+//#region extensions/codex/src/session-catalog-home-id.ts
+function canonicalCodexCatalogHome(value) {
+	const resolved = path.resolve(value);
+	try {
+		return fs.realpathSync.native(resolved);
+	} catch {
+		return resolved;
+	}
+}
+/** One canonical identity for catalog discovery and durable ownership rows. */
+function codexCatalogHomeId(codexHome) {
+	return createHash("sha256").update("openclaw:codex-session-catalog-home:v1\0").update(canonicalCodexCatalogHome(codexHome)).digest("hex");
+}
+//#endregion
+export { codexCatalogHomeId as n, canonicalCodexCatalogHome as t };

package/dist/session-catalog-node-adoption-B1tgDW-m.js

@@ -0,0 +1,182 @@
+import { c as CatalogParamsError } from "./thread-history-page-D0JIp48V.js";
+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";
+//#region extensions/codex/src/session-catalog-node-adoption.ts
+const CODEX_NODE_SESSION_KEY_PREFIX = "harness:codex:node-session:";
+const continueOperations = /* @__PURE__ */ new Map();
+const sessionActionTails = /* @__PURE__ */ new Map();
+async function runSessionActionExclusive(threadId, run) {
+	const operation = (sessionActionTails.get(threadId) ?? Promise.resolve()).then(run);
+	const tail = operation.then(() => void 0, () => void 0);
+	sessionActionTails.set(threadId, tail);
+	try {
+		return await operation;
+	} finally {
+		if (sessionActionTails.get(threadId) === tail) sessionActionTails.delete(threadId);
+	}
+}
+function adoptionSessionKeyRest(sessionKey) {
+	const trimmed = sessionKey.trim();
+	return parseAgentSessionKey(trimmed)?.rest ?? trimmed;
+}
+function nodeAdoptionSessionKey(hostId, threadId) {
+	const source = JSON.stringify([hostId, 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;
+	return {
+		sourceHostId: marker.sourceHostId,
+		sourceThreadId: marker.sourceThreadId,
+		nodeId: marker.nodeId,
+		...marker.initializing === true ? { initializing: true } : {}
+	};
+}
+function listNodeAdoptedSessionEntries(params) {
+	const adopted = /* @__PURE__ */ new Map();
+	for (const { agentId, entry, sessionKey } of listSessionCatalogEntries({
+		...params.agentId ? { agentId: params.agentId } : {},
+		config: params.config ?? {},
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
+	})) {
+		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 (adopted.has(sourceKey)) throw new Error(`multiple OpenClaw sessions adopt Codex thread ${marker.sourceThreadId} on ${marker.sourceHostId}`);
+		adopted.set(sourceKey, {
+			key: sessionKey,
+			sessionId,
+			agentId,
+			...marker.initializing === true ? { initializing: true } : {}
+		});
+	}
+	return adopted;
+}
+function findNodeAdoptedSessionEntry(params) {
+	return listNodeAdoptedSessionEntries(params).get(sessionCatalogAdoptedSourceKey(params.hostId, params.threadId));
+}
+function nodeSessionMarker(params) {
+	return {
+		sourceHostId: params.hostId,
+		sourceThreadId: params.threadId,
+		nodeId: params.nodeId,
+		...params.initializing === true ? { initializing: true } : {}
+	};
+}
+async function finalizeNodeAdoptedSession(params) {
+	const changedError = () => new CatalogParamsError("Codex OpenClaw session changed before it could be bound. Retry.");
+	let finalized;
+	try {
+		finalized = await params.api.runtime.agent.session.patchSessionEntry({
+			sessionKey: params.adopted.key,
+			readConsistency: "latest",
+			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 (current.initializing !== true) return {
+					archivedAt: void 0,
+					archivedBy: void 0,
+					archiveReason: void 0
+				};
+				const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : {};
+				return {
+					archivedAt: void 0,
+					archivedBy: void 0,
+					archiveReason: void 0,
+					pluginExtensions: {
+						...entry.pluginExtensions,
+						codex: {
+							...codex,
+							sessionCatalog: params.marker
+						}
+					}
+				};
+			}
+		});
+	} catch (error) {
+		const currentEntry = params.api.runtime.agent.session.getSessionEntry({
+			sessionKey: params.adopted.key,
+			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;
+		throw error;
+	}
+	if (!finalized) throw changedError();
+}
+async function createOrReuseNodeAdoptedSession(params) {
+	const existing = findNodeAdoptedSessionEntry({
+		agentId: params.agentId,
+		config: params.config,
+		runtime: params.api.runtime,
+		hostId: params.hostId,
+		threadId: params.record.threadId,
+		includeInitializing: true
+	});
+	if (existing) return existing;
+	const initializingMarker = {
+		...nodeSessionMarker({
+			hostId: params.hostId,
+			threadId: params.record.threadId,
+			nodeId: params.nodeId
+		}),
+		initializing: true
+	};
+	try {
+		const created = await params.api.runtime.agent.session.createSessionEntry({
+			cfg: params.config,
+			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId),
+			agentId: params.agentId,
+			recoverMatchingInitialEntry: true,
+			displayName: params.record.name ?? void 0,
+			...params.record.cwd?.trim() ? { spawnedCwd: params.record.cwd.trim() } : {},
+			initialEntry: {
+				agentHarnessId: "codex",
+				modelSelectionLocked: true,
+				pluginExtensions: { codex: { sessionCatalog: initializingMarker } }
+			},
+			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);
+				await importCodexThreadHistoryToTranscript({
+					thread: params.history.thread,
+					throughTurnId: params.history.throughTurnId,
+					storePath,
+					sessionId: entry.sessionId,
+					sessionKey: entry.key,
+					agentId: entry.agentId,
+					...params.record.cwd?.trim() ? { cwd: params.record.cwd.trim() } : {},
+					modelProvider: params.record.modelProvider,
+					config: params.config
+				});
+				return { pluginExtensions: { codex: { sessionCatalog: initializingMarker } } };
+			}
+		});
+		return {
+			key: created.key,
+			sessionId: created.sessionId,
+			agentId: created.agentId,
+			initializing: true
+		};
+	} catch (error) {
+		const raced = findNodeAdoptedSessionEntry({
+			agentId: params.agentId,
+			config: params.config,
+			runtime: params.api.runtime,
+			hostId: params.hostId,
+			threadId: params.record.threadId,
+			includeInitializing: true
+		});
+		if (raced) return raced;
+		throw error;
+	}
+}
+//#endregion
+export { adoptionSessionKeyRest, continueOperations, createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, listNodeAdoptedSessionEntries, nodeSessionMarker, runSessionActionExclusive };

package/dist/session-catalog-node-continue-Ci-DXyJP.js

@@ -0,0 +1,238 @@
+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 { 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
+const CODEX_NODE_CONTINUE_COMMANDS = [
+	CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+	CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+	CODEX_CLI_SESSION_RESUME_COMMAND
+];
+const NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS = 8e3;
+const continueNodeAdoption = createSessionCatalogAdoptionCoordinator();
+function nodeLabel(node) {
+	return node.displayName?.trim() || node.remoteIp?.trim() || node.nodeId;
+}
+function compareNodeLabels(left, right) {
+	const leftLabel = nodeLabel(left);
+	const rightLabel = nodeLabel(right);
+	if (leftLabel < rightLabel) return -1;
+	if (leftLabel > rightLabel) return 1;
+	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);
+}
+async function listPairedNode(params) {
+	const hostId = `node:${params.node.nodeId}`;
+	const common = {
+		hostId,
+		label: nodeLabel(params.node),
+		kind: "node",
+		nodeId: params.node.nodeId,
+		canContinueCodex: canContinueCodexOnNode(params.node),
+		...params.terminalCapabilities
+	};
+	if (params.node.connected !== true) {
+		const host = {
+			...common,
+			connected: false,
+			sessions: [],
+			error: {
+				code: "NODE_OFFLINE",
+				message: "Paired node is offline"
+			}
+		};
+		params.onHost?.(host);
+		return host;
+	}
+	if (!params.node.commands?.includes("codex.appServer.threads.list.v1")) {
+		const host = {
+			...common,
+			connected: true,
+			sessions: []
+		};
+		params.onHost?.(host);
+		return host;
+	}
+	const eventualHost = Promise.resolve().then(async () => {
+		const raw = await params.runtime.nodes.invoke({
+			nodeId: params.node.nodeId,
+			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+			params: {
+				agentId: params.agentId,
+				cursor: params.query.cursors?.[hostId],
+				limit: params.query.limitPerHost,
+				searchTerm: params.query.search
+			},
+			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+			scopes: ["operator.write"],
+			signal: params.signal
+		});
+		const page = filterCatalogPageByTitle(parseCatalogPage(unwrapNodeInvokePayload(raw)), params.query.search);
+		return {
+			...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;
+			})
+		};
+	}).catch((error) => ({
+		...common,
+		connected: true,
+		sessions: [],
+		error: catalogError("NODE_INVOKE_FAILED", error)
+	}));
+	publishSessionCatalogHost(params, eventualHost);
+	try {
+		return await withTimeout(eventualHost, NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS, "paired node Codex session catalog timed out");
+	} catch (error) {
+		return {
+			...common,
+			connected: true,
+			sessions: [],
+			error: catalogError("NODE_INVOKE_FAILED", error)
+		};
+	}
+}
+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");
+	return {
+		node,
+		nodeId
+	};
+}
+function requireContinuableNodeRecord(record) {
+	if (record.archived) throw new CatalogParamsError("Codex session is archived on the paired node");
+	if (!isInteractiveThreadSource(record.source)) throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+	if (record.status === "idle" || record.status === "notLoaded") return;
+	if (record.status === "active") throw new CatalogParamsError("Codex session is active on the paired node; wait for it to finish before continuing");
+	throw new CatalogParamsError("Codex session cannot be continued in its current state");
+}
+async function readNodeCodexHistory(params) {
+	const raw = await params.runtime.nodes.invoke({
+		nodeId: params.nodeId,
+		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+		params: {
+			agentId: params.agentId,
+			threadId: params.record.threadId,
+			limit: 50
+		},
+		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+		scopes: ["operator.write"]
+	});
+	const page = parseTranscriptPage(unwrapNodeInvokePayload(raw));
+	const thread = {
+		id: params.record.threadId,
+		createdAt: params.record.createdAt ?? 0,
+		modelProvider: params.record.modelProvider ?? "openai",
+		projectId: null,
+		turns: page.data.toReversed()
+	};
+	return {
+		thread,
+		throughTurnId: codexLastTerminalTurnId(thread, (value) => boundedCatalogString(value, 256)) ?? null
+	};
+}
+async function continueNodeCodexSessionInner(params) {
+	const { nodeId } = await requireNodeForCodexContinue({
+		runtime: params.api.runtime,
+		hostId: params.hostId
+	});
+	const lookup = await lookupNodeCodexCatalogRecord({
+		agentId: params.agentId,
+		runtime: params.api.runtime,
+		nodeId,
+		threadId: params.threadId
+	});
+	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");
+	const record = lookup.record;
+	requireContinuableNodeRecord(record);
+	const existing = findNodeAdoptedSessionEntry({
+		agentId: params.agentId,
+		config: params.config,
+		runtime: params.api.runtime,
+		hostId: params.hostId,
+		threadId: params.threadId,
+		includeInitializing: true
+	});
+	let adopted;
+	let disposition;
+	if (existing) {
+		adopted = existing;
+		disposition = "existing";
+	} else {
+		const history = await readNodeCodexHistory({
+			agentId: params.agentId,
+			runtime: params.api.runtime,
+			nodeId,
+			record
+		});
+		adopted = await createOrReuseNodeAdoptedSession({
+			agentId: params.agentId,
+			api: params.api,
+			config: params.config,
+			hostId: params.hostId,
+			nodeId,
+			record,
+			history
+		});
+		disposition = "forked";
+	}
+	const marker = nodeSessionMarker({
+		hostId: params.hostId,
+		threadId: params.threadId,
+		nodeId
+	});
+	return {
+		sessionKey: adopted.key,
+		disposition,
+		conversationBinding: {
+			summary: "Continue this Codex session on its paired node.",
+			detachHint: "Start a new chat to leave the paired-node Codex session.",
+			data: createCodexCliNodeConversationBindingData({
+				nodeId,
+				sessionId: params.threadId,
+				agentId: adopted.agentId,
+				cwd: record.cwd
+			})
+		},
+		afterConversationBound: async () => await finalizeNodeAdoptedSession({
+			api: params.api,
+			adopted,
+			marker
+		})
+	};
+}
+async function continueNodeCodexSession(params) {
+	if (params.clientScopes?.includes("operator.admin") !== true) throw new CatalogParamsError("continuing a paired-node Codex session requires operator.admin");
+	const nodeId = params.hostId.slice(5).trim();
+	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+	const agentId = resolveSessionAgentIdsStrict({
+		config: params.config,
+		agentId: params.agentId
+	}).sessionAgentId;
+	const sourceKey = sessionCatalogAdoptedSourceKey(`node:${nodeId}`, params.threadId);
+	const operationKey = sessionCatalogAdoptedSourceKey(agentId, sourceKey);
+	return await continueNodeAdoption({
+		sourceKey: operationKey,
+		findExisting: () => void 0,
+		create: () => runSessionActionExclusive(sourceKey, async () => continueNodeCodexSessionInner({
+			...params,
+			agentId
+		})),
+		complete: async (continued) => continued
+	});
+}
+//#endregion
+export { compareNodeLabels, continueNodeCodexSession, listPairedNode, nodeLabel };

package/dist/session-catalog-provenance-D-dIfRAH.js

@@ -0,0 +1,96 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import path from "node:path";
+import { createZstdDecompress } from "node:zlib";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
+//#region extensions/codex/src/session-catalog-provenance.ts
+const MAX_SESSION_META_BYTES = 1048576;
+const SESSION_META_READ_CHUNK_BYTES = 65536;
+const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
+const provenanceByPath = /* @__PURE__ */ new Map();
+function cacheProvenance(key, value) {
+	provenanceByPath.delete(key);
+	provenanceByPath.set(key, value);
+	while (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) {
+		const oldest = provenanceByPath.keys().next().value;
+		if (oldest === void 0) break;
+		provenanceByPath.delete(oldest);
+	}
+}
+/** Undefined means the metadata line is not durable enough to cache yet. */
+async function readCodexSessionMeta(sessionsRoot, rolloutPath, threadId) {
+	let safeRoot;
+	try {
+		safeRoot = await root(sessionsRoot, {
+			hardlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER,
+			symlinks: "reject"
+		});
+	} catch {
+		return;
+	}
+	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
+	for (const candidate of candidates) {
+		let opened;
+		try {
+			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
+		} catch {
+			continue;
+		}
+		const input = opened.handle.createReadStream({
+			autoClose: false,
+			highWaterMark: SESSION_META_READ_CHUNK_BYTES
+		});
+		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
+		try {
+			const chunks = [];
+			let bytesReadTotal = 0;
+			let line;
+			for await (const value of reader) {
+				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
+				if (remaining <= 0) break;
+				const bounded = chunk.subarray(0, remaining);
+				bytesReadTotal += bounded.length;
+				const newline = bounded.indexOf(10);
+				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
+				if (newline >= 0) {
+					line = Buffer.concat(chunks).toString("utf8");
+					break;
+				}
+			}
+			if (!line) continue;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (!isJsonObject(parsed) || parsed.type !== "session_meta" || !isJsonObject(parsed.payload)) return null;
+			const payload = parsed.payload;
+			return payload.id === threadId ? payload : null;
+		} catch {
+			continue;
+		} finally {
+			reader.destroy();
+			input.destroy();
+			await opened.handle.close().catch(() => void 0);
+		}
+	}
+}
+/**
+* Codex 0.147 reports OpenClaw app-server rollouts as `vscode`, so the rollout's
+* immutable session metadata is the authoritative historical provenance.
+*/
+async function isOpenClawManagedCodexThread(thread, localSessionsRoot) {
+	const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+	if (!localSessionsRoot || !rolloutPath) return false;
+	const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
+	const cached = provenanceByPath.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const metadata = await readCodexSessionMeta(localSessionsRoot, rolloutPath, thread.id);
+	const managed = metadata === void 0 ? void 0 : metadata?.originator === "openclaw";
+	if (managed !== void 0) cacheProvenance(cacheKey, managed);
+	return managed ?? false;
+}
+//#endregion
+export { readCodexSessionMeta as n, isOpenClawManagedCodexThread as t };

package/dist/{session-cli-BjLhpmS1.js → session-cli-DNN_jhGc.js}

@@ -1,8 +1,9 @@
-import "./session-catalog-B47uwekb.js";
+import "./session-catalog-ct-AH01I.js";
+import "./thread-history-page-D0JIp48V.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
+import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { addGatewayClientOptions, callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
 //#region extensions/codex/src/session-cli.ts
 const CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS = 75e3;

package/dist/{session-history-DWmMqiqW.js → session-history-Cz-tOOYj.js}

@@ -1,6 +1,6 @@
-import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-LHldwvyh.js";
-import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
+import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-cxPUxyVV.js";
 import { SessionManager } from "openclaw/plugin-sdk/agent-sessions";
+import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-history.ts
 function resolveCodexHistoryTarget(target, admission) {
 	if (target.sessionTarget) {
@@ -64,7 +64,10 @@ async function readCodexMirroredSessionHistoryMessages(target, admission, view =
 					signal
 				});
 				result = consumeCodexHistory(loaded.buildSessionContext().messages, loaded.getHeader(), target.sessionId, read, "codex mirrored model context");
-			} else result = await readCodexNativeHistory(resolved, target.sessionId, read, admission);
+			} else {
+				const history = await readCodexNativeHistory(resolved, target.sessionId, read, admission);
+				result = history.status === "ok" ? history.value : void 0;
+			}
 		}
 		signal?.throwIfAborted();
 		return result;

package/dist/{session-upstream-marker-DReTpGz6.js → session-history-import-DwyijFI6.js}

@@ -1,7 +1,7 @@
-import { l as sessionBindingIdentity } from "./session-binding-record-CyaXZvTe.js";
-import "./session-binding-4Ki04sW-.js";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-_njEB84z.js";
-import { n as prepareCodexSessionInitialization } from "./session-initialization-BCFVnLL4.js";
+import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
+import "./session-binding-CI8UuilT.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-C5CKgNy6.js";
+import { n as prepareCodexSessionInitialization } from "./session-initialization-Ct0_Hzmg.js";
 import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-history-import.ts
 /** Creates a session whose transcript is derived from one verified Codex thread snapshot. */
@@ -50,49 +50,4 @@ async function createImportedCodexSession(params) {
 	}) : await params.runtime.agent.session.createSessionEntry(createParams);
 }
 //#endregion
-//#region extensions/codex/src/session-upstream-marker.ts
-function lastIdentifiableTurn(thread, normalizeTurnId) {
-	for (let index = (thread.turns?.length ?? 0) - 1; index >= 0; index -= 1) {
-		const turn = thread.turns?.[index];
-		const turnId = normalizeTurnId(turn?.id);
-		if (turn && turnId) return {
-			...turn,
-			id: turnId
-		};
-	}
-}
-function codexUpstreamBaseline(thread, normalizeTurnId) {
-	const turn = lastIdentifiableTurn(thread, normalizeTurnId);
-	return {
-		turnId: turn?.id ?? null,
-		userMessageCount: turn?.items.filter((item) => item.type === "userMessage").length ?? 0
-	};
-}
-function codexLastTerminalTurnId(thread, normalizeTurnId) {
-	for (let index = (thread.turns?.length ?? 0) - 1; index >= 0; index -= 1) {
-		const turn = thread.turns?.[index];
-		const turnId = normalizeTurnId(turn?.id);
-		if (!turn || !turnId) continue;
-		if (turn.status === "completed" || turn.status === "interrupted" || turn.status === "failed") return turnId;
-	}
-}
-/** Build the upstream link seed for a continued Codex session, if a baseline exists. */
-function codexUpstreamContinueResult(sessionKey, threadId, baseline) {
-	if (!baseline) return { sessionKey };
-	return {
-		sessionKey,
-		upstream: {
-			kind: "codex-app-server",
-			ref: {
-				connectionFingerprint: baseline.connectionFingerprint,
-				threadId
-			},
-			marker: {
-				turnId: baseline.turnId,
-				userMessageCount: baseline.userMessageCount
-			}
-		}
-	};
-}
-//#endregion
-export { createImportedCodexSession as i, codexUpstreamBaseline as n, codexUpstreamContinueResult as r, codexLastTerminalTurnId as t };
+export { createImportedCodexSession };