@openclaw/codex 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{session-catalog-CA7R-hX2.js → session-catalog-CP2oCcEb.js}

@@ -1,26 +1,31 @@
-import { J as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, R as CodexAppServerRpcError, Z as isJsonObject, a as getLeasedSharedCodexAppServerClient, c as releaseLeasedSharedCodexAppServerClient, m as withTimeout, q as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES } from "./shared-client-CSXLtCLE.js";
-import { E as resolveCodexSupervisionAppServerRuntimeOptions, b as resolveCodexAppServerRuntimeOptions, c as sessionBindingIdentity, s as reclaimCurrentCodexSessionGeneration } from "./session-binding-Bmt20HfB.js";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-D9rTxx2P.js";
-import { n as listCodexAppServerModels } from "./models-DD5zBdX5.js";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DJbhLYSK.js";
-import { d as CODEX_CONTROL_METHODS, f as describeControlFailure, r as formatCodexDisplayText } from "./command-formatters-NCTL7A2q.js";
+import { E as resolveCodexAppServerClientInstanceId, L as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, R as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, V as isJsonObject, _ as CodexAppServerRpcError, a as getLeasedSharedCodexAppServerClient, h as withTimeout, l as releaseLeasedSharedCodexAppServerClient } from "./shared-client-BVKE40c-.js";
+import { c as reclaimCurrentCodexSessionGeneration, g as resolveCodexSupervisionAppServerRuntimeOptions, l as sessionBindingIdentity, p as resolveCodexAppServerRuntimeOptions } from "./session-binding-DlVQ-Pxs.js";
+import { t as assertCodexThreadForkParams } from "./protocol-validators-Dm4eXZmt.js";
+import { n as listCodexAppServerModels } from "./models-BA01NEez.js";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DSXX-rXO.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-uKA-A4tB.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-BHRSI6Cn.js";
+import { r as formatCodexDisplayText } from "./command-formatters-ico4ZFnk.js";
 import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-BHRpYbX3.js";
-import { n as requestCodexAppServerClientJson, r as requestCodexAppServerJson } from "./request-9yf9pZjf.js";
+import { n as requestCodexAppServerClientJson, r as requestCodexAppServerJson } from "./request-CXpPennK.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-QE-m5QFG.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
+import { listAgentIds, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
 import os from "node:os";
-import { listAgentIds, resolveDefaultAgentDir, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
-import { spawn } from "node:child_process";
 import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { spawn } from "node:child_process";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import process$1 from "node:process";
+import { listSessionCatalogEntries } from "openclaw/plugin-sdk/session-catalog";
+import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { decodeNodePtyResumeParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
 //#region extensions/codex/src/node-cli-sessions.ts
 const CODEX_CLI_SESSIONS_LIST_COMMAND = "codex.cli.sessions.list";
@@ -611,6 +616,29 @@ async function safeValue(read) {
 	}
 }
 //#endregion
+//#region extensions/codex/src/session-catalog-create.ts
+const CODEX_AGENT_RUNTIME_ID = "codex";
+const CODEX_CATALOG_DEFAULT_MODEL_REF = "openai/gpt-5.6-sol";
+function resolveCodexCatalogCreateSession(config, requestedAgentId) {
+	if (!config) return;
+	const agentId = requestedAgentId ?? resolveDefaultAgentId(config);
+	const defaultModel = resolveDefaultModelForAgent({
+		cfg: config,
+		agentId
+	});
+	return "error" in resolveAllowedModelRef({
+		cfg: config,
+		catalog: [],
+		raw: CODEX_CATALOG_DEFAULT_MODEL_REF,
+		defaultProvider: defaultModel.provider,
+		defaultModel: defaultModel.model,
+		agentId
+	}) ? void 0 : {
+		model: CODEX_CATALOG_DEFAULT_MODEL_REF,
+		agentRuntime: CODEX_AGENT_RUNTIME_ID
+	};
+}
+//#endregion
 //#region extensions/codex/src/session-catalog-parsing.ts
 const DEFAULT_PAGE_LIMIT = 50;
 const CODEX_APP_SERVER_THREADS_CAPABILITY = "codex-app-server-threads";
@@ -624,6 +652,7 @@ const MAX_CURSOR_COUNT = 100;
 const MAX_HOST_ID_LENGTH = 256;
 const MAX_CWD_LENGTH = 4096;
 const MAX_SESSION_NAME_LENGTH = 500;
+const MAX_SESSION_PREVIEW_LENGTH = 500;
 const MAX_SESSION_KEY_LENGTH = 1024;
 const MAX_METADATA_LENGTH = 500;
 const MAX_ACTIVE_FLAGS = 16;
@@ -641,6 +670,10 @@ function boundedCatalogString(value, maxLength, overflow = "omit") {
 	if (normalized.length <= maxLength) return normalized;
 	return overflow === "truncate" ? truncateUtf16Safe(normalized, maxLength) : void 0;
 }
+function catalogPreview(value) {
+	if (typeof value !== "string") return;
+	return boundedCatalogString(sanitizeTerminalText(value.replace(/\s+/g, " ")), MAX_SESSION_PREVIEW_LENGTH, "truncate");
+}
 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;
@@ -661,6 +694,7 @@ function toCatalogSession(thread, archived) {
 	const gitInfo = isRecord(record.gitInfo) ? record.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);
 	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");
@@ -671,6 +705,7 @@ function toCatalogSession(thread, archived) {
 		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 } : {},
@@ -789,12 +824,13 @@ function parseCatalogSession(value, options = {}) {
 	}) : void 0;
 	const sessionId = parseOptionalCatalogString(value.sessionId, "session id", 256);
 	const name = value.name === null ? null : parseOptionalCatalogString(value.name, "session name", MAX_SESSION_NAME_LENGTH);
+	const fallbackName = parseOptionalCatalogString(value.fallbackName, "session fallback name", MAX_SESSION_PREVIEW_LENGTH);
 	const cwd = parseOptionalCatalogString(value.cwd, "cwd", MAX_CWD_LENGTH);
 	const source = parseOptionalCatalogString(value.source, "source", MAX_METADATA_LENGTH);
 	const modelProvider = parseOptionalCatalogString(value.modelProvider, "model provider", MAX_METADATA_LENGTH);
 	const cliVersion = parseOptionalCatalogString(value.cliVersion, "CLI version", MAX_METADATA_LENGTH);
 	const gitBranch = parseOptionalCatalogString(value.gitBranch, "Git branch", MAX_METADATA_LENGTH);
-	const openClawSessionKey = options.allowOpenClawSessionKey ? parseOptionalCatalogString(value.openClawSessionKey, "OpenClaw session key", MAX_SESSION_KEY_LENGTH) : void 0;
+	const sessionKey = options.allowSessionKey ? parseOptionalCatalogString(value.sessionKey, "OpenClaw session key", MAX_SESSION_KEY_LENGTH) : void 0;
 	const createdAt = readFiniteNumber(value.createdAt);
 	const updatedAt = readFiniteNumber(value.updatedAt);
 	const recencyAt = value.recencyAt === null ? null : readFiniteNumber(value.recencyAt);
@@ -804,6 +840,7 @@ function parseCatalogSession(value, options = {}) {
 		archived: value.archived,
 		...sessionId !== void 0 ? { sessionId } : {},
 		...name !== void 0 ? { name } : {},
+		...fallbackName !== void 0 ? { fallbackName } : {},
 		...cwd !== void 0 ? { cwd } : {},
 		...activeFlags && activeFlags.length > 0 ? { activeFlags } : {},
 		...createdAt !== void 0 ? { createdAt } : {},
@@ -813,7 +850,7 @@ function parseCatalogSession(value, options = {}) {
 		...modelProvider !== void 0 ? { modelProvider } : {},
 		...cliVersion !== void 0 ? { cliVersion } : {},
 		...gitBranch !== void 0 ? { gitBranch } : {},
-		...openClawSessionKey !== void 0 ? { openClawSessionKey } : {}
+		...sessionKey !== void 0 ? { sessionKey } : {}
 	};
 }
 function parseCatalogPage(value, options = {}) {
@@ -930,7 +967,11 @@ function readNodeSessionMarker(entry) {
 }
 function listNodeAdoptedSessionEntries(params) {
 	const adopted = /* @__PURE__ */ new Map();
-	for (const agentId of listSupervisionAgentIds(params.config ?? {})) for (const { entry, sessionKey } of params.runtime.agent.session.listSessionEntries({ agentId })) {
+	for (const { agentId, entry, sessionKey } of listSessionCatalogEntries({
+		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;
@@ -1117,7 +1158,7 @@ async function listPairedNode(params) {
 			...page,
 			sessions: page.sessions.map((session) => {
 				const adopted = params.adoptedSessions.get(adoptedSourceKey(hostId, session.threadId));
-				return adopted ? Object.assign({}, session, { openClawSessionKey: adopted.key }) : session;
+				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
 			})
 		};
 	}).catch((error) => ({
@@ -1574,56 +1615,12 @@ function createChecker(params) {
 	});
 }
 //#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
 //#region extensions/codex/src/session-catalog.ts
 const boundCatalogSessionId = (value) => boundedCatalogString(value, 256);
 const CODEX_SUPERVISION_SESSION_KEY_PREFIX = "harness:codex:supervision:";
 function createCodexSessionCatalogControlFromRequests(params) {
 	return {
+		...params.clientId ? { clientId: params.clientId } : {},
 		...params.connectionFingerprint ? { connectionFingerprint: params.connectionFingerprint } : {},
 		withPinnedConnection: params.withPinnedConnection,
 		async listPage(pageParams) {
@@ -1678,6 +1675,9 @@ function createCodexSessionCatalogControlFromRequests(params) {
 		async listTurnPage(listParams) {
 			return await params.createRequestSnapshot().listThreadTurns(listParams);
 		},
+		async forkThread(forkParams) {
+			return await params.createRequestSnapshot().forkThread(forkParams);
+		},
 		async archiveThread(threadId) {
 			await params.createRequestSnapshot().archiveThread(threadId);
 		}
@@ -1705,6 +1705,7 @@ function createCodexSessionCatalogControl(params) {
 				includeTurns
 			}, requestOptions)).thread,
 			listThreadTurns: async (listParams) => await codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listThreadTurns, listParams, requestOptions),
+			forkThread: async (forkParams) => await codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.forkThread, assertCodexThreadForkParams(forkParams), requestOptions),
 			archiveThread: async (threadId) => {
 				await codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.archiveThread, { threadId }, requestOptions);
 			}
@@ -1745,6 +1746,13 @@ function createCodexSessionCatalogControl(params) {
 					config: runtimeConfig,
 					timeoutMs: runtime.requestTimeoutMs
 				}),
+				forkThread: async (forkParams) => await requestCodexAppServerClientJson({
+					client,
+					method: CODEX_CONTROL_METHODS.forkThread,
+					requestParams: assertCodexThreadForkParams(forkParams),
+					config: runtimeConfig,
+					timeoutMs: runtime.requestTimeoutMs
+				}),
 				archiveThread: async (threadId) => {
 					await requestCodexAppServerClientJson({
 						client,
@@ -1756,6 +1764,7 @@ function createCodexSessionCatalogControl(params) {
 				}
 			};
 			const pinnedControl = createCodexSessionCatalogControlFromRequests({
+				clientId: resolveCodexAppServerClientInstanceId(client),
 				connectionFingerprint: buildCodexAppServerConnectionFingerprint(runtime, resolveDefaultAgentDir(runtimeConfig ?? {})),
 				createRequestSnapshot: () => requests,
 				now,
@@ -1782,7 +1791,8 @@ async function listGatewayHost(params) {
 		const adoptedSessions = await listAdoptedSessionEntries({
 			bindingStore: params.bindingStore,
 			config: params.config,
-			runtime: params.runtime
+			runtime: params.runtime,
+			sessionEntries: params.sessionEntries
 		});
 		return {
 			hostId: CODEX_LOCAL_SESSION_HOST_ID,
@@ -1792,7 +1802,7 @@ async function listGatewayHost(params) {
 			...page,
 			sessions: page.sessions.map((session) => {
 				const adopted = adoptedSessions.get(session.threadId);
-				return adopted ? Object.assign({}, session, { openClawSessionKey: adopted.key }) : session;
+				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
 			})
 		};
 	} catch (error) {
@@ -1815,13 +1825,14 @@ async function listCodexSessionCatalog(params) {
 		config: params.config,
 		control: params.control,
 		query,
-		runtime: params.runtime
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
 	})] : [];
 	for (const host of localHosts) if (params.onHost) host.then(params.onHost).catch(() => void 0);
 	if (!(!requestedHostIds || query.hostIds?.some((hostId) => hostId.startsWith("node:")))) return { hosts: await Promise.all(localHosts) };
 	let nodes;
 	try {
-		nodes = (await params.runtime.nodes.list()).nodes.filter((node) => node.commands?.includes("codex.appServer.threads.list.v1") && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - localHosts.length);
+		nodes = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes.filter((node) => node.commands?.includes("codex.appServer.threads.list.v1") && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - localHosts.length);
 	} catch (error) {
 		const registryHost = {
 			hostId: "node:registry",
@@ -1836,7 +1847,8 @@ async function listCodexSessionCatalog(params) {
 	}
 	const adoptedNodeSessions = listNodeAdoptedSessionEntries({
 		config: params.config,
-		runtime: params.runtime
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
 	});
 	const nodeHosts = nodes.toSorted(compareNodeLabels).map(async (node) => {
 		const host = await listPairedNode({
@@ -1973,7 +1985,11 @@ function isAdoptionSessionKeyForThread(sessionKey, threadId) {
 }
 async function listAdoptedSessionEntries(params) {
 	const adopted = /* @__PURE__ */ new Map();
-	for (const agentId of listSupervisionAgentIds(params.config ?? {})) for (const { entry, sessionKey } of params.runtime.agent.session.listSessionEntries({ agentId })) {
+	for (const { agentId, entry, sessionKey } of listSessionCatalogEntries({
+		config: params.config ?? {},
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
+	})) {
 		const sessionKeyRest = adoptionSessionKeyRest(sessionKey);
 		if (!sessionKeyRest.startsWith(CODEX_SUPERVISION_SESSION_KEY_PREFIX) || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) continue;
 		const sessionId = entry.sessionId?.trim();
@@ -2087,17 +2103,17 @@ async function createOrReuseAdoptedSession(params) {
 	let createdBindingIdentity;
 	let createdPendingBinding;
 	try {
-		const label = params.sourceThread.name?.trim() || void 0;
 		const spawnedCwd = params.sourceThread.cwd?.trim() || void 0;
 		const pendingLastTurnId = codexLastTerminalTurnId(params.sourceThread, boundCatalogSessionId);
 		const marker = { sourceThreadId: params.sourceThread.id };
-		const created = await params.api.runtime.agent.session.createSessionEntry({
-			cfg: params.config,
+		const created = await createImportedCodexSession({
+			runtime: params.api.runtime,
+			config: params.config,
 			key: adoptionSessionKey(params.sourceThread.id),
 			agentId: resolveDefaultAgentId(params.config),
+			thread: params.sourceThread,
+			throughTurnId: pendingLastTurnId ?? null,
 			recoverMatchingInitialEntry: true,
-			...label ? { label } : {},
-			...spawnedCwd ? { spawnedCwd } : {},
 			initialEntry: {
 				agentHarnessId: "codex",
 				modelSelectionLocked: true,
@@ -2107,24 +2123,12 @@ async function createOrReuseAdoptedSession(params) {
 					modelLocked: true
 				} } }
 			},
-			afterCreate: async (entry) => {
+			afterImport: async (entry) => {
 				createdBindingIdentity = sessionBindingIdentity({
 					sessionId: entry.sessionId,
 					sessionKey: entry.key,
 					config: params.config
 				});
-				const storePath = resolveStorePath(params.config.session?.store, { agentId: entry.agentId });
-				await importCodexThreadHistoryToTranscript({
-					thread: params.sourceThread,
-					throughTurnId: pendingLastTurnId ?? null,
-					storePath,
-					sessionId: entry.sessionId,
-					sessionKey: entry.key,
-					agentId: entry.agentId,
-					...spawnedCwd ? { cwd: spawnedCwd } : {},
-					modelProvider: params.sourceThread.modelProvider,
-					config: params.config
-				});
 				createdPendingBinding = {
 					sourceThreadId: params.sourceThread.id,
 					connectionFingerprint: params.connectionFingerprint,
@@ -2251,7 +2255,10 @@ async function continueLocalCodexSession(params) {
 	}
 }
 async function assertNoPendingSupervisionBranch(params) {
-	const adoptedEntries = listSupervisionAgentIds(params.config).flatMap((agentId) => params.runtime.agent.session.listSessionEntries({ agentId })).filter((candidate) => isAdoptionSessionKeyForThread(candidate.sessionKey, params.threadId));
+	const adoptedEntries = listSupervisionAgentIds(params.config).flatMap((agentId) => params.runtime.agent.session.listSessionEntries({
+		agentId,
+		readOnly: true
+	})).filter((candidate) => isAdoptionSessionKeyForThread(candidate.sessionKey, params.threadId));
 	for (const adopted of adoptedEntries) {
 		if (adopted.entry.initializationPending === true) throw new CatalogParamsError("Codex session cannot be archived while its OpenClaw branch is initializing");
 		const sessionId = adopted.entry.sessionId?.trim();
@@ -2320,9 +2327,10 @@ function toGenericCatalogHost(host, localTerminalAvailable) {
 			const canContinue = (local || host.canContinueCodex === true) && continuableStatus && isInteractiveThreadSource(session.source);
 			const canArchive = local && continuableStatus && isInteractiveThreadSource(session.source);
 			const canOpenTerminal = isInteractiveThreadSource(session.source) && (local ? localTerminalAvailable : host.canOpenTerminalCodex === true);
+			const name = session.name ?? session.fallbackName;
 			return {
 				threadId: session.threadId,
-				...session.name != null ? { name: session.name } : {},
+				...name ? { name } : {},
 				...session.cwd ? { cwd: session.cwd } : {},
 				status: session.status,
 				...session.createdAt != null ? { createdAt: session.createdAt } : {},
@@ -2333,7 +2341,7 @@ function toGenericCatalogHost(host, localTerminalAvailable) {
 				...session.cliVersion ? { cliVersion: session.cliVersion } : {},
 				...session.gitBranch ? { gitBranch: session.gitBranch } : {},
 				archived: session.archived,
-				...session.openClawSessionKey ? { openClawSessionKey: session.openClawSessionKey } : {},
+				...session.sessionKey ? { sessionKey: session.sessionKey } : {},
 				canContinue,
 				canArchive,
 				canOpenTerminal
@@ -2347,9 +2355,10 @@ function registerCodexSessionCatalog(params) {
 	const provider = {
 		id: "codex",
 		label: "Codex",
+		resolveCreateSession: ({ agentId }) => resolveCodexCatalogCreateSession(params.getRuntimeConfig() ?? params.api.config, agentId),
 		list: async (query) => {
 			const localTerminalAvailable = resolveLocalCodexTerminalExecutable() !== void 0;
-			const { onHost, ...gatewayQuery } = query;
+			const { listNodes, onHost, sessionEntries, ...gatewayQuery } = query;
 			const mapHost = (host) => toGenericCatalogHost(host, localTerminalAvailable);
 			return (await listCodexSessionCatalog({
 				bindingStore: params.bindingStore,
@@ -2357,6 +2366,8 @@ function registerCodexSessionCatalog(params) {
 				runtime: params.api.runtime,
 				control: params.control,
 				query: gatewayQuery,
+				listNodes,
+				sessionEntries,
 				...onHost ? { onHost: (host) => onHost(mapHost(host)) } : {}
 			})).hosts.map(mapHost);
 		},

package/dist/{session-cli-Bxk3-Wqz.js → session-cli-CqZ0Fp2a.js}

@@ -1,6 +1,6 @@
-import { a as CODEX_LOCAL_SESSION_HOST_ID } from "./session-catalog-CA7R-hX2.js";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { a as CODEX_LOCAL_SESSION_HOST_ID } from "./session-catalog-CP2oCcEb.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 { addGatewayClientOptions, callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
 //#region extensions/codex/src/session-cli.ts

package/dist/session-upstream-marker-QE-m5QFG.js

@@ -0,0 +1,82 @@
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-uKA-A4tB.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. */
+async function createImportedCodexSession(params) {
+	const label = params.thread.name?.trim() || void 0;
+	const spawnedCwd = params.thread.cwd?.trim() || void 0;
+	const createParams = {
+		cfg: params.config,
+		key: params.key,
+		agentId: params.agentId,
+		...label ? { label } : {},
+		...spawnedCwd ? { spawnedCwd } : {},
+		initialEntry: params.initialEntry,
+		afterCreate: async (entry) => {
+			const storePath = resolveStorePath(params.config.session?.store, { agentId: entry.agentId });
+			await importCodexThreadHistoryToTranscript({
+				thread: params.thread,
+				throughTurnId: params.throughTurnId,
+				storePath,
+				sessionId: entry.sessionId,
+				sessionKey: entry.key,
+				agentId: entry.agentId,
+				...spawnedCwd ? { cwd: spawnedCwd } : {},
+				modelProvider: params.thread.modelProvider,
+				config: params.config
+			});
+			return await params.afterImport(entry);
+		}
+	};
+	return params.recoverMatchingInitialEntry ? await params.runtime.agent.session.createSessionEntry({
+		...createParams,
+		recoverMatchingInitialEntry: true
+	}) : 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 };