@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/index.js

@@ -1,38 +1,43 @@
 import { registerCodexCliMetadata } from "./cli-metadata.js";
-import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./.setup/harness-rxaaoN-o.mjs";
-import { l as readCurrentCodexAppServerBinding, n as assertCodexBindingMayBeReplaced, p as sessionBindingIdentity, u as readCurrentCodexNativeSubagentSubmissions } from "./.setup/session-binding-record-TH3xA0zj.mjs";
-import { n as defineCodexBuildState } from "./.setup/build-state-Xx9ybZqa.mjs";
+import { j as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS } from "./.setup/session-catalog-parsing-CPGaPYr-.mjs";
+import { i as isJsonObject } from "./.setup/protocol-CANUwXJ3.mjs";
+import { f as readCurrentCodexAppServerBinding, h as readCurrentNativePendingAssignments, m as readCurrentCodexNativeSubagentSubmissions, n as assertCodexBindingMayBeReplaced, p as readCurrentCodexAppServerBindings, v as sessionBindingIdentity } from "./.setup/session-binding-record-Oe9L-CNY.mjs";
+import { n as defineCodexBuildState } from "./.setup/build-state-Da1_z0kd.mjs";
+import { createCodexAppServerAgentHarness, createCodexAppServerNativeCompaction } from "./harness.js";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
 import codexProviderDiscovery from "./provider-discovery.js";
 import { n as createCodexAuthProfileSelection } from "./.setup/auth-profile-selection-DFu9e167.mjs";
-import { m as isJsonObject, t as assertCodexAppServerConnectionSecurity } from "./.setup/config-security-BRQ2mgW9.mjs";
-import { d as readCodexPluginConfig } from "./.setup/config-parsing-CcB9iPoq.mjs";
-import { V as CODEX_CATALOG_MAX_ROWS, W as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS } from "./.setup/session-catalog-native-projection-ChV3cCtm.mjs";
-import { r as createCodexAppServerConfig, t as codexAppServerStartOptionsKey } from "./.setup/config-options-BsanJ8QG.mjs";
-import { o as setManagedCodexPluginRoot } from "./.setup/managed-binary-DP6Rib3P.mjs";
-import { g as createCodexDesktopGenerationService, h as retireSharedCodexAppServerClientsBeforeDesktopGeneration, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./.setup/auth-cache-key-QirmgiCo.mjs";
+import { t as assertCodexAppServerConnectionSecurity } from "./.setup/config-security-CE-FcGw9.mjs";
+import { d as readCodexPluginConfig } from "./.setup/config-parsing-b088LyhT.mjs";
+import { r as createCodexAppServerConfig, t as codexAppServerStartOptionsKey } from "./.setup/config-options-CzyWLTJt.mjs";
+import { o as setManagedCodexPluginRoot } from "./.setup/managed-binary-kiWRhNRE.mjs";
+import { l as createCodexDesktopGenerationService, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./.setup/auth-cache-key-Dbvq-QgB.mjs";
 import { n as CODEX_MANAGED_THREAD_NAMESPACE, r as createCodexManagedThreadStore, t as CODEX_MANAGED_THREAD_MAX_ENTRIES } from "./.setup/managed-thread-store-BMqgThVL.mjs";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./.setup/session-binding-meta-B7aEMU7g.mjs";
-import { o as createCodexAppServerProcessReaperService } from "./.setup/transport-stdio-Cmx94Oiy.mjs";
-import { r as withCodexConversationThreadActivity, t as isIncognitoSessionKey } from "./.setup/incognito-session-uhrBF6wJ.mjs";
-import { n as filterCodexMarketplacePlugins, o as CODEX_NATIVE_EXECUTION_AUTH_ERROR, s as canMutateCodexHost, t as discoverCodexMarketplacePlugins } from "./.setup/plugin-marketplace-discovery-P-Vndfqq.mjs";
-import { o as formatCodexDisplayText } from "./.setup/command-formatters-CGEkdawF.mjs";
-import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData, o as resolveCodexDefaultWorkspaceDir } from "./.setup/conversation-binding-data-CrcyZk6O.mjs";
-import { t as buildCodexMigrationProvider } from "./.setup/provider-fFh_-VR3.mjs";
-import { t as CODEX_CONTROL_METHODS } from "./.setup/capabilities-_vXcZGSx.mjs";
-import { t as assertCodexArchiveDescendantsUnowned } from "./.setup/thread-archive-guard-jmecf6OJ.mjs";
-import { a as listCodexCliSessionsOnNode, n as createCodexCliSessionNodeHostCommands, o as resolveCodexCliSessionForBindingOnNode, r as createCodexCliSessionNodeInvokePolicies, s as resumeCodexCliSessionOnNode } from "./.setup/node-cli-sessions-Cl8b2ZF3.mjs";
-import { t as CODEX_CATALOG_STATE_NAMESPACE } from "./.setup/session-catalog-index-state-BAuDztHN.mjs";
-import { i as createCodexSessionCatalogNodeHostCommands, n as createCodexSessionCatalogNodeInvokePolicies, r as createCodexSessionCatalogControl, t as codexSessionCatalogRuntime } from "./.setup/session-catalog-fUdWDx-U.mjs";
-import { i as requestCodexAppServerJson } from "./.setup/request-BioXJLYa.mjs";
+import { f as retireSharedCodexAppServerClientsBeforeDesktopGeneration } from "./.setup/shared-client-lifecycle-DJIgqgMw.mjs";
+import { s as createCodexAppServerProcessReaperService } from "./.setup/transport-stdio-Bdegpn2V.mjs";
+import { n as codexNativeProfileRecoveryService } from "./.setup/auth-profile-health-oHizqgye.mjs";
+import { n as withCodexConversationThreadActivity } from "./.setup/thread-ownership-queue-Dp24d7-F.mjs";
+import { c as canMutateCodexHost, n as filterCodexMarketplacePlugins, o as CODEX_NATIVE_EXECUTION_AUTH_ERROR, t as discoverCodexMarketplacePlugins } from "./.setup/plugin-marketplace-discovery-D_dV9FXa.mjs";
+import { o as formatCodexDisplayText } from "./.setup/command-formatters-R3ckE3Co.mjs";
+import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData, o as resolveCodexDefaultWorkspaceDir } from "./.setup/conversation-binding-data-C746z5Pn.mjs";
+import { t as isIncognitoSessionKey } from "./.setup/incognito-session-DWYapfwf.mjs";
+import { t as buildCodexMigrationProvider } from "./.setup/provider-DH8NSzGt.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./.setup/capabilities-B3WEZl4e.mjs";
+import { t as assertCodexArchiveDescendantsUnowned } from "./.setup/thread-archive-guard-C9frICzX.mjs";
+import { a as createCodexCliSessionNodeInvokePolicies, c as resolveCodexCliSessionForBindingOnNode, i as createCodexCliSessionNodeHostCommands, l as resumeCodexCliSessionOnNode, s as listCodexCliSessionsOnNode } from "./.setup/node-cli-sessions-HC4W6FLI.mjs";
+import { t as CODEX_CATALOG_MAX_ROWS } from "./.setup/session-catalog-limits-DDxOsQeC.mjs";
+import { t as CODEX_CATALOG_STATE_NAMESPACE } from "./.setup/session-catalog-index-state-TeO7EyO-.mjs";
+import { i as createCodexSessionCatalogNodeHostCommands, n as createCodexSessionCatalogNodeInvokePolicies, r as createCodexSessionCatalogControl, t as codexSessionCatalogRuntime } from "./.setup/session-catalog-4sCdv5qx.mjs";
+import { i as requestCodexAppServerJson } from "./.setup/request-BHZ1nz8d.mjs";
 import { t as createCodexWebSearchProviderBase } from "./.setup/web-search-provider.shared-BrZmlqyR.mjs";
 import { normalizePluginsConfig, resolveEffectiveEnableState, resolveLivePluginConfigObject, resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { asBoolean, asOptionalRecord, asSafeIntegerInRange, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { isDeepStrictEqual } from "node:util";
 import { resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
+import { coerceErrorMessage, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
@@ -41,7 +46,7 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/codex/src/account-usage.ts
 function registerCodexAccountUsage(api) {
 	api.registerGatewayMethod("codex.accountUsage", async (options) => {
-		const { handleCodexAccountUsage } = await import("./.setup/account-usage-runtime-C2MOIvfq.mjs");
+		const { handleCodexAccountUsage } = await import("./.setup/account-usage-runtime-DFhbh1zz.mjs");
 		await handleCodexAccountUsage(options);
 	}, { scope: "operator.admin" });
 }
@@ -53,7 +58,7 @@ function createCodexAppServerConnectionHealthService(options) {
 	let abortController;
 	let monitor;
 	const run = async (ctx, signal) => {
-		const { resolveCodexAppServerRuntimeOptions } = await import("./.setup/config-runtime-CeAhl_h4.mjs").then((n) => n.t);
+		const { resolveCodexAppServerRuntimeOptions } = await import("./.setup/config-runtime-C0NbLms1.mjs").then((n) => n.t);
 		let consecutiveFailures = 0;
 		while (!signal.aborted) {
 			let pluginConfig;
@@ -69,8 +74,8 @@ function createCodexAppServerConnectionHealthService(options) {
 				return;
 			}
 			if (runtime.start.transport !== "websocket") return;
-			const { getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./.setup/shared-client-BpTtuLQ5.mjs").then((n) => n.y);
-			const { isUnsupportedCodexAppServerVersionError } = await import("./.setup/client-vXs2929Q.mjs").then((n) => n.n);
+			const { getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./.setup/shared-client-DqyTMYug.mjs").then((n) => n.v);
+			const { isUnsupportedCodexAppServerVersionError } = await import("./.setup/client-N0JpgSzF.mjs").then((n) => n.n);
 			if (signal.aborted) return;
 			let leasedClient;
 			try {
@@ -171,11 +176,15 @@ function waitForReconnect(delayMs, signal) {
 /** Keeps lifecycle/auth loading behind mutations while sharing the canonical read codec. */
 function createLazyCodexAppServerBindingStore(state, managedThreadState) {
 	let resolved;
-	const store = () => resolved ??= import("./.setup/session-binding-_0W_fHRr.mjs").then((n) => n.c).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
+	const store = () => resolved ??= import("./.setup/session-binding-DGCYAfvD.mjs").then((n) => n.s).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
 	const managedThreads = managedThreadState ? createCodexManagedThreadStore(managedThreadState) : void 0;
 	return {
 		...managedThreads ? { managedThreads } : {},
 		read: (identity) => readCurrentCodexAppServerBinding(state, identity),
+		get readMany() {
+			return state.lookupMany ? (identities) => readCurrentCodexAppServerBindings(state, identities) : void 0;
+		},
+		readNativeSubagentAssignments: (identity, owner) => readCurrentNativePendingAssignments(state, identity, owner),
 		readNativeSubagentSubmissions: (identity, owner) => readCurrentCodexNativeSubagentSubmissions(state, identity, owner),
 		hasOtherThreadOwner: async (threadId, currentIdentity) => (await store()).hasOtherThreadOwner(threadId, currentIdentity),
 		mutate: async (identity, mutation, assertCurrent) => (await store()).mutate(identity, mutation, assertCurrent),
@@ -213,14 +222,26 @@ function createCodexCommand(options) {
 		acceptsArgs: true,
 		requireAuth: true,
 		handler: async (ctx) => {
-			const { handleCodexCommand } = await import("./.setup/command-dispatch-naHIZwwF.mjs");
-			return handleCodexCommand(ctx, options);
+			const commandContext = {
+				...ctx,
+				gatewayClientScopes: ctx.gatewayClientScopes?.slice()
+			};
+			const { handleCodexCommand } = await import("./.setup/command-dispatch-BeAoaovI.mjs");
+			return handleCodexCommand(commandContext, options);
 		}
 	};
 }
 //#endregion
 //#region extensions/codex/src/conversation-binding-hooks.ts
 const getNodeConversationState = defineCodexBuildState("openclaw.codex.conversationBinding", () => ({ queue: new KeyedAsyncQueue() }));
+function isCurrentPublicBinding(binding, service) {
+	return service.resolveByConversation({
+		channel: binding.channel,
+		accountId: binding.accountId,
+		conversationId: binding.conversationId,
+		...binding.parentConversationId ? { parentConversationId: binding.parentConversationId } : {}
+	})?.bindingId === binding.bindingId;
+}
 async function handleCodexConversationInboundClaim(event, ctx, options) {
 	const publicBinding = ctx.pluginBinding;
 	const data = readCodexConversationBindingData(publicBinding);
@@ -237,7 +258,7 @@ async function handleCodexConversationInboundClaim(event, ctx, options) {
 		return {
 			handled: true,
 			reply: (await getNodeConversationState().queue.enqueue(`${data.nodeId}:${data.sessionId}`, async () => {
-				const { resolveCodexNativeSandboxBlock } = await import("./.setup/sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+				const { resolveCodexNativeSandboxBlock } = await import("./.setup/sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
 				const blocked = resolveCodexNativeSandboxBlock({
 					config: options.config,
 					sessionKey,
@@ -246,9 +267,13 @@ async function handleCodexConversationInboundClaim(event, ctx, options) {
 				if (blocked) return { reply: { text: blocked } };
 				const resume = options.resumeCodexCliSessionOnNode;
 				if (!resume) return { reply: { text: "Codex CLI node binding is unavailable because Gateway node runtime is not attached." } };
+				const { getSessionBindingService } = await import("openclaw/plugin-sdk/conversation-binding-runtime");
+				if (!isCurrentPublicBinding(publicBinding, getSessionBindingService())) return { reply: { text: "This Codex conversation was detached or changed before its message could run." } };
 				return { reply: { text: (await resume({
 					nodeId: data.nodeId,
 					sessionId: data.sessionId,
+					agentId: data.agentId,
+					sessionKey,
 					prompt,
 					cwd: data.cwd,
 					timeoutMs: options.timeoutMs
@@ -270,7 +295,7 @@ async function handleCodexConversationInboundClaim(event, ctx, options) {
 		return {
 			handled: true,
 			reply: (await withCodexConversationThreadActivity(data.bindingId, async () => {
-				const { resolveCodexNativeExecutionBlock } = await import("./.setup/sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+				const { resolveCodexNativeExecutionBlock } = await import("./.setup/sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
 				const nativeExecutionBlock = resolveCodexNativeExecutionBlock({
 					config: options.config,
 					sessionKey,
@@ -279,15 +304,9 @@ async function handleCodexConversationInboundClaim(event, ctx, options) {
 				});
 				if (nativeExecutionBlock) return { reply: { text: nativeExecutionBlock } };
 				const { getSessionBindingService } = await import("openclaw/plugin-sdk/conversation-binding-runtime");
-				const { runBoundTurnWithMissingThreadRecovery } = await import("./.setup/conversation-binding-DhzrpTM6.mjs");
-				const currentPublicBinding = getSessionBindingService().resolveByConversation({
-					channel: publicBinding.channel,
-					accountId: publicBinding.accountId,
-					conversationId: publicBinding.conversationId,
-					...publicBinding.parentConversationId ? { parentConversationId: publicBinding.parentConversationId } : {}
-				});
+				const { runBoundTurnWithMissingThreadRecovery } = await import("./.setup/conversation-binding-3Min8qvP.mjs");
 				const current = options.bindingStore.read(identity);
-				if (currentPublicBinding?.bindingId !== publicBinding.bindingId || expected && (!current || current.threadId !== expected.threadId || current.conversationStartId !== expected.conversationStartId) || !expected && current && data.start?.id && current.conversationStartId !== data.start.id) return { reply: { text: "This Codex conversation was detached or changed before its message could run." } };
+				if (!isCurrentPublicBinding(publicBinding, getSessionBindingService()) || expected && (!current || current.threadId !== expected.threadId || current.conversationStartId !== expected.conversationStartId) || !expected && current && data.start?.id && current.conversationStartId !== data.start.id) return { reply: { text: "This Codex conversation was detached or changed before its message could run." } };
 				return await runBoundTurnWithMissingThreadRecovery({
 					bindingStore: options.bindingStore,
 					data,
@@ -319,7 +338,7 @@ async function handleCodexConversationBindingResolved(event, options) {
 	const binding = options.bindingStore.read(identity);
 	assertCodexBindingMayBeReplaced(binding, "clearing a denied conversation binding");
 	if (binding && (!data.start?.id || binding.conversationStartId === data.start.id)) await withCodexConversationThreadActivity(identity.bindingId, async () => {
-		const { retireCodexConversationThreadBinding } = await import("./.setup/thread-ownership-skomxnIt.mjs").then((n) => n.o);
+		const { retireCodexConversationThreadBinding } = await import("./.setup/thread-ownership-roNP0l1c.mjs").then((n) => n.o);
 		return retireCodexConversationThreadBinding({
 			bindingStore: options.bindingStore,
 			identity,
@@ -354,7 +373,7 @@ function createCodexPluginsTool(options) {
 			const query = typeof params.query === "string" ? params.query : "";
 			const marketplace = typeof params.marketplace === "string" ? params.marketplace.trim() : void 0;
 			const limit = typeof params.limit === "number" && Number.isInteger(params.limit) ? Math.max(1, Math.min(params.limit, 20)) : 12;
-			const { codexBindingConnectionSelection, resolveCodexBindingAppServerConnection } = await import("./.setup/binding-connection-Bm38niE8.mjs").then((n) => n.n);
+			const { codexBindingConnectionSelection, resolveCodexBindingAppServerConnection } = await import("./.setup/binding-connection-DTtN1KrX.mjs").then((n) => n.n);
 			const pluginConfig = options.getPluginConfig();
 			const config = runtimeConfig();
 			const identity = options.context.sessionId ? sessionBindingIdentity({
@@ -367,10 +386,11 @@ function createCodexPluginsTool(options) {
 			const binding = readBinding();
 			const selection = codexBindingConnectionSelection(binding);
 			const assertCurrent = () => {
+				options.context.assertInvocationCurrent?.();
 				if (runtimeConfig() !== config || !isDeepStrictEqual(options.getPluginConfig(), pluginConfig) || !isDeepStrictEqual(codexBindingConnectionSelection(readBinding()), selection)) throw new Error("Codex plugin discovery ownership changed; retry the request.");
 			};
 			const workspaceDir = binding?.cwd?.trim() || options.context.workspaceDir?.trim() || resolveCodexDefaultWorkspaceDir(pluginConfig);
-			const request = options.request ?? (await import("./.setup/command-rpc-DHFpn4le.mjs").then((n) => n.n)).codexControlRequest;
+			const request = options.request ?? (await import("./.setup/command-rpc-CGJGUQ6Y.mjs").then((n) => n.n)).codexControlRequest;
 			const connection = await resolveCodexBindingAppServerConnection({
 				binding,
 				pluginConfig,
@@ -403,7 +423,7 @@ function createCodexPluginsTool(options) {
 	};
 }
 function projectAvailablePlugin(plugin) {
-	const projected = {
+	return {
 		id: plugin.id,
 		pluginName: plugin.pluginName,
 		marketplaceName: plugin.marketplaceName,
@@ -411,13 +431,12 @@ function projectAvailablePlugin(plugin) {
 		untrustedDeveloperName: plugin.developerName,
 		installed: plugin.installed,
 		enabled: plugin.enabled,
-		available: plugin.available
+		available: plugin.available,
+		...plugin.description ? { untrustedDescription: plugin.description } : {},
+		...plugin.installPolicy ? { installPolicy: plugin.installPolicy } : {},
+		...plugin.authPolicy ? { authPolicy: plugin.authPolicy } : {},
+		...plugin.mustShowInstallationInterstitial !== void 0 ? { mustShowInstallationInterstitial: plugin.mustShowInstallationInterstitial } : {}
 	};
-	if (plugin.description) projected.untrustedDescription = plugin.description;
-	if (plugin.installPolicy) projected.installPolicy = plugin.installPolicy;
-	if (plugin.authPolicy) projected.authPolicy = plugin.authPolicy;
-	if (plugin.mustShowInstallationInterstitial !== void 0) projected.mustShowInstallationInterstitial = plugin.mustShowInstallationInterstitial;
-	return projected;
 }
 //#endregion
 //#region extensions/codex/src/native-thread-tool.ts
@@ -475,22 +494,12 @@ function readThreadId(params) {
 		label: "thread_id"
 	});
 }
-function readThreadStatusType(value) {
-	if (!isJsonObject(value) || !isJsonObject(value.thread) || !isJsonObject(value.thread.status)) return;
-	return typeof value.thread.status.type === "string" ? value.thread.status.type : void 0;
-}
-function assertThreadMayBeArchived(value, expectedThreadId) {
+function assertThreadIdle(value, expectedThreadId, action) {
 	if (!isJsonObject(value) || !isJsonObject(value.thread)) throw new Error("Codex app-server returned an invalid thread/read response");
 	if (value.thread.id !== expectedThreadId) throw new Error("Codex app-server returned a different thread than requested");
-	const status = readThreadStatusType(value);
-	if (status === "active") throw new Error("cannot archive an active Codex thread; wait for its turn to finish");
-	if (status !== "idle" && status !== "notLoaded") throw new Error("cannot verify that the Codex thread is idle; refusing to archive");
-}
-function assertThreadMayBeForked(value, expectedThreadId) {
-	if (!isJsonObject(value) || !isJsonObject(value.thread)) throw new Error("Codex app-server returned an invalid thread/read response");
-	if (value.thread.id !== expectedThreadId) throw new Error("Codex app-server returned a different thread than requested");
-	const status = readThreadStatusType(value);
-	if (status !== "idle" && status !== "notLoaded") throw new Error("cannot fork a Codex thread unless it is idle or not loaded");
+	const status = isJsonObject(value.thread.status) ? value.thread.status.type : void 0;
+	if (action === "archive" && status === "active") throw new Error("cannot archive an active Codex thread; wait for its turn to finish");
+	if (status !== "idle" && status !== "notLoaded") throw new Error(action === "archive" ? "cannot verify that the Codex thread is idle; refusing to archive" : "cannot fork a Codex thread unless it is idle or not loaded");
 }
 function redactNativeThreadTranscriptFields(value) {
 	if (!isJsonObject(value)) return value;
@@ -558,11 +567,12 @@ function createCodexThreadsTool(options) {
 			const mayReadRawTranscripts = supervision?.enabled !== true || supervision.allowRawTranscripts === true;
 			if ((action === "fork" || action === "rename" || action === "archive" || action === "unarchive") && supervision?.enabled === true && supervision.allowWriteControls !== true) throw new Error("Codex native thread mutations are disabled for this codex plugin supervision config.");
 			const run = async (archiveAdmission) => {
-				const request = options.request ?? (await import("./.setup/command-rpc-DHFpn4le.mjs").then((n) => n.n)).codexControlRequest;
+				const request = options.request ?? (await import("./.setup/command-rpc-CGJGUQ6Y.mjs").then((n) => n.n)).codexControlRequest;
 				const { isModelSelectionLocked, ModelSelectionLockedError } = await import("openclaw/plugin-sdk/model-session-runtime");
-				const { codexBindingConnectionSelection, resolveCodexBindingAppServerConnection } = await import("./.setup/binding-connection-Bm38niE8.mjs").then((n) => n.n);
-				const { resolveCodexSupervisionAppServerRuntimeOptions } = await import("./.setup/config-runtime-CeAhl_h4.mjs").then((n) => n.t);
-				const requestOptions = async (pluginConfig) => {
+				const { codexBindingConnectionSelection, resolveCodexBindingAppServerConnection } = await import("./.setup/binding-connection-DTtN1KrX.mjs").then((n) => n.n);
+				const { resolveCodexSupervisionAppServerRuntimeOptions } = await import("./.setup/config-runtime-C0NbLms1.mjs").then((n) => n.t);
+				const requestOptions = async () => {
+					const pluginConfig = admissionConfig;
 					const plugin = readCodexPluginConfig(pluginConfig);
 					const base = baseRequestOptions();
 					const session = currentSession();
@@ -571,6 +581,7 @@ function createCodexThreadsTool(options) {
 					const binding = readBinding();
 					const selection = codexBindingConnectionSelection(binding);
 					const assertCurrent = () => {
+						options.context.assertInvocationCurrent?.();
 						const current = currentSession();
 						if (runtimeConfig() !== base.config || !isDeepStrictEqual(options.getPluginConfig(), pluginConfig) || current?.sessionId !== session?.sessionId || current?.entry?.sessionId !== session?.entry?.sessionId || isModelSelectionLocked(current?.entry) !== isModelSelectionLocked(session?.entry) || !isDeepStrictEqual(codexBindingConnectionSelection(readBinding()), selection)) throw new Error("Codex native thread ownership changed; retry the request.");
 					};
@@ -597,11 +608,12 @@ function createCodexThreadsTool(options) {
 						assertCurrent
 					};
 				};
+				const scopedRequest = async (method, requestParams) => request(admissionConfig, method, requestParams, await requestOptions());
 				if (action === "list") {
 					const cursor = readStringParam(params, "cursor");
 					const searchTerm = readStringParam(params, "search");
 					if (searchTerm && !mayReadRawTranscripts) throw new Error("Codex native thread search is disabled while raw transcript access is disabled.");
-					const response = await request(admissionConfig, CODEX_CONTROL_METHODS.listThreads, {
+					const response = await scopedRequest(CODEX_CONTROL_METHODS.listThreads, {
 						archived: asBoolean(params.archived) ?? false,
 						limit: asSafeIntegerInRange(params.limit, {
 							min: 1,
@@ -613,17 +625,17 @@ function createCodexThreadsTool(options) {
 						sourceKinds: [...CODEX_INTERACTIVE_THREAD_SOURCE_KINDS],
 						...cursor ? { cursor } : {},
 						...searchTerm ? { searchTerm } : {}
-					}, await requestOptions(admissionConfig));
+					});
 					return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
 				}
 				const threadId = archiveAdmission?.threadId ?? readThreadId(params);
 				if (action === "read") {
 					const includeTurns = asBoolean(params.include_turns) ?? false;
 					if (includeTurns && !mayReadRawTranscripts) throw new Error("Codex raw transcript reads are disabled for this codex plugin supervision config.");
-					const response = await request(admissionConfig, CODEX_CONTROL_METHODS.readThread, {
+					const response = await scopedRequest(CODEX_CONTROL_METHODS.readThread, {
 						threadId,
 						includeTurns
-					}, await requestOptions(admissionConfig));
+					});
 					return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
 				}
 				if (action === "rename") {
@@ -631,10 +643,10 @@ function createCodexThreadsTool(options) {
 						required: true,
 						label: "name"
 					});
-					await request(admissionConfig, CODEX_CONTROL_METHODS.renameThread, {
+					await scopedRequest(CODEX_CONTROL_METHODS.renameThread, {
 						threadId,
 						name
-					}, await requestOptions(admissionConfig));
+					});
 					return jsonResult({
 						action,
 						threadId,
@@ -642,7 +654,7 @@ function createCodexThreadsTool(options) {
 					});
 				}
 				if (action === "unarchive") {
-					const response = await request(admissionConfig, CODEX_CONTROL_METHODS.unarchiveThread, { threadId }, await requestOptions(admissionConfig));
+					const response = await scopedRequest(CODEX_CONTROL_METHODS.unarchiveThread, { threadId });
 					return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
 				}
 				const session = archiveAdmission?.session ?? currentSession();
@@ -654,27 +666,27 @@ function createCodexThreadsTool(options) {
 						if (isModelSelectionLocked(admittedSession.entry)) throw new ModelSelectionLockedError();
 						assertCodexBindingMayBeReplaced(archivedBinding, "archiving its bound native thread");
 					}
-					assertThreadMayBeArchived(await request(admissionConfig, CODEX_CONTROL_METHODS.readThread, {
+					assertThreadIdle(await scopedRequest(CODEX_CONTROL_METHODS.readThread, {
 						threadId,
 						includeTurns: false
-					}, await requestOptions(admissionConfig)), threadId);
+					}), threadId, "archive");
 					if (await options.bindingStore.hasOtherThreadOwner(threadId, identity)) throw new Error("cannot archive a native Codex thread owned by another OpenClaw session");
 					await assertCodexArchiveDescendantsUnowned({
 						bindingStore: options.bindingStore,
 						threadId,
-						listPage: async (listParams) => await request(admissionConfig, CODEX_CONTROL_METHODS.listThreads, listParams, await requestOptions(admissionConfig)),
+						listPage: async (listParams) => await scopedRequest(CODEX_CONTROL_METHODS.listThreads, listParams),
 						assertDescendantIdle: async (descendantThreadId) => {
-							assertThreadMayBeArchived(await request(admissionConfig, CODEX_CONTROL_METHODS.readThread, {
+							assertThreadIdle(await scopedRequest(CODEX_CONTROL_METHODS.readThread, {
 								threadId: descendantThreadId,
 								includeTurns: false
-							}, await requestOptions(admissionConfig)), descendantThreadId);
+							}), descendantThreadId, "archive");
 						}
 					});
-					await request(admissionConfig, CODEX_CONTROL_METHODS.archiveThread, { threadId }, await requestOptions(admissionConfig));
+					await scopedRequest(CODEX_CONTROL_METHODS.archiveThread, { threadId });
 					if (archivedBinding?.threadId === threadId) await options.bindingStore.mutate(identity, {
 						kind: "clear",
 						threadId
-					});
+					}, options.context.assertInvocationCurrent);
 					return jsonResult({
 						action,
 						threadId
@@ -686,33 +698,65 @@ function createCodexThreadsTool(options) {
 				if (attach && isModelSelectionLocked(session?.entry)) throw new ModelSelectionLockedError();
 				const usesSupervisionConnection = binding?.connectionScope === "supervision" || admissionPlugin.appServer?.homeScope !== "user" && supervision?.enabled === true;
 				if (attach && usesSupervisionConnection) throw new Error("Supervised Codex forks must stay detached; set attach=false.");
+				const forkOptions = await requestOptions();
+				const { retainCodexAppServerBindingSubscription, rollbackCodexAppServerBindingSubscription } = await import("./.setup/thread-ownership-roNP0l1c.mjs").then((n) => n.o);
+				const { closeCodexStartupClientBestEffort } = await import("./.setup/attempt-client-cleanup-DOP-cW5j.mjs").then((n) => n.a);
 				if (attach) {
 					assertCodexBindingMayBeReplaced(binding, "attaching a different native fork");
-					assertThreadMayBeForked(await request(admissionConfig, CODEX_CONTROL_METHODS.readThread, {
+					assertThreadIdle(await request(admissionConfig, CODEX_CONTROL_METHODS.readThread, {
 						threadId,
 						includeTurns: false
-					}, await requestOptions(admissionConfig)), threadId);
+					}, forkOptions), threadId, "fork");
 				}
 				const response = await request(admissionConfig, CODEX_CONTROL_METHODS.forkThread, {
 					threadId,
 					threadSource: "user",
 					excludeTurns: true
-				}, await requestOptions(admissionConfig));
-				if (!isJsonObject(response) || !isJsonObject(response.thread)) throw new Error("Codex app-server returned an invalid thread/fork response");
-				const forkThreadId = typeof response.thread.id === "string" && response.thread.id.trim() ? response.thread.id : void 0;
-				if (!forkThreadId) throw new Error("Codex app-server thread/fork response did not include a thread id");
-				if (attach && session) {
-					if (!await options.bindingStore.mutate(currentIdentity(session.sessionId), {
-						kind: "set",
-						binding: {
-							threadId: forkThreadId,
-							cwd: typeof response.thread.cwd === "string" ? response.thread.cwd : options.context.workspaceDir ?? "",
-							model: typeof response.model === "string" ? response.model : void 0,
-							modelProvider: typeof response.modelProvider === "string" ? response.modelProvider : void 0,
-							historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
+				}, {
+					...forkOptions,
+					onResponse: async (value, client, { assertCurrent }) => {
+						if (!isJsonObject(value) || !isJsonObject(value.thread)) {
+							await closeCodexStartupClientBestEffort(client);
+							throw new Error("Codex app-server returned an invalid thread/fork response");
 						}
-					})) throw new Error("Codex session binding changed before the fork could be attached");
-				}
+						const forkThread = value.thread;
+						const forkThreadId = typeof forkThread.id === "string" && forkThread.id.trim() ? forkThread.id : void 0;
+						if (!forkThreadId) {
+							await closeCodexStartupClientBestEffort(client);
+							throw new Error("Codex app-server thread/fork response did not include a thread id");
+						}
+						let retained = false;
+						let attached = false;
+						try {
+							assertCurrent();
+							if (attach && session) {
+								const identity = currentIdentity(session.sessionId);
+								await options.bindingStore.withLease(identity, async () => {
+									assertCurrent();
+									if (currentSession()?.entry?.sessionId !== session.sessionId) throw new Error("Codex native thread ownership changed; retry the request.");
+									assertCodexBindingMayBeReplaced(currentBinding(session), "attaching a different native fork");
+									retained = await retainCodexAppServerBindingSubscription(client, forkThreadId);
+									if (!retained) throw new Error("Codex fork lost its native subscription owner.");
+									const nextBinding = {
+										threadId: forkThreadId,
+										clientId: client.getInstanceId(),
+										cwd: typeof forkThread.cwd === "string" ? forkThread.cwd : options.context.workspaceDir ?? "",
+										model: typeof value.model === "string" ? value.model : void 0,
+										modelProvider: typeof value.modelProvider === "string" ? value.modelProvider : void 0,
+										historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
+									};
+									attached = await options.bindingStore.mutate(identity, {
+										kind: "set",
+										binding: nextBinding
+									}, assertCurrent);
+									if (!attached) throw new Error("Codex session binding changed before the fork could be attached");
+								});
+							}
+						} finally {
+							if (!attached) await rollbackCodexAppServerBindingSubscription(client, forkThreadId, retained);
+						}
+					}
+				});
 				const result = {
 					action,
 					sourceThreadId: threadId,
@@ -759,6 +803,7 @@ function createCodexNodeExecServerCommand() {
 		cap: CODEX_NODE_EXEC_SERVER_CAPABILITY,
 		dangerous: true,
 		duplex: true,
+		hasActiveWork: () => activeProcesses.size > 0,
 		onDisconnect: async () => {
 			await Promise.all([...activeProcesses].map(async (terminate) => await terminate()));
 		},
@@ -772,37 +817,34 @@ function createCodexNodeExecServerCommand() {
 			}
 			if (!isRecord(request) || Object.keys(request).length !== 2 || request.authorization !== "human-approved" && request.authorization !== "session-full") throw new Error("Codex node exec-server requires an authorized managed placement workspace launch.");
 			const placement = parseCodexNodePlacementWorkspace(request.placement);
-			if (!context?.acquireManagedWorkspace || context.sessionKey !== placement.sessionKey || io.signal.aborted) throw new Error("Codex node exec-server requires active managed placement authority.");
-			const workspace = context.acquireManagedWorkspace({
+			if (!context?.acquireManagedWorkspaceAsync || context.sessionKey !== placement.sessionKey || io.signal.aborted) throw new Error("Codex node exec-server requires active managed placement authority.");
+			if (!context.prepareExecAuthorization) throw new Error("Codex node execution requires node-local exec policy support; update the node.");
+			const runtimeIo = context.signal ? {
+				...io,
+				signal: AbortSignal.any([io.signal, context.signal])
+			} : io;
+			const assertExecAuthorized = context.prepareExecAuthorization(request.authorization);
+			const { runCodexNodeExecServer } = await import("./.setup/node-exec-server.runtime-BgBfWQqo.mjs");
+			runtimeIo.signal.throwIfAborted();
+			const workspace = await context.acquireManagedWorkspaceAsync({
 				workspaceDir: placement.cwd,
 				environmentId: placement.environmentId,
 				sessionId: placement.sessionId,
 				ownerEpoch: placement.ownerEpoch,
 				sessionKey: placement.sessionKey
 			});
-			const frames = io.frames;
-			let unsubscribe;
 			try {
-				if (!context.prepareExecAuthorization) throw new Error("Codex node execution requires node-local exec policy support; update the node.");
-				const assertExecAuthorized = context.prepareExecAuthorization(request.authorization);
-				const { runCodexNodeExecServer } = await import("./.setup/node-exec-server.runtime-BaViBKNz.mjs");
-				return await runCodexNodeExecServer({
-					workspaceDir: workspace.workspaceDir,
-					homeDir: workspace.homeDir,
-					io,
-					activeProcesses,
-					assertExecAuthorized,
-					onFrameReceiver: (receiver) => {
-						unsubscribe = frames.onMessage(receiver);
-					}
-				});
-			} finally {
-				try {
-					unsubscribe?.();
-				} finally {
-					workspace.release();
-				}
+				runtimeIo.signal.throwIfAborted();
+			} catch (error) {
+				workspace.release();
+				throw error;
 			}
+			return await runCodexNodeExecServer({
+				workspace,
+				io: runtimeIo,
+				activeProcesses,
+				assertExecAuthorized
+			});
 		}
 	};
 }
@@ -885,6 +927,29 @@ function createCodexNodeExecServerInvokePolicy() {
 	};
 }
 //#endregion
+//#region extensions/codex/src/supervision-tool-policy.ts
+var CodexSupervisionPolicyError = class extends Error {};
+function requireSupervisionEnabled(pluginConfig) {
+	if (readCodexPluginConfig(pluginConfig).supervision?.enabled !== true) throw new CodexSupervisionPolicyError("Codex supervision is disabled in the codex plugin config.");
+}
+function requireOwnerAccess(options) {
+	options.assertInvocationCurrent?.();
+	if (!options.senderIsOwner) throw new CodexSupervisionPolicyError("Codex supervision compatibility tools require an owner-authorized sender.");
+}
+function resolveToolPolicy(pluginConfig) {
+	const config = readCodexPluginConfig(pluginConfig).supervision;
+	return {
+		allowRawTranscripts: config?.allowRawTranscripts === true,
+		allowWriteControls: config?.allowWriteControls === true
+	};
+}
+function requireRawTranscriptAccess(pluginConfig) {
+	if (!resolveToolPolicy(pluginConfig).allowRawTranscripts) throw new CodexSupervisionPolicyError("Codex session reads are disabled for this codex plugin supervision config.");
+}
+function requireWriteAccess(pluginConfig) {
+	if (!resolveToolPolicy(pluginConfig).allowWriteControls) throw new CodexSupervisionPolicyError("Codex write controls are disabled for this codex plugin supervision config.");
+}
+//#endregion
 //#region extensions/codex/src/supervision-tools.ts
 /**
 * Compatibility tools for the retired Codex Supervisor plugin.
@@ -896,10 +961,6 @@ function createCodexNodeExecServerInvokePolicy() {
 */
 /** Legacy endpoint env retained for the shipped Supervisor tool contract. */
 const LEGACY_CODEX_SUPERVISOR_ENDPOINTS_ENV = "OPENCLAW_CODEX_SUPERVISOR_ENDPOINTS";
-/** Legacy standalone-MCP transcript gate. Agent tools use canonical config. */
-const LEGACY_CODEX_SUPERVISOR_RAW_TRANSCRIPTS_ENV = "OPENCLAW_CODEX_SUPERVISOR_ALLOW_RAW_TRANSCRIPTS";
-/** Legacy standalone-MCP write gate. Agent tools use canonical config. */
-const LEGACY_CODEX_SUPERVISOR_WRITE_CONTROLS_ENV = "OPENCLAW_CODEX_SUPERVISOR_ALLOW_WRITE_CONTROLS";
 const CODEX_SUPERVISION_COMPAT_TOOL_NAMES = [
 	"codex_endpoint_probe",
 	"codex_sessions_list",
@@ -952,7 +1013,6 @@ const PAGE_LIMIT = 100;
 const MAX_COMPAT_PAGINATION_PAGES = 100;
 const MAX_COMPAT_CURSOR_LENGTH = 4096;
 const MAX_COMPAT_THREAD_ID_LENGTH = 4096;
-var CodexSupervisionPolicyError = class extends Error {};
 function asRecordArray(value) {
 	return Array.isArray(value) ? value.filter(isRecord) : [];
 }
@@ -977,9 +1037,6 @@ function readStoredThreads(data, maxEntries) {
 		return entry;
 	});
 }
-function readBooleanParam(params, key) {
-	return params[key] === true;
-}
 function readIntegerParam(params, key) {
 	const value = params[key];
 	if (value === void 0) return;
@@ -1071,25 +1128,23 @@ function readLegacyEnvEndpoints(env) {
 function resolveEndpoints(pluginConfig, env, runtimeConfig, resolveAuthProfileId, resolveRuntimeOptions) {
 	const configured = readCodexPluginConfig(pluginConfig).supervision?.endpoints;
 	const endpoints = configured?.length ? configured : readLegacyEnvEndpoints(env);
-	return (endpoints ? requireUniqueEndpointIds(endpoints.map(normalizeConfiguredEndpoint)) : [{
+	const normalized = endpoints ? requireUniqueEndpointIds(endpoints.map(normalizeConfiguredEndpoint)) : [{
 		id: "local",
 		label: "local Codex app-server"
-	}]).map((endpoint) => {
-		const resolved = {
-			id: endpoint.id,
-			connectionKey: supervisionEndpointConnectionKey({
-				endpoint,
-				pluginConfig,
-				env,
-				runtimeConfig,
-				resolveAuthProfileId,
-				resolveRuntimeOptions
-			})
-		};
-		if (endpoint.label !== void 0) resolved.label = endpoint.label;
-		if (endpoint.configured !== void 0) resolved.configured = endpoint.configured;
-		return resolved;
+	}];
+	const resolved = [];
+	for (const endpoint of normalized) resolved.push({
+		...endpoint,
+		connectionKey: supervisionEndpointConnectionKey({
+			endpoint,
+			pluginConfig,
+			env,
+			runtimeConfig,
+			resolveAuthProfileId,
+			resolveRuntimeOptions
+		})
 	});
+	return resolved;
 }
 function resolveEndpointStartOptions(params) {
 	const base = params.resolveRuntimeOptions({
@@ -1148,8 +1203,10 @@ function supervisionEndpointConnectionKey(params) {
 		})
 	});
 }
-function createCanonicalEndpointRequest(options) {
+function createPolicyGuardedRequest(options, policy) {
 	return async (endpoint, method, requestParams) => {
+		const currentEndpoint = requireCurrentEndpoint(options, policy, endpoint);
+		if (options.request) return await options.request(currentEndpoint, method, requestParams);
 		const pluginConfig = options.getPluginConfig();
 		const env = options.env ?? process.env;
 		const runtime = options.resolveRuntimeOptions({
@@ -1158,7 +1215,7 @@ function createCanonicalEndpointRequest(options) {
 		});
 		const config = options.getRuntimeConfig?.();
 		const startOptions = resolveEndpointStartOptions({
-			endpoint,
+			endpoint: currentEndpoint,
 			pluginConfig,
 			env,
 			resolveRuntimeOptions: options.resolveRuntimeOptions
@@ -1168,6 +1225,9 @@ function createCanonicalEndpointRequest(options) {
 			requestParams,
 			timeoutMs: runtime.requestTimeoutMs,
 			startOptions,
+			assertCurrent: () => {
+				requireCurrentEndpoint(options, policy, currentEndpoint);
+			},
 			...endpoint.configured || startOptions.homeScope === "user" ? { authProfileId: null } : {},
 			...config ? { config } : {}
 		});
@@ -1203,7 +1263,7 @@ function threadFromRead(value) {
 	return isRecord(value) && isRecord(value.thread) ? value.thread : void 0;
 }
 function isLoadedThreadReadMiss(error) {
-	const message = error instanceof Error ? error.message : String(error);
+	const message = coerceErrorMessage(error);
 	return message.includes("thread not found") || message.includes("thread not loaded");
 }
 async function readThread(params) {
@@ -1224,86 +1284,63 @@ async function readThread(params) {
 		return thread;
 	}
 }
-async function listLoadedSessions(request, endpoint) {
+async function listSessions(request, endpoint, storedLimit) {
+	const loaded = storedLimit === void 0;
+	const method = loaded ? "thread/loaded/list" : "thread/list";
+	const limit = storedLimit ?? Infinity;
 	const sessions = [];
 	const seenCursors = /* @__PURE__ */ new Set();
 	let cursor;
 	for (let pageIndex = 0; pageIndex < MAX_COMPAT_PAGINATION_PAGES; pageIndex += 1) {
-		const listed = await request(endpoint, "thread/loaded/list", {
-			limit: PAGE_LIMIT,
+		const remaining = limit - sessions.length;
+		if (remaining <= 0) break;
+		const pageLimit = Math.min(PAGE_LIMIT, remaining);
+		const listed = await request(endpoint, method, {
+			...loaded ? {} : {
+				archived: false,
+				sourceKinds: [...ALL_CODEX_THREAD_SOURCE_KINDS],
+				modelProviders: [],
+				sortKey: "recency_at",
+				sortDirection: "desc",
+				useStateDbOnly: true
+			},
+			limit: pageLimit,
 			...cursor ? { cursor } : {}
 		});
-		if (!isRecord(listed) || !Array.isArray(listed.data)) throw new Error("Codex thread/loaded/list returned an invalid response");
-		const threadIds = readLoadedThreadIds(listed.data);
-		for (const threadId of threadIds) {
-			if (sessions.some((entry) => entry.threadId === threadId)) continue;
+		if (!isRecord(listed) || !Array.isArray(listed.data)) throw new Error(`Codex ${method} returned an invalid response`);
+		const entries = loaded ? readLoadedThreadIds(listed.data) : readStoredThreads(listed.data, pageLimit);
+		for (const entry of entries) {
+			if (typeof entry === "string" && sessions.some((session) => session.threadId === entry)) continue;
 			try {
-				const thread = await readThread({
+				const thread = typeof entry === "string" ? await readThread({
 					request,
 					endpoint,
-					threadId,
+					threadId: entry,
 					includeTurns: false
-				});
-				const session = toSession(endpoint.id, thread, true);
-				if (session) sessions.push(session);
+				}) : entry;
+				const session = toSession(endpoint.id, thread, loaded ? true : void 0);
+				if (session && (loaded || !sessions.some((existing) => existing.threadId === session.threadId))) sessions.push(session);
 			} catch (error) {
-				if (!isLoadedThreadReadMiss(error)) throw error;
+				if (!loaded || !isLoadedThreadReadMiss(error)) throw error;
 			}
 		}
-		const nextCursor = readCompatNextCursor(listed.nextCursor, "thread/loaded/list");
-		if (nextCursor && seenCursors.has(nextCursor)) throw new Error(`Codex thread/loaded/list returned repeated cursor ${nextCursor}`);
+		const nextCursor = readCompatNextCursor(listed.nextCursor, method);
+		if (nextCursor && sessions.length < limit && seenCursors.has(nextCursor)) throw new Error(`Codex ${method} returned repeated cursor ${nextCursor}`);
 		if (nextCursor) seenCursors.add(nextCursor);
 		cursor = nextCursor;
-		if (!cursor) break;
+		if (!cursor || sessions.length >= limit) break;
 	}
-	if (cursor) throw new Error(`Codex thread/loaded/list exceeded ${MAX_COMPAT_PAGINATION_PAGES} pages with a continuation cursor`);
-	return sessions;
-}
-async function listStoredSessions(params) {
-	const sessions = [];
-	const seenCursors = /* @__PURE__ */ new Set();
-	let cursor;
-	for (let pageIndex = 0; pageIndex < MAX_COMPAT_PAGINATION_PAGES; pageIndex += 1) {
-		const remaining = params.limit - sessions.length;
-		if (remaining <= 0) break;
-		const pageLimit = Math.min(PAGE_LIMIT, remaining);
-		const listed = await params.request(params.endpoint, "thread/list", {
-			archived: false,
-			limit: pageLimit,
-			sourceKinds: [...ALL_CODEX_THREAD_SOURCE_KINDS],
-			modelProviders: [],
-			sortKey: "recency_at",
-			sortDirection: "desc",
-			useStateDbOnly: true,
-			...cursor ? { cursor } : {}
-		});
-		if (!isRecord(listed) || !Array.isArray(listed.data)) throw new Error("Codex thread/list returned an invalid response");
-		for (const thread of readStoredThreads(listed.data, pageLimit)) {
-			if (sessions.length >= params.limit) break;
-			const session = toSession(params.endpoint.id, thread);
-			if (session && !sessions.some((entry) => entry.threadId === session.threadId)) sessions.push(session);
-		}
-		const nextCursor = readCompatNextCursor(listed.nextCursor, "thread/list");
-		if (nextCursor && sessions.length < params.limit && seenCursors.has(nextCursor)) throw new Error(`Codex thread/list returned repeated cursor ${nextCursor}`);
-		if (nextCursor) seenCursors.add(nextCursor);
-		cursor = nextCursor;
-		if (!cursor || sessions.length >= params.limit) break;
-	}
-	if (cursor && sessions.length < params.limit) throw new Error(`Codex thread/list exceeded ${MAX_COMPAT_PAGINATION_PAGES} pages with a continuation cursor`);
+	if (cursor && sessions.length < limit) throw new Error(`Codex ${method} exceeded ${MAX_COMPAT_PAGINATION_PAGES} pages with a continuation cursor`);
 	return sessions;
 }
 async function listSessionSnapshot(params) {
 	const sessions = [];
 	const errors = [];
 	for (const endpoint of params.endpoints) try {
-		const loaded = await listLoadedSessions(params.request, endpoint);
+		const loaded = await listSessions(params.request, endpoint);
 		sessions.push(...loaded);
 		if (params.includeStored) {
-			const stored = await listStoredSessions({
-				request: params.request,
-				endpoint,
-				limit: params.maxStoredSessions ?? DEFAULT_MAX_STORED_SESSIONS
-			});
+			const stored = await listSessions(params.request, endpoint, params.maxStoredSessions ?? DEFAULT_MAX_STORED_SESSIONS);
 			for (const session of stored) if (!sessions.some((entry) => entry.endpointId === endpoint.id && entry.threadId === session.threadId)) sessions.push(session);
 		}
 	} catch (error) {
@@ -1311,7 +1348,7 @@ async function listSessionSnapshot(params) {
 		errors.push({
 			endpointId: endpoint.id,
 			ok: false,
-			detail: error instanceof Error ? error.message : String(error)
+			detail: coerceErrorMessage(error)
 		});
 	}
 	return {
@@ -1335,7 +1372,6 @@ async function resolveEndpointForThread(params) {
 		})).id === params.threadId) matches.push(endpoint);
 	} catch (error) {
 		if (error instanceof CodexSupervisionPolicyError) throw error;
-		if (!isLoadedThreadReadMiss(error)) continue;
 	}
 	if (matches.length === 1) return expectDefined(matches[0], "single matching Codex supervision endpoint");
 	if (matches.length > 1) throw new Error(`Codex thread id is ambiguous across endpoints: ${params.threadId}`);
@@ -1384,27 +1420,16 @@ function redactEndpointUrl(value) {
 	}
 }
 function endpointResult(endpoint, pluginConfig, env, resolveRuntimeOptions) {
-	const configured = endpoint.configured;
-	if (configured && (configured.transport === "stdio-proxy" || configured.transport === void 0)) return {
-		id: endpoint.id,
-		transport: "stdio-proxy",
-		...endpoint.label ? { label: endpoint.label } : {}
-	};
-	if (configured?.transport === "websocket") return {
-		id: endpoint.id,
-		transport: "websocket",
-		...endpoint.label ? { label: endpoint.label } : {},
-		url: redactEndpointUrl(configured.url)
-	};
-	const start = resolveRuntimeOptions({
+	const start = endpoint.configured ?? resolveRuntimeOptions({
 		pluginConfig,
 		env
 	}).start;
+	const remote = start.transport === "websocket" || start.transport === "unix" ? { url: redactEndpointUrl(start.url ?? (start.transport === "unix" ? "unix://" : "")) } : void 0;
 	return {
 		id: endpoint.id,
-		transport: start.transport === "stdio" ? "stdio-proxy" : "websocket",
+		transport: remote ? "websocket" : "stdio-proxy",
 		...endpoint.label ? { label: endpoint.label } : {},
-		...start.transport === "stdio" ? {} : { url: redactEndpointUrl(start.transport === "unix" ? start.url ?? "unix://" : start.url ?? "") }
+		...remote
 	};
 }
 function sanitizeSessionListResult(result, includeTranscriptDerivedFields) {
@@ -1423,32 +1448,12 @@ function sanitizeSessionListResult(result, includeTranscriptDerivedFields) {
 		}))
 	};
 }
-function requireSupervisionEnabled(pluginConfig) {
-	if (readCodexPluginConfig(pluginConfig).supervision?.enabled !== true) throw new CodexSupervisionPolicyError("Codex supervision is disabled in the codex plugin config.");
-}
-function requireOwnerAccess(options) {
-	if (!options.senderIsOwner) throw new CodexSupervisionPolicyError("Codex supervision compatibility tools require an owner-authorized sender.");
-}
-function resolveToolPolicy(options, pluginConfig) {
-	const config = readCodexPluginConfig(pluginConfig).supervision;
-	const env = options.env ?? process.env;
-	return {
-		allowRawTranscripts: config?.allowRawTranscripts === true || options.useLegacyMcpPolicyEnv === true && env[LEGACY_CODEX_SUPERVISOR_RAW_TRANSCRIPTS_ENV] === "1",
-		allowWriteControls: config?.allowWriteControls === true || options.useLegacyMcpPolicyEnv === true && env[LEGACY_CODEX_SUPERVISOR_WRITE_CONTROLS_ENV] === "1"
-	};
-}
-function requireRawTranscriptAccess(options, pluginConfig) {
-	if (!resolveToolPolicy(options, pluginConfig).allowRawTranscripts) throw new CodexSupervisionPolicyError("Codex session reads are disabled for this codex plugin supervision config.");
-}
-function requireWriteAccess(options, pluginConfig) {
-	if (!resolveToolPolicy(options, pluginConfig).allowWriteControls) throw new CodexSupervisionPolicyError("Codex write controls are disabled for this codex plugin supervision config.");
-}
 function requireLiveToolPolicy(options, policy) {
 	requireOwnerAccess(options);
 	const pluginConfig = options.getPluginConfig();
 	requireSupervisionEnabled(pluginConfig);
-	if (policy === "raw-transcripts") requireRawTranscriptAccess(options, pluginConfig);
-	else if (policy === "write-controls") requireWriteAccess(options, pluginConfig);
+	if (policy === "raw-transcripts") requireRawTranscriptAccess(pluginConfig);
+	else if (policy === "write-controls") requireWriteAccess(pluginConfig);
 	return {
 		pluginConfig,
 		endpoints: resolveEndpoints(pluginConfig, options.env ?? process.env, options.getRuntimeConfig?.(), options.resolveAuthProfileId, options.resolveRuntimeOptions)
@@ -1465,22 +1470,34 @@ function requireCurrentEndpointSet(options, expected) {
 	if (!(current.endpoints.length === expected.length && expected.every((endpoint) => current.endpoints.some((candidate) => candidate.id === endpoint.id && candidate.connectionKey === endpoint.connectionKey)))) throw new CodexSupervisionPolicyError("Codex supervision endpoint configuration changed during the request.");
 	return { pluginConfig: current.pluginConfig };
 }
-function createPolicyGuardedRequest(options, request, policy) {
-	return async (endpoint, method, params) => {
-		return await request(requireCurrentEndpoint(options, policy, endpoint), method, params);
-	};
-}
 function idleContinuationError(threadId) {
 	return /* @__PURE__ */ new Error(`Codex thread ${threadId} is idle. Continue it from Codex Sessions so OpenClaw can install the Codex harness approval and tool handlers before resume.`);
 }
 /** Builds the five shipped Codex Supervisor compatibility tools. */
 function createCodexSupervisionTools(options) {
-	const baseRequest = options.request ?? createCanonicalEndpointRequest(options);
-	const request = createPolicyGuardedRequest(options, baseRequest, "enabled");
-	const rawTranscriptRequest = createPolicyGuardedRequest(options, baseRequest, "raw-transcripts");
-	const writeRequest = createPolicyGuardedRequest(options, baseRequest, "write-controls");
-	const current = () => {
-		return requireLiveToolPolicy(options, "enabled");
+	const request = createPolicyGuardedRequest(options, "enabled");
+	const rawTranscriptRequest = createPolicyGuardedRequest(options, "raw-transcripts");
+	const writeRequest = createPolicyGuardedRequest(options, "write-controls");
+	const current = () => requireLiveToolPolicy(options, "enabled");
+	const readActiveThread = async (endpoints, params, threadId, idleError) => {
+		const endpoint = await resolveEndpointForThread({
+			endpoints,
+			request: writeRequest,
+			endpointId: readStringParam(params, "endpoint_id"),
+			threadId
+		});
+		const thread = await readThread({
+			request: writeRequest,
+			endpoint,
+			threadId,
+			includeTurns: true
+		});
+		requireCurrentEndpoint(options, "write-controls", endpoint);
+		if (statusType(thread) !== "active") throw idleError();
+		return {
+			endpoint,
+			thread
+		};
 	};
 	return [
 		{
@@ -1523,13 +1540,13 @@ function createCodexSupervisionTools(options) {
 				const result = await listSessionSnapshot({
 					endpoints,
 					request,
-					includeStored: readBooleanParam(params, "include_stored"),
+					includeStored: params.include_stored === true,
 					maxStoredSessions: readIntegerParam(params, "max_stored_sessions")
 				});
 				const { pluginConfig } = requireCurrentEndpointSet(options, endpoints);
 				return jsonResult({
 					summary: `codex sessions: ${result.sessions.length}`,
-					...sanitizeSessionListResult(result, resolveToolPolicy(options, pluginConfig).allowRawTranscripts)
+					...sanitizeSessionListResult(result, resolveToolPolicy(pluginConfig).allowRawTranscripts)
 				});
 			}
 		},
@@ -1540,7 +1557,7 @@ function createCodexSupervisionTools(options) {
 			parameters: SessionReadParamsSchema,
 			execute: async (_toolCallId, rawParams) => {
 				const { endpoints, pluginConfig } = current();
-				requireRawTranscriptAccess(options, pluginConfig);
+				requireRawTranscriptAccess(pluginConfig);
 				const params = isRecord(rawParams) ? rawParams : {};
 				const threadId = readStringParam(params, "thread_id", { required: true });
 				const endpoint = await resolveEndpointForThread({
@@ -1553,7 +1570,7 @@ function createCodexSupervisionTools(options) {
 					request: rawTranscriptRequest,
 					endpoint,
 					threadId,
-					includeTurns: readBooleanParam(params, "include_turns")
+					includeTurns: params.include_turns === true
 				});
 				requireCurrentEndpoint(options, "raw-transcripts", endpoint);
 				return jsonResult({
@@ -1569,7 +1586,7 @@ function createCodexSupervisionTools(options) {
 			parameters: SessionSendParamsSchema,
 			execute: async (_toolCallId, rawParams) => {
 				const { endpoints, pluginConfig } = current();
-				requireWriteAccess(options, pluginConfig);
+				requireWriteAccess(pluginConfig);
 				const params = isRecord(rawParams) ? rawParams : {};
 				const threadId = readStringParam(params, "thread_id", { required: true });
 				const text = readStringParam(params, "text", {
@@ -1577,20 +1594,7 @@ function createCodexSupervisionTools(options) {
 					allowEmpty: false
 				});
 				if ((readModeParam(params) ?? "auto") === "start") throw idleContinuationError(threadId);
-				const endpoint = await resolveEndpointForThread({
-					endpoints,
-					request: writeRequest,
-					endpointId: readStringParam(params, "endpoint_id"),
-					threadId
-				});
-				const thread = await readThread({
-					request: writeRequest,
-					endpoint,
-					threadId,
-					includeTurns: true
-				});
-				requireCurrentEndpoint(options, "write-controls", endpoint);
-				if (statusType(thread) !== "active") throw idleContinuationError(threadId);
+				const { endpoint, thread } = await readActiveThread(endpoints, params, threadId, () => idleContinuationError(threadId));
 				const turnId = await resolveInProgressTurnId({
 					request: writeRequest,
 					endpoint,
@@ -1626,23 +1630,10 @@ function createCodexSupervisionTools(options) {
 			parameters: SessionInterruptParamsSchema,
 			execute: async (_toolCallId, rawParams) => {
 				const { endpoints, pluginConfig } = current();
-				requireWriteAccess(options, pluginConfig);
+				requireWriteAccess(pluginConfig);
 				const params = isRecord(rawParams) ? rawParams : {};
 				const threadId = readStringParam(params, "thread_id", { required: true });
-				const endpoint = await resolveEndpointForThread({
-					endpoints,
-					request: writeRequest,
-					endpointId: readStringParam(params, "endpoint_id"),
-					threadId
-				});
-				const thread = await readThread({
-					request: writeRequest,
-					endpoint,
-					threadId,
-					includeTurns: true
-				});
-				requireCurrentEndpoint(options, "write-controls", endpoint);
-				if (statusType(thread) !== "active") throw new Error(`Codex thread ${threadId} has no active turn to interrupt`);
+				const { endpoint, thread } = await readActiveThread(endpoints, params, threadId, () => /* @__PURE__ */ new Error(`Codex thread ${threadId} has no active turn to interrupt`));
 				const turnId = readStringParam(params, "turn_id") ?? await resolveInProgressTurnId({
 					request: writeRequest,
 					endpoint,
@@ -1669,7 +1660,7 @@ function createCodexSupervisionTools(options) {
 }
 //#endregion
 //#region extensions/codex/src/web-search-provider.ts
-const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./.setup/web-search-provider.runtime-CTGuJt6i.mjs"));
+const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./.setup/web-search-provider.runtime-P77OUeoo.mjs"));
 const CodexWebSearchSchema = {
 	type: "object",
 	properties: { query: {
@@ -1714,6 +1705,7 @@ var codex_default = definePluginEntry({
 	reload: { noopPrefixes: ["plugins.entries.codex.config.codexPlugins"] },
 	register(api) {
 		registerCodexAccountUsage(api);
+		api.registerService(codexNativeProfileRecoveryService);
 		setManagedCodexPluginRoot(api.rootDir);
 		api.registerProvider(codexProviderDiscovery);
 		const resolveCurrentConfig = () => api.runtime.config?.current ? api.runtime.config.current() : void 0;
@@ -1739,20 +1731,28 @@ var codex_default = definePluginEntry({
 			getRuntimeConfig: resolveCurrentConfig
 		}));
 		let bindingStateStore;
+		let bindingMutationStore;
 		let managedThreadStateStore;
-		const openBindingStateStore = () => bindingStateStore ??= api.runtime.state.openSyncKeyedStore({
+		const bindingStateOptions = {
 			namespace: CODEX_APP_SERVER_BINDING_NAMESPACE,
 			maxEntries: CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
 			overflowPolicy: "reject-new"
-		});
+		};
+		const openBindingStateStore = () => bindingStateStore ??= api.runtime.state.openSyncKeyedStore(bindingStateOptions);
+		const openBindingMutationStore = () => bindingMutationStore ??= api.runtime.state.openKeyedStore(bindingStateOptions);
 		const lazyBindingStateStore = {
 			deleteIf: (key, predicate) => openBindingStateStore().deleteIf(key, predicate),
 			entries: () => openBindingStateStore().entries(),
 			lookup: (key) => openBindingStateStore().lookup(key),
-			registerIfAbsent: (key, value, options) => openBindingStateStore().registerIfAbsent(key, value, options),
-			get update() {
+			get lookupMany() {
 				const store = openBindingStateStore();
-				return store.update?.bind(store);
+				return store.lookupMany?.bind(store);
+			},
+			registerIfAbsent: (key, value, options) => openBindingStateStore().registerIfAbsent(key, value, options),
+			withCurrent: (authority) => {
+				const store = openBindingMutationStore();
+				if (!store.withCurrent) throw new Error("Codex bindings require action-bound plugin-state mutations");
+				return store.withCurrent(authority);
 			}
 		};
 		const openManagedThreadStateStore = () => managedThreadStateStore ??= api.runtime.state.openKeyedStore({
@@ -1799,16 +1799,20 @@ var codex_default = definePluginEntry({
 		for (const policy of createCodexSessionCatalogNodeInvokePolicies()) api.registerNodeInvokePolicy(policy);
 		if (readCodexPluginConfig(resolveCurrentPluginConfig()).supervision?.enabled === true) {
 			const { resolveCodexAppServerAuthProfileIdForAgent } = createCodexAuthProfileSelection(api.runtime.modelAuth);
-			api.registerTool((context) => {
-				if (context.senderIsOwner !== true) return [];
-				const resolveToolRuntimeConfig = () => context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config ?? resolveCurrentConfig();
-				return createCodexSupervisionTools({
-					getPluginConfig: () => resolvePluginConfig(resolveToolRuntimeConfig),
-					getRuntimeConfig: resolveToolRuntimeConfig,
-					resolveAuthProfileId: resolveCodexAppServerAuthProfileIdForAgent,
-					resolveRuntimeOptions: resolveCodexSupervisionAppServerRuntimeOptions,
-					senderIsOwner: context.senderIsOwner
-				});
+			api.registerTool({
+				contextVersion: 2,
+				create: (context) => {
+					if (context.senderIsOwner !== true) return [];
+					const resolveToolRuntimeConfig = () => context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config ?? resolveCurrentConfig();
+					return createCodexSupervisionTools({
+						getPluginConfig: () => resolvePluginConfig(resolveToolRuntimeConfig),
+						getRuntimeConfig: resolveToolRuntimeConfig,
+						resolveAuthProfileId: resolveCodexAppServerAuthProfileIdForAgent,
+						resolveRuntimeOptions: resolveCodexSupervisionAppServerRuntimeOptions,
+						senderIsOwner: context.senderIsOwner,
+						assertInvocationCurrent: context.assertInvocationCurrent
+					});
+				}
 			}, { names: [...CODEX_SUPERVISION_COMPAT_TOOL_NAMES] });
 		}
 		const agentHarnessOptions = {
@@ -1822,12 +1826,15 @@ var codex_default = definePluginEntry({
 		api.registerMediaUnderstandingProvider(buildCodexMediaUnderstandingProvider({ pluginConfig: api.pluginConfig }));
 		api.registerWebSearchProvider(createCodexWebSearchProvider({ resolvePluginConfig: resolveCurrentPluginConfig }));
 		api.registerMigrationProvider(buildCodexMigrationProvider({ runtime: api.runtime }));
-		api.registerTool((context) => createCodexThreadsTool({
-			bindingStore,
-			context,
-			runtime: api.runtime,
-			getPluginConfig: resolveCurrentPluginConfig
-		}), { name: "codex_threads" });
+		api.registerTool({
+			contextVersion: 2,
+			create: (context) => createCodexThreadsTool({
+				bindingStore,
+				context,
+				runtime: api.runtime,
+				getPluginConfig: resolveCurrentPluginConfig
+			})
+		}, { name: "codex_threads" });
 		api.registerToolMetadata({
 			toolName: "codex_threads",
 			displayName: "Codex Threads",
@@ -1835,11 +1842,14 @@ var codex_default = definePluginEntry({
 			risk: "high",
 			tags: ["codex", "sessions"]
 		});
-		api.registerTool((context) => createCodexPluginsTool({
-			bindingStore,
-			context,
-			getPluginConfig: resolveCurrentPluginConfig
-		}), { name: "codex_plugins" });
+		api.registerTool({
+			contextVersion: 2,
+			create: (context) => createCodexPluginsTool({
+				bindingStore,
+				context,
+				getPluginConfig: resolveCurrentPluginConfig
+			})
+		}, { name: "codex_plugins" });
 		api.registerToolMetadata({
 			toolName: "codex_plugins",
 			displayName: "Codex Plugins",
@@ -1851,7 +1861,7 @@ var codex_default = definePluginEntry({
 				"discovery"
 			]
 		});
-		for (const command of createCodexCliSessionNodeHostCommands()) api.registerNodeHostCommand(command);
+		for (const command of createCodexCliSessionNodeHostCommands((agentId) => sessionCatalogControlFactory.forNode(agentId))) api.registerNodeHostCommand(command);
 		for (const policy of createCodexCliSessionNodeInvokePolicies()) api.registerNodeInvokePolicy(policy);
 		api.registerNodeHostCommand(createCodexNodeExecServerCommand());
 		api.registerNodeInvokePolicy(createCodexNodeExecServerInvokePolicy());
@@ -1870,40 +1880,29 @@ var codex_default = definePluginEntry({
 				}),
 				codexPluginsManagementIo: {
 					readConfig: () => {
-						const plugins = (api.runtime.config?.current?.() ?? {}).plugins;
-						if (!plugins || typeof plugins !== "object") return Promise.resolve({});
-						const entries = plugins.entries;
-						if (!entries || typeof entries !== "object") return Promise.resolve({});
-						const codexEntry = entries.codex;
-						if (!codexEntry || typeof codexEntry !== "object") return Promise.resolve({});
-						const config = codexEntry.config;
-						if (!config || typeof config !== "object") return Promise.resolve({});
-						const codexPlugins = config.codexPlugins;
+						const codexPlugins = resolveCurrentConfig()?.plugins?.entries?.codex?.config?.codexPlugins;
 						if (!codexPlugins || typeof codexPlugins !== "object") return Promise.resolve({});
-						const declared = codexPlugins.plugins;
-						if (!declared || typeof declared !== "object") return Promise.resolve({ enabled: codexPlugins.enabled === true });
+						const enabled = "enabled" in codexPlugins && codexPlugins.enabled === true;
+						const declared = "plugins" in codexPlugins ? codexPlugins.plugins : void 0;
 						return Promise.resolve({
-							enabled: codexPlugins.enabled === true,
-							plugins: declared
+							enabled,
+							...declared && typeof declared === "object" ? { plugins: declared } : {}
 						});
 					},
-					mutate: async (update) => {
+					mutate: async (update, assertCurrent) => {
 						const { mutateConfigFile } = await import("openclaw/plugin-sdk/config-mutation");
-						await mutateConfigFile({ mutate: (draft) => {
-							const root = draft;
-							root.plugins = root.plugins ?? {};
-							const pluginsBlock = root.plugins;
-							pluginsBlock.entries = pluginsBlock.entries ?? {};
-							const entries = pluginsBlock.entries;
-							entries.codex = entries.codex ?? {};
-							const codexEntry = entries.codex;
-							codexEntry.config = codexEntry.config ?? {};
-							const config = codexEntry.config;
-							config.codexPlugins = config.codexPlugins ?? {};
-							const codexPlugins = config.codexPlugins;
-							codexPlugins.plugins = codexPlugins.plugins ?? {};
-							update(codexPlugins);
-						} });
+						await mutateConfigFile({
+							writeOptions: { assertCurrent },
+							mutate: (draft) => {
+								draft.plugins ??= {};
+								draft.plugins.entries ??= {};
+								const entry = draft.plugins.entries.codex ??= {};
+								const config = entry.config ??= {};
+								const codexPlugins = config.codexPlugins ??= {};
+								codexPlugins.plugins ??= {};
+								update(codexPlugins);
+							}
+						});
 					}
 				}
 			}
@@ -1926,7 +1925,7 @@ var codex_default = definePluginEntry({
 			if (endedSessionKey && nextSessionKey && nextSessionKey !== endedSessionKey) return;
 			if (event.nextSessionId?.trim() === event.sessionId.trim()) return;
 			const config = resolveCurrentConfig();
-			const [{ sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./.setup/session-binding-_0W_fHRr.mjs").then((n) => n.c), import("./.setup/session-retirement-CU87AOg9.mjs")]);
+			const [{ sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./.setup/session-binding-DGCYAfvD.mjs").then((n) => n.s), import("./.setup/session-retirement-qMTxkNx2.mjs")]);
 			await retireCodexAppServerSessionGeneration({
 				bindingStore,
 				identity: sessionBindingIdentity({