@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{session-catalog-index-order-Cc5BzlQr.mjs → session-catalog-index-order-BcQpHks3.mjs}

@@ -1,4 +1,4 @@
-import { V as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+import { t as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-limits-DDxOsQeC.mjs";
 //#region extensions/codex/src/session-catalog-index-order.ts
 function codexCatalogRowRecency(row) {
 	return row.recencyAt ?? row.updatedAt ?? 0;
@@ -21,7 +21,7 @@ var CodexCatalogOrdering = class {
 		this.nextEventOrder = -1;
 	}
 	read(rows) {
-		return this.ordered ??= [...rows.values()].toSorted(compareCodexCatalogRows);
+		return this.ordered ??= [...rows.values()].filter((row) => !row.archived && row.page.sessions.length > 0).toSorted(compareCodexCatalogRows);
 	}
 	invalidate() {
 		this.ordered = void 0;

package/dist/.setup/{session-catalog-index-state-BAuDztHN.mjs → session-catalog-index-state-TeO7EyO-.mjs}

@@ -1,5 +1,6 @@
-import { H as detachCodexCatalogString, O as parseCatalogPage } from "./session-catalog-native-projection-ChV3cCtm.mjs";
-import { i as retainCodexCatalogRow } from "./session-catalog-index-order-Cc5BzlQr.mjs";
+import { v as parseCatalogPage } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { n as detachCodexCatalogString } from "./session-catalog-limits-DDxOsQeC.mjs";
+import { i as retainCodexCatalogRow } from "./session-catalog-index-order-BcQpHks3.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { setImmediate } from "node:timers/promises";
@@ -109,6 +110,9 @@ var CodexCatalogPersistence = class {
 		this.failed = false;
 		this.retired = false;
 	}
+	hasActiveWork() {
+		return this.writing !== void 0 || this.pending.size > 0;
+	}
 	async readSnapshot() {
 		await this.drain();
 		return await readCodexCatalogSnapshot(this.state);

package/dist/.setup/session-catalog-limits-DDxOsQeC.mjs

@@ -0,0 +1,14 @@
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+//#region extensions/codex/src/session-catalog-limits.ts
+var session_catalog_limits_exports = /* @__PURE__ */ __exportAll({
+	CODEX_CATALOG_MAX_ROWS: () => CODEX_CATALOG_MAX_ROWS,
+	CODEX_CATALOG_MAX_STATE_KEY_BYTES: () => 512,
+	detachCodexCatalogString: () => detachCodexCatalogString
+});
+const CODEX_CATALOG_MAX_ROWS = 2e4;
+/** Preserve UTF-16 code units without retaining an oversized source string. */
+function detachCodexCatalogString(value) {
+	return Buffer.from(value, "utf16le").toString("utf16le");
+}
+//#endregion
+export { detachCodexCatalogString as n, session_catalog_limits_exports as r, CODEX_CATALOG_MAX_ROWS as t };

package/dist/.setup/session-catalog-list-request-CvtxrYSe.mjs

@@ -0,0 +1,170 @@
+import { o as CatalogParamsError } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { r as compareCodexCatalogRows } from "./session-catalog-index-order-BcQpHks3.mjs";
+import { i as withTimeout } from "./timeout-CXOfNoaX.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+//#region extensions/codex/src/session-catalog-availability.ts
+var CodexCatalogLoadingError = class extends Error {
+	constructor() {
+		super("Codex session catalog is still loading. Retry shortly.");
+		this.code = "APP_SERVER_UNAVAILABLE";
+	}
+};
+/** One generation promise wakes cold callers; native pages remain owned by the index. */
+var CodexCatalogAvailability = class {
+	constructor() {
+		this.complete = false;
+		this.changed = createDeferred();
+	}
+	begin() {
+		this.failure = void 0;
+	}
+	publish(frontier, complete = false) {
+		if (this.complete) return;
+		if (frontier && (!this.frontier || compareCodexCatalogRows(frontier, this.frontier) > 0)) {
+			const { threadId, updatedAt, recencyAt, sourceOrder } = frontier;
+			this.frontier = {
+				threadId,
+				updatedAt,
+				recencyAt,
+				sourceOrder
+			};
+		}
+		this.complete = complete;
+		this.notify();
+	}
+	fail(error) {
+		this.failure = { error };
+		this.notify();
+	}
+	notify() {
+		const previous = this.changed;
+		this.changed = createDeferred();
+		previous.resolve();
+	}
+	async until(promise, deadline) {
+		const remaining = deadline - performance.now();
+		if (remaining <= 0) throw new CodexCatalogLoadingError();
+		return await withTimeout(promise, remaining, "Codex session catalog is still loading", () => new CodexCatalogLoadingError());
+	}
+	async next(deadline) {
+		if (this.failure) throw this.failure.error;
+		await this.until(this.changed.promise, deadline);
+	}
+};
+//#endregion
+//#region extensions/codex/src/session-catalog-list-request.ts
+const listRequest = new AsyncLocalStorage();
+function currentCodexCatalogListRequest() {
+	return listRequest.getStore();
+}
+/** One foreground request owns its native read budget and source-health outcome. */
+var CodexCatalogListRequest = class {
+	constructor() {
+		this.pages = 0;
+		this.closed = false;
+		this.attempts = /* @__PURE__ */ new Map();
+	}
+	get hasPages() {
+		return this.pages < 20;
+	}
+	deadline(timeoutMs) {
+		this.assertActive();
+		return this.deadlineAt ??= performance.now() + timeoutMs;
+	}
+	constrainDeadline(absolute) {
+		this.assertActive();
+		this.deadlineAt = Math.min(this.deadlineAt ?? absolute, absolute);
+		return this.deadlineAt;
+	}
+	remaining(timeoutMs) {
+		const remaining = Math.min(timeoutMs, this.deadline(timeoutMs) - performance.now());
+		if (remaining <= 0) throw new CodexCatalogLoadingError();
+		return remaining;
+	}
+	assertActive() {
+		if (this.closed) throw new DOMException("Codex session catalog request is closed", "AbortError");
+		if (this.deadlineAt !== void 0 && this.deadlineAt <= performance.now()) throw new CodexCatalogLoadingError();
+	}
+	async run(run) {
+		this.assertActive();
+		const pending = listRequest.run(this, run);
+		const remaining = this.deadlineAt === void 0 ? void 0 : this.deadlineAt - performance.now();
+		if (remaining !== void 0 && remaining <= 0) {
+			pending.catch(() => {});
+			throw new CodexCatalogLoadingError();
+		}
+		const result = remaining === void 0 ? await pending : await withTimeout(pending, remaining, "Codex session catalog is still loading", () => new CodexCatalogLoadingError());
+		this.assertActive();
+		return result;
+	}
+	async read(timeoutMs, read) {
+		const remaining = this.remaining(timeoutMs);
+		if (!this.hasPages) throw new CatalogParamsError("Codex catalog native page budget is exhausted");
+		this.pages++;
+		try {
+			const result = await withTimeout(read(remaining), remaining, "Codex session catalog is still loading", () => new CodexCatalogLoadingError());
+			this.assertActive();
+			return result;
+		} catch (error) {
+			if (!this.closed) this.failure ??= { error };
+			throw error;
+		}
+	}
+	attempt(owner, key, start) {
+		this.assertActive();
+		let attempts = this.attempts.get(owner);
+		const existing = attempts?.get(key);
+		if (existing) return existing;
+		const attempt = start();
+		if (!attempts) {
+			attempts = /* @__PURE__ */ new Map();
+			this.attempts.set(owner, attempts);
+		}
+		attempts.set(key, attempt);
+		return attempt;
+	}
+	resolved() {
+		if (this.failure) {
+			this.rejected(this.failure.error);
+			return;
+		}
+		this.settle((attempt) => attempt.resolved());
+	}
+	rejected(error) {
+		if (error instanceof Error && error.name === "AbortError") {
+			this.close();
+			return;
+		}
+		const reason = this.failure?.error ?? error;
+		this.settle((attempt) => attempt.rejected(reason));
+	}
+	close() {
+		this.settle((attempt) => attempt.abandoned());
+	}
+	settle(settle) {
+		if (this.closed) return;
+		this.closed = true;
+		for (const attempts of this.attempts.values()) for (const attempt of attempts.values()) if (attempt.allowed) settle(attempt);
+		this.attempts.clear();
+		this.failure = void 0;
+	}
+};
+async function withCodexCatalogListRequest(run) {
+	const current = currentCodexCatalogListRequest();
+	if (current) {
+		current.assertActive();
+		return await run(current);
+	}
+	const scope = new CodexCatalogListRequest();
+	try {
+		const result = await scope.run(() => run(scope));
+		scope.resolved();
+		return result;
+	} catch (error) {
+		scope.rejected(error);
+		throw error;
+	}
+}
+//#endregion
+export { CodexCatalogLoadingError as a, CodexCatalogAvailability as i, currentCodexCatalogListRequest as n, withCodexCatalogListRequest as r, CodexCatalogListRequest as t };

package/dist/.setup/session-catalog-native-projection-DjhwGL6x.mjs

@@ -0,0 +1,178 @@
+import { D as selectCodexCatalogPreviewInput, c as MAX_CWD_LENGTH, d as boundedCatalogString, k as truncateCodexCatalogPreview } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { n as defineCodexBuildState } from "./build-state-Da1_z0kd.mjs";
+import { n as detachCodexCatalogString } from "./session-catalog-limits-DDxOsQeC.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+//#region extensions/codex/src/session-catalog-source.ts
+function hasLiveCodexCatalogSource(sources) {
+	for (const source of sources) if (!source.closed) return true;
+	return false;
+}
+const getSources = defineCodexBuildState("openclaw.codexCatalogSources", () => ({
+	clients: /* @__PURE__ */ new WeakMap(),
+	values: /* @__PURE__ */ new WeakMap()
+}));
+const getEphemeralObservers = defineCodexBuildState("openclaw.codexCatalogEphemeralObservers", () => /* @__PURE__ */ new WeakMap());
+/** A passive lifetime fact; the token never retains its client or a lease. */
+function codexCatalogSourceForClient(client) {
+	const { clients } = getSources();
+	let source = clients.get(client);
+	if (!source) {
+		source = { closed: false };
+		clients.set(client, source);
+	}
+	return source;
+}
+function closeCodexCatalogClientSource(client) {
+	const { clients } = getSources();
+	const source = clients.get(client);
+	if (source) {
+		source.closed = true;
+		getEphemeralObservers().delete(source);
+	} else clients.set(client, { closed: true });
+}
+/** The catalog observer is bound once per physical source and released on closure. */
+function observeCodexCatalogEphemeralThreads(source, observer) {
+	getEphemeralObservers().set(source, observer);
+}
+function getCodexCatalogSource(value) {
+	return value !== null && typeof value === "object" ? getSources().values.get(value) : void 0;
+}
+function setCodexCatalogSource(value, source) {
+	if (source) getSources().values.set(value, source);
+	return value;
+}
+/** Source attribution survives projection without becoming serialized row data. */
+function copyCodexCatalogSource(from, to) {
+	return setCodexCatalogSource(to, getCodexCatalogSource(from));
+}
+/** Stamp the final decoded objects, including any bounded catalog DTO replacement. */
+function recordCodexCatalogResponseSource(method, result, source) {
+	if (result === null || typeof result !== "object") return;
+	if (method === "thread/list" && "data" in result && Array.isArray(result.data)) {
+		setCodexCatalogSource(result, source);
+		for (const thread of result.data) if (thread !== null && typeof thread === "object") setCodexCatalogSource(thread, source);
+	} else if ((method === "thread/read" || method === "thread/start" || method === "thread/fork" || method === "thread/resume") && "thread" in result && result.thread !== null && typeof result.thread === "object") {
+		setCodexCatalogSource(result, source);
+		setCodexCatalogSource(result.thread, source);
+		if ("ephemeral" in result.thread && result.thread.ephemeral === true && "id" in result.thread && typeof result.thread.id === "string") getEphemeralObservers().get(source)?.(result.thread.id);
+	}
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-native-projection.ts
+var session_catalog_native_projection_exports = /* @__PURE__ */ __exportAll({
+	CODEX_CATALOG_NATIVE_PAGE_LIMIT: () => 64,
+	projectCodexCatalogNativeResponse: () => projectCodexCatalogNativeResponse,
+	projectCodexCatalogNativeThread: () => projectCodexCatalogNativeThread,
+	reuseCodexCatalogPreview: () => reuseCodexCatalogPreview
+});
+const CODEX_CATALOG_NATIVE_PAGE_LIMIT = 64;
+const STRING_FIELDS = [
+	[
+		"name",
+		500,
+		"truncate"
+	],
+	[
+		"cwd",
+		MAX_CWD_LENGTH,
+		"omit"
+	],
+	[
+		"modelProvider",
+		500,
+		"truncate"
+	],
+	[
+		"cliVersion",
+		500,
+		"truncate"
+	]
+];
+/** Drop unused native fields before catalog-owned asynchronous work can retain them. */
+function projectCodexCatalogNativeThread(thread, sanitize, cachedPreview) {
+	if (!isJsonObject(thread)) throw new Error("Codex catalog response contains an invalid thread");
+	const id = boundedCatalogString(thread.id, 256);
+	if (!id) throw new Error("Codex catalog response contains an invalid thread id");
+	const row = {
+		id,
+		projectId: boundedCatalogString(thread.projectId, 256, "omit") ?? null
+	};
+	const sessionId = boundedCatalogString(thread.sessionId, 256, "omit");
+	if (sessionId) row.sessionId = sessionId;
+	if (thread.ephemeral === true) return copyCodexCatalogSource(thread, {
+		...row,
+		ephemeral: true
+	});
+	for (const [field, limit, overflow] of STRING_FIELDS) {
+		const value = thread[field];
+		const bounded = boundedCatalogString(value, limit, overflow);
+		if (value === null || bounded !== void 0) row[field] = bounded ?? null;
+	}
+	if (typeof thread.path === "string") {
+		if (thread.path.length > 4096) throw new Error("Codex catalog rollout path exceeds its length limit");
+		row.path = detachCodexCatalogString(thread.path);
+	} else if (thread.path === null) row.path = null;
+	if (typeof thread.originator === "string") row.originator = detachCodexCatalogString(thread.originator.slice(0, 500));
+	for (const field of [
+		"createdAt",
+		"updatedAt",
+		"recencyAt"
+	]) {
+		const value = thread[field];
+		if (value === null || typeof value === "number" && Number.isFinite(value)) row[field] = value;
+	}
+	const rawPreview = thread.preview;
+	const preview = reuseCodexCatalogPreview(row, typeof rawPreview === "string" ? Boolean(rawPreview) : void 0, cachedPreview);
+	if (preview !== void 0) row.preview = preview;
+	else if (typeof rawPreview === "string") row.preview = rawPreview ? truncateCodexCatalogPreview(selectCodexCatalogPreviewInput(rawPreview), sanitize) : "";
+	else if (rawPreview === null) row.preview = null;
+	const source = typeof thread.source === "string" ? detachCodexCatalogString(thread.source.slice(0, 500)) : void 0;
+	if (source === "cli" || source === "vscode" || source === "exec" || source === "appServer" || source === "unknown") row.source = source;
+	else if (isJsonObject(thread.source) && typeof thread.source.custom === "string" && thread.source.custom.length <= 500) row.source = { custom: detachCodexCatalogString(thread.source.custom) };
+	if (isJsonObject(thread.gitInfo)) {
+		const branch = boundedCatalogString(thread.gitInfo.branch, 500, "truncate");
+		if (branch !== void 0) row.gitInfo = { branch };
+	}
+	if (isJsonObject(thread.status)) {
+		const type = boundedCatalogString(thread.status.type, 64);
+		if (type === "active" || type === "idle" || type === "notLoaded" || type === "systemError") {
+			const activeFlags = type === "active" && Array.isArray(thread.status.activeFlags) ? thread.status.activeFlags.slice(0, 16).flatMap((flag) => {
+				const bounded = boundedCatalogString(flag, 128, "omit");
+				return bounded ? [bounded] : [];
+			}) : void 0;
+			row.status = type === "active" ? {
+				type,
+				...activeFlags ? { activeFlags } : {}
+			} : { type };
+		}
+	}
+	return copyCodexCatalogSource(thread, row);
+}
+/** Keep only the admitted prefix before an RPC promise retains its response. */
+function projectCodexCatalogNativeResponse(response, sanitize, cachedPreview, remainingRows = 64) {
+	if (!Array.isArray(response.data) || response.data.length > 64) throw new Error("Codex catalog response exceeds its native page limit");
+	const limit = Number.isFinite(remainingRows) ? Math.max(0, Math.min(64, Math.floor(remainingRows))) : 0;
+	const page = { data: response.data.slice(0, limit).map((thread) => projectCodexCatalogNativeThread(thread, sanitize, cachedPreview)) };
+	for (const field of ["nextCursor", "backwardsCursor"]) {
+		const value = response[field];
+		if (value === null) page[field] = null;
+		else if (value !== void 0) {
+			if (typeof value !== "string" || value.length > 4096) throw new Error("Codex catalog response contains an invalid cursor");
+			page[field] = detachCodexCatalogString(value);
+		}
+	}
+	return page;
+}
+/** Reuse resident text without transferring a cache or an unbounded native preview. */
+function reuseCodexCatalogPreview(thread, rawPreviewNonempty, cachedPreview) {
+	const preview = cachedPreview?.({
+		id: thread.id,
+		path: typeof thread.path === "string" ? thread.path : null,
+		updatedAt: typeof thread.updatedAt === "number" ? thread.updatedAt : null,
+		recencyAt: typeof thread.recencyAt === "number" ? thread.recencyAt : null
+	});
+	return preview !== void 0 && preview.length <= 500 && (rawPreviewNonempty === void 0 || rawPreviewNonempty === Boolean(preview)) ? preview : void 0;
+}
+//#endregion
+export { session_catalog_native_projection_exports as a, copyCodexCatalogSource as c, observeCodexCatalogEphemeralThreads as d, recordCodexCatalogResponseSource as f, reuseCodexCatalogPreview as i, getCodexCatalogSource as l, projectCodexCatalogNativeResponse as n, closeCodexCatalogClientSource as o, setCodexCatalogSource as p, projectCodexCatalogNativeThread as r, codexCatalogSourceForClient as s, CODEX_CATALOG_NATIVE_PAGE_LIMIT as t, hasLiveCodexCatalogSource as u };

package/dist/.setup/{session-catalog-node-adoption-BVRsYOSh.mjs → session-catalog-node-adoption-DgXvSGu0.mjs}

@@ -1,37 +1,35 @@
-import { g as CatalogParamsError } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+import { o as CatalogParamsError } from "./session-catalog-parsing-CPGaPYr-.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
-import { listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 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);
-	}
-}
+const catalogSessionActions = new KeyedAsyncQueue();
 function adoptionSessionKeyRest(sessionKey) {
 	const trimmed = sessionKey.trim();
 	return parseAgentSessionKey(trimmed)?.rest ?? trimmed;
 }
-function nodeAdoptionSessionKey(hostId, threadId) {
-	const source = JSON.stringify([hostId, threadId]);
+function nodeAdoptedSourceKey(hostId, threadId, sourceHomeId) {
+	return sessionCatalogAdoptedSourceKey(JSON.stringify([hostId, sourceHomeId]), threadId);
+}
+function nodeAdoptionSessionKey(hostId, threadId, sourceHomeId) {
+	const source = JSON.stringify([
+		hostId,
+		sourceHomeId,
+		threadId
+	]);
 	return sessionCatalogAdoptedSessionKey(CODEX_NODE_SESSION_KEY_PREFIX, source);
 }
 function readNodeSessionMarker(entry) {
 	const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : void 0;
 	const marker = codex && isRecord(codex.sessionCatalog) ? codex.sessionCatalog : void 0;
-	if (!marker || typeof marker.sourceHostId !== "string" || !marker.sourceHostId.startsWith("node:") || typeof marker.sourceThreadId !== "string" || !marker.sourceThreadId.trim() || typeof marker.nodeId !== "string" || !marker.nodeId.trim()) return;
+	if (!marker || typeof marker.sourceHostId !== "string" || !marker.sourceHostId.startsWith("node:") || typeof marker.sourceThreadId !== "string" || !marker.sourceThreadId.trim() || typeof marker.nodeId !== "string" || !marker.nodeId.trim() || marker.sourceHomeId !== void 0 && (typeof marker.sourceHomeId !== "string" || !marker.sourceHomeId.trim() || marker.sourceHomeId.length > 256)) return;
 	return {
 		sourceHostId: marker.sourceHostId,
 		sourceThreadId: marker.sourceThreadId,
+		...typeof marker.sourceHomeId === "string" ? { sourceHomeId: marker.sourceHomeId } : {},
 		nodeId: marker.nodeId,
 		...marker.initializing === true ? { initializing: true } : {}
 	};
@@ -46,8 +44,8 @@ function listNodeAdoptedSessionEntries(params) {
 	})) {
 		const marker = readNodeSessionMarker(entry);
 		const sessionId = entry.sessionId?.trim();
-		if (!marker || marker.initializing === true && params.includeInitializing !== true || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !sessionId || adoptionSessionKeyRest(sessionKey) !== nodeAdoptionSessionKey(marker.sourceHostId, marker.sourceThreadId) || marker.sourceHostId !== `node:${marker.nodeId}`) continue;
-		const sourceKey = sessionCatalogAdoptedSourceKey(marker.sourceHostId, marker.sourceThreadId);
+		if (!marker || !marker.sourceHomeId || marker.initializing === true && params.includeInitializing !== true || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !sessionId || adoptionSessionKeyRest(sessionKey) !== nodeAdoptionSessionKey(marker.sourceHostId, marker.sourceThreadId, marker.sourceHomeId) || marker.sourceHostId !== `node:${marker.nodeId}`) continue;
+		const sourceKey = nodeAdoptedSourceKey(marker.sourceHostId, marker.sourceThreadId, marker.sourceHomeId);
 		if (adopted.has(sourceKey)) throw new Error(`multiple OpenClaw sessions adopt Codex thread ${marker.sourceThreadId} on ${marker.sourceHostId}`);
 		adopted.set(sourceKey, {
 			key: sessionKey,
@@ -59,12 +57,13 @@ function listNodeAdoptedSessionEntries(params) {
 	return adopted;
 }
 function findNodeAdoptedSessionEntry(params) {
-	return listNodeAdoptedSessionEntries(params).get(sessionCatalogAdoptedSourceKey(params.hostId, params.threadId));
+	return listNodeAdoptedSessionEntries(params).get(nodeAdoptedSourceKey(params.hostId, params.threadId, params.sourceHomeId));
 }
 function nodeSessionMarker(params) {
 	return {
 		sourceHostId: params.hostId,
 		sourceThreadId: params.threadId,
+		sourceHomeId: params.sourceHomeId,
 		nodeId: params.nodeId,
 		...params.initializing === true ? { initializing: true } : {}
 	};
@@ -79,7 +78,7 @@ async function finalizeNodeAdoptedSession(params) {
 			preserveActivity: true,
 			update: (entry) => {
 				const current = readNodeSessionMarker(entry);
-				if (entry.sessionId?.trim() !== params.adopted.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !current || current.sourceHostId !== params.marker.sourceHostId || current.sourceThreadId !== params.marker.sourceThreadId || current.nodeId !== params.marker.nodeId) throw changedError();
+				if (entry.sessionId?.trim() !== params.adopted.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !current || current.sourceHostId !== params.marker.sourceHostId || current.sourceThreadId !== params.marker.sourceThreadId || current.sourceHomeId !== params.marker.sourceHomeId || current.nodeId !== params.marker.nodeId) throw changedError();
 				if (current.initializing !== true) return {
 					archivedAt: void 0,
 					archivedBy: void 0,
@@ -106,25 +105,28 @@ async function finalizeNodeAdoptedSession(params) {
 			readConsistency: "latest"
 		});
 		const current = currentEntry ? readNodeSessionMarker(currentEntry) : void 0;
-		if (currentEntry?.sessionId?.trim() === params.adopted.sessionId && current?.initializing !== true && current?.sourceHostId === params.marker.sourceHostId && current.sourceThreadId === params.marker.sourceThreadId && current.nodeId === params.marker.nodeId) return;
+		if (currentEntry?.sessionId?.trim() === params.adopted.sessionId && current?.initializing !== true && current?.sourceHostId === params.marker.sourceHostId && current.sourceThreadId === params.marker.sourceThreadId && current.sourceHomeId === params.marker.sourceHomeId && current.nodeId === params.marker.nodeId) return;
 		throw error;
 	}
 	if (!finalized) throw changedError();
 }
 async function createOrReuseNodeAdoptedSession(params) {
-	const existing = findNodeAdoptedSessionEntry({
+	const lookup = {
 		agentId: params.agentId,
 		config: params.config,
 		runtime: params.api.runtime,
 		hostId: params.hostId,
 		threadId: params.record.threadId,
+		sourceHomeId: params.sourceHomeId,
 		includeInitializing: true
-	});
+	};
+	const existing = findNodeAdoptedSessionEntry(lookup);
 	if (existing) return existing;
 	const initializingMarker = {
 		...nodeSessionMarker({
 			hostId: params.hostId,
 			threadId: params.record.threadId,
+			sourceHomeId: params.sourceHomeId,
 			nodeId: params.nodeId
 		}),
 		initializing: true
@@ -132,7 +134,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 	try {
 		const created = await params.api.runtime.agent.session.createSessionEntry({
 			cfg: params.config,
-			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId),
+			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId, params.sourceHomeId),
 			agentId: params.agentId,
 			recoverMatchingInitialEntry: true,
 			displayName: params.record.name ?? void 0,
@@ -144,7 +146,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 			},
 			afterCreate: async (entry) => {
 				const storePath = resolveStorePath(params.config.session?.store, { agentId: entry.agentId });
-				const { importCodexThreadHistoryToTranscript } = await import("./transcript-mirror-D4qp_leP.mjs").then((n) => n.a);
+				const { importCodexThreadHistoryToTranscript } = await import("./transcript-mirror-kxmCYsuF.mjs").then((n) => n.a);
 				await importCodexThreadHistoryToTranscript({
 					thread: params.history.thread,
 					throughTurnId: params.history.throughTurnId,
@@ -166,17 +168,10 @@ async function createOrReuseNodeAdoptedSession(params) {
 			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
-		});
+		const raced = findNodeAdoptedSessionEntry(lookup);
 		if (raced) return raced;
 		throw error;
 	}
 }
 //#endregion
-export { adoptionSessionKeyRest, continueOperations, createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, listNodeAdoptedSessionEntries, nodeSessionMarker, runSessionActionExclusive };
+export { CODEX_NODE_SESSION_KEY_PREFIX, adoptionSessionKeyRest, catalogSessionActions, createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, listNodeAdoptedSessionEntries, nodeAdoptedSourceKey, nodeSessionMarker, readNodeSessionMarker };