@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/{session-catalog-DaLKVtpH.js → session-catalog-B47uwekb.js}

@@ -1,40 +1,44 @@
-import { S as resolveCodexAppServerUserHomeDir, h as readCodexPluginConfig, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-giW8X0QA.js";
-import { G as CodexAppServerRpcError, St as resolveCodexAppServerLocalHomeDir, U as resolveCodexAppServerClientInstanceId, ht as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, mt as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, o as getLeasedSharedCodexAppServerClient, p as releaseLeasedSharedCodexAppServerClient, rt as withTimeout, vt as isJsonObject, xt as resolveCodexAppServerHomeDir } from "./shared-client-DKz23hHY.js";
-import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity } from "./session-binding-Bcynfd-_.js";
-import { n as assertCodexThreadForkParams } from "./protocol-validators-VeJxxJ0U.js";
-import { i as replaceCodexCatalogConnectionHomes, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-C1CAdfcP.js";
-import { n as codexCatalogHomeId, t as canonicalCodexCatalogHome } from "./session-catalog-home-id-BNwAJ9D7.js";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-DsCMWBca.js";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-BRMh0aIq.js";
-import { r as formatCodexDisplayText } from "./command-formatters-DEsIufkt.js";
-import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-CW2GuupV.js";
-import { n as requestCodexAppServerClientJson } from "./request-DXXGHko0.js";
-import { t as codexControlRequest } from "./command-rpc-CCeCkf_v.js";
-import { i as createImportedCodexSession, n as codexUpstreamBaseline, r as codexUpstreamContinueResult, t as codexLastTerminalTurnId } from "./session-upstream-marker-BIkusb95.js";
+import { l as sessionBindingIdentity } from "./session-binding-record-CyaXZvTe.js";
+import { B as isJsonObject, I as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, L as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, M as resolveCodexAppServerHomeDir, N as resolveCodexAppServerLocalHomeDir, O as readCodexPluginConfig, P as resolveCodexAppServerUserHomeDir, i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-CyapYSji.js";
+import { $ as assertCodexThreadForkParams, Ft as withTimeout, J as isCodexThreadReadMissingError, K as resolveCodexAppServerClientInstanceId, Kt as resolveCodexAppServerPreparedAuthHandoff, Ut as resolveCodexAppServerAuthProfileStore, Vt as resolveCodexAppServerAuthProfileId, Xt as readCodexSessionMeta, Yt as isOpenClawManagedCodexThread, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, y as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-CKhX2kFt.js";
+import { r as createCodexSessionGenerationSupersededError, s as reclaimCurrentCodexSessionGeneration } from "./session-binding-4Ki04sW-.js";
+import { a as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-Bp1ZOnk2.js";
+import { n as listCodexAppServerModels } from "./models-CcrgSMQR.js";
+import { a as replaceCodexCatalogConnectionHomes, n as buildCodexAppServerConnectionFingerprint, t as resumeCodexAppServerThread } from "./thread-resume-BLgqkUc1.js";
+import { d as codexCatalogHomeId, l as projectCodexUserItemText, r as importCodexThreadHistoryToTranscript, u as canonicalCodexCatalogHome } from "./transcript-mirror-_njEB84z.js";
+import { i as requestCodexAppServerJson, o as withCodexAppServerJsonClient, r as requestCodexAppServerClientJson } from "./request-C8H22rPi.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-B1mgvpP8.js";
+import { a as formatCodexDisplayText } from "./command-formatters-DSbGMXA0.js";
+import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-BiodpIzq.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-DReTpGz6.js";
 import { asFiniteNumber, isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { z } from "zod";
+import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { runCommandBuffered } from "openclaw/plugin-sdk/process-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 { prepareAgentRuntimeAuth } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import fsSync from "node:fs";
 import os from "node:os";
-import { listAgentIds, resolveAgentDir, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
-import { runCommandBuffered } from "openclaw/plugin-sdk/process-runtime";
+import { listAgentIds as listAgentIds$1, resolveAgentDir as resolveAgentDir$2, resolveAgentWorkspaceDir, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId as resolveDefaultAgentId$1, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
-import { 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 { root } from "openclaw/plugin-sdk/file-access-runtime";
 import process$1 from "node:process";
-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";
-import { createZstdDecompress } from "node:zlib";
+import { resolveSessionModelRef } from "openclaw/plugin-sdk/model-session-runtime";
+import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
+import { createSessionCatalogAdoptionCoordinator, listSessionCatalogEntries, publishSessionCatalogHost, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey, sessionCatalogPaging } from "openclaw/plugin-sdk/session-catalog";
+import { decodeNodePtyResumeParams, decodeNodePtyStartParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
 //#region extensions/codex/src/jsonl-lines.ts
-const JSONL_STREAM_THRESHOLD_BYTES = 4 * 1024 * 1024;
-const JSONL_READ_CHUNK_BYTES = 1024 * 1024;
+const JSONL_STREAM_THRESHOLD_BYTES = 4194304;
+const JSONL_READ_CHUNK_BYTES = 1048576;
 async function visitJsonlLines(file, visitor, chunkBytes = JSONL_READ_CHUNK_BYTES) {
 	let size;
 	try {
@@ -134,7 +138,7 @@ const CODEX_CLI_SESSIONS_LIST_COMMAND = "codex.cli.sessions.list";
 const CODEX_CLI_SESSION_RESUME_COMMAND = "codex.cli.session.resume";
 const DEFAULT_SESSION_LIMIT = 10;
 const MAX_SESSION_LIMIT = 50;
-const DEFAULT_RESUME_TIMEOUT_MS = 20 * 6e4;
+const DEFAULT_RESUME_TIMEOUT_MS = 12e5;
 const SESSION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
 const activeResumeSessions = /* @__PURE__ */ new Set();
 function createCodexCliSessionNodeHostCommands() {
@@ -525,7 +529,7 @@ function normalizeLimit$1(value) {
 	return typeof value === "number" && Number.isFinite(value) ? Math.min(MAX_SESSION_LIMIT, Math.max(1, Math.floor(value))) : DEFAULT_SESSION_LIMIT;
 }
 function normalizeTimeoutMs(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.min(60 * 6e4, Math.floor(value)) : DEFAULT_RESUME_TIMEOUT_MS;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.min(36e5, Math.floor(value)) : DEFAULT_RESUME_TIMEOUT_MS;
 }
 function truncateText(value, max) {
 	if (value.length <= max) return value;
@@ -546,6 +550,206 @@ function formatNodeLabel(node) {
 	].filter(Boolean).join(" / ") || "node";
 }
 //#endregion
+//#region extensions/codex/src/command-rpc.ts
+async function prepareControlAuth(options, startOptions) {
+	if (!options.onResponse) return {
+		authProfileId: options.authProfileId ?? void 0,
+		clientOptions: { authProfileId: options.authProfileId }
+	};
+	if (!options.config || !options.sessionKey || !options.sessionId) throw new Error("Codex control subscription requires admitted session authority.");
+	const config = options.config;
+	const { sessionAgentId } = resolveSessionAgentIdsStrict({
+		config,
+		sessionKey: options.sessionKey,
+		agentId: options.agentId
+	});
+	const agentDir = options.agentDir ?? resolveAgentDir$2(config, sessionAgentId);
+	const workspaceDir = resolveAgentWorkspaceDir(config, sessionAgentId);
+	const entry = getSessionEntry({
+		agentId: sessionAgentId,
+		storePath: options.storePath?.trim() || resolveStorePath(config.session?.store, { agentId: sessionAgentId }),
+		sessionKey: options.sessionKey,
+		hydrateSkillPromptRefs: false,
+		readConsistency: "latest"
+	});
+	if (entry?.sessionId !== options.sessionId) throw createCodexSessionGenerationSupersededError(options.sessionId);
+	if (options.authProfileId === null || startOptions.homeScope === "user") return {
+		authProfileId: options.authProfileId ?? void 0,
+		clientOptions: { authProfileId: options.authProfileId }
+	};
+	const model = resolveSessionModelRef(config, entry, sessionAgentId);
+	const authProfileId = entry?.authProfileOverride ?? options.authProfileId;
+	const store = resolveCodexAppServerAuthProfileStore({
+		agentDir,
+		config,
+		authProfileId
+	});
+	const { plan, attempts } = prepareAgentRuntimeAuth({
+		provider: model.provider,
+		modelId: model.model,
+		config,
+		agentDir,
+		workspaceDir,
+		authProfileStore: store,
+		sessionAuthProfileId: 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 {
+		limit,
+		timeoutMs: runtime.requestTimeoutMs,
+		startOptions: runtime.start,
+		config,
+		agentDir
+	};
+}
+async function codexControlRequest(pluginConfig, method, requestParams, options = {}) {
+	const runtime = options.startOptions ? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig }) : resolveCodexAppServerRuntimeOptions({ pluginConfig });
+	const startOptions = options.startOptions ?? runtime.start;
+	const auth = await prepareControlAuth(options, startOptions);
+	const controlRequestOptions = {
+		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
+		assertCurrent: options.assertCurrent,
+		startOptions,
+		config: options.config,
+		sessionKey: options.sessionKey,
+		sessionId: options.sessionId,
+		agentDir: options.agentDir,
+		isolated: options.isolated,
+		...auth.clientOptions
+	};
+	if (options.onResponse || options.beforeRequest) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client, scope) => {
+		await options.beforeRequest?.(request, client, scope);
+		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, {
+			authProfileId: auth.authProfileId,
+			assertCurrent: scope.assertCurrent
+		});
+		scope.assertCurrent();
+		return response;
+	});
+	return await requestCodexAppServerJson({
+		method,
+		requestParams,
+		...controlRequestOptions
+	});
+}
+async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
+	return await safeValue(async () => await codexControlRequest(pluginConfig, method, requestParams, options));
+}
+async function safeCodexModelList(pluginConfig, limit, config, agentDir) {
+	return await safeValue(async () => await listCodexAppServerModels(requestOptions(pluginConfig, limit, config, agentDir)));
+}
+async function readCodexStatusProbes(pluginConfig, config, agentDir) {
+	const [models, account, limits, mcps, skills] = await Promise.all([
+		safeCodexModelList(pluginConfig, 20, config, agentDir),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, {
+			config,
+			agentDir
+		}),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, {
+			config,
+			agentDir
+		}),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }, {
+			config,
+			agentDir
+		}),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, {
+			config,
+			agentDir
+		})
+	]);
+	return {
+		models,
+		account,
+		limits,
+		mcps,
+		skills
+	};
+}
+async function safeValue(read) {
+	try {
+		return {
+			ok: true,
+			value: await read()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: describeControlFailure(error)
+		};
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/thread-archive-guard.ts
 const DESCENDANT_PAGE_LIMIT = 100;
 const MAX_DESCENDANT_PAGES = 100;
@@ -601,6 +805,7 @@ const DEFAULT_PAGE_LIMIT = 50;
 const CODEX_APP_SERVER_THREADS_CAPABILITY = "codex-app-server-threads";
 const CODEX_APP_SERVER_THREADS_LIST_COMMAND = "codex.appServer.threads.list.v1";
 const CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND = "codex.appServer.thread.turns.list.v1";
+const CODEX_CATALOG_TRANSCRIPT_READ_COMMAND = "codex.sessionCatalog.transcript.read.v1";
 const CODEX_LOCAL_SESSION_HOST_ID = "gateway:local";
 const NODE_INVOKE_TIMEOUT_MS = 65e3;
 const MAX_SEARCH_LENGTH = 500;
@@ -613,7 +818,7 @@ const MAX_SESSION_PREVIEW_LENGTH = 500;
 const MAX_SESSION_KEY_LENGTH = 1024;
 const MAX_METADATA_LENGTH = 500;
 const MAX_ACTIVE_FLAGS = 16;
-const MAX_TRANSCRIPT_PAGE_BYTES = 20 * 1024 * 1024;
+const MAX_TRANSCRIPT_PAGE_BYTES = 20971520;
 var CatalogParamsError = class extends Error {};
 function readControlCursor(value, label) {
 	if (value === void 0 || value === null) return;
@@ -863,7 +1068,7 @@ function parseTranscriptPage(value) {
 		...nextCursor ? { nextCursor } : {},
 		...backwardsCursor ? { backwardsCursor } : {}
 	};
-	if (Buffer.byteLength(JSON.stringify(page), "utf8") > MAX_TRANSCRIPT_PAGE_BYTES) throw new Error("Codex app-server transcript page exceeds the safe response size");
+	if (Buffer.byteLength(JSON.stringify(page), "utf8") > 20971520) throw new Error("Codex app-server transcript page exceeds the safe response size");
 	return page;
 }
 function requireBoundThread(entry) {
@@ -948,10 +1153,16 @@ async function finalizeNodeAdoptedSession(params) {
 			update: (entry) => {
 				const current = readNodeSessionMarker(entry);
 				if (entry.sessionId?.trim() !== params.adopted.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !current || current.sourceHostId !== params.marker.sourceHostId || current.sourceThreadId !== params.marker.sourceThreadId || current.nodeId !== params.marker.nodeId) throw changedError();
-				if (current.initializing !== true) return { archivedAt: void 0 };
+				if (current.initializing !== true) return {
+					archivedAt: void 0,
+					archivedBy: void 0,
+					archiveReason: void 0
+				};
 				const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : {};
 				return {
 					archivedAt: void 0,
+					archivedBy: void 0,
+					archiveReason: void 0,
 					pluginExtensions: {
 						...entry.pluginExtensions,
 						codex: {
@@ -997,7 +1208,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId),
 			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",
@@ -1040,182 +1251,6 @@ async function createOrReuseNodeAdoptedSession(params) {
 	}
 }
 //#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 agentDir = sources.source?.agentDir ?? (sources.agentId ? resolveAgentDir(runtimeConfig, sources.agentId) : resolveDefaultAgentDir(runtimeConfig));
-	return resolveCodexAppServerLocalHomeDir(sources.source?.appServer.start ?? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: sources.getPluginConfig() }).start, agentDir);
-}
-function 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(bindRequest, 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 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 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: {
-				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) {
-			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");
-}
-async function openCodexCatalogTerminal(params) {
-	const title = `codex resume ${params.threadId.slice(0, 8)}…`;
-	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");
-		return {
-			kind: "local",
-			argv: [
-				resolution.executable,
-				"resume",
-				params.threadId
-			],
-			...record.cwd ? { cwd: record.cwd } : {},
-			env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
-			...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
-			title
-		};
-	}
-	if (!params.hostId.startsWith("node:")) throw new CatalogParamsError("hostId is invalid");
-	const nodeId = params.hostId.slice(5);
-	if (!(await params.api.runtime.nodes.list()).nodes.find((candidate) => {
-		const commands = candidate.invocableCommands ?? candidate.commands;
-		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,
-		parseCatalogPage: params.parseCatalogPage
-	});
-	return {
-		kind: "node",
-		nodeId,
-		command: CODEX_TERMINAL_RESUME_COMMAND,
-		paramsJSON: JSON.stringify({
-			agentId: params.agentId,
-			threadId: params.threadId
-		}),
-		...record.cwd ? { cwd: record.cwd } : {},
-		title
-	};
-}
-async function startCodexCatalogTerminal(params) {
-	if (params.nodeId) throw new CatalogParamsError("Paired-node Codex terminal start is unavailable; omit hostId to start on the gateway host");
-	const resolution = resolveLocalCodexTerminalResolution();
-	if (!resolution) throw new CatalogParamsError("Codex CLI is unavailable; install Codex or add codex to PATH, then try again");
-	return {
-		kind: "local",
-		argv: [resolution.executable, ...params.initialMessage !== void 0 ? ["--", params.initialMessage] : []],
-		cwd: params.cwd,
-		env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
-		...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
-		title: "codex"
-	};
-}
-//#endregion
 //#region extensions/codex/src/session-catalog-adoption.ts
 const CODEX_SUPERVISION_SESSION_KEY_PREFIX = "harness:codex:supervision:";
 const boundCatalogSessionId = (value) => boundedCatalogString(value, 256);
@@ -1255,7 +1290,7 @@ async function listAdoptedSessionEntries(params) {
 		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({
+		const binding = params.bindingStore.read(sessionBindingIdentity({
 			sessionId,
 			sessionKey,
 			config: params.config
@@ -1278,54 +1313,26 @@ async function findAdoptedSessionEntry(params) {
 	const adopted = await listAdoptedSessionEntries(params);
 	return adopted.get(sessionCatalogAdoptedSourceKey(params.sourceHomeId ?? "gateway:local", params.threadId)) ?? (params.sourceHomeId && params.allowLegacy === true ? adopted.get(sessionCatalogAdoptedSourceKey("gateway:local", params.threadId)) : void 0);
 }
-async function clearCreatedAdoptionBinding(params) {
-	let cleared = false;
-	let clearError;
-	try {
-		cleared = await params.bindingStore.mutate(params.identity, {
-			kind: "clear",
-			threadId: params.sourceThreadId,
-			expectedPendingSupervisionBranch: params.expectedPending
-		});
-	} catch (error) {
-		clearError = error;
-	}
-	if (cleared) return;
-	let current;
-	try {
-		current = await params.bindingStore.read(params.identity);
-	} catch (readError) {
-		throw new AggregateError([
-			params.cause,
-			...clearError ? [clearError] : [],
-			readError
-		], `OpenClaw session creation failed and the Codex binding could not be verified for ${params.sourceThreadId}`, { cause: readError });
-	}
-	if (!matchesPendingSupervisionOwner(current, params.expectedPending)) return;
-	throw new AggregateError([params.cause, ...clearError ? [clearError] : []], `OpenClaw session creation failed and the Codex binding could not be cleared for ${params.sourceThreadId}`, { cause: params.cause });
-}
 function matchesPendingAdoptionBinding(binding, expected) {
 	const historyCoveredThrough = binding?.historyCoveredThrough;
 	return binding?.threadId === expected.sourceThreadId && binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && binding.cwd === expected.cwd && binding.conversationSourceTransferComplete === true && binding.preserveNativeModel === true && binding.pendingSupervisionBranch?.sourceThreadId === expected.sourceThreadId && binding.pendingSupervisionBranch.connectionFingerprint === expected.connectionFingerprint && binding.pendingSupervisionBranch.lastTurnId === expected.lastTurnId && (binding.pendingSupervisionBranch.cleanupThreadIds?.length ?? 0) === 0 && typeof historyCoveredThrough === "string" && Number.isFinite(Date.parse(historyCoveredThrough));
 }
-function matchesPendingSupervisionOwner(binding, expected) {
-	const pending = binding?.pendingSupervisionBranch;
-	const cleanupThreadIds = pending?.cleanupThreadIds ?? [];
-	const expectedCleanupThreadIds = expected.cleanupThreadIds ?? [];
-	return binding?.threadId === expected.sourceThreadId && binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && pending?.sourceThreadId === expected.sourceThreadId && pending.connectionFingerprint === expected.connectionFingerprint && pending.lastTurnId === expected.lastTurnId && cleanupThreadIds.length === expectedCleanupThreadIds.length && cleanupThreadIds.every((threadId, index) => threadId === expectedCleanupThreadIds[index]);
-}
 async function ensurePendingAdoptionBinding(params) {
 	const pending = {
 		sourceThreadId: params.sourceThreadId,
 		connectionFingerprint: params.connectionFingerprint,
 		...params.lastTurnId ? { lastTurnId: params.lastTurnId } : {}
 	};
-	if (!await reclaimCurrentCodexSessionGeneration({
+	const ownsGeneration = await reclaimCurrentCodexSessionGeneration({
+		assertCurrent: params.initialization.assertCurrent,
 		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);
+	});
+	params.initialization.assertCurrent();
+	if (!ownsGeneration) throw new Error(`failed to claim the OpenClaw session generation for ${params.sourceThreadId}`);
+	const existing = params.bindingStore.read(params.identity);
+	params.initialization.assertCurrent();
 	if (existing) {
 		if (matchesPendingAdoptionBinding(existing, params)) return;
 		throw new Error(`OpenClaw session is already bound to Codex thread ${existing.threadId}`);
@@ -1340,19 +1347,7 @@ async function ensurePendingAdoptionBinding(params) {
 		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}`);
+	await params.initialization.bind(binding);
 }
 async function createOrReuseAdoptedSession(params) {
 	const runtime = params.api.runtime;
@@ -1363,8 +1358,6 @@ async function createOrReuseAdoptedSession(params) {
 	};
 	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);
@@ -1374,9 +1367,11 @@ async function createOrReuseAdoptedSession(params) {
 		};
 		const created = await createImportedCodexSession({
 			runtime: params.api.runtime,
+			bindingStore: params.bindingStore,
 			config: params.config,
 			key: adoptionSessionKey(params.sourceThread.id, params.sourceHomeId),
 			agentId: params.agentId,
+			displayName: params.sourceThread.name ?? void 0,
 			thread: params.sourceThread,
 			throughTurnId: pendingLastTurnId ?? null,
 			recoverMatchingInitialEntry: true,
@@ -1389,21 +1384,17 @@ async function createOrReuseAdoptedSession(params) {
 					modelLocked: true
 				} } }
 			},
-			afterImport: async (entry) => {
-				createdBindingIdentity = sessionBindingIdentity({
+			afterImport: async (entry, initialization) => {
+				const identity = 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,
+					identity,
+					initialization,
 					sourceThreadId: params.sourceThread.id,
 					connectionFingerprint: params.connectionFingerprint,
 					cwd: spawnedCwd ?? "",
@@ -1422,24 +1413,13 @@ async function createOrReuseAdoptedSession(params) {
 			boundThreadId: params.sourceThread.id
 		};
 	} catch (error) {
-		let raced = await findAdoptedSessionEntry(lookup);
+		const raced = await findAdoptedSessionEntry(lookup);
 		if (raced) return raced;
-		if (createdBindingIdentity && createdPendingBinding) {
-			await clearCreatedAdoptionBinding({
-				bindingStore: params.bindingStore,
-				identity: createdBindingIdentity,
-				sourceThreadId: params.sourceThread.id,
-				expectedPending: createdPendingBinding,
-				cause: error
-			});
-			raced = await findAdoptedSessionEntry(lookup);
-			if (raced) return raced;
-		}
 		throw error;
 	}
 }
 async function continueLocalCodexSessionInner(params) {
-	await requireCatalogEligibleThread(params.control, params.threadId);
+	await params.control.requireEligibleThread(params.threadId);
 	const existing = await findAdoptedSessionEntry({
 		...params,
 		runtime: params.api.runtime
@@ -1455,7 +1435,11 @@ async function continueLocalCodexSessionInner(params) {
 			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 {
+					archivedAt: void 0,
+					archivedBy: void 0,
+					archiveReason: void 0
+				};
 			}
 		})) throw changedError();
 		const connectionFingerprint = params.control.connectionFingerprint;
@@ -1510,8 +1494,8 @@ async function continueLocalCodexSession(params) {
 }
 //#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({
+function assertNoPendingSupervisionBranch(params) {
+	const adoptedEntries = [params.agentId, ...listAgentIds$1(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));
@@ -1519,7 +1503,7 @@ async function assertNoPendingSupervisionBranch(params) {
 		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({
+		const binding = params.bindingStore.read(sessionBindingIdentity({
 			sessionId,
 			sessionKey: adopted.sessionKey,
 			config: params.config
@@ -1532,8 +1516,8 @@ 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);
+				assertNoPendingSupervisionBranch(params);
+				await control.requireEligibleThread(params.threadId);
 				const thread = await control.readThread(params.threadId, false);
 				if (thread.id !== params.threadId) throw new Error("Codex app-server returned a different thread than requested");
 				requireIdleThread(thread, "archive");
@@ -1561,7 +1545,7 @@ 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 agentId = requestedAgentId ?? resolveDefaultAgentId$1(config);
 	const defaultModel = resolveDefaultModelForAgent({
 		cfg: config,
 		agentId
@@ -1607,7 +1591,8 @@ async function listPairedNode(params) {
 		label: nodeLabel(params.node),
 		kind: "node",
 		nodeId: params.node.nodeId,
-		canContinueCodex: canContinueCodexOnNode(params.node)
+		canContinueCodex: canContinueCodexOnNode(params.node),
+		...params.terminalCapabilities
 	};
 	if (params.node.connected !== true) {
 		const host = {
@@ -1622,6 +1607,15 @@ async function listPairedNode(params) {
 		params.onHost?.(host);
 		return host;
 	}
+	if (!params.node.commands?.includes("codex.appServer.threads.list.v1")) {
+		const host = {
+			...common,
+			connected: true,
+			sessions: []
+		};
+		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,
@@ -1633,7 +1627,8 @@ async function listPairedNode(params) {
 				searchTerm: params.query.search
 			},
 			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
-			scopes: ["operator.write"]
+			scopes: ["operator.write"],
+			signal: params.signal
 		}))), params.query.search);
 		return {
 			...common,
@@ -1650,7 +1645,7 @@ async function listPairedNode(params) {
 		sessions: [],
 		error: catalogError("NODE_INVOKE_FAILED", error)
 	}));
-	if (params.onHost) eventualHost.then(params.onHost).catch(() => void 0);
+	publishSessionCatalogHost(params, eventualHost);
 	try {
 		return await withTimeout(eventualHost, NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS, "paired node Codex session catalog timed out");
 	} catch (error) {
@@ -1800,7 +1795,7 @@ async function continueNodeCodexSession(params) {
 	if (params.clientScopes?.includes("operator.admin") !== true) throw new CatalogParamsError("continuing a paired-node Codex session requires operator.admin");
 	const nodeId = params.hostId.slice(5).trim();
 	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
-	const agentId = resolveSessionAgentIds({
+	const agentId = resolveSessionAgentIdsStrict({
 		config: params.config,
 		agentId: params.agentId
 	}).sessionAgentId;
@@ -1817,15 +1812,342 @@ async function continueNodeCodexSession(params) {
 	});
 }
 //#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;
+//#region extensions/codex/src/session-catalog-terminal.ts
+const CODEX_TERMINAL_RESUME_COMMAND = "codex.terminal.resume.v1";
+const CODEX_TERMINAL_START_COMMAND = "codex.terminal.start.v1";
+function createCodexTerminalStartNodeHostCommand() {
+	return {
+		command: CODEX_TERMINAL_START_COMMAND,
+		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+		dangerous: false,
+		duplex: true,
+		isAvailable: ({ env }) => Boolean(resolveNodeHostExecutable("codex", {
+			env,
+			strategy: "direct"
+		})),
+		handle: async (paramsJSON, io) => {
+			if (!io) throw new Error("Codex terminal command requires duplex transport");
+			const params = decodeNodePtyStartParams(paramsJSON);
+			const resolution = resolveNodeHostExecutable("codex", { strategy: "direct" });
+			if (!resolution) throw new Error("Codex CLI is unavailable; install codex on this node and reconnect");
+			return JSON.stringify(await runNodePtyCommand({
+				file: resolution.executable,
+				args: params.initialMessage !== void 0 ? ["--", params.initialMessage] : [],
+				cwd: params.cwd,
+				requiredCwd: true,
+				cols: params.cols,
+				rows: params.rows
+			}, io));
+		}
+	};
+}
+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$2(runtimeConfig, sources.agentId) : resolveDefaultAgentDir(runtimeConfig));
+	const startOptions = sources.source?.appServer.start ?? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig: sources.getPluginConfig() }).start;
+	return resolveCodexAppServerLocalHomeDir(startOptions, agentDir);
+}
+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 {
+		canOpenTerminalCodex: node.connected === true && commands?.includes("codex.terminal.resume.v1") === true,
+		canStartTerminal: node.connected === true && node.invocableCommands?.includes("codex.terminal.start.v1") === true
+	};
+}
+function createCodexTerminalNodeHostCommand(bindRequest, 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 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 request.control.requireEligibleThread(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],
+				...record.cwd ? { cwd: record.cwd } : {},
+				env: { CODEX_HOME: resolveCodexCatalogTerminalHome({
+					...configSources,
+					agentId: request.agentId
+				}) },
+				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: {
+				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) {
+			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");
+}
+async function openCodexCatalogTerminal(params) {
+	const title = `codex resume ${params.threadId.slice(0, 8)}…`;
+	if (params.hostId === "gateway:local" || params.hostId.startsWith(`gateway:local:`)) {
+		const record = await params.control.requireEligibleThread(params.threadId);
+		const resolution = resolveLocalCodexTerminalResolution();
+		if (!resolution) throw new CatalogParamsError("Codex CLI is unavailable");
+		return {
+			kind: "local",
+			argv: [
+				resolution.executable,
+				"resume",
+				params.threadId
+			],
+			...record.cwd ? { cwd: record.cwd } : {},
+			env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
+			...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
+			title
+		};
+	}
+	if (!params.hostId.startsWith("node:")) throw new CatalogParamsError("hostId is invalid");
+	const nodeId = params.hostId.slice(5);
+	if (!(await params.api.runtime.nodes.list()).nodes.find((candidate) => {
+		const commands = candidate.invocableCommands ?? candidate.commands;
+		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,
+		parseCatalogPage: params.parseCatalogPage
+	});
+	return {
+		kind: "node",
+		nodeId,
+		command: CODEX_TERMINAL_RESUME_COMMAND,
+		paramsJSON: JSON.stringify({
+			agentId: params.agentId,
+			threadId: params.threadId
+		}),
+		...record.cwd ? { cwd: record.cwd } : {},
+		title
+	};
+}
+async function startCodexCatalogTerminal(params) {
+	if (params.nodeId) return {
+		kind: "node",
+		nodeId: params.nodeId,
+		command: CODEX_TERMINAL_START_COMMAND,
+		paramsJSON: JSON.stringify({
+			cwd: params.cwd,
+			initialMessage: params.initialMessage
+		}),
+		cwd: params.cwd,
+		title: "codex"
+	};
+	const resolution = resolveLocalCodexTerminalResolution();
+	if (!resolution) throw new CatalogParamsError("Codex CLI is unavailable; install Codex or add codex to PATH, then try again");
+	return {
+		kind: "local",
+		argv: [resolution.executable, ...params.initialMessage !== void 0 ? ["--", params.initialMessage] : []],
+		cwd: params.cwd,
+		env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
+		...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
+		title: "codex"
+	};
+}
+//#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-catalog-transcript.ts
+const TURN_ITEM_CURSOR_PREFIX = "turn-item:";
+const transcriptPageSchema = z.strictObject({
+	items: z.array(z.strictObject({
+		id: z.string(),
+		type: z.enum([
+			"userMessage",
+			"agentMessage",
+			"reasoning",
+			"toolCall",
+			"toolResult",
+			"other"
+		]),
+		text: z.string().optional(),
+		raw: z.record(z.string(), z.json()).optional(),
+		truncated: z.boolean().optional()
+	})),
+	nextCursor: z.string().optional()
+});
+function parseCodexCatalogTranscriptPage(value) {
+	return transcriptPageSchema.parse(value);
+}
+function encodeTurnItemCursor(turnCursor, itemId) {
+	return TURN_ITEM_CURSOR_PREFIX + Buffer.from(JSON.stringify([turnCursor, itemId])).toString("base64url");
+}
+function decodeTurnItemCursor(cursor) {
+	if (!cursor?.startsWith(TURN_ITEM_CURSOR_PREFIX)) return { turnCursor: cursor };
+	let value;
+	try {
+		value = JSON.parse(Buffer.from(cursor.slice(10), "base64url").toString());
+	} catch {
+		throw new CatalogParamsError("invalid Codex transcript item cursor");
+	}
+	if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !value[0] || typeof value[1] !== "string" || !value[1]) throw new CatalogParamsError("invalid Codex transcript item cursor");
+	return {
+		turnCursor: value[0],
+		itemId: value[1]
+	};
+}
+function projectTranscriptPage(items, limit) {
+	const projected = items.map(toGenericTranscriptItem);
+	const page = sessionCatalogPaging.boundTranscriptPage(projected.toReversed(), limit, 0).items;
+	for (const [index, item] of page.entries()) if (item.text !== projected[index]?.text && projected[index]?.text) item.truncated = true;
+	return page;
+}
+function pageFitsNodeTransport(page) {
+	return Buffer.byteLength(JSON.stringify({ payloadJSON: JSON.stringify(page) }), "utf8") <= MAX_TRANSCRIPT_PAGE_BYTES;
+}
+/** The legacy API can anchor a turn, but cannot continue within that turn. */
+async function readLegacyCodexTranscriptPage(readTurns, request) {
+	const { turnCursor, itemId } = decodeTurnItemCursor(request.cursor);
+	const page = parseTranscriptPage(await readTurns({
+		threadId: request.threadId,
+		limit: 1,
+		sortDirection: "desc",
+		itemsView: "full",
+		...turnCursor ? { cursor: turnCursor } : {}
+	}));
+	const source = page.data.flatMap((turn) => turn.items.toReversed());
+	const anchorIndex = itemId ? source.findIndex((item) => item.id === itemId) : -1;
+	if (itemId && anchorIndex < 0) throw new CatalogParamsError("Codex transcript changed; refresh the session before loading older items");
+	const remaining = source.slice(anchorIndex + 1);
+	const items = projectTranscriptPage(remaining, request.limit);
+	const result = () => {
+		const lastSource = remaining[items.length - 1];
+		const partial = lastSource !== void 0 && items.length < remaining.length;
+		const nativeCursor = partial ? page.backwardsCursor : page.nextCursor;
+		const cursor = nativeCursor ? partial ? encodeTurnItemCursor(nativeCursor, lastSource.id) : nativeCursor : void 0;
+		if (partial && !cursor) throw new Error("Codex app-server did not provide a transcript continuation anchor");
+		return {
+			items,
+			...cursor ? { nextCursor: cursor } : {}
+		};
+	};
+	let bounded = result();
+	while (!pageFitsNodeTransport(bounded)) {
+		if (items.length <= 1) throw new Error("Codex transcript item exceeds the safe response size");
+		items.pop();
+		bounded = result();
+	}
+	return bounded;
+}
+/** Uses the native store's item cursor whenever that store supports item history. */
+async function readCodexCatalogTranscriptPage(control, request) {
+	if ((await control.requireEligibleThread(request.threadId)).historyMode !== "paginated") return readLegacyCodexTranscriptPage((params) => control.listTurnPage(params), request);
+	let limit = request.limit;
+	for (;;) {
+		const page = await control.listItemPage({
+			threadId: request.threadId,
+			limit,
+			sortDirection: "desc",
+			...request.cursor ? { cursor: request.cursor } : {}
+		});
+		const nextCursor = readControlCursor(page.nextCursor, "transcript next response");
+		const items = projectTranscriptPage(page.data.map(({ item }) => item), limit);
+		const result = {
+			items,
+			...nextCursor ? { nextCursor } : {}
+		};
+		const fittingCount = items.length - (pageFitsNodeTransport(result) ? 0 : 1);
+		if (fittingCount === page.data.length) return result;
+		if (fittingCount < 1) throw new Error("Codex transcript item exceeds the safe response size");
+		limit = fittingCount;
+	}
+}
+//#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) {
+		params.signal?.throwIfAborted();
 		let excludedFromPage = false;
 		const rawPage = await params.control.listPage({
 			limit: params.limit - sessions.length,
@@ -1833,10 +2155,12 @@ async function listVisiblePage(params) {
 			...params.searchTerm ? { searchTerm: params.searchTerm } : {},
 			...params.cwd ? { cwd: params.cwd } : {}
 		});
+		params.signal?.throwIfAborted();
 		const page = filterCatalogPageByTitle(parseCatalogPage(rawPage), params.searchTerm);
 		if (pageIndex === 0) backwardsCursor = page.backwardsCursor;
 		for (const managed of rawPage.managedThreads ?? []) {
 			excludedFromPage = true;
+			params.signal?.throwIfAborted();
 			await params.onExcludedThread?.(managed);
 		}
 		for (const session of page.sessions) {
@@ -1845,6 +2169,7 @@ async function listVisiblePage(params) {
 				continue;
 			}
 			excludedFromPage = true;
+			params.signal?.throwIfAborted();
 			await params.onExcludedThread?.({ threadId: session.threadId });
 		}
 		nextCursor = page.nextCursor;
@@ -1870,8 +2195,10 @@ async function listGatewayHost(params) {
 			excludedThreadIds: params.excludedThreadIds,
 			limit: params.query.limitPerHost,
 			onExcludedThread: params.onExcludedThread,
-			searchTerm: params.query.search
+			searchTerm: params.query.search,
+			signal: params.signal
 		});
+		params.signal?.throwIfAborted();
 		const adoptedSessions = await listAdoptedSessionEntries({
 			agentId: params.agentId,
 			bindingStore: params.bindingStore,
@@ -1904,7 +2231,7 @@ async function listGatewayHost(params) {
 }
 /** Lists Gateway-local and paired-node Codex sessions with per-host failures. */
 async function listCodexSessionCatalog(params) {
-	const agentId = resolveSessionAgentIds({
+	const agentId = resolveSessionAgentIdsStrict({
 		config: params.config ?? {},
 		agentId: params.agentId
 	}).sessionAgentId;
@@ -1912,6 +2239,7 @@ async function listCodexSessionCatalog(params) {
 	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();
+	params.signal?.throwIfAborted();
 	const fallbackSource = params.control.homesForAgent(agentId)[0];
 	const localHosts = localSources.map((source) => (() => {
 		const ownershipSource = source ?? fallbackSource;
@@ -1924,6 +2252,7 @@ async function listCodexSessionCatalog(params) {
 			query,
 			runtime: params.runtime,
 			sessionEntries: params.sessionEntries,
+			signal: params.signal,
 			excludedThreadIds: managedThreadIds,
 			...ownershipSource && params.bindingStore.managedThreads ? { onExcludedThread: async ({ threadId, rolloutPath }) => {
 				if (!managedThreadIds?.has(threadId)) await params.bindingStore.managedThreads?.mark({
@@ -1935,40 +2264,42 @@ async function listCodexSessionCatalog(params) {
 			...source ? { source } : {}
 		});
 	})());
-	for (const host of localHosts) if (params.onHost) host.then(params.onHost).catch(() => void 0);
+	for (const host of localHosts) publishSessionCatalogHost(params, host);
 	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);
+		nodes = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes.filter((node) => node.gatewayLocal !== true && (node.commands?.includes("codex.appServer.threads.list.v1") || codexNodeTerminalCapability(node).canStartTerminal) && (!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,
+			canStartTerminal: false,
 			sessions: [],
 			error: catalogError("NODE_LIST_FAILED", error)
 		};
 		params.onHost?.(registryHost);
 		return { hosts: [...await Promise.all(localHosts), registryHost] };
 	}
+	params.signal?.throwIfAborted();
 	const adoptedNodeSessions = listNodeAdoptedSessionEntries({
 		agentId,
 		config: params.config,
 		runtime: params.runtime,
 		sessionEntries: params.sessionEntries
 	});
-	const nodeHosts = nodes.toSorted(compareNodeLabels).map(async (node) => {
-		const host = await listPairedNode({
-			agentId,
-			runtime: params.runtime,
-			node,
-			query,
-			adoptedSessions: adoptedNodeSessions,
-			...params.onHost ? { onHost: params.onHost } : {}
-		});
-		return Object.assign(host, codexNodeTerminalCapability(node));
-	});
+	const nodeHosts = nodes.toSorted(compareNodeLabels).map((node) => listPairedNode({
+		agentId,
+		runtime: params.runtime,
+		node,
+		query,
+		adoptedSessions: adoptedNodeSessions,
+		terminalCapabilities: codexNodeTerminalCapability(node),
+		waitUntil: params.waitUntil,
+		signal: params.signal,
+		...params.onHost ? { onHost: params.onHost } : {}
+	}));
 	return { hosts: await Promise.all([...localHosts, ...nodeHosts]) };
 }
 /** Builds the node-local read-only Codex app-server catalog command. */
@@ -1978,11 +2309,11 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, configSources
 		if (!isRecord(parsed)) throw new CatalogParamsError("Codex session catalog parameters must be an object");
 		const requestedAgentId = readBoundedOptionalString(parsed, "agentId", 256);
 		const config = configSources.getRuntimeConfig() ?? {};
-		const agentId = resolveSessionAgentIds({
+		const agentId = resolveSessionAgentIdsStrict({
 			config,
 			agentId: requestedAgentId
 		}).sessionAgentId;
-		if (!listAgentIds(config).includes(agentId)) throw new CatalogParamsError(`unknown Codex session catalog agent: ${agentId}`);
+		if (!listAgentIds$1(config).includes(agentId)) throw new CatalogParamsError(`unknown Codex session catalog agent: ${agentId}`);
 		const request = { ...parsed };
 		delete request.agentId;
 		const source = controlFactory.homesForAgent(agentId)[0];
@@ -1994,7 +2325,7 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, configSources
 			paramsJSON: JSON.stringify(request)
 		};
 	};
-	return [
+	const commands = [
 		{
 			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
 			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
@@ -2035,7 +2366,7 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, configSources
 				const request = bindRequest(paramsJSON);
 				const action = readNodeTranscriptParams(request.params);
 				try {
-					await requireCatalogEligibleThread(request.control, action.threadId);
+					await request.control.requireEligibleThread(action.threadId);
 					const page = parseTranscriptPage(await request.control.listTurnPage({
 						threadId: action.threadId,
 						limit: action.limit,
@@ -2050,8 +2381,25 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, configSources
 				}
 			}
 		},
-		createCodexTerminalNodeHostCommand(bindRequest, configSources)
+		{
+			command: CODEX_CATALOG_TRANSCRIPT_READ_COMMAND,
+			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+			dangerous: false,
+			handle: async (paramsJSON) => {
+				const request = bindRequest(paramsJSON);
+				const action = readNodeTranscriptParams(request.params);
+				try {
+					return JSON.stringify(await readCodexCatalogTranscriptPage(request.control, action));
+				} catch (error) {
+					if (error instanceof CatalogParamsError) throw error;
+					throw new Error("Codex app-server transcript is unavailable", { cause: error });
+				}
+			}
+		},
+		createCodexTerminalNodeHostCommand(bindRequest, configSources),
+		createCodexTerminalStartNodeHostCommand()
 	];
+	return process.env.OPENCLAW_NODE_EXEC_HOST?.trim().toLowerCase() === "app" ? commands.filter(({ command }) => command !== CODEX_CATALOG_TRANSCRIPT_READ_COMMAND) : commands;
 }
 function readNodeTranscriptParams(value) {
 	if (!isRecord(value)) throw new CatalogParamsError("Codex session read parameters must be an object");
@@ -2074,94 +2422,58 @@ function readBoundedLimit(value, key, fallback, max) {
 	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) {
+	const cursor = readControlCursor(params.cursor, "transcript request");
+	const limit = readBoundedLimit(params.limit, "limit", 20, 50);
 	if (params.source || params.hostId === "gateway:local") {
-		await requireCatalogEligibleThread(params.control, params.threadId);
-		const listParams = {
+		const page = await readCodexCatalogTranscriptPage(params.control, {
 			threadId: params.threadId,
-			limit: params.limit,
-			sortDirection: "desc",
-			itemsView: "full",
-			...params.cursor ? { cursor: params.cursor } : {}
-		};
-		const page = parseTranscriptPage(await params.control.listTurnPage(listParams));
+			limit,
+			cursor
+		});
 		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 } : {}
+			...page
 		};
 	}
 	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({
+	const invoke = async (command, request) => unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
 		nodeId,
-		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+		command,
 		params: {
 			agentId: params.agentId,
 			threadId: params.threadId,
-			limit: params.limit,
-			...params.cursor ? { cursor: params.cursor } : {}
+			...request
 		},
 		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
 		scopes: ["operator.write"]
-	})));
+	}));
+	const page = node.commands?.includes("codex.sessionCatalog.transcript.read.v1") ? parseCodexCatalogTranscriptPage(await invoke(CODEX_CATALOG_TRANSCRIPT_READ_COMMAND, {
+		cursor,
+		limit
+	})) : await readLegacyCodexTranscriptPage(async ({ cursor: turnCursor, limit: turnLimit }) => parseTranscriptPage(await invoke(CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, {
+		cursor: turnCursor,
+		limit: turnLimit
+	})), {
+		threadId: params.threadId,
+		cursor,
+		limit
+	});
 	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.text || resultText || changesText || fallback;
-	return {
-		id: item.id,
-		type,
-		...text ? { text } : {},
-		raw: item
+		...page
 	};
 }
 //#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;
@@ -2224,14 +2536,14 @@ function normalizeUserMessageTexts(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) {
+async function checkCodexUpstreamActivity(probes, control, resolveThreadId = (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 threadId = resolveThreadId(probe);
 				const page = await pinned.listTurnPage({
 					threadId,
 					limit: CODEX_UPSTREAM_TURN_LIMIT,
@@ -2243,7 +2555,7 @@ async function checkCodexUpstreamActivity(probes, control, resolveThreadId = asy
 					try {
 						await pinned.readThread(threadId, false);
 					} catch (error) {
-						if (isCodexThreadGoneError(error)) activities.push({
+						if (isCodexThreadReadMissingError(error, threadId)) activities.push({
 							kind: "missing",
 							sessionKey: probe.sessionKey
 						});
@@ -2261,7 +2573,7 @@ async function checkCodexUpstreamActivity(probes, control, resolveThreadId = asy
 	});
 }
 function createChecker(params) {
-	const resolveThreadId = async (probe) => {
+	const resolveThreadId = (probe) => {
 		const config = params.getRuntimeConfig();
 		const sessionId = params.api.runtime.agent.session.getSessionEntry({
 			agentId: probe.agentId,
@@ -2269,7 +2581,7 @@ function createChecker(params) {
 			readConsistency: "latest"
 		})?.sessionId?.trim();
 		if (!sessionId) return probe.threadId;
-		const binding = await params.bindingStore.read(sessionBindingIdentity({
+		const binding = params.bindingStore.read(sessionBindingIdentity({
 			sessionId,
 			sessionKey: probe.sessionKey,
 			config
@@ -2311,7 +2623,7 @@ function existingCatalogHomeCandidates(value, label) {
 /** Resolves every local Codex store the operator already owns, without path disclosure. */
 function resolveCodexCatalogHomes(params) {
 	const { config, env, ownerAgentId, pluginConfig } = params;
-	const ownerAgentDir = resolveAgentDir(config, ownerAgentId, env);
+	const ownerAgentDir = resolveAgentDir$2(config, ownerAgentId, env);
 	const configuredHomes = readCodexPluginConfig(pluginConfig).sessionCatalog?.homes ?? [];
 	const base = resolveCodexSupervisionAppServerRuntimeOptions({
 		pluginConfig,
@@ -2333,8 +2645,8 @@ function resolveCodexCatalogHomes(params) {
 			label: "Local Codex · user",
 			usesProcessHomeFallback: !processHomeConfigured
 		});
-		const agentIds = listAgentIds(config).toSorted((left, right) => left === ownerAgentId ? -1 : right === ownerAgentId ? 1 : left.localeCompare(right));
-		candidates.push(...agentIds.flatMap((agentId) => existingCatalogHomeCandidates(resolveCodexAppServerHomeDir(resolveAgentDir(config, agentId, env)), agentId)), ...configuredHomes.flatMap((entry) => {
+		const agentIds = listAgentIds$1(config).toSorted((left, right) => left === ownerAgentId ? -1 : right === ownerAgentId ? 1 : left.localeCompare(right));
+		candidates.push(...agentIds.flatMap((agentId) => existingCatalogHomeCandidates(resolveCodexAppServerHomeDir(resolveAgentDir$2(config, agentId, env)), agentId)), ...configuredHomes.flatMap((entry) => {
 			const { path: home, label } = typeof entry === "string" ? { path: entry } : entry;
 			return existingCatalogHomeCandidates(home, label);
 		}));
@@ -2375,7 +2687,7 @@ function createCodexCatalogHomeResolver(params) {
 	const homesByConfig = /* @__PURE__ */ new WeakMap();
 	const buildSnapshot = (config) => {
 		const pluginConfig = params.getPluginConfig();
-		const homesByAgent = new Map(listAgentIds(config).map((agentId) => [agentId, resolveCodexCatalogHomes({
+		const homesByAgent = new Map(listAgentIds$1(config).map((agentId) => [agentId, resolveCodexCatalogHomes({
 			config,
 			pluginConfig,
 			ownerAgentId: agentId,
@@ -2400,96 +2712,6 @@ function createCodexCatalogHomeResolver(params) {
 	} };
 }
 //#endregion
-//#region extensions/codex/src/session-catalog-provenance.ts
-const MAX_SESSION_META_BYTES = 1024 * 1024;
-const SESSION_META_READ_CHUNK_BYTES = 64 * 1024;
-const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
-const provenanceByPath = /* @__PURE__ */ new Map();
-function cacheProvenance(key, value) {
-	provenanceByPath.delete(key);
-	provenanceByPath.set(key, value);
-	while (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) {
-		const oldest = provenanceByPath.keys().next().value;
-		if (oldest === void 0) break;
-		provenanceByPath.delete(oldest);
-	}
-}
-/** Undefined means the metadata line is not durable enough to cache yet. */
-async function readOpenClawOriginator(sessionsRoot, rolloutPath, threadId) {
-	let safeRoot;
-	try {
-		safeRoot = await root(sessionsRoot, {
-			hardlinks: "reject",
-			maxBytes: Number.MAX_SAFE_INTEGER,
-			symlinks: "reject"
-		});
-	} catch {
-		return;
-	}
-	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
-	for (const candidate of candidates) {
-		let opened;
-		try {
-			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
-		} catch {
-			continue;
-		}
-		const input = opened.handle.createReadStream({
-			autoClose: false,
-			highWaterMark: SESSION_META_READ_CHUNK_BYTES
-		});
-		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
-		try {
-			const chunks = [];
-			let bytesReadTotal = 0;
-			let line;
-			for await (const value of reader) {
-				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
-				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
-				if (remaining <= 0) break;
-				const bounded = chunk.subarray(0, remaining);
-				bytesReadTotal += bounded.length;
-				const newline = bounded.indexOf(10);
-				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
-				if (newline >= 0) {
-					line = Buffer.concat(chunks).toString("utf8");
-					break;
-				}
-			}
-			if (!line) continue;
-			let parsed;
-			try {
-				parsed = JSON.parse(line);
-			} catch {
-				continue;
-			}
-			if (!isRecord(parsed) || parsed.type !== "session_meta" || !isRecord(parsed.payload)) return false;
-			const payload = parsed.payload;
-			return (payload.id ?? payload.session_id) === threadId && payload.originator === "openclaw";
-		} catch {
-			continue;
-		} finally {
-			reader.destroy();
-			input.destroy();
-			await opened.handle.close().catch(() => void 0);
-		}
-	}
-}
-/**
-* Codex 0.147 reports OpenClaw app-server rollouts as `vscode`, so the rollout's
-* immutable session metadata is the authoritative historical provenance.
-*/
-async function isOpenClawManagedCodexThread(thread, localSessionsRoot) {
-	const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
-	if (!localSessionsRoot || !rolloutPath) return false;
-	const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
-	const cached = provenanceByPath.get(cacheKey);
-	if (cached !== void 0) return cached;
-	const managed = await readOpenClawOriginator(localSessionsRoot, rolloutPath, thread.id);
-	if (managed !== void 0) cacheProvenance(cacheKey, managed);
-	return managed ?? false;
-}
-//#endregion
 //#region extensions/codex/src/session-catalog-control.ts
 const CODEX_SESSION_CATALOG_LIST_TTL_MS = 32e3;
 const CODEX_SESSION_CATALOG_LIST_CACHE_MAX_ENTRIES = 32;
@@ -2508,21 +2730,76 @@ function createCodexCatalogRequestSnapshot(requestTimeoutMs, request) {
 		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, {
+		listThreadItems: (params) => request(CODEX_CONTROL_METHODS.listThreadItems, params),
+		forkThread: (params, assertCurrent) => request(CODEX_CONTROL_METHODS.forkThread, assertCodexThreadForkParams(params), void 0, assertCurrent),
+		readThread: async (threadId, includeTurns, timeoutMs) => (await request(CODEX_CONTROL_METHODS.readThread, {
 			threadId,
 			includeTurns
-		})).thread,
-		archiveThread: async (threadId) => {
-			await request(CODEX_CONTROL_METHODS.archiveThread, { threadId });
+		}, timeoutMs)).thread,
+		archiveThread: async (threadId, assertCurrent) => {
+			await request(CODEX_CONTROL_METHODS.archiveThread, { threadId }, void 0, assertCurrent);
 		}
 	};
 }
 function createCodexSessionCatalogControlFromRequests(params) {
 	return {
+		forkContext: params.forkContext,
 		...params.clientId ? { clientId: params.clientId } : {},
 		...params.connectionFingerprint ? { connectionFingerprint: params.connectionFingerprint } : {},
 		withPinnedConnection: params.withPinnedConnection,
+		async requireEligibleThread(threadId) {
+			const requests = params.createRequestSnapshot();
+			const deadline = params.now() + requests.requestTimeoutMs;
+			const unverified = () => new CatalogParamsError("Codex session eligibility could not be verified. Refresh the catalog and verify the session in its native Codex home before retrying.");
+			const remaining = () => {
+				const timeoutMs = Math.ceil(deadline - params.now());
+				if (timeoutMs <= 0) throw unverified();
+				return timeoutMs;
+			};
+			const verify = async () => {
+				if (params.sourceHomeId && await params.managedThreads?.has(params.sourceHomeId, threadId)) throw unverified();
+				const root = params.localSessionsRoot;
+				const thread = root ? await requests.readThread(threadId, false, remaining()) : void 0;
+				if (root && (!thread || thread.id !== threadId || !isInteractiveThreadSource(thread.source))) throw unverified();
+				let cursor;
+				const seenCursors = /* @__PURE__ */ new Set();
+				for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
+					const page = await requests.listThreads({
+						archived: false,
+						limit: 100,
+						modelProviders: [],
+						sortKey: root ? "recency_at" : "updated_at",
+						sortDirection: "desc",
+						...root ? {
+							useStateDbOnly: true,
+							...thread?.cwd ? { cwd: thread.cwd } : {}
+						} : {},
+						...cursor ? { cursor } : {}
+					}, remaining());
+					remaining();
+					const candidate = page.data.find((value) => value.id === threadId);
+					if (candidate) {
+						if (!isInteractiveThreadSource(candidate.source)) throw unverified();
+						if (root && thread) {
+							const rolloutPath = thread.path;
+							if (!rolloutPath || !candidate.path || rolloutPath.replace(/\.zst$/u, "") !== candidate.path.replace(/\.zst$/u, "")) throw unverified();
+							const metadata = await readCodexSessionMeta(root, rolloutPath, threadId);
+							remaining();
+							if (!metadata || !isInteractiveThreadSource(metadata.source) || metadata.originator === "openclaw") throw unverified();
+							return thread;
+						}
+						return candidate;
+					}
+					const nextCursor = readControlCursor(page.nextCursor, "next response");
+					if (!nextCursor || seenCursors.has(nextCursor)) throw unverified();
+					seenCursors.add(nextCursor);
+					cursor = nextCursor;
+				}
+				throw unverified();
+			};
+			return await withTimeout(verify(), requests.requestTimeoutMs, "Codex session eligibility could not be verified", unverified);
+		},
+		retireConnection: params.retireConnection,
 		async listPage(pageParams) {
 			const limit = normalizeLimit(pageParams.limit, "limit");
 			const search = pageParams.searchTerm?.trim().toLocaleLowerCase() || void 0;
@@ -2584,11 +2861,12 @@ function createCodexSessionCatalogControlFromRequests(params) {
 		async listTurnPage(listParams) {
 			return await params.createRequestSnapshot().listThreadTurns(listParams);
 		},
-		async forkThread(forkParams) {
-			return await params.createRequestSnapshot().forkThread(forkParams);
+		listItemPage: (listParams) => params.createRequestSnapshot().listThreadItems(listParams),
+		async forkThread(forkParams, assertCurrent) {
+			return await params.createRequestSnapshot().forkThread(forkParams, assertCurrent);
 		},
-		async archiveThread(threadId) {
-			await params.createRequestSnapshot().archiveThread(threadId);
+		async archiveThread(threadId, assertCurrent) {
+			await params.createRequestSnapshot().archiveThread(threadId, assertCurrent);
 		}
 	};
 }
@@ -2606,7 +2884,7 @@ function createCodexSessionCatalogControl(params) {
 	const catalogPagesByConfig = /* @__PURE__ */ new WeakMap();
 	const resolveRequestOptions = (startOptions, agentId, source) => {
 		const runtimeConfig = params.getRuntimeConfig();
-		const agentDir = source?.agentDir ?? resolveAgentDir(runtimeConfig ?? {}, agentId);
+		const agentDir = source?.agentDir ?? resolveAgentDir$2(runtimeConfig ?? {}, agentId);
 		const resolvedStartOptions = source?.appServer.start ?? startOptions;
 		if (!runtimeConfig) return {
 			agentDir,
@@ -2633,8 +2911,9 @@ function createCodexSessionCatalogControl(params) {
 		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, {
+		return createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs, assertCurrent) => await codexControlRequest(pluginConfig, method, requestParams, {
 			...requestOptions,
+			assertCurrent,
 			...timeoutMs === void 0 ? {} : { timeoutMs }
 		}));
 	};
@@ -2650,18 +2929,31 @@ function createCodexSessionCatalogControl(params) {
 				timeoutMs: runtime.requestTimeoutMs
 			});
 			try {
-				const requests = createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs) => await requestCodexAppServerClientJson({
+				const requests = createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs, assertCurrent) => await requestCodexAppServerClientJson({
 					client,
 					method,
 					requestParams,
 					config: runtimeConfig,
-					timeoutMs: timeoutMs ?? runtime.requestTimeoutMs
+					timeoutMs: timeoutMs ?? runtime.requestTimeoutMs,
+					assertCurrent
 				}));
 				const pinnedControl = createCodexSessionCatalogControlFromRequests({
+					forkContext: {
+						client,
+						appServer: runtime,
+						pluginConfig,
+						agentDir,
+						localSessionsRoot: source?.localSessionsRoot
+					},
 					clientId: resolveCodexAppServerClientInstanceId(client),
+					retireConnection: () => {
+						retireSharedCodexAppServerClientIfCurrent(client);
+					},
 					connectionFingerprint: buildCodexAppServerConnectionFingerprint(runtime, agentDir),
 					createRequestSnapshot: () => requests,
 					...source?.localSessionsRoot ? { localSessionsRoot: source.localSessionsRoot } : {},
+					sourceHomeId: source?.sourceHomeId,
+					managedThreads: params.managedThreads,
 					now,
 					withPinnedConnection: async (nestedRun) => await nestedRun(pinnedControl)
 				});
@@ -2678,6 +2970,7 @@ function createCodexSessionCatalogControl(params) {
 		});
 		return {
 			...control,
+			requireEligibleThread: (threadId) => withPinnedConnection((pinned) => pinned.requireEligibleThread(threadId)),
 			async listPage(pageParams) {
 				const runtimeConfig = params.getRuntimeConfig();
 				if (!runtimeConfig) return await control.listPage(pageParams);
@@ -2688,7 +2981,7 @@ function createCodexSessionCatalogControl(params) {
 				}
 				const key = codexCatalogPageCacheKey(pageParams, agentId, source);
 				const cached = cache.get(key);
-				if (pageParams.forceRefresh !== true && cached) {
+				if (cached) {
 					cache.delete(key);
 					cache.set(key, cached);
 					if (cached.expiresAt > now()) return cached.value ?? await cached.page;
@@ -2719,7 +3012,7 @@ function createCodexSessionCatalogControl(params) {
 					});
 					else cache.delete(key);
 				};
-				if (pageParams.forceRefresh !== true && staleValue) {
+				if (staleValue) {
 					page.then(settle, restore);
 					return staleValue;
 				}
@@ -2751,14 +3044,22 @@ function createCodexSessionCatalogNodeInvokePolicies() {
 		commands: [
 			CODEX_APP_SERVER_THREADS_LIST_COMMAND,
 			CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
-			CODEX_TERMINAL_RESUME_COMMAND
+			CODEX_CATALOG_TRANSCRIPT_READ_COMMAND,
+			CODEX_TERMINAL_RESUME_COMMAND,
+			CODEX_TERMINAL_START_COMMAND
 		],
 		defaultPlatforms: [
 			"macos",
 			"linux",
 			"windows"
 		],
-		handle: (context) => context.command === "codex.terminal.resume.v1" ? { ok: true } : context.invokeNode()
+		handle: (context) => {
+			if (context.command === "codex.terminal.start.v1") return context.client?.scopes?.includes("operator.admin") && context.config.gateway?.cliAgents?.enabled === true && context.config.gateway?.terminal?.enabled !== false ? { ok: true } : {
+				ok: false,
+				message: "Native terminal start requires operator.admin and enabled CLI agents and terminals"
+			};
+			return context.command === "codex.terminal.resume.v1" ? { ok: true } : context.invokeNode();
+		}
 	}];
 }
 function toGenericCatalogHost(host, localTerminalAvailable) {
@@ -2813,7 +3114,7 @@ function registerCodexSessionCatalog(params) {
 		const homes = params.control.homesForAgent(agentId);
 		return allowProcessHomeFallback === false ? homes.filter((home) => !home.usesProcessHomeFallback) : homes;
 	};
-	const resolveRequestAgentId = (agentId) => resolveSessionAgentIds({
+	const resolveRequestAgentId = (agentId) => resolveSessionAgentIdsStrict({
 		config: params.getRuntimeConfig() ?? params.api.config,
 		agentId
 	}).sessionAgentId;
@@ -2846,10 +3147,13 @@ function registerCodexSessionCatalog(params) {
 		resolveCreateSession: ({ agentId }) => resolveCodexCatalogCreateSession(params.getRuntimeConfig() ?? params.api.config, agentId),
 		list: async (query) => {
 			const localTerminalAvailable = resolveLocalCodexTerminalExecutable() !== void 0;
-			const { agentId: requestedAgentId, allowProcessHomeFallback, listNodes, onHost, sessionEntries, ...gatewayQuery } = query;
+			const { agentId: requestedAgentId, allowProcessHomeFallback, listNodes, onHost, waitUntil, signal, sessionEntries, ...gatewayQuery } = query;
 			const agentId = resolveRequestAgentId(requestedAgentId);
-			const mapHost = (host) => toGenericCatalogHost(host, localTerminalAvailable);
 			const localHomes = [...catalogHomes(agentId, allowProcessHomeFallback)];
+			const mapHost = (host) => ({
+				...toGenericCatalogHost(host, localTerminalAvailable),
+				canStartTerminal: host.kind === "gateway" ? localTerminalAvailable && localHomes.some((home) => home.hostId === host.hostId && home.appServer.start.transport === "stdio") : host.canStartTerminal === true
+			});
 			return (await listCodexSessionCatalog({
 				agentId,
 				bindingStore: params.bindingStore,
@@ -2858,6 +3162,8 @@ function registerCodexSessionCatalog(params) {
 				control: params.control,
 				query: gatewayQuery,
 				listNodes,
+				waitUntil,
+				signal,
 				sessionEntries,
 				localHomes,
 				...onHost ? { onHost: (host) => onHost(mapHost(host)) } : {}
@@ -2865,7 +3171,7 @@ function registerCodexSessionCatalog(params) {
 		},
 		read: async (request) => {
 			const { agentId, source, control } = bindRequest(request);
-			const page = await readCodexSessionTranscript({
+			return await readCodexSessionTranscript({
 				agentId,
 				runtime: params.api.runtime,
 				control,
@@ -2875,10 +3181,6 @@ function registerCodexSessionCatalog(params) {
 				limit: request.limit ?? 20,
 				...source ? { source } : {}
 			});
-			return {
-				...page,
-				items: page.items.map(toGenericTranscriptItem)
-			};
 		},
 		continueSession: async (request) => {
 			const config = params.getRuntimeConfig();
@@ -2894,7 +3196,7 @@ function registerCodexSessionCatalog(params) {
 			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({
+			const continued = await continueLocalCodexSession({
 				agentId,
 				api: params.api,
 				bindingStore: params.bindingStore,
@@ -2907,7 +3209,8 @@ function registerCodexSessionCatalog(params) {
 				onContinued: (baseline) => {
 					upstreamBaseline = baseline;
 				}
-			})).sessionKey, request.threadId, upstreamBaseline);
+			});
+			return codexUpstreamContinueResult(continued.sessionKey, request.threadId, upstreamBaseline);
 		},
 		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) => {
@@ -2943,11 +3246,16 @@ function registerCodexSessionCatalog(params) {
 			});
 		},
 		startTerminalSession: async (request) => {
-			if (!request.nodeId && catalogHomes(request.agentId, request.allowProcessHomeFallback).length === 0) throw new CatalogParamsError("local Codex sessions are unavailable in isolated state");
+			const source = request.nodeId ? void 0 : resolveLocalCatalogHomeForThread({
+				homes: [...catalogHomes(request.agentId, request.allowProcessHomeFallback)],
+				hostId: request.hostId ?? "gateway:local"
+			});
+			if (source && source.appServer.start.transport !== "stdio") throw new CatalogParamsError("Native terminal start requires a local Codex source");
 			return await startCodexCatalogTerminal({
 				getPluginConfig: params.getPluginConfig,
 				getRuntimeConfig: params.getRuntimeConfig,
-				...request
+				...request,
+				source
 			});
 		}
 	});
@@ -2961,4 +3269,4 @@ const codexSessionCatalogRuntime = {
 	archiveLocal: archiveLocalCodexSession
 };
 //#endregion
-export { CODEX_LOCAL_SESSION_HOST_ID as a, createCodexCliSessionNodeInvokePolicies as c, resolveCodexCliSessionForBindingOnNode as d, resumeCodexCliSessionOnNode as f, createCodexSessionCatalogNodeHostCommands as i, formatCodexCliSessions as l, createCodexSessionCatalogNodeInvokePolicies as n, assertCodexArchiveDescendantsUnowned as o, createCodexSessionCatalogControl as r, createCodexCliSessionNodeHostCommands as s, codexSessionCatalogRuntime as t, listCodexCliSessionsOnNode as u };
+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 };