@openclaw/codex 2026.8.1-beta.2 → 2026.8.1-beta.3

package/dist/{session-catalog-xwNi_SDM.js → session-catalog-ezP_UcRM.js}

@@ -1,32 +1,37 @@
-import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity, g as resolveCodexAppServerRuntimeOptions, y as resolveCodexSupervisionAppServerRuntimeOptions } from "./session-binding-DPxIvMgE.js";
-import { R as resolveCodexAppServerClientInstanceId, _ as withTimeout, a as getLeasedSharedCodexAppServerClient, at as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, ct as isJsonObject, dt as resolveCodexAppServerLocalHomeDir, it as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, l as releaseLeasedSharedCodexAppServerClient, z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
-import { n as assertCodexThreadForkParams } from "./protocol-validators-B4F7L8Rf.js";
-import { n as listCodexAppServerModels } from "./models-BFlpn1Ex.js";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-C3H2CVp6.js";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-B9gGgnJS.js";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-CybGI1oz.js";
-import { r as formatCodexDisplayText } from "./command-formatters-B1AEz8ZA.js";
+import { h as readCodexPluginConfig, s as resolveCodexSupervisionAppServerRuntimeOptions, x as resolveCodexAppServerUserHomeDir } from "./config-CpNeo5AE.js";
+import { B as CodexAppServerRpcError, R as resolveCodexAppServerClientInstanceId, _ as withTimeout, a as getLeasedSharedCodexAppServerClient, ft as resolveCodexAppServerHomeDir, l as releaseLeasedSharedCodexAppServerClient, ot as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, pt as resolveCodexAppServerLocalHomeDir, st as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity } from "./session-binding-BTrLf9Qm.js";
+import { n as assertCodexThreadForkParams } from "./protocol-validators-VAVyEnDp.js";
+import { i as replaceCodexCatalogConnectionHomes, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DMNQ8Zi8.js";
+import { n as codexCatalogHomeId, t as canonicalCodexCatalogHome } from "./session-catalog-home-id-BNwAJ9D7.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-BU0_LKAL.js";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-CH3K57v4.js";
+import { r as formatCodexDisplayText } from "./command-formatters-D0nZ3qtd.js";
 import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-CW2GuupV.js";
-import { i as withCodexAppServerJsonClient, n as requestCodexAppServerClientJson, r as requestCodexAppServerJson } from "./request-BRl5_UfX.js";
-import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-CrIFX06J.js";
+import { n as requestCodexAppServerClientJson } from "./request-DSK0W6YI.js";
+import { t as codexControlRequest } from "./command-rpc-xUIIonsO.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-D_2npHlA.js";
 import { asFiniteNumber, isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 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 { createHash } from "node:crypto";
+import fsSync from "node:fs";
 import os from "node:os";
-import { listAgentIds, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
-import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { listAgentIds, resolveAgentDir, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { runCommandBuffered } from "openclaw/plugin-sdk/process-runtime";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 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 { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
+import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import process$1 from "node:process";
-import { listSessionCatalogEntries } from "openclaw/plugin-sdk/session-catalog";
+import { createSessionCatalogAdoptionCoordinator, listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 import { decodeNodePtyResumeParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
+import { createZstdDecompress } from "node:zlib";
 //#region extensions/codex/src/jsonl-lines.ts
 const JSONL_STREAM_THRESHOLD_BYTES = 4 * 1024 * 1024;
 const JSONL_READ_CHUNK_BYTES = 1024 * 1024;
@@ -132,11 +137,6 @@ const MAX_SESSION_LIMIT = 50;
 const DEFAULT_RESUME_TIMEOUT_MS = 20 * 6e4;
 const SESSION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
 const activeResumeSessions = /* @__PURE__ */ new Set();
-const DEFAULT_RESUME_SPAWN_RUNTIME = {
-	platform: process$1.platform,
-	env: process$1.env,
-	execPath: process$1.execPath
-};
 function createCodexCliSessionNodeHostCommands() {
 	return [{
 		command: CODEX_CLI_SESSIONS_LIST_COMMAND,
@@ -272,7 +272,7 @@ async function resumeLocalCodexCliSession(paramsJSON) {
 async function runCodexExecResume(params) {
 	const outputPath = path.join(await fs.mkdtemp(path.join(resolvePreferredOpenClawTmpDir(), "openclaw-codex-cli-")), "last-message.txt");
 	try {
-		const invocation = resolveCodexCliResumeSpawnInvocation([
+		const args = [
 			"exec",
 			"resume",
 			"--skip-git-repo-check",
@@ -280,45 +280,27 @@ async function runCodexExecResume(params) {
 			outputPath,
 			params.sessionId,
 			"-"
-		], {
+		];
+		const invocation = materializeWindowsSpawnProgram(resolveWindowsSpawnProgram({
+			command: "codex",
 			platform: process$1.platform,
 			env: process$1.env,
-			execPath: process$1.execPath
-		});
-		const child = spawn(invocation.command, invocation.args, {
+			execPath: process$1.execPath,
+			packageName: "@openai/codex"
+		}), args);
+		const result = await runCommandBuffered([invocation.command, ...invocation.argv], {
 			cwd: params.cwd || process$1.cwd(),
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
+			input: params.prompt,
 			env: process$1.env,
-			shell: invocation.shell,
-			windowsHide: invocation.windowsHide
-		});
-		const stdout = [];
-		const stderr = [];
-		let timedOut = false;
-		let forceKillTimeout;
-		const timeout = setTimeout(() => {
-			timedOut = true;
-			child.kill("SIGTERM");
-			forceKillTimeout = setTimeout(() => child.kill("SIGKILL"), 2e3);
-			forceKillTimeout.unref?.();
-		}, params.timeoutMs);
-		child.stdout.on("data", (chunk) => stdout.push(chunk));
-		child.stderr.on("data", (chunk) => stderr.push(chunk));
-		child.stdin.end(params.prompt);
-		const exitCode = await new Promise((resolve, reject) => {
-			child.on("error", reject);
-			child.on("exit", (code) => resolve(code));
-		}).finally(() => {
-			clearTimeout(timeout);
-			if (forceKillTimeout) clearTimeout(forceKillTimeout);
+			killGraceMs: 2e3,
+			killProcessTree: false,
+			terminateOnOutputError: true,
+			timeoutMs: params.timeoutMs
 		});
-		if (timedOut) throw new Error(`codex exec resume timed out after ${String(params.timeoutMs)}ms`);
-		if (exitCode !== 0) {
-			const message = Buffer.concat(stderr).toString("utf8").trim() || Buffer.concat(stdout).toString("utf8").trim() || `codex exec resume exited with code ${String(exitCode)}`;
+		if (result.termination === "timeout") throw new Error(`codex exec resume timed out after ${String(params.timeoutMs)}ms`);
+		if (result.termination === "error" && result.error) throw result.error;
+		if (result.code !== 0) {
+			const message = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || `codex exec resume exited with code ${String(result.code)}`;
 			throw new Error(message);
 		}
 		return await fs.readFile(outputPath, "utf8");
@@ -329,21 +311,6 @@ async function runCodexExecResume(params) {
 		});
 	}
 }
-function resolveCodexCliResumeSpawnInvocation(args, runtime = DEFAULT_RESUME_SPAWN_RUNTIME) {
-	const resolved = materializeWindowsSpawnProgram(resolveWindowsSpawnProgram({
-		command: "codex",
-		platform: runtime.platform,
-		env: runtime.env,
-		execPath: runtime.execPath,
-		packageName: "@openai/codex"
-	}), args);
-	return {
-		command: resolved.command,
-		args: resolved.argv,
-		shell: resolved.shell,
-		windowsHide: resolved.windowsHide
-	};
-}
 async function readHistorySessions(codexHome) {
 	const summaries = /* @__PURE__ */ new Map();
 	if (!(await visitJsonlLines(path.join(codexHome, "history.jsonl"), (line) => {
@@ -579,91 +546,6 @@ function formatNodeLabel(node) {
 	].filter(Boolean).join(" / ") || "node";
 }
 //#endregion
-//#region extensions/codex/src/command-rpc.ts
-function requestOptions(pluginConfig, limit, config, agentDir) {
-	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	return {
-		limit,
-		timeoutMs: runtime.requestTimeoutMs,
-		startOptions: runtime.start,
-		config,
-		agentDir
-	};
-}
-async function codexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	const runtime = options.startOptions ? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig }) : resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	const controlRequestOptions = {
-		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
-		startOptions: options.startOptions ?? runtime.start,
-		config: options.config,
-		sessionKey: options.sessionKey,
-		sessionId: options.sessionId,
-		authProfileId: options.authProfileId,
-		agentDir: options.agentDir,
-		isolated: options.isolated
-	};
-	if (options.onResponse) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client) => {
-		const response = await request({
-			method,
-			requestParams
-		});
-		await options.onResponse(response, client);
-		return response;
-	});
-	return await requestCodexAppServerJson({
-		method,
-		requestParams,
-		...controlRequestOptions
-	});
-}
-async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	return await safeValue(async () => await codexControlRequest(pluginConfig, method, requestParams, options));
-}
-async function safeCodexModelList(pluginConfig, limit, config, agentDir) {
-	return await safeValue(async () => await listCodexAppServerModels(requestOptions(pluginConfig, limit, config, agentDir)));
-}
-async function readCodexStatusProbes(pluginConfig, config, agentDir) {
-	const [models, account, limits, mcps, skills] = await Promise.all([
-		safeCodexModelList(pluginConfig, 20, config, agentDir),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, {
-			config,
-			agentDir
-		}),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, {
-			config,
-			agentDir
-		}),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }, {
-			config,
-			agentDir
-		}),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, {
-			config,
-			agentDir
-		})
-	]);
-	return {
-		models,
-		account,
-		limits,
-		mcps,
-		skills
-	};
-}
-async function safeValue(read) {
-	try {
-		return {
-			ok: true,
-			value: await read()
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error: describeControlFailure(error)
-		};
-	}
-}
-//#endregion
 //#region extensions/codex/src/app-server/thread-archive-guard.ts
 const DESCENDANT_PAGE_LIMIT = 100;
 const MAX_DESCENDANT_PAGES = 100;
@@ -714,29 +596,6 @@ async function assertCodexArchiveDescendantsUnowned(params) {
 	throw new Error("Codex descendant enumeration exceeded its safety limit");
 }
 //#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";
@@ -1030,24 +889,9 @@ function adoptionSessionKeyRest(sessionKey) {
 	const trimmed = sessionKey.trim();
 	return parseAgentSessionKey(trimmed)?.rest ?? trimmed;
 }
-function listSupervisionAgentIds(config) {
-	const defaultAgentId = resolveDefaultAgentId(config);
-	return [defaultAgentId, ...listAgentIds(config).filter((agentId) => agentId !== defaultAgentId)];
-}
-function adoptedSourceKey(hostId, threadId) {
-	return `${hostId}\u0000${threadId}`;
-}
-function lastTerminalTurnId(thread) {
-	for (let index = (thread.turns?.length ?? 0) - 1; index >= 0; index -= 1) {
-		const turn = thread.turns?.[index];
-		const turnId = boundedCatalogString(turn?.id, 256);
-		if (!turnId) continue;
-		if (turn?.status === "completed" || turn?.status === "interrupted" || turn?.status === "failed") return turnId;
-	}
-}
 function nodeAdoptionSessionKey(hostId, threadId) {
-	const digest = createHash("sha256").update(JSON.stringify([hostId, threadId])).digest("hex");
-	return `${CODEX_NODE_SESSION_KEY_PREFIX}${digest}`;
+	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;
@@ -1063,6 +907,7 @@ function readNodeSessionMarker(entry) {
 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
@@ -1070,7 +915,7 @@ 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 = adoptedSourceKey(marker.sourceHostId, marker.sourceThreadId);
+		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,
@@ -1082,7 +927,7 @@ function listNodeAdoptedSessionEntries(params) {
 	return adopted;
 }
 function findNodeAdoptedSessionEntry(params) {
-	return listNodeAdoptedSessionEntries(params).get(adoptedSourceKey(params.hostId, params.threadId));
+	return listNodeAdoptedSessionEntries(params).get(sessionCatalogAdoptedSourceKey(params.hostId, params.threadId));
 }
 function nodeSessionMarker(params) {
 	return {
@@ -1130,6 +975,7 @@ async function finalizeNodeAdoptedSession(params) {
 }
 async function createOrReuseNodeAdoptedSession(params) {
 	const existing = findNodeAdoptedSessionEntry({
+		agentId: params.agentId,
 		config: params.config,
 		runtime: params.api.runtime,
 		hostId: params.hostId,
@@ -1149,7 +995,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 		const created = await params.api.runtime.agent.session.createSessionEntry({
 			cfg: params.config,
 			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId),
-			agentId: resolveDefaultAgentId(params.config),
+			agentId: params.agentId,
 			recoverMatchingInitialEntry: true,
 			...params.record.name?.trim() ? { label: params.record.name.trim() } : {},
 			...params.record.cwd?.trim() ? { spawnedCwd: params.record.cwd.trim() } : {},
@@ -1182,6 +1028,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 		};
 	} catch (error) {
 		const raced = findNodeAdoptedSessionEntry({
+			agentId: params.agentId,
 			config: params.config,
 			runtime: params.api.runtime,
 			hostId: params.hostId,
@@ -1193,346 +1040,127 @@ async function createOrReuseNodeAdoptedSession(params) {
 	}
 }
 //#endregion
-//#region extensions/codex/src/session-catalog-node-continue.ts
-const CODEX_NODE_CONTINUE_COMMANDS = [
-	CODEX_APP_SERVER_THREADS_LIST_COMMAND,
-	CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
-	CODEX_CLI_SESSION_RESUME_COMMAND
-];
-const NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS = 8e3;
-function nodeLabel(node) {
-	return node.displayName?.trim() || node.remoteIp?.trim() || node.nodeId;
+//#region extensions/codex/src/session-catalog-terminal.ts
+const CODEX_TERMINAL_RESUME_COMMAND = "codex.terminal.resume.v1";
+function resolveCodexCatalogTerminalHome(sources) {
+	const runtimeConfig = sources.getRuntimeConfig();
+	if (!runtimeConfig) throw new Error("OpenClaw runtime config is unavailable");
+	const agentDir = sources.source?.agentDir ?? (sources.agentId ? resolveAgentDir(runtimeConfig, sources.agentId) : resolveDefaultAgentDir(runtimeConfig));
+	return resolveCodexAppServerLocalHomeDir(sources.source?.appServer.start ?? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: sources.getPluginConfig() }).start, agentDir);
 }
-function compareNodeLabels(left, right) {
-	const leftLabel = nodeLabel(left);
-	const rightLabel = nodeLabel(right);
-	if (leftLabel < rightLabel) return -1;
-	if (leftLabel > rightLabel) return 1;
-	return 0;
+function resolveLocalCodexTerminalExecutable(env = process.env) {
+	return resolveLocalCodexTerminalResolution(env)?.executable;
 }
-function canContinueCodexOnNode(node) {
-	return node.connected === true && CODEX_NODE_CONTINUE_COMMANDS.every((command) => node.commands?.includes(command) === true && node.invocableCommands?.includes(command) === true);
+function resolveLocalCodexTerminalResolution(env = process.env) {
+	return resolveNodeHostExecutable("codex", {
+		env,
+		pathEnv: env.PATH ?? env.Path ?? "",
+		strategy: "fallback"
+	});
 }
-async function listPairedNode(params) {
-	const hostId = `node:${params.node.nodeId}`;
-	const common = {
-		hostId,
-		label: nodeLabel(params.node),
-		kind: "node",
-		nodeId: params.node.nodeId,
-		canContinueCodex: canContinueCodexOnNode(params.node)
-	};
-	if (params.node.connected !== true) {
-		const host = {
-			...common,
-			connected: false,
-			sessions: [],
-			error: {
-				code: "NODE_OFFLINE",
-				message: "Paired node is offline"
-			}
-		};
-		params.onHost?.(host);
-		return host;
-	}
-	const eventualHost = Promise.resolve().then(async () => {
-		const page = filterCatalogPageByTitle(parseCatalogPage(unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
-			nodeId: params.node.nodeId,
-			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
-			params: {
-				cursor: params.query.cursors?.[hostId],
-				limit: params.query.limitPerHost,
-				searchTerm: params.query.search
-			},
-			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
-			scopes: ["operator.write"]
-		}))), params.query.search);
-		return {
-			...common,
-			connected: true,
-			...page,
-			sessions: page.sessions.map((session) => {
-				const adopted = params.adoptedSessions.get(adoptedSourceKey(hostId, session.threadId));
-				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
-			})
-		};
-	}).catch((error) => ({
-		...common,
-		connected: true,
-		sessions: [],
-		error: catalogError("NODE_INVOKE_FAILED", error)
-	}));
-	if (params.onHost) eventualHost.then(params.onHost).catch(() => void 0);
-	try {
-		return await withTimeout(eventualHost, NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS, "paired node Codex session catalog timed out");
-	} catch (error) {
-		return {
-			...common,
-			connected: true,
-			sessions: [],
-			error: catalogError("NODE_INVOKE_FAILED", error)
-		};
+function codexNodeTerminalCapability(node) {
+	const commands = node.invocableCommands ?? node.commands;
+	return node.connected === true && commands?.includes("codex.terminal.resume.v1") === true ? { canOpenTerminalCodex: true } : {};
+}
+async function requireCatalogEligibleThread(control, threadId) {
+	const cached = await findCatalogEligibleThread(control, threadId, false);
+	if (cached) return cached;
+	const refreshed = await findCatalogEligibleThread(control, threadId, true);
+	if (refreshed) return refreshed;
+	throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+}
+async function findCatalogEligibleThread(control, threadId, forceRefresh) {
+	let cursor;
+	const seenCursors = /* @__PURE__ */ new Set();
+	for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
+		const page = await control.listPage({
+			limit: 100,
+			...cursor ? { cursor } : {},
+			...forceRefresh ? { forceRefresh: true } : {}
+		});
+		const candidate = page.sessions.find((session) => session.threadId === threadId);
+		if (candidate) {
+			if (isInteractiveThreadSource(candidate.source)) return candidate;
+			throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+		}
+		const nextCursor = page.nextCursor?.trim();
+		if (!nextCursor) return;
+		if (seenCursors.has(nextCursor)) throw new CatalogParamsError("Codex session eligibility could not be verified");
+		seenCursors.add(nextCursor);
+		cursor = nextCursor;
 	}
+	throw new CatalogParamsError("Codex session eligibility could not be verified");
 }
-async function requireNodeForCodexContinue(params) {
-	const nodeId = params.hostId.slice(5).trim();
-	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
-	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId);
-	if (!node || !canContinueCodexOnNode(node)) throw new CatalogParamsError("paired node does not permit Codex session continuation");
+function createCodexTerminalNodeHostCommand(bindRequest, configSources) {
 	return {
-		node,
-		nodeId
+		command: CODEX_TERMINAL_RESUME_COMMAND,
+		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+		dangerous: false,
+		duplex: true,
+		isAvailable: ({ env }) => Boolean(resolveNodeHostExecutable("codex", {
+			env,
+			pathEnv: env.PATH ?? env.Path ?? "",
+			strategy: "direct"
+		})),
+		handle: async (paramsJSON, io) => {
+			if (!io) throw new Error("Codex terminal command requires duplex transport");
+			const request = bindRequest(paramsJSON);
+			const resume = decodeNodePtyResumeParams(request.paramsJSON, (value) => {
+				if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value)) throw new CatalogParamsError("threadId must be a UUID");
+				return value;
+			});
+			const record = await requireCatalogEligibleThread(request.control, resume.threadId);
+			const resolution = resolveNodeHostExecutable("codex", {
+				env: process.env,
+				pathEnv: process.env.PATH ?? process.env.Path ?? "",
+				strategy: "direct"
+			});
+			if (!resolution) throw new Error("Codex CLI is unavailable");
+			return JSON.stringify(await runNodePtyCommand({
+				file: resolution.executable,
+				args: ["resume", resume.threadId],
+				cwd: record.cwd,
+				env: { CODEX_HOME: resolveCodexCatalogTerminalHome({
+					...configSources,
+					agentId: request.agentId
+				}) },
+				cols: resume.cols,
+				rows: resume.rows
+			}, io));
+		}
 	};
 }
-async function resolveNodeCodexRecord(params) {
+async function resolveNodeCatalogEligibleThread(params) {
 	let cursor;
 	const seenCursors = /* @__PURE__ */ new Set();
 	for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
-		const page = parseCatalogPage(unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+		const raw = await params.runtime.nodes.invoke({
 			nodeId: params.nodeId,
 			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
 			params: {
+				agentId: params.agentId,
 				limit: 100,
 				...cursor ? { cursor } : {}
 			},
 			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
 			scopes: ["operator.write"]
-		})));
+		});
+		const page = params.parseCatalogPage(unwrapNodeInvokePayload(raw));
 		const record = page.sessions.find((candidate) => candidate.threadId === params.threadId);
-		if (record) return record;
+		if (record) {
+			if (isInteractiveThreadSource(record.source)) return record;
+			break;
+		}
 		const nextCursor = page.nextCursor?.trim();
-		if (!nextCursor) break;
-		if (seenCursors.has(nextCursor)) throw new CatalogParamsError("Codex session eligibility could not be verified");
+		if (!nextCursor || seenCursors.has(nextCursor)) break;
 		seenCursors.add(nextCursor);
 		cursor = nextCursor;
 	}
-	throw new CatalogParamsError("Codex session is unavailable on the paired node");
-}
-function requireContinuableNodeRecord(record) {
-	if (record.archived) throw new CatalogParamsError("Codex session is archived on the paired node");
-	if (!isInteractiveThreadSource(record.source)) throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
-	if (record.status === "idle" || record.status === "notLoaded") return;
-	if (record.status === "active") throw new CatalogParamsError("Codex session is active on the paired node; wait for it to finish before continuing");
-	throw new CatalogParamsError("Codex session cannot be continued in its current state");
-}
-async function readNodeCodexHistory(params) {
-	const page = parseTranscriptPage(unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
-		nodeId: params.nodeId,
-		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
-		params: {
-			threadId: params.record.threadId,
-			limit: 50
-		},
-		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
-		scopes: ["operator.write"]
-	})));
-	const thread = {
-		id: params.record.threadId,
-		createdAt: params.record.createdAt ?? 0,
-		modelProvider: params.record.modelProvider ?? "openai",
-		turns: page.data.toReversed()
-	};
-	return {
-		thread,
-		throughTurnId: lastTerminalTurnId(thread) ?? null
-	};
-}
-async function continueNodeCodexSessionInner(params) {
-	const { nodeId } = await requireNodeForCodexContinue({
-		runtime: params.api.runtime,
-		hostId: params.hostId
-	});
-	const record = await resolveNodeCodexRecord({
-		runtime: params.api.runtime,
-		nodeId,
-		threadId: params.threadId
-	});
-	requireContinuableNodeRecord(record);
-	const existing = findNodeAdoptedSessionEntry({
-		config: params.config,
-		runtime: params.api.runtime,
-		hostId: params.hostId,
-		threadId: params.threadId,
-		includeInitializing: true
-	});
-	let adopted;
-	let disposition;
-	if (existing) {
-		adopted = existing;
-		disposition = "existing";
-	} else {
-		const history = await readNodeCodexHistory({
-			runtime: params.api.runtime,
-			nodeId,
-			record
-		});
-		adopted = await createOrReuseNodeAdoptedSession({
-			api: params.api,
-			config: params.config,
-			hostId: params.hostId,
-			nodeId,
-			record,
-			history
-		});
-		disposition = "forked";
-	}
-	const marker = nodeSessionMarker({
-		hostId: params.hostId,
-		threadId: params.threadId,
-		nodeId
-	});
-	return {
-		sessionKey: adopted.key,
-		disposition,
-		conversationBinding: {
-			summary: "Continue this Codex session on its paired node.",
-			detachHint: "Start a new chat to leave the paired-node Codex session.",
-			data: createCodexCliNodeConversationBindingData({
-				nodeId,
-				sessionId: record.sessionId?.trim() || params.threadId,
-				agentId: adopted.agentId,
-				cwd: record.cwd
-			})
-		},
-		afterConversationBound: async () => await finalizeNodeAdoptedSession({
-			api: params.api,
-			adopted,
-			marker
-		})
-	};
-}
-async function continueNodeCodexSession(params) {
-	if (params.clientScopes?.includes("operator.admin") !== true) throw new CatalogParamsError("continuing a paired-node Codex session requires operator.admin");
-	const nodeId = params.hostId.slice(5).trim();
-	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
-	const sourceKey = adoptedSourceKey(`node:${nodeId}`, params.threadId);
-	const current = continueOperations.get(sourceKey);
-	if (current) return await current;
-	const operation = runSessionActionExclusive(sourceKey, async () => continueNodeCodexSessionInner(params));
-	continueOperations.set(sourceKey, operation);
-	try {
-		return await operation;
-	} finally {
-		if (continueOperations.get(sourceKey) === operation) continueOperations.delete(sourceKey);
-	}
-}
-//#endregion
-//#region extensions/codex/src/session-catalog-terminal.ts
-const CODEX_TERMINAL_RESUME_COMMAND = "codex.terminal.resume.v1";
-function resolveCodexCatalogTerminalHome(sources) {
-	const runtimeConfig = sources.getRuntimeConfig();
-	if (!runtimeConfig) throw new Error("OpenClaw runtime config is unavailable");
-	const startOptions = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: sources.getPluginConfig() }).start;
-	return resolveCodexAppServerLocalHomeDir(startOptions, resolveDefaultAgentDir(runtimeConfig));
-}
-function resolveLocalCodexTerminalExecutable(env = process.env) {
-	return resolveLocalCodexTerminalResolution(env)?.executable;
-}
-function resolveLocalCodexTerminalResolution(env = process.env) {
-	return resolveNodeHostExecutable("codex", {
-		env,
-		pathEnv: env.PATH ?? env.Path ?? "",
-		strategy: "fallback"
-	});
-}
-function codexNodeTerminalCapability(node) {
-	const commands = node.invocableCommands ?? node.commands;
-	return node.connected === true && commands?.includes("codex.terminal.resume.v1") === true ? { canOpenTerminalCodex: true } : {};
-}
-async function requireCatalogEligibleThread(control, threadId) {
-	const cached = await findCatalogEligibleThread(control, threadId, false);
-	if (cached) return cached;
-	const refreshed = await findCatalogEligibleThread(control, threadId, true);
-	if (refreshed) return refreshed;
-	throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
-}
-async function findCatalogEligibleThread(control, threadId, forceRefresh) {
-	let cursor;
-	const seenCursors = /* @__PURE__ */ new Set();
-	for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
-		const page = await control.listPage({
-			limit: 100,
-			...cursor ? { cursor } : {},
-			...forceRefresh ? { forceRefresh: true } : {}
-		});
-		const candidate = page.sessions.find((session) => session.threadId === threadId);
-		if (candidate) {
-			if (isInteractiveThreadSource(candidate.source)) return candidate;
-			throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
-		}
-		const nextCursor = page.nextCursor?.trim();
-		if (!nextCursor) return;
-		if (seenCursors.has(nextCursor)) throw new CatalogParamsError("Codex session eligibility could not be verified");
-		seenCursors.add(nextCursor);
-		cursor = nextCursor;
-	}
-	throw new CatalogParamsError("Codex session eligibility could not be verified");
-}
-function createCodexTerminalNodeHostCommand(control, configSources) {
-	return {
-		command: CODEX_TERMINAL_RESUME_COMMAND,
-		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
-		dangerous: false,
-		duplex: true,
-		isAvailable: ({ env }) => Boolean(resolveNodeHostExecutable("codex", {
-			env,
-			pathEnv: env.PATH ?? env.Path ?? "",
-			strategy: "direct"
-		})),
-		handle: async (paramsJSON, io) => {
-			if (!io) throw new Error("Codex terminal command requires duplex transport");
-			const resume = decodeNodePtyResumeParams(paramsJSON, (value) => {
-				if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value)) throw new CatalogParamsError("threadId must be a UUID");
-				return value;
-			});
-			const record = await requireCatalogEligibleThread(control, resume.threadId);
-			const resolution = resolveNodeHostExecutable("codex", {
-				env: process.env,
-				pathEnv: process.env.PATH ?? process.env.Path ?? "",
-				strategy: "direct"
-			});
-			if (!resolution) throw new Error("Codex CLI is unavailable");
-			return JSON.stringify(await runNodePtyCommand({
-				file: resolution.executable,
-				args: ["resume", resume.threadId],
-				cwd: record.cwd,
-				env: { CODEX_HOME: resolveCodexCatalogTerminalHome(configSources) },
-				cols: resume.cols,
-				rows: resume.rows
-			}, io));
-		}
-	};
-}
-async function resolveNodeCatalogEligibleThread(params) {
-	let cursor;
-	const seenCursors = /* @__PURE__ */ new Set();
-	for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
-		const raw = await params.runtime.nodes.invoke({
-			nodeId: params.nodeId,
-			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
-			params: {
-				limit: 100,
-				...cursor ? { cursor } : {}
-			},
-			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
-			scopes: ["operator.write"]
-		});
-		const page = params.parseCatalogPage(unwrapNodeInvokePayload(raw));
-		const record = page.sessions.find((candidate) => candidate.threadId === params.threadId);
-		if (record) {
-			if (isInteractiveThreadSource(record.source)) return record;
-			break;
-		}
-		const nextCursor = page.nextCursor?.trim();
-		if (!nextCursor || seenCursors.has(nextCursor)) break;
-		seenCursors.add(nextCursor);
-		cursor = nextCursor;
-	}
-	throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+	throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
 }
 async function openCodexCatalogTerminal(params) {
 	const title = `codex resume ${params.threadId.slice(0, 8)}…`;
-	if (params.hostId === "gateway:local") {
+	if (params.hostId === "gateway:local" || params.hostId.startsWith(`gateway:local:`)) {
 		const record = await requireCatalogEligibleThread(params.control, params.threadId);
 		const resolution = resolveLocalCodexTerminalResolution();
 		if (!resolution) throw new CatalogParamsError("Codex CLI is unavailable");
@@ -1556,6 +1184,7 @@ async function openCodexCatalogTerminal(params) {
 		return candidate.nodeId === nodeId && candidate.connected === true && commands?.includes("codex.appServer.threads.list.v1") === true && commands.includes("codex.terminal.resume.v1");
 	})) throw new CatalogParamsError("paired-node Codex terminal is unavailable");
 	const record = await resolveNodeCatalogEligibleThread({
+		agentId: params.agentId,
 		runtime: params.api.runtime,
 		nodeId,
 		threadId: params.threadId,
@@ -1565,7 +1194,10 @@ async function openCodexCatalogTerminal(params) {
 		kind: "node",
 		nodeId,
 		command: CODEX_TERMINAL_RESUME_COMMAND,
-		paramsJSON: JSON.stringify({ threadId: params.threadId }),
+		paramsJSON: JSON.stringify({
+			agentId: params.agentId,
+			threadId: params.threadId
+		}),
 		...record.cwd ? { cwd: record.cwd } : {},
 		title
 	};
@@ -1584,480 +1216,684 @@ async function startCodexCatalogTerminal(params) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/session-catalog-transcript-item.ts
-const CODEX_MESSAGE_TYPES = /* @__PURE__ */ new Map([
-	["userMessage", "userMessage"],
-	["agentMessage", "agentMessage"],
-	["reasoning", "reasoning"]
-]);
-const CODEX_TOOL_TYPES = /* @__PURE__ */ new Set([
-	"commandExecution",
-	"fileChange",
-	"mcpToolCall",
-	"dynamicToolCall",
-	"collabAgentToolCall",
-	"webSearch",
-	"imageView",
-	"imageGeneration"
-]);
-function toGenericTranscriptItem(item) {
-	let type = CODEX_MESSAGE_TYPES.get(item.type);
-	if (!type && CODEX_TOOL_TYPES.has(item.type)) type = item.result !== void 0 || Boolean(item.aggregatedOutput) ? "toolResult" : "toolCall";
-	type ??= "other";
-	const fallback = item.title ?? item.name ?? item.tool ?? item.command ?? item.query ?? void 0;
-	const resultText = item.aggregatedOutput || (item.result === void 0 ? void 0 : JSON.stringify(item.result, null, 2));
-	const changesText = Array.isArray(item.changes) ? item.changes.map((change) => `${change.kind}: ${change.path}`).join("\n") || void 0 : void 0;
-	const text = item.text || resultText || changesText || fallback;
-	return {
-		id: item.id,
-		type,
-		...text ? { text } : {},
-		raw: item
-	};
+//#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");
 }
-//#endregion
-//#region extensions/codex/src/session-upstream-activity.ts
-const CODEX_UPSTREAM_TURN_LIMIT = 100;
-const CODEX_APP_SERVER_INVALID_REQUEST_CODE = -32600;
-const CODEX_THREAD_NOT_LOADED_MESSAGE_PREFIX = "thread not loaded:";
-function isCodexThreadGoneError(error) {
-	return error instanceof CodexAppServerRpcError && error.code === CODEX_APP_SERVER_INVALID_REQUEST_CODE && error.message.startsWith(CODEX_THREAD_NOT_LOADED_MESSAGE_PREFIX);
+function adoptionSessionKey(threadId, sourceHomeId) {
+	const source = sourceHomeId ? JSON.stringify([sourceHomeId, threadId]) : threadId;
+	return sessionCatalogAdoptedSessionKey(CODEX_SUPERVISION_SESSION_KEY_PREFIX, source);
 }
-function readMarker(probe) {
-	if (!isRecord(probe.marker)) return;
-	const turnId = probe.marker.turnId;
-	if (turnId !== null && typeof turnId !== "string") return;
-	const count = probe.marker.userMessageCount;
-	if (count !== void 0 && (!Number.isSafeInteger(count) || count < 0)) return;
+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 {
-		turnId,
-		...count === void 0 ? {} : { userMessageCount: count }
+		sourceThreadId: sourceThreadId.trim(),
+		...typeof sourceHomeId === "string" ? { sourceHomeId: sourceHomeId.trim() } : {}
 	};
 }
-function upstreamConnectionFingerprint(probe) {
-	return isRecord(probe.upstreamRef) && typeof probe.upstreamRef.connectionFingerprint === "string" ? probe.upstreamRef.connectionFingerprint : void 0;
-}
-function classifyCodexUpstreamTurns(params) {
-	const marker = readMarker(params.probe);
-	if (!marker) return;
-	const newest = params.turns[0];
-	if (!newest?.id) return;
-	const markerIndex = marker.turnId === null ? -1 : params.turns.findIndex((turn) => turn.id === marker.turnId);
-	const candidateTurns = markerIndex < 0 ? params.turns : params.turns.slice(0, markerIndex + 1);
-	const newestUserMessageCount = countUserMessages(newest);
-	if (!(marker.turnId !== newest.id || marker.userMessageCount === void 0 || newestUserMessageCount > marker.userMessageCount)) return;
-	const ownTexts = new Set(params.probe.ownRecentUserTexts);
-	let humanTurns = 0;
-	let occurredAt;
-	for (const turn of candidateTurns) {
-		const userMessages = turn.items.filter((item) => item.type === "userMessage");
-		const alreadySeen = turn.id === marker.turnId ? marker.userMessageCount ?? userMessages.length : 0;
-		for (const item of userMessages.slice(alreadySeen)) {
-			const texts = normalizeUserMessageTexts(item);
-			if (ownTexts.has(texts.join(" ")) || texts.length > 1 && texts.every((text) => ownTexts.has(text))) continue;
-			humanTurns += 1;
-			if (occurredAt === void 0) {
-				const timestampSeconds = turn.completedAt ?? turn.startedAt;
-				occurredAt = typeof timestampSeconds === "number" && Number.isFinite(timestampSeconds) ? timestampSeconds * 1e3 : params.now ?? Date.now();
+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 = await 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);
+}
+async function clearCreatedAdoptionBinding(params) {
+	let cleared = false;
+	let clearError;
+	try {
+		cleared = await params.bindingStore.mutate(params.identity, {
+			kind: "clear",
+			threadId: params.sourceThreadId,
+			expectedPendingSupervisionBranch: params.expectedPending
+		});
+	} catch (error) {
+		clearError = error;
+	}
+	if (cleared) return;
+	let current;
+	try {
+		current = await params.bindingStore.read(params.identity);
+	} catch (readError) {
+		throw new AggregateError([
+			params.cause,
+			...clearError ? [clearError] : [],
+			readError
+		], `OpenClaw session creation failed and the Codex binding could not be verified for ${params.sourceThreadId}`, { cause: readError });
+	}
+	if (!matchesPendingSupervisionOwner(current, params.expectedPending)) return;
+	throw new AggregateError([params.cause, ...clearError ? [clearError] : []], `OpenClaw session creation failed and the Codex binding could not be cleared for ${params.sourceThreadId}`, { cause: params.cause });
+}
+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));
+}
+function matchesPendingSupervisionOwner(binding, expected) {
+	const pending = binding?.pendingSupervisionBranch;
+	const cleanupThreadIds = pending?.cleanupThreadIds ?? [];
+	const expectedCleanupThreadIds = expected.cleanupThreadIds ?? [];
+	return binding?.threadId === expected.sourceThreadId && binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && pending?.sourceThreadId === expected.sourceThreadId && pending.connectionFingerprint === expected.connectionFingerprint && pending.lastTurnId === expected.lastTurnId && cleanupThreadIds.length === expectedCleanupThreadIds.length && cleanupThreadIds.every((threadId, index) => threadId === expectedCleanupThreadIds[index]);
+}
+async function ensurePendingAdoptionBinding(params) {
+	const pending = {
+		sourceThreadId: params.sourceThreadId,
+		connectionFingerprint: params.connectionFingerprint,
+		...params.lastTurnId ? { lastTurnId: params.lastTurnId } : {}
+	};
+	if (!await reclaimCurrentCodexSessionGeneration({
+		bindingStore: params.bindingStore,
+		identity: params.identity,
+		config: params.config
+	})) throw new Error(`failed to claim the OpenClaw session generation for ${params.sourceThreadId}`);
+	const existing = await params.bindingStore.read(params.identity);
+	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
+	};
+	let stored;
+	try {
+		stored = await params.bindingStore.mutate(params.identity, {
+			kind: "set",
+			if: { kind: "absent" },
+			binding
+		});
+	} catch (error) {
+		if (matchesPendingAdoptionBinding(await params.bindingStore.read(params.identity), params)) return;
+		throw error;
+	}
+	if (stored) return;
+	if (!matchesPendingAdoptionBinding(await params.bindingStore.read(params.identity), params)) throw new Error(`failed to bind OpenClaw session to Codex thread ${params.sourceThreadId}`);
+}
+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;
+	let createdBindingIdentity;
+	let createdPendingBinding;
+	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 created = await createImportedCodexSession({
+			runtime: params.api.runtime,
+			config: params.config,
+			key: adoptionSessionKey(params.sourceThread.id, params.sourceHomeId),
+			agentId: params.agentId,
+			thread: params.sourceThread,
+			throughTurnId: pendingLastTurnId ?? null,
+			recoverMatchingInitialEntry: true,
+			initialEntry: {
+				agentHarnessId: "codex",
+				modelSelectionLocked: true,
+				pluginExtensions: { codex: { supervision: {
+					...marker,
+					initializing: true,
+					modelLocked: true
+				} } }
+			},
+			afterImport: async (entry) => {
+				createdBindingIdentity = sessionBindingIdentity({
+					sessionId: entry.sessionId,
+					sessionKey: entry.key,
+					config: params.config
+				});
+				createdPendingBinding = {
+					sourceThreadId: params.sourceThread.id,
+					connectionFingerprint: params.connectionFingerprint,
+					...pendingLastTurnId ? { lastTurnId: pendingLastTurnId } : {}
+				};
+				await ensurePendingAdoptionBinding({
+					bindingStore: params.bindingStore,
+					config: params.config,
+					identity: createdBindingIdentity,
+					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) {
+		let raced = await findAdoptedSessionEntry(lookup);
+		if (raced) return raced;
+		if (createdBindingIdentity && createdPendingBinding) {
+			await clearCreatedAdoptionBinding({
+				bindingStore: params.bindingStore,
+				identity: createdBindingIdentity,
+				sourceThreadId: params.sourceThread.id,
+				expectedPending: createdPendingBinding,
+				cause: error
+			});
+			raced = await findAdoptedSessionEntry(lookup);
+			if (raced) return raced;
+		}
+		throw error;
+	}
+}
+async function continueLocalCodexSessionInner(params) {
+	await requireCatalogEligibleThread(params.control, 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 };
+			}
+		})) 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
+//#region extensions/codex/src/session-catalog-archive.ts
+async 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 = await 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) => {
+				await requireCatalogEligibleThread(control, params.threadId);
+				await assertNoPendingSupervisionBranch(params);
+				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
+//#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-node-continue.ts
+const CODEX_NODE_CONTINUE_COMMANDS = [
+	CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+	CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+	CODEX_CLI_SESSION_RESUME_COMMAND
+];
+const NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS = 8e3;
+const continueNodeAdoption = createSessionCatalogAdoptionCoordinator();
+function nodeLabel(node) {
+	return node.displayName?.trim() || node.remoteIp?.trim() || node.nodeId;
+}
+function compareNodeLabels(left, right) {
+	const leftLabel = nodeLabel(left);
+	const rightLabel = nodeLabel(right);
+	if (leftLabel < rightLabel) return -1;
+	if (leftLabel > rightLabel) return 1;
+	return 0;
+}
+function canContinueCodexOnNode(node) {
+	return node.connected === true && CODEX_NODE_CONTINUE_COMMANDS.every((command) => node.commands?.includes(command) === true && node.invocableCommands?.includes(command) === true);
+}
+async function listPairedNode(params) {
+	const hostId = `node:${params.node.nodeId}`;
+	const common = {
+		hostId,
+		label: nodeLabel(params.node),
+		kind: "node",
+		nodeId: params.node.nodeId,
+		canContinueCodex: canContinueCodexOnNode(params.node)
+	};
+	if (params.node.connected !== true) {
+		const host = {
+			...common,
+			connected: false,
+			sessions: [],
+			error: {
+				code: "NODE_OFFLINE",
+				message: "Paired node is offline"
 			}
-		}
+		};
+		params.onHost?.(host);
+		return host;
 	}
-	const activityId = `${newest.id}:${newestUserMessageCount}`;
+	const eventualHost = Promise.resolve().then(async () => {
+		const page = filterCatalogPageByTitle(parseCatalogPage(unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+			nodeId: params.node.nodeId,
+			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+			params: {
+				agentId: params.agentId,
+				cursor: params.query.cursors?.[hostId],
+				limit: params.query.limitPerHost,
+				searchTerm: params.query.search
+			},
+			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+			scopes: ["operator.write"]
+		}))), params.query.search);
+		return {
+			...common,
+			connected: true,
+			...page,
+			sessions: page.sessions.map((session) => {
+				const adopted = params.adoptedSessions.get(sessionCatalogAdoptedSourceKey(hostId, session.threadId));
+				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
+			})
+		};
+	}).catch((error) => ({
+		...common,
+		connected: true,
+		sessions: [],
+		error: catalogError("NODE_INVOKE_FAILED", error)
+	}));
+	if (params.onHost) eventualHost.then(params.onHost).catch(() => void 0);
+	try {
+		return await withTimeout(eventualHost, NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS, "paired node Codex session catalog timed out");
+	} catch (error) {
+		return {
+			...common,
+			connected: true,
+			sessions: [],
+			error: catalogError("NODE_INVOKE_FAILED", error)
+		};
+	}
+}
+async function requireNodeForCodexContinue(params) {
+	const nodeId = params.hostId.slice(5).trim();
+	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId);
+	if (!node || !canContinueCodexOnNode(node)) throw new CatalogParamsError("paired node does not permit Codex session continuation");
 	return {
-		kind: "activity",
-		sessionKey: params.probe.sessionKey,
-		humanTurns,
-		nextMarker: {
-			turnId: newest.id,
-			userMessageCount: newestUserMessageCount
-		},
-		...humanTurns > 0 ? {
-			occurredAt: occurredAt ?? params.now ?? Date.now(),
-			dedupeId: activityId
-		} : {}
+		node,
+		nodeId
 	};
 }
-function countUserMessages(turn) {
-	return turn.items.filter((item) => item.type === "userMessage").length;
+async function resolveNodeCodexRecord(params) {
+	let cursor;
+	const seenCursors = /* @__PURE__ */ new Set();
+	for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
+		const page = parseCatalogPage(unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+			nodeId: params.nodeId,
+			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+			params: {
+				agentId: params.agentId,
+				limit: 100,
+				...cursor ? { cursor } : {}
+			},
+			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+			scopes: ["operator.write"]
+		})));
+		const record = page.sessions.find((candidate) => candidate.threadId === params.threadId);
+		if (record) return record;
+		const nextCursor = page.nextCursor?.trim();
+		if (!nextCursor) break;
+		if (seenCursors.has(nextCursor)) throw new CatalogParamsError("Codex session eligibility could not be verified");
+		seenCursors.add(nextCursor);
+		cursor = nextCursor;
+	}
+	throw new CatalogParamsError("Codex session is unavailable on the paired node");
 }
-function normalizeUserMessageTexts(item) {
-	const typed = item;
-	const contentTexts = typed.content?.filter((input) => input.type === "text").map((input) => input.text.trim().replace(/\s+/g, " ")).filter(Boolean);
-	return contentTexts?.length ? contentTexts : [(typed.text ?? "").trim().replace(/\s+/g, " ")];
+function requireContinuableNodeRecord(record) {
+	if (record.archived) throw new CatalogParamsError("Codex session is archived on the paired node");
+	if (!isInteractiveThreadSource(record.source)) throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+	if (record.status === "idle" || record.status === "notLoaded") return;
+	if (record.status === "active") throw new CatalogParamsError("Codex session is active on the paired node; wait for it to finish before continuing");
+	throw new CatalogParamsError("Codex session cannot be continued in its current state");
 }
-async function checkCodexUpstreamActivity(probes, control, resolveThreadId = async (probe) => probe.threadId) {
-	return await control.withPinnedConnection(async (pinned) => {
-		const activities = [];
-		for (const probe of probes) {
-			const fingerprint = upstreamConnectionFingerprint(probe);
-			if (probe.upstreamKind !== "codex-app-server" || !fingerprint || fingerprint !== pinned.connectionFingerprint) continue;
-			try {
-				const threadId = await resolveThreadId(probe);
-				const page = await pinned.listTurnPage({
-					threadId,
-					limit: CODEX_UPSTREAM_TURN_LIMIT,
-					sortDirection: "desc",
-					itemsView: "full"
-				});
-				const marker = readMarker(probe);
-				if (page.data.length === 0 && marker) {
-					try {
-						await pinned.readThread(threadId, false);
-					} catch (error) {
-						if (isCodexThreadGoneError(error)) activities.push({
-							kind: "missing",
-							sessionKey: probe.sessionKey
-						});
-					}
-					continue;
-				}
-				const activity = classifyCodexUpstreamTurns({
-					probe,
-					turns: page.data
-				});
-				if (activity) activities.push(activity);
-			} catch {}
-		}
-		return activities;
-	});
+async function readNodeCodexHistory(params) {
+	const page = parseTranscriptPage(unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+		nodeId: params.nodeId,
+		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+		params: {
+			agentId: params.agentId,
+			threadId: params.record.threadId,
+			limit: 50
+		},
+		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+		scopes: ["operator.write"]
+	})));
+	const thread = {
+		id: params.record.threadId,
+		createdAt: params.record.createdAt ?? 0,
+		modelProvider: params.record.modelProvider ?? "openai",
+		turns: page.data.toReversed()
+	};
+	return {
+		thread,
+		throughTurnId: codexLastTerminalTurnId(thread, (value) => boundedCatalogString(value, 256)) ?? null
+	};
 }
-function createChecker(params) {
-	return async (probes) => await checkCodexUpstreamActivity(probes, params.control, async (probe) => {
-		const config = params.getRuntimeConfig();
-		const sessionId = params.api.runtime.agent.session.getSessionEntry({
-			agentId: probe.agentId,
-			sessionKey: probe.sessionKey,
-			readConsistency: "latest"
-		})?.sessionId?.trim();
-		if (!sessionId) return probe.threadId;
-		const binding = await params.bindingStore.read(sessionBindingIdentity({
-			sessionId,
-			sessionKey: probe.sessionKey,
-			config
-		}));
-		return binding?.connectionScope === "supervision" && binding.supervisionSourceThreadId === probe.threadId ? binding.threadId : probe.threadId;
+async function continueNodeCodexSessionInner(params) {
+	const { nodeId } = await requireNodeForCodexContinue({
+		runtime: params.api.runtime,
+		hostId: params.hostId
 	});
-}
-//#endregion
-//#region extensions/codex/src/session-catalog.ts
-const boundCatalogSessionId = (value) => boundedCatalogString(value, 256);
-const CODEX_SUPERVISION_SESSION_KEY_PREFIX = "harness:codex:supervision:";
-const CODEX_SESSION_CATALOG_LIST_TTL_MS = 32e3;
-const CODEX_SESSION_CATALOG_LIST_CACHE_MAX_ENTRIES = 32;
-function codexCatalogPageCacheKey(params) {
-	return JSON.stringify([
-		params.cursor ?? null,
-		params.limit ?? null,
-		params.searchTerm?.trim().toLocaleLowerCase() || null,
-		params.cwd?.trim() || null
-	]);
-}
-function createCodexSessionCatalogControlFromRequests(params) {
-	return {
-		...params.clientId ? { clientId: params.clientId } : {},
-		...params.connectionFingerprint ? { connectionFingerprint: params.connectionFingerprint } : {},
-		withPinnedConnection: params.withPinnedConnection,
-		async listPage(pageParams) {
-			const limit = normalizeLimit(pageParams.limit, "limit");
-			const search = pageParams.searchTerm?.trim().toLocaleLowerCase() || void 0;
-			const cwd = pageParams.cwd?.trim() || void 0;
-			const maxPages = search ? 20 : 1;
-			const sessions = [];
-			let cursor = readControlCursor(pageParams.cursor, "request");
-			let nextCursor;
-			let backwardsCursor;
-			const seenCursors = new Set(cursor ? [cursor] : []);
-			const requests = params.createRequestSnapshot();
-			const deadline = params.now() + requests.requestTimeoutMs;
-			for (let pageIndex = 0; pageIndex < maxPages; pageIndex += 1) {
-				const remaining = limit - sessions.length;
-				const remainingTimeoutMs = Math.ceil(deadline - params.now());
-				if (remainingTimeoutMs <= 0) throw new Error("Codex session catalog listing timed out");
-				const response = await requests.listThreads({
-					archived: false,
-					limit: remaining,
-					modelProviders: [],
-					sortKey: "updated_at",
-					sortDirection: "desc",
-					...cwd ? { cwd } : {},
-					...cursor ? { cursor } : {}
-				}, remainingTimeoutMs);
-				if (pageIndex === 0) backwardsCursor = readControlCursor(response.backwardsCursor, "backwards response");
-				sessions.push(...response.data.flatMap((thread) => {
-					const session = toCatalogSession(thread, false);
-					return session ? [session] : [];
-				}).filter((session) => !search || session.name?.toLocaleLowerCase().includes(search)));
-				nextCursor = readControlCursor(response.nextCursor, "next response");
-				if (!nextCursor || sessions.length >= limit) break;
-				if (seenCursors.has(nextCursor)) throw new Error("Codex session catalog returned a repeated search cursor");
-				seenCursors.add(nextCursor);
-				cursor = nextCursor;
-			}
-			return {
-				sessions,
-				...nextCursor ? { nextCursor } : {},
-				...backwardsCursor ? { backwardsCursor } : {}
-			};
-		},
-		async listDescendantPage(listParams) {
-			const requests = params.createRequestSnapshot();
-			return await requests.listThreads(listParams, requests.requestTimeoutMs);
-		},
-		async readThread(threadId, includeTurns = false) {
-			return await params.createRequestSnapshot().readThread(threadId, includeTurns);
-		},
-		async listTurnPage(listParams) {
-			return await params.createRequestSnapshot().listThreadTurns(listParams);
-		},
-		async forkThread(forkParams) {
-			return await params.createRequestSnapshot().forkThread(forkParams);
+	const record = await resolveNodeCodexRecord({
+		agentId: params.agentId,
+		runtime: params.api.runtime,
+		nodeId,
+		threadId: params.threadId
+	});
+	requireContinuableNodeRecord(record);
+	const existing = findNodeAdoptedSessionEntry({
+		agentId: params.agentId,
+		config: params.config,
+		runtime: params.api.runtime,
+		hostId: params.hostId,
+		threadId: params.threadId,
+		includeInitializing: true
+	});
+	let adopted;
+	let disposition;
+	if (existing) {
+		adopted = existing;
+		disposition = "existing";
+	} else {
+		const history = await readNodeCodexHistory({
+			agentId: params.agentId,
+			runtime: params.api.runtime,
+			nodeId,
+			record
+		});
+		adopted = await createOrReuseNodeAdoptedSession({
+			agentId: params.agentId,
+			api: params.api,
+			config: params.config,
+			hostId: params.hostId,
+			nodeId,
+			record,
+			history
+		});
+		disposition = "forked";
+	}
+	const marker = nodeSessionMarker({
+		hostId: params.hostId,
+		threadId: params.threadId,
+		nodeId
+	});
+	return {
+		sessionKey: adopted.key,
+		disposition,
+		conversationBinding: {
+			summary: "Continue this Codex session on its paired node.",
+			detachHint: "Start a new chat to leave the paired-node Codex session.",
+			data: createCodexCliNodeConversationBindingData({
+				nodeId,
+				sessionId: record.sessionId?.trim() || params.threadId,
+				agentId: adopted.agentId,
+				cwd: record.cwd
+			})
 		},
-		async archiveThread(threadId) {
-			await params.createRequestSnapshot().archiveThread(threadId);
-		}
+		afterConversationBound: async () => await finalizeNodeAdoptedSession({
+			api: params.api,
+			adopted,
+			marker
+		})
 	};
 }
-/** Builds the passive catalog over the Codex plugin's canonical shared client. */
-function createCodexSessionCatalogControl(params) {
-	const now = params.now ?? Date.now;
-	const getPluginConfig = () => params.getPluginConfig();
-	const requestOptionsByConfig = /* @__PURE__ */ new WeakMap();
-	const catalogPagesByConfig = /* @__PURE__ */ new WeakMap();
-	const resolveRequestOptions = (startOptions) => {
-		const runtimeConfig = params.getRuntimeConfig();
-		if (!runtimeConfig) return {
-			config: void 0,
-			startOptions: structuredClone(startOptions)
-		};
-		const cached = requestOptionsByConfig.get(runtimeConfig);
-		if (cached) return cached;
-		const resolved = {
-			config: structuredClone(runtimeConfig),
-			startOptions: structuredClone(startOptions)
-		};
-		requestOptionsByConfig.set(runtimeConfig, resolved);
-		return resolved;
-	};
-	const createRequestSnapshot = () => {
-		const pluginConfig = getPluginConfig();
-		const runtime = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig });
-		const requestOptions = resolveRequestOptions(runtime.start);
-		return {
-			requestTimeoutMs: runtime.requestTimeoutMs,
-			listThreads: async (listParams, timeoutMs) => await codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listThreads, listParams, {
-				...requestOptions,
-				timeoutMs
-			}),
-			readThread: async (threadId, includeTurns) => (await codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
-				threadId,
-				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);
-			}
-		};
-	};
-	const withPinnedConnection = async (run) => {
-		const runtime = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: getPluginConfig() });
-		const { config: runtimeConfig, startOptions } = resolveRequestOptions(runtime.start);
-		const client = await getLeasedSharedCodexAppServerClient({
-			config: runtimeConfig,
-			startOptions,
-			timeoutMs: runtime.requestTimeoutMs
+async function continueNodeCodexSession(params) {
+	if (params.clientScopes?.includes("operator.admin") !== true) throw new CatalogParamsError("continuing a paired-node Codex session requires operator.admin");
+	const nodeId = params.hostId.slice(5).trim();
+	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+	const agentId = resolveSessionAgentIds({
+		config: params.config,
+		agentId: params.agentId
+	}).defaultAgentId;
+	const sourceKey = sessionCatalogAdoptedSourceKey(`node:${nodeId}`, params.threadId);
+	const operationKey = sessionCatalogAdoptedSourceKey(agentId, sourceKey);
+	return await continueNodeAdoption({
+		sourceKey: operationKey,
+		findExisting: () => void 0,
+		create: () => runSessionActionExclusive(sourceKey, async () => continueNodeCodexSessionInner({
+			...params,
+			agentId
+		})),
+		complete: async (continued) => continued
+	});
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-listing.ts
+async function listVisiblePage(params) {
+	const excluded = params.excludedThreadIds;
+	const sessions = [];
+	let cursor = params.cursor;
+	let nextCursor;
+	let backwardsCursor;
+	const seenCursors = /* @__PURE__ */ new Set();
+	for (let pageIndex = 0; pageIndex < 20; pageIndex += 1) {
+		let excludedFromPage = false;
+		const rawPage = await params.control.listPage({
+			limit: params.limit - sessions.length,
+			...cursor ? { cursor } : {},
+			...params.searchTerm ? { searchTerm: params.searchTerm } : {},
+			...params.cwd ? { cwd: params.cwd } : {}
 		});
-		try {
-			const requests = {
-				requestTimeoutMs: runtime.requestTimeoutMs,
-				listThreads: async (listParams, timeoutMs) => await requestCodexAppServerClientJson({
-					client,
-					method: CODEX_CONTROL_METHODS.listThreads,
-					requestParams: listParams,
-					config: runtimeConfig,
-					timeoutMs
-				}),
-				readThread: async (threadId, includeTurns) => (await requestCodexAppServerClientJson({
-					client,
-					method: CODEX_CONTROL_METHODS.readThread,
-					requestParams: {
-						threadId,
-						includeTurns
-					},
-					config: runtimeConfig,
-					timeoutMs: runtime.requestTimeoutMs
-				})).thread,
-				listThreadTurns: async (listParams) => await requestCodexAppServerClientJson({
-					client,
-					method: CODEX_CONTROL_METHODS.listThreadTurns,
-					requestParams: listParams,
-					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,
-						method: CODEX_CONTROL_METHODS.archiveThread,
-						requestParams: { threadId },
-						config: runtimeConfig,
-						timeoutMs: runtime.requestTimeoutMs
-					});
-				}
-			};
-			const pinnedControl = createCodexSessionCatalogControlFromRequests({
-				clientId: resolveCodexAppServerClientInstanceId(client),
-				connectionFingerprint: buildCodexAppServerConnectionFingerprint(runtime, resolveDefaultAgentDir(runtimeConfig ?? {})),
-				createRequestSnapshot: () => requests,
-				now,
-				withPinnedConnection: async (nestedRun) => await nestedRun(pinnedControl)
-			});
-			return await run(pinnedControl);
-		} finally {
-			releaseLeasedSharedCodexAppServerClient(client);
+		const page = filterCatalogPageByTitle(parseCatalogPage(rawPage), params.searchTerm);
+		if (pageIndex === 0) backwardsCursor = page.backwardsCursor;
+		for (const managed of rawPage.managedThreads ?? []) {
+			excludedFromPage = true;
+			await params.onExcludedThread?.(managed);
 		}
-	};
-	const control = createCodexSessionCatalogControlFromRequests({
-		createRequestSnapshot,
-		now,
-		withPinnedConnection
-	});
-	return {
-		...control,
-		async listPage(pageParams) {
-			const runtimeConfig = params.getRuntimeConfig();
-			if (!runtimeConfig) return await control.listPage(pageParams);
-			let cache = catalogPagesByConfig.get(runtimeConfig);
-			if (!cache) {
-				cache = /* @__PURE__ */ new Map();
-				catalogPagesByConfig.set(runtimeConfig, cache);
-			}
-			const key = codexCatalogPageCacheKey(pageParams);
-			const cached = cache.get(key);
-			if (pageParams.forceRefresh !== true && cached) {
-				cache.delete(key);
-				cache.set(key, cached);
-				if (cached.stalePage) return await cached.stalePage;
-				if (cached.expiresAt > now()) return await cached.page;
-				const stalePage = cached.settledPage;
-				if (!stalePage) return await cached.page;
-				const page = control.listPage(pageParams);
-				const entry = {
-					expiresAt: Number.POSITIVE_INFINITY,
-					page,
-					settledPage: stalePage,
-					stalePage
-				};
-				cache.set(key, entry);
-				page.then(() => {
-					if (cache.get(key) === entry) {
-						delete entry.stalePage;
-						entry.settledPage = page;
-						entry.expiresAt = now() + CODEX_SESSION_CATALOG_LIST_TTL_MS;
-					}
-				}, async () => {
-					let stale;
-					try {
-						stale = await stalePage;
-					} catch {}
-					if (cache.get(key) !== entry) return;
-					if (stale) {
-						cache.delete(key);
-						const settledPage = Promise.resolve(stale);
-						cache.set(key, {
-							expiresAt: now(),
-							page: settledPage,
-							settledPage
-						});
-					} else cache.delete(key);
-				});
-				return await stalePage;
-			}
-			if (cached) cache.delete(key);
-			const serveStaleOnError = pageParams.forceRefresh !== true;
-			const page = control.listPage(pageParams);
-			const stalePage = cached?.settledPage;
-			const entry = {
-				expiresAt: Number.POSITIVE_INFINITY,
-				page,
-				...stalePage ? {
-					stalePage,
-					settledPage: stalePage
-				} : {}
-			};
-			cache.set(key, entry);
-			while (cache.size > CODEX_SESSION_CATALOG_LIST_CACHE_MAX_ENTRIES) {
-				const oldest = cache.keys().next();
-				if (oldest.done) break;
-				cache.delete(oldest.value);
-			}
-			try {
-				const result = await page;
-				if (cache.get(key) === entry) {
-					delete entry.stalePage;
-					entry.settledPage = page;
-					entry.expiresAt = now() + CODEX_SESSION_CATALOG_LIST_TTL_MS;
-				}
-				return result;
-			} catch (error) {
-				if (stalePage) {
-					let stale;
-					try {
-						stale = await stalePage;
-					} catch {}
-					if (stale) {
-						if (cache.get(key) === entry) {
-							cache.delete(key);
-							const settledPage = Promise.resolve(stale);
-							cache.set(key, {
-								expiresAt: now(),
-								page: settledPage,
-								settledPage
-							});
-						}
-						if (serveStaleOnError) return stale;
-					}
-				}
-				if (cache.get(key) === entry) cache.delete(key);
-				throw error;
+		for (const session of page.sessions) {
+			if (!excluded?.has(session.threadId)) {
+				sessions.push(session);
+				continue;
 			}
+			excludedFromPage = true;
+			await params.onExcludedThread?.({ threadId: session.threadId });
 		}
+		nextCursor = page.nextCursor;
+		if (!nextCursor || sessions.length >= params.limit || !excludedFromPage) break;
+		if (seenCursors.has(nextCursor)) throw new Error("Codex session catalog returned a repeated exclusion cursor");
+		seenCursors.add(nextCursor);
+		cursor = nextCursor;
+	}
+	return {
+		sessions: sessions.slice(0, params.limit),
+		...nextCursor ? { nextCursor } : {},
+		...backwardsCursor ? { backwardsCursor } : {}
 	};
 }
 async function listGatewayHost(params) {
+	const hostId = params.source?.hostId ?? "gateway:local";
+	const label = params.source?.label ?? "Local Codex";
+	const sourceHomeId = params.source?.sourceHomeId ?? "gateway:local";
 	try {
-		const page = parseCatalogPage(await params.control.listPage({
+		const page = await listVisiblePage({
+			control: params.control,
+			cursor: params.query.cursors?.[hostId],
+			excludedThreadIds: params.excludedThreadIds,
 			limit: params.query.limitPerHost,
-			...params.query.cursors?.["gateway:local"] ? { cursor: params.query.cursors[CODEX_LOCAL_SESSION_HOST_ID] } : {},
-			...params.query.search ? { searchTerm: params.query.search } : {}
-		}));
+			onExcludedThread: params.onExcludedThread,
+			searchTerm: params.query.search
+		});
 		const adoptedSessions = await listAdoptedSessionEntries({
+			agentId: params.agentId,
 			bindingStore: params.bindingStore,
 			config: params.config,
 			runtime: params.runtime,
 			sessionEntries: params.sessionEntries
 		});
 		return {
-			hostId: CODEX_LOCAL_SESSION_HOST_ID,
-			label: "Local Codex",
+			hostId,
+			label,
 			kind: "gateway",
 			connected: true,
 			...page,
 			sessions: page.sessions.map((session) => {
-				const adopted = adoptedSessions.get(session.threadId);
-				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
+				const adopted = adoptedSessions.get(sessionCatalogAdoptedSourceKey(sourceHomeId, session.threadId)) ?? (hostId === "gateway:local" ? adoptedSessions.get(sessionCatalogAdoptedSourceKey("gateway:local", session.threadId)) : void 0);
+				const sourced = params.source ? Object.assign({}, session, { sourceHomeId: params.source.sourceHomeId }) : session;
+				return adopted ? Object.assign({}, sourced, { sessionKey: adopted.key }) : sourced;
 			})
 		};
 	} catch (error) {
 		return {
-			hostId: CODEX_LOCAL_SESSION_HOST_ID,
-			label: "Local Codex",
+			hostId,
+			label,
 			kind: "gateway",
 			connected: false,
 			sessions: [],
@@ -2067,16 +1903,37 @@ async function listGatewayHost(params) {
 }
 /** Lists Gateway-local and paired-node Codex sessions with per-host failures. */
 async function listCodexSessionCatalog(params) {
+	const agentId = resolveSessionAgentIds({
+		config: params.config ?? {},
+		agentId: params.agentId
+	}).sessionAgentId;
 	const query = readGatewayParams(params.query);
 	const requestedHostIds = query.hostIds ? new Set(query.hostIds) : void 0;
-	const localHosts = params.includeLocal !== false && (!requestedHostIds || requestedHostIds.has("gateway:local")) ? [listGatewayHost({
-		bindingStore: params.bindingStore,
-		config: params.config,
-		control: params.control,
-		query,
-		runtime: params.runtime,
-		sessionEntries: params.sessionEntries
-	})] : [];
+	const localSources = params.localHomes?.filter((source) => !requestedHostIds || requestedHostIds.has(source.hostId)) ?? (params.includeLocal !== false && (!requestedHostIds || requestedHostIds.has("gateway:local")) ? [void 0] : []);
+	const managedThreads = await params.bindingStore.managedThreads?.snapshot();
+	const fallbackSource = params.control.homesForAgent(agentId)[0];
+	const localHosts = localSources.map((source) => (() => {
+		const ownershipSource = source ?? fallbackSource;
+		const managedThreadIds = ownershipSource ? managedThreads?.get(ownershipSource.sourceHomeId) : void 0;
+		return listGatewayHost({
+			agentId,
+			bindingStore: params.bindingStore,
+			config: params.config,
+			control: params.control.forRequest(agentId, ownershipSource),
+			query,
+			runtime: params.runtime,
+			sessionEntries: params.sessionEntries,
+			excludedThreadIds: managedThreadIds,
+			...ownershipSource && params.bindingStore.managedThreads ? { onExcludedThread: async ({ threadId, rolloutPath }) => {
+				if (!managedThreadIds?.has(threadId)) await params.bindingStore.managedThreads?.mark({
+					sourceHomeId: ownershipSource.sourceHomeId,
+					threadId,
+					...rolloutPath ? { rolloutPath } : {}
+				});
+			} } : {},
+			...source ? { source } : {}
+		});
+	})());
 	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;
@@ -2095,12 +1952,14 @@ async function listCodexSessionCatalog(params) {
 		return { hosts: [...await Promise.all(localHosts), registryHost] };
 	}
 	const adoptedNodeSessions = listNodeAdoptedSessionEntries({
+		agentId,
 		config: params.config,
 		runtime: params.runtime,
 		sessionEntries: params.sessionEntries
 	});
 	const nodeHosts = nodes.toSorted(compareNodeLabels).map(async (node) => {
 		const host = await listPairedNode({
+			agentId,
 			runtime: params.runtime,
 			node,
 			query,
@@ -2112,16 +1971,55 @@ async function listCodexSessionCatalog(params) {
 	return { hosts: await Promise.all([...localHosts, ...nodeHosts]) };
 }
 /** Builds the node-local read-only Codex app-server catalog command. */
-function createCodexSessionCatalogNodeHostCommands(control, configSources) {
+function createCodexSessionCatalogNodeHostCommands(controlFactory, configSources, bindingStore) {
+	const bindRequest = (paramsJSON) => {
+		const parsed = parseJsonParams(paramsJSON);
+		if (!isRecord(parsed)) throw new CatalogParamsError("Codex session catalog parameters must be an object");
+		const requestedAgentId = readBoundedOptionalString(parsed, "agentId", 256);
+		const config = configSources.getRuntimeConfig() ?? {};
+		const agentId = resolveSessionAgentIds({
+			config,
+			agentId: requestedAgentId
+		}).sessionAgentId;
+		if (!listAgentIds(config).includes(agentId)) throw new CatalogParamsError(`unknown Codex session catalog agent: ${agentId}`);
+		const request = { ...parsed };
+		delete request.agentId;
+		const source = controlFactory.homesForAgent(agentId)[0];
+		return {
+			agentId,
+			control: controlFactory.forRequest(agentId, source),
+			sourceHomeId: source?.sourceHomeId,
+			params: request,
+			paramsJSON: JSON.stringify(request)
+		};
+	};
 	return [
 		{
 			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
 			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
 			dangerous: false,
 			handle: async (paramsJSON) => {
-				const pageParams = readPageParams(parseJsonParams(paramsJSON));
+				const request = bindRequest(paramsJSON);
+				const pageParams = readPageParams(request.params);
 				try {
-					const page = filterCatalogPageByTitle(parseCatalogPage(await control.listPage(pageParams)), pageParams.searchTerm);
+					const managedThreads = await bindingStore?.managedThreads?.snapshot();
+					const sourceHomeId = request.sourceHomeId;
+					const managedThreadIds = sourceHomeId ? managedThreads?.get(sourceHomeId) : void 0;
+					const page = await listVisiblePage({
+						control: request.control,
+						cursor: pageParams.cursor,
+						cwd: pageParams.cwd,
+						excludedThreadIds: managedThreadIds,
+						limit: pageParams.limit,
+						...sourceHomeId && bindingStore?.managedThreads ? { onExcludedThread: async ({ threadId, rolloutPath }) => {
+							if (!managedThreadIds?.has(threadId)) await bindingStore.managedThreads?.mark({
+								sourceHomeId,
+								threadId,
+								...rolloutPath ? { rolloutPath } : {}
+							});
+						} } : {},
+						searchTerm: pageParams.searchTerm
+					});
 					return JSON.stringify(page);
 				} catch {
 					throw new Error("Codex app-server catalog is unavailable");
@@ -2133,10 +2031,11 @@ function createCodexSessionCatalogNodeHostCommands(control, configSources) {
 			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
 			dangerous: false,
 			handle: async (paramsJSON) => {
-				const action = readNodeTranscriptParams(parseJsonParams(paramsJSON));
+				const request = bindRequest(paramsJSON);
+				const action = readNodeTranscriptParams(request.params);
 				try {
-					await requireCatalogEligibleThread(control, action.threadId);
-					const page = parseTranscriptPage(await control.listTurnPage({
+					await requireCatalogEligibleThread(request.control, action.threadId);
+					const page = parseTranscriptPage(await request.control.listTurnPage({
 						threadId: action.threadId,
 						limit: action.limit,
 						sortDirection: "desc",
@@ -2150,7 +2049,7 @@ function createCodexSessionCatalogNodeHostCommands(control, configSources) {
 				}
 			}
 		},
-		createCodexTerminalNodeHostCommand(control, configSources)
+		createCodexTerminalNodeHostCommand(bindRequest, configSources)
 	];
 }
 function readNodeTranscriptParams(value) {
@@ -2179,18 +2078,19 @@ function flattenTranscriptPageDesc(page) {
 }
 /** Reads the persisted transcript for a Gateway-local or paired-node Codex session. */
 async function readCodexSessionTranscript(params) {
-	if (params.hostId === "gateway:local") {
+	if (params.source || params.hostId === "gateway:local") {
 		await requireCatalogEligibleThread(params.control, params.threadId);
-		const page = parseTranscriptPage(await params.control.listTurnPage({
+		const listParams = {
 			threadId: params.threadId,
 			limit: params.limit,
 			sortDirection: "desc",
 			itemsView: "full",
 			...params.cursor ? { cursor: params.cursor } : {}
-		}));
+		};
+		const page = parseTranscriptPage(await params.control.listTurnPage(listParams));
 		return {
 			hostId: params.hostId,
-			label: "Local Codex",
+			label: params.source?.label ?? "Local Codex",
 			threadId: params.threadId,
 			items: flattenTranscriptPageDesc(page),
 			...page.nextCursor ? { nextCursor: page.nextCursor } : {},
@@ -2204,6 +2104,7 @@ async function readCodexSessionTranscript(params) {
 		nodeId,
 		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
 		params: {
+			agentId: params.agentId,
 			threadId: params.threadId,
 			limit: params.limit,
 			...params.cursor ? { cursor: params.cursor } : {}
@@ -2220,332 +2121,629 @@ async function readCodexSessionTranscript(params) {
 		...page.backwardsCursor ? { backwardsCursor: page.backwardsCursor } : {}
 	};
 }
-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) {
-	const digest = createHash("sha256").update(threadId).digest("hex");
-	return `${CODEX_SUPERVISION_SESSION_KEY_PREFIX}${digest}`;
-}
-function isAdoptionSessionKeyForThread(sessionKey, threadId) {
-	return adoptionSessionKeyRest(sessionKey) === adoptionSessionKey(threadId);
-}
-async function listAdoptedSessionEntries(params) {
-	const adopted = /* @__PURE__ */ new Map();
-	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();
-		if (!sessionId) continue;
-		const binding = await 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)) continue;
-		if (adopted.has(sourceThreadId)) throw new Error(`multiple OpenClaw sessions adopt Codex thread ${sourceThreadId}`);
-		adopted.set(sourceThreadId, {
-			key: sessionKey,
-			sessionId,
-			agentId,
-			boundThreadId
-		});
-	}
-	return adopted;
-}
-async function findAdoptedSessionEntry(params) {
-	return (await listAdoptedSessionEntries(params)).get(params.threadId);
-}
-async function clearCreatedAdoptionBinding(params) {
-	let cleared = false;
-	let clearError;
-	try {
-		cleared = await params.bindingStore.mutate(params.identity, {
-			kind: "clear",
-			threadId: params.sourceThreadId,
-			expectedPendingSupervisionBranch: params.expectedPending
-		});
-	} catch (error) {
-		clearError = error;
-	}
-	if (cleared) return;
-	let current;
-	try {
-		current = await params.bindingStore.read(params.identity);
-	} catch (readError) {
-		throw new AggregateError([
-			params.cause,
-			...clearError ? [clearError] : [],
-			readError
-		], `OpenClaw session creation failed and the Codex binding could not be verified for ${params.sourceThreadId}`, { cause: readError });
-	}
-	if (!matchesPendingSupervisionOwner(current, params.expectedPending)) return;
-	throw new AggregateError([params.cause, ...clearError ? [clearError] : []], `OpenClaw session creation failed and the Codex binding could not be cleared for ${params.sourceThreadId}`, { cause: params.cause });
-}
-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));
+//#endregion
+//#region extensions/codex/src/session-catalog-transcript-item.ts
+const CODEX_MESSAGE_TYPES = /* @__PURE__ */ new Map([
+	["userMessage", "userMessage"],
+	["agentMessage", "agentMessage"],
+	["reasoning", "reasoning"]
+]);
+const CODEX_TOOL_TYPES = /* @__PURE__ */ new Set([
+	"commandExecution",
+	"fileChange",
+	"mcpToolCall",
+	"dynamicToolCall",
+	"collabAgentToolCall",
+	"webSearch",
+	"imageView",
+	"imageGeneration"
+]);
+function toGenericTranscriptItem(item) {
+	let type = CODEX_MESSAGE_TYPES.get(item.type);
+	if (!type && CODEX_TOOL_TYPES.has(item.type)) type = item.result !== void 0 || Boolean(item.aggregatedOutput) ? "toolResult" : "toolCall";
+	type ??= "other";
+	const fallback = item.title ?? item.name ?? item.tool ?? item.command ?? item.query ?? void 0;
+	const resultText = item.aggregatedOutput || (item.result === void 0 ? void 0 : JSON.stringify(item.result, null, 2));
+	const changesText = Array.isArray(item.changes) ? item.changes.map((change) => `${change.kind}: ${change.path}`).join("\n") || void 0 : void 0;
+	const text = item.text || resultText || changesText || fallback;
+	return {
+		id: item.id,
+		type,
+		...text ? { text } : {},
+		raw: item
+	};
 }
-function matchesPendingSupervisionOwner(binding, expected) {
-	const pending = binding?.pendingSupervisionBranch;
-	const cleanupThreadIds = pending?.cleanupThreadIds ?? [];
-	const expectedCleanupThreadIds = expected.cleanupThreadIds ?? [];
-	return binding?.threadId === expected.sourceThreadId && binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && pending?.sourceThreadId === expected.sourceThreadId && pending.connectionFingerprint === expected.connectionFingerprint && pending.lastTurnId === expected.lastTurnId && cleanupThreadIds.length === expectedCleanupThreadIds.length && cleanupThreadIds.every((threadId, index) => threadId === expectedCleanupThreadIds[index]);
+//#endregion
+//#region extensions/codex/src/session-upstream-activity.ts
+const CODEX_UPSTREAM_TURN_LIMIT = 100;
+const CODEX_APP_SERVER_INVALID_REQUEST_CODE = -32600;
+const CODEX_THREAD_NOT_LOADED_MESSAGE_PREFIX = "thread not loaded:";
+function isCodexThreadGoneError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === CODEX_APP_SERVER_INVALID_REQUEST_CODE && error.message.startsWith(CODEX_THREAD_NOT_LOADED_MESSAGE_PREFIX);
 }
-async function ensurePendingAdoptionBinding(params) {
-	const pending = {
-		sourceThreadId: params.sourceThreadId,
-		connectionFingerprint: params.connectionFingerprint,
-		...params.lastTurnId ? { lastTurnId: params.lastTurnId } : {}
+function readMarker(probe) {
+	if (!isRecord(probe.marker)) return;
+	const turnId = probe.marker.turnId;
+	if (turnId !== null && typeof turnId !== "string") return;
+	const count = probe.marker.userMessageCount;
+	if (count !== void 0 && (!Number.isSafeInteger(count) || count < 0)) return;
+	return {
+		turnId,
+		...count === void 0 ? {} : { userMessageCount: count }
 	};
-	if (!await reclaimCurrentCodexSessionGeneration({
-		bindingStore: params.bindingStore,
-		identity: params.identity,
-		config: params.config
-	})) throw new Error(`failed to claim the OpenClaw session generation for ${params.sourceThreadId}`);
-	const existing = await params.bindingStore.read(params.identity);
-	if (existing) {
-		if (matchesPendingAdoptionBinding(existing, params)) return;
-		throw new Error(`OpenClaw session is already bound to Codex thread ${existing.threadId}`);
+}
+function upstreamConnectionFingerprint(probe) {
+	return isRecord(probe.upstreamRef) && typeof probe.upstreamRef.connectionFingerprint === "string" ? probe.upstreamRef.connectionFingerprint : void 0;
+}
+function classifyCodexUpstreamTurns(params) {
+	const marker = readMarker(params.probe);
+	if (!marker) return;
+	const newest = params.turns[0];
+	if (!newest?.id) return;
+	const markerIndex = marker.turnId === null ? -1 : params.turns.findIndex((turn) => turn.id === marker.turnId);
+	const candidateTurns = markerIndex < 0 ? params.turns : params.turns.slice(0, markerIndex + 1);
+	const newestUserMessageCount = countUserMessages(newest);
+	if (!(marker.turnId !== newest.id || marker.userMessageCount === void 0 || newestUserMessageCount > marker.userMessageCount)) return;
+	const ownTexts = new Set(params.probe.ownRecentUserTexts);
+	let humanTurns = 0;
+	let occurredAt;
+	for (const turn of candidateTurns) {
+		const userMessages = turn.items.filter((item) => item.type === "userMessage");
+		const alreadySeen = turn.id === marker.turnId ? marker.userMessageCount ?? userMessages.length : 0;
+		for (const item of userMessages.slice(alreadySeen)) {
+			const texts = normalizeUserMessageTexts(item);
+			if (ownTexts.has(texts.join(" ")) || texts.length > 1 && texts.every((text) => ownTexts.has(text))) continue;
+			humanTurns += 1;
+			if (occurredAt === void 0) {
+				const timestampSeconds = turn.completedAt ?? turn.startedAt;
+				occurredAt = typeof timestampSeconds === "number" && Number.isFinite(timestampSeconds) ? timestampSeconds * 1e3 : params.now ?? Date.now();
+			}
+		}
 	}
-	const binding = {
-		threadId: params.sourceThreadId,
-		connectionScope: "supervision",
-		supervisionSourceThreadId: params.sourceThreadId,
-		cwd: params.cwd,
-		historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
-		conversationSourceTransferComplete: true,
-		preserveNativeModel: true,
-		pendingSupervisionBranch: pending
+	const activityId = `${newest.id}:${newestUserMessageCount}`;
+	return {
+		kind: "activity",
+		sessionKey: params.probe.sessionKey,
+		humanTurns,
+		nextMarker: {
+			turnId: newest.id,
+			userMessageCount: newestUserMessageCount
+		},
+		...humanTurns > 0 ? {
+			occurredAt: occurredAt ?? params.now ?? Date.now(),
+			dedupeId: activityId
+		} : {}
 	};
-	let stored;
-	try {
-		stored = await params.bindingStore.mutate(params.identity, {
-			kind: "set",
-			if: { kind: "absent" },
-			binding
-		});
-	} catch (error) {
-		if (matchesPendingAdoptionBinding(await params.bindingStore.read(params.identity), params)) return;
-		throw error;
-	}
-	if (stored) return;
-	if (!matchesPendingAdoptionBinding(await params.bindingStore.read(params.identity), params)) throw new Error(`failed to bind OpenClaw session to Codex thread ${params.sourceThreadId}`);
 }
-async function createOrReuseAdoptedSession(params) {
-	const existing = await findAdoptedSessionEntry({
-		bindingStore: params.bindingStore,
-		config: params.config,
-		runtime: params.api.runtime,
-		threadId: params.sourceThread.id
-	});
-	if (existing) return existing;
-	let createdBindingIdentity;
-	let createdPendingBinding;
-	try {
-		const spawnedCwd = params.sourceThread.cwd?.trim() || void 0;
-		const pendingLastTurnId = codexLastTerminalTurnId(params.sourceThread, boundCatalogSessionId);
-		const marker = { sourceThreadId: params.sourceThread.id };
-		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,
-			initialEntry: {
-				agentHarnessId: "codex",
-				modelSelectionLocked: true,
-				pluginExtensions: { codex: { supervision: {
-					...marker,
-					initializing: true,
-					modelLocked: true
-				} } }
-			},
-			afterImport: async (entry) => {
-				createdBindingIdentity = sessionBindingIdentity({
-					sessionId: entry.sessionId,
-					sessionKey: entry.key,
-					config: params.config
+function countUserMessages(turn) {
+	return turn.items.filter((item) => item.type === "userMessage").length;
+}
+function normalizeUserMessageTexts(item) {
+	const typed = item;
+	const contentTexts = typed.content?.filter((input) => input.type === "text").map((input) => input.text.trim().replace(/\s+/g, " ")).filter(Boolean);
+	return contentTexts?.length ? contentTexts : [(typed.text ?? "").trim().replace(/\s+/g, " ")];
+}
+async function checkCodexUpstreamActivity(probes, control, resolveThreadId = async (probe) => probe.threadId) {
+	return await control.withPinnedConnection(async (pinned) => {
+		const activities = [];
+		for (const probe of probes) {
+			const fingerprint = upstreamConnectionFingerprint(probe);
+			if (probe.upstreamKind !== "codex-app-server" || !fingerprint || fingerprint !== pinned.connectionFingerprint) continue;
+			try {
+				const threadId = await resolveThreadId(probe);
+				const page = await pinned.listTurnPage({
+					threadId,
+					limit: CODEX_UPSTREAM_TURN_LIMIT,
+					sortDirection: "desc",
+					itemsView: "full"
 				});
-				createdPendingBinding = {
-					sourceThreadId: params.sourceThread.id,
-					connectionFingerprint: params.connectionFingerprint,
-					...pendingLastTurnId ? { lastTurnId: pendingLastTurnId } : {}
-				};
-				await ensurePendingAdoptionBinding({
-					bindingStore: params.bindingStore,
-					config: params.config,
-					identity: createdBindingIdentity,
-					sourceThreadId: params.sourceThread.id,
-					connectionFingerprint: params.connectionFingerprint,
-					cwd: spawnedCwd ?? "",
-					...pendingLastTurnId ? { lastTurnId: pendingLastTurnId } : {}
+				const marker = readMarker(probe);
+				if (page.data.length === 0 && marker) {
+					try {
+						await pinned.readThread(threadId, false);
+					} catch (error) {
+						if (isCodexThreadGoneError(error)) activities.push({
+							kind: "missing",
+							sessionKey: probe.sessionKey
+						});
+					}
+					continue;
+				}
+				const activity = classifyCodexUpstreamTurns({
+					probe,
+					turns: page.data
 				});
-				return { pluginExtensions: { codex: { supervision: {
-					...marker,
-					modelLocked: true
-				} } } };
-			}
-		});
-		return {
-			key: created.key,
-			sessionId: created.sessionId,
-			agentId: created.agentId,
-			boundThreadId: params.sourceThread.id
-		};
-	} catch (error) {
-		let raced = await findAdoptedSessionEntry({
-			bindingStore: params.bindingStore,
-			config: params.config,
-			runtime: params.api.runtime,
-			threadId: params.sourceThread.id
-		});
-		if (raced) return raced;
-		if (createdBindingIdentity && createdPendingBinding) {
-			await clearCreatedAdoptionBinding({
-				bindingStore: params.bindingStore,
-				identity: createdBindingIdentity,
-				sourceThreadId: params.sourceThread.id,
-				expectedPending: createdPendingBinding,
-				cause: error
-			});
-			raced = await findAdoptedSessionEntry({
-				bindingStore: params.bindingStore,
-				config: params.config,
-				runtime: params.api.runtime,
-				threadId: params.sourceThread.id
-			});
-			if (raced) return raced;
+				if (activity) activities.push(activity);
+			} catch {}
 		}
-		throw error;
-	}
-}
-async function continueLocalCodexSessionInner(params) {
-	await requireCatalogEligibleThread(params.control, params.threadId);
-	const existing = await findAdoptedSessionEntry({
-		bindingStore: params.bindingStore,
-		config: params.config,
-		runtime: params.api.runtime,
-		threadId: params.threadId
-	});
-	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 };
-			}
-		})) 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({
-		api: params.api,
-		bindingStore: params.bindingStore,
-		config: params.config,
-		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 activities;
 	});
-	return {
-		sessionKey: adopted.key,
-		disposition: "forked"
+}
+function createChecker(params) {
+	const resolveThreadId = async (probe) => {
+		const config = params.getRuntimeConfig();
+		const sessionId = params.api.runtime.agent.session.getSessionEntry({
+			agentId: probe.agentId,
+			sessionKey: probe.sessionKey,
+			readConsistency: "latest"
+		})?.sessionId?.trim();
+		if (!sessionId) return probe.threadId;
+		const binding = await params.bindingStore.read(sessionBindingIdentity({
+			sessionId,
+			sessionKey: probe.sessionKey,
+			config
+		}));
+		return binding?.connectionScope === "supervision" && binding.supervisionSourceThreadId === probe.threadId ? binding.threadId : probe.threadId;
+	};
+	return async (probes) => {
+		const groups = /* @__PURE__ */ new Map();
+		for (const probe of probes) {
+			const fingerprint = upstreamConnectionFingerprint(probe);
+			if (!fingerprint) continue;
+			const control = params.control.forUpstream(probe.agentId, fingerprint);
+			if (!control) continue;
+			const key = `${probe.agentId}\0${fingerprint}`;
+			const group = groups.get(key) ?? {
+				control,
+				probes: []
+			};
+			group.probes.push(probe);
+			groups.set(key, group);
+		}
+		return (await Promise.all([...groups.values()].map((group) => checkCodexUpstreamActivity(group.probes, group.control, resolveThreadId)))).flat();
 	};
 }
-/** Creates one locked OpenClaw branch whose first harness run forks the Codex source. */
-async function continueLocalCodexSession(params) {
-	const sourceKey = adoptedSourceKey(CODEX_LOCAL_SESSION_HOST_ID, params.threadId);
-	const current = continueOperations.get(sourceKey);
-	if (current) return await current;
-	const operation = runSessionActionExclusive(sourceKey, async () => params.control.withPinnedConnection(async (control) => continueLocalCodexSessionInner({
-		...params,
-		control
-	})));
-	continueOperations.set(sourceKey, operation);
+//#endregion
+//#region extensions/codex/src/session-catalog-homes.ts
+function existingCatalogHomeCandidates(value, label) {
+	const codexHome = canonicalCodexCatalogHome(value);
 	try {
-		return await operation;
-	} finally {
-		if (continueOperations.get(sourceKey) === operation) continueOperations.delete(sourceKey);
+		if (!fsSync.statSync(codexHome).isDirectory()) return [];
+	} catch {
+		return [];
 	}
+	return [{
+		codexHome,
+		label: `Local Codex · ${label ?? path.basename(codexHome)}`
+	}];
 }
-async function assertNoPendingSupervisionBranch(params) {
-	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();
-		if (!sessionId) continue;
-		const binding = await params.bindingStore.read(sessionBindingIdentity({
-			sessionId,
-			sessionKey: adopted.sessionKey,
-			config: params.config
+/** Resolves every local Codex store the operator already owns, without path disclosure. */
+function resolveCodexCatalogHomes(params) {
+	const { config, env, ownerAgentId, pluginConfig } = params;
+	const ownerAgentDir = resolveAgentDir(config, ownerAgentId, env);
+	const configuredHomes = readCodexPluginConfig(pluginConfig).sessionCatalog?.homes ?? [];
+	const base = resolveCodexSupervisionAppServerRuntimeOptions({
+		pluginConfig,
+		env,
+		agentDir: ownerAgentDir,
+		config
+	});
+	const primaryCodexHome = canonicalCodexCatalogHome(resolveCodexAppServerLocalHomeDir(base.start, ownerAgentDir, env));
+	const processUserHome = canonicalCodexCatalogHome(resolveCodexAppServerUserHomeDir(env));
+	const processHomeConfigured = Boolean(env.CODEX_HOME?.trim());
+	const candidates = [{
+		codexHome: primaryCodexHome,
+		label: "Local Codex",
+		usesProcessHomeFallback: base.start.transport === "stdio" && base.start.homeScope === "user" && !processHomeConfigured
+	}];
+	if (base.start.transport === "stdio") {
+		candidates.push({
+			codexHome: processUserHome,
+			label: "Local Codex · user",
+			usesProcessHomeFallback: !processHomeConfigured
+		});
+		const agentIds = listAgentIds(config).toSorted((left, right) => left === ownerAgentId ? -1 : right === ownerAgentId ? 1 : left.localeCompare(right));
+		candidates.push(...agentIds.flatMap((agentId) => existingCatalogHomeCandidates(resolveCodexAppServerHomeDir(resolveAgentDir(config, agentId, env)), agentId)), ...configuredHomes.flatMap((entry) => {
+			const { path: home, label } = typeof entry === "string" ? { path: entry } : entry;
+			return existingCatalogHomeCandidates(home, label);
 		}));
-		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");
 	}
+	const seen = /* @__PURE__ */ new Set();
+	const homes = [];
+	for (const candidate of candidates) {
+		if (seen.has(candidate.codexHome)) continue;
+		seen.add(candidate.codexHome);
+		const sourceHomeId = codexCatalogHomeId(candidate.codexHome);
+		const primary = homes.length === 0;
+		homes.push({
+			sourceHomeId,
+			hostId: primary ? CODEX_LOCAL_SESSION_HOST_ID : `${CODEX_LOCAL_SESSION_HOST_ID}:${sourceHomeId}`,
+			label: candidate.label,
+			agentDir: ownerAgentDir,
+			appServer: primary ? base : {
+				...base,
+				start: {
+					...base.start,
+					homeScope: "user",
+					env: {
+						...base.start.env,
+						CODEX_HOME: candidate.codexHome
+					}
+				}
+			},
+			...base.connectionClass === "remote" ? {} : { localSessionsRoot: path.join(candidate.codexHome, "sessions") },
+			usesProcessHomeFallback: candidate.usesProcessHomeFallback ?? false
+		});
+		if (homes.length >= 100) break;
+	}
+	return homes;
+}
+/** Discovers Codex homes once per immutable Gateway config generation. */
+function createCodexCatalogHomeResolver(params) {
+	const env = params.env ?? process.env;
+	const homesByConfig = /* @__PURE__ */ new WeakMap();
+	const buildSnapshot = (config) => {
+		const pluginConfig = params.getPluginConfig();
+		const homesByAgent = new Map(listAgentIds(config).map((agentId) => [agentId, resolveCodexCatalogHomes({
+			config,
+			pluginConfig,
+			ownerAgentId: agentId,
+			env
+		})]));
+		replaceCodexCatalogConnectionHomes([...homesByAgent.values()].flatMap((homes) => homes.filter((home) => home.appServer.start.transport === "stdio").map((home) => ({
+			agentDir: home.agentDir,
+			fingerprint: buildCodexAppServerConnectionFingerprint(home.appServer, home.agentDir),
+			codexHome: resolveCodexAppServerLocalHomeDir(home.appServer.start, home.agentDir, env)
+		}))));
+		homesByConfig.set(config, homesByAgent);
+		return homesByAgent;
+	};
+	let lastSnapshot = buildSnapshot(params.config);
+	return { forAgent(agentId) {
+		const config = params.getRuntimeConfig();
+		if (!config) return lastSnapshot.get(agentId) ?? [];
+		const cached = homesByConfig.get(config);
+		if (cached) return cached.get(agentId) ?? [];
+		lastSnapshot = buildSnapshot(config);
+		return lastSnapshot.get(agentId) ?? [];
+	} };
 }
-/** Archives one inactive Gateway-local Codex thread after a fresh status read. */
-async function archiveLocalCodexSession(params) {
-	return await runSessionActionExclusive(adoptedSourceKey(CODEX_LOCAL_SESSION_HOST_ID, params.threadId), async () => {
-		return await params.bindingStore.withThreadArchiveFence(async () => {
-			return await params.control.withPinnedConnection(async (control) => {
-				await requireCatalogEligibleThread(control, params.threadId);
-				await assertNoPendingSupervisionBranch(params);
-				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");
+//#endregion
+//#region extensions/codex/src/session-catalog-provenance.ts
+const MAX_SESSION_META_BYTES = 1024 * 1024;
+const SESSION_META_READ_CHUNK_BYTES = 64 * 1024;
+const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
+const provenanceByPath = /* @__PURE__ */ new Map();
+function cacheProvenance(key, value) {
+	provenanceByPath.delete(key);
+	provenanceByPath.set(key, value);
+	while (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) {
+		const oldest = provenanceByPath.keys().next().value;
+		if (oldest === void 0) break;
+		provenanceByPath.delete(oldest);
+	}
+}
+/** Undefined means the metadata line is not durable enough to cache yet. */
+async function readOpenClawOriginator(sessionsRoot, rolloutPath, threadId) {
+	let safeRoot;
+	try {
+		safeRoot = await root(sessionsRoot, {
+			hardlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER,
+			symlinks: "reject"
+		});
+	} catch {
+		return;
+	}
+	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
+	for (const candidate of candidates) {
+		let opened;
+		try {
+			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
+		} catch {
+			continue;
+		}
+		const input = opened.handle.createReadStream({
+			autoClose: false,
+			highWaterMark: SESSION_META_READ_CHUNK_BYTES
+		});
+		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
+		try {
+			const chunks = [];
+			let bytesReadTotal = 0;
+			let line;
+			for await (const value of reader) {
+				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
+				if (remaining <= 0) break;
+				const bounded = chunk.subarray(0, remaining);
+				bytesReadTotal += bounded.length;
+				const newline = bounded.indexOf(10);
+				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
+				if (newline >= 0) {
+					line = Buffer.concat(chunks).toString("utf8");
+					break;
+				}
+			}
+			if (!line) continue;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (!isRecord(parsed) || parsed.type !== "session_meta" || !isRecord(parsed.payload)) return false;
+			const payload = parsed.payload;
+			return (payload.id ?? payload.session_id) === threadId && payload.originator === "openclaw";
+		} catch {
+			continue;
+		} finally {
+			reader.destroy();
+			input.destroy();
+			await opened.handle.close().catch(() => void 0);
+		}
+	}
+}
+/**
+* Codex 0.147 reports OpenClaw app-server rollouts as `vscode`, so the rollout's
+* immutable session metadata is the authoritative historical provenance.
+*/
+async function isOpenClawManagedCodexThread(thread, localSessionsRoot) {
+	const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+	if (!localSessionsRoot || !rolloutPath) return false;
+	const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
+	const cached = provenanceByPath.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const managed = await readOpenClawOriginator(localSessionsRoot, rolloutPath, thread.id);
+	if (managed !== void 0) cacheProvenance(cacheKey, managed);
+	return managed ?? false;
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-control.ts
+const CODEX_SESSION_CATALOG_LIST_TTL_MS = 32e3;
+const CODEX_SESSION_CATALOG_LIST_CACHE_MAX_ENTRIES = 32;
+function codexCatalogPageCacheKey(params, agentId, source) {
+	return JSON.stringify([
+		agentId,
+		source?.sourceHomeId ?? null,
+		params.cursor ?? null,
+		params.limit ?? null,
+		params.searchTerm?.trim().toLocaleLowerCase() || null,
+		params.cwd?.trim() || null
+	]);
+}
+function createCodexCatalogRequestSnapshot(requestTimeoutMs, request) {
+	return {
+		requestTimeoutMs,
+		listThreads: (params, timeoutMs) => request(CODEX_CONTROL_METHODS.listThreads, params, timeoutMs),
+		listThreadTurns: (params) => request(CODEX_CONTROL_METHODS.listThreadTurns, params),
+		forkThread: (params) => request(CODEX_CONTROL_METHODS.forkThread, assertCodexThreadForkParams(params)),
+		readThread: async (threadId, includeTurns) => (await request(CODEX_CONTROL_METHODS.readThread, {
+			threadId,
+			includeTurns
+		})).thread,
+		archiveThread: async (threadId) => {
+			await request(CODEX_CONTROL_METHODS.archiveThread, { threadId });
+		}
+	};
+}
+function createCodexSessionCatalogControlFromRequests(params) {
+	return {
+		...params.clientId ? { clientId: params.clientId } : {},
+		...params.connectionFingerprint ? { connectionFingerprint: params.connectionFingerprint } : {},
+		withPinnedConnection: params.withPinnedConnection,
+		async listPage(pageParams) {
+			const limit = normalizeLimit(pageParams.limit, "limit");
+			const search = pageParams.searchTerm?.trim().toLocaleLowerCase() || void 0;
+			const cwd = pageParams.cwd?.trim() || void 0;
+			const maxPages = search ? 20 : 1;
+			const sessions = [];
+			const managedThreads = [];
+			let cursor = readControlCursor(pageParams.cursor, "request");
+			let nextCursor;
+			let backwardsCursor;
+			const seenCursors = new Set(cursor ? [cursor] : []);
+			const requests = params.createRequestSnapshot();
+			const deadline = params.now() + requests.requestTimeoutMs;
+			for (let pageIndex = 0; pageIndex < maxPages; pageIndex += 1) {
+				const remainingTimeoutMs = Math.ceil(deadline - params.now());
+				if (remainingTimeoutMs <= 0) throw new Error("Codex session catalog listing timed out");
+				const response = await requests.listThreads({
+					archived: false,
+					limit: limit - sessions.length,
+					modelProviders: [],
+					sortKey: "updated_at",
+					sortDirection: "desc",
+					...cwd ? { cwd } : {},
+					...cursor ? { cursor } : {}
+				}, remainingTimeoutMs);
+				if (pageIndex === 0) backwardsCursor = readControlCursor(response.backwardsCursor, "backwards response");
+				for (const thread of response.data) {
+					if (await isOpenClawManagedCodexThread(thread, params.localSessionsRoot)) {
+						const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+						managedThreads.push({
+							threadId: thread.id,
+							...rolloutPath ? { rolloutPath } : {}
+						});
+						continue;
 					}
-				});
-				await control.archiveThread(params.threadId);
-				return { archived: true };
+					const session = toCatalogSession(thread, false);
+					if (session && (!search || session.name?.toLocaleLowerCase().includes(search))) sessions.push(session);
+				}
+				nextCursor = readControlCursor(response.nextCursor, "next response");
+				if (!nextCursor || sessions.length >= limit) break;
+				if (seenCursors.has(nextCursor)) throw new Error("Codex session catalog returned a repeated search cursor");
+				seenCursors.add(nextCursor);
+				cursor = nextCursor;
+			}
+			return {
+				sessions,
+				...managedThreads.length > 0 ? { managedThreads } : {},
+				...nextCursor ? { nextCursor } : {},
+				...backwardsCursor ? { backwardsCursor } : {}
+			};
+		},
+		async listDescendantPage(listParams) {
+			const requests = params.createRequestSnapshot();
+			return await requests.listThreads(listParams, requests.requestTimeoutMs);
+		},
+		async readThread(threadId, includeTurns = false) {
+			return await params.createRequestSnapshot().readThread(threadId, includeTurns);
+		},
+		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);
+		}
+	};
+}
+/** Builds the passive catalog over the Codex plugin's canonical shared client. */
+function createCodexSessionCatalogControl(params) {
+	const now = params.now ?? Date.now;
+	const getPluginConfig = () => params.getPluginConfig();
+	const homeResolver = createCodexCatalogHomeResolver({
+		config: params.getRuntimeConfig() ?? params.config ?? {},
+		getRuntimeConfig: params.getRuntimeConfig,
+		getPluginConfig: params.getPluginConfig,
+		...params.env ? { env: params.env } : {}
+	});
+	const requestOptionsByConfig = /* @__PURE__ */ new WeakMap();
+	const catalogPagesByConfig = /* @__PURE__ */ new WeakMap();
+	const resolveRequestOptions = (startOptions, agentId, source) => {
+		const runtimeConfig = params.getRuntimeConfig();
+		const agentDir = source?.agentDir ?? resolveAgentDir(runtimeConfig ?? {}, agentId);
+		const resolvedStartOptions = source?.appServer.start ?? startOptions;
+		if (!runtimeConfig) return {
+			agentDir,
+			config: void 0,
+			startOptions: structuredClone(resolvedStartOptions)
+		};
+		let byAgent = requestOptionsByConfig.get(runtimeConfig);
+		const cacheKey = `${agentId ?? ""}\0${source?.sourceHomeId ?? ""}`;
+		const cached = byAgent?.get(cacheKey);
+		if (cached) return cached;
+		const resolved = {
+			agentDir,
+			config: structuredClone(runtimeConfig),
+			startOptions: structuredClone(resolvedStartOptions)
+		};
+		if (!byAgent) {
+			byAgent = /* @__PURE__ */ new Map();
+			requestOptionsByConfig.set(runtimeConfig, byAgent);
+		}
+		byAgent.set(cacheKey, resolved);
+		return resolved;
+	};
+	const createRequestSnapshot = (agentId, source) => {
+		const pluginConfig = getPluginConfig();
+		const runtime = source?.appServer ?? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig });
+		const requestOptions = resolveRequestOptions(runtime.start, agentId, source);
+		return createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs) => await codexControlRequest(pluginConfig, method, requestParams, {
+			...requestOptions,
+			...timeoutMs === void 0 ? {} : { timeoutMs }
+		}));
+	};
+	const forRequest = (agentId, source) => {
+		const withPinnedConnection = async (run) => {
+			const pluginConfig = getPluginConfig();
+			const runtime = source?.appServer ?? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig });
+			const { agentDir, config: runtimeConfig, startOptions } = resolveRequestOptions(runtime.start, agentId, source);
+			const client = await getLeasedSharedCodexAppServerClient({
+				agentDir,
+				config: runtimeConfig,
+				startOptions,
+				timeoutMs: runtime.requestTimeoutMs
 			});
+			try {
+				const requests = createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs) => await requestCodexAppServerClientJson({
+					client,
+					method,
+					requestParams,
+					config: runtimeConfig,
+					timeoutMs: timeoutMs ?? runtime.requestTimeoutMs
+				}));
+				const pinnedControl = createCodexSessionCatalogControlFromRequests({
+					clientId: resolveCodexAppServerClientInstanceId(client),
+					connectionFingerprint: buildCodexAppServerConnectionFingerprint(runtime, agentDir),
+					createRequestSnapshot: () => requests,
+					...source?.localSessionsRoot ? { localSessionsRoot: source.localSessionsRoot } : {},
+					now,
+					withPinnedConnection: async (nestedRun) => await nestedRun(pinnedControl)
+				});
+				return await run(pinnedControl);
+			} finally {
+				releaseLeasedSharedCodexAppServerClient(client);
+			}
+		};
+		const control = createCodexSessionCatalogControlFromRequests({
+			createRequestSnapshot: () => createRequestSnapshot(agentId, source),
+			...source?.localSessionsRoot ? { localSessionsRoot: source.localSessionsRoot } : {},
+			now,
+			withPinnedConnection
 		});
-	});
+		return {
+			...control,
+			async listPage(pageParams) {
+				const runtimeConfig = params.getRuntimeConfig();
+				if (!runtimeConfig) return await control.listPage(pageParams);
+				let cache = catalogPagesByConfig.get(runtimeConfig);
+				if (!cache) {
+					cache = /* @__PURE__ */ new Map();
+					catalogPagesByConfig.set(runtimeConfig, cache);
+				}
+				const key = codexCatalogPageCacheKey(pageParams, agentId, source);
+				const cached = cache.get(key);
+				if (pageParams.forceRefresh !== true && cached) {
+					cache.delete(key);
+					cache.set(key, cached);
+					if (cached.expiresAt > now()) return cached.value ?? await cached.page;
+				}
+				if (cached) cache.delete(key);
+				const page = control.listPage(pageParams);
+				const staleValue = cached?.value;
+				const entry = {
+					expiresAt: Number.POSITIVE_INFINITY,
+					page,
+					...staleValue ? { value: staleValue } : {}
+				};
+				cache.set(key, entry);
+				pruneMapToMaxSize(cache, CODEX_SESSION_CATALOG_LIST_CACHE_MAX_ENTRIES);
+				const settle = (value) => {
+					if (cache.get(key) === entry) {
+						entry.value = value;
+						entry.expiresAt = now() + CODEX_SESSION_CATALOG_LIST_TTL_MS;
+					}
+					return value;
+				};
+				const restore = () => {
+					if (cache.get(key) !== entry) return;
+					if (staleValue) cache.set(key, {
+						expiresAt: now(),
+						page: Promise.resolve(staleValue),
+						value: staleValue
+					});
+					else cache.delete(key);
+				};
+				if (pageParams.forceRefresh !== true && staleValue) {
+					page.then(settle, restore);
+					return staleValue;
+				}
+				try {
+					return settle(await page);
+				} catch (error) {
+					restore();
+					throw error;
+				}
+			}
+		};
+	};
+	const homesForAgent = (agentId) => homeResolver.forAgent(agentId);
+	const forUpstream = (agentId, connectionFingerprint) => {
+		const source = homesForAgent(agentId).find((home) => buildCodexAppServerConnectionFingerprint(home.appServer, home.agentDir) === connectionFingerprint);
+		return source ? forRequest(agentId, source) : void 0;
+	};
+	return {
+		forRequest,
+		forUpstream,
+		homesForAgent
+	};
 }
+//#endregion
+//#region extensions/codex/src/session-catalog.ts
 /** Allows read-only catalog and transcript commands on supported paired-node platforms. */
 function createCodexSessionCatalogNodeInvokePolicies() {
 	return [{
@@ -2563,7 +2761,7 @@ function createCodexSessionCatalogNodeInvokePolicies() {
 	}];
 }
 function toGenericCatalogHost(host, localTerminalAvailable) {
-	const local = host.hostId === CODEX_LOCAL_SESSION_HOST_ID;
+	const local = isLocalCodexCatalogHost(host.hostId);
 	return {
 		hostId: host.hostId,
 		label: host.label,
@@ -2578,6 +2776,7 @@ function toGenericCatalogHost(host, localTerminalAvailable) {
 			const name = session.name ?? session.fallbackName;
 			return {
 				threadId: session.threadId,
+				...session.sourceHomeId ? { sourceHomeId: session.sourceHomeId } : {},
 				...name ? { name } : {},
 				...session.cwd ? { cwd: session.cwd } : {},
 				status: session.status,
@@ -2599,13 +2798,44 @@ function toGenericCatalogHost(host, localTerminalAvailable) {
 		...host.error ? { error: host.error } : {}
 	};
 }
+function isLocalCodexCatalogHost(hostId) {
+	return hostId === "gateway:local" || hostId.startsWith(`gateway:local:`);
+}
+function resolveLocalCatalogHomeForThread(params) {
+	if (params.homes.length === 0) throw new CatalogParamsError("local Codex sessions are unavailable in isolated state");
+	const exact = params.sourceHomeId ? params.homes.filter((home) => home.sourceHomeId === params.sourceHomeId) : params.homes.filter((home) => home.hostId === params.hostId);
+	if (exact.length === 0 || params.sourceHomeId && exact[0]?.hostId !== params.hostId) throw new CatalogParamsError("Codex session source home is unavailable");
+	return exact[0];
+}
 function registerCodexSessionCatalog(params) {
-	const usesProcessHomeFallback = () => {
-		const start = resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: params.getPluginConfig() }).start;
-		return start.transport === "stdio" && start.homeScope === "user" && !process.env.CODEX_HOME?.trim();
+	const catalogHomes = (agentId, allowProcessHomeFallback) => {
+		const homes = params.control.homesForAgent(agentId);
+		return allowProcessHomeFallback === false ? homes.filter((home) => !home.usesProcessHomeFallback) : homes;
+	};
+	const resolveRequestAgentId = (agentId) => resolveSessionAgentIds({
+		config: params.getRuntimeConfig() ?? params.api.config,
+		agentId
+	}).sessionAgentId;
+	const bindRequest = (request) => {
+		const agentId = resolveRequestAgentId(request.agentId);
+		const source = isLocalCodexCatalogHost(request.hostId) ? resolveLocalCatalogHomeForThread({
+			homes: [...catalogHomes(agentId, request.allowProcessHomeFallback)],
+			hostId: request.hostId,
+			...request.sourceHomeId ? { sourceHomeId: request.sourceHomeId } : {}
+		}) : void 0;
+		return {
+			agentId,
+			source,
+			control: params.control.forRequest(agentId, source)
+		};
 	};
-	const assertLocalAccess = (hostId, allowProcessHomeFallback) => {
-		if (hostId === "gateway:local" && allowProcessHomeFallback === false && usesProcessHomeFallback()) throw new CatalogParamsError("local Codex sessions are unavailable in isolated state");
+	const bindLocalRequest = (request) => {
+		const bound = bindRequest(request);
+		if (!bound.source) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+		return {
+			...bound,
+			source: bound.source
+		};
 	};
 	const checkUpstreamActivity = createChecker(params);
 	params.api.registerSessionCatalog({
@@ -2615,9 +2845,12 @@ function registerCodexSessionCatalog(params) {
 		resolveCreateSession: ({ agentId }) => resolveCodexCatalogCreateSession(params.getRuntimeConfig() ?? params.api.config, agentId),
 		list: async (query) => {
 			const localTerminalAvailable = resolveLocalCodexTerminalExecutable() !== void 0;
-			const { allowProcessHomeFallback, listNodes, onHost, sessionEntries, ...gatewayQuery } = query;
+			const { agentId: requestedAgentId, allowProcessHomeFallback, listNodes, onHost, sessionEntries, ...gatewayQuery } = query;
+			const agentId = resolveRequestAgentId(requestedAgentId);
 			const mapHost = (host) => toGenericCatalogHost(host, localTerminalAvailable);
+			const localHomes = [...catalogHomes(agentId, allowProcessHomeFallback)];
 			return (await listCodexSessionCatalog({
+				agentId,
 				bindingStore: params.bindingStore,
 				config: params.getRuntimeConfig(),
 				runtime: params.api.runtime,
@@ -2625,20 +2858,21 @@ function registerCodexSessionCatalog(params) {
 				query: gatewayQuery,
 				listNodes,
 				sessionEntries,
-				includeLocal: allowProcessHomeFallback !== false || !usesProcessHomeFallback(),
+				localHomes,
 				...onHost ? { onHost: (host) => onHost(mapHost(host)) } : {}
 			})).hosts.map(mapHost);
 		},
 		read: async (request) => {
-			const { allowProcessHomeFallback, ...catalogRequest } = request;
-			assertLocalAccess(catalogRequest.hostId, allowProcessHomeFallback);
+			const { agentId, source, control } = bindRequest(request);
 			const page = await readCodexSessionTranscript({
+				agentId,
 				runtime: params.api.runtime,
-				control: params.control,
-				hostId: catalogRequest.hostId,
-				threadId: catalogRequest.threadId,
-				cursor: catalogRequest.cursor,
-				limit: catalogRequest.limit ?? 20
+				control,
+				hostId: request.hostId,
+				threadId: request.threadId,
+				cursor: request.cursor,
+				limit: request.limit ?? 20,
+				...source ? { source } : {}
 			});
 			return {
 				...page,
@@ -2646,58 +2880,69 @@ function registerCodexSessionCatalog(params) {
 			};
 		},
 		continueSession: async (request) => {
-			assertLocalAccess(request.hostId, request.allowProcessHomeFallback);
 			const config = params.getRuntimeConfig();
 			if (!config) throw new Error("OpenClaw runtime config is unavailable");
 			if (request.hostId.startsWith("node:")) return await continueNodeCodexSession({
+				agentId: resolveRequestAgentId(request.agentId),
 				api: params.api,
 				config,
 				hostId: request.hostId,
 				threadId: request.threadId,
 				clientScopes: request.clientScopes
 			});
-			if (request.hostId !== "gateway:local") throw new CatalogParamsError("Codex session catalog hostId is invalid");
+			if (!isLocalCodexCatalogHost(request.hostId)) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+			const { agentId, source, control } = bindLocalRequest(request);
 			let upstreamBaseline;
 			return codexUpstreamContinueResult((await continueLocalCodexSession({
+				agentId,
 				api: params.api,
 				bindingStore: params.bindingStore,
 				config,
-				control: params.control,
+				control,
 				threadId: request.threadId,
+				hostId: source.hostId,
+				sourceHomeId: source.sourceHomeId,
+				...source.hostId === "gateway:local" ? { allowLegacy: true } : {},
 				onContinued: (baseline) => {
 					upstreamBaseline = baseline;
 				}
 			})).sessionKey, request.threadId, upstreamBaseline);
 		},
-		checkUpstreamActivity: (probes, policy) => checkUpstreamActivity(probes.filter((probe) => probe.hostId !== "gateway:local" || policy?.allowProcessHomeFallback !== false || !usesProcessHomeFallback())),
+		checkUpstreamActivity: (probes, policy) => checkUpstreamActivity(probes.filter((probe) => !isLocalCodexCatalogHost(probe.hostId) || policy?.allowProcessHomeFallback !== false || catalogHomes(probe.agentId, false).some((home) => home.hostId === probe.hostId))),
 		archive: async (request) => {
-			assertLocalAccess(request.hostId, request.allowProcessHomeFallback);
 			if (request.confirmNoOtherRunner !== true) throw new CatalogParamsError("archive requires confirmation that no other runner is active");
-			if (request.hostId !== "gateway:local") throw new CatalogParamsError("paired-node Codex sessions are view-only");
+			if (!isLocalCodexCatalogHost(request.hostId)) throw new CatalogParamsError("paired-node Codex sessions are view-only");
 			const config = params.getRuntimeConfig();
 			if (!config) throw new Error("OpenClaw runtime config is unavailable");
+			const { agentId, source, control } = bindLocalRequest(request);
 			await archiveLocalCodexSession({
+				agentId,
 				bindingStore: params.bindingStore,
 				config,
-				control: params.control,
+				control,
 				runtime: params.api.runtime,
-				threadId: request.threadId
+				threadId: request.threadId,
+				hostId: source.hostId,
+				sourceHomeId: source.sourceHomeId,
+				...source.hostId === "gateway:local" ? { allowLegacy: true } : {}
 			});
 			return { ok: true };
 		},
 		openTerminal: async (request) => {
-			assertLocalAccess(request.hostId, request.allowProcessHomeFallback);
+			const { agentId, source, control } = bindRequest(request);
 			return await openCodexCatalogTerminal({
 				api: params.api,
-				control: params.control,
+				control,
 				getPluginConfig: params.getPluginConfig,
 				getRuntimeConfig: params.getRuntimeConfig,
 				parseCatalogPage,
-				...request
+				...source ? { source } : {},
+				...request,
+				agentId
 			});
 		},
 		startTerminalSession: async (request) => {
-			assertLocalAccess(request.nodeId ? `node:${request.nodeId}` : CODEX_LOCAL_SESSION_HOST_ID, request.allowProcessHomeFallback);
+			if (!request.nodeId && catalogHomes(request.agentId, request.allowProcessHomeFallback).length === 0) throw new CatalogParamsError("local Codex sessions are unavailable in isolated state");
 			return await startCodexCatalogTerminal({
 				getPluginConfig: params.getPluginConfig,
 				getRuntimeConfig: params.getRuntimeConfig,
@@ -2715,4 +2960,4 @@ const codexSessionCatalogRuntime = {
 	archiveLocal: archiveLocalCodexSession
 };
 //#endregion
-export { CODEX_LOCAL_SESSION_HOST_ID as a, readCodexStatusProbes as c, createCodexCliSessionNodeHostCommands as d, createCodexCliSessionNodeInvokePolicies as f, resumeCodexCliSessionOnNode as g, resolveCodexCliSessionForBindingOnNode as h, createCodexSessionCatalogNodeInvokePolicies as i, requestOptions as l, listCodexCliSessionsOnNode as m, createCodexSessionCatalogControl as n, assertCodexArchiveDescendantsUnowned as o, formatCodexCliSessions as p, createCodexSessionCatalogNodeHostCommands as r, codexControlRequest as s, codexSessionCatalogRuntime as t, safeCodexControlRequest as u };
+export { CODEX_LOCAL_SESSION_HOST_ID as a, createCodexCliSessionNodeInvokePolicies as c, resolveCodexCliSessionForBindingOnNode as d, resumeCodexCliSessionOnNode as f, createCodexSessionCatalogNodeHostCommands as i, formatCodexCliSessions as l, createCodexSessionCatalogNodeInvokePolicies as n, assertCodexArchiveDescendantsUnowned as o, createCodexSessionCatalogControl as r, createCodexCliSessionNodeHostCommands as s, codexSessionCatalogRuntime as t, listCodexCliSessionsOnNode as u };