@openclaw/codex 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/index.js

@@ -1,28 +1,59 @@
 import { createCodexAppServerAgentHarness } from "./harness.js";
-import { I as ensureCodexPluginActivation, L as pluginReadParams, z as defaultCodexAppInventoryCache } from "./thread-lifecycle-DeSMZSXr.js";
-import { d as resolveCodexAppServerRuntimeOptions, t as CODEX_PLUGINS_MARKETPLACE_NAME, u as readCodexPluginConfig } from "./config-C_whBx3M.js";
-import { t as buildCodexProvider } from "./provider-DosqwRb6.js";
-import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-C5yYzx_6.js";
-import { i as describeControlFailure, n as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-CDioyur-.js";
-import { a as formatCodexDisplayText } from "./app-server-policy-xi0ZmBGO.js";
-import { a as getLeasedSharedCodexAppServerClient, d as resolveCodexAppServerAuthAccountCacheKey, m as resolveCodexAppServerFallbackApiKeyCacheKey, o as releaseLeasedSharedCodexAppServerClient, p as resolveCodexAppServerAuthProfileIdForAgent, r as clearSharedCodexAppServerClientIfCurrentAndWait } from "./shared-client-rR6TDJA3.js";
-import { a as createCodexCliSessionNodeInvokePolicies, c as resolveCodexCliSessionForBindingOnNode, i as createCodexCliSessionNodeHostCommands, l as resumeCodexCliSessionOnNode, n as handleCodexConversationInboundClaim, s as listCodexCliSessionsOnNode, t as handleCodexConversationBindingResolved } from "./conversation-binding-CEE2UyYb.js";
-import { t as requestCodexAppServerJson } from "./request-BQuSQF29.js";
+import { r as isJsonObject, t as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS } from "./protocol-2POPqAY4.js";
+import { d as resolveCodexAppServerRuntimeOptions, g as resolveOpenClawExecPolicyForCodexAppServer, i as codexSandboxPolicyForTurn, n as canUseCodexModelBackedApprovalsReviewerForModel, t as CODEX_PLUGINS_MARKETPLACE_NAME, u as readCodexPluginConfig } from "./config-CYEDnLJ2.js";
+import { r as assertCodexThreadStartResponse } from "./protocol-validators-dZQ-UTOa.js";
+import { K as defaultCodexAppInventoryCache, U as ensureCodexPluginActivation, W as pluginReadParams, d as resolveCodexAppServerRequestModelSelection, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-lifecycle-BskXnNP-.js";
+import { t as buildCodexProvider } from "./provider-cc_62eQE.js";
+import { _ as resolveCodexAppServerAuthAccountCacheKey, a as getLeasedSharedCodexAppServerClient, b as resolveCodexAppServerFallbackApiKeyCacheKey, o as releaseLeasedSharedCodexAppServerClient, r as clearSharedCodexAppServerClientIfCurrentAndWait, y as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-4ICy3U6d.js";
+import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
+import { i as normalizeCodexAppServerBindingModelProvider, o as sessionBindingIdentity, r as isCodexAppServerNativeAuthProfile } from "./session-binding-Dc03iwRF.js";
+import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-DgqRvU2_.js";
+import { i as describeControlFailure, n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-o-AHbdaf.js";
+import { a as formatCodexDisplayText, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BUk0GLMy.js";
+import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-DA2TQfZW.js";
+import { S as canMutateCodexHost, a as createCodexCliSessionNodeHostCommands, b as trackCodexConversationActiveTurn, c as listCodexCliSessionsOnNode, l as resolveCodexCliSessionForBindingOnNode, o as createCodexCliSessionNodeInvokePolicies, t as codexControlRequest, u as resumeCodexCliSessionOnNode, x as CODEX_NATIVE_EXECUTION_AUTH_ERROR } from "./command-rpc-BjgEPh19.js";
+import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData } from "./conversation-binding-data-BHRpYbX3.js";
+import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-Bo7KB3ks.js";
+import { t as requestCodexAppServerJson } from "./request-BcJyl8KL.js";
 import { t as createCodexWebSearchProviderBase } from "./web-search-provider.shared-BrZmlqyR.js";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
 import { resolveLivePluginConfigObject, resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
-import { asBoolean, isRecord, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import os from "node:os";
-import { loadAuthProfileStoreWithoutExternalProfiles, resolveAgentConfig, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+import { loadAuthProfileStoreWithoutExternalProfiles, resolveAgentConfig, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
+import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
+import { asBoolean, asOptionalRecord, isRecord, normalizeOptionalString, normalizeSingleOrTrimmedStringList, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { formatErrorMessage, resolveSandboxContext } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { jsonResult, readStringParam } from "openclaw/plugin-sdk/core";
 import { applyAuthProfileConfig, buildApiKeyCredential, buildOauthProviderAuthResult, buildOpenAICodexCredentialExtra, readCodexCliCredentialsCached, resolveOpenAICodexAuthIdentity, resolveOpenAICodexImportProfileName, updateAuthProfileStoreWithLock } from "openclaw/plugin-sdk/provider-auth";
+import { fileURLToPath } from "node:url";
 import { pathExists } from "openclaw/plugin-sdk/security-runtime";
+import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { MIGRATION_REASON_TARGET_EXISTS, applyMigrationManualItem, createMigrationItem, createMigrationManualItem, hasMigrationConfigPatchConflict, markMigrationItemConflict, markMigrationItemError, markMigrationItemSkipped, readMigrationConfigPath, summarizeMigrationItems, writeMigrationConfigPath } from "openclaw/plugin-sdk/migration";
 import { archiveMigrationItem, copyMigrationFileItem, withCachedMigrationConfigRuntime, writeMigrationReport } from "openclaw/plugin-sdk/migration-runtime";
+import { sleep } from "openclaw/plugin-sdk/runtime-env";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
+import { Type } from "typebox";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+//#region extensions/codex/src/app-server/session-binding-store.ts
+/** Defers schema compilation and auth loading until the first binding operation. */
+function createLazyCodexAppServerBindingStore(state) {
+	let resolved;
+	const store = () => resolved ??= import("./session-binding-Dc03iwRF.js").then((n) => n.s).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
+	return {
+		read: async (identity) => (await store()).read(identity),
+		mutate: async (identity, mutation) => (await store()).mutate(identity, mutation),
+		prepareSessionGenerationReclaim: async (identity) => (await store()).prepareSessionGenerationReclaim(identity),
+		adoptSessionGeneration: async (identity, previousSessionId) => (await store()).adoptSessionGeneration(identity, previousSessionId),
+		retireSessionGeneration: async (identity) => (await store()).retireSessionGeneration(identity),
+		withLease: async (identity, run) => (await store()).withLease(identity, run)
+	};
+}
+//#endregion
 //#region extensions/codex/src/commands.ts
 /** Creates the reserved `/codex` command definition exposed by the plugin. */
 function createCodexCommand(options) {
@@ -43,19 +74,815 @@ function createCodexCommand(options) {
 	};
 }
 /** Dispatches a `/codex` command to the subcommand handler and formats failures for chat. */
-async function handleCodexCommand(ctx, options = {}) {
-	const { loadSubcommandHandler, ...subcommandOptions } = options;
+async function handleCodexCommand(ctx, options) {
+	const { loadSubcommandHandler, resolvePluginConfig, ...subcommandOptions } = options;
 	try {
-		return await (loadSubcommandHandler ? await loadSubcommandHandler() : await loadDefaultCodexSubcommandHandler())(ctx, subcommandOptions);
+		return await (loadSubcommandHandler ? await loadSubcommandHandler() : await loadDefaultCodexSubcommandHandler())(ctx, {
+			...subcommandOptions,
+			pluginConfig: resolvePluginConfig?.() ?? subcommandOptions.pluginConfig
+		});
 	} catch (error) {
 		return { text: `Codex command failed: ${formatCodexDisplayText(describeControlFailure(error))}` };
 	}
 }
 async function loadDefaultCodexSubcommandHandler() {
-	const { handleCodexSubcommand } = await import("./command-handlers-vZy8xX5X.js");
+	const { handleCodexSubcommand } = await import("./command-handlers-UVniG5Hl.js");
 	return handleCodexSubcommand;
 }
 //#endregion
+//#region extensions/codex/src/conversation-turn-collector.ts
+const MAX_PENDING_NOTIFICATIONS_PER_TURN = 100;
+function createCodexConversationTurnCollector(threadId) {
+	let turnId;
+	let completed = false;
+	let failedError;
+	let timeout;
+	const assistantTextByItem = /* @__PURE__ */ new Map();
+	const assistantOrder = [];
+	const pendingNotificationsByTurnId = /* @__PURE__ */ new Map();
+	let resolveCompletion;
+	let rejectCompletion;
+	const rememberItem = (itemId) => {
+		if (!assistantOrder.includes(itemId)) assistantOrder.push(itemId);
+	};
+	const collectReplyText = () => {
+		return assistantOrder.map((itemId) => assistantTextByItem.get(itemId)?.trim()).filter((text) => Boolean(text)).at(-1) ?? "";
+	};
+	const clearWaitState = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = void 0;
+		}
+		resolveCompletion = void 0;
+		rejectCompletion = void 0;
+	};
+	const finish = () => {
+		if (completed) return;
+		completed = true;
+		if (failedError) rejectCompletion?.(new Error(failedError));
+		else resolveCompletion?.({ replyText: collectReplyText() });
+		clearWaitState();
+	};
+	const handleNotification = (notification) => {
+		const params = isJsonObject(notification.params) ? notification.params : void 0;
+		if (!params || readCodexNotificationThreadId(params) !== threadId) return;
+		if (!turnId) {
+			const pendingTurnId = readNotificationTurnId(params);
+			if (pendingTurnId) {
+				const pending = pendingNotificationsByTurnId.get(pendingTurnId) ?? [];
+				if (pending.length < MAX_PENDING_NOTIFICATIONS_PER_TURN) {
+					pending.push(notification);
+					pendingNotificationsByTurnId.set(pendingTurnId, pending);
+				}
+			}
+			return;
+		}
+		if (!isNotificationForTurn(params, threadId, turnId)) return;
+		if (notification.method === "item/agentMessage/delta") {
+			const itemId = readString(params, "itemId") ?? "assistant";
+			const delta = readTextString(params, "delta");
+			if (!delta) return;
+			rememberItem(itemId);
+			assistantTextByItem.set(itemId, `${assistantTextByItem.get(itemId) ?? ""}${delta}`);
+			return;
+		}
+		if (notification.method === "item/completed") {
+			const item = isJsonObject(params.item) ? params.item : void 0;
+			if (item?.type === "agentMessage") {
+				const itemId = readString(item, "id") ?? readString(params, "itemId") ?? "assistant";
+				const text = readTextString(item, "text");
+				if (text) {
+					rememberItem(itemId);
+					assistantTextByItem.set(itemId, text);
+				}
+			}
+			return;
+		}
+		if (notification.method === "turn/completed") {
+			const turn = isJsonObject(params.turn) ? params.turn : void 0;
+			if (readString(turn, "status") === "failed") failedError = readString(asOptionalRecord(turn?.error), "message") ?? "codex app-server turn failed";
+			const items = Array.isArray(turn?.items) ? turn.items : [];
+			for (const item of items) {
+				if (!isJsonObject(item) || item.type !== "agentMessage") continue;
+				const itemId = readString(item, "id") ?? `assistant-${assistantOrder.length + 1}`;
+				const text = readTextString(item, "text");
+				if (text) {
+					rememberItem(itemId);
+					assistantTextByItem.set(itemId, text);
+				}
+			}
+			finish();
+		}
+	};
+	return {
+		setTurnId(nextTurnId) {
+			turnId = nextTurnId;
+			const pending = pendingNotificationsByTurnId.get(nextTurnId) ?? [];
+			pendingNotificationsByTurnId.clear();
+			for (const notification of pending) handleNotification(notification);
+		},
+		handleNotification,
+		wait(params) {
+			if (completed) return failedError ? Promise.reject(new Error(failedError)) : Promise.resolve({ replyText: collectReplyText() });
+			return new Promise((resolve, reject) => {
+				resolveCompletion = resolve;
+				rejectCompletion = reject;
+				timeout = setTimeout(() => {
+					completed = true;
+					reject(/* @__PURE__ */ new Error("codex app-server bound turn timed out"));
+					clearWaitState();
+				}, resolveTimerTimeoutMs(params.timeoutMs, 100, 100));
+				timeout.unref?.();
+			});
+		}
+	};
+}
+function isNotificationForTurn(params, threadId, turnId) {
+	if (readCodexNotificationThreadId(params) !== threadId) return false;
+	if (!turnId) return true;
+	const directTurnId = readString(params, "turnId");
+	if (directTurnId) return directTurnId === turnId;
+	return readString(isJsonObject(params.turn) ? params.turn : void 0, "id") === turnId;
+}
+function readNotificationTurnId(params) {
+	return readCodexNotificationTurnId(params);
+}
+function readString(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readTextString(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+//#endregion
+//#region extensions/codex/src/conversation-turn-input.ts
+const IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".avif",
+	".gif",
+	".jpeg",
+	".jpg",
+	".png",
+	".webp"
+]);
+function buildCodexConversationTurnInput(params) {
+	return [{
+		type: "text",
+		text: params.prompt,
+		text_elements: []
+	}, ...extractInboundMedia(params.event).map(toCodexImageInput).filter((item) => item !== void 0)];
+}
+function extractInboundMedia(event) {
+	const metadata = event.metadata ?? {};
+	const paths = normalizeSingleOrTrimmedStringList(metadata.mediaPaths).concat(normalizeSingleOrTrimmedStringList(metadata.mediaPath));
+	const urls = normalizeSingleOrTrimmedStringList(metadata.mediaUrls).concat(normalizeSingleOrTrimmedStringList(metadata.mediaUrl));
+	const mimeTypes = normalizeSingleOrTrimmedStringList(metadata.mediaTypes).concat(normalizeSingleOrTrimmedStringList(metadata.mediaType));
+	const count = Math.max(paths.length, urls.length, mimeTypes.length);
+	const media = [];
+	for (let index = 0; index < count; index += 1) media.push({
+		path: paths[index],
+		url: urls[index],
+		mimeType: mimeTypes[index] ?? mimeTypes[0]
+	});
+	return media;
+}
+function toCodexImageInput(media) {
+	if (!isImageMedia(media)) return;
+	const localPath = media.path ?? readLocalMediaPath(media.url);
+	if (localPath) {
+		const normalized = normalizeFileUrl(localPath);
+		return normalized ? {
+			type: "localImage",
+			path: normalized
+		} : void 0;
+	}
+	return media.url ? {
+		type: "image",
+		url: media.url
+	} : void 0;
+}
+function isImageMedia(media) {
+	if (media.mimeType?.toLowerCase().startsWith("image/")) return true;
+	const candidate = media.path ?? media.url;
+	if (!candidate) return false;
+	return IMAGE_EXTENSIONS.has(path.extname(candidate.split(/[?#]/, 1)[0] ?? "").toLowerCase());
+}
+function normalizeFileUrl(value) {
+	if (!value.startsWith("file://")) return value;
+	try {
+		return fileURLToPath(value);
+	} catch {
+		return;
+	}
+}
+function readLocalMediaPath(value) {
+	if (!value) return;
+	if (value.startsWith("file://")) return value;
+	if (value.startsWith("//")) return;
+	if (path.isAbsolute(value) || path.win32.isAbsolute(value)) return value;
+	return /^[a-z][a-z0-9+.-]*:/i.test(value) ? void 0 : value;
+}
+//#endregion
+//#region extensions/codex/src/conversation-binding.ts
+const DEFAULT_BOUND_TURN_TIMEOUT_MS = 20 * 6e4;
+const DEFAULT_AGENT_ID = "main";
+const VALID_AGENT_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
+const INVALID_AGENT_ID_CHARS_PATTERN = /[^a-z0-9_-]+/g;
+const LEADING_DASH_PATTERN = /^-+/;
+const TRAILING_DASH_PATTERN = /-+$/;
+const NATIVE_CONVERSATION_INTERACTIVE_APPROVALS_UNAVAILABLE = "OpenClaw native Codex conversation binding cannot route interactive approvals yet; use the Codex harness or explicit /acp spawn codex for that workflow.";
+async function resolveConversationAppServerRuntime(params) {
+	const execPolicy = resolveConversationExecPolicy({
+		config: params.config,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey
+	});
+	const sandboxForPolicy = execPolicy.touched && execPolicy.security === "full" && execPolicy.ask !== "off" ? await resolveSandboxContext({
+		config: params.config,
+		sessionKey: params.sessionKey,
+		workspaceDir: params.workspaceDir
+	}) : void 0;
+	return {
+		execPolicy,
+		runtime: resolveCodexAppServerRuntimeOptions({
+			pluginConfig: params.pluginConfig,
+			execPolicy,
+			modelProvider: params.modelProvider,
+			model: params.model,
+			config: params.config,
+			agentDir: params.agentDir,
+			openClawSandboxActive: Boolean(sandboxForPolicy?.enabled)
+		})
+	};
+}
+const CODEX_CONVERSATION_GLOBAL_STATE = Symbol.for("openclaw.codex.conversationBinding");
+const CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS = "This Codex thread is bound to an OpenClaw conversation. Answer normally; OpenClaw will deliver your final response back to the conversation.";
+function getGlobalState() {
+	const globalState = globalThis;
+	globalState[CODEX_CONVERSATION_GLOBAL_STATE] ??= { queue: new KeyedAsyncQueue() };
+	return globalState[CODEX_CONVERSATION_GLOBAL_STATE];
+}
+async function handleCodexConversationInboundClaim(event, ctx, options) {
+	const data = readCodexConversationBindingData(ctx.pluginBinding);
+	if (!data) return;
+	if (event.commandAuthorized !== true) return { handled: true };
+	const prompt = event.bodyForAgent?.trim() || event.content?.trim() || "";
+	if (!prompt) return { handled: true };
+	if (!canMutateCodexHost(event)) return {
+		handled: true,
+		reply: { text: CODEX_NATIVE_EXECUTION_AUTH_ERROR }
+	};
+	const nativeExecutionBlock = data.kind === "codex-cli-node-session" ? resolveCodexNativeSandboxBlock({
+		config: options.config,
+		sessionKey: event.sessionKey ?? ctx.sessionKey,
+		surface: "Codex CLI node conversation binding"
+	}) : resolveCodexNativeExecutionBlock({
+		config: options.config,
+		sessionKey: event.sessionKey ?? ctx.sessionKey,
+		agentId: data.agentId,
+		surface: "Codex app-server conversation binding"
+	});
+	if (nativeExecutionBlock) return {
+		handled: true,
+		reply: { text: nativeExecutionBlock }
+	};
+	if (data.kind === "codex-cli-node-session") {
+		const resume = options.resumeCodexCliSessionOnNode;
+		if (!resume) return {
+			handled: true,
+			reply: { text: "Codex CLI node binding is unavailable because Gateway node runtime is not attached." }
+		};
+		try {
+			return {
+				handled: true,
+				reply: (await enqueueBoundTurn(`${data.nodeId}:${data.sessionId}`, async () => {
+					return { reply: { text: (await resume({
+						nodeId: data.nodeId,
+						sessionId: data.sessionId,
+						prompt,
+						cwd: data.cwd,
+						timeoutMs: options.timeoutMs
+					})).text.trim() || "Codex completed without a text reply." } };
+				})).reply
+			};
+		} catch (error) {
+			return {
+				handled: true,
+				reply: { text: `Codex CLI node turn failed: ${formatCodexDisplayText(formatErrorMessage(error))}` }
+			};
+		}
+	}
+	try {
+		return {
+			handled: true,
+			reply: (await enqueueBoundTurn(data.bindingId, () => runBoundTurnWithMissingThreadRecovery({
+				bindingStore: options.bindingStore,
+				data,
+				prompt,
+				event,
+				config: options.config,
+				sessionKey: event.sessionKey ?? ctx.sessionKey,
+				pluginConfig: options.pluginConfig,
+				timeoutMs: options.timeoutMs
+			}))).reply
+		};
+	} catch (error) {
+		return {
+			handled: true,
+			reply: { text: `Codex app-server turn failed: ${formatCodexDisplayText(formatErrorMessage(error))}` }
+		};
+	}
+}
+async function handleCodexConversationBindingResolved(event, options) {
+	if (event.status !== "denied") return;
+	const data = readCodexConversationBindingDataRecord(event.request.data ?? {});
+	if (!data || data.kind !== "codex-app-server-session") return;
+	const identity = conversationBindingIdentity(data);
+	const binding = await options.bindingStore.read(identity);
+	if (!data.start?.id || binding?.conversationStartId === data.start.id) await options.bindingStore.mutate(identity, { kind: "clear" });
+}
+async function resolveThreadBindingRuntime(params) {
+	const agentLookup = buildAgentLookup({
+		agentDir: params.agentDir,
+		config: params.config
+	});
+	const modelProvider = resolveThreadRequestModelProvider({
+		authProfileId: params.authProfileId,
+		modelProvider: params.modelProvider,
+		...agentLookup
+	});
+	const modelSelection = resolveOptionalThreadRequestModelSelection({
+		model: params.model,
+		modelProvider,
+		authProfileId: params.authProfileId,
+		...agentLookup
+	});
+	const reviewerModelProvider = resolveModelBackedReviewerPolicyProvider({
+		authProfileId: params.authProfileId,
+		modelProvider: params.modelProvider,
+		...agentLookup
+	});
+	const { execPolicy, runtime } = await resolveConversationAppServerRuntime({
+		pluginConfig: params.pluginConfig,
+		config: params.config,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		workspaceDir: params.workspaceDir,
+		modelProvider: reviewerModelProvider,
+		model: params.model,
+		agentDir: params.agentDir
+	});
+	const modelScopedRuntime = resolveCodexAppServerForModelProvider({
+		appServer: runtime,
+		provider: reviewerModelProvider,
+		model: params.model,
+		config: params.config,
+		env: process.env,
+		agentDir: params.agentDir
+	});
+	assertNativeConversationApprovalPolicySupported({
+		execPolicy,
+		approvalPolicy: execPolicy?.touched ? modelScopedRuntime.approvalPolicy : params.approvalPolicy ?? modelScopedRuntime.approvalPolicy,
+		approvalsReviewer: modelScopedRuntime.approvalsReviewer,
+		modelBackedApprovalsReviewerUnavailable: !canUseCodexModelBackedApprovalsReviewerForModel({
+			modelProvider: reviewerModelProvider,
+			model: params.model,
+			config: params.config,
+			env: process.env,
+			agentDir: params.agentDir
+		})
+	});
+	const client = await getLeasedSharedCodexAppServerClient({
+		startOptions: runtime.start,
+		timeoutMs: runtime.requestTimeoutMs,
+		authProfileId: params.authProfileId,
+		...agentLookup
+	});
+	return {
+		execPolicy,
+		runtime: modelScopedRuntime,
+		agentLookup,
+		model: modelSelection?.model,
+		modelProvider: modelSelection?.modelProvider ?? modelProvider,
+		client
+	};
+}
+function buildThreadRequestRuntimeOptions(params, resolved) {
+	const serviceTier = params.serviceTier ?? resolved.runtime.serviceTier;
+	const sandbox = resolved.execPolicy?.touched ? resolved.runtime.sandbox : params.sandbox ?? resolved.runtime.sandbox;
+	return {
+		approvalPolicy: resolved.execPolicy?.touched ? resolved.runtime.approvalPolicy : params.approvalPolicy ?? resolved.runtime.approvalPolicy,
+		approvalsReviewer: resolved.runtime.approvalsReviewer,
+		...codexConversationSandboxOrPermissions(resolved.runtime, sandbox),
+		...serviceTier ? { serviceTier } : {}
+	};
+}
+function codexConversationSandboxOrPermissions(runtime, sandbox) {
+	const networkProxy = runtime.networkProxy;
+	if (networkProxy) return { config: networkProxy.configPatch };
+	return { sandbox };
+}
+async function requestNewConversationBindingThread(params, resolved) {
+	return await resolved.client.request("thread/start", {
+		cwd: params.workspaceDir,
+		...resolved.model ? { model: resolved.model } : {},
+		...resolved.modelProvider ? { modelProvider: resolved.modelProvider } : {},
+		personality: CODEX_NATIVE_PERSONALITY_NONE,
+		...buildThreadRequestRuntimeOptions(params, resolved),
+		developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
+		experimentalRawEvents: true
+	}, { timeoutMs: resolved.runtime.requestTimeoutMs });
+}
+async function writeThreadBindingFromResponse(params, resolved, response) {
+	const runtimeApprovalPolicy = typeof resolved.runtime.approvalPolicy === "string" ? resolved.runtime.approvalPolicy : void 0;
+	if (!await params.bindingStore.mutate(params.identity, {
+		kind: "set",
+		binding: {
+			threadId: response.thread.id,
+			cwd: response.thread.cwd ?? params.workspaceDir,
+			authProfileId: params.authProfileId,
+			model: response.model ?? resolved.model ?? params.model,
+			modelProvider: normalizeCodexAppServerBindingModelProvider({
+				authProfileId: params.authProfileId,
+				modelProvider: response.modelProvider ?? resolved.modelProvider ?? params.modelProvider,
+				...resolved.agentLookup
+			}),
+			approvalPolicy: resolved.execPolicy?.touched ? runtimeApprovalPolicy : params.approvalPolicy ?? runtimeApprovalPolicy,
+			sandbox: resolved.execPolicy?.touched ? resolved.runtime.sandbox : params.sandbox ?? resolved.runtime.sandbox,
+			serviceTier: params.serviceTier ?? resolved.runtime.serviceTier ?? void 0,
+			networkProxyProfileName: resolved.runtime.networkProxy?.profileName,
+			networkProxyConfigFingerprint: resolved.runtime.networkProxy?.configFingerprint
+		}
+	})) throw new Error("Codex conversation binding changed while storing its thread.");
+}
+async function attachExistingThread(params) {
+	const resolved = await resolveThreadBindingRuntime(params);
+	try {
+		await writeThreadBindingFromResponse(params, resolved, resolved.runtime.networkProxy ? await requestNewConversationBindingThread(params, resolved) : await resolved.client.request(CODEX_CONTROL_METHODS.resumeThread, {
+			threadId: params.threadId,
+			...resolved.model ? { model: resolved.model } : {},
+			...resolved.modelProvider ? { modelProvider: resolved.modelProvider } : {},
+			personality: CODEX_NATIVE_PERSONALITY_NONE,
+			...buildThreadRequestRuntimeOptions(params, resolved)
+		}, { timeoutMs: resolved.runtime.requestTimeoutMs }));
+	} finally {
+		releaseLeasedSharedCodexAppServerClient(resolved.client);
+	}
+}
+async function createThread(params) {
+	const resolved = await resolveThreadBindingRuntime(params);
+	try {
+		await writeThreadBindingFromResponse(params, resolved, await requestNewConversationBindingThread(params, resolved));
+	} finally {
+		releaseLeasedSharedCodexAppServerClient(resolved.client);
+	}
+}
+async function runBoundTurn(params) {
+	const agentLookup = buildAgentLookup({
+		agentDir: params.data.agentDir,
+		config: params.config
+	});
+	const identity = conversationBindingIdentity(params.data);
+	const binding = await params.bindingStore.read(identity);
+	if (!binding?.threadId) throw new Error("bound Codex conversation has no thread binding");
+	let threadId = binding.threadId;
+	const workspaceDir = binding.cwd || params.data.workspaceDir;
+	const reviewerModelProvider = resolveModelBackedReviewerPolicyProvider({
+		authProfileId: binding.authProfileId,
+		modelProvider: binding.modelProvider,
+		...agentLookup
+	});
+	const { execPolicy, runtime } = await resolveConversationAppServerRuntime({
+		pluginConfig: params.pluginConfig,
+		config: params.config,
+		agentId: params.data.agentId,
+		sessionKey: params.sessionKey,
+		workspaceDir,
+		modelProvider: reviewerModelProvider,
+		model: binding.model,
+		agentDir: params.data.agentDir
+	});
+	const modelScopedRuntime = resolveCodexAppServerForModelProvider({
+		appServer: runtime,
+		provider: reviewerModelProvider,
+		model: binding.model,
+		config: params.config,
+		env: process.env,
+		agentDir: params.data.agentDir
+	});
+	const modelBackedApprovalsReviewerUnavailable = !canUseCodexModelBackedApprovalsReviewerForModel({
+		modelProvider: reviewerModelProvider,
+		model: binding.model,
+		config: params.config,
+		env: process.env,
+		agentDir: params.data.agentDir
+	});
+	const useModelScopedPolicy = execPolicy?.touched === true || modelBackedApprovalsReviewerUnavailable;
+	const approvalPolicy = useModelScopedPolicy ? modelScopedRuntime.approvalPolicy : binding.approvalPolicy ?? modelScopedRuntime.approvalPolicy;
+	const sandbox = useModelScopedPolicy ? modelScopedRuntime.sandbox : binding.sandbox ?? modelScopedRuntime.sandbox;
+	const permissionProfile = modelScopedRuntime.networkProxy?.profileName;
+	const networkProxyConfigFingerprint = modelScopedRuntime.networkProxy?.configFingerprint;
+	const networkProxyBindingChanged = binding.networkProxyProfileName !== permissionProfile || binding.networkProxyConfigFingerprint !== networkProxyConfigFingerprint;
+	const serviceTier = binding.serviceTier ?? runtime.serviceTier;
+	let useStickyNetworkProfile = permissionProfile !== void 0 && binding.networkProxyProfileName === permissionProfile && binding.networkProxyConfigFingerprint === networkProxyConfigFingerprint;
+	assertNativeConversationApprovalPolicySupported({
+		execPolicy,
+		approvalPolicy,
+		approvalsReviewer: modelScopedRuntime.approvalsReviewer,
+		modelBackedApprovalsReviewerUnavailable
+	});
+	const modelSelection = binding.model ? resolveCodexAppServerRequestModelSelection({
+		model: binding.model,
+		modelProvider: binding.modelProvider,
+		authProfileId: binding.authProfileId,
+		...agentLookup
+	}) : void 0;
+	const client = await getLeasedSharedCodexAppServerClient({
+		startOptions: runtime.start,
+		timeoutMs: runtime.requestTimeoutMs,
+		authProfileId: binding.authProfileId,
+		...agentLookup
+	});
+	let notificationCleanup = () => void 0;
+	let requestCleanup = () => void 0;
+	try {
+		if (networkProxyBindingChanged) {
+			const response = assertCodexThreadStartResponse(await client.request("thread/start", {
+				cwd: workspaceDir,
+				...modelSelection?.model ? { model: modelSelection.model } : {},
+				...modelSelection?.modelProvider ? { modelProvider: modelSelection.modelProvider } : {},
+				personality: CODEX_NATIVE_PERSONALITY_NONE,
+				approvalPolicy,
+				approvalsReviewer: modelScopedRuntime.approvalsReviewer,
+				...modelScopedRuntime.networkProxy ? { config: modelScopedRuntime.networkProxy.configPatch } : { sandbox },
+				...serviceTier ? { serviceTier } : {},
+				developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
+				experimentalRawEvents: true
+			}, { timeoutMs: runtime.requestTimeoutMs }));
+			threadId = response.thread.id;
+			if (!await params.bindingStore.mutate(identity, {
+				kind: "set",
+				binding: {
+					threadId,
+					cwd: response.thread.cwd ?? workspaceDir,
+					authProfileId: binding.authProfileId,
+					model: response.model ?? modelSelection?.model ?? binding.model,
+					modelProvider: normalizeCodexAppServerBindingModelProvider({
+						authProfileId: binding.authProfileId,
+						modelProvider: response.modelProvider ?? modelSelection?.modelProvider ?? binding.modelProvider,
+						...agentLookup
+					}),
+					approvalPolicy: typeof approvalPolicy === "string" ? approvalPolicy : void 0,
+					sandbox,
+					serviceTier: serviceTier ?? void 0,
+					networkProxyProfileName: modelScopedRuntime.networkProxy?.profileName,
+					networkProxyConfigFingerprint: modelScopedRuntime.networkProxy?.configFingerprint,
+					conversationStartId: binding.conversationStartId,
+					conversationSourceTransferComplete: binding.conversationSourceTransferComplete,
+					historyCoveredThrough: binding.historyCoveredThrough
+				}
+			})) throw new Error("Codex conversation binding changed while rotating its thread.");
+			useStickyNetworkProfile = modelScopedRuntime.networkProxy !== void 0;
+		}
+		const collector = createCodexConversationTurnCollector(threadId);
+		notificationCleanup = client.addNotificationHandler((notification) => collector.handleNotification(notification));
+		requestCleanup = client.addRequestHandler(async (request) => {
+			if (request.method === "item/tool/call") return {
+				contentItems: [{
+					type: "inputText",
+					text: "OpenClaw native Codex conversation binding does not expose dynamic OpenClaw tools yet."
+				}],
+				success: false
+			};
+			if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") return {
+				decision: "decline",
+				reason: "OpenClaw native Codex conversation binding cannot route interactive approvals yet; use the Codex harness or explicit /acp spawn codex for that workflow."
+			};
+			if (request.method === "item/permissions/requestApproval") return {
+				permissions: {},
+				scope: "turn"
+			};
+			if (request.method.includes("requestApproval")) return {
+				decision: "decline",
+				reason: "OpenClaw native Codex conversation binding cannot route interactive approvals yet; use the Codex harness or explicit /acp spawn codex for that workflow."
+			};
+		});
+		const turnId = (await client.request("turn/start", {
+			threadId,
+			input: buildCodexConversationTurnInput({
+				prompt: params.prompt,
+				event: params.event
+			}),
+			cwd: workspaceDir,
+			approvalPolicy,
+			approvalsReviewer: modelScopedRuntime.approvalsReviewer,
+			...useStickyNetworkProfile ? {} : { sandboxPolicy: codexSandboxPolicyForTurn(sandbox, workspaceDir) },
+			...modelSelection?.model ? { model: modelSelection.model } : {},
+			personality: CODEX_NATIVE_PERSONALITY_NONE,
+			...serviceTier ? { serviceTier } : {}
+		}, { timeoutMs: runtime.requestTimeoutMs })).turn.id;
+		const activeCleanup = trackCodexConversationActiveTurn({
+			identity,
+			threadId,
+			turnId
+		});
+		collector.setTurnId(turnId);
+		return { reply: { text: (await collector.wait({ timeoutMs: params.timeoutMs ?? DEFAULT_BOUND_TURN_TIMEOUT_MS }).finally(activeCleanup)).replyText.trim() || "Codex completed without a text reply." } };
+	} finally {
+		notificationCleanup();
+		requestCleanup();
+		releaseLeasedSharedCodexAppServerClient(client);
+	}
+}
+function assertNativeConversationApprovalPolicySupported(params) {
+	if (params.approvalPolicy !== "never" && (params.execPolicy?.touched === true || params.modelBackedApprovalsReviewerUnavailable && params.approvalsReviewer === "user")) throw new Error(NATIVE_CONVERSATION_INTERACTIVE_APPROVALS_UNAVAILABLE);
+}
+async function runBoundTurnWithMissingThreadRecovery(params) {
+	await prepareConversationBinding(params);
+	try {
+		return await runBoundTurn(params);
+	} catch (error) {
+		if (!isCodexThreadNotFoundError(error)) throw error;
+		await prepareConversationBinding(params, { forceNew: true });
+		return await runBoundTurn(params);
+	}
+}
+async function prepareConversationBinding(params, options = {}) {
+	const identity = conversationBindingIdentity(params.data);
+	await params.bindingStore.withLease(identity, async () => {
+		const current = await params.bindingStore.read(identity);
+		const requested = params.data.start && current?.conversationStartId !== params.data.start.id ? params.data.start : void 0;
+		if (current && !requested && !options.forceNew) return;
+		const sourceIdentity = params.data.source ? sessionBindingIdentity({
+			agentId: params.data.source.agentId,
+			sessionId: params.data.source.sessionId,
+			sessionKey: params.data.source.sessionKey,
+			config: params.config
+		}) : void 0;
+		const sourceBinding = sourceIdentity ? await params.bindingStore.read(sourceIdentity) : void 0;
+		const inherited = current ?? sourceBinding;
+		const execPolicy = resolveConversationExecPolicy({
+			config: params.config,
+			agentId: params.data.agentId,
+			sessionKey: params.sessionKey
+		});
+		const agentLookup = buildAgentLookup({
+			agentDir: params.data.agentDir,
+			config: params.config
+		});
+		const bindingParams = {
+			bindingStore: params.bindingStore,
+			identity,
+			pluginConfig: params.pluginConfig,
+			workspaceDir: requested ? params.data.workspaceDir : inherited?.cwd ?? params.data.workspaceDir,
+			...agentLookup,
+			model: requested?.model ?? inherited?.model,
+			modelProvider: requested?.modelProvider ?? inherited?.modelProvider,
+			authProfileId: requested?.authProfileId ?? inherited?.authProfileId,
+			approvalPolicy: execPolicy.touched ? void 0 : inherited?.approvalPolicy,
+			sandbox: execPolicy.touched ? void 0 : inherited?.sandbox,
+			serviceTier: inherited?.serviceTier,
+			config: params.config,
+			sessionKey: params.sessionKey,
+			agentId: params.data.agentId
+		};
+		const threadId = requested?.threadId ?? (!current ? params.data.source?.threadId : void 0);
+		if (threadId && !options.forceNew) await attachExistingThread({
+			...bindingParams,
+			threadId
+		});
+		else await createThread(bindingParams);
+		const stored = await params.bindingStore.read(identity);
+		if (!stored) throw new Error("Codex conversation binding disappeared while initializing its thread.");
+		if (sourceIdentity && params.data.source && !current?.conversationSourceTransferComplete) await params.bindingStore.withLease(sourceIdentity, async () => {
+			const source = await params.bindingStore.read(sourceIdentity);
+			if (source && source.threadId === params.data.source?.threadId) await params.bindingStore.mutate(sourceIdentity, {
+				kind: "clear",
+				threadId: source.threadId
+			});
+		});
+		if (!await params.bindingStore.mutate(identity, {
+			kind: "patch",
+			threadId: stored.threadId,
+			patch: {
+				...params.data.start ? { conversationStartId: params.data.start.id } : {},
+				...sourceIdentity ? { conversationSourceTransferComplete: true } : {}
+			}
+		})) throw new Error("Codex conversation binding changed while initializing its thread.");
+	});
+}
+function resolveConversationExecPolicy(params) {
+	const agentId = params.agentId ?? (params.config ? resolveSessionAgentIds({
+		sessionKey: params.sessionKey,
+		config: params.config
+	}).sessionAgentId : void 0);
+	return resolveOpenClawExecPolicyForCodexAppServer({
+		config: params.config,
+		agentId,
+		execOverrides: readSessionExecOverrides({
+			config: params.config,
+			agentId,
+			sessionKey: params.sessionKey
+		}),
+		approvals: loadExecApprovals()
+	});
+}
+function readSessionExecOverrides(params) {
+	const sessionKey = params.sessionKey?.trim();
+	if (!params.config || !sessionKey) return;
+	if (!canReadSessionExecOverrides({
+		config: params.config,
+		agentId: params.agentId,
+		sessionKey
+	})) return;
+	const entry = getSessionEntry({
+		storePath: resolveStorePath(params.config.session?.store, { agentId: params.agentId }),
+		sessionKey,
+		readConsistency: "latest"
+	});
+	if (!entry?.execSecurity && !entry?.execAsk) return;
+	return {
+		security: entry.execSecurity,
+		ask: entry.execAsk
+	};
+}
+function canReadSessionExecOverrides(params) {
+	const agentId = normalizeAgentIdOrDefault(params.agentId);
+	if (!agentId) return true;
+	const sessionAgentId = parseAgentIdFromSessionKey(params.sessionKey);
+	if (!sessionAgentId) return isDefaultAgentSessionKeyForAgent({
+		config: params.config,
+		agentId
+	});
+	return sessionAgentId === agentId;
+}
+function parseAgentIdFromSessionKey(sessionKey) {
+	const raw = sessionKey?.trim();
+	if (!raw) return;
+	const parts = raw.toLowerCase().split(":").filter(Boolean);
+	if (parts.length < 3 || parts[0] !== "agent" || !parts[2]) return;
+	return normalizeAgentIdOrDefault(parts[1]);
+}
+function isDefaultAgentSessionKeyForAgent(params) {
+	return normalizeAgentId(params.agentId) === resolveDefaultPolicyAgentId(params.config);
+}
+function resolveDefaultPolicyAgentId(config) {
+	const agents = (config.agents?.list ?? []).filter((entry) => entry !== null && typeof entry === "object");
+	return normalizeAgentId((agents.find((entry) => entry?.default) ?? agents[0])?.id);
+}
+function normalizeAgentIdOrDefault(value) {
+	const normalized = normalizeAgentId(value);
+	return normalized === DEFAULT_AGENT_ID && !(value ?? "").trim() ? void 0 : normalized;
+}
+function normalizeAgentId(value) {
+	const trimmed = (value ?? "").trim();
+	if (!trimmed) return DEFAULT_AGENT_ID;
+	const normalized = trimmed.toLowerCase();
+	if (VALID_AGENT_ID_PATTERN.test(trimmed)) return normalized;
+	return normalized.replace(INVALID_AGENT_ID_CHARS_PATTERN, "-").replace(LEADING_DASH_PATTERN, "").replace(TRAILING_DASH_PATTERN, "").slice(0, 64) || DEFAULT_AGENT_ID;
+}
+function isCodexThreadNotFoundError(error) {
+	const message = formatErrorMessage(error);
+	return /\bthread not found:/iu.test(message) || /\bbound Codex conversation has no thread binding\b/u.test(message);
+}
+function enqueueBoundTurn(key, run) {
+	return getGlobalState().queue.enqueue(key, run);
+}
+function resolveThreadRequestModelProvider(params) {
+	const modelProvider = params.modelProvider?.trim();
+	if (!modelProvider || modelProvider.toLowerCase() === "codex") return;
+	if (isCodexAppServerNativeAuthProfile(params) && modelProvider.toLowerCase() === "openai") return;
+	return modelProvider.toLowerCase() === "openai" ? "openai" : modelProvider;
+}
+function resolveOptionalThreadRequestModelSelection(params) {
+	if (!params.model?.trim()) return;
+	return resolveCodexAppServerRequestModelSelection({
+		model: params.model,
+		modelProvider: params.modelProvider,
+		authProfileId: params.authProfileId,
+		agentDir: params.agentDir,
+		config: params.config
+	});
+}
+function resolveModelBackedReviewerPolicyProvider(params) {
+	const modelProvider = params.modelProvider?.trim();
+	if (modelProvider && modelProvider.toLowerCase() !== "codex") return modelProvider.toLowerCase() === "openai" ? "openai" : modelProvider;
+	return isCodexAppServerNativeAuthProfile(params) ? "openai" : void 0;
+}
+function buildAgentLookup(params) {
+	const agentDir = params.agentDir?.trim();
+	return {
+		...agentDir ? { agentDir } : {},
+		...params.config ? { config: params.config } : {}
+	};
+}
+function conversationBindingIdentity(data) {
+	return {
+		kind: "conversation",
+		bindingId: data.bindingId
+	};
+}
+//#endregion
 //#region extensions/codex/src/migration/helpers.ts
 async function exists(filePath) {
 	return await pathExists(filePath);
@@ -1405,11 +2232,6 @@ function targetCodexMarketplaceDiscoveryTimeoutMs(env = process.env) {
 function isCodexPluginLoadWarningItem(item) {
 	return item.kind === "plugin" && item.action === "install" && item.status === "warning" && item.details?.warningReason === CODEX_PLUGIN_LOAD_WARNING;
 }
-async function sleep(ms) {
-	await new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
 async function buildTargetCodexPluginAppCacheKey(ctx) {
 	const targets = resolveCodexMigrationTargets(ctx);
 	const appServer = resolveTargetCodexAppServer(ctx);
@@ -1547,12 +2369,221 @@ function buildCodexMigrationProvider(params = {}) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/web-search-provider.ts
-let codexWebSearchRuntimePromise;
-function loadCodexWebSearchRuntime() {
-	codexWebSearchRuntimePromise ??= import("./web-search-provider.runtime-Q89rQhsL.js");
-	return codexWebSearchRuntimePromise;
+//#region extensions/codex/src/native-thread-tool.ts
+/**
+* Owner-only access to native Codex threads stored in the user's Codex home.
+*/
+const ListParamsSchema = Type.Object({
+	action: Type.Literal("list"),
+	archived: Type.Optional(Type.Boolean()),
+	cursor: Type.Optional(Type.String()),
+	limit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 100
+	})),
+	search: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const ReadParamsSchema = Type.Object({
+	action: Type.Literal("read"),
+	thread_id: Type.String(),
+	include_turns: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+const ForkParamsSchema = Type.Object({
+	action: Type.Literal("fork"),
+	thread_id: Type.String(),
+	attach: Type.Optional(Type.Boolean({
+		default: true,
+		description: "Attach the fork to this OpenClaw session for its next turn."
+	}))
+}, { additionalProperties: false });
+const RenameParamsSchema = Type.Object({
+	action: Type.Literal("rename"),
+	thread_id: Type.String(),
+	name: Type.String()
+}, { additionalProperties: false });
+const ArchiveParamsSchema = Type.Object({
+	action: Type.Literal("archive"),
+	thread_id: Type.String(),
+	confirm: Type.Literal(true, { description: "Required acknowledgement that the thread is closed in other Codex clients." })
+}, { additionalProperties: false });
+const UnarchiveParamsSchema = Type.Object({
+	action: Type.Literal("unarchive"),
+	thread_id: Type.String()
+}, { additionalProperties: false });
+const CodexThreadsParamsSchema = Type.Union([
+	ListParamsSchema,
+	ReadParamsSchema,
+	ForkParamsSchema,
+	RenameParamsSchema,
+	ArchiveParamsSchema,
+	UnarchiveParamsSchema
+]);
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readBoolean(value, fallback = false) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function readLimit(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 100 ? value : void 0;
+}
+function resolveToolSession(context, runtime) {
+	const sessionKey = context.sessionKey?.trim();
+	if (!sessionKey) return;
+	const entry = runtime.agent.session.getSessionEntry({
+		agentId: context.agentId,
+		sessionKey,
+		readConsistency: "latest"
+	});
+	const sessionId = context.sessionId?.trim() || entry?.sessionId?.trim();
+	if (!sessionId) return;
+	const storePath = runtime.agent.session.resolveStorePath(void 0, { agentId: context.agentId });
+	return {
+		sessionId,
+		sessionFile: runtime.agent.session.resolveSessionFilePath(sessionId, entry, {
+			agentId: context.agentId,
+			sessionsDir: path.dirname(storePath)
+		})
+	};
 }
+function readThreadId(params) {
+	return readStringParam(params, "thread_id", {
+		required: true,
+		label: "thread_id"
+	});
+}
+function readThreadStatusType(value) {
+	if (!isJsonObject(value) || !isJsonObject(value.thread) || !isJsonObject(value.thread.status)) return;
+	return typeof value.thread.status.type === "string" ? value.thread.status.type : void 0;
+}
+/** Builds the native Codex thread tool only for owner runs in shared-user-home mode. */
+function createCodexThreadsTool(options) {
+	if (options.context.senderIsOwner !== true) return null;
+	if (readCodexPluginConfig(options.getPluginConfig()).appServer?.homeScope !== "user") return null;
+	const request = options.request ?? codexControlRequest;
+	const requestOptions = () => ({
+		agentDir: options.context.agentDir,
+		config: options.context.getRuntimeConfig?.() ?? options.context.runtimeConfig ?? options.context.config,
+		sessionId: options.context.sessionId,
+		sessionKey: options.context.sessionKey
+	});
+	const currentSession = () => resolveToolSession(options.context, options.runtime);
+	const currentIdentity = (sessionId) => {
+		return sessionBindingIdentity({
+			sessionId,
+			sessionKey: options.context.sessionKey,
+			agentId: options.context.agentId,
+			config: requestOptions().config
+		});
+	};
+	const currentBinding = async (session) => session ? await options.bindingStore.read(currentIdentity(session.sessionId)) : void 0;
+	return {
+		name: "codex_threads",
+		label: "Codex Threads",
+		description: "List, read, fork, rename, archive, or restore native Codex threads. Fork to continue a thread safely across Codex clients; do not resume the same thread from two clients.",
+		parameters: CodexThreadsParamsSchema,
+		async execute(_toolCallId, rawParams) {
+			const params = asRecord(rawParams);
+			const action = readStringParam(params, "action", {
+				required: true,
+				label: "action"
+			});
+			const pluginConfig = options.getPluginConfig();
+			if (action === "list") {
+				const cursor = readStringParam(params, "cursor");
+				const searchTerm = readStringParam(params, "search");
+				return jsonResult(await request(pluginConfig, CODEX_CONTROL_METHODS.listThreads, {
+					archived: readBoolean(params.archived),
+					limit: readLimit(params.limit) ?? 20,
+					modelProviders: [],
+					sortKey: "recency_at",
+					sortDirection: "desc",
+					sourceKinds: [...CODEX_INTERACTIVE_THREAD_SOURCE_KINDS],
+					...cursor ? { cursor } : {},
+					...searchTerm ? { searchTerm } : {}
+				}, requestOptions()));
+			}
+			const threadId = readThreadId(params);
+			if (action === "read") return jsonResult(await request(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
+				threadId,
+				includeTurns: readBoolean(params.include_turns)
+			}, requestOptions()));
+			if (action === "rename") {
+				const name = readStringParam(params, "name", {
+					required: true,
+					label: "name"
+				});
+				await request(pluginConfig, CODEX_CONTROL_METHODS.renameThread, {
+					threadId,
+					name
+				}, requestOptions());
+				return jsonResult({
+					action,
+					threadId,
+					name
+				});
+			}
+			if (action === "unarchive") return jsonResult(await request(pluginConfig, CODEX_CONTROL_METHODS.unarchiveThread, { threadId }, requestOptions()));
+			const session = currentSession();
+			const binding = await currentBinding(session);
+			if (action === "archive") {
+				if (params.confirm !== true) throw new Error("confirm=true is required to archive a native Codex thread");
+				if (binding?.threadId === threadId) {
+					if (readThreadStatusType(await request(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
+						threadId,
+						includeTurns: false
+					}, requestOptions())) === "active") throw new Error("cannot archive the Codex thread active in this OpenClaw session");
+				}
+				await request(pluginConfig, CODEX_CONTROL_METHODS.archiveThread, { threadId }, requestOptions());
+				if (session && binding?.threadId === threadId) await options.bindingStore.mutate(currentIdentity(session.sessionId), {
+					kind: "clear",
+					threadId
+				});
+				return jsonResult({
+					action,
+					threadId
+				});
+			}
+			if (action !== "fork") throw new Error(`unsupported codex_threads action: ${action}`);
+			const attach = readBoolean(params.attach, true);
+			if (attach && !session) throw new Error("cannot attach a Codex fork without an active OpenClaw session");
+			if (attach && binding?.threadId === threadId) {
+				if (readThreadStatusType(await request(pluginConfig, CODEX_CONTROL_METHODS.readThread, {
+					threadId,
+					includeTurns: false
+				}, requestOptions())) === "active") throw new Error("cannot replace the Codex thread active in this OpenClaw turn");
+			}
+			const response = await request(pluginConfig, CODEX_CONTROL_METHODS.forkThread, {
+				threadId,
+				threadSource: "user"
+			}, requestOptions());
+			if (!isJsonObject(response) || !isJsonObject(response.thread)) throw new Error("Codex app-server returned an invalid thread/fork response");
+			const forkThreadId = typeof response.thread.id === "string" && response.thread.id.trim() ? response.thread.id : void 0;
+			if (!forkThreadId) throw new Error("Codex app-server thread/fork response did not include a thread id");
+			if (attach && session) {
+				if (!await options.bindingStore.mutate(currentIdentity(session.sessionId), {
+					kind: "set",
+					binding: {
+						threadId: forkThreadId,
+						cwd: typeof response.thread.cwd === "string" ? response.thread.cwd : options.context.workspaceDir ?? "",
+						model: typeof response.model === "string" ? response.model : void 0,
+						modelProvider: typeof response.modelProvider === "string" ? response.modelProvider : void 0,
+						historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
+					}
+				})) throw new Error("Codex session binding changed before the fork could be attached");
+			}
+			return jsonResult({
+				action,
+				sourceThreadId: threadId,
+				thread: response.thread,
+				attached: attach
+			});
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/web-search-provider.ts
+const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./web-search-provider.runtime-B5F42P7x.js"));
 const CodexWebSearchSchema = {
 	type: "object",
 	properties: { query: {
@@ -1584,6 +2615,13 @@ function createCodexWebSearchProvider(options = {}) {
 }
 //#endregion
 //#region extensions/codex/index.ts
+const ENDED_SESSION_REASONS = /* @__PURE__ */ new Set([
+	"new",
+	"reset",
+	"idle",
+	"daily",
+	"deleted"
+]);
 var codex_default = definePluginEntry({
 	id: "codex",
 	name: "Codex",
@@ -1591,16 +2629,40 @@ var codex_default = definePluginEntry({
 	register(api) {
 		const resolveCurrentConfig = () => api.runtime.config?.current ? api.runtime.config.current() : void 0;
 		const resolveCurrentPluginConfig = () => resolveLivePluginConfigObject(resolveCurrentConfig, "codex", api.pluginConfig) ?? api.pluginConfig;
-		api.registerAgentHarness(createCodexAppServerAgentHarness({ resolvePluginConfig: resolveCurrentPluginConfig }));
+		const bindingStore = createLazyCodexAppServerBindingStore(api.runtime.state.openSyncKeyedStore({
+			namespace: CODEX_APP_SERVER_BINDING_NAMESPACE,
+			maxEntries: CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
+			overflowPolicy: "reject-new"
+		}));
+		api.registerAgentHarness(createCodexAppServerAgentHarness({
+			bindingStore,
+			resolveConfig: resolveCurrentConfig,
+			resolvePluginConfig: resolveCurrentPluginConfig
+		}));
 		api.registerProvider(buildCodexProvider({ pluginConfig: api.pluginConfig }));
 		api.registerMediaUnderstandingProvider(buildCodexMediaUnderstandingProvider({ pluginConfig: api.pluginConfig }));
 		api.registerWebSearchProvider(createCodexWebSearchProvider({ resolvePluginConfig: resolveCurrentPluginConfig }));
 		api.registerMigrationProvider(buildCodexMigrationProvider({ runtime: api.runtime }));
+		api.registerTool((context) => createCodexThreadsTool({
+			bindingStore,
+			context,
+			runtime: api.runtime,
+			getPluginConfig: resolveCurrentPluginConfig
+		}), { name: "codex_threads" });
+		api.registerToolMetadata({
+			toolName: "codex_threads",
+			displayName: "Codex Threads",
+			description: "Manage native Codex threads in the shared user Codex home.",
+			risk: "high",
+			tags: ["codex", "sessions"]
+		});
 		for (const command of createCodexCliSessionNodeHostCommands()) api.registerNodeHostCommand(command);
 		for (const policy of createCodexCliSessionNodeInvokePolicies()) api.registerNodeInvokePolicy(policy);
 		api.registerCommand(createCodexCommand({
 			pluginConfig: api.pluginConfig,
+			resolvePluginConfig: resolveCurrentPluginConfig,
 			deps: {
+				bindingStore,
 				listCodexCliSessionsOnNode: (params) => listCodexCliSessionsOnNode({
 					runtime: api.runtime,
 					...params
@@ -1649,6 +2711,7 @@ var codex_default = definePluginEntry({
 			}
 		}));
 		api.on("inbound_claim", (event, ctx) => handleCodexConversationInboundClaim(event, ctx, {
+			bindingStore,
 			pluginConfig: resolveCurrentPluginConfig(),
 			config: resolveCurrentConfig(),
 			resumeCodexCliSessionOnNode: (params) => resumeCodexCliSessionOnNode({
@@ -1656,7 +2719,35 @@ var codex_default = definePluginEntry({
 				...params
 			})
 		}));
-		api.onConversationBindingResolved?.(handleCodexConversationBindingResolved);
+		api.onConversationBindingResolved?.((event) => handleCodexConversationBindingResolved(event, { bindingStore }));
+		api.on("after_compaction", async (event, ctx) => {
+			const previousSessionId = event.previousSessionId?.trim();
+			const sessionId = ctx.sessionId?.trim();
+			if (!previousSessionId || !sessionId || previousSessionId === sessionId) return;
+			const config = resolveCurrentConfig();
+			const sessionKey = ctx.sessionKey?.trim();
+			const { sessionBindingIdentity } = await import("./session-binding-Dc03iwRF.js").then((n) => n.s);
+			const identity = sessionBindingIdentity({
+				sessionId,
+				...sessionKey ? { sessionKey } : {},
+				...ctx.agentId ? { agentId: ctx.agentId } : {},
+				...config ? { config } : {}
+			});
+			const adopted = await bindingStore.adoptSessionGeneration(identity, previousSessionId);
+			if (adopted === "conflict") api.logger.warn?.(`codex: could not adopt compacted session generation ${sessionId} (${adopted}); secondary native compaction will skip`);
+		});
+		api.on("session_end", async (event, ctx) => {
+			if (!event.reason || !ENDED_SESSION_REASONS.has(event.reason)) return;
+			const sessionKey = event.sessionKey ?? ctx.sessionKey;
+			const config = resolveCurrentConfig();
+			const { sessionBindingIdentity } = await import("./session-binding-Dc03iwRF.js").then((n) => n.s);
+			await bindingStore.retireSessionGeneration(sessionBindingIdentity({
+				sessionId: event.sessionId,
+				...sessionKey ? { sessionKey } : {},
+				...ctx.agentId ? { agentId: ctx.agentId } : {},
+				...config ? { config } : {}
+			}));
+		});
 	}
 });
 //#endregion