@openclaw/codex 2026.9.1-beta.1 → 2026.9.1

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

@@ -1,40 +1,42 @@
-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 { $t as isJsonObject, Jt as readCodexSessionMeta, K as resolveCodexAppServerClientInstanceId, Nt as withTimeout, Vt as resolveCodexAppServerAuthProfileStore, Wt as resolveCodexAppServerPreparedAuthHandoff, Xt as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, Yt as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, Z as assertCodexThreadForkParams, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, q as CodexAppServerRpcError, qt as isOpenClawManagedCodexThread, y as retireSharedCodexAppServerClientIfCurrent, zt as resolveCodexAppServerAuthProfileId } from "./shared-client-DxcfF9KX.js";
+import { E as readCodexPluginConfig, F as resolveCodexAppServerHomeDir, I as resolveCodexAppServerLocalHomeDir, L as resolveCodexAppServerUserHomeDir, i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-BhmfC1s6.js";
+import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity } from "./session-binding-BHuTCRZQ.js";
+import { a as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-DYHcRQAa.js";
+import { n as listCodexAppServerModels } from "./models-sYnEc0gd.js";
+import { a as replaceCodexCatalogConnectionHomes, n as buildCodexAppServerConnectionFingerprint, t as resumeCodexAppServerThread } from "./thread-resume-C7pyVKeW.js";
+import { g as codexCatalogHomeId, h as canonicalCodexCatalogHome, m as projectCodexUserItemText, r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-DTUxFWa_.js";
+import { i as requestCodexAppServerJson, o as withCodexAppServerJsonClient, r as requestCodexAppServerClientJson } from "./request-DYAI5FQE.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-dIjNVCYH.js";
+import { a as formatCodexDisplayText } from "./command-formatters-CLHhEB1Q.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-C351-5Qw.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 { 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 { 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 { 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 { root } from "openclaw/plugin-sdk/file-access-runtime";
 import process$1 from "node:process";
+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";
-import { createZstdDecompress } from "node:zlib";
+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 +136,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 +527,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 +548,198 @@ function formatNodeLabel(node) {
 	].filter(Boolean).join(" / ") || "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 {
+		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;
@@ -613,7 +807,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;
@@ -997,7 +1191,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 +1234,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);
@@ -1278,54 +1296,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}`);
+	});
+	params.initialization.assertCurrent();
+	if (!ownsGeneration) 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 (existing) {
 		if (matchesPendingAdoptionBinding(existing, params)) return;
 		throw new Error(`OpenClaw session is already bound to Codex thread ${existing.threadId}`);
@@ -1340,19 +1330,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 +1341,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 +1350,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 +1367,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 +1396,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
@@ -1532,8 +1495,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);
+				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");
@@ -1607,7 +1570,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 +1586,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,
@@ -1800,7 +1773,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,6 +1790,194 @@ async function continueNodeCodexSession(params) {
 	});
 }
 //#endregion
+//#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$1(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-listing.ts
 async function listVisiblePage(params) {
 	const excluded = params.excludedThreadIds;
@@ -1904,7 +2065,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;
@@ -1939,13 +2100,14 @@ async function listCodexSessionCatalog(params) {
 	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)
 		};
@@ -1958,17 +2120,15 @@ async function listCodexSessionCatalog(params) {
 		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),
+		...params.onHost ? { onHost: params.onHost } : {}
+	}));
 	return { hosts: await Promise.all([...localHosts, ...nodeHosts]) };
 }
 /** Builds the node-local read-only Codex app-server catalog command. */
@@ -1978,7 +2138,7 @@ 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;
@@ -2035,7 +2195,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,7 +2210,8 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, configSources
 				}
 			}
 		},
-		createCodexTerminalNodeHostCommand(bindRequest, configSources)
+		createCodexTerminalNodeHostCommand(bindRequest, configSources),
+		createCodexTerminalStartNodeHostCommand()
 	];
 }
 function readNodeTranscriptParams(value) {
@@ -2080,7 +2241,7 @@ function flattenTranscriptPageDesc(page) {
 /** 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);
+		await params.control.requireEligibleThread(params.threadId);
 		const listParams = {
 			threadId: params.threadId,
 			limit: params.limit,
@@ -2146,7 +2307,7 @@ function toGenericTranscriptItem(item) {
 	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;
+	const text = item.type === "userMessage" ? projectCodexUserItemText(item) : item.text || resultText || changesText || fallback;
 	return {
 		id: item.id,
 		type,
@@ -2311,7 +2472,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$1(config, ownerAgentId, env);
 	const configuredHomes = readCodexPluginConfig(pluginConfig).sessionCatalog?.homes ?? [];
 	const base = resolveCodexSupervisionAppServerRuntimeOptions({
 		pluginConfig,
@@ -2334,7 +2495,7 @@ function resolveCodexCatalogHomes(params) {
 			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) => {
+		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);
 		}));
@@ -2400,96 +2561,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 +2579,75 @@ 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, {
+		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 +2709,11 @@ function createCodexSessionCatalogControlFromRequests(params) {
 		async listTurnPage(listParams) {
 			return await params.createRequestSnapshot().listThreadTurns(listParams);
 		},
-		async forkThread(forkParams) {
-			return await params.createRequestSnapshot().forkThread(forkParams);
+		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 +2731,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$1(runtimeConfig ?? {}, agentId);
 		const resolvedStartOptions = source?.appServer.start ?? startOptions;
 		if (!runtimeConfig) return {
 			agentDir,
@@ -2633,8 +2758,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 +2776,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 +2817,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 +2828,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 +2859,7 @@ function createCodexSessionCatalogControl(params) {
 					});
 					else cache.delete(key);
 				};
-				if (pageParams.forceRefresh !== true && staleValue) {
+				if (staleValue) {
 					page.then(settle, restore);
 					return staleValue;
 				}
@@ -2751,14 +2891,21 @@ function createCodexSessionCatalogNodeInvokePolicies() {
 		commands: [
 			CODEX_APP_SERVER_THREADS_LIST_COMMAND,
 			CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
-			CODEX_TERMINAL_RESUME_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 +2960,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;
@@ -2848,8 +2995,11 @@ function registerCodexSessionCatalog(params) {
 			const localTerminalAvailable = resolveLocalCodexTerminalExecutable() !== void 0;
 			const { agentId: requestedAgentId, allowProcessHomeFallback, listNodes, onHost, 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,
@@ -2894,7 +3044,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 +3057,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 +3094,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 +3117,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 };