@openclaw/codex 2026.8.2 → 2026.9.1

package/dist/{runtime-artifact-D9pYp4zL.js → runtime-artifact-C3jVimFn.js}

@@ -1,10 +1,11 @@
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-NT_Dpd9V.js";
+import { i as resolvePackagedCodexNativeCommand } from "./managed-binary-4-Vjz5GH.js";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-CyPldczm.js";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { resolveWindowsExecutablePath, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
-import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 //#region extensions/codex/src/app-server/runtime-artifact.ts
 /** Exact local runtime artifact identity for verified Codex setup turns. */
 const ARTIFACT_ID_PREFIX = "codex-app-server:v1:";
@@ -363,6 +364,8 @@ async function captureFilesystemDescriptor(params) {
 	const spawnCwd = path.resolve(params.startOptions.cwd ?? process.cwd());
 	const commandPath = await resolveCommandPath(params.startOptions.command, env, spawnCwd);
 	const commandRealPath = await fs.realpath(commandPath);
+	let nativeCommand = params.spawnIdentity.nativeCommand;
+	let nativeCandidate = commandRealPath;
 	let invocationPaths;
 	if (process.platform === "win32") {
 		const program = resolveWindowsSpawnProgram({
@@ -372,7 +375,10 @@ async function captureFilesystemDescriptor(params) {
 			execPath: process.execPath,
 			packageName: "@openai/codex"
 		});
-		if (program.resolution === "node-entrypoint" && !params.spawnIdentity.nativeCommand) throw new Error("Codex runtime cannot attest a custom Node launcher without its native target");
+		const entrypoint = program.leadingArgv[0];
+		if (program.resolution === "node-entrypoint" && entrypoint && !nativeCommand) nativeCommand = resolvePackagedCodexNativeCommand(await fs.realpath(entrypoint));
+		if (program.resolution === "node-entrypoint" && !nativeCommand) throw new Error("Codex runtime cannot attest a custom Node launcher without its native target");
+		nativeCandidate = program.command;
 		const invocationCandidates = [
 			commandRealPath,
 			program.command,
@@ -383,17 +389,18 @@ async function captureFilesystemDescriptor(params) {
 			const resolved = await resolveCommandPath(candidate, env, spawnCwd);
 			invocationPaths.push(await fs.realpath(resolved));
 		}
-	} else invocationPaths = await resolvePosixInvocationPaths({
-		commandRealPath,
-		env,
-		cwd: spawnCwd,
-		nativeCommand: params.spawnIdentity.nativeCommand
-	});
+	} else {
+		nativeCommand ??= resolvePackagedCodexNativeCommand(commandRealPath);
+		invocationPaths = await resolvePosixInvocationPaths({
+			commandRealPath,
+			env,
+			cwd: spawnCwd,
+			nativeCommand
+		});
+	}
 	invocationPaths = [...new Set(invocationPaths)].toSorted(compareArtifactNames);
 	if (invocationPaths.length > MAX_ARTIFACT_INVOCATION_PATHS) throw new Error("Codex runtime launcher exceeds the bounded invocation file count");
-	const nativeCandidate = params.spawnIdentity.nativeCommand ?? invocationPaths[0];
-	if (!nativeCandidate) throw new Error("Codex runtime did not resolve a native executable");
-	const nativePath = await fs.realpath(await resolveCommandPath(nativeCandidate, env, spawnCwd));
+	const nativePath = await fs.realpath(await resolveCommandPath(nativeCommand ?? nativeCandidate, env, spawnCwd));
 	const packageRoot = await resolvePackageRoot(nativePath);
 	const configuredCodeModeHost = readEffectiveSpawnEnvironmentValue(env, CODE_MODE_HOST_PATH_ENV)?.trim();
 	const adjacentCodeModeHost = path.join(path.dirname(nativePath), process.platform === "win32" ? "codex-code-mode-host.exe" : "codex-code-mode-host");

package/dist/{session-binding-D0zinCP1.js → session-binding-BHuTCRZQ.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { A as normalizeCodexServiceTier, N as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-CcYL77O6.js";
+import { P as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN, j as normalizeCodexServiceTier } from "./config-BhmfC1s6.js";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
@@ -31,7 +31,8 @@ var session_binding_exports = /* @__PURE__ */ __exportAll({
 	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
 	resolveCodexRunSessionBindingAuthority: () => resolveCodexRunSessionBindingAuthority,
 	scopeCodexRunBindingStore: () => scopeCodexRunBindingStore,
-	sessionBindingIdentity: () => sessionBindingIdentity
+	sessionBindingIdentity: () => sessionBindingIdentity,
+	validateBindingForWrite: () => validateBindingForWrite
 });
 const CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER = "openai";
 const PUBLIC_OPENAI_MODEL_PROVIDER = "openai";
@@ -333,9 +334,11 @@ function scopeCodexRunBindingStore(params) {
 }
 /** Lets the authoritative OpenClaw session generation claim a stale stable binding row. */
 async function reclaimCurrentCodexSessionGeneration(params) {
+	params.assertCurrent?.();
 	const sessionKey = params.identity.sessionKey?.trim();
 	if (!sessionKey) return true;
 	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
+	params.assertCurrent?.();
 	if (plan.kind === "resolved") return plan.result;
 	try {
 		const storePath = params.storePath?.trim() || resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId });
@@ -352,7 +355,7 @@ async function reclaimCurrentCodexSessionGeneration(params) {
 	return await params.bindingStore.mutate(params.identity, {
 		kind: "reclaim-generation",
 		expectedPreviousSessionId: plan.expectedPreviousSessionId
-	});
+	}, params.assertCurrent);
 }
 /** Creates the single binding facade owned by the Codex plugin runtime. */
 function createCodexAppServerBindingStore(state) {
@@ -640,9 +643,8 @@ function createCodexAppServerBindingStore(state) {
 					const active = ownsGeneration ? storedActive : void 0;
 					const retiredGeneration = current?.state === "cleared" && current.retired === true && ownsGeneration;
 					const preservesSupervisionOwner = mutation.kind === "set" && active?.binding.connectionScope === "supervision" && isSameSupervisionOwner(active.binding, mutation.binding);
-					const clearsPendingSupervisionOwner = mutation.kind === "clear" && matchesPendingSupervisionClear(active?.binding, mutation.threadId, mutation.expectedPendingSupervisionBranch);
 					const replacesExpectedOrdinaryOwner = mutation.kind === "replace-thread" && active?.binding.threadId === mutation.expectedThreadId && active.binding.connectionScope !== "supervision" && mutation.binding.connectionScope !== "supervision" && mutation.binding.threadId !== mutation.expectedThreadId;
-					if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration || active?.binding.connectionScope === "supervision" && !preservesSupervisionOwner) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || mutation.kind === "replace-thread" && !replacesExpectedOrdinaryOwner || (mutation.kind === "patch-pending-supervision-branch" || mutation.kind === "commit-pending-supervision-branch") && !matchesPendingSupervisionBranch(active?.binding, mutation.expected) || mutation.kind === "clear" && (!ownsGeneration || (mutation.expectedPendingSupervisionBranch ? !clearsPendingSupervisionOwner : mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || active?.binding.connectionScope === "supervision"))) return { result: false };
+					if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration || active?.binding.connectionScope === "supervision" && !preservesSupervisionOwner) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || mutation.kind === "replace-thread" && !replacesExpectedOrdinaryOwner || (mutation.kind === "patch-pending-supervision-branch" || mutation.kind === "commit-pending-supervision-branch") && !matchesPendingSupervisionBranch(active?.binding, mutation.expected) || mutation.kind === "clear" && (!ownsGeneration || mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || active?.binding.connectionScope === "supervision")) return { result: false };
 					if (mutation.kind === "clear" && retiredGeneration) return { result: true };
 					if (mutation.kind === "clear") return {
 						result: true,
@@ -798,10 +800,6 @@ function matchesPendingSupervisionBranch(binding, expected) {
 function isSameSupervisionOwner(current, replacement) {
 	return replacement.connectionScope === "supervision" && replacement.threadId === current.threadId && replacement.supervisionSourceThreadId === current.supervisionSourceThreadId;
 }
-function matchesPendingSupervisionClear(binding, threadId, expected) {
-	if (!expected || threadId !== expected.sourceThreadId) return false;
-	return !binding || binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && matchesPendingSupervisionBranch(binding, expected);
-}
 /** Stable plugin-state key for one current binding owner. */
 function bindingStoreKey(identity) {
 	if (identity.kind === "session") {
@@ -944,4 +942,4 @@ function normalizeCodexAppServerBindingModelProvider(params) {
 	return modelProvider;
 }
 //#endregion
-export { hashCodexAppServerBindingFingerprint as a, reclaimCurrentCodexSessionGeneration as c, sessionBindingIdentity as d, session_binding_exports as f, createCodexSessionGenerationSupersededError as i, resolveCodexRunSessionBindingAuthority as l, assertCodexBindingMayBeReplaced as n, isCodexAppServerNativeAuthProfile as o, bindingStoreKey as r, normalizeCodexAppServerBindingModelProvider as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t, scopeCodexRunBindingStore as u };
+export { hashCodexAppServerBindingFingerprint as a, reclaimCurrentCodexSessionGeneration as c, sessionBindingIdentity as d, session_binding_exports as f, createCodexSessionGenerationSupersededError as i, resolveCodexRunSessionBindingAuthority as l, assertCodexBindingMayBeReplaced as n, isCodexAppServerNativeAuthProfile as o, validateBindingForWrite as p, bindingStoreKey as r, normalizeCodexAppServerBindingModelProvider as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t, scopeCodexRunBindingStore as u };

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

@@ -1,24 +1,23 @@
-import { F as resolveCodexAppServerLocalHomeDir, I as resolveCodexAppServerUserHomeDir, P as resolveCodexAppServerHomeDir, T as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-CcYL77O6.js";
-import { $ as CodexAppServerRpcError, Et as withTimeout, Ht as isJsonObject, Lt as resolveCodexAppServerPreparedAuthHandoff, Mt as resolveCodexAppServerAuthProfileId, Pt as resolveCodexAppServerAuthProfileStore, Q as resolveCodexAppServerClientInstanceId, Rt as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, zt as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS } from "./shared-client-B1tT5U6r.js";
-import { c as reclaimCurrentCodexSessionGeneration, d as sessionBindingIdentity } from "./session-binding-D0zinCP1.js";
-import { i as assertCodexThreadForkParams } from "./protocol-validators-Bg5rpNxk.js";
-import { a as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-CpVfwctT.js";
-import { n as listCodexAppServerModels } from "./models-DaWfETQk.js";
-import { a as replaceCodexCatalogConnectionHomes, n as buildCodexAppServerConnectionFingerprint, t as resumeCodexAppServerThread } from "./thread-resume-BFt1-ZDa.js";
-import { i as readCodexSessionMeta, n as codexCatalogHomeId, r as isOpenClawManagedCodexThread, t as canonicalCodexCatalogHome } from "./session-catalog-home-id-Dt2GiG5o.js";
-import { i as requestCodexAppServerJson, o as withCodexAppServerJsonClient, r as requestCodexAppServerClientJson } from "./request-BWxweEdK.js";
-import { m as projectCodexUserItemText, r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-1ep4XjzF.js";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-D6m_TdVy.js";
-import { r as formatCodexDisplayText } from "./command-formatters--UToCokS.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-gqrYIRHk.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 as resolveAgentDir$1, resolveAgentWorkspaceDir, resolveAllowedModelRef, resolveDefaultAgentDir, resolveDefaultAgentId, resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
@@ -34,8 +33,7 @@ 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 { decodeNodePtyResumeParams, decodeNodePtyStartParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
 //#region extensions/codex/src/jsonl-lines.ts
 const JSONL_STREAM_THRESHOLD_BYTES = 4194304;
 const JSONL_READ_CHUNK_BYTES = 1048576;
@@ -650,6 +648,7 @@ async function codexControlRequest(pluginConfig, method, requestParams, options
 	const auth = await prepareControlAuth(options, startOptions);
 	const controlRequestOptions = {
 		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
+		assertCurrent: options.assertCurrent,
 		startOptions,
 		config: options.config,
 		sessionKey: options.sessionKey,
@@ -659,7 +658,7 @@ async function codexControlRequest(pluginConfig, method, requestParams, options
 		...auth.clientOptions
 	};
 	if (options.onResponse || options.beforeRequest) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client, scope) => {
-		await options.beforeRequest?.(request);
+		await options.beforeRequest?.(request, client, scope);
 		scope.assertCurrent();
 		let response;
 		if (method === "thread/resume") {
@@ -1297,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}`);
@@ -1359,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;
@@ -1382,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);
@@ -1393,6 +1350,7 @@ 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,
@@ -1409,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 ?? "",
@@ -1442,19 +1396,8 @@ 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;
 	}
 }
@@ -1627,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 = {
@@ -1642,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,
@@ -1839,6 +1792,33 @@ 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");
@@ -1858,7 +1838,10 @@ function resolveLocalCodexTerminalResolution(env = process.env) {
 }
 function codexNodeTerminalCapability(node) {
 	const commands = node.invocableCommands ?? node.commands;
-	return node.connected === true && commands?.includes("codex.terminal.resume.v1") === true ? { canOpenTerminalCodex: true } : {};
+	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 {
@@ -1972,7 +1955,17 @@ async function openCodexCatalogTerminal(params) {
 	};
 }
 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");
+	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 {
@@ -2107,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)
 		};
@@ -2126,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. */
@@ -2218,7 +2210,8 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, configSources
 				}
 			}
 		},
-		createCodexTerminalNodeHostCommand(bindRequest, configSources)
+		createCodexTerminalNodeHostCommand(bindRequest, configSources),
+		createCodexTerminalStartNodeHostCommand()
 	];
 }
 function readNodeTranscriptParams(value) {
@@ -2586,18 +2579,19 @@ 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)),
+		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
 		}, timeoutMs)).thread,
-		archiveThread: async (threadId) => {
-			await request(CODEX_CONTROL_METHODS.archiveThread, { threadId });
+		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,
@@ -2653,6 +2647,7 @@ function createCodexSessionCatalogControlFromRequests(params) {
 			};
 			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;
@@ -2714,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);
 		}
 	};
 }
@@ -2763,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 }
 		}));
 	};
@@ -2780,15 +2776,26 @@ 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 } : {},
@@ -2884,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) {
@@ -2981,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,
@@ -3077,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
 			});
 		}
 	});

package/dist/{session-cli-B2lyjJA0.js → session-cli-CmFEXMAM.js}

@@ -1,4 +1,4 @@
-import "./session-catalog-eMhVm0Ql.js";
+import "./session-catalog-yyvTWFOw.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";