@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{session-catalog-adoption-CR_whkEW.mjs → session-catalog-adoption-BU_pHWG7.mjs}

@@ -1,12 +1,13 @@
-import { p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
-import { F as requireBoundThread, g as CatalogParamsError, x as boundedCatalogString } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+import { T as requireBoundThread, d as boundedCatalogString, o as CatalogParamsError } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
 import { n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.mjs";
-import { i as reclaimCurrentCodexSessionGeneration } from "./session-binding-_0W_fHRr.mjs";
-import { adoptionSessionKeyRest, continueOperations, runSessionActionExclusive } from "./session-catalog-node-adoption-BVRsYOSh.mjs";
+import { i as reclaimCurrentCodexSessionGeneration } from "./session-binding-DGCYAfvD.mjs";
+import { adoptionSessionKeyRest, catalogSessionActions } from "./session-catalog-node-adoption-DgXvSGu0.mjs";
 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 continueOperations = /* @__PURE__ */ new Map();
 const boundCatalogSessionId = (value) => boundedCatalogString(value, 256);
 function requireIdleThread(thread, action) {
 	if (thread.status?.type === "idle" || action === "archive" && thread.status?.type === "notLoaded") return;
@@ -32,36 +33,68 @@ function readCodexSupervisionMarker(entry) {
 	};
 }
 async function listAdoptedSessionEntries(params) {
-	const adopted = /* @__PURE__ */ new Map();
-	for (const { agentId, entry, sessionKey } of listSessionCatalogEntries({
+	const entries = listSessionCatalogEntries({
 		...params.agentId ? { agentId: params.agentId } : {},
 		config: params.config ?? {},
 		runtime: params.runtime,
 		sessionEntries: params.sessionEntries
-	})) {
+	});
+	const candidateForEntry = ({ agentId, entry, sessionKey }) => {
 		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;
+		if (!sessionKeyRest.startsWith(CODEX_SUPERVISION_SESSION_KEY_PREFIX) || !marker || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) return;
 		const sessionId = entry.sessionId?.trim();
-		if (!sessionId) continue;
-		const binding = params.bindingStore.read(sessionBindingIdentity({
-			sessionId,
+		if (!sessionId) return;
+		return {
+			agentId,
 			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,
+			sessionKeyRest,
 			sessionId,
-			agentId,
-			boundThreadId
-		});
+			marker,
+			identity: sessionBindingIdentity({
+				sessionId,
+				sessionKey,
+				config: params.config
+			})
+		};
+	};
+	function* candidates() {
+		for (const entry of entries) {
+			const candidate = candidateForEntry(entry);
+			if (candidate) yield candidate;
+		}
+	}
+	const collect = (selected, readBinding = (identity) => params.bindingStore.read(identity)) => {
+		const adopted = /* @__PURE__ */ new Map();
+		for (const { agentId, sessionKey, sessionKeyRest, sessionId, marker, identity } of selected) {
+			const binding = readBinding(identity);
+			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;
+	};
+	if (!params.bindingStore.readMany) return collect(candidates());
+	let prepared;
+	try {
+		prepared = [...candidates()];
+	} catch {
+		return collect(candidates());
+	}
+	const bindings = params.bindingStore.readMany(prepared.map(({ identity }) => identity));
+	try {
+		return collect(prepared, () => bindings.next().value);
+	} finally {
+		bindings.return(void 0);
 	}
-	return adopted;
 }
 async function findAdoptedSessionEntry(params) {
 	const adopted = await listAdoptedSessionEntries(params);
@@ -119,7 +152,7 @@ async function createOrReuseAdoptedSession(params) {
 			sourceThreadId: params.sourceThread.id,
 			...params.sourceHomeId ? { sourceHomeId: params.sourceHomeId } : {}
 		};
-		const { createImportedCodexSession } = await import("./session-history-import-JHXT5Xfi.mjs");
+		const { createImportedCodexSession } = await import("./session-history-import-WhX-X33a.mjs");
 		const created = await createImportedCodexSession({
 			runtime: params.api.runtime,
 			bindingStore: params.bindingStore,
@@ -239,7 +272,7 @@ async function continueLocalCodexSession(params) {
 		...params,
 		control
 	});
-	const operation = runSessionActionExclusive(sourceKey, async () => params.control.withPinnedConnection(run));
+	const operation = catalogSessionActions.enqueue(sourceKey, async () => params.control.withPinnedConnection(run));
 	continueOperations.set(operationKey, operation);
 	try {
 		return await operation;

package/dist/.setup/{session-catalog-archive-CwZaPacf.mjs → session-catalog-archive-spHfihri.mjs}

@@ -1,9 +1,9 @@
-import { p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
-import { g as CatalogParamsError } from "./session-catalog-native-projection-ChV3cCtm.mjs";
-import { t as assertCodexArchiveDescendantsUnowned } from "./thread-archive-guard-jmecf6OJ.mjs";
-import "./session-binding-_0W_fHRr.mjs";
-import { runSessionActionExclusive } from "./session-catalog-node-adoption-BVRsYOSh.mjs";
-import { isAdoptionSessionKeyForThread, requireIdleThread } from "./session-catalog-adoption-CR_whkEW.mjs";
+import { o as CatalogParamsError } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
+import { t as assertCodexArchiveDescendantsUnowned } from "./thread-archive-guard-C9frICzX.mjs";
+import "./session-binding-DGCYAfvD.mjs";
+import { catalogSessionActions } from "./session-catalog-node-adoption-DgXvSGu0.mjs";
+import { isAdoptionSessionKeyForThread, requireIdleThread } from "./session-catalog-adoption-BU_pHWG7.mjs";
 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
@@ -26,7 +26,7 @@ function assertNoPendingSupervisionBranch(params) {
 }
 /** 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 catalogSessionActions.enqueue(sessionCatalogAdoptedSourceKey(params.hostId ?? "gateway:local", params.threadId), async () => {
 		return await params.bindingStore.withThreadArchiveFence(async () => {
 			const run = async (control) => {
 				assertNoPendingSupervisionBranch(params);

package/dist/.setup/session-catalog-events-DePDzzjc.mjs

@@ -0,0 +1,139 @@
+import { c as MAX_CWD_LENGTH, d as boundedCatalogString } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { n as defineCodexBuildState } from "./build-state-Da1_z0kd.mjs";
+import { r as inferCodexAppServerConnectionClass } from "./config-security-CE-FcGw9.mjs";
+import { n as resolveCodexAppServerLocalHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import { n as codexCatalogHomeIdFromCanonicalPath } from "./session-catalog-home-id-vlih0B_g.mjs";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BL9B5H0L.mjs";
+import { d as observeCodexCatalogEphemeralThreads, r as projectCodexCatalogNativeThread, s as codexCatalogSourceForClient } from "./session-catalog-native-projection-DjhwGL6x.mjs";
+import { createHash } from "node:crypto";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region extensions/codex/src/session-catalog-events.ts
+const getCatalogEvents = defineCodexBuildState("openclaw.codexCatalogEvents", () => ({
+	listeners: /* @__PURE__ */ new Map(),
+	clients: /* @__PURE__ */ new WeakMap()
+}));
+const CATALOG_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
+	"thread/started",
+	"turn/started",
+	"turn/completed",
+	"thread/archived",
+	"thread/deleted",
+	"thread/unarchived",
+	"thread/reverted",
+	"thread/name/updated",
+	"thread/status/changed",
+	"thread/settings/updated"
+]);
+function notifyEphemeralThread(homeKey, rawId) {
+	const id = boundedCatalogString(rawId, 256);
+	if (!id) return;
+	for (const listener of getCatalogEvents().listeners.get(homeKey) ?? []) try {
+		listener.onEphemeralThread?.(id);
+	} catch (error) {
+		embeddedAgentLog.warn("Codex catalog ephemeral observer failed", { error });
+	}
+}
+/** Uses prepared local identity or resolves it once during client/index startup. */
+async function codexCatalogResidentHomeKey(params) {
+	if (inferCodexAppServerConnectionClass(params.startOptions) === "remote") {
+		const fingerprint = buildCodexAppServerConnectionFingerprint({
+			start: params.startOptions,
+			connectionClass: "remote"
+		}, params.agentDir);
+		return `remote:${createHash("sha256").update(fingerprint).digest("hex")}`;
+	}
+	if (params.sourceHomeId) return params.sourceHomeId;
+	const home = path.resolve(params.runtimeIdentity?.codexHome ?? resolveCodexAppServerLocalHomeDir(params.startOptions, params.agentDir));
+	return codexCatalogHomeIdFromCanonicalPath(await fs.realpath(home).catch(() => home));
+}
+function subscribeCodexCatalogEvents(homeKey, listener, callbacks = {}) {
+	const { listeners } = getCatalogEvents();
+	let homeListeners = listeners.get(homeKey);
+	if (!homeListeners) {
+		homeListeners = /* @__PURE__ */ new Set();
+		listeners.set(homeKey, homeListeners);
+	}
+	const subscription = {
+		notify: listener,
+		...callbacks
+	};
+	homeListeners.add(subscription);
+	return () => {
+		homeListeners.delete(subscription);
+		if (homeListeners.size === 0 && listeners.get(homeKey) === homeListeners) listeners.delete(homeKey);
+	};
+}
+/** Observes physical clients without extending their lease or native thread lifetime. */
+function observeCodexCatalogClient(client, params) {
+	const state = getCatalogEvents();
+	const existing = state.clients.get(client);
+	if (existing) return existing.then(() => void 0);
+	const observing = (async () => {
+		const homeKey = await codexCatalogResidentHomeKey({
+			...params,
+			runtimeIdentity: client.getRuntimeIdentity()
+		});
+		if (client.getCloseError()) return;
+		const source = codexCatalogSourceForClient(client);
+		observeCodexCatalogEphemeralThreads(source, notifyEphemeralThread.bind(void 0, homeKey));
+		const notifyLifecycle = (callback) => {
+			for (const listener of state.listeners.get(homeKey) ?? []) try {
+				listener[callback]?.(source);
+			} catch (error) {
+				embeddedAgentLog.warn("Codex catalog lifecycle observer failed", {
+					callback,
+					error
+				});
+			}
+		};
+		const readThread = async (threadId) => (await client.request("thread/read", {
+			threadId,
+			includeTurns: false
+		}, {
+			timeoutMs: 6e4,
+			catalogPreview: true
+		})).thread;
+		const stopNotifications = client.addNotificationHandler((event) => {
+			if (!CATALOG_NOTIFICATION_METHODS.has(event.method)) return;
+			for (const listener of state.listeners.get(homeKey) ?? []) listener.notify(event, readThread, source);
+		});
+		const stopClose = client.addCloseHandler(() => {
+			stopNotifications();
+			stopClose();
+			notifyLifecycle("onClose");
+		});
+		if (inferCodexAppServerConnectionClass(params.startOptions) === "remote") notifyLifecycle("onRemoteReady");
+		return {
+			homeKey,
+			source
+		};
+	})();
+	state.clients.set(client, observing);
+	return observing.then(() => void 0);
+}
+/** Acknowledged resume settings may differ from the response thread's persisted metadata. */
+async function publishCodexCatalogResume(client, response, sanitize) {
+	try {
+		const prepared = {
+			thread: projectCodexCatalogNativeThread(response.thread, sanitize),
+			cwd: boundedCatalogString(response.cwd, MAX_CWD_LENGTH),
+			modelProvider: boundedCatalogString(response.modelProvider, 500, "truncate")
+		};
+		const state = getCatalogEvents();
+		const binding = await state.clients.get(client);
+		if (!binding || binding.source.closed) return;
+		await Promise.all(Array.from(state.listeners.get(binding.homeKey) ?? [], async (listener) => {
+			try {
+				await listener.onResume?.(prepared, binding.source);
+			} catch (error) {
+				embeddedAgentLog.warn("Codex catalog resume observer failed", { error });
+			}
+		}));
+	} catch (error) {
+		embeddedAgentLog.warn("Codex catalog resume publication failed", { error });
+	}
+}
+//#endregion
+export { subscribeCodexCatalogEvents as i, observeCodexCatalogClient as n, publishCodexCatalogResume as r, codexCatalogResidentHomeKey as t };

package/dist/.setup/session-catalog-home-id-vlih0B_g.mjs

@@ -0,0 +1,22 @@
+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 codexCatalogHomeIdFromCanonicalPath(canonicalCodexCatalogHome(codexHome));
+}
+/** Hashes lifecycle-prepared paths without repeating filesystem discovery. */
+function codexCatalogHomeIdFromCanonicalPath(codexHome) {
+	return createHash("sha256").update("openclaw:codex-session-catalog-home:v1\0").update(codexHome).digest("hex");
+}
+//#endregion
+export { codexCatalogHomeIdFromCanonicalPath as n, codexCatalogHomeId as t };