@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

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

@@ -1,32 +1,41 @@
-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 { F as resolveCodexAppServerLocalHomeDir, I as resolveCodexAppServerUserHomeDir, P as resolveCodexAppServerHomeDir, T as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-Cxw3Cl3k.js";
+import { $ as CodexAppServerRpcError, Et as withTimeout, Ht as isJsonObject, Lt as resolveCodexAppServerPreparedAuthHandoff, Mt as resolveCodexAppServerAuthProfileId, Pt as resolveCodexAppServerAuthProfileStore, Q as resolveCodexAppServerClientInstanceId, Rt as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, zt as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS } from "./shared-client-kNkljY-R.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity } from "./session-binding-q2WSTVmC.js";
+import { i as assertCodexThreadForkParams } from "./protocol-validators-Bg5rpNxk.js";
+import { a as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-CVPvp9dL.js";
+import { n as listCodexAppServerModels } from "./models-DgFWSuxA.js";
+import { a as replaceCodexCatalogConnectionHomes, n as buildCodexAppServerConnectionFingerprint, t as resumeCodexAppServerThread } from "./thread-resume-DF54hagX.js";
+import { n as codexCatalogHomeId, r as isOpenClawManagedCodexThread, t as canonicalCodexCatalogHome } from "./session-catalog-home-id-DAKUrm3C.js";
+import { i as requestCodexAppServerJson, o as withCodexAppServerJsonClient, r as requestCodexAppServerClientJson } from "./request-CCm4LaED.js";
+import { p as projectCodexUserItemText, r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-CkEQIna-.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-CGm_94eL.js";
+import { r as formatCodexDisplayText } from "./command-formatters-C54Yg3eA.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 prepareCodexAppServerAuthBinding } from "./auth-binding-Ds_QVm-X.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-Bcy33kam.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 { prepareAgentRuntimeAuth } from "openclaw/plugin-sdk/agent-harness-runtime";
+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 as resolveAgentDir$1, resolveAgentWorkspaceDir, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import { runCommandBuffered } from "openclaw/plugin-sdk/process-runtime";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-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 { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 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 process$1 from "node:process";
-import { listSessionCatalogEntries } from "openclaw/plugin-sdk/session-catalog";
+import { resolveSessionModelRef } from "openclaw/plugin-sdk/model-session-runtime";
+import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
+import { createSessionCatalogAdoptionCoordinator, listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 import { decodeNodePtyResumeParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 //#region extensions/codex/src/jsonl-lines.ts
 const JSONL_STREAM_THRESHOLD_BYTES = 4 * 1024 * 1024;
 const JSONL_READ_CHUNK_BYTES = 1024 * 1024;
@@ -132,11 +141,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 +276,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 +284,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 +315,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) => {
@@ -580,6 +551,89 @@ function formatNodeLabel(node) {
 }
 //#endregion
 //#region extensions/codex/src/command-rpc.ts
+async function prepareControlAuth(options, startOptions) {
+	if (!options.onResponse || !options.config || !options.sessionKey || options.authProfileId === null || startOptions.homeScope === "user") return {
+		authProfileId: options.authProfileId ?? void 0,
+		clientOptions: { authProfileId: options.authProfileId }
+	};
+	const config = options.config;
+	const { sessionAgentId } = resolveSessionAgentIdsStrict({
+		config,
+		sessionKey: options.sessionKey,
+		agentId: options.agentId
+	});
+	const agentDir = options.agentDir ?? resolveAgentDir$1(config, sessionAgentId);
+	const workspaceDir = resolveAgentWorkspaceDir(config, sessionAgentId);
+	const entry = getSessionEntry({
+		agentId: sessionAgentId,
+		storePath: resolveStorePath(config.session?.store, { agentId: sessionAgentId }),
+		sessionKey: options.sessionKey,
+		hydrateSkillPromptRefs: false,
+		readConsistency: "latest"
+	});
+	const model = resolveSessionModelRef(config, entry, sessionAgentId);
+	const store = resolveCodexAppServerAuthProfileStore({
+		agentDir,
+		config
+	});
+	const { plan, attempts } = prepareAgentRuntimeAuth({
+		provider: model.provider,
+		modelId: model.model,
+		config,
+		agentDir,
+		workspaceDir,
+		authProfileStore: store,
+		sessionAuthProfileId: entry?.authProfileOverride ?? options.authProfileId,
+		sessionAuthProfileSource: entry?.authProfileOverrideSource,
+		harnessId: "codex",
+		harnessAuthBootstrap: "harness"
+	});
+	const route = plan.modelRoute;
+	const resolvedAuth = route ? await resolveApiKeyForProvider({
+		provider: route.provider,
+		modelId: route.modelId,
+		modelApi: route.api,
+		cfg: config,
+		agentDir,
+		workspaceDir,
+		store,
+		profileId: attempts[0]?.profileId,
+		lockedProfile: plan.forwardedAuthProfileSource === "user",
+		allowAuthProfileFallback: attempts[0]?.allowAuthProfileFallback,
+		skipSetupProviderFallback: true
+	}) : void 0;
+	const handoff = await resolveCodexAppServerPreparedAuthHandoff({
+		authRequirement: route?.authRequirement,
+		resolvedApiKey: resolvedAuth?.apiKey,
+		authProfileId: route ? plan.forwardedAuthProfileId : resolveCodexAppServerAuthProfileId({
+			authProfileId: plan.forwardedAuthProfileId,
+			store,
+			config
+		}),
+		authProfileStore: store,
+		agentDir,
+		homeScope: startOptions.homeScope ?? "agent",
+		config,
+		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a forwarded OpenAI OAuth or token profile.",
+		subscriptionProfileUnusableError: "Prepared Codex subscription auth profile is unusable."
+	});
+	const binding = handoff.authProfileId ? await prepareCodexAppServerAuthBinding({
+		authProfileId: handoff.authProfileId,
+		authProfileStore: store,
+		agentDir,
+		config
+	}) : void 0;
+	return {
+		authProfileId: handoff.authProfileId,
+		clientOptions: {
+			...handoff.preparedAuth ? { preparedAuth: handoff.preparedAuth } : { authProfileId: handoff.authProfileId },
+			authRequirement: route?.authRequirement,
+			authProfileStore: binding?.authProfileStore ?? store,
+			authBindingFingerprint: binding?.fingerprint,
+			agentDir
+		}
+	};
+}
 function requestOptions(pluginConfig, limit, config, agentDir) {
 	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
 	return {
@@ -592,22 +646,45 @@ function requestOptions(pluginConfig, limit, config, agentDir) {
 }
 async function codexControlRequest(pluginConfig, method, requestParams, options = {}) {
 	const runtime = options.startOptions ? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig }) : resolveCodexAppServerRuntimeOptions({ pluginConfig });
+	const startOptions = options.startOptions ?? runtime.start;
+	const auth = await prepareControlAuth(options, startOptions);
 	const controlRequestOptions = {
 		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
-		startOptions: options.startOptions ?? runtime.start,
+		startOptions,
 		config: options.config,
 		sessionKey: options.sessionKey,
 		sessionId: options.sessionId,
-		authProfileId: options.authProfileId,
 		agentDir: options.agentDir,
-		isolated: options.isolated
+		isolated: options.isolated,
+		...auth.clientOptions
 	};
-	if (options.onResponse) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client) => {
-		const response = await request({
+	if (options.onResponse || options.beforeRequest) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client, scope) => {
+		await options.beforeRequest?.(request);
+		scope.assertCurrent();
+		let response;
+		if (method === "thread/resume") {
+			if (!isJsonObject(requestParams) || typeof requestParams.threadId !== "string") throw new Error("Codex thread/resume requires a thread id.");
+			response = await resumeCodexAppServerThread({
+				client,
+				request: {
+					...requestParams,
+					threadId: requestParams.threadId
+				},
+				requestResume: () => request({
+					method,
+					requestParams
+				}),
+				abandonClient: () => closeCodexStartupClientBestEffort(client)
+			});
+		} else response = await request({
 			method,
 			requestParams
 		});
-		await options.onResponse(response, client);
+		await options.onResponse?.(response, client, {
+			authProfileId: auth.authProfileId,
+			assertCurrent: scope.assertCurrent
+		});
+		scope.assertCurrent();
 		return response;
 	});
 	return await requestCodexAppServerJson({
@@ -714,29 +791,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";
@@ -962,7 +1016,7 @@ function filterCatalogPageByTitle(page, searchTerm) {
 	if (!searchTerm) return page;
 	return {
 		...page,
-		sessions: page.sessions.filter((session) => session.name?.toLocaleLowerCase().includes(searchTerm.toLocaleLowerCase()))
+		sessions: page.sessions.filter((session) => (session.name ?? session.fallbackName)?.toLocaleLowerCase().includes(searchTerm.toLocaleLowerCase()))
 	};
 }
 function unwrapNodeInvokePayload(value) {
@@ -1030,24 +1084,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 +1102,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 +1110,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 +1122,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 +1170,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,9 +1190,9 @@ 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() } : {},
+			displayName: params.record.name ?? void 0,
 			...params.record.cwd?.trim() ? { spawnedCwd: params.record.cwd.trim() } : {},
 			initialEntry: {
 				agentHarnessId: "codex",
@@ -1182,6 +1223,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 +1235,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$1(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 +1379,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 +1389,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,968 +1411,1446 @@ 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
+		});
 	}
-	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
-		} : {}
-	};
+	return adopted;
 }
-function countUserMessages(turn) {
-	return turn.items.filter((item) => item.type === "userMessage").length;
+async function findAdoptedSessionEntry(params) {
+	const adopted = await listAdoptedSessionEntries(params);
+	return adopted.get(sessionCatalogAdoptedSourceKey(params.sourceHomeId ?? "gateway:local", params.threadId)) ?? (params.sourceHomeId && params.allowLegacy === true ? adopted.get(sessionCatalogAdoptedSourceKey("gateway:local", params.threadId)) : void 0);
 }
-function 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 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 });
 }
-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"
+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,
+			displayName: params.sourceThread.name ?? void 0,
+			thread: params.sourceThread,
+			throughTurnId: pendingLastTurnId ?? null,
+			recoverMatchingInitialEntry: true,
+			initialEntry: {
+				agentHarnessId: "codex",
+				modelSelectionLocked: true,
+				pluginExtensions: { codex: { supervision: {
+					...marker,
+					initializing: true,
+					modelLocked: true
+				} } }
+			},
+			afterImport: async (entry) => {
+				createdBindingIdentity = sessionBindingIdentity({
+					sessionId: entry.sessionId,
+					sessionKey: entry.key,
+					config: params.config
 				});
-				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
+				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 } : {}
 				});
-				if (activity) activities.push(activity);
-			} catch {}
+				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;
 		}
-		return activities;
-	});
+		throw error;
+	}
 }
-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 continueLocalCodexSessionInner(params) {
+	await requireCatalogEligibleThread(params.control, params.threadId);
+	const existing = await findAdoptedSessionEntry({
+		...params,
+		runtime: params.api.runtime
 	});
-}
-//#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;
+	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 };
 			}
-			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);
-		},
-		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 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);
+		})) throw changedError();
+		const connectionFingerprint = params.control.connectionFingerprint;
+		if (connectionFingerprint) params.onContinued?.({
+			connectionFingerprint,
+			...codexUpstreamBaseline(boundThread, boundCatalogSessionId)
+		});
 		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);
-			}
+			sessionKey: existing.key,
+			disposition: "existing"
 		};
-	};
-	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
-		});
-		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 control = createCodexSessionCatalogControlFromRequests({
-		createRequestSnapshot,
-		now,
-		withPinnedConnection
+	}
+	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 {
-		...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;
-			}
-		}
+		sessionKey: adopted.key,
+		disposition: "forked"
 	};
 }
-async function listGatewayHost(params) {
+/** 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 {
-		const page = parseCatalogPage(await params.control.listPage({
-			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 } : {}
-		}));
-		const adoptedSessions = await listAdoptedSessionEntries({
-			bindingStore: params.bindingStore,
-			config: params.config,
-			runtime: params.runtime,
-			sessionEntries: params.sessionEntries
-		});
-		return {
-			hostId: CODEX_LOCAL_SESSION_HOST_ID,
-			label: "Local Codex",
-			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;
-			})
-		};
-	} catch (error) {
-		return {
-			hostId: CODEX_LOCAL_SESSION_HOST_ID,
-			label: "Local Codex",
-			kind: "gateway",
-			connected: false,
-			sessions: [],
-			error: catalogError("APP_SERVER_UNAVAILABLE", error)
-		};
+		return await operation;
+	} finally {
+		if (continueOperations.get(operationKey) === operation) continueOperations.delete(operationKey);
 	}
 }
-/** Lists Gateway-local and paired-node Codex sessions with per-host failures. */
-async function listCodexSessionCatalog(params) {
-	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
-	})] : [];
-	for (const host of localHosts) if (params.onHost) host.then(params.onHost).catch(() => void 0);
-	if (!(!requestedHostIds || query.hostIds?.some((hostId) => hostId.startsWith("node:")))) return { hosts: await Promise.all(localHosts) };
-	let nodes;
-	try {
-		nodes = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes.filter((node) => node.gatewayLocal !== true && node.commands?.includes("codex.appServer.threads.list.v1") && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - localHosts.length);
-	} catch (error) {
-		const registryHost = {
-			hostId: "node:registry",
-			label: "Paired nodes",
-			kind: "node",
-			connected: false,
-			sessions: [],
-			error: catalogError("NODE_LIST_FAILED", error)
-		};
-		params.onHost?.(registryHost);
-		return { hosts: [...await Promise.all(localHosts), registryHost] };
+//#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");
 	}
-	const adoptedNodeSessions = listNodeAdoptedSessionEntries({
-		config: params.config,
-		runtime: params.runtime,
-		sessionEntries: params.sessionEntries
-	});
-	const nodeHosts = nodes.toSorted(compareNodeLabels).map(async (node) => {
-		const host = await listPairedNode({
-			runtime: params.runtime,
-			node,
-			query,
-			adoptedSessions: adoptedNodeSessions,
-			...params.onHost ? { onHost: params.onHost } : {}
-		});
-		return Object.assign(host, codexNodeTerminalCapability(node));
-	});
-	return { hosts: await Promise.all([...localHosts, ...nodeHosts]) };
 }
-/** Builds the node-local read-only Codex app-server catalog command. */
-function createCodexSessionCatalogNodeHostCommands(control, configSources) {
-	return [
-		{
-			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
-			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
-			dangerous: false,
-			handle: async (paramsJSON) => {
-				const pageParams = readPageParams(parseJsonParams(paramsJSON));
-				try {
-					const page = filterCatalogPageByTitle(parseCatalogPage(await control.listPage(pageParams)), pageParams.searchTerm);
-					return JSON.stringify(page);
-				} catch {
-					throw new Error("Codex app-server catalog is unavailable");
-				}
-			}
-		},
-		{
-			command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
-			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
-			dangerous: false,
-			handle: async (paramsJSON) => {
-				const action = readNodeTranscriptParams(parseJsonParams(paramsJSON));
-				try {
-					await requireCatalogEligibleThread(control, action.threadId);
-					const page = parseTranscriptPage(await control.listTurnPage({
-						threadId: action.threadId,
-						limit: action.limit,
-						sortDirection: "desc",
-						itemsView: "full",
-						...action.cursor ? { cursor: action.cursor } : {}
-					}));
-					return JSON.stringify(page);
-				} catch (error) {
-					if (error instanceof CatalogParamsError) throw error;
-					throw new Error("Codex app-server transcript is unavailable", { cause: error });
-				}
-			}
-		},
-		createCodexTerminalNodeHostCommand(control, configSources)
-	];
+/** 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);
+		});
+	});
 }
-function readNodeTranscriptParams(value) {
-	if (!isRecord(value)) throw new CatalogParamsError("Codex session read parameters must be an object");
-	requireOnlyKeys(value, /* @__PURE__ */ new Set([
-		"threadId",
-		"cursor",
-		"limit"
-	]));
-	const threadId = readBoundedOptionalString(value, "threadId", 256);
-	if (!threadId) throw new CatalogParamsError("threadId is required");
-	const cursor = readBoundedOptionalString(value, "cursor", MAX_CURSOR_LENGTH);
-	return {
-		threadId,
-		limit: readBoundedLimit(value.limit, "limit", 20, 50),
-		...cursor ? { cursor } : {}
+//#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
 	};
 }
-function readBoundedLimit(value, key, fallback, max) {
-	if (value === void 0) return fallback;
-	if (!Number.isInteger(value) || value < 1 || value > max) throw new CatalogParamsError(`${key} must be an integer from 1 to ${max}`);
-	return value;
+//#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 flattenTranscriptPageDesc(page) {
-	return page.data.flatMap((turn) => turn.items.toReversed());
+function compareNodeLabels(left, right) {
+	const leftLabel = nodeLabel(left);
+	const rightLabel = nodeLabel(right);
+	if (leftLabel < rightLabel) return -1;
+	if (leftLabel > rightLabel) return 1;
+	return 0;
 }
-/** Reads the persisted transcript for a Gateway-local or paired-node Codex session. */
-async function readCodexSessionTranscript(params) {
-	if (params.hostId === "gateway:local") {
-		await requireCatalogEligibleThread(params.control, params.threadId);
-		const page = parseTranscriptPage(await params.control.listTurnPage({
-			threadId: params.threadId,
-			limit: params.limit,
-			sortDirection: "desc",
-			itemsView: "full",
-			...params.cursor ? { cursor: params.cursor } : {}
-		}));
+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 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 {
-			hostId: params.hostId,
-			label: "Local Codex",
-			threadId: params.threadId,
-			items: flattenTranscriptPageDesc(page),
-			...page.nextCursor ? { nextCursor: page.nextCursor } : {},
-			...page.backwardsCursor ? { backwardsCursor: page.backwardsCursor } : {}
+			...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)
 		};
 	}
-	const nodeId = params.hostId.slice(5);
-	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId && candidate.connected === true && candidate.commands?.includes("codex.appServer.thread.turns.list.v1"));
-	if (!node) throw new CatalogParamsError("paired-node Codex session host is offline or unavailable");
+}
+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 {
+		node,
+		nodeId
+	};
+}
+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 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,
+		nodeId: params.nodeId,
 		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
 		params: {
-			threadId: params.threadId,
-			limit: params.limit,
-			...params.cursor ? { cursor: params.cursor } : {}
+			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",
+		projectId: null,
+		turns: page.data.toReversed()
+	};
 	return {
-		hostId: params.hostId,
-		label: nodeLabel(node),
-		threadId: params.threadId,
-		items: flattenTranscriptPageDesc(page),
-		...page.nextCursor ? { nextCursor: page.nextCursor } : {},
-		...page.backwardsCursor ? { backwardsCursor: page.backwardsCursor } : {}
+		thread,
+		throughTurnId: codexLastTerminalTurnId(thread, (value) => boundedCatalogString(value, 256)) ?? null
 	};
 }
-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
+async function continueNodeCodexSessionInner(params) {
+	const { nodeId } = await requireNodeForCodexContinue({
+		runtime: params.api.runtime,
+		hostId: params.hostId
+	});
+	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
 		});
-	}
-	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
+		adopted = await createOrReuseNodeAdoptedSession({
+			agentId: params.agentId,
+			api: params.api,
+			config: params.config,
+			hostId: params.hostId,
+			nodeId,
+			record,
+			history
 		});
-	} 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 });
+		disposition = "forked";
 	}
-	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));
+	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: params.threadId,
+				agentId: adopted.agentId,
+				cwd: record.cwd
+			})
+		},
+		afterConversationBound: async () => await finalizeNodeAdoptedSession({
+			api: params.api,
+			adopted,
+			marker
+		})
+	};
 }
-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 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 = resolveSessionAgentIdsStrict({
+		config: params.config,
+		agentId: params.agentId
+	}).sessionAgentId;
+	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
+	});
 }
-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}`);
+//#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 } : {}
+		});
+		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);
+		}
+		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;
 	}
-	const binding = {
-		threadId: params.sourceThreadId,
-		connectionScope: "supervision",
-		supervisionSourceThreadId: params.sourceThreadId,
-		cwd: params.cwd,
-		historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
-		conversationSourceTransferComplete: true,
-		preserveNativeModel: true,
-		pendingSupervisionBranch: pending
+	return {
+		sessions: sessions.slice(0, params.limit),
+		...nextCursor ? { nextCursor } : {},
+		...backwardsCursor ? { backwardsCursor } : {}
 	};
-	let stored;
+}
+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 {
-		stored = await params.bindingStore.mutate(params.identity, {
-			kind: "set",
-			if: { kind: "absent" },
-			binding
+		const page = await listVisiblePage({
+			control: params.control,
+			cursor: params.query.cursors?.[hostId],
+			excludedThreadIds: params.excludedThreadIds,
+			limit: params.query.limitPerHost,
+			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,
+			label,
+			kind: "gateway",
+			connected: true,
+			...page,
+			sessions: page.sessions.map((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) {
-		if (matchesPendingAdoptionBinding(await params.bindingStore.read(params.identity), params)) return;
-		throw error;
+		return {
+			hostId,
+			label,
+			kind: "gateway",
+			connected: false,
+			sessions: [],
+			error: catalogError("APP_SERVER_UNAVAILABLE", 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,
+/** Lists Gateway-local and paired-node Codex sessions with per-host failures. */
+async function listCodexSessionCatalog(params) {
+	const agentId = resolveSessionAgentIdsStrict({
+		config: params.config ?? {},
+		agentId: params.agentId
+	}).sessionAgentId;
+	const query = readGatewayParams(params.query);
+	const requestedHostIds = query.hostIds ? new Set(query.hostIds) : void 0;
+	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,
-			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
-				});
-				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 } : {}
+			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 } : {}
 				});
-				return { pluginExtensions: { codex: { supervision: {
-					...marker,
-					modelLocked: true
-				} } } };
-			}
+			} } : {},
+			...source ? { source } : {}
 		});
-		return {
-			key: created.key,
-			sessionId: created.sessionId,
-			agentId: created.agentId,
-			boundThreadId: params.sourceThread.id
-		};
+	})());
+	for (const host of localHosts) if (params.onHost) host.then(params.onHost).catch(() => void 0);
+	if (!(!requestedHostIds || query.hostIds?.some((hostId) => hostId.startsWith("node:")))) return { hosts: await Promise.all(localHosts) };
+	let nodes;
+	try {
+		nodes = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes.filter((node) => node.gatewayLocal !== true && node.commands?.includes("codex.appServer.threads.list.v1") && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - localHosts.length);
 	} 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;
-		}
-		throw error;
+		const registryHost = {
+			hostId: "node:registry",
+			label: "Paired nodes",
+			kind: "node",
+			connected: false,
+			sessions: [],
+			error: catalogError("NODE_LIST_FAILED", error)
+		};
+		params.onHost?.(registryHost);
+		return { hosts: [...await Promise.all(localHosts), registryHost] };
 	}
-}
-async function continueLocalCodexSessionInner(params) {
-	await requireCatalogEligibleThread(params.control, params.threadId);
-	const existing = await findAdoptedSessionEntry({
-		bindingStore: params.bindingStore,
+	const adoptedNodeSessions = listNodeAdoptedSessionEntries({
+		agentId,
 		config: params.config,
-		runtime: params.api.runtime,
-		threadId: params.threadId
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
 	});
-	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)
+	const nodeHosts = nodes.toSorted(compareNodeLabels).map(async (node) => {
+		const host = await listPairedNode({
+			agentId,
+			runtime: params.runtime,
+			node,
+			query,
+			adoptedSessions: adoptedNodeSessions,
+			...params.onHost ? { onHost: params.onHost } : {}
 		});
+		return Object.assign(host, codexNodeTerminalCapability(node));
+	});
+	return { hosts: await Promise.all([...localHosts, ...nodeHosts]) };
+}
+/** Builds the node-local read-only Codex app-server catalog command. */
+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 = resolveSessionAgentIdsStrict({
+			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 {
-			sessionKey: existing.key,
-			disposition: "existing"
+			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 request = bindRequest(paramsJSON);
+				const pageParams = readPageParams(request.params);
+				try {
+					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");
+				}
+			}
+		},
+		{
+			command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+			dangerous: false,
+			handle: async (paramsJSON) => {
+				const request = bindRequest(paramsJSON);
+				const action = readNodeTranscriptParams(request.params);
+				try {
+					await requireCatalogEligibleThread(request.control, action.threadId);
+					const page = parseTranscriptPage(await request.control.listTurnPage({
+						threadId: action.threadId,
+						limit: action.limit,
+						sortDirection: "desc",
+						itemsView: "full",
+						...action.cursor ? { cursor: action.cursor } : {}
+					}));
+					return JSON.stringify(page);
+				} catch (error) {
+					if (error instanceof CatalogParamsError) throw error;
+					throw new Error("Codex app-server transcript is unavailable", { cause: error });
+				}
+			}
+		},
+		createCodexTerminalNodeHostCommand(bindRequest, configSources)
+	];
+}
+function readNodeTranscriptParams(value) {
+	if (!isRecord(value)) throw new CatalogParamsError("Codex session read parameters must be an object");
+	requireOnlyKeys(value, /* @__PURE__ */ new Set([
+		"threadId",
+		"cursor",
+		"limit"
+	]));
+	const threadId = readBoundedOptionalString(value, "threadId", 256);
+	if (!threadId) throw new CatalogParamsError("threadId is required");
+	const cursor = readBoundedOptionalString(value, "cursor", MAX_CURSOR_LENGTH);
+	return {
+		threadId,
+		limit: readBoundedLimit(value.limit, "limit", 20, 50),
+		...cursor ? { cursor } : {}
+	};
+}
+function readBoundedLimit(value, key, fallback, max) {
+	if (value === void 0) return fallback;
+	if (!Number.isInteger(value) || value < 1 || value > max) throw new CatalogParamsError(`${key} must be an integer from 1 to ${max}`);
+	return value;
+}
+function flattenTranscriptPageDesc(page) {
+	return page.data.flatMap((turn) => turn.items.toReversed());
+}
+/** Reads the persisted transcript for a Gateway-local or paired-node Codex session. */
+async function readCodexSessionTranscript(params) {
+	if (params.source || params.hostId === "gateway:local") {
+		await requireCatalogEligibleThread(params.control, params.threadId);
+		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: params.source?.label ?? "Local Codex",
+			threadId: params.threadId,
+			items: flattenTranscriptPageDesc(page),
+			...page.nextCursor ? { nextCursor: page.nextCursor } : {},
+			...page.backwardsCursor ? { backwardsCursor: page.backwardsCursor } : {}
 		};
 	}
-	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)
+	const nodeId = params.hostId.slice(5);
+	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId && candidate.connected === true && candidate.commands?.includes("codex.appServer.thread.turns.list.v1"));
+	if (!node) throw new CatalogParamsError("paired-node Codex session host is offline or unavailable");
+	const page = parseTranscriptPage(unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+		nodeId,
+		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+		params: {
+			agentId: params.agentId,
+			threadId: params.threadId,
+			limit: params.limit,
+			...params.cursor ? { cursor: params.cursor } : {}
+		},
+		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+		scopes: ["operator.write"]
+	})));
+	return {
+		hostId: params.hostId,
+		label: nodeLabel(node),
+		threadId: params.threadId,
+		items: flattenTranscriptPageDesc(page),
+		...page.nextCursor ? { nextCursor: page.nextCursor } : {},
+		...page.backwardsCursor ? { backwardsCursor: page.backwardsCursor } : {}
+	};
+}
+//#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.type === "userMessage" ? projectCodexUserItemText(item) : item.text || resultText || changesText || fallback;
+	return {
+		id: item.id,
+		type,
+		...text ? { text } : {},
+		raw: item
+	};
+}
+//#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 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 }
+	};
+}
+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 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
+		} : {}
+	};
+}
+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"
+				});
+				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;
 	});
-	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$1(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$1(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-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 ?? session.fallbackName)?.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$1(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 +2868,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 +2883,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 +2905,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) => resolveSessionAgentIdsStrict({
+		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 +2952,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 +2965,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 +2987,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 +3067,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, readCodexStatusProbes as c, createCodexCliSessionNodeHostCommands as d, createCodexCliSessionNodeInvokePolicies as f, resumeCodexCliSessionOnNode as g, resolveCodexCliSessionForBindingOnNode as h, createCodexSessionCatalogNodeHostCommands as i, requestOptions as l, listCodexCliSessionsOnNode as m, createCodexSessionCatalogNodeInvokePolicies as n, assertCodexArchiveDescendantsUnowned as o, formatCodexCliSessions as p, createCodexSessionCatalogControl as r, codexControlRequest as s, codexSessionCatalogRuntime as t, safeCodexControlRequest as u };