@openclaw/codex 2026.9.8 → 2026.10.1-beta.1

package/dist/index.js

@@ -1,52 +1,76 @@
 import { registerCodexCliMetadata } from "./cli-metadata.js";
-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-DIQ5O_-S.mjs";
+import { A as unwrapNodeInvokePayload, C as readGatewayParams, E as requireOnlyKeys, S as readControlCursor, _ as normalizeLimit, a as CODEX_LOCAL_SESSION_HOST_ID, b as parseTranscriptPage, f as catalogError, g as isInteractiveThreadSource, h as filterCatalogPageByTitle, i as CODEX_CATALOG_TRANSCRIPT_READ_COMMAND, j as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, l as MAX_TRANSCRIPT_PAGE_BYTES, n as CODEX_APP_SERVER_THREADS_LIST_COMMAND, o as CatalogParamsError, r as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, s as MAX_CURSOR_LENGTH, t as CODEX_APP_SERVER_THREADS_CAPABILITY, u as NODE_INVOKE_TIMEOUT_MS, v as parseCatalogPage, w as readPageParams, x as readBoundedOptionalString, y as parseJsonParams } from "./.setup/session-catalog-parsing-B-qWJh2x.mjs";
+import { i as isJsonObject, n as assertCodexThreadForkParams } from "./.setup/protocol-CANUwXJ3.mjs";
+import { d as readCurrentCodexNativeSubagentSubmissions, f as readCurrentNativePendingAssignments, l as readCurrentCodexAppServerBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, u as readCurrentCodexAppServerBindings } from "./.setup/session-binding-record-BZB8RgcF.mjs";
+import { n as defineCodexBuildState } from "./.setup/build-state-CIi3Ckqu.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 { 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-Dnps4W4_.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 { f as retireSharedCodexAppServerClientsBeforeDesktopGeneration } from "./.setup/shared-client-lifecycle-7xgtlo15.mjs";
-import { s as createCodexAppServerProcessReaperService } from "./.setup/transport-stdio-Bdegpn2V.mjs";
+import { n as createCodexAuthProfileSelection } from "./.setup/auth-profile-selection-hr8ocLtz.mjs";
+import { t as assertCodexAppServerConnectionSecurity } from "./.setup/config-security-KAPScztc.mjs";
+import { d as readCodexPluginConfig } from "./.setup/config-parsing-BQq-CHTF.mjs";
+import { n as resolveCodexAppServerLocalHomeDir, r as resolveCodexAppServerUserHomeDir, t as resolveCodexAppServerHomeDir } from "./.setup/auth-start-options-BPIPeEX8.mjs";
+import { r as createCodexAppServerConfig, t as codexAppServerStartOptionsKey } from "./.setup/config-options-HG_Rr3W_.mjs";
+import { o as setManagedCodexPluginRoot } from "./.setup/managed-binary-C1VFoVPf.mjs";
+import { O as createCodexDesktopGenerationService, T as retireSharedCodexAppServerClientsBeforeDesktopGeneration, m as hasActiveSharedCodexAppServerWork, p as getSharedCodexAppServerClientState, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./.setup/auth-cache-key-CEd9QlIs.mjs";
+import { i as CODEX_APP_SERVER_BINDING_NAMESPACE, r as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./.setup/session-binding-meta-Lkm5Lpf4.mjs";
+import { s as createCodexAppServerProcessReaperService } from "./.setup/transport-stdio-a0HDa2Mj.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-D6F_7p1I.mjs";
-import { t as CODEX_CONTROL_METHODS } from "./.setup/capabilities-B3WEZl4e.mjs";
+import { a as canMutateCodexHost, r as CODEX_NATIVE_EXECUTION_AUTH_ERROR } from "./.setup/command-authorization-AikPDtcc.mjs";
+import { o as formatCodexDisplayText } from "./.setup/command-formatters-DV3DHhdr.mjs";
+import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData, o as resolveCodexDefaultWorkspaceDir } from "./.setup/conversation-binding-data-DJ4ix-W5.mjs";
+import { t as buildCodexMigrationProvider } from "./.setup/provider-BP8ZaZqn.mjs";
+import { r as CodexAppServerRpcError, s as isCodexThreadReadMissingError } from "./.setup/rpc-error-hmWM21RB.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./.setup/capabilities-kQntafj_.mjs";
+import { n as filterCodexMarketplacePlugins, t as discoverCodexMarketplacePlugins } from "./.setup/plugin-marketplace-discovery-SQPhSuic.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-BFafIiF6.mjs";
-import { i as requestCodexAppServerJson } from "./.setup/request-BZOfsSXW.mjs";
+import { a as createCodexCliSessionNodeInvokePolicies, c as resolveCodexCliSessionForBindingOnNode, i as createCodexCliSessionNodeHostCommands, l as resumeCodexCliSessionOnNode, s as listCodexCliSessionsOnNode } from "./.setup/node-cli-sessions-B5oNDkUS.mjs";
+import { n as codexCatalogHomeIdFromCanonicalPath } from "./.setup/session-catalog-home-id-vlih0B_g.mjs";
+import { t as CODEX_CATALOG_MAX_ROWS } from "./.setup/session-catalog-limits-DEU36Qlo.mjs";
+import { a as CodexCatalogLoadingError, n as currentCodexCatalogListRequest, o as CODEX_CATALOG_STATE_NAMESPACE, r as withCodexCatalogListRequest, t as CodexCatalogListRequest } from "./.setup/session-catalog-list-request-tXephOB4.mjs";
+import { i as withTimeout$1 } from "./.setup/timeout-CXOfNoaX.mjs";
+import { t as lookupNodeCodexCatalogRecord } from "./.setup/session-catalog-node-lookup-Uufckwcm.mjs";
+import { r as projectCodexUserItemText } from "./.setup/transcript-history-projection-B9a7HwUV.mjs";
+import { r as codexUpstreamContinueResult } from "./.setup/session-upstream-marker-D15C9NHp.mjs";
+import { t as buildCodexAppServerConnectionFingerprint } from "./.setup/plugin-app-cache-key-BW8rd98k.mjs";
+import { n as readCodexSessionMeta } from "./.setup/session-catalog-provenance-CmsOE5mh.mjs";
+import { t as codexCatalogResidentHomeKey } from "./.setup/session-catalog-events-KIXOoSnQ.mjs";
+import { a as setCodexCatalogConnectionHomeResolver } from "./.setup/binding-connection-C-08ez1w.mjs";
+import { n as findCodexAppServerSpawnError } from "./.setup/spawn-error-CL3n6MAa.mjs";
+import { r as requestCodexAppServerJson } from "./.setup/request-BH3FvYUE.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 { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
+import { embeddedAgentLog, resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
+import { listAgentIds, resolveAgentDir, resolveDefaultAgentId, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { z } from "zod";
+import path from "node:path";
+import fs from "node:fs/promises";
 import { coerceErrorMessage, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { canonicalPathFromExistingAncestor } from "openclaw/plugin-sdk/file-access-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { scheduler } from "node:timers/promises";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
 import { readStringParam } from "openclaw/plugin-sdk/param-readers";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { isMainThread, threadId } from "node:worker_threads";
+import { areDiagnosticsEnabledForProcess, createSubsystemLogger } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { publishSessionCatalogHost, sessionCatalogPaging } from "openclaw/plugin-sdk/session-catalog-paging";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
+import { decodeNodePtyResumeParams, decodeNodePtyStartParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
 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-G348lY1q.mjs");
+		const { handleCodexAccountUsage } = await import("./.setup/account-usage-runtime-C4GFoef_.mjs");
 		await handleCodexAccountUsage(options);
 	}, { scope: "operator.admin" });
 }
@@ -58,7 +82,7 @@ function createCodexAppServerConnectionHealthService(options) {
 	let abortController;
 	let monitor;
 	const run = async (ctx, signal) => {
-		const { resolveCodexAppServerRuntimeOptions } = await import("./.setup/config-runtime-C0NbLms1.mjs").then((n) => n.t);
+		const { resolveCodexAppServerRuntimeOptions } = await import("./.setup/config-runtime-cUYrqu_a.mjs").then((n) => n.t);
 		let consecutiveFailures = 0;
 		while (!signal.aborted) {
 			let pluginConfig;
@@ -74,8 +98,9 @@ function createCodexAppServerConnectionHealthService(options) {
 				return;
 			}
 			if (runtime.start.transport !== "websocket") return;
-			const { getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./.setup/shared-client-CJCTeFpQ.mjs").then((n) => n.v);
-			const { isUnsupportedCodexAppServerVersionError } = await import("./.setup/client-qyUBJlGZ.mjs").then((n) => n.n);
+			const { getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./.setup/shared-client-DJJ3ljH2.mjs").then((n) => n.v);
+			const { sleepWithAbort } = await import("openclaw/plugin-sdk/runtime-env");
+			const { isUnsupportedCodexAppServerVersionError } = await import("./.setup/client-CBzEVDyb.mjs").then((n) => n.n);
 			if (signal.aborted) return;
 			let leasedClient;
 			try {
@@ -105,7 +130,7 @@ function createCodexAppServerConnectionHealthService(options) {
 			}
 			if (!signal.aborted) {
 				const exponentialDelayMs = Math.min(INITIAL_RECONNECT_DELAY_MS * 2 ** Math.max(0, consecutiveFailures - 1), MAX_RECONNECT_DELAY_MS);
-				await waitForReconnect(Math.min(Math.round(exponentialDelayMs * (.75 + Math.random() * .5)), MAX_RECONNECT_DELAY_MS), signal);
+				await sleepWithAbort(Math.min(Math.round(exponentialDelayMs * (.75 + Math.random() * .5)), MAX_RECONNECT_DELAY_MS), signal, { ref: false }).catch(() => void 0);
 			}
 		}
 	};
@@ -142,7 +167,7 @@ function isPermanentCodexAppServerConnectionFailure(error, isUnsupportedCodexApp
 }
 function waitForCodexAppServerClose(client, signal) {
 	return new Promise((resolve) => {
-		if (signal.aborted) {
+		if (signal.aborted || client.getCloseError()) {
 			resolve();
 			return;
 		}
@@ -155,46 +180,113 @@ function waitForCodexAppServerClose(client, signal) {
 		signal.addEventListener("abort", finish, { once: true });
 	});
 }
-function waitForReconnect(delayMs, signal) {
-	return new Promise((resolve) => {
-		if (signal.aborted) {
-			resolve();
-			return;
+//#endregion
+//#region extensions/codex/src/app-server/managed-thread-store.ts
+const CODEX_MANAGED_THREAD_NAMESPACE = "app-server-managed-threads";
+const CODEX_MANAGED_THREAD_MAX_ENTRIES = 2e4;
+const managedThreadSchema = z.object({
+	version: z.literal(1),
+	kind: z.literal("managed-thread"),
+	sourceHomeId: z.string().min(1),
+	threadId: z.string().min(1),
+	rolloutPath: z.string().min(1).optional()
+});
+function managedThreadStoreKey(sourceHomeId, threadId) {
+	return `sha256:${createHash("sha256").update("openclaw:codex-managed-thread:v1\0").update(sourceHomeId).update("\0").update(threadId).digest("hex")}`;
+}
+/** Durable ownership index for Codex threads created by OpenClaw. */
+function createCodexManagedThreadStore(state) {
+	const byHome = /* @__PURE__ */ new Map();
+	const memberships = /* @__PURE__ */ new Map();
+	let hydration;
+	const remember = ({ sourceHomeId, threadId }) => {
+		const key = managedThreadStoreKey(sourceHomeId, threadId);
+		if (memberships.has(key)) return key;
+		memberships.set(key, {
+			sourceHomeId,
+			threadId
+		});
+		let ids = byHome.get(sourceHomeId);
+		if (!ids) {
+			ids = /* @__PURE__ */ new Set();
+			byHome.set(sourceHomeId, ids);
 		}
-		const finish = () => {
-			clearTimeout(timer);
-			signal.removeEventListener("abort", finish);
-			resolve();
-		};
-		const timer = setTimeout(finish, delayMs);
-		timer.unref();
-		signal.addEventListener("abort", finish, { once: true });
-	});
+		ids.add(threadId);
+		if (memberships.size > 2e4) {
+			const oldest = memberships.entries().next().value;
+			if (oldest) {
+				memberships.delete(oldest[0]);
+				const oldestHome = byHome.get(oldest[1].sourceHomeId);
+				oldestHome?.delete(oldest[1].threadId);
+				if (oldestHome?.size === 0) byHome.delete(oldest[1].sourceHomeId);
+			}
+		}
+		return key;
+	};
+	const snapshot = async () => {
+		hydration ??= state.entries().then((entries) => {
+			const marked = new Map(memberships);
+			memberships.clear();
+			byHome.clear();
+			for (const entry of entries.toSorted((a, b) => a.createdAt - b.createdAt)) {
+				const parsed = managedThreadSchema.safeParse(entry.value);
+				if (parsed.success) marked.delete(remember(parsed.data));
+			}
+			for (const membership of marked.values()) remember(membership);
+		}).catch((error) => {
+			hydration = void 0;
+			throw error;
+		});
+		await hydration;
+		return byHome;
+	};
+	return {
+		async has(sourceHomeId, threadId) {
+			return (await snapshot()).get(sourceHomeId)?.has(threadId) ?? false;
+		},
+		async mark(params) {
+			try {
+				const value = managedThreadSchema.parse({
+					version: 1,
+					kind: "managed-thread",
+					sourceHomeId: params.sourceHomeId.trim(),
+					threadId: params.threadId.trim(),
+					...params.rolloutPath?.trim() ? { rolloutPath: params.rolloutPath.trim() } : {}
+				});
+				await state.registerIfAbsent(managedThreadStoreKey(value.sourceHomeId, value.threadId), value);
+				remember(value);
+				return true;
+			} catch (error) {
+				embeddedAgentLog.warn("failed to record Codex managed thread ownership", { error });
+				return false;
+			}
+		},
+		snapshot
+	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/session-binding-store.ts
+/** Binding reads with lazy mutation, lease, and auth machinery. */
 /** 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-DGCYAfvD.mjs").then((n) => n.s).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
+	const store = () => resolved ??= import("./.setup/session-binding-Ce7BqiPN.mjs").then((n) => n.i).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;
-		},
+		readMany: (identities) => readCurrentCodexAppServerBindings(state.asyncReads, identities),
 		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),
+		mutate: async (identity, mutation, assertCurrent, authority) => (await store()).mutate(identity, mutation, assertCurrent, authority),
 		prepareSessionGenerationReclaim: async (identity) => (await store()).prepareSessionGenerationReclaim(identity),
-		adoptSessionGeneration: async (identity, previousSessionId, assertCurrent) => (await store()).adoptSessionGeneration(identity, previousSessionId, assertCurrent),
+		adoptSessionGeneration: async (identity, previousSessionId, assertCurrent, authority) => (await store()).adoptSessionGeneration(identity, previousSessionId, assertCurrent, authority),
 		resetSessionGeneration: async (identity) => (await store()).resetSessionGeneration(identity),
 		retireSessionGeneration: async (identity) => (await store()).retireSessionGeneration(identity),
 		withSessionDeletion: async (identity, assertCurrent, run) => (await store()).withSessionDeletion(identity, assertCurrent, run),
 		withThreadArchiveFence: async (run) => (await store()).withThreadArchiveFence(run),
-		withLease: async (identity, run) => (await store()).withLease(identity, run)
+		withLease: async (identity, run, options) => (await store()).withLease(identity, run, options)
 	};
 }
 //#endregion
@@ -226,7 +318,7 @@ function createCodexCommand(options) {
 				...ctx,
 				gatewayClientScopes: ctx.gatewayClientScopes?.slice()
 			};
-			const { handleCodexCommand } = await import("./.setup/command-dispatch-Btrs1D6f.mjs");
+			const { handleCodexCommand } = await import("./.setup/command-dispatch-BE_RdMou.mjs");
 			return handleCodexCommand(commandContext, options);
 		}
 	};
@@ -258,7 +350,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-DjCz2eOw.mjs").then((n) => n.r);
+				const { resolveCodexNativeSandboxBlock } = await import("./.setup/sandbox-guard-WqE8yPge.mjs").then((n) => n.r);
 				const blocked = resolveCodexNativeSandboxBlock({
 					config: options.config,
 					sessionKey,
@@ -295,7 +387,7 @@ async function handleCodexConversationInboundClaim(event, ctx, options) {
 		return {
 			handled: true,
 			reply: (await withCodexConversationThreadActivity(data.bindingId, async () => {
-				const { resolveCodexNativeExecutionBlock } = await import("./.setup/sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
+				const { resolveCodexNativeExecutionBlock } = await import("./.setup/sandbox-guard-WqE8yPge.mjs").then((n) => n.r);
 				const nativeExecutionBlock = resolveCodexNativeExecutionBlock({
 					config: options.config,
 					sessionKey,
@@ -304,7 +396,7 @@ 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-74LaGGH-.mjs");
+				const { runBoundTurnWithMissingThreadRecovery } = await import("./.setup/conversation-binding-CgSSD1Qz.mjs");
 				const current = options.bindingStore.read(identity);
 				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({
@@ -338,7 +430,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-B6pPt21M.mjs").then((n) => n.o);
+		const { retireCodexConversationThreadBinding } = await import("./.setup/thread-ownership-0aRHD9iK.mjs").then((n) => n.o);
 		return retireCodexConversationThreadBinding({
 			bindingStore: options.bindingStore,
 			identity,
@@ -373,7 +465,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-DTtN1KrX.mjs").then((n) => n.n);
+			const { codexBindingConnectionSelection, resolveCodexBindingAppServerConnection } = await import("./.setup/binding-connection-C-08ez1w.mjs").then((n) => n.n);
 			const pluginConfig = options.getPluginConfig();
 			const config = runtimeConfig();
 			const identity = options.context.sessionId ? sessionBindingIdentity({
@@ -390,7 +482,7 @@ function createCodexPluginsTool(options) {
 				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-skzRq4wD.mjs").then((n) => n.n)).codexControlRequest;
+			const request = options.request ?? (await import("./.setup/command-rpc-B6xsq2dB.mjs").then((n) => n.n)).codexControlRequest;
 			const connection = await resolveCodexBindingAppServerConnection({
 				binding,
 				pluginConfig,
@@ -565,15 +657,16 @@ function createCodexThreadsTool(options) {
 			const admissionPlugin = readCodexPluginConfig(admissionConfig);
 			const supervision = admissionPlugin.supervision;
 			const mayReadRawTranscripts = supervision?.enabled !== true || supervision.allowRawTranscripts === true;
+			const threadResult = (response) => jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
 			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-skzRq4wD.mjs").then((n) => n.n)).codexControlRequest;
+				const request = options.request ?? (await import("./.setup/command-rpc-B6xsq2dB.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-DTtN1KrX.mjs").then((n) => n.n);
-				const { resolveCodexSupervisionAppServerRuntimeOptions } = await import("./.setup/config-runtime-C0NbLms1.mjs").then((n) => n.t);
+				const { codexBindingConnectionSelection, resolveCodexBindingAppServerConnection } = await import("./.setup/binding-connection-C-08ez1w.mjs").then((n) => n.n);
+				const { resolveCodexSupervisionAppServerRuntimeOptions } = await import("./.setup/config-runtime-cUYrqu_a.mjs").then((n) => n.t);
 				const requestOptions = async () => {
 					const pluginConfig = admissionConfig;
-					const plugin = readCodexPluginConfig(pluginConfig);
+					const plugin = admissionPlugin;
 					const base = baseRequestOptions();
 					const session = currentSession();
 					const identity = session ? currentIdentity(session.sessionId) : void 0;
@@ -626,7 +719,7 @@ function createCodexThreadsTool(options) {
 						...cursor ? { cursor } : {},
 						...searchTerm ? { searchTerm } : {}
 					});
-					return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
+					return threadResult(response);
 				}
 				const threadId = archiveAdmission?.threadId ?? readThreadId(params);
 				if (action === "read") {
@@ -636,7 +729,7 @@ function createCodexThreadsTool(options) {
 						threadId,
 						includeTurns
 					});
-					return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
+					return threadResult(response);
 				}
 				if (action === "rename") {
 					const name = readStringParam(params, "name", {
@@ -655,7 +748,7 @@ function createCodexThreadsTool(options) {
 				}
 				if (action === "unarchive") {
 					const response = await scopedRequest(CODEX_CONTROL_METHODS.unarchiveThread, { threadId });
-					return jsonResult(mayReadRawTranscripts ? response : redactNativeThreadResponse(response));
+					return threadResult(response);
 				}
 				const session = archiveAdmission?.session ?? currentSession();
 				const binding = currentBinding(session);
@@ -699,8 +792,8 @@ function createCodexThreadsTool(options) {
 				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-B6pPt21M.mjs").then((n) => n.o);
-				const { closeCodexStartupClientBestEffort } = await import("./.setup/attempt-client-cleanup-B-S7ngS_.mjs").then((n) => n.a);
+				const { retainCodexAppServerBindingSubscription, rollbackCodexAppServerBindingSubscription } = await import("./.setup/thread-ownership-0aRHD9iK.mjs").then((n) => n.o);
+				const { closeCodexStartupClientBestEffort } = await import("./.setup/attempt-client-cleanup-yLjGwbwT.mjs").then((n) => n.a);
 				if (attach) {
 					assertCodexBindingMayBeReplaced(binding, "attaching a different native fork");
 					assertThreadIdle(await request(admissionConfig, CODEX_CONTROL_METHODS.readThread, {
@@ -763,7 +856,7 @@ function createCodexThreadsTool(options) {
 					thread: response.thread,
 					attached: attach
 				};
-				return jsonResult(mayReadRawTranscripts ? result : redactNativeThreadResponse(result));
+				return threadResult(result);
 			};
 			if (action === "archive") {
 				const threadId = readThreadId(params);
@@ -824,7 +917,7 @@ function createCodexNodeExecServerCommand() {
 				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");
+			const { runCodexNodeExecServer } = await import("./.setup/node-exec-server.runtime-0xSEjKYt.mjs");
 			runtimeIo.signal.throwIfAborted();
 			const workspace = await context.acquireManagedWorkspaceAsync({
 				workspaceDir: placement.cwd,
@@ -927,188 +1020,2711 @@ 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
+//#region extensions/codex/src/session-catalog-create.ts
+const CODEX_AGENT_RUNTIME_ID = "codex";
+const CODEX_CATALOG_DEFAULT_MODEL_REF = "openai/gpt-6-astra";
+function resolveCodexCatalogCreateSession(modelConfig, config, requestedAgentId) {
+	if (!config) return;
+	const agentId = requestedAgentId ?? resolveDefaultAgentId(config);
+	const defaultModel = modelConfig.resolveDefaultModelForAgent({
+		cfg: config,
+		agentId
+	});
+	const modelRef = defaultModel.provider === "openai" ? `${defaultModel.provider}/${defaultModel.model}` : CODEX_CATALOG_DEFAULT_MODEL_REF;
+	const allowed = modelConfig.resolveAllowedModelRef({
+		cfg: config,
+		catalog: [],
+		raw: modelRef,
+		defaultProvider: defaultModel.provider,
+		defaultModel: defaultModel.model,
+		agentId
+	});
+	return "error" in allowed ? void 0 : {
+		model: allowed.key,
+		agentRuntime: CODEX_AGENT_RUNTIME_ID
 	};
 }
-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.
-*
-* Read operations and active-turn controls use the Codex plugin's canonical
-* shared app-server client. Idle threads are never resumed or started here:
-* continuation belongs to the Codex harness, which installs approval and tool
-* handlers before it starts or resumes the harness-owned Codex thread.
-*/
-/** Legacy endpoint env retained for the shipped Supervisor tool contract. */
-const LEGACY_CODEX_SUPERVISOR_ENDPOINTS_ENV = "OPENCLAW_CODEX_SUPERVISOR_ENDPOINTS";
-const CODEX_SUPERVISION_COMPAT_TOOL_NAMES = [
-	"codex_endpoint_probe",
-	"codex_sessions_list",
-	"codex_session_read",
-	"codex_session_send",
-	"codex_session_interrupt"
+//#region extensions/codex/src/app-server/request-observation.ts
+const CODEX_REQUEST_WAITER_OUTCOMES = [
+	"resolved",
+	"native-error",
+	"timed-out",
+	"aborted",
+	"authority-rejected",
+	"local-failed",
+	"client-closed"
 ];
-const EmptyParamsSchema = Type.Object({}, { additionalProperties: false });
-const SessionsListParamsSchema = Type.Object({
-	include_stored: Type.Optional(Type.Boolean()),
-	max_stored_sessions: Type.Optional(Type.Integer({
-		minimum: 1,
-		maximum: 1e3
-	}))
-}, { additionalProperties: false });
-const SessionReadParamsSchema = Type.Object({
-	endpoint_id: Type.Optional(Type.String()),
-	thread_id: Type.String(),
-	include_turns: Type.Optional(Type.Boolean())
-}, { additionalProperties: false });
-const SessionSendParamsSchema = Type.Object({
-	endpoint_id: Type.Optional(Type.String()),
-	thread_id: Type.String(),
-	text: Type.String(),
-	mode: Type.Optional(Type.Union([
-		Type.Literal("auto"),
-		Type.Literal("start"),
-		Type.Literal("steer")
-	]))
-}, { additionalProperties: false });
-const SessionInterruptParamsSchema = Type.Object({
-	endpoint_id: Type.Optional(Type.String()),
-	thread_id: Type.String(),
-	turn_id: Type.Optional(Type.String())
-}, { additionalProperties: false });
-const ALL_CODEX_THREAD_SOURCE_KINDS = [
-	"cli",
-	"vscode",
-	"exec",
-	"appServer",
-	"subAgent",
-	"subAgentReview",
-	"subAgentCompact",
-	"subAgentThreadSpawn",
-	"subAgentOther",
-	"unknown"
+const CODEX_REQUEST_WIRE_OUTCOMES = [
+	"retained-pending",
+	"native-ok",
+	"native-error",
+	"ingress-rejected",
+	"correlation-closed",
+	"not-written"
 ];
-const DEFAULT_MAX_STORED_SESSIONS = 200;
-const PAGE_LIMIT = 100;
-const MAX_COMPAT_PAGINATION_PAGES = 100;
-const MAX_COMPAT_CURSOR_LENGTH = 4096;
-const MAX_COMPAT_THREAD_ID_LENGTH = 4096;
-function asRecordArray(value) {
-	return Array.isArray(value) ? value.filter(isRecord) : [];
-}
-function readCompatNextCursor(value, method) {
-	if (value === null || value === void 0) return;
-	if (typeof value !== "string" || value.trim().length === 0 || value.length > MAX_COMPAT_CURSOR_LENGTH) throw new Error(`Codex ${method} returned an invalid nextCursor`);
-	return value;
+//#endregion
+//#region extensions/codex/src/session-catalog-diagnostics.ts
+const log = createSubsystemLogger("gateway/session-catalog");
+const listScope = new AsyncLocalStorage();
+let epoch;
+let sequence = 0;
+let active = 0;
+let windowStart = 0;
+let emitted = 0;
+let omitted = 0;
+const WAITER_OUTCOMES = new Set(CODEX_REQUEST_WAITER_OUTCOMES);
+const WIRE_OUTCOMES = new Set(CODEX_REQUEST_WIRE_OUTCOMES);
+function controlWaiterTuple(controlCallOrdinal, summary) {
+	const ordinals = [
+		controlCallOrdinal,
+		summary.overloadAttemptOrdinal,
+		summary.rpcId,
+		summary.waiterOrdinal
+	];
+	const times = [
+		summary.attemptCreatedAtMs,
+		summary.waiterAttachedAtMs,
+		summary.waiterSettledAtMs
+	];
+	const optionalTimes = [summary.firstPossibleWriteAtMs, summary.wireObservedAtMs];
+	const validTime = (value) => Number.isFinite(value) && value >= 0 && Number.isSafeInteger(Math.round(value));
+	if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(summary.clientInstanceId) || !ordinals.every((value) => Number.isSafeInteger(value) && value > 0) || !times.every(validTime) || !optionalTimes.every((value) => value === null || validTime(value)) || summary.disposition !== "new" && summary.disposition !== "joined" || !WAITER_OUTCOMES.has(summary.waiterOutcome) || !WIRE_OUTCOMES.has(summary.wireOutcomeAtWaiterSettlement)) return;
+	return [
+		controlCallOrdinal,
+		summary.overloadAttemptOrdinal,
+		summary.clientInstanceId,
+		summary.rpcId,
+		summary.waiterOrdinal,
+		summary.disposition,
+		Math.round(summary.attemptCreatedAtMs),
+		summary.firstPossibleWriteAtMs === null ? null : Math.round(summary.firstPossibleWriteAtMs),
+		Math.round(summary.waiterAttachedAtMs),
+		Math.round(summary.waiterSettledAtMs),
+		summary.waiterOutcome,
+		summary.wireOutcomeAtWaiterSettlement,
+		summary.wireObservedAtMs === null ? null : Math.round(summary.wireObservedAtMs)
+	];
 }
-function readCompatThreadId(value, method, index) {
-	if (typeof value !== "string" || value.trim().length === 0 || value.length > MAX_COMPAT_THREAD_ID_LENGTH) throw new Error(`Codex ${method} returned an invalid thread id at data[${index}]`);
-	return value;
+function fitsMetadata(metadata) {
+	return Object.keys(metadata).length <= 28 && Buffer.byteLength(JSON.stringify(metadata)) <= 2048;
 }
-function readLoadedThreadIds(data) {
-	if (data.length > PAGE_LIMIT) throw new Error(`Codex thread/loaded/list returned more than ${PAGE_LIMIT} entries`);
-	return data.map((entry, index) => readCompatThreadId(entry, "thread/loaded/list", index));
+function withControlWaiters(metadata, fields) {
+	if (!("origin" in fields) || !fields.controlWaitersV1) return metadata;
+	const kept = fields.controlWaitersV1.slice();
+	let count = fields.controlWaitersOmitted ?? 0;
+	while (true) {
+		const complete = {
+			...metadata,
+			controlWaitersV1: JSON.stringify(kept),
+			controlWaitersOmitted: count
+		};
+		if (fitsMetadata(complete)) return complete;
+		if (kept.length === 0) {
+			const countOnly = {
+				...metadata,
+				controlWaitersOmitted: count
+			};
+			return fitsMetadata(countOnly) ? countOnly : metadata;
+		}
+		kept.splice(kept.length > 2 ? kept.length - 2 : 0, 1);
+		count = Math.min(Number.MAX_SAFE_INTEGER, count + 1);
+	}
 }
-function readStoredThreads(data, maxEntries) {
-	if (data.length > maxEntries) throw new Error(`Codex thread/list returned more than ${maxEntries} entries`);
-	return data.map((entry, index) => {
-		if (!isRecord(entry)) throw new Error(`Codex thread/list returned an invalid entry at data[${index}]`);
-		readCompatThreadId(entry.id, "thread/list", index);
-		return entry;
-	});
+const CONTROL_PHASE_FIELDS = {
+	"load-control": "controlLoadMs",
+	prepare: "controlPrepareMs",
+	"acquire-client": "controlAcquireClientMs",
+	"client-request": "controlClientRequestMs",
+	"release-client": "controlReleaseClientMs"
+};
+function enabled() {
+	return areDiagnosticsEnabledForProcess() && log.isEnabled("warn");
 }
-function readIntegerParam(params, key) {
-	const value = params[key];
-	if (value === void 0) return;
-	if (typeof value !== "number" || !Number.isInteger(value)) throw new Error(`${key} must be an integer`);
-	if (value < 1 || value > 1e3) throw new Error(`${key} must be between 1 and 1000`);
-	return value;
+function start(kind, fields) {
+	if (!enabled()) return;
+	if (active >= 64) {
+		omitted = Math.min(Number.MAX_SAFE_INTEGER, omitted + 1);
+		return;
+	}
+	active++;
+	epoch ??= randomUUID();
+	const started = performance.now();
+	const observation = {
+		operationId: String(++sequence),
+		fields,
+		closed: false,
+		finish(outcome) {
+			if (observation.closed) return;
+			observation.closed = true;
+			active--;
+			const elapsedMs = performance.now() - started;
+			try {
+				if (elapsedMs < 1e3 || !enabled()) return;
+				if (performance.now() - windowStart >= 6e4) {
+					windowStart = performance.now();
+					emitted = 0;
+				}
+				if (emitted >= 60) {
+					omitted = Math.min(Number.MAX_SAFE_INTEGER, omitted + 1);
+					return;
+				}
+				const metadata = {
+					diagnosticEpoch: epoch,
+					operationId: observation.operationId,
+					pid: process.pid,
+					threadId,
+					isMainThread,
+					elapsedMs: Math.round(elapsedMs),
+					outcome,
+					omittedObservations: omitted,
+					...Object.fromEntries(Object.entries(fields).filter(([key, value]) => value !== void 0 && key !== "controlWaitersV1" && key !== "controlWaitersOmitted").map(([key, value]) => [key, typeof value === "number" ? Math.round(value) : value]))
+				};
+				if (!fitsMetadata(metadata)) {
+					omitted = Math.min(Number.MAX_SAFE_INTEGER, omitted + 1);
+					return;
+				}
+				emitted++;
+				log.warn(`slow Codex catalog ${kind}`, withControlWaiters(metadata, fields));
+				omitted = 0;
+			} catch {}
+		}
+	};
+	return observation;
 }
-function readModeParam(params) {
-	const mode = readStringParam(params, "mode");
-	if (!mode) return;
-	if (mode === "auto" || mode === "start" || mode === "steer") return mode;
-	throw new Error("mode must be auto, start, or steer");
+function currentCodexCatalogListDiagnostics() {
+	const observation = listScope.getStore();
+	return observation?.closed ? void 0 : observation;
 }
-function normalizeEndpointId(value, index) {
-	const trimmed = value.trim();
-	return trimmed ? trimmed.replace(/[^a-zA-Z0-9_.:-]/g, "-") : `endpoint-${index + 1}`;
+function startCodexCatalogListTiming(field, counter) {
+	const observation = currentCodexCatalogListDiagnostics();
+	const started = observation ? performance.now() : 0;
+	if (observation && counter) observation.fields[counter]++;
+	return () => {
+		if (observation && !observation.closed) observation.fields[field] = (observation.fields[field] ?? 0) + performance.now() - started;
+	};
 }
-function normalizeConfiguredEndpoint(endpoint, index) {
+/** One logical list scope survives admission pauses; finishing drops its captured context. */
+function createCodexCatalogListScope() {
+	const observation = start("list phases", {
+		controlPageCalls: 0,
+		exclusionMarkCalls: 0,
+		adoptionCalls: 0
+	});
+	let captured = listScope.run(observation, () => AsyncLocalStorage.snapshot());
 	return {
-		id: normalizeEndpointId(endpoint.id ?? endpoint.label ?? "", index),
-		...endpoint.label?.trim() ? { label: endpoint.label.trim() } : {},
-		configured: endpoint
+		run(run) {
+			if (!captured) throw new Error("Codex catalog diagnostic scope is closed");
+			return captured(run);
+		},
+		finish(outcome) {
+			const finishInScope = captured;
+			captured = void 0;
+			finishInScope?.(() => observation?.finish(outcome));
+		}
 	};
 }
-function parseEndpointRecord(value) {
-	if (!isRecord(value)) return;
-	const transport = typeof value.transport === "string" ? value.transport : void 0;
-	const common = {
-		...typeof value.id === "string" ? { id: value.id } : {},
-		...typeof value.label === "string" ? { label: value.label } : {}
+function startCodexCatalogPageDiagnostics(origin) {
+	return start("page producer", {
+		origin,
+		listOperationId: currentCodexCatalogListDiagnostics()?.operationId,
+		controlRequestCalls: 0,
+		provenanceChecks: 0,
+		provenanceCacheHits: 0,
+		provenanceReadCalls: 0
+	});
+}
+function startCodexCatalogControlRequestDiagnostics(page) {
+	if (!page) return;
+	let state = "active";
+	const controlCallOrdinal = page.fields.controlRequestCalls;
+	let phase = "load-control";
+	let phaseStarted = performance.now();
+	const finishPhase = () => {
+		const now = performance.now();
+		const field = CONTROL_PHASE_FIELDS[phase];
+		page.fields[field] = (page.fields[field] ?? 0) + (now - phaseStarted);
+		phaseStarted = now;
 	};
-	if (transport === "websocket" && typeof value.url === "string") return {
-		...common,
-		transport,
-		url: value.url,
-		...typeof value.authTokenEnv === "string" ? { authTokenEnv: value.authTokenEnv } : {}
+	const observation = {
+		attemptWaiterFinished(summary) {
+			if (state === "closed" || page.closed) return;
+			const kept = page.fields.controlWaitersV1 ??= [];
+			page.fields.controlWaitersOmitted ??= 0;
+			const tuple = controlWaiterTuple(controlCallOrdinal, summary);
+			if (!tuple) {
+				page.fields.controlWaitersOmitted = Math.min(Number.MAX_SAFE_INTEGER, page.fields.controlWaitersOmitted + 1);
+				return;
+			}
+			if (kept.length === 4) {
+				kept.splice(2, 1);
+				page.fields.controlWaitersOmitted = Math.min(Number.MAX_SAFE_INTEGER, page.fields.controlWaitersOmitted + 1);
+			}
+			kept.push(tuple);
+		},
+		phase(next) {
+			if (state === "active" && !page.closed) {
+				finishPhase();
+				phase = next;
+			}
+		},
+		failed(failure) {
+			if (state === "active" && !page.closed) {
+				finishPhase();
+				state = "failed";
+				page.fields.controlFailurePhase = failure.phase;
+				page.fields.controlFailureCategory = failure.category;
+			}
+		},
+		rejected() {
+			observation.failed({
+				phase,
+				category: "other"
+			});
+		},
+		close() {
+			if (state === "active" && !page.closed) finishPhase();
+			state = "closed";
+		}
 	};
-	if (transport === "stdio-proxy" || transport === void 0) {
-		const args = Array.isArray(value.args) ? value.args.filter((entry) => typeof entry === "string") : void 0;
+	return observation;
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-node-snapshot.ts
+/** One query-compatible native page per node, owned by the registered catalog provider. */
+var CodexCatalogNodeSnapshots = class {
+	constructor() {
+		this.generation = 0;
+		this.inventoryGeneration = 0;
+		this.configGeneration = 0;
+		this.nodes = /* @__PURE__ */ new Map();
+	}
+	start(config) {
+		if (this.config !== config) {
+			this.nodes.clear();
+			this.config = config;
+			this.configGeneration = this.generation + 1;
+			this.inventoryGeneration = this.configGeneration;
+		}
+		return ++this.generation;
+	}
+	observe(generation, nodes) {
+		if (generation < this.inventoryGeneration) return;
+		this.inventoryGeneration = generation;
+		const connected = new Map(nodes.filter((node) => node.connected).map((node) => [node.nodeId, node]));
+		for (const [nodeId, publication] of this.nodes) {
+			const node = connected.get(nodeId);
+			if (!node || node.connectedAtMs !== publication.connection) this.nodes.delete(nodeId);
+		}
+		for (const node of connected.values()) if (!this.nodes.has(node.nodeId)) this.nodes.set(node.nodeId, {
+			connection: node.connectedAtMs,
+			generation: 0
+		});
+	}
+	forNode(node, generation, key) {
+		let publication = this.nodes.get(node.nodeId);
+		if (!publication) {
+			publication = {
+				connection: node.connectedAtMs,
+				generation: 0
+			};
+			if (generation >= this.inventoryGeneration) this.nodes.set(node.nodeId, publication);
+		}
+		const valid = () => generation >= this.configGeneration && this.nodes.get(node.nodeId) === publication && publication.connection === node.connectedAtMs;
 		return {
-			...common,
-			transport: "stdio-proxy",
-			...typeof value.command === "string" ? { command: value.command } : {},
-			...args && args.length > 0 ? { args } : {},
-			...typeof value.cwd === "string" ? { cwd: value.cwd } : {}
+			read: () => valid() && publication.snapshot?.key === key ? publication.snapshot : void 0,
+			publish: (host) => {
+				if (!valid() || generation < publication.generation) return false;
+				publication.generation = generation;
+				publication.snapshot = node.connected && host.connected ? {
+					key,
+					host
+				} : void 0;
+				return true;
+			},
+			isCurrent: (snapshot) => valid() && publication.snapshot === snapshot,
+			valid
 		};
 	}
-}
-function endpointFromToken(token, index) {
-	const trimmed = token.trim();
-	if (!trimmed) return;
-	if (trimmed.startsWith("ws://") || trimmed.startsWith("wss://") || trimmed.startsWith("unix://")) return {
-		id: normalizeEndpointId("", index),
-		transport: "websocket",
-		url: trimmed
+};
+function createNodeHostPublication(publication, adopted, sourceKey, onHost, signal, partial, waitUntil) {
+	let publishedSnapshot;
+	let publishedHost;
+	const project = (host) => ({
+		...host,
+		sessions: host.sessions.map((session) => {
+			const entry = session.sourceHomeId ? adopted.get(sourceKey(host.hostId, session.threadId, session.sourceHomeId)) : void 0;
+			return entry ? {
+				...session,
+				sessionKey: entry.key
+			} : session;
+		})
+	});
+	const emit = (host) => {
+		publishedHost = project(host);
+		return onHost?.(publishedHost);
 	};
-	if (trimmed === "local" || trimmed === "proxy" || trimmed === "stdio") return {
-		id: "local",
-		label: "local Codex app-server",
-		transport: "stdio-proxy"
+	return {
+		project,
+		readPublished: () => publishedHost,
+		publish: (host) => {
+			if (signal?.aborted) return partial ? void 0 : onHost?.(project(host));
+			if (!publication.valid()) return;
+			if (publication.publish(host)) {
+				publishedSnapshot = publication.read();
+				return emit(host);
+			}
+			const latest = publication.read();
+			return emit(latest?.host ?? host);
+		},
+		publishCached: (snapshot) => {
+			if (signal?.aborted || snapshot === publishedSnapshot || !publication.isCurrent(snapshot)) return;
+			const completion = createDeferred();
+			completion.promise.catch(() => void 0);
+			try {
+				waitUntil?.(completion.promise);
+				completion.resolve(emit(snapshot.host));
+				publishedSnapshot = snapshot;
+			} catch (error) {
+				completion.reject(error);
+				throw error;
+			}
+		}
 	};
-	const separatorIndex = trimmed.indexOf("=");
-	const id = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex) : trimmed;
-	const url = separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1) : void 0;
-	if (url?.startsWith("ws://") || url?.startsWith("wss://") || url?.startsWith("unix://")) return {
-		id: normalizeEndpointId(id, index),
-		transport: "websocket",
-		url
+}
+//#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,
+		hasActiveWork: () => false,
+		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 requireUniqueEndpointIds(endpoints) {
-	const seen = /* @__PURE__ */ new Set();
+function resolveCodexCatalogTerminalHome(sources) {
+	sources.source?.assertCurrent();
+	const runtimeConfig = sources.getRuntimeConfig();
+	if (!runtimeConfig) throw new Error("OpenClaw runtime config is unavailable");
+	const agentDir = sources.source?.agentDir ?? (sources.agentId ? resolveAgentDir(runtimeConfig, sources.agentId) : resolveDefaultAgentDir(runtimeConfig));
+	const startOptions = sources.source?.appServer.start ?? sources.resolveRuntimeOptions({ pluginConfig: sources.getPluginConfig() }).start;
+	if (startOptions.transport !== "stdio") throw new CatalogParamsError("Native terminal requires a local Codex source");
+	return resolveCodexAppServerLocalHomeDir(startOptions, agentDir);
+}
+function resolveLocalCodexTerminalExecutable(env = process.env) {
+	return resolveLocalCodexTerminalResolution(env)?.executable;
+}
+function resolveLocalCodexTerminalResolution(env = process.env) {
+	return resolveNodeHostExecutable("codex", {
+		env,
+		pathEnv: env.PATH ?? env.Path ?? "",
+		strategy: "fallback"
+	});
+}
+function codexNodeTerminalCapability(node) {
+	const commands = node.invocableCommands ?? node.commands;
+	return {
+		canOpenTerminalCodex: node.connected === true && commands?.includes("codex.terminal.resume.v1") === true,
+		canStartTerminal: node.connected === true && node.invocableCommands?.includes("codex.terminal.start.v1") === true
+	};
+}
+function createCodexTerminalNodeHostCommand(bindRequest) {
+	return {
+		command: CODEX_TERMINAL_RESUME_COMMAND,
+		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+		dangerous: false,
+		duplex: true,
+		hasActiveWork: () => false,
+		isAvailable: ({ config, env }) => (readCodexPluginConfig(config.plugins?.entries?.codex?.config).appServer?.transport ?? "stdio") === "stdio" && Boolean(resolveNodeHostExecutable("codex", {
+			env,
+			pathEnv: env.PATH ?? env.Path ?? "",
+			strategy: "direct"
+		})),
+		handle: async (paramsJSON, io) => {
+			if (!io) throw new Error("Codex terminal command requires duplex transport");
+			const request = await bindRequest(paramsJSON);
+			if (request.transport !== "stdio") throw new CatalogParamsError("Native terminal requires a local Codex source");
+			const resume = decodeNodePtyResumeParams(request.paramsJSON, (value) => {
+				if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value)) throw new CatalogParamsError("threadId must be a UUID");
+				return value;
+			});
+			const record = await request.control.requireEligibleThread(resume.threadId);
+			const resolution = resolveNodeHostExecutable("codex", {
+				env: process.env,
+				pathEnv: process.env.PATH ?? process.env.Path ?? "",
+				strategy: "direct"
+			});
+			if (!resolution) throw new Error("Codex CLI is unavailable");
+			request.assertCurrent();
+			return JSON.stringify(await runNodePtyCommand({
+				file: resolution.executable,
+				args: ["resume", resume.threadId],
+				assertCurrent: () => request.assertCurrent(),
+				...record.cwd ? { cwd: record.cwd } : {},
+				env: { CODEX_HOME: request.codexHome },
+				cols: resume.cols,
+				rows: resume.rows
+			}, io));
+		}
+	};
+}
+async function openCodexCatalogTerminal(params) {
+	const title = `codex resume ${params.threadId.slice(0, 8)}…`;
+	if (params.hostId === "gateway:local" || params.hostId.startsWith(`gateway:local:`)) {
+		const record = await params.control.requireEligibleThread(params.threadId);
+		const resolution = resolveLocalCodexTerminalResolution();
+		if (!resolution) throw new CatalogParamsError("Codex CLI is unavailable");
+		return {
+			kind: "local",
+			argv: [
+				resolution.executable,
+				"resume",
+				params.threadId
+			],
+			...record.cwd ? { cwd: record.cwd } : {},
+			env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
+			...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
+			title
+		};
+	}
+	if (!params.hostId.startsWith("node:")) throw new CatalogParamsError("hostId is invalid");
+	const nodeId = params.hostId.slice(5);
+	if (!(await params.api.runtime.nodes.list()).nodes.find((candidate) => {
+		const commands = candidate.invocableCommands ?? candidate.commands;
+		return candidate.nodeId === nodeId && candidate.connected === true && commands?.includes("codex.appServer.threads.list.v1") === true && commands.includes("codex.terminal.resume.v1");
+	})) throw new CatalogParamsError("paired-node Codex terminal is unavailable");
+	const lookup = await lookupNodeCodexCatalogRecord({
+		agentId: params.agentId,
+		runtime: params.api.runtime,
+		nodeId,
+		threadId: params.threadId,
+		sourceHomeId: params.sourceHomeId
+	});
+	if (lookup.kind !== "found" || !isInteractiveThreadSource(lookup.record.source)) throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+	const record = lookup.record;
+	return {
+		kind: "node",
+		nodeId,
+		command: CODEX_TERMINAL_RESUME_COMMAND,
+		uploadPathStyle: "native",
+		paramsJSON: JSON.stringify({
+			agentId: params.agentId,
+			threadId: params.threadId,
+			...lookup.sourceHomeId ? { sourceHomeId: lookup.sourceHomeId } : {}
+		}),
+		...record.cwd ? { cwd: record.cwd } : {},
+		title
+	};
+}
+async function startCodexCatalogTerminal(params) {
+	if (params.nodeId) return {
+		kind: "node",
+		nodeId: params.nodeId,
+		command: CODEX_TERMINAL_START_COMMAND,
+		uploadPathStyle: "native",
+		paramsJSON: JSON.stringify({
+			cwd: params.cwd,
+			initialMessage: params.initialMessage
+		}),
+		cwd: params.cwd,
+		title: "codex"
+	};
+	const resolution = resolveLocalCodexTerminalResolution();
+	if (!resolution) throw new CatalogParamsError("Codex CLI is unavailable; install Codex or add codex to PATH, then try again");
+	return {
+		kind: "local",
+		argv: [resolution.executable, ...params.initialMessage !== void 0 ? ["--", params.initialMessage] : []],
+		cwd: params.cwd,
+		env: { CODEX_HOME: resolveCodexCatalogTerminalHome(params) },
+		...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
+		title: "codex"
+	};
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-visible-page.ts
+/** Fill exclusions from bounded resident pages. */
+var CodexCatalogVisiblePage = class {
+	constructor(params) {
+		this.params = params;
+		this.sessions = [];
+		this.seenCursors = /* @__PURE__ */ new Set();
+		this.pages = 0;
+		this.complete = false;
+		this.request = new CodexCatalogListRequest();
+		this.cursor = params.cursor;
+	}
+	async next() {
+		try {
+			const step = await this.request.run(() => this.nextPage());
+			if (step.done) this.request.resolved();
+			return step;
+		} catch (error) {
+			if (this.params.signal?.aborted) this.request.close();
+			else this.request.rejected(error);
+			throw error;
+		}
+	}
+	close() {
+		this.complete = true;
+		this.request.close();
+	}
+	async nextPage() {
+		if (this.complete) throw new Error("Codex catalog page is already complete");
+		const params = this.params;
+		params.signal?.throwIfAborted();
+		const finishTiming = startCodexCatalogListTiming("controlWaitSumMs", "controlPageCalls");
+		let rawPage;
+		try {
+			rawPage = await params.control.listPage({
+				limit: params.limit - this.sessions.length,
+				...this.cursor ? { cursor: this.cursor } : {},
+				...params.searchTerm ? { searchTerm: params.searchTerm } : {},
+				...params.cwd ? { cwd: params.cwd } : {}
+			});
+		} finally {
+			finishTiming();
+		}
+		this.request.assertActive();
+		params.signal?.throwIfAborted();
+		const page = filterCatalogPageByTitle(parseCatalogPage(rawPage), params.searchTerm);
+		if (this.pages++ === 0) this.backwardsCursor = page.backwardsCursor;
+		let excludedFromPage = false;
+		for (const managed of rawPage.managedThreads ?? []) {
+			excludedFromPage = true;
+			params.signal?.throwIfAborted();
+			await params.onExcludedThread?.(managed);
+		}
+		for (const session of page.sessions) {
+			if (!params.excludedThreadIds?.has(session.threadId)) {
+				this.sessions.push(session);
+				continue;
+			}
+			excludedFromPage = true;
+			params.signal?.throwIfAborted();
+			await params.onExcludedThread?.({ threadId: session.threadId });
+		}
+		const nextCursor = page.nextCursor;
+		if (!nextCursor || this.sessions.length >= params.limit || !excludedFromPage) this.complete = true;
+		else {
+			if (this.seenCursors.has(nextCursor)) throw new Error("Codex session catalog returned a repeated exclusion cursor");
+			this.seenCursors.add(nextCursor);
+			this.cursor = nextCursor;
+			this.complete = this.pages >= 20 || !this.request.hasPages;
+		}
+		return this.complete ? {
+			done: true,
+			page: {
+				sessions: this.sessions.slice(0, params.limit),
+				...nextCursor ? { nextCursor } : {},
+				...this.backwardsCursor ? { backwardsCursor: this.backwardsCursor } : {}
+			}
+		} : { done: false };
+	}
+};
+/** Node and direct callers finish the same bounded outer algorithm inline. */
+async function listVisiblePage(params) {
+	const operation = new CodexCatalogVisiblePage(params);
+	try {
+		for (;;) {
+			const step = await operation.next();
+			if (step.done) return step.page;
+		}
+	} finally {
+		operation.close();
+	}
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-list-operation.ts
+async function boundedHost(pending) {
+	return await raceWithTimeout(pending, 250, () => void 0);
+}
+function measureNodeHost(host, diagnostics, started) {
+	return diagnostics ? host.finally(() => {
+		if (!diagnostics.closed) {
+			diagnostics.fields.pairedNodeSettled = (diagnostics.fields.pairedNodeSettled ?? 0) + 1;
+			diagnostics.fields.nodeWaitSumMs = (diagnostics.fields.nodeWaitSumMs ?? 0) + performance.now() - started;
+		}
+	}) : host;
+}
+function hostFailure(source, error) {
+	return {
+		hostId: source?.hostId ?? "gateway:local",
+		label: source?.label ?? "Local Codex",
+		kind: "gateway",
+		connected: false,
+		sessions: [],
+		error: error instanceof CodexCatalogLoadingError ? {
+			code: error.code,
+			message: error.message
+		} : catalogError("APP_SERVER_UNAVAILABLE", error)
+	};
+}
+async function projectLocalHost(params, agentId, source, page) {
+	params.signal?.throwIfAborted();
+	const { listAdoptedSessionEntries } = await import("./.setup/session-catalog-adoption-CPIP4S_y.mjs");
+	const { sessionCatalogAdoptedSourceKey } = await import("openclaw/plugin-sdk/session-catalog");
+	params.signal?.throwIfAborted();
+	const finishTiming = startCodexCatalogListTiming("adoptionSumMs", "adoptionCalls");
+	let adopted;
+	try {
+		adopted = await listAdoptedSessionEntries({
+			agentId,
+			bindingStore: params.bindingStore,
+			config: params.config,
+			runtime: params.runtime,
+			sessionEntries: params.sessionEntries
+		});
+	} finally {
+		finishTiming();
+	}
+	const hostId = source?.hostId ?? "gateway:local";
+	const sourceHomeId = source?.sourceHomeId ?? "gateway:local";
+	return {
+		hostId,
+		label: source?.label ?? "Local Codex",
+		kind: "gateway",
+		connected: true,
+		...page,
+		sessions: page.sessions.map((session) => {
+			const entry = adopted.get(sessionCatalogAdoptedSourceKey(sourceHomeId, session.threadId)) ?? (hostId === "gateway:local" ? adopted.get(sessionCatalogAdoptedSourceKey("gateway:local", session.threadId)) : void 0);
+			const sourced = source ? {
+				...session,
+				sourceHomeId: source.sourceHomeId
+			} : session;
+			return entry ? {
+				...sourced,
+				sessionKey: entry.key
+			} : sourced;
+		})
+	};
+}
+function managedMarker(store, sourceHomeId, managed) {
+	return async ({ threadId, rolloutPath }) => {
+		if (managed?.has(threadId)) return;
+		const finishTiming = startCodexCatalogListTiming("exclusionMarkSumMs", "exclusionMarkCalls");
+		try {
+			await store.mark({
+				sourceHomeId,
+				threadId,
+				...rolloutPath ? { rolloutPath } : {}
+			});
+		} finally {
+			finishTiming();
+		}
+	};
+}
+async function finishLocalHost(params, agentId, host) {
+	try {
+		for (;;) {
+			const step = await host.page.next();
+			params.signal?.throwIfAborted();
+			if (step.done) return await projectLocalHost(params, agentId, host.source, step.page);
+		}
+	} catch (error) {
+		return hostFailure(host.source, error);
+	} finally {
+		host.page.close();
+	}
+}
+function createNodePublicationTracker(publications, waitUntil) {
+	const settled = () => {
+		publications.pending--;
+	};
+	return (completion) => {
+		publications.pending++;
+		completion.then(settled, settled);
+		waitUntil?.(completion);
+	};
+}
+/** Holds only one logical filled list; no native producer is suspended between next calls. */
+var CodexCatalogListDriver = class {
+	constructor(params) {
+		this.locals = [];
+		this.nodeActive = false;
+		this.nodeResults = [];
+		this.nodeDiscoveryFailed = false;
+		this.nodePublications = { pending: 0 };
+		this.nodesStarted = false;
+		this.localFailed = false;
+		this.active = 0;
+		this.running = false;
+		this.complete = false;
+		this.params = params;
+		this.nodeSnapshots = params.nodeSnapshots ?? new CodexCatalogNodeSnapshots();
+		this.nodeGeneration = this.nodeSnapshots.start(params.config);
+	}
+	request() {
+		if (!this.params) throw new Error("Codex catalog list operation is closed");
+		return this.params;
+	}
+	selection() {
+		if (!this.prepared) throw new Error("Codex catalog list operation is not initialized");
+		return this.prepared;
+	}
+	async initialize() {
+		const params = this.request();
+		const agentId = resolveSessionAgentIdsStrict({
+			config: params.config ?? {},
+			agentId: params.agentId
+		}).sessionAgentId;
+		const query = readGatewayParams(params.query);
+		const requestedHostIds = query.hostIds ? new Set(query.hostIds) : void 0;
+		const localSources = params.localHomes?.filter((source) => !requestedHostIds || requestedHostIds.has(source.hostId)) ?? (params.includeLocal !== false && (!requestedHostIds || requestedHostIds.has("gateway:local")) ? [void 0] : []);
+		const diagnostics = currentCodexCatalogListDiagnostics();
+		if (diagnostics) diagnostics.fields.localHostCount = localSources.length;
+		const store = params.bindingStore.managedThreads;
+		const started = diagnostics && store ? performance.now() : 0;
+		let managed;
+		try {
+			managed = await store?.snapshot();
+		} finally {
+			if (diagnostics && !diagnostics.closed && store) diagnostics.fields.managedSnapshotMs = performance.now() - started;
+		}
+		params.signal?.throwIfAborted();
+		const fallback = localSources.some((source) => source === void 0) ? (await params.control.homesForAgent(agentId))[0] : void 0;
+		params.signal?.throwIfAborted();
+		this.prepared = {
+			agentId,
+			query,
+			requestedHostIds
+		};
+		if (requestedHostIds && !query.hostIds?.some((host) => host.startsWith("node:"))) this.nodeHosts = [];
+		for (const source of localSources) {
+			const selected = source ?? fallback;
+			const excluded = selected ? managed?.get(selected.sourceHomeId) : void 0;
+			const host = {
+				source,
+				page: new CodexCatalogVisiblePage({
+					control: params.control.forRequest(agentId, selected),
+					cursor: query.cursors?.[source?.hostId ?? "gateway:local"],
+					limit: query.limitPerHost,
+					excludedThreadIds: excluded,
+					searchTerm: query.search,
+					signal: params.signal,
+					...selected && store ? { onExcludedThread: managedMarker(store, selected.sourceHomeId, excluded) } : {}
+				}),
+				completion: createDeferred()
+			};
+			this.locals.push(host);
+			publishSessionCatalogHost(params, host.completion.promise);
+		}
+	}
+	canPause() {
+		return !this.localFailed && this.nodeHosts !== void 0 && !this.nodeDiscoveryFailed && !this.nodeActive && this.nodePublications.pending === 0;
+	}
+	async readHost(host) {
+		const params = this.request();
+		if (params.allowPartialResults === true && params.onHost && params.waitUntil) {
+			host.background = true;
+			const completion = finishLocalHost(params, this.selection().agentId, host);
+			completion.then(host.completion.resolve, host.completion.reject);
+			host.value = await boundedHost(completion) ?? {
+				hostId: host.source?.hostId ?? "gateway:local",
+				label: host.source?.label ?? "Local Codex",
+				kind: "gateway",
+				connected: true,
+				pending: true,
+				sessions: []
+			};
+			return;
+		}
+		try {
+			const page = await host.page.next();
+			params.signal?.throwIfAborted();
+			if (page.done) host.value = await projectLocalHost(params, this.selection().agentId, host.source, page.page);
+		} catch (error) {
+			this.localFailed = true;
+			host.value = hostFailure(host.source, error);
+		}
+		if (host.value) host.completion.resolve(host.value);
+	}
+	startHost(host) {
+		if (host.value || host.active || this.failure) return;
+		this.active++;
+		host.active = this.readHost(host).then(() => {
+			host.active = void 0;
+			this.active--;
+			if (!host.value && (!this.canPause() || this.active > 0)) this.startHost(host);
+			this.checkpoint();
+		}, (error) => {
+			host.active = void 0;
+			this.active--;
+			this.failure ??= { error };
+			this.checkpoint();
+		});
+	}
+	async readNodes() {
+		const params = this.request();
+		const { agentId, query, requestedHostIds } = this.selection();
+		const diagnostics = currentCodexCatalogListDiagnostics();
+		const started = diagnostics ? performance.now() : 0;
+		if (diagnostics) diagnostics.fields.nodeRegistryCalls = 1;
+		let nodes;
+		let inventory;
+		try {
+			try {
+				inventory = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes;
+				nodes = inventory.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 - this.locals.length);
+			} finally {
+				if (diagnostics && !diagnostics.closed) diagnostics.fields.nodeRegistryMs = performance.now() - started;
+			}
+		} catch (error) {
+			this.nodeDiscoveryFailed = true;
+			const host = {
+				hostId: "node:registry",
+				label: "Paired nodes",
+				kind: "node",
+				connected: false,
+				canStartTerminal: false,
+				sessions: [],
+				error: catalogError("NODE_LIST_FAILED", error)
+			};
+			params.onHost?.(host);
+			return [host];
+		}
+		params.signal?.throwIfAborted();
+		this.nodeSnapshots.observe(this.nodeGeneration, inventory);
+		const { listNodeAdoptedSessionEntries, nodeAdoptedSourceKey } = await import("./.setup/session-catalog-node-adoption-7-WEQTB1.mjs");
+		const { compareNodeLabels, listPairedNode, nodeLabel } = await import("./.setup/session-catalog-node-continue-DLWBwAAO.mjs");
+		params.signal?.throwIfAborted();
+		const adopted = listNodeAdoptedSessionEntries({
+			agentId,
+			config: params.config,
+			runtime: params.runtime,
+			sessionEntries: params.sessionEntries
+		});
+		if (diagnostics && !diagnostics.closed) {
+			diagnostics.fields.pairedNodeCalls = 0;
+			diagnostics.fields.pairedNodeSettled = 0;
+		}
+		const trackPublication = createNodePublicationTracker(this.nodePublications, params.waitUntil);
+		const partial = params.allowPartialResults === true && Boolean(params.onHost && params.waitUntil);
+		const pendingHosts = nodes.toSorted(compareNodeLabels).map((node) => {
+			const key = JSON.stringify([
+				agentId,
+				query.limitPerHost,
+				query.search,
+				query.cursors?.[`node:${node.nodeId}`],
+				node.displayName,
+				node.remoteIp,
+				node.caps,
+				node.commands,
+				node.invocableCommands
+			]);
+			const publication = this.nodeSnapshots.forNode(node, this.nodeGeneration, key);
+			const { project, publish, publishCached, readPublished } = createNodeHostPublication(publication, adopted, nodeAdoptedSourceKey, params.onHost, params.signal, partial, trackPublication);
+			const cached = partial ? publication.read() : void 0;
+			let result;
+			this.nodeResults.push(() => {
+				const latest = partial ? publication.read() : void 0;
+				if (latest) {
+					publishCached(latest);
+					return project(latest.host);
+				}
+				return !partial ? result : publication.valid() ? readPublished() ?? result : void 0;
+			});
+			if (cached) publishCached(cached);
+			const nodeStarted = diagnostics ? performance.now() : 0;
+			if (diagnostics && !diagnostics.closed) diagnostics.fields.pairedNodeCalls = (diagnostics.fields.pairedNodeCalls ?? 0) + 1;
+			const completion = measureNodeHost(listPairedNode({
+				agentId,
+				runtime: params.runtime,
+				node,
+				query,
+				terminalCapabilities: codexNodeTerminalCapability(node),
+				waitUntil: trackPublication,
+				signal: params.signal,
+				onHost: publish
+			}), diagnostics, nodeStarted);
+			if (cached) {
+				completion.catch(() => void 0);
+				return Promise.resolve(project(cached.host));
+			}
+			return (partial ? boundedHost(completion) : completion).then((value) => {
+				result = value ? project(value) : {
+					hostId: `node:${node.nodeId}`,
+					label: nodeLabel(node),
+					kind: "node",
+					nodeId: node.nodeId,
+					connected: true,
+					pending: true,
+					...codexNodeTerminalCapability(node),
+					sessions: []
+				};
+				return result;
+			});
+		});
+		try {
+			return await Promise.all(pendingHosts);
+		} catch (error) {
+			await Promise.allSettled(pendingHosts);
+			throw error;
+		}
+	}
+	startNodes() {
+		if (this.nodeHosts !== void 0 || this.nodesStarted) return;
+		this.nodesStarted = true;
+		this.nodeActive = true;
+		this.readNodes().then((hosts) => {
+			this.nodeHosts = hosts;
+			this.nodeActive = false;
+			this.checkpoint();
+		}, (error) => {
+			this.nodeActive = false;
+			this.failure ??= { error };
+			this.checkpoint();
+		});
+	}
+	checkpoint() {
+		if (this.active > 0 || !this.step) return;
+		if (this.failure) {
+			if (!this.nodeActive) this.step.reject(this.failure.error);
+		} else if (this.nodeHosts && this.locals.every((host) => host.value !== void 0)) try {
+			this.complete = true;
+			this.step.resolve({
+				done: true,
+				hosts: [...this.locals.flatMap((host) => host.value ? [host.value] : []), ...this.nodeResults.length ? this.nodeResults.flatMap((read) => {
+					const host = read();
+					return host ? [host] : [];
+				}) : this.nodeHosts]
+			});
+		} catch (error) {
+			this.failure ??= { error };
+			this.step.reject(error);
+		}
+		else if (this.canPause()) this.step.resolve({ done: false });
+	}
+	async next() {
+		const params = this.request();
+		if (this.running || this.complete) throw new Error("Codex catalog list operation cannot advance");
+		params.signal?.throwIfAborted();
+		this.running = true;
+		try {
+			if (!this.prepared) await this.initialize();
+			this.step = createDeferred();
+			for (const host of this.locals) this.startHost(host);
+			this.startNodes();
+			this.checkpoint();
+			return await this.step.promise;
+		} finally {
+			this.running = false;
+			this.step = void 0;
+		}
+	}
+	close() {
+		if (!this.params) return;
+		if (this.running) throw new Error("Cannot close an active Codex catalog list step");
+		const reason = this.failure?.error ?? this.params.signal?.reason ?? /* @__PURE__ */ new Error("Codex catalog list operation closed");
+		this.params = void 0;
+		for (const host of this.locals) {
+			if (!host.background) host.page.close();
+			if (!host.value) host.completion.reject(reason);
+		}
+		this.locals = [];
+		this.prepared = void 0;
+		this.nodeHosts = void 0;
+		this.nodeResults = [];
+		this.failure = void 0;
+	}
+};
+function createCodexSessionCatalogListOperation(params) {
+	const driver = new CodexCatalogListDriver(params);
+	return {
+		next: () => driver.next(),
+		close: () => driver.close()
+	};
+}
+async function runCatalogListInline(operation) {
+	try {
+		for (;;) {
+			const step = await operation.next();
+			if (step.done) return step.hosts;
+		}
+	} finally {
+		operation.close();
+	}
+}
+//#endregion
+//#region extensions/codex/src/app-server/thread-history-page.ts
+const TURN_ITEM_CURSOR_PREFIX = "turn-item:";
+function encodeTurnItemCursor(turnCursor, itemId) {
+	return TURN_ITEM_CURSOR_PREFIX + Buffer.from(JSON.stringify([turnCursor, itemId])).toString("base64url");
+}
+function decodeTurnItemCursor(cursor) {
+	if (!cursor?.startsWith(TURN_ITEM_CURSOR_PREFIX)) return { turnCursor: cursor };
+	let value;
+	try {
+		value = JSON.parse(Buffer.from(cursor.slice(10), "base64url").toString());
+	} catch {
+		throw new CatalogParamsError("invalid Codex transcript item cursor");
+	}
+	if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !value[0] || typeof value[1] !== "string" || !value[1]) throw new CatalogParamsError("invalid Codex transcript item cursor");
+	return {
+		turnCursor: value[0],
+		itemId: value[1]
+	};
+}
+/** Legacy stores expose only turn cursors; an item identity preserves paging across appends. */
+async function readLegacyCodexHistoryPage(readTurns, request, projection) {
+	const { turnCursor, itemId } = decodeTurnItemCursor(request.cursor);
+	const page = parseTranscriptPage(await readTurns({
+		threadId: request.threadId,
+		limit: 1,
+		sortDirection: "desc",
+		itemsView: "full",
+		...turnCursor ? { cursor: turnCursor } : {}
+	}));
+	const source = page.data.flatMap(({ items, ...turn }) => items.toReversed().map((item) => ({
+		turnId: turn.id,
+		item,
+		turn
+	})));
+	const anchorIndex = itemId ? source.findIndex(({ item }) => item.id === itemId) : -1;
+	if (itemId && anchorIndex < 0) throw new CatalogParamsError("Codex transcript changed; refresh the session before loading older items");
+	const remaining = source.slice(anchorIndex + 1);
+	const items = projection.project(remaining.slice(0, request.limit), request.limit);
+	const result = () => {
+		const lastSource = remaining[items.length - 1];
+		const partial = lastSource !== void 0 && items.length < remaining.length;
+		const nativeCursor = partial ? page.backwardsCursor : page.nextCursor;
+		const cursor = nativeCursor ? partial ? encodeTurnItemCursor(nativeCursor, lastSource.item.id) : nativeCursor : void 0;
+		if (partial && !cursor) throw new Error("Codex app-server did not provide a transcript continuation anchor");
+		return {
+			items,
+			...cursor ? { nextCursor: cursor } : {}
+		};
+	};
+	let bounded = result();
+	while (!projection.fits(bounded)) {
+		if (items.length <= 1) throw new Error("Codex transcript item exceeds the safe response size");
+		items.pop();
+		bounded = result();
+	}
+	return bounded;
+}
+/** Callers authorize the thread; this reader owns native cursor and response-size semantics. */
+async function readCodexThreadHistoryPage(control, thread, request, projection) {
+	if (thread.historyMode !== "paginated") return readLegacyCodexHistoryPage((params) => control.listTurnPage(params), request, projection);
+	let limit = request.limit;
+	for (;;) {
+		const page = await control.listItemPage({
+			threadId: request.threadId,
+			limit,
+			sortDirection: "desc",
+			...request.cursor ? { cursor: request.cursor } : {}
+		});
+		const nextCursor = readControlCursor(page.nextCursor, "transcript next response");
+		const items = projection.project(page.data, limit);
+		const result = {
+			items,
+			...nextCursor ? { nextCursor } : {}
+		};
+		const fittingCount = items.length - (projection.fits(result) ? 0 : 1);
+		if (fittingCount === page.data.length) return result;
+		if (fittingCount < 1) throw new Error("Codex transcript item exceeds the safe response size");
+		limit = fittingCount;
+	}
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-transcript-item.ts
+const CODEX_MESSAGE_TYPES = /* @__PURE__ */ new Map([
+	["userMessage", "userMessage"],
+	["agentMessage", "agentMessage"],
+	["reasoning", "reasoning"]
+]);
+const CODEX_TOOL_TYPES = /* @__PURE__ */ new Set([
+	"commandExecution",
+	"fileChange",
+	"mcpToolCall",
+	"dynamicToolCall",
+	"collabAgentToolCall",
+	"webSearch",
+	"imageView",
+	"imageGeneration"
+]);
+function toGenericTranscriptItem(item) {
+	let type = CODEX_MESSAGE_TYPES.get(item.type);
+	if (!type && CODEX_TOOL_TYPES.has(item.type)) type = item.result !== void 0 || Boolean(item.aggregatedOutput) ? "toolResult" : "toolCall";
+	type ??= "other";
+	const fallback = item.title ?? item.name ?? item.tool ?? item.command ?? item.query ?? void 0;
+	const resultText = item.aggregatedOutput || (item.result === void 0 ? void 0 : JSON.stringify(item.result, null, 2));
+	const changesText = Array.isArray(item.changes) ? item.changes.map((change) => `${change.kind}: ${change.path}`).join("\n") || void 0 : void 0;
+	const text = item.type === "userMessage" ? projectCodexUserItemText(item) : item.text || resultText || changesText || fallback;
+	return {
+		id: item.id,
+		type,
+		...text ? { text } : {},
+		raw: item
+	};
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-transcript.ts
+const transcriptPageSchema = z.strictObject({
+	items: z.array(z.strictObject({
+		id: z.string(),
+		type: z.enum([
+			"userMessage",
+			"agentMessage",
+			"reasoning",
+			"toolCall",
+			"toolResult",
+			"other"
+		]),
+		text: z.string().optional(),
+		raw: z.record(z.string(), z.json()).optional(),
+		truncated: z.boolean().optional()
+	})),
+	nextCursor: z.string().optional()
+});
+function parseCodexCatalogTranscriptPage(value) {
+	return transcriptPageSchema.parse(value);
+}
+function projectTranscriptPage(entries, limit) {
+	const projected = entries.map(({ item }) => toGenericTranscriptItem(item));
+	const page = sessionCatalogPaging.boundTranscriptPage(projected.toReversed(), limit, 0).items;
+	for (const [index, item] of page.entries()) if (item.text !== projected[index]?.text && projected[index]?.text) item.truncated = true;
+	return page;
+}
+function pageFitsNodeTransport(page) {
+	return Buffer.byteLength(JSON.stringify({ payloadJSON: JSON.stringify(page) }), "utf8") <= MAX_TRANSCRIPT_PAGE_BYTES;
+}
+/** The legacy API can anchor a turn, but cannot continue within that turn. */
+async function readLegacyCodexTranscriptPage(readTurns, request) {
+	return readLegacyCodexHistoryPage(readTurns, request, {
+		project: projectTranscriptPage,
+		fits: pageFitsNodeTransport
+	});
+}
+/** Uses the native store's item cursor whenever that store supports item history. */
+async function readCodexCatalogTranscriptPage(control, request) {
+	return readCodexThreadHistoryPage(control, await control.requireEligibleThread(request.threadId), request, {
+		project: projectTranscriptPage,
+		fits: pageFitsNodeTransport
+	});
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-listing.ts
+/** Builds the node-local read-only Codex app-server catalog command. */
+function createCodexSessionCatalogNodeHostCommands(controlFactory, bindingStore) {
+	const bindRequest = async (paramsJSON) => {
+		const parsed = parseJsonParams(paramsJSON);
+		if (!isRecord(parsed)) throw new CatalogParamsError("Codex session catalog parameters must be an object");
+		const agentId = readBoundedOptionalString(parsed, "agentId", 256);
+		const sourceHomeId = readBoundedOptionalString(parsed, "sourceHomeId", 256);
+		const source = await controlFactory.forNode(agentId);
+		if (sourceHomeId && sourceHomeId !== source.sourceHomeId) throw new CatalogParamsError("Codex catalog source home changed. Reopen the session from the catalog.");
+		const request = { ...parsed };
+		delete request.agentId;
+		delete request.sourceHomeId;
+		return {
+			...source,
+			params: request,
+			paramsJSON: JSON.stringify(request)
+		};
+	};
+	const transcriptCommand = (command, read) => ({
+		command,
+		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+		dangerous: false,
+		hasActiveWork: controlFactory.hasActiveWork,
+		onDisconnect: controlFactory.disconnect,
+		handle: async (paramsJSON) => {
+			const request = await bindRequest(paramsJSON);
+			const action = readNodeTranscriptParams(request.params);
+			try {
+				return JSON.stringify(await read(request.control, action));
+			} catch (error) {
+				if (error instanceof CatalogParamsError) throw error;
+				throw new Error("Codex app-server transcript is unavailable", { cause: error });
+			}
+		}
+	});
+	const commands = [
+		{
+			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+			dangerous: false,
+			hasActiveWork: controlFactory.hasActiveWork,
+			onDisconnect: controlFactory.disconnect,
+			handle: async (paramsJSON) => {
+				const request = await bindRequest(paramsJSON);
+				const pageParams = readPageParams(request.params);
+				try {
+					const managedThreads = await bindingStore?.managedThreads?.snapshot();
+					const sourceHomeId = request.sourceHomeId;
+					const managedThreadIds = sourceHomeId ? managedThreads?.get(sourceHomeId) : void 0;
+					const page = await listVisiblePage({
+						control: request.control,
+						cursor: pageParams.cursor,
+						cwd: pageParams.cwd,
+						excludedThreadIds: managedThreadIds,
+						limit: pageParams.limit,
+						...sourceHomeId && bindingStore?.managedThreads ? { onExcludedThread: async ({ threadId, rolloutPath }) => {
+							if (!managedThreadIds?.has(threadId)) await bindingStore.managedThreads?.mark({
+								sourceHomeId,
+								threadId,
+								...rolloutPath ? { rolloutPath } : {}
+							});
+						} } : {},
+						searchTerm: pageParams.searchTerm
+					});
+					return JSON.stringify({
+						...page,
+						sourceHomeId: request.sourceHomeId,
+						canContinueCodex: request.transport === "stdio"
+					});
+				} catch {
+					throw new Error("Codex app-server catalog is unavailable");
+				}
+			}
+		},
+		transcriptCommand(CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, async (control, action) => {
+			await control.requireEligibleThread(action.threadId);
+			return parseTranscriptPage(await control.listTurnPage({
+				threadId: action.threadId,
+				limit: action.limit,
+				sortDirection: "desc",
+				itemsView: "full",
+				...action.cursor ? { cursor: action.cursor } : {}
+			}));
+		}),
+		transcriptCommand(CODEX_CATALOG_TRANSCRIPT_READ_COMMAND, readCodexCatalogTranscriptPage),
+		createCodexTerminalNodeHostCommand(bindRequest),
+		createCodexTerminalStartNodeHostCommand()
+	];
+	return process.env.OPENCLAW_NODE_EXEC_HOST?.trim().toLowerCase() === "app" ? commands.filter(({ command }) => command !== CODEX_CATALOG_TRANSCRIPT_READ_COMMAND) : commands;
+}
+function readNodeTranscriptParams(value) {
+	requireOnlyKeys(value, /* @__PURE__ */ new Set([
+		"threadId",
+		"cursor",
+		"limit"
+	]));
+	const threadId = readBoundedOptionalString(value, "threadId", 256);
+	if (!threadId) throw new CatalogParamsError("threadId is required");
+	const cursor = readBoundedOptionalString(value, "cursor", MAX_CURSOR_LENGTH);
+	return {
+		threadId,
+		limit: normalizeLimit(value.limit, "limit", 20, 50),
+		...cursor ? { cursor } : {}
+	};
+}
+/** Reads the persisted transcript for a Gateway-local or paired-node Codex session. */
+async function readCodexSessionTranscript(params) {
+	const cursor = readControlCursor(params.cursor, "transcript request");
+	const limit = normalizeLimit(params.limit, "limit", 20, 50);
+	if (params.source || params.hostId === "gateway:local") {
+		const page = await readCodexCatalogTranscriptPage(params.control, {
+			threadId: params.threadId,
+			limit,
+			cursor
+		});
+		return {
+			hostId: params.hostId,
+			label: params.source?.label ?? "Local Codex",
+			threadId: params.threadId,
+			...page
+		};
+	}
+	const nodeId = params.hostId.slice(5);
+	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId && candidate.connected === true && candidate.commands?.includes("codex.appServer.thread.turns.list.v1"));
+	if (!node) throw new CatalogParamsError("paired-node Codex session host is offline or unavailable");
+	const invoke = async (command, request) => unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+		nodeId,
+		command,
+		params: {
+			agentId: params.agentId,
+			threadId: params.threadId,
+			...params.sourceHomeId ? { sourceHomeId: params.sourceHomeId } : {},
+			...request
+		},
+		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+		scopes: ["operator.write"]
+	}));
+	const page = node.commands?.includes("codex.sessionCatalog.transcript.read.v1") ? parseCodexCatalogTranscriptPage(await invoke(CODEX_CATALOG_TRANSCRIPT_READ_COMMAND, {
+		cursor,
+		limit
+	})) : await readLegacyCodexTranscriptPage(async ({ cursor: turnCursor, limit: turnLimit }) => parseTranscriptPage(await invoke(CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, {
+		cursor: turnCursor,
+		limit: turnLimit
+	})), {
+		threadId: params.threadId,
+		cursor,
+		limit
+	});
+	const { nodeLabel } = await import("./.setup/session-catalog-node-continue-DLWBwAAO.mjs");
+	return {
+		hostId: params.hostId,
+		label: nodeLabel(node),
+		threadId: params.threadId,
+		...page
+	};
+}
+//#endregion
+//#region extensions/codex/src/session-upstream-activity.ts
+const CODEX_UPSTREAM_TURN_LIMIT = 100;
+function readMarker(probe) {
+	if (!isRecord(probe.marker)) return;
+	const turnId = probe.marker.turnId;
+	if (turnId !== null && typeof turnId !== "string") return;
+	const count = probe.marker.userMessageCount;
+	if (count !== void 0 && (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0)) return;
+	return {
+		turnId,
+		...count === void 0 ? {} : { userMessageCount: count }
+	};
+}
+function upstreamConnectionFingerprint(probe) {
+	return isRecord(probe.upstreamRef) && typeof probe.upstreamRef.connectionFingerprint === "string" ? probe.upstreamRef.connectionFingerprint : void 0;
+}
+function classifyCodexUpstreamTurns(params) {
+	const marker = readMarker(params.probe);
+	if (!marker) return;
+	const newest = params.turns[0];
+	if (!newest?.id) return;
+	const markerIndex = marker.turnId === null ? -1 : params.turns.findIndex((turn) => turn.id === marker.turnId);
+	const candidateTurns = markerIndex < 0 ? params.turns : params.turns.slice(0, markerIndex + 1);
+	const newestUserMessageCount = newest.items.filter((item) => item.type === "userMessage").length;
+	if (!(marker.turnId !== newest.id || marker.userMessageCount === void 0 || newestUserMessageCount > marker.userMessageCount)) return;
+	const ownTexts = new Set(params.probe.ownRecentUserTexts);
+	let humanTurns = 0;
+	let occurredAt;
+	for (const turn of candidateTurns) {
+		const userMessages = turn.items.filter((item) => item.type === "userMessage");
+		const alreadySeen = turn.id === marker.turnId ? marker.userMessageCount ?? userMessages.length : 0;
+		for (const item of userMessages.slice(alreadySeen)) {
+			const texts = normalizeUserMessageTexts(item);
+			if (ownTexts.has(texts.join(" ")) || texts.length > 1 && texts.every((text) => ownTexts.has(text))) continue;
+			humanTurns += 1;
+			if (occurredAt === void 0) {
+				const timestampSeconds = turn.completedAt ?? turn.startedAt;
+				occurredAt = typeof timestampSeconds === "number" && Number.isFinite(timestampSeconds) ? timestampSeconds * 1e3 : params.now ?? Date.now();
+			}
+		}
+	}
+	const activityId = `${newest.id}:${newestUserMessageCount}`;
+	return {
+		kind: "activity",
+		sessionKey: params.probe.sessionKey,
+		humanTurns,
+		nextMarker: {
+			turnId: newest.id,
+			userMessageCount: newestUserMessageCount
+		},
+		...humanTurns > 0 ? {
+			occurredAt: occurredAt ?? params.now ?? Date.now(),
+			dedupeId: activityId
+		} : {}
+	};
+}
+function normalizeUserMessageTexts(item) {
+	const typed = item;
+	const contentTexts = typed.content?.filter((input) => input.type === "text").map((input) => input.text.trim().replace(/\s+/g, " ")).filter(Boolean);
+	return contentTexts?.length ? contentTexts : [(typed.text ?? "").trim().replace(/\s+/g, " ")];
+}
+async function checkCodexUpstreamActivity(probes, control, resolveThreadId = (probe) => probe.threadId) {
+	return await control.withPinnedConnection(async (pinned) => {
+		const activities = [];
+		for (const probe of probes) {
+			const fingerprint = upstreamConnectionFingerprint(probe);
+			if (probe.upstreamKind !== "codex-app-server" || !fingerprint || fingerprint !== pinned.connectionFingerprint) continue;
+			try {
+				const threadId = resolveThreadId(probe);
+				const page = await pinned.listTurnPage({
+					threadId,
+					limit: CODEX_UPSTREAM_TURN_LIMIT,
+					sortDirection: "desc",
+					itemsView: "full"
+				}).catch((error) => {
+					if (error instanceof CodexAppServerRpcError && error.code === -32600) return;
+					throw error;
+				});
+				if (!page?.data.length && readMarker(probe)) {
+					try {
+						await pinned.readThread(threadId, false);
+					} catch (error) {
+						if (isCodexThreadReadMissingError(error, threadId)) activities.push({
+							kind: "missing",
+							sessionKey: probe.sessionKey
+						});
+					}
+					continue;
+				}
+				const activity = page && classifyCodexUpstreamTurns({
+					probe,
+					turns: page.data
+				});
+				if (activity) activities.push(activity);
+			} catch {}
+		}
+		return activities;
+	});
+}
+function createChecker(params) {
+	const resolveThreadId = (probe) => {
+		const config = params.getRuntimeConfig();
+		const sessionId = params.api.runtime.agent.session.getSessionEntry({
+			agentId: probe.agentId,
+			sessionKey: probe.sessionKey,
+			readConsistency: "latest"
+		})?.sessionId?.trim();
+		if (!sessionId) return probe.threadId;
+		const binding = params.bindingStore.read(sessionBindingIdentity({
+			sessionId,
+			sessionKey: probe.sessionKey,
+			config
+		}));
+		return binding?.connectionScope === "supervision" && binding.supervisionSourceThreadId === probe.threadId ? binding.threadId : probe.threadId;
+	};
+	return async (probes) => {
+		const groups = /* @__PURE__ */ new Map();
+		for (const probe of probes) {
+			const fingerprint = upstreamConnectionFingerprint(probe);
+			if (!fingerprint) continue;
+			const control = await params.control.forUpstream(probe.agentId, fingerprint);
+			if (!control) continue;
+			const key = `${probe.agentId}\0${fingerprint}`;
+			const group = groups.get(key) ?? {
+				control,
+				probes: []
+			};
+			group.probes.push(probe);
+			groups.set(key, group);
+		}
+		return (await Promise.all([...groups.values()].map((group) => checkCodexUpstreamActivity(group.probes, group.control, resolveThreadId)))).flat();
+	};
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-eligibility.ts
+/** Exact identity and native membership are independent of resident retention. */
+async function requireEligibleCodexThread(params) {
+	const { requests, threadId } = params;
+	const deadline = params.now() + requests.requestTimeoutMs;
+	const unverified = () => new CatalogParamsError("Codex session eligibility could not be verified. Refresh the catalog and verify the session in its native Codex home before retrying.");
+	const remaining = () => {
+		const timeoutMs = Math.ceil(deadline - params.now());
+		if (timeoutMs <= 0) throw unverified();
+		return timeoutMs;
+	};
+	const verify = async () => {
+		if (params.sourceHomeId && await params.managedThreads?.has(params.sourceHomeId, threadId)) throw unverified();
+		remaining();
+		const index = await requests.index();
+		const root = params.localSessionsRoot;
+		if (root && index.get(threadId)?.archived) throw unverified();
+		const thread = await requests.readThread(threadId, false, remaining());
+		remaining();
+		if (thread.id !== threadId || thread.ephemeral === true || !isInteractiveThreadSource(thread.source)) throw unverified();
+		if (!root) {
+			const { CODEX_CATALOG_NATIVE_PAGE_LIMIT } = await import("./.setup/session-catalog-native-projection-CTBd4EUm.mjs").then((n) => n.a);
+			const { CODEX_CATALOG_MAX_ROWS } = await import("./.setup/session-catalog-limits-DEU36Qlo.mjs").then((n) => n.r);
+			let cursor;
+			const seenCursors = /* @__PURE__ */ new Set();
+			for (;;) {
+				const page = await requests.listThreads({
+					archived: false,
+					limit: CODEX_CATALOG_NATIVE_PAGE_LIMIT,
+					modelProviders: [],
+					sortKey: "recency_at",
+					sortDirection: "desc",
+					...thread.cwd ? { cwd: thread.cwd } : {},
+					...cursor ? { cursor } : {}
+				}, remaining());
+				remaining();
+				const listed = page.data.find((entry) => entry.id === threadId);
+				if (listed) {
+					if (listed.ephemeral === true || !isInteractiveThreadSource(listed.source)) throw unverified();
+					break;
+				}
+				const nextCursor = readControlCursor(page.nextCursor, "next response");
+				if (!nextCursor || seenCursors.has(nextCursor)) throw unverified();
+				seenCursors.add(nextCursor);
+				if (seenCursors.size > CODEX_CATALOG_MAX_ROWS) {
+					const oldest = seenCursors.values().next().value;
+					if (oldest !== void 0) seenCursors.delete(oldest);
+				}
+				cursor = nextCursor;
+			}
+		}
+		if (root) {
+			if (!thread.path) throw unverified();
+			const metadata = await readCodexSessionMeta(root, thread.path, threadId);
+			remaining();
+			if (!metadata || !isInteractiveThreadSource(metadata.source) || metadata.originator === "openclaw") throw unverified();
+			await index.upsertThread(thread);
+			remaining();
+		}
+		return thread;
+	};
+	return await withTimeout$1(verify(), requests.requestTimeoutMs, "Codex session eligibility could not be verified", unverified);
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-control-requests.ts
+function createCodexCatalogRequestSnapshot(requestTimeoutMs, request, index, beginList, catalogRead = false) {
+	const read = (method, params, timeoutMs, observation) => {
+		const scope = catalogRead ? void 0 : currentCodexCatalogListRequest();
+		if (!scope) return request(method, params, timeoutMs, void 0, observation);
+		return scope.read(timeoutMs ?? requestTimeoutMs, async (remaining) => {
+			const attempt = beginList(scope);
+			if (!attempt.allowed) throw attempt.error;
+			return await request(method, params, remaining, void 0, observation);
+		});
+	};
+	return {
+		index,
+		beginList,
+		get requestTimeoutMs() {
+			return catalogRead ? requestTimeoutMs : currentCodexCatalogListRequest()?.remaining(requestTimeoutMs) ?? requestTimeoutMs;
+		},
+		listThreads: (params, timeoutMs, observation) => read(CODEX_CONTROL_METHODS.listThreads, params, timeoutMs, observation),
+		listThreadTurns: (params) => read(CODEX_CONTROL_METHODS.listThreadTurns, params),
+		listThreadItems: (params) => read(CODEX_CONTROL_METHODS.listThreadItems, params),
+		forkThread: (params, assertCurrent) => request(CODEX_CONTROL_METHODS.forkThread, assertCodexThreadForkParams(params), void 0, assertCurrent),
+		readThread: async (threadId, includeTurns, timeoutMs) => (await read(CODEX_CONTROL_METHODS.readThread, {
+			threadId,
+			includeTurns
+		}, timeoutMs)).thread,
+		archiveThread: async (threadId, assertCurrent) => {
+			await request(CODEX_CONTROL_METHODS.archiveThread, { threadId }, void 0, assertCurrent);
+		}
+	};
+}
+function createCodexSessionCatalogControlFromRequests(params) {
+	return {
+		forkContext: params.forkContext,
+		...params.clientId ? { clientId: params.clientId } : {},
+		...params.connectionFingerprint ? { connectionFingerprint: params.connectionFingerprint } : {},
+		withPinnedConnection: params.withPinnedConnection,
+		async initialize() {
+			await (await params.createRequestSnapshot().index()).initialize();
+		},
+		requireEligibleThread: (threadId) => requireEligibleCodexThread({
+			threadId,
+			requests: params.createRequestSnapshot(),
+			localSessionsRoot: params.localSessionsRoot,
+			sourceHomeId: params.sourceHomeId,
+			managedThreads: params.managedThreads,
+			now: params.now
+		}),
+		retireConnection: params.retireConnection,
+		async listPage(pageParams) {
+			readControlCursor(pageParams.cursor, "request");
+			const query = readPageParams(pageParams);
+			return await withCodexCatalogListRequest(async (request) => {
+				const requests = params.createRequestSnapshot();
+				const timeoutMs = Math.min(requests.requestTimeoutMs, 5e3);
+				const deadline = request.constrainDeadline(performance.now() + timeoutMs);
+				return await (await withTimeout$1(requests.index(), request.remaining(timeoutMs), "Codex session catalog is still loading", () => new CodexCatalogLoadingError())).list(query, deadline);
+			});
+		},
+		async listDescendantPage(listParams) {
+			const requests = params.createRequestSnapshot();
+			return await requests.listThreads(listParams, requests.requestTimeoutMs);
+		},
+		async readThread(threadId, includeTurns = false) {
+			return await params.createRequestSnapshot().readThread(threadId, includeTurns);
+		},
+		async listTurnPage(listParams) {
+			return await params.createRequestSnapshot().listThreadTurns(listParams);
+		},
+		listItemPage: (listParams) => params.createRequestSnapshot().listThreadItems(listParams),
+		async forkThread(forkParams, assertCurrent) {
+			const requests = params.createRequestSnapshot();
+			const index = forkParams.ephemeral === true ? void 0 : await requests.index();
+			const response = await requests.forkThread(forkParams, assertCurrent);
+			if (index && !index.get(response.thread.id)) await index.upsertThread(response.thread);
+			return response;
+		},
+		async archiveThread(threadId, assertCurrent) {
+			const requests = params.createRequestSnapshot();
+			const index = await requests.index();
+			await requests.archiveThread(threadId, assertCurrent);
+			index.archive(threadId);
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-homes.ts
+/** Discovers path facts on demand; runtime projections belong only to their requesting owner. */
+function createCodexCatalogHomeResolver(params) {
+	const env = params.env ?? process.env;
+	const generations = /* @__PURE__ */ new WeakMap();
+	let lastConfig = params.config;
+	const currentConfig = () => lastConfig = params.getRuntimeConfig() ?? lastConfig;
+	const generation = () => {
+		const config = currentConfig();
+		let current = generations.get(config);
+		if (!current) {
+			current = {
+				config,
+				assertCurrent: () => {
+					if (currentConfig() !== config) throw new CatalogParamsError("Codex session catalog configuration changed; retry the request");
+				},
+				pluginConfig: params.getPluginConfig(),
+				agentDirs: /* @__PURE__ */ new Map(),
+				paths: /* @__PURE__ */ new Map(),
+				directories: /* @__PURE__ */ new Set()
+			};
+			generations.set(config, current);
+		}
+		return current;
+	};
+	const agentIds = (snapshot) => snapshot.agentIds ??= listAgentIds(snapshot.config).toSorted((a, b) => a.localeCompare(b));
+	const agentDir = (snapshot, agentId) => {
+		let directory = snapshot.agentDirs.get(agentId);
+		if (!directory) {
+			directory = resolveAgentDir(snapshot.config, agentId, env);
+			snapshot.agentDirs.set(agentId, directory);
+		}
+		return directory;
+	};
+	const homePath = async (snapshot, value) => {
+		const cached = snapshot.paths.get(value);
+		if (cached !== void 0) return cached;
+		const resolved = path.resolve(value);
+		const discovery = canonicalPathFromExistingAncestor(resolved).catch(() => resolved).then(async (canonical) => {
+			if (await fs.stat(canonical).then((stat) => stat.isDirectory(), () => false)) snapshot.directories.add(value);
+			snapshot.paths.set(value, canonical);
+			return canonical;
+		});
+		snapshot.paths.set(value, discovery);
+		return discovery;
+	};
+	const sharedCandidates = (snapshot) => snapshot.candidates ??= (async () => {
+		const candidates = [];
+		const seen = /* @__PURE__ */ new Set();
+		const append = async (value, label) => {
+			const codexHome = await homePath(snapshot, value);
+			if (!snapshot.directories.has(value) || seen.has(codexHome)) return;
+			seen.add(codexHome);
+			candidates.push({
+				codexHome,
+				label: `Local Codex · ${label ?? path.basename(codexHome)}`
+			});
+		};
+		for (const id of agentIds(snapshot)) {
+			await scheduler.yield();
+			const directory = await homePath(snapshot, agentDir(snapshot, id));
+			await append(resolveCodexAppServerHomeDir(directory), id);
+			if (candidates.length === 100) return candidates;
+		}
+		for (const entry of readCodexPluginConfig(snapshot.pluginConfig).sessionCatalog?.homes ?? []) {
+			await scheduler.yield();
+			const { path: home, label } = typeof entry === "string" ? { path: entry } : entry;
+			await append(home, label);
+			if (candidates.length === 100) break;
+		}
+		return candidates;
+	})().then((candidates) => snapshot.candidates = candidates, (error) => {
+		snapshot.candidates = void 0;
+		throw error;
+	});
+	const prepareAgentHomes = async (snapshot, agentId, fleet) => {
+		await scheduler.yield();
+		snapshot.assertCurrent();
+		if (!agentIds(snapshot).includes(agentId)) return [];
+		const ownerAgentDir = await homePath(snapshot, agentDir(snapshot, agentId));
+		const base = params.resolveRuntimeOptions({
+			config: snapshot.config,
+			pluginConfig: snapshot.pluginConfig,
+			agentDir: ownerAgentDir,
+			env
+		});
+		const processHomeConfigured = Boolean(env.CODEX_HOME?.trim());
+		const candidates = [{
+			codexHome: await homePath(snapshot, resolveCodexAppServerLocalHomeDir(base.start, ownerAgentDir, env)),
+			label: "Local Codex",
+			usesProcessHomeFallback: base.start.transport === "stdio" && base.start.homeScope === "user" && !processHomeConfigured
+		}];
+		if (fleet && base.start.transport === "stdio") {
+			candidates.push({
+				codexHome: await homePath(snapshot, resolveCodexAppServerUserHomeDir(env)),
+				label: "Local Codex · user",
+				usesProcessHomeFallback: !processHomeConfigured
+			});
+			const ownerHome = resolveCodexAppServerHomeDir(ownerAgentDir);
+			const codexHome = await homePath(snapshot, ownerHome);
+			if (snapshot.directories.has(ownerHome)) candidates.push({
+				codexHome,
+				label: `Local Codex · ${agentId}`
+			});
+			candidates.push(...await sharedCandidates(snapshot));
+		}
+		snapshot.assertCurrent();
+		const homes = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const candidate of candidates) {
+			if (seen.has(candidate.codexHome)) continue;
+			seen.add(candidate.codexHome);
+			const sourceHomeId = codexCatalogHomeIdFromCanonicalPath(candidate.codexHome);
+			const primary = homes.length === 0;
+			homes.push({
+				assertCurrent: snapshot.assertCurrent,
+				sourceHomeId,
+				hostId: primary ? CODEX_LOCAL_SESSION_HOST_ID : `${CODEX_LOCAL_SESSION_HOST_ID}:${sourceHomeId}`,
+				label: candidate.label,
+				agentDir: ownerAgentDir,
+				appServer: base.start.transport !== "stdio" ? base : {
+					...base,
+					start: {
+						...base.start,
+						codexHome: candidate.codexHome,
+						...!primary ? {
+							homeScope: "user",
+							env: {
+								...base.start.env,
+								CODEX_HOME: candidate.codexHome
+							}
+						} : {}
+					}
+				},
+				...base.connectionClass === "remote" ? {} : { localSessionsRoot: path.join(candidate.codexHome, "sessions") },
+				usesProcessHomeFallback: candidate.usesProcessHomeFallback ?? false
+			});
+			if (homes.length === 100) break;
+		}
+		return homes;
+	};
+	setCodexCatalogConnectionHomeResolver(async (directory) => {
+		const snapshot = generation();
+		for (const id of agentIds(snapshot)) {
+			await scheduler.yield();
+			if (agentDir(snapshot, id) === directory) return prepareAgentHomes(snapshot, id, true);
+		}
+		snapshot.assertCurrent();
+		return [];
+	});
+	return {
+		forAgent: (agentId) => prepareAgentHomes(generation(), agentId, true),
+		async forNode(requestedAgentId) {
+			const snapshot = generation();
+			const configured = readCodexPluginConfig(snapshot.pluginConfig).appServer;
+			if (configured?.homeScope === "agent" || configured?.transport && configured.transport !== "stdio") {
+				const agentId = resolveSessionAgentIdsStrict({
+					config: snapshot.config,
+					agentId: requestedAgentId
+				}).sessionAgentId;
+				const source = (await prepareAgentHomes(snapshot, agentId, false))[0];
+				if (!source) throw new CatalogParamsError(`unknown Codex session catalog agent: ${agentId}`);
+				return {
+					...source,
+					agentId,
+					codexHome: resolveCodexAppServerLocalHomeDir(source.appServer.start, source.agentDir, env)
+				};
+			}
+			const codexHome = await homePath(snapshot, resolveCodexAppServerUserHomeDir(env));
+			snapshot.assertCurrent();
+			const appServer = params.resolveRuntimeOptions({
+				pluginConfig: snapshot.pluginConfig,
+				config: snapshot.config,
+				env
+			});
+			return {
+				assertCurrent: snapshot.assertCurrent,
+				sourceHomeId: codexCatalogHomeIdFromCanonicalPath(codexHome),
+				codexHome,
+				localSessionsRoot: path.join(codexHome, "sessions"),
+				appServer: {
+					...appServer,
+					start: {
+						...appServer.start,
+						env: {
+							...appServer.start.env,
+							CODEX_HOME: codexHome
+						}
+					}
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-source-backoff.ts
+const INITIAL_BACKOFF_MS = 5e3;
+const MAX_BACKOFF_MS = 6e4;
+/** Source health is separate from query-keyed page sharing and cached page delivery. */
+var CodexCatalogSourceBackoff = class {
+	constructor(now) {
+		this.now = now;
+		this.sourcesByConfig = /* @__PURE__ */ new WeakMap();
+	}
+	begin(config, agentId, sourceHomeId, scope) {
+		let sources = this.sourcesByConfig.get(config);
+		if (!sources) {
+			sources = /* @__PURE__ */ new Map();
+			this.sourcesByConfig.set(config, sources);
+		}
+		const key = JSON.stringify([agentId, sourceHomeId ?? null]);
+		if (scope) return scope.attempt(sources, key, () => this.begin(config, agentId, sourceHomeId));
+		let state = sources.get(key);
+		if (!state) {
+			state = {};
+			sources.set(key, state);
+		}
+		const failure = state.failure;
+		if (failure && (failure.probing || failure.retryAt > this.now())) return {
+			allowed: false,
+			error: failure.error
+		};
+		if (failure) failure.probing = true;
+		return {
+			allowed: true,
+			resolved: () => {
+				if (sources.get(key) === state) sources.set(key, {});
+			},
+			rejected: (error) => {
+				if (sources.get(key) !== state) return;
+				if (error instanceof CatalogParamsError || error instanceof Error && error.name === "AbortError" || error instanceof CodexAppServerRpcError && (error.code === -32600 || error.code === -32602)) {
+					if (failure) failure.probing = false;
+					return;
+				}
+				const delayMs = findCodexAppServerSpawnError(error) ? Infinity : failure ? Math.min(failure.delayMs * 2 || INITIAL_BACKOFF_MS, MAX_BACKOFF_MS) : 0;
+				sources.set(key, { failure: {
+					error,
+					delayMs,
+					retryAt: this.now() + delayMs,
+					probing: false
+				} });
+			},
+			abandoned: () => {
+				if (sources.get(key) === state && failure) failure.probing = false;
+			}
+		};
+	}
+};
+//#endregion
+//#region extensions/codex/src/session-catalog-control.ts
+/** Builds the passive catalog over the Codex plugin's canonical shared client. */
+function createCodexSessionCatalogControl(params) {
+	const now = params.now ?? Date.now;
+	const sourceBackoff = new CodexCatalogSourceBackoff(now);
+	const noConfig = {};
+	const resolveRuntimeOptions = (options) => {
+		const runtime = params.resolveRuntimeOptions(options);
+		return runtime.start.transport === "stdio" && runtime.start.commandSource === "managed" ? {
+			...runtime,
+			start: {
+				...runtime.start,
+				managedCommandOrder: "package-only"
+			}
+		} : runtime;
+	};
+	const homeResolver = createCodexCatalogHomeResolver({
+		config: params.config ?? {},
+		getRuntimeConfig: params.getRuntimeConfig,
+		getPluginConfig: params.getPluginConfig,
+		resolveRuntimeOptions,
+		...params.env ? { env: params.env } : {}
+	});
+	const requestOptionsByConfig = /* @__PURE__ */ new WeakMap();
+	const indexes = /* @__PURE__ */ new Map();
+	const retiringState = /* @__PURE__ */ new Map();
+	const directHomes = /* @__PURE__ */ new Map();
+	const residentRequests = /* @__PURE__ */ new Set();
+	let generation = params.getRuntimeConfig();
+	let residentEpoch = 0;
+	let closed = false;
+	let runBackground = (run) => run();
+	let retiring;
+	const retireIndexes = () => {
+		residentEpoch++;
+		const closing = [];
+		for (const [homeId, index] of indexes) {
+			const writes = index.retire().finally(() => {
+				if (retiringState.get(homeId) === writes) retiringState.delete(homeId);
+			});
+			retiringState.set(homeId, writes);
+			closing.push(writes, index.close());
+		}
+		indexes.clear();
+		directHomes.clear();
+		const drain = Promise.allSettled([retiring, ...closing]).then(() => {
+			if (retiring === drain) retiring = void 0;
+		});
+		retiring = drain;
+		return drain;
+	};
+	const resolveResident = async (agentId, source) => {
+		if (closed) throw new Error("Codex resident catalog is closed");
+		const config = params.getRuntimeConfig();
+		if (generation !== config) {
+			generation = config;
+			retireIndexes();
+		}
+		const epoch = residentEpoch;
+		const runtime = source?.appServer ?? resolveRuntimeOptions({ pluginConfig: params.getPluginConfig() });
+		const requestOptions = resolveRequestOptions(runtime.start, agentId, source);
+		const key = source?.sourceHomeId ?? agentId ?? "";
+		let home = directHomes.get(key);
+		if (!home) {
+			home = codexCatalogResidentHomeKey({
+				startOptions: requestOptions.startOptions,
+				agentDir: requestOptions.agentDir,
+				sourceHomeId: source?.sourceHomeId
+			});
+			directHomes.set(key, home);
+		}
+		const homeId = await home;
+		await retiringState.get(homeId);
+		if (closed || generation !== config || residentEpoch !== epoch) throw new Error("Codex catalog configuration changed");
+		let index = indexes.get(homeId);
+		if (!index) {
+			const [{ CodexCatalogIndex }, { canReuseCodexCatalogPreview, projectCodexCatalogDeltaPage, projectCodexCatalogPage }] = await Promise.all([import("./.setup/session-catalog-index-DPICGlxr.mjs"), import("./.setup/session-catalog-projection-CE0_Hffi.mjs")]);
+			source?.assertCurrent();
+			if (closed || generation !== config || residentEpoch !== epoch) throw new Error("Codex catalog configuration changed");
+			index = indexes.get(homeId);
+			if (index) return index;
+			const root = source?.localSessionsRoot ?? (runtime.connectionClass !== "remote" ? path.join(resolveCodexAppServerLocalHomeDir(requestOptions.startOptions, requestOptions.agentDir, params.env), "sessions") : void 0);
+			let nativeAttempt;
+			index = new CodexCatalogIndex({
+				homeId,
+				requestTimeoutMs: runtime.requestTimeoutMs,
+				runBackground: (run) => runBackground(run),
+				localSessionsRoot: root,
+				state: params.openResidentState?.(homeId),
+				runNativeWalk: async (run) => {
+					try {
+						const result = await run();
+						if (nativeAttempt?.allowed) nativeAttempt.resolved();
+						return result;
+					} catch (error) {
+						if (nativeAttempt?.allowed) nativeAttempt.rejected(error);
+						throw error;
+					} finally {
+						nativeAttempt = void 0;
+					}
+				},
+				assertCurrent: () => {
+					source?.assertCurrent();
+					if (closed || params.getRuntimeConfig() !== config || residentEpoch !== epoch) throw new Error("Codex catalog configuration changed");
+				},
+				readNative: async (query, remainingRows, foreground) => {
+					const requests = createRequestSnapshot(agentId, source, true, query.useStateDbOnly ? (thread) => {
+						const row = index?.get(thread.id);
+						return canReuseCodexCatalogPreview(row, thread) ? row?.preview : void 0;
+					} : void 0, Math.min(64, remainingRows));
+					const attempt = foreground ? requests.beginList(foreground) : query.cursor && nativeAttempt ? nativeAttempt : requests.beginList();
+					if (!foreground) nativeAttempt = attempt;
+					if (!attempt.allowed) throw attempt.error;
+					const diagnostics = startCodexCatalogPageDiagnostics("cold");
+					if (diagnostics) diagnostics.fields.controlRequestCalls = 1;
+					const observation = startCodexCatalogControlRequestDiagnostics(diagnostics);
+					let outcome = "rejected";
+					try {
+						const started = performance.now();
+						let response;
+						try {
+							response = await requests.listThreads(query, foreground?.remaining(requests.requestTimeoutMs) ?? requests.requestTimeoutMs, observation);
+						} finally {
+							if (diagnostics) {
+								const elapsed = performance.now() - started;
+								diagnostics.fields.inclusiveControlRequestWaitMs = elapsed;
+								diagnostics.fields.inclusiveControlRequestWaitMaxMs = elapsed;
+							}
+						}
+						foreground?.assertActive();
+						const { sanitizeTerminalText } = await import("openclaw/plugin-sdk/text-chunking");
+						const bounded = {
+							...response,
+							data: response.data.slice(0, remainingRows)
+						};
+						const projection = {
+							localSessionsRoot: root,
+							sanitize: sanitizeTerminalText,
+							diagnostics
+						};
+						const page = query.useStateDbOnly ? await projectCodexCatalogDeltaPage(bounded, {
+							...projection,
+							getRow: (threadId) => index?.get(threadId)
+						}) : await projectCodexCatalogPage(bounded, projection);
+						foreground?.assertActive();
+						outcome = "resolved";
+						return page;
+					} catch (error) {
+						observation?.rejected();
+						throw error;
+					} finally {
+						observation?.close();
+						diagnostics?.finish(outcome);
+					}
+				}
+			});
+			indexes.set(homeId, index);
+		}
+		return index;
+	};
+	const residentFor = (agentId, source) => {
+		const request = resolveResident(agentId, source);
+		residentRequests.add(request);
+		const release = () => residentRequests.delete(request);
+		request.then(release, release);
+		return request;
+	};
+	const resolveRequestOptions = (startOptions, agentId, source) => {
+		source?.assertCurrent();
+		const runtimeConfig = params.getRuntimeConfig();
+		const agentDir = source?.agentDir ?? (agentId ? resolveAgentDir(runtimeConfig ?? {}, agentId) : void 0);
+		const resolvedStartOptions = source?.appServer.start ?? startOptions;
+		if (!runtimeConfig) return {
+			agentDir,
+			config: void 0,
+			startOptions: structuredClone(resolvedStartOptions)
+		};
+		let snapshot = requestOptionsByConfig.get(runtimeConfig);
+		const cacheKey = `${agentId ?? ""}\0${source?.sourceHomeId ?? ""}`;
+		const cached = snapshot?.byAgent.get(cacheKey);
+		if (cached) return cached;
+		if (!snapshot) {
+			snapshot = {
+				config: structuredClone(runtimeConfig),
+				byAgent: /* @__PURE__ */ new Map()
+			};
+			requestOptionsByConfig.set(runtimeConfig, snapshot);
+		}
+		const resolved = {
+			agentDir,
+			config: snapshot.config,
+			startOptions: structuredClone(resolvedStartOptions)
+		};
+		snapshot.byAgent.set(cacheKey, resolved);
+		return resolved;
+	};
+	const createRequestSnapshot = (agentId, source, catalogPreview, catalogPreviewCache, catalogRows) => {
+		const pluginConfig = params.getPluginConfig();
+		const runtime = source?.appServer ?? resolveRuntimeOptions({ pluginConfig });
+		const requestOptions = resolveRequestOptions(runtime.start, agentId, source);
+		return createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs, assertCurrent, observation) => {
+			const { codexControlRequest } = await import("./.setup/command-rpc-B6xsq2dB.mjs").then((n) => n.n);
+			return await codexControlRequest(pluginConfig, method, requestParams, {
+				...requestOptions,
+				authProfileId: null,
+				assertCurrent,
+				...catalogPreview && method === CODEX_CONTROL_METHODS.listThreads ? {
+					catalogPreview,
+					catalogRows,
+					...catalogPreviewCache ? { catalogPreviewCache } : {}
+				} : {},
+				...observation ? { controlObservation: observation } : {},
+				...timeoutMs === void 0 ? {} : { timeoutMs }
+			});
+		}, () => residentFor(agentId, source), (request) => sourceBackoff.begin(requestOptions.config ?? noConfig, agentId, source?.sourceHomeId, request), catalogPreview === true);
+	};
+	const forRequest = (agentId, source) => {
+		source?.assertCurrent();
+		const withPinnedConnection = async (run) => {
+			const pluginConfig = params.getPluginConfig();
+			const runtime = source?.appServer ?? resolveRuntimeOptions({ pluginConfig });
+			const { agentDir, config: runtimeConfig, startOptions } = resolveRequestOptions(runtime.start, agentId, source);
+			let catalogIndex;
+			const { getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./.setup/shared-client-DJJ3ljH2.mjs").then((n) => n.v);
+			const { resolveCodexAppServerClientInstanceId } = await import("./.setup/client-CBzEVDyb.mjs").then((n) => n.n);
+			const { requestCodexAppServerClientJson } = await import("./.setup/request-BH3FvYUE.mjs").then((n) => n.i);
+			const client = await getLeasedSharedCodexAppServerClient({
+				agentDir,
+				config: runtimeConfig,
+				startOptions,
+				authProfileId: null,
+				timeoutMs: currentCodexCatalogListRequest()?.remaining(runtime.requestTimeoutMs) ?? runtime.requestTimeoutMs
+			});
+			try {
+				const requests = createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs, assertCurrent, observation) => await requestCodexAppServerClientJson({
+					client,
+					method,
+					requestParams,
+					config: runtimeConfig,
+					timeoutMs: timeoutMs ?? runtime.requestTimeoutMs,
+					assertCurrent,
+					...observation ? { controlObservation: observation } : {}
+				}), () => catalogIndex ??= residentFor(agentId, source), (request) => sourceBackoff.begin(runtimeConfig ?? noConfig, agentId, source?.sourceHomeId, request));
+				const pinnedControl = createCodexSessionCatalogControlFromRequests({
+					forkContext: agentDir ? {
+						client,
+						appServer: runtime,
+						pluginConfig,
+						agentDir,
+						localSessionsRoot: source?.localSessionsRoot
+					} : void 0,
+					clientId: resolveCodexAppServerClientInstanceId(client),
+					retireConnection: () => {
+						retireSharedCodexAppServerClientIfCurrent(client);
+					},
+					connectionFingerprint: buildCodexAppServerConnectionFingerprint(runtime, agentDir),
+					createRequestSnapshot: () => requests,
+					...source?.localSessionsRoot ? { localSessionsRoot: source.localSessionsRoot } : {},
+					sourceHomeId: source?.sourceHomeId,
+					managedThreads: params.managedThreads,
+					now,
+					withPinnedConnection: async (nestedRun) => await nestedRun(pinnedControl)
+				});
+				return await run(pinnedControl);
+			} finally {
+				releaseLeasedSharedCodexAppServerClient(client);
+			}
+		};
+		const control = createCodexSessionCatalogControlFromRequests({
+			createRequestSnapshot: () => createRequestSnapshot(agentId, source),
+			...source?.localSessionsRoot ? { localSessionsRoot: source.localSessionsRoot } : {},
+			now,
+			withPinnedConnection
+		});
+		return {
+			...control,
+			requireEligibleThread: (threadId) => withPinnedConnection((pinned) => pinned.requireEligibleThread(threadId)),
+			async listPage(pageParams) {
+				source?.assertCurrent();
+				return await control.listPage(pageParams);
+			}
+		};
+	};
+	const forUpstream = async (agentId, connectionFingerprint) => {
+		const source = (await homeResolver.forAgent(agentId)).find((home) => buildCodexAppServerConnectionFingerprint(home.appServer, home.agentDir) === connectionFingerprint);
+		return source ? forRequest(agentId, source) : void 0;
+	};
+	return {
+		hasActiveWork: () => residentRequests.size > 0 || retiring !== void 0 || hasActiveSharedCodexAppServerWork() || [...indexes.values()].some((index) => index.hasActiveWork()),
+		async disconnect() {
+			await retireIndexes();
+			await Promise.allSettled(residentRequests);
+			const clients = getSharedCodexAppServerClientState();
+			if (clients.liveClients.size > 0 || clients.startup.pending.size > 0) {
+				const { clearSharedCodexAppServerClientAndWait } = await import("./.setup/shared-client-DJJ3ljH2.mjs").then((n) => n.v);
+				await clearSharedCodexAppServerClientAndWait();
+			}
+		},
+		async start() {
+			const serviceScope = AsyncLocalStorage.snapshot();
+			runBackground = (run) => serviceScope(run);
+		},
+		async stop() {
+			closed = true;
+			await retireIndexes();
+			await Promise.allSettled(residentRequests);
+		},
+		forRequest,
+		forUpstream,
+		homesForAgent: homeResolver.forAgent,
+		async forNode(agentId) {
+			const source = await homeResolver.forNode(agentId);
+			return {
+				assertCurrent: () => source.assertCurrent(),
+				control: forRequest(source.agentId, source),
+				sourceHomeId: source.sourceHomeId,
+				codexHome: source.codexHome,
+				transport: source.appServer.start.transport
+			};
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/session-catalog.ts
+/** Allows read-only catalog and transcript commands on supported paired-node platforms. */
+function createCodexSessionCatalogNodeInvokePolicies() {
+	return [{
+		commands: [
+			CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+			CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+			CODEX_CATALOG_TRANSCRIPT_READ_COMMAND,
+			CODEX_TERMINAL_RESUME_COMMAND,
+			CODEX_TERMINAL_START_COMMAND
+		],
+		defaultPlatforms: [
+			"macos",
+			"linux",
+			"windows"
+		],
+		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 isLocalCodexCatalogHost(hostId) {
+	return hostId === "gateway:local" || hostId.startsWith(`gateway:local:`);
+}
+function resolveLocalCatalogHomeForThread(params) {
+	if (params.homes.length === 0) throw new CatalogParamsError("local Codex sessions are unavailable in isolated state");
+	const exact = params.sourceHomeId ? params.homes.find((home) => home.sourceHomeId === params.sourceHomeId) : params.homes.find((home) => home.hostId === params.hostId);
+	if (!exact || params.sourceHomeId && exact.hostId !== params.hostId) throw new CatalogParamsError("Codex session source home is unavailable");
+	return exact;
+}
+function withCatalogListScope(initialize) {
+	let create = initialize;
+	let operation;
+	let scope;
+	let running = false;
+	let closed = false;
+	let completed = false;
+	return {
+		async next() {
+			if (closed || running) throw new Error("Codex catalog list operation cannot advance");
+			running = true;
+			try {
+				scope ??= createCodexCatalogListScope();
+				return await scope.run(async () => {
+					if (create) {
+						const initializeOnce = create;
+						create = void 0;
+						operation = await initializeOnce();
+					}
+					if (!operation) throw new Error("Codex catalog list operation did not initialize");
+					const step = await operation.next();
+					completed ||= step.done;
+					return step;
+				});
+			} finally {
+				running = false;
+			}
+		},
+		close() {
+			if (closed) return;
+			if (running) throw new Error("Cannot close an active Codex catalog list step");
+			closed = true;
+			create = void 0;
+			const current = operation;
+			operation = void 0;
+			const currentScope = scope;
+			scope = void 0;
+			try {
+				if (currentScope) currentScope.run(() => current?.close());
+			} finally {
+				currentScope?.finish(completed ? "resolved" : "rejected");
+			}
+		}
+	};
+}
+function catalogHostMapper(localTerminalAvailable, localHomes) {
+	return (host) => {
+		const finishTiming = startCodexCatalogListTiming("mappingMs");
+		try {
+			const localSourceAvailable = localTerminalAvailable && localHomes.some((home) => home.hostId === host.hostId && home.appServer.start.transport === "stdio");
+			const local = isLocalCodexCatalogHost(host.hostId);
+			return {
+				hostId: host.hostId,
+				label: host.label,
+				kind: host.kind,
+				connected: host.connected,
+				...host.pending ? { pending: true } : {},
+				...host.nodeId ? { nodeId: host.nodeId } : {},
+				sessions: host.sessions.map((session) => {
+					const interactive = isInteractiveThreadSource(session.source);
+					const continuable = interactive && !session.archived && (session.status === "idle" || session.status === "notLoaded");
+					const name = session.name ?? session.fallbackName;
+					return {
+						threadId: session.threadId,
+						...session.sourceHomeId ? { sourceHomeId: session.sourceHomeId } : {},
+						...name ? { name } : {},
+						...session.cwd ? { cwd: session.cwd } : {},
+						status: session.status,
+						...session.createdAt != null ? { createdAt: session.createdAt } : {},
+						...session.updatedAt != null ? { updatedAt: session.updatedAt } : {},
+						...session.recencyAt != null ? { recencyAt: session.recencyAt } : {},
+						...session.source ? { source: session.source } : {},
+						...session.modelProvider ? { modelProvider: session.modelProvider } : {},
+						...session.cliVersion ? { cliVersion: session.cliVersion } : {},
+						...session.gitBranch ? { gitBranch: session.gitBranch } : {},
+						archived: session.archived,
+						...session.sessionKey ? { sessionKey: session.sessionKey } : {},
+						canContinue: (local || host.canContinueCodex === true) && continuable,
+						canArchive: local && continuable,
+						canOpenTerminal: interactive && (local ? localSourceAvailable : host.canOpenTerminalCodex === true)
+					};
+				}),
+				...host.nextCursor ? { nextCursor: host.nextCursor } : {},
+				...host.error ? { error: host.error } : {},
+				canStartTerminal: host.kind === "gateway" ? localSourceAvailable && host.hostId === "gateway:local" : host.canStartTerminal === true
+			};
+		} finally {
+			finishTiming();
+		}
+	};
+}
+function registerCodexSessionCatalog(params) {
+	const catalogHomes = async (agentId, allowProcessHomeFallback) => {
+		const homes = await params.control.homesForAgent(agentId);
+		return allowProcessHomeFallback === false ? homes.filter((home) => !home.usesProcessHomeFallback) : homes;
+	};
+	const resolveRequestAgentId = (agentId) => resolveSessionAgentIdsStrict({
+		config: params.getRuntimeConfig() ?? params.api.config,
+		agentId
+	}).sessionAgentId;
+	const bindRequest = async (request) => {
+		const agentId = resolveRequestAgentId(request.agentId);
+		const source = isLocalCodexCatalogHost(request.hostId) ? resolveLocalCatalogHomeForThread({
+			homes: [...await catalogHomes(agentId, request.allowProcessHomeFallback)],
+			hostId: request.hostId,
+			...request.sourceHomeId ? { sourceHomeId: request.sourceHomeId } : {}
+		}) : void 0;
+		return {
+			agentId,
+			source,
+			control: params.control.forRequest(agentId, source)
+		};
+	};
+	const bindLocalRequest = async (request) => {
+		const bound = await bindRequest(request);
+		if (!bound.source) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+		return {
+			...bound,
+			source: bound.source
+		};
+	};
+	const checkUpstreamActivity = createChecker(params);
+	const nodeSnapshots = new CodexCatalogNodeSnapshots();
+	const createListOperation = (query) => withCatalogListScope(async () => {
+		const { agentId: requestedAgentId, allowProcessHomeFallback, allowPartialResults, listNodes, onHost, waitUntil, signal, sessionEntries, ...gatewayQuery } = query;
+		const agentId = resolveRequestAgentId(requestedAgentId);
+		const selectedQuery = readGatewayParams(gatewayQuery);
+		const localHomes = selectedQuery.hostIds && !selectedQuery.hostIds.some(isLocalCodexCatalogHost) ? [] : [...await catalogHomes(agentId, allowProcessHomeFallback)];
+		const mapHost = catalogHostMapper(resolveLocalCodexTerminalExecutable() !== void 0, localHomes);
+		const operation = createCodexSessionCatalogListOperation({
+			agentId,
+			bindingStore: params.bindingStore,
+			config: params.getRuntimeConfig(),
+			runtime: params.api.runtime,
+			control: params.control,
+			query: selectedQuery,
+			listNodes,
+			waitUntil,
+			signal,
+			sessionEntries,
+			localHomes,
+			allowPartialResults,
+			nodeSnapshots,
+			...onHost ? { onHost: (host) => onHost(mapHost(host)) } : {}
+		});
+		return {
+			async next() {
+				const step = await operation.next();
+				return step.done ? {
+					done: true,
+					hosts: step.hosts.map(mapHost)
+				} : step;
+			},
+			close: () => operation.close()
+		};
+	});
+	const provider = {
+		id: "codex",
+		label: "Codex",
+		supportsProcessHomeIsolation: true,
+		resolveCreateSession: ({ agentId }) => resolveCodexCatalogCreateSession(params.api.runtime.modelConfig, params.getRuntimeConfig() ?? params.api.config, agentId),
+		list: (query) => runCatalogListInline(createListOperation(query)),
+		createListOperation,
+		read: async (request) => {
+			const { agentId, source, control } = await bindRequest(request);
+			return await readCodexSessionTranscript({
+				agentId,
+				runtime: params.api.runtime,
+				control,
+				hostId: request.hostId,
+				threadId: request.threadId,
+				sourceHomeId: request.sourceHomeId,
+				cursor: request.cursor,
+				limit: request.limit ?? 20,
+				...source ? { source } : {}
+			});
+		},
+		continueSession: async (request) => {
+			const config = params.getRuntimeConfig();
+			if (!config) throw new Error("OpenClaw runtime config is unavailable");
+			if (request.hostId.startsWith("node:")) {
+				const agentId = resolveRequestAgentId(request.agentId);
+				const { continueNodeCodexSession } = await import("./.setup/session-catalog-node-continue-DLWBwAAO.mjs");
+				return await continueNodeCodexSession({
+					agentId,
+					api: params.api,
+					config,
+					hostId: request.hostId,
+					threadId: request.threadId,
+					sourceHomeId: request.sourceHomeId,
+					clientScopes: request.clientScopes
+				});
+			}
+			if (!isLocalCodexCatalogHost(request.hostId)) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+			const { agentId, source, control } = await bindLocalRequest(request);
+			source.assertCurrent();
+			let upstreamBaseline;
+			const { continueLocalCodexSession } = await import("./.setup/session-catalog-adoption-CPIP4S_y.mjs");
+			const continued = await continueLocalCodexSession({
+				agentId,
+				api: params.api,
+				bindingStore: params.bindingStore,
+				config,
+				control,
+				threadId: request.threadId,
+				hostId: source.hostId,
+				sourceHomeId: source.sourceHomeId,
+				...source.hostId === "gateway:local" ? { allowLegacy: true } : {},
+				onContinued: (baseline) => {
+					upstreamBaseline = baseline;
+				}
+			});
+			return codexUpstreamContinueResult(continued.sessionKey, request.threadId, upstreamBaseline);
+		},
+		checkUpstreamActivity: async (probes, policy) => {
+			const filtered = [];
+			for (const probe of probes) if (!isLocalCodexCatalogHost(probe.hostId) || policy?.allowProcessHomeFallback !== false || (await catalogHomes(probe.agentId, false)).some((home) => home.hostId === probe.hostId)) filtered.push(probe);
+			return checkUpstreamActivity(filtered);
+		},
+		archive: async (request) => {
+			if (request.confirmNoOtherRunner !== true) throw new CatalogParamsError("archive requires confirmation that no other runner is active");
+			if (!isLocalCodexCatalogHost(request.hostId)) throw new CatalogParamsError("paired-node Codex sessions are view-only");
+			const config = params.getRuntimeConfig();
+			if (!config) throw new Error("OpenClaw runtime config is unavailable");
+			const { agentId, source, control } = await bindLocalRequest(request);
+			source.assertCurrent();
+			const { archiveLocalCodexSession } = await import("./.setup/session-catalog-archive-DcgwvSbF.mjs");
+			await archiveLocalCodexSession({
+				agentId,
+				bindingStore: params.bindingStore,
+				config,
+				control,
+				runtime: params.api.runtime,
+				threadId: request.threadId,
+				hostId: source.hostId,
+				sourceHomeId: source.sourceHomeId,
+				...source.hostId === "gateway:local" ? { allowLegacy: true } : {}
+			});
+			return { ok: true };
+		},
+		openTerminal: async (request) => {
+			const { agentId, source, control } = await bindRequest(request);
+			return await openCodexCatalogTerminal({
+				api: params.api,
+				control,
+				getPluginConfig: params.getPluginConfig,
+				getRuntimeConfig: params.getRuntimeConfig,
+				resolveRuntimeOptions: params.resolveRuntimeOptions,
+				...source ? { source } : {},
+				...request,
+				agentId
+			});
+		},
+		startTerminalSession: async (request) => {
+			if (!request.nodeId && request.hostId && request.hostId !== "gateway:local") throw new CatalogParamsError("Codex terminal host is unavailable; select the local machine or a connected node");
+			const source = request.nodeId ? void 0 : resolveLocalCatalogHomeForThread({
+				homes: [...await 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,
+				resolveRuntimeOptions: params.resolveRuntimeOptions,
+				...request,
+				source
+			});
+		}
+	};
+	params.api.registerSessionCatalog(provider);
+}
+//#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.
+*
+* Read operations and active-turn controls use the Codex plugin's canonical
+* shared app-server client. Idle threads are never resumed or started here:
+* continuation belongs to the Codex harness, which installs approval and tool
+* handlers before it starts or resumes the harness-owned Codex thread.
+*/
+/** Legacy endpoint env retained for the shipped Supervisor tool contract. */
+const LEGACY_CODEX_SUPERVISOR_ENDPOINTS_ENV = "OPENCLAW_CODEX_SUPERVISOR_ENDPOINTS";
+const CODEX_SUPERVISION_COMPAT_TOOL_NAMES = [
+	"codex_endpoint_probe",
+	"codex_sessions_list",
+	"codex_session_read",
+	"codex_session_send",
+	"codex_session_interrupt"
+];
+const EmptyParamsSchema = Type.Object({}, { additionalProperties: false });
+const SessionsListParamsSchema = Type.Object({
+	include_stored: Type.Optional(Type.Boolean()),
+	max_stored_sessions: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 1e3
+	}))
+}, { additionalProperties: false });
+const SessionReadParamsSchema = Type.Object({
+	endpoint_id: Type.Optional(Type.String()),
+	thread_id: Type.String(),
+	include_turns: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const SessionSendParamsSchema = Type.Object({
+	endpoint_id: Type.Optional(Type.String()),
+	thread_id: Type.String(),
+	text: Type.String(),
+	mode: Type.Optional(Type.Union([
+		Type.Literal("auto"),
+		Type.Literal("start"),
+		Type.Literal("steer")
+	]))
+}, { additionalProperties: false });
+const SessionInterruptParamsSchema = Type.Object({
+	endpoint_id: Type.Optional(Type.String()),
+	thread_id: Type.String(),
+	turn_id: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const ALL_CODEX_THREAD_SOURCE_KINDS = [
+	"cli",
+	"vscode",
+	"exec",
+	"appServer",
+	"subAgent",
+	"subAgentReview",
+	"subAgentCompact",
+	"subAgentThreadSpawn",
+	"subAgentOther",
+	"unknown"
+];
+const DEFAULT_MAX_STORED_SESSIONS = 200;
+const PAGE_LIMIT = 100;
+const MAX_COMPAT_PAGINATION_PAGES = 100;
+const MAX_COMPAT_CURSOR_LENGTH = 4096;
+const MAX_COMPAT_THREAD_ID_LENGTH = 4096;
+function asRecordArray(value) {
+	return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function readCompatNextCursor(value, method) {
+	if (value === null || value === void 0) return;
+	if (typeof value !== "string" || value.trim().length === 0 || value.length > MAX_COMPAT_CURSOR_LENGTH) throw new Error(`Codex ${method} returned an invalid nextCursor`);
+	return value;
+}
+function readCompatThreadId(value, method, index) {
+	if (typeof value !== "string" || value.trim().length === 0 || value.length > MAX_COMPAT_THREAD_ID_LENGTH) throw new Error(`Codex ${method} returned an invalid thread id at data[${index}]`);
+	return value;
+}
+function readLoadedThreadIds(data) {
+	if (data.length > PAGE_LIMIT) throw new Error(`Codex thread/loaded/list returned more than ${PAGE_LIMIT} entries`);
+	return data.map((entry, index) => readCompatThreadId(entry, "thread/loaded/list", index));
+}
+function readStoredThreads(data, maxEntries) {
+	if (data.length > maxEntries) throw new Error(`Codex thread/list returned more than ${maxEntries} entries`);
+	return data.map((entry, index) => {
+		if (!isRecord(entry)) throw new Error(`Codex thread/list returned an invalid entry at data[${index}]`);
+		readCompatThreadId(entry.id, "thread/list", index);
+		return entry;
+	});
+}
+function readIntegerParam(params, key) {
+	const value = params[key];
+	if (value === void 0) return;
+	if (typeof value !== "number" || !Number.isInteger(value)) throw new Error(`${key} must be an integer`);
+	if (value < 1 || value > 1e3) throw new Error(`${key} must be between 1 and 1000`);
+	return value;
+}
+function readModeParam(params) {
+	const mode = readStringParam(params, "mode");
+	if (!mode) return;
+	if (mode === "auto" || mode === "start" || mode === "steer") return mode;
+	throw new Error("mode must be auto, start, or steer");
+}
+function normalizeEndpointId(value, index) {
+	const trimmed = value.trim();
+	return trimmed ? trimmed.replace(/[^a-zA-Z0-9_.:-]/g, "-") : `endpoint-${index + 1}`;
+}
+function normalizeConfiguredEndpoint(endpoint, index) {
+	return {
+		id: normalizeEndpointId(endpoint.id ?? endpoint.label ?? "", index),
+		...endpoint.label?.trim() ? { label: endpoint.label.trim() } : {},
+		configured: endpoint
+	};
+}
+function parseEndpointRecord(value) {
+	if (!isRecord(value)) return;
+	const transport = typeof value.transport === "string" ? value.transport : void 0;
+	const common = {
+		...typeof value.id === "string" ? { id: value.id } : {},
+		...typeof value.label === "string" ? { label: value.label } : {}
+	};
+	if (transport === "websocket" && typeof value.url === "string") return {
+		...common,
+		transport,
+		url: value.url,
+		...typeof value.authTokenEnv === "string" ? { authTokenEnv: value.authTokenEnv } : {}
+	};
+	if (transport === "stdio-proxy" || transport === void 0) {
+		const args = Array.isArray(value.args) ? value.args.filter((entry) => typeof entry === "string") : void 0;
+		return {
+			...common,
+			transport: "stdio-proxy",
+			...typeof value.command === "string" ? { command: value.command } : {},
+			...args && args.length > 0 ? { args } : {},
+			...typeof value.cwd === "string" ? { cwd: value.cwd } : {}
+		};
+	}
+}
+function endpointFromToken(token, index) {
+	const trimmed = token.trim();
+	if (!trimmed) return;
+	if (trimmed.startsWith("ws://") || trimmed.startsWith("wss://") || trimmed.startsWith("unix://")) return {
+		id: normalizeEndpointId("", index),
+		transport: "websocket",
+		url: trimmed
+	};
+	if (trimmed === "local" || trimmed === "proxy" || trimmed === "stdio") return {
+		id: "local",
+		label: "local Codex app-server",
+		transport: "stdio-proxy"
+	};
+	const separatorIndex = trimmed.indexOf("=");
+	const id = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex) : trimmed;
+	const url = separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1) : void 0;
+	if (url?.startsWith("ws://") || url?.startsWith("wss://") || url?.startsWith("unix://")) return {
+		id: normalizeEndpointId(id, index),
+		transport: "websocket",
+		url
+	};
+}
+function requireUniqueEndpointIds(endpoints) {
+	const seen = /* @__PURE__ */ new Set();
 	for (const endpoint of endpoints) {
 		if (seen.has(endpoint.id)) throw new Error(`duplicate Codex supervisor endpoint id: ${endpoint.id}`);
 		seen.add(endpoint.id);
@@ -1128,23 +3744,17 @@ function readLegacyEnvEndpoints(env) {
 function resolveEndpoints(pluginConfig, env, runtimeConfig, resolveAuthProfileId, resolveRuntimeOptions) {
 	const configured = readCodexPluginConfig(pluginConfig).supervision?.endpoints;
 	const endpoints = configured?.length ? configured : readLegacyEnvEndpoints(env);
-	const normalized = endpoints ? requireUniqueEndpointIds(endpoints.map(normalizeConfiguredEndpoint)) : [{
+	return (endpoints ? requireUniqueEndpointIds(endpoints.map(normalizeConfiguredEndpoint)) : [{
 		id: "local",
 		label: "local Codex app-server"
-	}];
-	const resolved = [];
-	for (const endpoint of normalized) resolved.push({
-		...endpoint,
-		connectionKey: supervisionEndpointConnectionKey({
-			endpoint,
-			pluginConfig,
-			env,
-			runtimeConfig,
-			resolveAuthProfileId,
-			resolveRuntimeOptions
-		})
-	});
-	return resolved;
+	}]).map((endpoint) => Object.assign({}, endpoint, { connectionKey: supervisionEndpointConnectionKey({
+		endpoint,
+		pluginConfig,
+		env,
+		runtimeConfig,
+		resolveAuthProfileId,
+		resolveRuntimeOptions
+	}) }));
 }
 function resolveEndpointStartOptions(params) {
 	const base = params.resolveRuntimeOptions({
@@ -1259,29 +3869,24 @@ function toSession(endpointId, thread, humanAttached) {
 		...humanAttached !== void 0 ? { humanAttached } : {}
 	};
 }
-function threadFromRead(value) {
-	return isRecord(value) && isRecord(value.thread) ? value.thread : void 0;
-}
 function isLoadedThreadReadMiss(error) {
 	const message = coerceErrorMessage(error);
 	return message.includes("thread not found") || message.includes("thread not loaded");
 }
 async function readThread(params) {
-	try {
-		const thread = threadFromRead(await params.request(params.endpoint, "thread/read", {
+	const read = async (includeTurns, errorOptions) => {
+		const response = await params.request(params.endpoint, "thread/read", {
 			threadId: params.threadId,
-			includeTurns: params.includeTurns
-		}));
-		if (!thread) throw new Error("Codex thread/read returned an invalid response");
-		return thread;
+			includeTurns
+		});
+		if (!isRecord(response) || !isRecord(response.thread)) throw new Error("Codex thread/read returned an invalid response", errorOptions);
+		return response.thread;
+	};
+	try {
+		return await read(params.includeTurns);
 	} catch (error) {
 		if (!params.includeTurns || !String(error).includes("not materialized yet")) throw error;
-		const thread = threadFromRead(await params.request(params.endpoint, "thread/read", {
-			threadId: params.threadId,
-			includeTurns: false
-		}));
-		if (!thread) throw new Error("Codex thread/read returned an invalid response", { cause: error });
-		return thread;
+		return await read(false, { cause: error });
 	}
 }
 async function listSessions(request, endpoint, storedLimit) {
@@ -1409,15 +4014,12 @@ function redactCodexSupervisionValue(value, key = "") {
 }
 function redactEndpointUrl(value) {
 	if (value.startsWith("unix://")) return "unix://";
-	try {
-		const url = new URL(value);
-		url.username = "";
-		url.password = "";
-		if (url.search) url.search = "?[redacted]";
-		return url.toString();
-	} catch {
-		return "[redacted]";
-	}
+	const url = URL.parse(value);
+	if (!url) return "[redacted]";
+	url.username = "";
+	url.password = "";
+	if (url.search) url.search = "?[redacted]";
+	return url.toString();
 }
 function endpointResult(endpoint, pluginConfig, env, resolveRuntimeOptions) {
 	const start = endpoint.configured ?? resolveRuntimeOptions({
@@ -1660,7 +4262,7 @@ function createCodexSupervisionTools(options) {
 }
 //#endregion
 //#region extensions/codex/src/web-search-provider.ts
-const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./.setup/web-search-provider.runtime-UKgeiBUG.mjs"));
+const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./.setup/web-search-provider.runtime-CsVmqbFm.mjs"));
 const CodexWebSearchSchema = {
 	type: "object",
 	properties: { query: {
@@ -1744,9 +4346,12 @@ var codex_default = definePluginEntry({
 			deleteIf: (key, predicate) => openBindingStateStore().deleteIf(key, predicate),
 			entries: () => openBindingStateStore().entries(),
 			lookup: (key) => openBindingStateStore().lookup(key),
-			get lookupMany() {
-				const store = openBindingStateStore();
-				return store.lookupMany?.bind(store);
+			asyncReads: {
+				lookup: (key) => openBindingMutationStore().lookup(key),
+				get lookupMany() {
+					const store = openBindingMutationStore();
+					return store.lookupMany?.bind(store);
+				}
 			},
 			registerIfAbsent: (key, value, options) => openBindingStateStore().registerIfAbsent(key, value, options),
 			withCurrent: (authority) => {
@@ -1762,7 +4367,6 @@ var codex_default = definePluginEntry({
 		});
 		const bindingStore = createLazyCodexAppServerBindingStore(lazyBindingStateStore, {
 			entries: () => openManagedThreadStateStore().entries(),
-			lookup: (key) => openManagedThreadStateStore().lookup(key),
 			registerIfAbsent: (key, value) => openManagedThreadStateStore().registerIfAbsent(key, value)
 		});
 		registerCodexCliMetadata(api);
@@ -1786,7 +4390,7 @@ var codex_default = definePluginEntry({
 			stop: () => sessionCatalogControlFactory.stop()
 		});
 		if (sessionCatalogEnabled) {
-			codexSessionCatalogRuntime.register({
+			registerCodexSessionCatalog({
 				api,
 				resolveRuntimeOptions: resolveCodexSupervisionAppServerRuntimeOptions,
 				bindingStore,
@@ -1925,7 +4529,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-DGCYAfvD.mjs").then((n) => n.s), import("./.setup/session-retirement-LlYWBKTJ.mjs")]);
+			const [{ sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./.setup/session-binding-Ce7BqiPN.mjs").then((n) => n.i), import("./.setup/session-retirement-aC60o6P3.mjs")]);
 			await retireCodexAppServerSessionGeneration({
 				bindingStore,
 				identity: sessionBindingIdentity({