@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/session-catalog-adoption-BKLtSrwi.js

@@ -0,0 +1,251 @@
+import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
+import { S as requireBoundThread, o as CatalogParamsError, u as boundedCatalogString } from "./session-catalog-parsing-CdD3JhdM.js";
+import { n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.js";
+import { i as reclaimCurrentCodexSessionGeneration } from "./session-binding-CKSepwIC.js";
+import { adoptionSessionKeyRest, continueOperations, runSessionActionExclusive } from "./session-catalog-node-adoption-BUuDYY8R.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
+//#region extensions/codex/src/session-catalog-adoption.ts
+const CODEX_SUPERVISION_SESSION_KEY_PREFIX = "harness:codex:supervision:";
+const boundCatalogSessionId = (value) => boundedCatalogString(value, 256);
+function requireIdleThread(thread, action) {
+	if (thread.status?.type === "idle" || action === "archive" && thread.status?.type === "notLoaded") return;
+	if (thread.status?.type === "active") throw new CatalogParamsError(`Codex session is active in this App Server; wait for it to finish before ${action === "continue" ? "starting a branch" : "archiving"}`);
+	throw new CatalogParamsError(action === "archive" ? "Codex session cannot be archived in its current state" : "Codex session cannot start a branch in its current state");
+}
+function adoptionSessionKey(threadId, sourceHomeId) {
+	const source = sourceHomeId ? JSON.stringify([sourceHomeId, threadId]) : threadId;
+	return sessionCatalogAdoptedSessionKey(CODEX_SUPERVISION_SESSION_KEY_PREFIX, source);
+}
+function isAdoptionSessionKeyForThread(sessionKey, threadId, sourceHomeId) {
+	return adoptionSessionKeyRest(sessionKey) === adoptionSessionKey(threadId, sourceHomeId);
+}
+function readCodexSupervisionMarker(entry) {
+	const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : void 0;
+	const marker = codex && isRecord(codex.supervision) ? codex.supervision : void 0;
+	const sourceThreadId = marker?.sourceThreadId;
+	const sourceHomeId = marker?.sourceHomeId;
+	if (typeof sourceThreadId !== "string" || !sourceThreadId.trim() || sourceHomeId !== void 0 && (typeof sourceHomeId !== "string" || !sourceHomeId.trim())) return;
+	return {
+		sourceThreadId: sourceThreadId.trim(),
+		...typeof sourceHomeId === "string" ? { sourceHomeId: sourceHomeId.trim() } : {}
+	};
+}
+async function listAdoptedSessionEntries(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 sessionKeyRest = adoptionSessionKeyRest(sessionKey);
+		const marker = readCodexSupervisionMarker(entry);
+		if (!sessionKeyRest.startsWith(CODEX_SUPERVISION_SESSION_KEY_PREFIX) || !marker || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) continue;
+		const sessionId = entry.sessionId?.trim();
+		if (!sessionId) continue;
+		const binding = params.bindingStore.read(sessionBindingIdentity({
+			sessionId,
+			sessionKey,
+			config: params.config
+		}));
+		const sourceThreadId = binding?.supervisionSourceThreadId?.trim();
+		const boundThreadId = binding?.threadId.trim();
+		if (binding?.connectionScope !== "supervision" || !sourceThreadId || !boundThreadId || sessionKeyRest !== adoptionSessionKey(sourceThreadId, marker.sourceHomeId)) continue;
+		const sourceKey = sessionCatalogAdoptedSourceKey(marker.sourceHomeId ?? "gateway:local", sourceThreadId);
+		if (adopted.has(sourceKey)) throw new Error(`multiple OpenClaw sessions adopt Codex thread ${sourceThreadId} from the same home`);
+		adopted.set(sourceKey, {
+			key: sessionKey,
+			sessionId,
+			agentId,
+			boundThreadId
+		});
+	}
+	return adopted;
+}
+async function findAdoptedSessionEntry(params) {
+	const adopted = await listAdoptedSessionEntries(params);
+	return adopted.get(sessionCatalogAdoptedSourceKey(params.sourceHomeId ?? "gateway:local", params.threadId)) ?? (params.sourceHomeId && params.allowLegacy === true ? adopted.get(sessionCatalogAdoptedSourceKey("gateway:local", params.threadId)) : void 0);
+}
+function matchesPendingAdoptionBinding(binding, expected) {
+	const historyCoveredThrough = binding?.historyCoveredThrough;
+	return binding?.threadId === expected.sourceThreadId && binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && binding.cwd === expected.cwd && binding.conversationSourceTransferComplete === true && binding.preserveNativeModel === true && binding.pendingSupervisionBranch?.sourceThreadId === expected.sourceThreadId && binding.pendingSupervisionBranch.connectionFingerprint === expected.connectionFingerprint && binding.pendingSupervisionBranch.lastTurnId === expected.lastTurnId && (binding.pendingSupervisionBranch.cleanupThreadIds?.length ?? 0) === 0 && typeof historyCoveredThrough === "string" && Number.isFinite(Date.parse(historyCoveredThrough));
+}
+async function ensurePendingAdoptionBinding(params) {
+	const pending = {
+		sourceThreadId: params.sourceThreadId,
+		connectionFingerprint: params.connectionFingerprint,
+		...params.lastTurnId ? { lastTurnId: params.lastTurnId } : {}
+	};
+	const ownsGeneration = await reclaimCurrentCodexSessionGeneration({
+		assertCurrent: params.initialization.assertCurrent,
+		bindingStore: params.bindingStore,
+		identity: params.identity,
+		config: params.config
+	});
+	params.initialization.assertCurrent();
+	if (!ownsGeneration) throw new Error(`failed to claim the OpenClaw session generation for ${params.sourceThreadId}`);
+	const existing = params.bindingStore.read(params.identity);
+	params.initialization.assertCurrent();
+	if (existing) {
+		if (matchesPendingAdoptionBinding(existing, params)) return;
+		throw new Error(`OpenClaw session is already bound to Codex thread ${existing.threadId}`);
+	}
+	const binding = {
+		threadId: params.sourceThreadId,
+		connectionScope: "supervision",
+		supervisionSourceThreadId: params.sourceThreadId,
+		cwd: params.cwd,
+		historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
+		conversationSourceTransferComplete: true,
+		preserveNativeModel: true,
+		pendingSupervisionBranch: pending
+	};
+	await params.initialization.bind(binding);
+}
+async function createOrReuseAdoptedSession(params) {
+	const runtime = params.api.runtime;
+	const lookup = {
+		...params,
+		runtime,
+		threadId: params.sourceThread.id
+	};
+	const existing = await findAdoptedSessionEntry(lookup);
+	if (existing) return existing;
+	try {
+		const spawnedCwd = params.sourceThread.cwd?.trim() || void 0;
+		const pendingLastTurnId = codexLastTerminalTurnId(params.sourceThread, boundCatalogSessionId);
+		const marker = {
+			sourceThreadId: params.sourceThread.id,
+			...params.sourceHomeId ? { sourceHomeId: params.sourceHomeId } : {}
+		};
+		const { createImportedCodexSession } = await import("./session-history-import-DFN7sWRU.js");
+		const created = await createImportedCodexSession({
+			runtime: params.api.runtime,
+			bindingStore: params.bindingStore,
+			config: params.config,
+			key: adoptionSessionKey(params.sourceThread.id, params.sourceHomeId),
+			agentId: params.agentId,
+			displayName: params.sourceThread.name ?? void 0,
+			thread: params.sourceThread,
+			throughTurnId: pendingLastTurnId ?? null,
+			recoverMatchingInitialEntry: true,
+			initialEntry: {
+				agentHarnessId: "codex",
+				modelSelectionLocked: true,
+				pluginExtensions: { codex: { supervision: {
+					...marker,
+					initializing: true,
+					modelLocked: true
+				} } }
+			},
+			afterImport: async (entry, initialization) => {
+				const identity = sessionBindingIdentity({
+					sessionId: entry.sessionId,
+					sessionKey: entry.key,
+					config: params.config
+				});
+				await ensurePendingAdoptionBinding({
+					bindingStore: params.bindingStore,
+					config: params.config,
+					identity,
+					initialization,
+					sourceThreadId: params.sourceThread.id,
+					connectionFingerprint: params.connectionFingerprint,
+					cwd: spawnedCwd ?? "",
+					...pendingLastTurnId ? { lastTurnId: pendingLastTurnId } : {}
+				});
+				return { pluginExtensions: { codex: { supervision: {
+					...marker,
+					modelLocked: true
+				} } } };
+			}
+		});
+		return {
+			key: created.key,
+			sessionId: created.sessionId,
+			agentId: created.agentId,
+			boundThreadId: params.sourceThread.id
+		};
+	} catch (error) {
+		const raced = await findAdoptedSessionEntry(lookup);
+		if (raced) return raced;
+		throw error;
+	}
+}
+async function continueLocalCodexSessionInner(params) {
+	await params.control.requireEligibleThread(params.threadId);
+	const existing = await findAdoptedSessionEntry({
+		...params,
+		runtime: params.api.runtime
+	});
+	if (existing) {
+		const boundThreadId = requireBoundThread(existing);
+		const boundThread = await params.control.readThread(boundThreadId, true);
+		if (boundThread.id !== boundThreadId) throw new Error("Codex app-server returned a different thread than requested");
+		const changedError = () => new CatalogParamsError("Codex OpenClaw session changed before it could be opened. Retry.");
+		if (!await params.api.runtime.agent.session.patchSessionEntry({
+			sessionKey: existing.key,
+			readConsistency: "latest",
+			preserveActivity: true,
+			update: (entry) => {
+				if (entry.sessionId?.trim() !== existing.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) throw changedError();
+				return {
+					archivedAt: void 0,
+					archivedBy: void 0,
+					archiveReason: void 0
+				};
+			}
+		})) throw changedError();
+		const connectionFingerprint = params.control.connectionFingerprint;
+		if (connectionFingerprint) params.onContinued?.({
+			connectionFingerprint,
+			...codexUpstreamBaseline(boundThread, boundCatalogSessionId)
+		});
+		return {
+			sessionKey: existing.key,
+			disposition: "existing"
+		};
+	}
+	const sourceThread = await params.control.readThread(params.threadId, true);
+	if (sourceThread.id !== params.threadId) throw new Error("Codex app-server returned a different thread than requested");
+	if (sourceThread.status?.type !== "notLoaded") requireIdleThread(sourceThread, "continue");
+	const connectionFingerprint = params.control.connectionFingerprint;
+	if (!connectionFingerprint) throw new Error("Codex Continue requires a pinned app-server connection");
+	const adopted = await createOrReuseAdoptedSession({
+		...params,
+		sourceThread,
+		connectionFingerprint
+	});
+	const boundThreadId = requireBoundThread(adopted);
+	const baselineThread = boundThreadId === sourceThread.id ? sourceThread : await params.control.readThread(boundThreadId, true);
+	if (baselineThread.id !== boundThreadId) throw new Error("Codex app-server returned a different thread than requested");
+	params.onContinued?.({
+		connectionFingerprint,
+		...codexUpstreamBaseline(baselineThread, boundCatalogSessionId)
+	});
+	return {
+		sessionKey: adopted.key,
+		disposition: "forked"
+	};
+}
+/** Creates one locked OpenClaw branch whose first harness run forks the Codex source. */
+async function continueLocalCodexSession(params) {
+	const sourceKey = sessionCatalogAdoptedSourceKey(params.hostId ?? "gateway:local", params.threadId);
+	const operationKey = sessionCatalogAdoptedSourceKey(params.agentId, sourceKey);
+	const current = continueOperations.get(operationKey);
+	if (current) return await current;
+	const run = async (control) => await continueLocalCodexSessionInner({
+		...params,
+		control
+	});
+	const operation = runSessionActionExclusive(sourceKey, async () => params.control.withPinnedConnection(run));
+	continueOperations.set(operationKey, operation);
+	try {
+		return await operation;
+	} finally {
+		if (continueOperations.get(operationKey) === operation) continueOperations.delete(operationKey);
+	}
+}
+//#endregion
+export { continueLocalCodexSession, isAdoptionSessionKeyForThread, listAdoptedSessionEntries, requireIdleThread };

package/dist/session-catalog-archive-D0i2pGj2.js

@@ -0,0 +1,56 @@
+import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
+import { t as assertCodexArchiveDescendantsUnowned } from "./thread-archive-guard-D1bP04Tf.js";
+import { o as CatalogParamsError } from "./session-catalog-parsing-CdD3JhdM.js";
+import "./session-binding-CKSepwIC.js";
+import { runSessionActionExclusive } from "./session-catalog-node-adoption-BUuDYY8R.js";
+import { isAdoptionSessionKeyForThread, requireIdleThread } from "./session-catalog-adoption-BKLtSrwi.js";
+import { listAgentIds } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
+//#region extensions/codex/src/session-catalog-archive.ts
+function assertNoPendingSupervisionBranch(params) {
+	const adoptedEntries = [params.agentId, ...listAgentIds(params.config).filter((agentId) => agentId !== params.agentId)].flatMap((agentId) => params.runtime.agent.session.listSessionEntries({
+		agentId,
+		readOnly: true
+	})).filter((candidate) => isAdoptionSessionKeyForThread(candidate.sessionKey, params.threadId, params.sourceHomeId) || params.sourceHomeId !== void 0 && params.allowLegacy === true && 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();
+		if (!sessionId) continue;
+		const binding = params.bindingStore.read(sessionBindingIdentity({
+			sessionId,
+			sessionKey: adopted.sessionKey,
+			config: params.config
+		}));
+		if (binding?.connectionScope === "supervision" && binding.supervisionSourceThreadId === params.threadId && binding.pendingSupervisionBranch?.sourceThreadId === params.threadId) throw new CatalogParamsError("Codex session cannot be archived until its OpenClaw branch starts");
+	}
+}
+/** Archives one inactive Gateway-local Codex thread after a fresh status read. */
+async function archiveLocalCodexSession(params) {
+	return await runSessionActionExclusive(sessionCatalogAdoptedSourceKey(params.hostId ?? "gateway:local", params.threadId), async () => {
+		return await params.bindingStore.withThreadArchiveFence(async () => {
+			const run = async (control) => {
+				assertNoPendingSupervisionBranch(params);
+				await control.requireEligibleThread(params.threadId);
+				const thread = await control.readThread(params.threadId, false);
+				if (thread.id !== params.threadId) throw new Error("Codex app-server returned a different thread than requested");
+				requireIdleThread(thread, "archive");
+				if (await params.bindingStore.hasOtherThreadOwner(params.threadId)) throw new CatalogParamsError("Codex session cannot be archived while it is attached to an OpenClaw session");
+				await assertCodexArchiveDescendantsUnowned({
+					bindingStore: params.bindingStore,
+					threadId: params.threadId,
+					listPage: (request) => control.listDescendantPage(request),
+					assertDescendantIdle: async (descendantThreadId) => {
+						const descendant = await control.readThread(descendantThreadId, false);
+						if (descendant.id !== descendantThreadId) throw new Error("Codex app-server returned a different descendant than requested");
+						requireIdleThread(descendant, "archive");
+					}
+				});
+				await control.archiveThread(params.threadId);
+				return { archived: true };
+			};
+			return await params.control.withPinnedConnection(run);
+		});
+	});
+}
+//#endregion
+export { archiveLocalCodexSession };

package/dist/session-catalog-home-id-D7-aLiNt.js

@@ -0,0 +1,190 @@
+import { t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
+import { Buffer } from "node:buffer";
+//#region extensions/codex/src/app-server/transcript-history-projection.ts
+const CODEX_HISTORY_IMPORT_MAX_MESSAGES = 200;
+const CODEX_HISTORY_IMPORT_MAX_BYTES = 524288;
+const CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES = 65536;
+const CODEX_HISTORY_TRUNCATION_SUFFIX = "\n\n[Message truncated during Codex history import.]";
+const CODEX_HISTORY_ASSISTANT_API = "openai-chatgpt-responses";
+const CODEX_HISTORY_ASSISTANT_PROVIDER = "openai";
+const CODEX_HISTORY_ASSISTANT_MODEL = "native-history";
+const CODEX_HISTORY_ZERO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+function normalizeImportedHistoryText(value) {
+	if (typeof value !== "string") return;
+	const text = value.trim();
+	if (!text) return;
+	if (Buffer.byteLength(text, "utf8") <= CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES) return text;
+	const suffixBytes = Buffer.byteLength(CODEX_HISTORY_TRUNCATION_SUFFIX, "utf8");
+	const contentLimitBytes = Math.max(0, CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES - suffixBytes);
+	return `${truncateUtf8Prefix(text, contentLimitBytes)}${CODEX_HISTORY_TRUNCATION_SUFFIX}`;
+}
+function projectCodexUserItemText(item) {
+	if (!Array.isArray(item.content)) return;
+	const parts = [];
+	for (const value of item.content) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+		const input = value;
+		if (input.type === "text") {
+			const text = normalizeImportedHistoryText(input.text);
+			if (text) parts.push(text);
+			continue;
+		}
+		if (input.type === "image" || input.type === "localImage") {
+			parts.push("[Image attachment]");
+			continue;
+		}
+		if (input.type === "audio" || input.type === "localAudio" || input.type === "local_audio") parts.push("[Audio attachment]");
+		if (input.type === "skill" || input.type === "mention") {
+			const name = normalizeOptionalString(input.name);
+			if (name) parts.push(`${input.type === "skill" ? "$" : "@"}${name}`);
+		}
+	}
+	return normalizeImportedHistoryText(parts.join("\n"));
+}
+function selectTurnsThroughBoundary(thread, throughTurnId) {
+	if (throughTurnId === null) return [];
+	const turns = thread.turns ?? [];
+	const boundaryIndex = turns.findIndex((turn) => turn.id === throughTurnId);
+	if (boundaryIndex < 0) throw new Error(`Codex history boundary turn not found: ${throughTurnId}`);
+	const boundary = turns[boundaryIndex];
+	if (boundary?.status !== "completed" && boundary?.status !== "interrupted" && boundary?.status !== "failed") throw new Error(`Codex history boundary turn is not terminal: ${throughTurnId}`);
+	return turns.slice(0, boundaryIndex + 1);
+}
+function projectCodexThreadHistory(params) {
+	const projected = [];
+	const threadTimestamp = typeof params.thread.createdAt === "number" && Number.isFinite(params.thread.createdAt) ? params.thread.createdAt * 1e3 : params.importedAt;
+	let itemOffset = 0;
+	for (const turn of selectTurnsThroughBoundary(params.thread, params.throughTurnId)) for (const value of turn.items) {
+		const item = value;
+		const itemId = normalizeOptionalString(item.id);
+		const identity = `${turn.id}:${itemId ?? itemOffset}`;
+		const timestampSeconds = item.type === "agentMessage" ? turn.completedAt ?? turn.startedAt : turn.startedAt ?? turn.completedAt;
+		const timestamp = typeof timestampSeconds === "number" && Number.isFinite(timestampSeconds) ? timestampSeconds * 1e3 + itemOffset : threadTimestamp + itemOffset;
+		const text = item.type === "userMessage" ? projectCodexUserItemText(item) : item.type === "agentMessage" ? normalizeImportedHistoryText(item.text) : void 0;
+		const role = item.type === "userMessage" ? "user" : item.type === "agentMessage" ? "assistant" : void 0;
+		itemOffset += 1;
+		if (!text || !role) continue;
+		const phase = item.phase === "commentary" || item.phase === "final_answer" ? item.phase : void 0;
+		const asyncDelivery = item.delivery === "async";
+		const message = role === "assistant" ? attachCodexMirrorIdentity({
+			role,
+			content: [{
+				type: "text",
+				text
+			}],
+			api: CODEX_HISTORY_ASSISTANT_API,
+			provider: normalizeOptionalString(params.modelProvider) ?? normalizeOptionalString(params.thread.modelProvider) ?? CODEX_HISTORY_ASSISTANT_PROVIDER,
+			model: CODEX_HISTORY_ASSISTANT_MODEL,
+			usage: CODEX_HISTORY_ZERO_USAGE,
+			stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop",
+			...turn.status === "failed" && turn.error?.message ? { errorMessage: turn.error.message } : {},
+			...phase ? { phase } : {},
+			...asyncDelivery && itemId ? { openclawAsyncDelivery: { itemId } } : {},
+			timestamp
+		}, identity) : attachCodexMirrorIdentity({
+			role,
+			content: text,
+			timestamp
+		}, identity);
+		projected.push({
+			message,
+			responseItem: {
+				type: "message",
+				role,
+				content: [{
+					type: role === "assistant" ? "output_text" : "input_text",
+					text
+				}],
+				...role === "assistant" && phase ? { phase } : {}
+			},
+			textBytes: Buffer.byteLength(text, "utf8")
+		});
+	}
+	return projected;
+}
+function selectBoundedCodexHistoryTail(projected) {
+	const selected = [];
+	let selectedBytes = 0;
+	for (let index = projected.length - 1; index >= 0; index -= 1) {
+		const candidate = projected[index];
+		if (!candidate) continue;
+		if (selected.length >= CODEX_HISTORY_IMPORT_MAX_MESSAGES || selectedBytes + candidate.textBytes > CODEX_HISTORY_IMPORT_MAX_BYTES) break;
+		selected.push(candidate);
+		selectedBytes += candidate.textBytes;
+	}
+	return selected.toReversed();
+}
+/** Projects one terminal Codex history prefix into transcript and Responses API items. */
+function projectBoundedCodexThreadHistory(params) {
+	const projected = projectCodexThreadHistory({
+		thread: params.thread,
+		throughTurnId: params.throughTurnId,
+		importedAt: params.importedAt,
+		...params.modelProvider ? { modelProvider: params.modelProvider } : {}
+	});
+	const selected = selectBoundedCodexHistoryTail(projected);
+	return {
+		importedMessages: selected.length,
+		omittedMessages: projected.length - selected.length,
+		responseItems: selected.filter(({ message }) => message.role !== "assistant" || message.stopReason !== "aborted" && message.stopReason !== "error" && !("openclawAsyncDelivery" in message)).map(({ responseItem }) => responseItem),
+		transcriptMessages: selected.map(({ message }) => message)
+	};
+}
+/** Projects only visible local user/assistant messages through the same bounded history policy. */
+function projectBoundedCodexVisibleSessionHistory(entries) {
+	const projected = [];
+	for (const entry of entries) {
+		if (entry.role !== "user" && entry.role !== "assistant" || !("content" in entry.message)) continue;
+		if (entry.role === "assistant" && ("stopReason" in entry.message && (entry.message.stopReason === "aborted" || entry.message.stopReason === "error") || "openclawAsyncDelivery" in entry.message)) continue;
+		const content = entry.message.content;
+		const text = normalizeImportedHistoryText(typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((part) => part && typeof part === "object" && "text" in part && typeof part.text === "string" ? [part.text] : []).join("\n") : void 0);
+		if (!text) continue;
+		projected.push({
+			message: entry.message,
+			responseItem: {
+				type: "message",
+				role: entry.role,
+				content: [{
+					type: entry.role === "assistant" ? "output_text" : "input_text",
+					text
+				}]
+			},
+			textBytes: Buffer.byteLength(text, "utf8")
+		});
+	}
+	return selectBoundedCodexHistoryTail(projected).map(({ responseItem }) => responseItem);
+}
+//#endregion
+//#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 { projectCodexUserItemText as a, projectBoundedCodexVisibleSessionHistory as i, codexCatalogHomeId as n, projectBoundedCodexThreadHistory as r, canonicalCodexCatalogHome as t };

package/dist/session-catalog-node-adoption-BUuDYY8R.js

@@ -0,0 +1,182 @@
+import { o as CatalogParamsError } from "./session-catalog-parsing-CdD3JhdM.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-t5TOccct.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 };