@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/{session-binding-DPxIvMgE.js → config-Cxw3Cl3k.js}

@@ -1,22 +1,52 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
-import { asOptionalRecord, asOptionalRecord as readRecord, normalizeOptionalString as readNonEmptyString, normalizeTrimmedStringList, parseBooleanValue } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { n as readCodexAppServerConfigOptions, t as normalizeCodexAppServerArgs } from "./launch-args-sXOAg0SX.js";
+import { asNullableRecord, asOptionalRecord as readRecord, normalizeOptionalString, normalizeOptionalString as readNonEmptyString, normalizeTrimmedStringList, parseBooleanValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path from "node:path";
 import { resolvePositiveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
+import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { createHash, createHmac, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import { ensureAuthProfileStore, resolveDefaultAgentDir, resolveProviderIdForAuth, resolveSessionAgentIds as resolveSessionAgentIds$1 } from "openclaw/plugin-sdk/agent-runtime";
-import { parse } from "smol-toml";
+import { resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveAgentConfig as resolveAgentConfig$1 } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { resolveExecApprovalsFromFile } from "openclaw/plugin-sdk/exec-approvals-runtime";
-import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { buildSecretInputSchema, normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { detectWindowsSpawnCommandInlineArgs } from "openclaw/plugin-sdk/windows-spawn";
 import { z } from "zod";
+import { parse } from "smol-toml";
 import { isLoopbackHost } from "openclaw/plugin-sdk/ssrf-runtime";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+//#region extensions/codex/src/app-server/auth-start-options.ts
+const CODEX_APP_SERVER_HOME_DIRNAME = "codex-home";
+const CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE = "cli_auth_credentials_store=\"ephemeral\"";
+function resolveCodexAppServerHomeDir(agentDir) {
+	return path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME);
+}
+/** Resolves the native user Codex home used by Desktop and the CLI. */
+function resolveCodexAppServerUserHomeDir(env = process.env, homedir$1 = homedir) {
+	const configured = normalizeOptionalString(env.CODEX_HOME);
+	return path.resolve(configured ?? path.join(homedir$1(), ".codex"));
+}
+/** Resolves the local CODEX_HOME used when starting one app-server connection. */
+function resolveCodexAppServerLocalHomeDir(startOptions, agentDir, env = process.env) {
+	const configured = startOptions.env?.CODEX_HOME;
+	if (configured?.trim()) return configured;
+	return startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir(env) : resolveCodexAppServerHomeDir(agentDir);
+}
+/** Forces OpenClaw-owned Codex auth to remain process-local. */
+function withEphemeralCodexAuthStore(params) {
+	const { startOptions } = params;
+	if (!params.preparedAuth && params.authProfileId === null) return startOptions;
+	const args = normalizeCodexAppServerArgs(startOptions.args, CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE);
+	return args === startOptions.args ? startOptions : {
+		...startOptions,
+		args
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/config-contracts.ts
+const CODEX_PLUGINS_MARKETPLACE_NAME = "openai-curated";
+const CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME = "workspace-directory";
+const CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+//#endregion
 //#region extensions/codex/src/app-server/config-utils.ts
 const START_OPTIONS_KEY_SECRET_SYMBOL = Symbol.for("openclaw.codexAppServerStartOptionsKeySecret");
 const START_OPTIONS_KEY_SECRET = getStartOptionsKeySecret();
@@ -122,8 +152,9 @@ function selectGuardianSandbox(allowedSandboxModes) {
 	return "workspace-write";
 }
 function resolveApprovalPolicy(value) {
+	if (value === "untrusted") throw new Error("Codex app-server approval policy \"untrusted\" is retired; run \"openclaw doctor --fix\" and use \"on-request\".");
 	if (value === "on-failure") return "on-request";
-	return value === "on-request" || value === "untrusted" || value === "never" ? value : void 0;
+	return value === "on-request" || value === "never" ? value : void 0;
 }
 function resolveSandbox(value) {
 	return value === "read-only" || value === "workspace-write" || value === "danger-full-access" ? value : void 0;
@@ -132,20 +163,16 @@ function resolveApprovalsReviewer(value) {
 	return value === "auto_review" || value === "guardian_subagent" || value === "user" ? value : void 0;
 }
 function resolveOpenClawExecPolicyFromConfig(params) {
-	const root = readRecord(params.config);
-	const globalExec = readRecord(readRecord(root?.tools)?.exec);
+	const globalExec = readRecord(params.config?.tools?.exec);
 	const globalPolicy = applyOpenClawExecPolicyLayer(createDefaultOpenClawExecPolicy(), globalExec);
 	const agentId = params.agentId?.trim();
-	if (!agentId) return globalPolicy;
-	const agents = readRecord(root?.agents);
-	const agentList = Array.isArray(agents?.list) ? agents.list : [];
-	const normalizedAgentId = normalizeAgentId(agentId);
-	return applyOpenClawExecPolicyLayer(globalPolicy, readRecord(readRecord(readRecord(agentList.find((entry) => {
-		const id = readRecord(entry)?.id;
-		return typeof id === "string" && normalizeAgentId(id) === normalizedAgentId;
-	}))?.tools)?.exec));
+	return applyOpenClawExecPolicyLayer(globalPolicy, agentId ? readRecord(resolveAgentConfig$1(params.config ?? {}, agentId)?.tools?.exec) : void 0);
 }
 function resolveOpenClawExecPolicyForCodexAppServer(params) {
+	if (params.permissionMode === "full") return {
+		...resolveOpenClawExecPolicyForMode("full"),
+		touched: true
+	};
 	const overridePolicy = applyOpenClawExecPolicyLayer(resolveOpenClawExecPolicyFromConfig({
 		config: params.config,
 		agentId: params.agentId
@@ -169,8 +196,7 @@ function assertCodexAppServerAllowedForOpenClawExecMode(mode) {
 }
 function createDefaultOpenClawExecPolicy() {
 	return {
-		security: "full",
-		ask: "off",
+		...resolveOpenClawExecPolicyForMode("full"),
 		touched: false
 	};
 }
@@ -274,15 +300,232 @@ function readExecMode(value) {
 	return value === "deny" || value === "allowlist" || value === "ask" || value === "auto" || value === "full" ? value : void 0;
 }
 //#endregion
+//#region extensions/codex/src/app-server/session-discovery-config.ts
+const codexSessionCatalogHomeSchema = z.union([z.string().trim().min(1), z.object({
+	path: z.string().trim().min(1),
+	label: z.string().trim().min(1).optional()
+}).strict()]);
+const codexSessionCatalogConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	homes: z.array(codexSessionCatalogHomeSchema).optional()
+}).strict();
+const codexDiscoveryConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	timeoutMs: z.number().positive().optional()
+}).strict();
+//#endregion
+//#region extensions/codex/src/app-server/config-parsing.ts
+const DEFAULT_CODEX_COMPUTER_USE_PLUGIN_NAME = "computer-use";
+const DEFAULT_CODEX_COMPUTER_USE_MARKETPLACE_DISCOVERY_TIMEOUT_MS = 6e4;
+const DEFAULT_CODEX_COMPUTER_USE_LIVE_TEST_TIMEOUT_MS = 6e4;
+const DEFAULT_CODEX_COMPUTER_USE_TOOL_CALL_TIMEOUT_MS = 6e4;
+const DEFAULT_CODEX_APP_SERVER_NETWORK_PROXY_PROFILE_PREFIX = "openclaw-network";
+const codexAppServerTransportSchema = z.enum([
+	"stdio",
+	"websocket",
+	"unix"
+]);
+const codexAppServerHomeScopeSchema = z.enum(["agent", "user"]);
+const SecretInputSchema = buildSecretInputSchema();
+const codexAppServerPolicyModeSchema = z.enum(["yolo", "guardian"]);
+const codexAppServerApprovalPolicySchema = z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum(["never", "on-request"]));
+const codexAppServerSandboxSchema = z.enum([
+	"read-only",
+	"workspace-write",
+	"danger-full-access"
+]);
+const codexAppServerApprovalsReviewerSchema = z.enum([
+	"user",
+	"auto_review",
+	"guardian_subagent"
+]);
+const codexDynamicToolsLoadingSchema = z.enum(["searchable", "direct"]);
+const codexComputerUseHealthIntervalSchema = z.union([
+	z.literal(30),
+	z.literal(60),
+	z.literal(120),
+	z.literal(240)
+]);
+const codexComputerUsePluginCacheModeSchema = z.enum(["shared", "independent"]);
+const codexPluginDestructivePolicySchema = z.union([
+	z.boolean(),
+	z.literal("auto"),
+	z.literal("ask")
+]);
+const codexAppServerServiceTierSchema = z.preprocess((value) => value === null ? null : normalizeCodexServiceTier(value), z.string().trim().min(1).nullable().optional()).optional();
+const codexAppServerExperimentalSchema = z.object({ sandboxExecServer: z.boolean().optional() }).strict();
+const codexAppServerRemoteWorkspaceRootSchema = z.string().trim().min(1);
+const codexAppServerNetworkProxyDomainPermissionSchema = z.enum(["allow", "deny"]);
+const codexAppServerNetworkProxyUnixSocketPermissionSchema = z.enum(["allow", "none"]);
+const codexAppServerNetworkProxySchema = z.object({
+	enabled: z.boolean().optional(),
+	profileName: z.string().trim().min(1).optional(),
+	baseProfile: z.enum(["read-only", "workspace"]).optional(),
+	mode: z.enum(["limited", "full"]).optional(),
+	domains: z.record(z.string(), codexAppServerNetworkProxyDomainPermissionSchema).optional(),
+	unixSockets: z.record(z.string(), codexAppServerNetworkProxyUnixSocketPermissionSchema).optional(),
+	proxyUrl: z.string().trim().min(1).optional(),
+	socksUrl: z.string().trim().min(1).optional(),
+	enableSocks5: z.boolean().optional(),
+	enableSocks5Udp: z.boolean().optional(),
+	allowUpstreamProxy: z.boolean().optional(),
+	allowLocalBinding: z.boolean().optional(),
+	dangerouslyAllowNonLoopbackProxy: z.boolean().optional(),
+	dangerouslyAllowAllUnixSockets: z.boolean().optional()
+}).strict();
+const codexPluginEntryConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	marketplaceName: z.string().regex(CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN).optional(),
+	pluginName: z.string().trim().min(1).optional(),
+	allow_destructive_actions: codexPluginDestructivePolicySchema.optional()
+}).strict();
+const codexPluginsConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	allow_all_plugins: z.boolean().optional(),
+	allow_destructive_actions: codexPluginDestructivePolicySchema.optional(),
+	plugins: z.record(z.string(), codexPluginEntryConfigSchema).optional()
+}).strict();
+const codexSupervisionEndpointSchema = z.union([z.object({
+	id: z.string().optional(),
+	label: z.string().optional(),
+	transport: z.literal("stdio-proxy").optional(),
+	command: z.string().optional(),
+	args: z.array(z.string()).optional(),
+	cwd: z.string().optional()
+}).strict(), z.object({
+	id: z.string().optional(),
+	label: z.string().optional(),
+	transport: z.literal("websocket"),
+	url: z.string(),
+	authTokenEnv: z.string().optional()
+}).strict()]);
+const codexSupervisionConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	endpoints: z.array(codexSupervisionEndpointSchema).optional(),
+	allowRawTranscripts: z.boolean().optional(),
+	allowWriteControls: z.boolean().optional()
+}).strict();
+const codexPluginConfigSchema = z.object({
+	codexDynamicToolsLoading: codexDynamicToolsLoadingSchema.optional(),
+	codexDynamicToolsExclude: z.array(z.string()).optional(),
+	sessionCatalog: codexSessionCatalogConfigSchema.optional(),
+	discovery: codexDiscoveryConfigSchema.optional(),
+	computerUse: z.object({
+		enabled: z.boolean().optional(),
+		autoInstall: z.boolean().optional(),
+		marketplaceDiscoveryTimeoutMs: z.number().positive().optional(),
+		liveTestTimeoutMs: z.number().positive().optional(),
+		toolCallTimeoutMs: z.number().positive().optional(),
+		healthCheckEnabled: z.boolean().optional(),
+		healthCheckIntervalMinutes: codexComputerUseHealthIntervalSchema.optional(),
+		pluginCacheMode: codexComputerUsePluginCacheModeSchema.optional(),
+		strictReadiness: z.boolean().optional(),
+		autoRepair: z.boolean().optional(),
+		marketplaceSource: z.string().optional(),
+		marketplacePath: z.string().optional(),
+		marketplaceName: z.string().optional(),
+		pluginName: z.string().optional(),
+		mcpServerName: z.string().optional()
+	}).strict().optional(),
+	codexPlugins: z.unknown().optional(),
+	supervision: codexSupervisionConfigSchema.optional(),
+	appServer: z.object({
+		mode: codexAppServerPolicyModeSchema.optional(),
+		transport: codexAppServerTransportSchema.optional(),
+		homeScope: codexAppServerHomeScopeSchema.optional(),
+		command: z.string().optional(),
+		args: z.union([z.array(z.string()), z.string()]).optional(),
+		url: z.string().optional(),
+		authToken: SecretInputSchema.optional(),
+		headers: z.record(z.string(), SecretInputSchema).optional(),
+		clearEnv: z.array(z.string()).optional(),
+		remoteWorkspaceRoot: codexAppServerRemoteWorkspaceRootSchema.optional(),
+		codeModeOnly: z.boolean().optional(),
+		loopDetectionPreToolUseRelay: z.boolean().optional(),
+		requestTimeoutMs: z.number().positive().optional(),
+		turnCompletionIdleTimeoutMs: z.number().positive().optional(),
+		turnAssistantCompletionIdleTimeoutMs: z.number().positive().optional(),
+		postToolRawAssistantCompletionIdleTimeoutMs: z.number().positive().optional(),
+		approvalPolicy: codexAppServerApprovalPolicySchema.optional(),
+		sandbox: codexAppServerSandboxSchema.optional(),
+		approvalsReviewer: codexAppServerApprovalsReviewerSchema.optional(),
+		serviceTier: codexAppServerServiceTierSchema,
+		networkProxy: codexAppServerNetworkProxySchema.optional(),
+		defaultWorkspaceDir: z.string().optional(),
+		experimental: codexAppServerExperimentalSchema.optional()
+	}).strict().optional()
+}).strict();
+function readCodexPluginConfig(value) {
+	if (asNullableRecord(asNullableRecord(value)?.appServer)?.approvalPolicy === "untrusted") throw new Error("plugins.entries.codex.config.appServer.approvalPolicy=\"untrusted\" is retired; run \"openclaw doctor --fix\" to migrate it to \"on-request\".");
+	const parsed = codexPluginConfigSchema.safeParse(value);
+	if (!parsed.success) return {};
+	const { codexPlugins: rawCodexPlugins, ...config } = parsed.data;
+	const plugins = codexPluginsConfigSchema.safeParse(rawCodexPlugins);
+	if (!plugins.success) return config;
+	return {
+		...config,
+		...plugins.data ? { codexPlugins: plugins.data } : {}
+	};
+}
+function isCodexSandboxExecServerEnabled(pluginConfig, sandbox) {
+	return isCodexRemoteExecPlacementSandbox(sandbox) || readCodexPluginConfig(pluginConfig).appServer?.experimental?.sandboxExecServer === true;
+}
+function isCodexRemoteExecPlacementSandbox(sandbox) {
+	return typeof sandbox === "object" && sandbox !== null && "placementExecutionMode" in sandbox && sandbox.placementExecutionMode === "remote-exec";
+}
+function isCodexPairedNodeRemoteExecPlacementSandbox(sandbox) {
+	return isCodexRemoteExecPlacementSandbox(sandbox) && typeof sandbox === "object" && sandbox !== null && "placementNodeId" in sandbox && typeof sandbox.placementNodeId === "string" && sandbox.placementNodeId.length > 0;
+}
+function assertCodexAppServerCommandHasNoInlineArgs(params) {
+	const inlineArgs = detectWindowsSpawnCommandInlineArgs(params.command);
+	if (!inlineArgs) return;
+	const sourceLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_BIN" : "plugins.entries.codex.config.appServer.command";
+	const argsLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_ARGS" : "plugins.entries.codex.config.appServer.args";
+	throw new Error(`${sourceLabel} must be only the Codex app-server executable path; "${inlineArgs.executable}" was configured with inline arguments "${inlineArgs.arguments}". Move those arguments to ${argsLabel}, or remove the override to use the managed Codex startup path.`);
+}
+function resolveCodexPluginsPolicy(pluginConfig) {
+	const config = readCodexPluginConfig(pluginConfig).codexPlugins;
+	const configured = config !== void 0;
+	const enabled = config?.enabled === true;
+	const destructivePolicy = resolveCodexPluginDestructivePolicy(config?.allow_destructive_actions ?? true);
+	const pluginPolicies = Object.entries(config?.plugins ?? {}).flatMap(([configKey, entry]) => {
+		if (!isCodexPluginMarketplaceName(entry.marketplaceName) || !entry.pluginName) return [];
+		const entryDestructivePolicy = resolveCodexPluginDestructivePolicy(entry.allow_destructive_actions ?? config?.allow_destructive_actions ?? true);
+		return [{
+			configKey,
+			marketplaceName: entry.marketplaceName,
+			pluginName: entry.pluginName,
+			enabled: enabled && entry.enabled !== false,
+			allowDestructiveActions: entryDestructivePolicy.allowDestructiveActions,
+			destructiveApprovalMode: entryDestructivePolicy.destructiveApprovalMode
+		}];
+	}).toSorted((left, right) => left.configKey.localeCompare(right.configKey));
+	return {
+		configured,
+		enabled,
+		allowAllPlugins: enabled && config?.allow_all_plugins === true,
+		allowDestructiveActions: destructivePolicy.allowDestructiveActions,
+		destructiveApprovalMode: destructivePolicy.destructiveApprovalMode,
+		pluginPolicies
+	};
+}
+function isCodexPluginMarketplaceName(value) {
+	return typeof value === "string" && CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN.test(value);
+}
+function resolveCodexPluginDestructivePolicy(policy) {
+	if (policy === "auto" || policy === "ask") return {
+		allowDestructiveActions: true,
+		destructiveApprovalMode: policy
+	};
+	return {
+		allowDestructiveActions: policy,
+		destructiveApprovalMode: policy ? "allow" : "deny"
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/config-requirements.ts
 const UNIX_CODEX_REQUIREMENTS_PATH = "/etc/codex/requirements.toml";
 const WINDOWS_CODEX_REQUIREMENTS_SUFFIX = "\\OpenAI\\Codex\\requirements.toml";
-function isCodexAppServerApprovalPolicyAllowedByRequirements(policy, params = {}) {
-	const content = readCodexRequirementsToml(params);
-	if (content === void 0) return true;
-	const allowedApprovalPolicies = parseAllowedApprovalPoliciesFromCodexRequirements(content);
-	return allowedApprovalPolicies === void 0 || allowedApprovalPolicies.has(policy);
-}
 function readCodexRequirementsToml(params) {
 	if (params.requirementsToml !== void 0) return params.requirementsToml ?? void 0;
 	const requirementsPath = readNonEmptyString(params.requirementsPath) ?? resolveCodexRequirementsPath(params.env ?? process.env, params.platform ?? process.platform);
@@ -449,6 +692,7 @@ function globPatternMatches(value, pattern) {
 function normalizeRequirementsApprovalPolicy(value) {
 	const normalized = value.trim().toLowerCase();
 	if (normalized === "on-failure") return "on-request";
+	if (normalized === "untrusted") return normalized;
 	return resolveApprovalPolicy(normalized);
 }
 function normalizeRequirementsApprovalsReviewer(value) {
@@ -456,8 +700,8 @@ function normalizeRequirementsApprovalsReviewer(value) {
 }
 function selectGuardianApprovalPolicy(allowedApprovalPolicies, execModeRequiringPromptingApprovals) {
 	if (allowedApprovalPolicies === void 0 || allowedApprovalPolicies.has("on-request")) return "on-request";
-	if (execModeRequiringPromptingApprovals) throw new Error(`tools.exec.mode=${execModeRequiringPromptingApprovals} requires Codex app-server prompting approvals`);
 	if (allowedApprovalPolicies.has("untrusted")) return "untrusted";
+	if (execModeRequiringPromptingApprovals) throw new Error(`tools.exec.mode=${execModeRequiringPromptingApprovals} requires Codex app-server prompting approvals`);
 	if (allowedApprovalPolicies.has("never")) return "never";
 	return "on-request";
 }
@@ -474,14 +718,30 @@ function selectUserApprovalsReviewer(allowedApprovalsReviewers, execModeRequirin
 }
 //#endregion
 //#region extensions/codex/src/app-server/config-reviewer.ts
-const CODEX_APP_SERVER_HOME_DIRNAME = "codex-home";
 const CODEX_CONFIG_TOML_FILENAME = "config.toml";
+/** Cloud/system config can redirect reviews after local home/profile checks have passed. */
+async function assertCodexModelBackedReviewerEffectiveConfig(params) {
+	if (params.approvalsReviewer !== "auto_review" && params.approvalsReviewer !== "guardian_subagent") return;
+	const effectiveConfig = readRecord(readRecord(await params.client.request("config/read", {
+		cwd: path.resolve(params.cwd),
+		includeLayers: false
+	}, { signal: params.signal }))?.config);
+	if (!effectiveConfig) throw new Error("Codex config/read returned an invalid model-backed reviewer config");
+	const modelProvider = effectiveConfig.model_provider;
+	const providers = effectiveConfig.model_providers;
+	const providerRecords = providers == null ? void 0 : readRecord(providers);
+	const provider = providerRecords?.openai;
+	const openAIProvider = provider == null ? void 0 : readRecord(provider);
+	if (modelProvider != null && modelProvider !== "openai" || providers != null && !providerRecords || provider != null && !openAIProvider || !isTrustedOptionalReviewerEndpoint(effectiveConfig.openai_base_url, isNativeOpenAIBaseUrl) || !isTrustedOptionalReviewerEndpoint(effectiveConfig.chatgpt_base_url, isNativeChatGPTBaseUrl) || !isTrustedOptionalReviewerEndpoint(openAIProvider?.base_url, isNativeOpenAIBaseUrl)) throw new Error("Codex model-backed approval reviewer requires the running server to use a trusted OpenAI endpoint");
+}
+function isTrustedOptionalReviewerEndpoint(value, isTrusted) {
+	return value == null || typeof value === "string" && isTrusted(value);
+}
 function canUseCodexModelBackedApprovalsReviewerForModel(params) {
 	const explicitProvider = params.modelProvider?.trim().toLowerCase();
 	const inferredProvider = inferProviderFromModelRef(params.model);
-	if (explicitProvider && explicitProvider !== "codex") return isTrustedCodexModelBackedApprovalsReviewerProvider(explicitProvider, params) && (inferredProvider === void 0 || isTrustedCodexModelBackedApprovalsReviewerProvider(inferredProvider, params));
-	if (inferredProvider !== void 0) return isTrustedCodexModelBackedApprovalsReviewerProvider(inferredProvider, params);
-	return isTrustedCodexModelBackedApprovalsReviewerProvider(explicitProvider, params);
+	if (explicitProvider && explicitProvider !== "codex" && explicitProvider !== "openai") return false;
+	return (inferredProvider ?? explicitProvider) === "openai" && isTrustedCodexModelBackedOpenAIProvider(params);
 }
 function isTrustedCodexModelBackedOpenAIProvider(params) {
 	if (!openAIBaseUrlEnvOverridesAreTrustedForModelBackedReview(params.env)) return false;
@@ -518,43 +778,50 @@ function resolveCodexModelBackedReviewerPolicyContext(params) {
 		model: params.model ?? params.bindingModel
 	};
 }
-function isCodexModelBackedApprovalsReviewerProvider(provider) {
-	return provider?.trim().toLowerCase() === "openai";
-}
-function isTrustedCodexModelBackedApprovalsReviewerProvider(provider, params) {
-	return isCodexModelBackedApprovalsReviewerProvider(provider) && isTrustedCodexModelBackedOpenAIProvider({
-		config: params.config,
-		env: params.env,
-		model: params.model,
-		agentDir: params.agentDir,
-		codexConfigToml: params.codexConfigToml,
-		homeScope: params.homeScope
-	});
-}
 function readCodexBaseUrlOverridesForModelBackedReview(params) {
 	const configToml = readCodexAppServerConfigToml(params);
 	if (configToml === false) return false;
-	if (configToml === void 0) return {
-		openAI: [],
-		chatGPT: []
-	};
-	const topLevelContent = stripTomlLineComments(configToml).slice(0, firstTomlTableOffset(configToml));
-	const modelProviderOpenAISection = parseTomlTableSection(configToml, "model_providers.openai");
-	const openAIBaseUrl = parseTomlStringValue(topLevelContent, "openai_base_url");
-	const chatGPTBaseUrl = parseTomlStringValue(topLevelContent, "chatgpt_base_url");
-	const openAI = [
-		openAIBaseUrl,
-		parseTomlStringValue(topLevelContent, "model_providers.openai.base_url"),
-		parseInlineOpenAIModelProviderBaseUrl(topLevelContent),
-		modelProviderOpenAISection ? parseTomlStringValue(modelProviderOpenAISection, "base_url") : void 0
-	];
-	const chatGPT = [chatGPTBaseUrl];
+	const configTomls = configToml === void 0 ? [] : [configToml];
+	const nativeOverrides = readNativeCodexReviewerConfigOverrides(params);
+	if (nativeOverrides === false) return false;
+	configTomls.push(...nativeOverrides);
+	const openAI = [];
+	const chatGPT = [];
+	for (const content of configTomls) {
+		const topLevelContent = stripTomlLineComments(content).slice(0, firstTomlTableOffset(content));
+		const modelProviderOpenAISection = parseTomlTableSection(content, "model_providers.openai");
+		const modelProvider = parseTomlStringValue(topLevelContent, "model_provider");
+		if (modelProvider === false || modelProvider && modelProvider !== "openai") return false;
+		openAI.push(parseTomlStringValue(topLevelContent, "openai_base_url"), parseTomlStringValue(topLevelContent, "model_providers.openai.base_url"), parseInlineOpenAIModelProviderBaseUrl(topLevelContent), modelProviderOpenAISection ? parseTomlStringValue(modelProviderOpenAISection, "base_url") : void 0);
+		chatGPT.push(parseTomlStringValue(topLevelContent, "chatgpt_base_url"));
+	}
 	if ([...openAI, ...chatGPT].includes(false)) return false;
 	return {
 		openAI: openAI.filter((entry) => typeof entry === "string"),
 		chatGPT: chatGPT.filter((entry) => typeof entry === "string")
 	};
 }
+function readNativeCodexReviewerConfigOverrides(params) {
+	if (params.codexArgs?.some((arg) => !arg)) return false;
+	const overrides = [];
+	let profile;
+	for (const { name, value } of readCodexAppServerConfigOptions(params.codexArgs ?? [])) {
+		if (!value) return false;
+		if (name === "--profile" || name === "-p") profile = value;
+		else overrides.push(`${value}\n`);
+	}
+	if (profile) {
+		if (path.basename(profile) !== profile || profile === "." || profile === "..") return false;
+		const configPath = resolveCodexAppServerConfigPath(params);
+		if (!configPath) return false;
+		try {
+			overrides.unshift(readFileSync(path.join(path.dirname(configPath), `${profile}.config.toml`), "utf8"));
+		} catch (error) {
+			if (readErrorCode(error) !== "ENOENT") return false;
+		}
+	}
+	return overrides;
+}
 function readCodexAppServerConfigToml(params) {
 	if (params.codexConfigToml !== void 0) return params.codexConfigToml ?? void 0;
 	const configPath = resolveCodexAppServerConfigPath(params);
@@ -591,13 +858,7 @@ function codexConfigEnablesNativeComputerUse(params) {
 function resolveCodexAppServerConfigPath(params) {
 	if (params.homeScope === "user") return path.join(resolveCodexAppServerUserHomeDir(params.env), CODEX_CONFIG_TOML_FILENAME);
 	const agentDir = readNonEmptyString(params.agentDir);
-	const codexHome = agentDir ? path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME) : void 0;
-	return codexHome ? path.join(codexHome, CODEX_CONFIG_TOML_FILENAME) : void 0;
-}
-/** Resolves the native user Codex home used by Desktop and the CLI. */
-function resolveCodexAppServerUserHomeDir(env = process.env, homedir$1 = homedir) {
-	const configured = readNonEmptyString(env.CODEX_HOME);
-	return path.resolve(configured ?? path.join(homedir$1(), ".codex"));
+	return agentDir ? path.join(resolveCodexAppServerHomeDir(agentDir), CODEX_CONFIG_TOML_FILENAME) : void 0;
 }
 function readErrorCode(error) {
 	return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
@@ -671,227 +932,6 @@ function inferProviderFromModelRef(model) {
 	return slashIndex > 0 ? normalized?.slice(0, slashIndex) : void 0;
 }
 //#endregion
-//#region extensions/codex/src/app-server/config-contracts.ts
-const CODEX_PLUGINS_MARKETPLACE_NAME = "openai-curated";
-const CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME = "workspace-directory";
-const CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
-//#endregion
-//#region extensions/codex/src/app-server/session-discovery-config.ts
-const codexSessionCatalogConfigSchema = z.object({ enabled: z.boolean().optional() }).strict();
-const codexDiscoveryConfigSchema = z.object({
-	enabled: z.boolean().optional(),
-	timeoutMs: z.number().positive().optional()
-}).strict();
-//#endregion
-//#region extensions/codex/src/app-server/config-parsing.ts
-const DEFAULT_CODEX_COMPUTER_USE_PLUGIN_NAME = "computer-use";
-const DEFAULT_CODEX_COMPUTER_USE_MARKETPLACE_DISCOVERY_TIMEOUT_MS = 6e4;
-const DEFAULT_CODEX_COMPUTER_USE_LIVE_TEST_TIMEOUT_MS = 6e4;
-const DEFAULT_CODEX_COMPUTER_USE_TOOL_CALL_TIMEOUT_MS = 6e4;
-const DEFAULT_CODEX_APP_SERVER_NETWORK_PROXY_PROFILE_PREFIX = "openclaw-network";
-const codexAppServerTransportSchema = z.enum([
-	"stdio",
-	"websocket",
-	"unix"
-]);
-const codexAppServerHomeScopeSchema = z.enum(["agent", "user"]);
-const SecretInputSchema = buildSecretInputSchema();
-const codexAppServerPolicyModeSchema = z.enum(["yolo", "guardian"]);
-const codexAppServerApprovalPolicySchema = z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum([
-	"never",
-	"on-request",
-	"untrusted"
-]));
-const codexAppServerSandboxSchema = z.enum([
-	"read-only",
-	"workspace-write",
-	"danger-full-access"
-]);
-const codexAppServerApprovalsReviewerSchema = z.enum([
-	"user",
-	"auto_review",
-	"guardian_subagent"
-]);
-const codexDynamicToolsLoadingSchema = z.enum(["searchable", "direct"]);
-const codexComputerUseHealthIntervalSchema = z.union([
-	z.literal(30),
-	z.literal(60),
-	z.literal(120),
-	z.literal(240)
-]);
-const codexComputerUsePluginCacheModeSchema = z.enum(["shared", "independent"]);
-const codexPluginDestructivePolicySchema = z.union([
-	z.boolean(),
-	z.literal("auto"),
-	z.literal("ask")
-]);
-const codexAppServerServiceTierSchema = z.preprocess((value) => value === null ? null : normalizeCodexServiceTier(value), z.string().trim().min(1).nullable().optional()).optional();
-const codexAppServerExperimentalSchema = z.object({ sandboxExecServer: z.boolean().optional() }).strict();
-const codexAppServerRemoteWorkspaceRootSchema = z.string().trim().min(1);
-const codexAppServerNetworkProxyDomainPermissionSchema = z.enum(["allow", "deny"]);
-const codexAppServerNetworkProxyUnixSocketPermissionSchema = z.enum(["allow", "none"]);
-const codexAppServerNetworkProxySchema = z.object({
-	enabled: z.boolean().optional(),
-	profileName: z.string().trim().min(1).optional(),
-	baseProfile: z.enum(["read-only", "workspace"]).optional(),
-	mode: z.enum(["limited", "full"]).optional(),
-	domains: z.record(z.string(), codexAppServerNetworkProxyDomainPermissionSchema).optional(),
-	unixSockets: z.record(z.string(), codexAppServerNetworkProxyUnixSocketPermissionSchema).optional(),
-	proxyUrl: z.string().trim().min(1).optional(),
-	socksUrl: z.string().trim().min(1).optional(),
-	enableSocks5: z.boolean().optional(),
-	enableSocks5Udp: z.boolean().optional(),
-	allowUpstreamProxy: z.boolean().optional(),
-	allowLocalBinding: z.boolean().optional(),
-	dangerouslyAllowNonLoopbackProxy: z.boolean().optional(),
-	dangerouslyAllowAllUnixSockets: z.boolean().optional()
-}).strict();
-const codexPluginEntryConfigSchema = z.object({
-	enabled: z.boolean().optional(),
-	marketplaceName: z.string().regex(CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN).optional(),
-	pluginName: z.string().trim().min(1).optional(),
-	allow_destructive_actions: codexPluginDestructivePolicySchema.optional()
-}).strict();
-const codexPluginsConfigSchema = z.object({
-	enabled: z.boolean().optional(),
-	allow_all_plugins: z.boolean().optional(),
-	allow_destructive_actions: codexPluginDestructivePolicySchema.optional(),
-	plugins: z.record(z.string(), codexPluginEntryConfigSchema).optional()
-}).strict();
-const codexSupervisionEndpointSchema = z.union([z.object({
-	id: z.string().optional(),
-	label: z.string().optional(),
-	transport: z.literal("stdio-proxy").optional(),
-	command: z.string().optional(),
-	args: z.array(z.string()).optional(),
-	cwd: z.string().optional()
-}).strict(), z.object({
-	id: z.string().optional(),
-	label: z.string().optional(),
-	transport: z.literal("websocket"),
-	url: z.string(),
-	authTokenEnv: z.string().optional()
-}).strict()]);
-const codexSupervisionConfigSchema = z.object({
-	enabled: z.boolean().optional(),
-	endpoints: z.array(codexSupervisionEndpointSchema).optional(),
-	allowRawTranscripts: z.boolean().optional(),
-	allowWriteControls: z.boolean().optional()
-}).strict();
-const codexPluginConfigSchema = z.object({
-	codexDynamicToolsLoading: codexDynamicToolsLoadingSchema.optional(),
-	codexDynamicToolsExclude: z.array(z.string()).optional(),
-	sessionCatalog: codexSessionCatalogConfigSchema.optional(),
-	discovery: codexDiscoveryConfigSchema.optional(),
-	computerUse: z.object({
-		enabled: z.boolean().optional(),
-		autoInstall: z.boolean().optional(),
-		marketplaceDiscoveryTimeoutMs: z.number().positive().optional(),
-		liveTestTimeoutMs: z.number().positive().optional(),
-		toolCallTimeoutMs: z.number().positive().optional(),
-		healthCheckEnabled: z.boolean().optional(),
-		healthCheckIntervalMinutes: codexComputerUseHealthIntervalSchema.optional(),
-		pluginCacheMode: codexComputerUsePluginCacheModeSchema.optional(),
-		strictReadiness: z.boolean().optional(),
-		autoRepair: z.boolean().optional(),
-		marketplaceSource: z.string().optional(),
-		marketplacePath: z.string().optional(),
-		marketplaceName: z.string().optional(),
-		pluginName: z.string().optional(),
-		mcpServerName: z.string().optional()
-	}).strict().optional(),
-	codexPlugins: z.unknown().optional(),
-	supervision: codexSupervisionConfigSchema.optional(),
-	appServer: z.object({
-		mode: codexAppServerPolicyModeSchema.optional(),
-		transport: codexAppServerTransportSchema.optional(),
-		homeScope: codexAppServerHomeScopeSchema.optional(),
-		command: z.string().optional(),
-		args: z.union([z.array(z.string()), z.string()]).optional(),
-		url: z.string().optional(),
-		authToken: SecretInputSchema.optional(),
-		headers: z.record(z.string(), SecretInputSchema).optional(),
-		clearEnv: z.array(z.string()).optional(),
-		remoteWorkspaceRoot: codexAppServerRemoteWorkspaceRootSchema.optional(),
-		codeModeOnly: z.boolean().optional(),
-		loopDetectionPreToolUseRelay: z.boolean().optional(),
-		requestTimeoutMs: z.number().positive().optional(),
-		turnCompletionIdleTimeoutMs: z.number().positive().optional(),
-		turnAssistantCompletionIdleTimeoutMs: z.number().positive().optional(),
-		postToolRawAssistantCompletionIdleTimeoutMs: z.number().positive().optional(),
-		approvalPolicy: codexAppServerApprovalPolicySchema.optional(),
-		sandbox: codexAppServerSandboxSchema.optional(),
-		approvalsReviewer: codexAppServerApprovalsReviewerSchema.optional(),
-		serviceTier: codexAppServerServiceTierSchema,
-		networkProxy: codexAppServerNetworkProxySchema.optional(),
-		defaultWorkspaceDir: z.string().optional(),
-		experimental: codexAppServerExperimentalSchema.optional()
-	}).strict().optional()
-}).strict();
-function readCodexPluginConfig(value) {
-	const parsed = codexPluginConfigSchema.safeParse(value);
-	if (!parsed.success) return {};
-	const { codexPlugins: rawCodexPlugins, ...config } = parsed.data;
-	const plugins = codexPluginsConfigSchema.safeParse(rawCodexPlugins);
-	if (!plugins.success) return config;
-	return {
-		...config,
-		...plugins.data ? { codexPlugins: plugins.data } : {}
-	};
-}
-function isCodexSandboxExecServerEnabled(pluginConfig, sandbox) {
-	return isCodexRemoteExecPlacementSandbox(sandbox) || readCodexPluginConfig(pluginConfig).appServer?.experimental?.sandboxExecServer === true;
-}
-function isCodexRemoteExecPlacementSandbox(sandbox) {
-	return typeof sandbox === "object" && sandbox !== null && "placementExecutionMode" in sandbox && sandbox.placementExecutionMode === "remote-exec";
-}
-function assertCodexAppServerCommandHasNoInlineArgs(params) {
-	const inlineArgs = detectWindowsSpawnCommandInlineArgs(params.command);
-	if (!inlineArgs) return;
-	const sourceLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_BIN" : "plugins.entries.codex.config.appServer.command";
-	const argsLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_ARGS" : "plugins.entries.codex.config.appServer.args";
-	throw new Error(`${sourceLabel} must be only the Codex app-server executable path; "${inlineArgs.executable}" was configured with inline arguments "${inlineArgs.arguments}". Move those arguments to ${argsLabel}, or remove the override to use the managed Codex startup path.`);
-}
-function resolveCodexPluginsPolicy(pluginConfig) {
-	const config = readCodexPluginConfig(pluginConfig).codexPlugins;
-	const configured = config !== void 0;
-	const enabled = config?.enabled === true;
-	const destructivePolicy = resolveCodexPluginDestructivePolicy(config?.allow_destructive_actions ?? true);
-	const pluginPolicies = Object.entries(config?.plugins ?? {}).flatMap(([configKey, entry]) => {
-		if (!isCodexPluginMarketplaceName(entry.marketplaceName) || !entry.pluginName) return [];
-		const entryDestructivePolicy = resolveCodexPluginDestructivePolicy(entry.allow_destructive_actions ?? config?.allow_destructive_actions ?? true);
-		return [{
-			configKey,
-			marketplaceName: entry.marketplaceName,
-			pluginName: entry.pluginName,
-			enabled: enabled && entry.enabled !== false,
-			allowDestructiveActions: entryDestructivePolicy.allowDestructiveActions,
-			destructiveApprovalMode: entryDestructivePolicy.destructiveApprovalMode
-		}];
-	}).toSorted((left, right) => left.configKey.localeCompare(right.configKey));
-	return {
-		configured,
-		enabled,
-		allowAllPlugins: enabled && config?.allow_all_plugins === true,
-		allowDestructiveActions: destructivePolicy.allowDestructiveActions,
-		destructiveApprovalMode: destructivePolicy.destructiveApprovalMode,
-		pluginPolicies
-	};
-}
-function isCodexPluginMarketplaceName(value) {
-	return typeof value === "string" && CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN.test(value);
-}
-function resolveCodexPluginDestructivePolicy(policy) {
-	if (policy === "auto" || policy === "ask") return {
-		allowDestructiveActions: true,
-		destructiveApprovalMode: policy
-	};
-	return {
-		allowDestructiveActions: policy,
-		destructiveApprovalMode: policy ? "allow" : "deny"
-	};
-}
-//#endregion
 //#region extensions/codex/src/app-server/config-security.ts
 function shouldAutoApproveCodexAppServerApprovals(appServer) {
 	return appServer.networkProxy === void 0 && appServer.approvalPolicy === "never" && appServer.sandbox === "danger-full-access";
@@ -956,6 +996,7 @@ function stableStringifyJson(value) {
 	return JSON.stringify(value);
 }
 function withMcpElicitationsApprovalPolicy(policy) {
+	if (policy === "untrusted") return policy;
 	if (typeof policy !== "string") return { granular: {
 		...policy.granular,
 		mcp_elicitations: true
@@ -1039,7 +1080,7 @@ function resolveDefaultCodexAppServerPolicy(params) {
 	const allowedApprovalPolicies = parseAllowedApprovalPoliciesFromCodexRequirements(content);
 	const allowedApprovalsReviewers = parseAllowedApprovalsReviewersFromCodexRequirements(content);
 	const yoloSandboxAllowed = allowedSandboxModes === void 0 || allowedSandboxModes.has("danger-full-access");
-	const yoloApprovalAllowed = allowedApprovalPolicies === void 0 || allowedApprovalPolicies.has("never");
+	const yoloApprovalAllowed = allowedApprovalPolicies === void 0 || allowedApprovalPolicies.has("never") && !allowedApprovalPolicies.has("untrusted");
 	const yoloReviewerAllowed = allowedApprovalsReviewers === void 0 || allowedApprovalsReviewers.has("user");
 	if (!params.forceGuardian && yoloSandboxAllowed && yoloApprovalAllowed && yoloReviewerAllowed) return {
 		mode: "yolo",
@@ -1069,9 +1110,11 @@ function resolveCodexAppServerHomeScope(params) {
 }
 function resolveCodexAppServerRuntimeOptions(params = {}) {
 	const env = params.env ?? process.env;
-	const config = readCodexPluginConfig(params.pluginConfig).appServer ?? {};
+	const pluginConfig = readCodexPluginConfig(params.pluginConfig);
+	const config = pluginConfig.appServer ?? {};
 	const transport = resolveTransport(config.transport);
 	const homeScope = resolveCodexAppServerHomeScope({ appServer: config });
+	if (transport !== "stdio" && pluginConfig.sessionCatalog?.homes?.length) throw new Error("plugins.entries.codex.config.sessionCatalog.homes requires appServer.transport=stdio");
 	const configCommand = readNonEmptyString(config.command);
 	const envCommand = readNonEmptyString(env.OPENCLAW_CODEX_APP_SERVER_BIN);
 	const command = configCommand ?? envCommand ?? "codex";
@@ -1098,7 +1141,7 @@ function resolveCodexAppServerRuntimeOptions(params = {}) {
 		execMode: params.execMode,
 		execPolicy: params.execPolicy
 	});
-	assertCodexAppServerAllowedForOpenClawExecMode(execMode);
+	if (!params.sessionPermissionMode) assertCodexAppServerAllowedForOpenClawExecMode(execMode);
 	const explicitPolicyMode = resolvePolicyMode(config.mode) ?? resolvePolicyMode(env.OPENCLAW_CODEX_APP_SERVER_MODE);
 	const configuredSandbox = resolveSandbox(config.sandbox) ?? resolveSandbox(env.OPENCLAW_CODEX_APP_SERVER_SANDBOX);
 	const explicitApprovalsReviewer = resolveApprovalsReviewer(config.approvalsReviewer);
@@ -1117,6 +1160,15 @@ function resolveCodexAppServerRuntimeOptions(params = {}) {
 	const forceGuardianReviewer = execMode === "auto" && canUseModelBackedReviewer;
 	const execModeRequiringPromptingApprovals = execMode === "auto" || execMode === "ask" ? execMode : forceUserReviewer ? "ask" : void 0;
 	const forceDangerFullAccessSandbox = params.execPolicy?.touched === true && params.execPolicy.security === "full" && params.execPolicy.ask === "always";
+	const forcePerCommandApprovals = params.execPolicy?.ask === "always";
+	const requirementsToml = forcePerCommandApprovals ? readCodexRequirementsToml({
+		env,
+		requirementsToml: params.requirementsToml,
+		requirementsPath: params.requirementsPath,
+		readRequirementsFile: params.readRequirementsFile,
+		platform: params.platform
+	}) ?? null : params.requirementsToml;
+	if (forcePerCommandApprovals && requirementsToml && parseAllowedApprovalPoliciesFromCodexRequirements(requirementsToml)?.has("untrusted") === false) throw new Error("tools.exec.ask=always requires Codex app-server per-command approvals");
 	const forceRuntimePolicy = forceUserReviewer || forceGuardianReviewer || forceDangerFullAccessSandbox;
 	const defaultPolicy = explicitPolicyMode && !forceRuntimePolicy && !ignoreLegacyYoloPolicyMode ? void 0 : resolveDefaultCodexAppServerPolicy({
 		transport,
@@ -1124,7 +1176,7 @@ function resolveCodexAppServerRuntimeOptions(params = {}) {
 		forceGuardian: normalizedPolicyMode === "guardian",
 		forceUserReviewer: forceUserReviewer || !canUseModelBackedReviewer,
 		execModeRequiringPromptingApprovals,
-		requirementsToml: params.requirementsToml,
+		requirementsToml,
 		requirementsPath: params.requirementsPath,
 		readRequirementsFile: params.readRequirementsFile,
 		platform: params.platform,
@@ -1133,7 +1185,7 @@ function resolveCodexAppServerRuntimeOptions(params = {}) {
 	});
 	const preserveExplicitAutoSandbox = forceGuardianReviewer && configuredSandbox === "read-only";
 	const forcedPolicy = forceRuntimePolicy ? {
-		approvalPolicy: defaultPolicy?.approvalPolicy ?? "on-request",
+		approvalPolicy: forcePerCommandApprovals ? "untrusted" : defaultPolicy?.approvalPolicy ?? "on-request",
 		sandbox: preserveExplicitAutoSandbox ? void 0 : forceDangerFullAccessSandbox ? selectForcedDangerFullAccessSandbox({
 			configuredSandbox,
 			defaultPolicy,
@@ -1295,17 +1347,22 @@ function codexSandboxPolicyForTurn(mode, cwd, nativeArgs = []) {
 	};
 	let excludeTmpdirEnvVar = false;
 	let excludeSlashTmp = false;
-	for (let index = 0; index < nativeArgs.length; index += 1) {
-		const arg = nativeArgs[index];
-		const override = arg === "-c" || arg === "--config" ? nativeArgs[++index] : arg?.startsWith("--config=") ? arg.slice(9) : void 0;
-		if (!override) continue;
+	for (const { name, value: override } of readCodexAppServerConfigOptions(nativeArgs)) {
+		if (name !== "-c" && name !== "--config" || !override) continue;
 		const separator = override.indexOf("=");
 		if (separator < 0) continue;
 		const key = override.slice(0, separator).trim();
-		const value = override.slice(separator + 1).trim();
-		if (value !== "true" && value !== "false") continue;
-		if (key === "sandbox_workspace_write.exclude_tmpdir_env_var") excludeTmpdirEnvVar = value === "true";
-		else if (key === "sandbox_workspace_write.exclude_slash_tmp") excludeSlashTmp = value === "true";
+		const isTmpdirExclusion = key === "sandbox_workspace_write.exclude_tmpdir_env_var";
+		if (!isTmpdirExclusion && key !== "sandbox_workspace_write.exclude_slash_tmp") continue;
+		let value;
+		try {
+			value = parse(`_x_ = ${override.slice(separator + 1).trim()}`)["_x_"];
+		} catch {
+			continue;
+		}
+		if (typeof value !== "boolean") continue;
+		if (isTmpdirExclusion) excludeTmpdirEnvVar = value;
+		else excludeSlashTmp = value;
 	}
 	return {
 		type: "workspaceWrite",
@@ -1335,861 +1392,4 @@ function resolveCodexSupervisionAppServerRuntimeOptions(params = {}) {
 	});
 }
 //#endregion
-//#region extensions/codex/src/app-server/session-binding.ts
-/** SQLite-backed Codex app-server thread bindings. */
-var session_binding_exports = /* @__PURE__ */ __exportAll({
-	CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS: () => CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS,
-	CODEX_APP_SERVER_BINDING_MAX_ENTRIES: () => CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
-	CODEX_APP_SERVER_BINDING_NAMESPACE: () => CODEX_APP_SERVER_BINDING_NAMESPACE,
-	CodexSupervisionBindingReplacementError: () => CodexSupervisionBindingReplacementError,
-	assertCodexBindingMayBeReplaced: () => assertCodexBindingMayBeReplaced,
-	bindingStoreKey: () => bindingStoreKey,
-	createCodexAppServerBindingStore: () => createCodexAppServerBindingStore,
-	createCodexSessionGenerationSupersededError: () => createCodexSessionGenerationSupersededError,
-	createStoredCodexAppServerBinding: () => createStoredCodexAppServerBinding,
-	hashCodexAppServerBindingFingerprint: () => hashCodexAppServerBindingFingerprint,
-	isCodexAppServerNativeAuthProfile: () => isCodexAppServerNativeAuthProfile,
-	normalizeCodexAppServerBindingModelProvider: () => normalizeCodexAppServerBindingModelProvider,
-	normalizeStoredCodexAppServerBindingFingerprints: () => normalizeStoredCodexAppServerBindingFingerprints,
-	readCodexAppServerThreadBinding: () => readCodexAppServerThreadBinding,
-	readStoredCodexAppServerBinding: () => readStoredCodexAppServerBinding,
-	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
-	resolveCodexRunSessionBindingAuthority: () => resolveCodexRunSessionBindingAuthority,
-	scopeCodexRunBindingStore: () => scopeCodexRunBindingStore,
-	sessionBindingIdentity: () => sessionBindingIdentity
-});
-const CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER = "openai";
-const PUBLIC_OPENAI_MODEL_PROVIDER = "openai";
-const BINDING_LEASE_RETRY_INTERVAL_MS = 1e3;
-const BOUNDED_BINDING_FINGERPRINT_PATTERN = /^sha256:[a-f0-9]{64}$/i;
-const CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS = 6e4;
-const BINDING_LEASE_STALE_MS = 65e3;
-const BINDING_LEASE_WAIT_MS = 7e4;
-const BINDING_LEASE_RENEW_INTERVAL_MS = Math.floor(BINDING_LEASE_STALE_MS / 3);
-const PHYSICAL_SESSION_RETIRE_TTL_MS = BINDING_LEASE_WAIT_MS;
-/** Resolves the same agent scope OpenClaw uses for transcript/session ownership. */
-function sessionBindingIdentity(params) {
-	const { sessionAgentId } = resolveSessionAgentIds$1(params);
-	const sessionKey = params.sessionKey?.trim();
-	return {
-		kind: "session",
-		agentId: sessionAgentId,
-		sessionId: params.sessionId,
-		...sessionKey ? { sessionKey } : {}
-	};
-}
-/** Decides whether a run may share the durable stable-key binding owner. */
-function resolveCodexRunSessionBindingAuthority(params) {
-	const sessionKey = params.identity.sessionKey?.trim();
-	if (!sessionKey) return "ephemeral";
-	try {
-		const storePath = params.storePath?.trim() || resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId });
-		const entry = getSessionEntry({
-			agentId: params.identity.agentId,
-			hydrateSkillPromptRefs: false,
-			readConsistency: "latest",
-			sessionKey,
-			storePath
-		});
-		if (!entry) return "ephemeral";
-		return entry.sessionId === params.identity.sessionId ? "current" : "superseded";
-	} catch {
-		return "superseded";
-	}
-}
-/** Builds the terminal coordination error used when a newer OpenClaw session owns the binding. */
-function createCodexSessionGenerationSupersededError(sessionId) {
-	return new AgentHarnessSessionSupersededError(`Codex session generation is no longer current: ${sessionId}`);
-}
-const optionalStringSchema = z.string().optional().catch(void 0);
-const optionalBooleanSchema = z.boolean().optional().catch(void 0);
-const optionalNonBlankStringSchema = z.string().refine((value) => Boolean(value.trim())).optional().catch(void 0);
-const optionalTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value))).optional().catch(void 0);
-const pendingSupervisionBranchSchema = z.object({
-	sourceThreadId: z.string().trim().min(1),
-	connectionFingerprint: z.string().trim().min(1).optional(),
-	lastTurnId: z.string().trim().min(1).optional(),
-	cleanupThreadIds: z.array(z.string().trim().min(1)).max(2).optional()
-}).strict().superRefine((pending, context) => {
-	const cleanupThreadIds = pending.cleanupThreadIds ?? [];
-	if (new Set(cleanupThreadIds).size !== cleanupThreadIds.length) context.addIssue({
-		code: "custom",
-		message: "pending supervision cleanup thread ids must be unique"
-	});
-	if (cleanupThreadIds.includes(pending.sourceThreadId)) context.addIssue({
-		code: "custom",
-		message: "pending supervision cleanup cannot target its source"
-	});
-});
-const contextEngineProjectionSchema = z.object({
-	schemaVersion: z.literal(1),
-	mode: z.literal("thread_bootstrap"),
-	epoch: z.string().refine((value) => Boolean(value.trim())),
-	fingerprint: optionalStringSchema
-}).strict();
-const contextEngineSchema = z.object({
-	schemaVersion: z.literal(1),
-	engineId: z.string(),
-	policyFingerprint: z.string(),
-	projection: contextEngineProjectionSchema.optional().catch(void 0)
-}).strict();
-const destructiveApprovalModeSchema = z.enum([
-	"allow",
-	"deny",
-	"auto",
-	"ask"
-]).optional().catch(void 0);
-const accountAppPolicyEntrySchema = z.object({
-	source: z.literal("account"),
-	appName: z.string(),
-	allowDestructiveActions: z.boolean(),
-	allowOpenWorld: z.boolean().optional(),
-	destructiveApprovalMode: destructiveApprovalModeSchema,
-	mcpServerNames: z.array(z.string())
-}).strict();
-const pluginAppPolicyEntrySchema = z.object({
-	source: z.literal("plugin").optional(),
-	configKey: z.string(),
-	marketplaceName: z.string().regex(CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN),
-	pluginName: z.string(),
-	allowDestructiveActions: z.boolean(),
-	allowOpenWorld: z.boolean().optional(),
-	destructiveApprovalMode: destructiveApprovalModeSchema,
-	mcpServerNames: z.array(z.string())
-}).strict();
-const pluginAppPolicyContextSchema = z.object({
-	fingerprint: z.string(),
-	apps: z.record(z.string(), z.union([accountAppPolicyEntrySchema, pluginAppPolicyEntrySchema])),
-	pluginAppIds: z.record(z.string(), z.array(z.string())).default({})
-}).strict();
-const threadBindingSchema = z.object({
-	threadId: z.string().refine((value) => Boolean(value.trim())),
-	clientId: optionalStringSchema,
-	cwd: z.string(),
-	rolloutPath: optionalNonBlankStringSchema,
-	connectionScope: z.literal("supervision").optional(),
-	supervisionSourceThreadId: z.string().trim().min(1).optional(),
-	authProfileId: optionalStringSchema,
-	model: optionalStringSchema,
-	preserveNativeModel: z.literal(true).optional().catch(void 0),
-	pendingSupervisionBranch: pendingSupervisionBranchSchema.optional(),
-	modelProvider: z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0),
-	approvalPolicy: z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum([
-		"never",
-		"on-request",
-		"untrusted"
-	]).optional()).catch(void 0),
-	sandbox: z.enum([
-		"read-only",
-		"workspace-write",
-		"danger-full-access"
-	]).optional().catch(void 0),
-	serviceTier: z.preprocess(normalizeCodexServiceTier, z.custom((value) => typeof value === "string").optional()).optional().catch(void 0),
-	networkProxyProfileName: optionalStringSchema,
-	networkProxyConfigFingerprint: optionalStringSchema,
-	dynamicToolsFingerprint: optionalStringSchema,
-	dynamicToolsContainDeferred: optionalBooleanSchema,
-	webSearchThreadConfigFingerprint: optionalStringSchema,
-	nativeSkillIsolationFingerprint: optionalStringSchema,
-	userMcpServersFingerprint: optionalStringSchema,
-	mcpServersFingerprint: optionalStringSchema,
-	configuredMcpOwnershipVersion: z.literal(1).optional().catch(void 0),
-	ringZeroConfigFingerprint: optionalStringSchema,
-	ringZeroClientInstanceId: optionalStringSchema,
-	/** Durable fact preventing a later unrestricted turn from widening this thread. */
-	nativeToolPolicyRestricted: z.literal(true).optional().catch(void 0),
-	nativeHookRelayGeneration: optionalNonBlankStringSchema,
-	appServerRuntimeFingerprint: optionalStringSchema,
-	pluginAppsFingerprint: optionalStringSchema,
-	pluginAppsInputFingerprint: optionalStringSchema,
-	pluginAppPolicyContext: pluginAppPolicyContextSchema.optional().catch(void 0),
-	contextEngine: contextEngineSchema.optional().catch(void 0),
-	environmentSelectionFingerprint: optionalStringSchema,
-	conversationStartId: optionalStringSchema,
-	conversationSourceTransferComplete: z.literal(true).optional().catch(void 0),
-	historyCoveredThrough: optionalTimestampSchema
-}).superRefine((binding, context) => {
-	if (binding.connectionScope === "supervision") {
-		if (!binding.supervisionSourceThreadId) context.addIssue({
-			code: "custom",
-			message: "supervision connection ownership requires its native source thread id"
-		});
-		if (binding.preserveNativeModel !== true) context.addIssue({
-			code: "custom",
-			message: "supervision connection ownership requires native model ownership"
-		});
-		if (binding.conversationSourceTransferComplete !== true) context.addIssue({
-			code: "custom",
-			message: "supervision connection ownership requires a completed source transfer"
-		});
-		if (!binding.pendingSupervisionBranch && (!binding.model?.trim() || !binding.modelProvider)) context.addIssue({
-			code: "custom",
-			message: "materialized supervision bindings require a native model and provider"
-		});
-	}
-	if (binding.supervisionSourceThreadId && binding.connectionScope !== "supervision") context.addIssue({
-		code: "custom",
-		message: "a supervision source thread id requires supervision connection ownership"
-	});
-	if (!binding.pendingSupervisionBranch) return;
-	if (binding.threadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
-		code: "custom",
-		message: "pending supervision source must match the provisional thread binding"
-	});
-	if (binding.supervisionSourceThreadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
-		code: "custom",
-		message: "pending supervision source must match its durable source identity"
-	});
-	if (binding.preserveNativeModel !== true) context.addIssue({
-		code: "custom",
-		message: "pending supervision bindings must defer model selection to Codex App Server"
-	});
-	if (binding.connectionScope !== "supervision") context.addIssue({
-		code: "custom",
-		message: "pending supervision bindings require supervision connection ownership"
-	});
-});
-var CodexSupervisionBindingReplacementError = class extends Error {
-	constructor(threadId, operation) {
-		super(`Refusing to replace supervised Codex thread ${threadId} while ${operation}; its native user-home connection and model ownership must be preserved`);
-		this.name = "CodexSupervisionBindingReplacementError";
-	}
-};
-function assertCodexBindingMayBeReplaced(binding, operation) {
-	if (binding?.connectionScope === "supervision") throw new CodexSupervisionBindingReplacementError(binding.threadId, operation);
-}
-const bindingLeaseSchema = z.object({
-	token: z.string().refine((value) => Boolean(value.trim())),
-	expiresAt: z.number().finite()
-});
-const storedSessionIdSchema = z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0);
-const storedBindingSchema = z.discriminatedUnion("state", [z.object({
-	version: z.literal(1),
-	state: z.literal("active"),
-	binding: threadBindingSchema,
-	sessionId: storedSessionIdSchema,
-	lease: bindingLeaseSchema.optional().catch(void 0)
-}), z.object({
-	version: z.literal(1),
-	state: z.literal("cleared"),
-	sessionId: storedSessionIdSchema,
-	lease: bindingLeaseSchema.optional().catch(void 0),
-	retired: z.literal(true).optional().catch(void 0)
-})]);
-function hashCodexAppServerBindingFingerprint(canonical) {
-	return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
-}
-function normalizeLegacyBindingFingerprint(value) {
-	if (typeof value !== "string" || value === "" || value === "[]" || BOUNDED_BINDING_FINGERPRINT_PATTERN.test(value)) return value;
-	return hashCodexAppServerBindingFingerprint(value);
-}
-function normalizeLegacyBindingFingerprints(record) {
-	let normalized = record;
-	for (const key of ["dynamicToolsFingerprint", "userMcpServersFingerprint"]) {
-		const value = record[key];
-		const next = normalizeLegacyBindingFingerprint(value);
-		if (next === value) continue;
-		if (normalized === record) normalized = { ...record };
-		normalized[key] = next;
-	}
-	return normalized;
-}
-function normalizeStoredCodexAppServerBindingFingerprints(value) {
-	const stored = readStoredCodexAppServerBinding(value);
-	if (!stored || stored.state !== "active") return stored;
-	const binding = normalizeLegacyBindingFingerprints(stored.binding);
-	return binding === stored.binding ? stored : readStoredCodexAppServerBinding({
-		...stored,
-		binding
-	});
-}
-/** Encodes a migrated sidecar binding as one canonical plugin-state row. */
-function createStoredCodexAppServerBinding(value, options = {}) {
-	const rawRecord = asOptionalRecord(value);
-	if (!rawRecord) return;
-	const record = normalizeLegacyBindingFingerprints(rawRecord);
-	if (record.schemaVersion !== 1 && record.schemaVersion !== 2) return;
-	const pluginAppPolicyContext = readPluginAppPolicyContext(record.pluginAppPolicyContext, record.schemaVersion);
-	const historyCoveredThrough = readTimestamp(record.historyCoveredThrough) ?? readTimestamp(record.updatedAt) ?? readTimestamp(record.createdAt) ?? readTimestamp(options.now) ?? (/* @__PURE__ */ new Date()).toISOString();
-	const authProfileId = typeof record.authProfileId === "string" ? record.authProfileId : void 0;
-	const binding = readCodexAppServerThreadBinding({
-		...record,
-		modelProvider: normalizeCodexAppServerBindingModelProvider({
-			...options.lookup,
-			authProfileId,
-			modelProvider: typeof record.modelProvider === "string" ? record.modelProvider : void 0
-		}),
-		cwd: typeof record.cwd === "string" ? record.cwd : "",
-		pluginAppPolicyContext,
-		historyCoveredThrough
-	});
-	return binding ? {
-		version: 1,
-		state: "active",
-		binding: stripUndefinedBinding(binding)
-	} : void 0;
-}
-function bindingLeaseLostError(key, cause) {
-	return new Error(`Lost Codex binding lease: ${key}`, cause === void 0 ? void 0 : { cause });
-}
-/** Carries one prepared run identity through callers that rederive it from public params. */
-function scopeCodexRunBindingStore(params) {
-	const mapSessionIdentity = (identity) => identity.agentId === params.logicalIdentity.agentId && identity.sessionId === params.logicalIdentity.sessionId && identity.sessionKey?.trim() === params.logicalIdentity.sessionKey?.trim() ? params.physicalIdentity : identity;
-	const mapIdentity = (identity) => identity.kind === "session" ? mapSessionIdentity(identity) : identity;
-	return {
-		read: (identity) => params.bindingStore.read(mapIdentity(identity)),
-		hasOtherThreadOwner: (threadId, identity) => params.bindingStore.hasOtherThreadOwner(threadId, identity ? mapIdentity(identity) : void 0),
-		mutate: (identity, mutation) => params.bindingStore.mutate(mapIdentity(identity), mutation),
-		prepareSessionGenerationReclaim: (identity) => params.bindingStore.prepareSessionGenerationReclaim(mapSessionIdentity(identity)),
-		adoptSessionGeneration: (identity, expectedPreviousSessionId) => params.bindingStore.adoptSessionGeneration(mapSessionIdentity(identity), expectedPreviousSessionId),
-		resetSessionGeneration: (identity) => params.bindingStore.resetSessionGeneration(mapSessionIdentity(identity)),
-		retireSessionGeneration: (identity) => params.bindingStore.retireSessionGeneration(mapSessionIdentity(identity)),
-		withThreadArchiveFence: (run) => params.bindingStore.withThreadArchiveFence(run),
-		withLease: (identity, run) => params.bindingStore.withLease(mapIdentity(identity), run)
-	};
-}
-/** Lets the authoritative OpenClaw session generation claim a stale stable binding row. */
-async function reclaimCurrentCodexSessionGeneration(params) {
-	const sessionKey = params.identity.sessionKey?.trim();
-	if (!sessionKey) return true;
-	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
-	if (plan.kind === "resolved") return plan.result;
-	try {
-		const storePath = params.storePath?.trim() || resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId });
-		if (getSessionEntry({
-			agentId: params.identity.agentId,
-			hydrateSkillPromptRefs: false,
-			readConsistency: "latest",
-			sessionKey,
-			storePath
-		})?.sessionId !== params.identity.sessionId) return false;
-	} catch {
-		return false;
-	}
-	return await params.bindingStore.mutate(params.identity, {
-		kind: "reclaim-generation",
-		expectedPreviousSessionId: plan.expectedPreviousSessionId
-	});
-}
-/** Creates the single binding facade owned by the Codex plugin runtime. */
-function createCodexAppServerBindingStore(state) {
-	const update = state.update?.bind(state);
-	if (!update) throw new Error("Codex app-server bindings require atomic plugin-state updates");
-	const leaseContext = new AsyncLocalStorage();
-	const archiveContext = new AsyncLocalStorage();
-	let activeBindingMutations = 0;
-	let pendingArchives = 0;
-	let archiveTail = Promise.resolve();
-	let bindingMutationsDrained = [];
-	const waitForBindingMutations = async () => {
-		if (activeBindingMutations === 0) return;
-		await new Promise((resolve) => {
-			bindingMutationsDrained.push(resolve);
-		});
-	};
-	const runBindingMutation = async (run) => {
-		if (archiveContext.getStore() === true) return await run();
-		if (pendingArchives > 0) throw new Error("Codex binding mutation blocked while a native archive is in progress; retry");
-		activeBindingMutations += 1;
-		try {
-			return await run();
-		} finally {
-			activeBindingMutations -= 1;
-			if (activeBindingMutations === 0) {
-				const drained = bindingMutationsDrained;
-				bindingMutationsDrained = [];
-				for (const resolve of drained) resolve();
-			}
-		}
-	};
-	const renewLease = (key, owner) => {
-		if (owner.failure) return;
-		try {
-			let renewed = false;
-			const stored = update(key, (raw) => {
-				const current = readStoredCodexAppServerBinding(raw);
-				if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
-				const lease = current?.lease;
-				const now = Date.now();
-				if (!lease || lease.token !== owner.token || lease.expiresAt <= now) return;
-				renewed = true;
-				return {
-					...current,
-					lease: {
-						token: owner.token,
-						expiresAt: now + BINDING_LEASE_STALE_MS
-					}
-				};
-			});
-			if (!renewed || !stored) owner.failure = bindingLeaseLostError(key);
-		} catch (error) {
-			owner.failure = bindingLeaseLostError(key, error);
-		}
-	};
-	const transactKey = async (key, apply, ttlMs) => {
-		const deadline = Date.now() + BINDING_LEASE_WAIT_MS;
-		while (true) {
-			let busy = false;
-			let leaseLost = false;
-			let result;
-			const ownedLease = leaseContext.getStore()?.get(key);
-			if (ownedLease?.failure) throw ownedLease.failure;
-			const ownedToken = ownedLease?.token;
-			update(key, (raw) => {
-				const current = readStoredCodexAppServerBinding(raw);
-				if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
-				const activeLease = current?.lease;
-				const now = Date.now();
-				if (ownedToken && (!activeLease || activeLease.token !== ownedToken || activeLease.expiresAt <= now)) {
-					leaseLost = true;
-					return;
-				}
-				if (activeLease && activeLease.token !== ownedToken && activeLease.expiresAt > now) {
-					busy = true;
-					return;
-				}
-				const applied = apply(current, ownedToken);
-				result = applied.result;
-				return applied.next;
-			}, ttlMs == null ? void 0 : { ttlMs });
-			if (leaseLost) {
-				const failure = bindingLeaseLostError(key);
-				if (ownedLease) ownedLease.failure = failure;
-				throw failure;
-			}
-			if (!busy) return result;
-			if (Date.now() >= deadline) throw new Error(`Timed out waiting for Codex binding lease: ${key}`);
-			await sleep(BINDING_LEASE_RETRY_INTERVAL_MS);
-		}
-	};
-	return {
-		async read(identity) {
-			const key = bindingStoreKey(identity);
-			const raw = state.lookup(key);
-			const stored = readStoredCodexAppServerBinding(raw);
-			if (raw !== void 0 && !stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
-			return stored?.state === "active" && ownsStoredSessionGeneration(identity, stored) ? stored.binding : void 0;
-		},
-		async hasOtherThreadOwner(threadId, currentIdentity) {
-			const currentKey = currentIdentity ? bindingStoreKey(currentIdentity) : void 0;
-			return state.entries().some(({ key, value }) => {
-				const stored = readStoredCodexAppServerBinding(value);
-				if (!stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
-				const isCurrentOwner = currentIdentity !== void 0 && key === currentKey && (currentIdentity.kind === "conversation" || stored.sessionId === currentIdentity.sessionId.trim());
-				if (stored.state !== "active" || stored.binding.threadId !== threadId || isCurrentOwner) return false;
-				return true;
-			});
-		},
-		async prepareSessionGenerationReclaim(identity) {
-			const key = bindingStoreKey(identity);
-			const raw = state.lookup(key);
-			const current = readStoredCodexAppServerBinding(raw);
-			if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
-			if (!current) return {
-				kind: "resolved",
-				result: true
-			};
-			const currentSessionId = current.sessionId;
-			if (!currentSessionId) return {
-				kind: "resolved",
-				result: current.state !== "cleared" || current.retired !== true
-			};
-			if (currentSessionId === identity.sessionId) return current.state === "cleared" && current.retired === true ? {
-				kind: "verify",
-				expectedPreviousSessionId: currentSessionId
-			} : {
-				kind: "resolved",
-				result: true
-			};
-			return {
-				kind: "verify",
-				expectedPreviousSessionId: currentSessionId
-			};
-		},
-		async mutate(identity, mutation) {
-			return await runBindingMutation(async () => {
-				const key = bindingStoreKey(identity);
-				const retainLegacyClear = mutation.kind === "clear" && key.startsWith("conversation:legacy-");
-				return await transactKey(key, (current, leaseToken) => {
-					const ownsGeneration = ownsStoredSessionGeneration(identity, current);
-					const ownedLease = current?.lease && current.lease.token === leaseToken ? { lease: current.lease } : {};
-					if (mutation.kind === "reclaim-generation") {
-						if (identity.kind !== "session" || !identity.sessionKey?.trim()) return { result: false };
-						if (!current) return { result: true };
-						if (ownsGeneration) {
-							if (current.state === "cleared" && current.retired === true && current.sessionId === mutation.expectedPreviousSessionId) return {
-								result: true,
-								next: {
-									version: 1,
-									state: "cleared",
-									sessionId: identity.sessionId,
-									...ownedLease
-								}
-							};
-							return { result: current.state !== "cleared" || current.retired !== true };
-						}
-						if (current.sessionId !== mutation.expectedPreviousSessionId) return { result: false };
-						if (current.state === "active" && current.binding.connectionScope === "supervision") return { result: false };
-						return {
-							result: true,
-							next: {
-								version: 1,
-								state: "cleared",
-								sessionId: identity.sessionId,
-								...ownedLease
-							}
-						};
-					}
-					const storedActive = current?.state === "active" ? current : void 0;
-					const active = ownsGeneration ? storedActive : void 0;
-					const retiredGeneration = current?.state === "cleared" && current.retired === true && ownsGeneration;
-					const preservesSupervisionOwner = mutation.kind === "set" && active?.binding.connectionScope === "supervision" && isSameSupervisionOwner(active.binding, mutation.binding);
-					const clearsPendingSupervisionOwner = mutation.kind === "clear" && active?.binding.connectionScope === "supervision" && matchesPendingSupervisionClear(active.binding, mutation.threadId, mutation.expectedPendingSupervisionBranch);
-					const replacesExpectedOrdinaryOwner = mutation.kind === "replace-thread" && active?.binding.threadId === mutation.expectedThreadId && active.binding.connectionScope !== "supervision" && mutation.binding.connectionScope !== "supervision" && mutation.binding.threadId !== mutation.expectedThreadId;
-					if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration || active?.binding.connectionScope === "supervision" && !preservesSupervisionOwner) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || mutation.kind === "replace-thread" && !replacesExpectedOrdinaryOwner || (mutation.kind === "patch-pending-supervision-branch" || mutation.kind === "commit-pending-supervision-branch") && !matchesPendingSupervisionBranch(active?.binding, mutation.expected) || mutation.kind === "clear" && (mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || !ownsGeneration || active?.binding.connectionScope === "supervision" && !clearsPendingSupervisionOwner)) return { result: false };
-					if (mutation.kind === "clear" && retiredGeneration) return { result: true };
-					if (mutation.kind === "clear") return {
-						result: true,
-						next: {
-							version: 1,
-							state: "cleared",
-							...storedSessionGeneration(identity, current),
-							...ownedLease
-						}
-					};
-					let binding;
-					if (mutation.kind === "set" || mutation.kind === "replace-thread") binding = validateBindingForWrite(mutation.binding);
-					else if (mutation.kind === "patch-pending-supervision-branch") binding = validateBindingForWrite({
-						...active.binding,
-						pendingSupervisionBranch: mutation.pending
-					});
-					else if (mutation.kind === "commit-pending-supervision-branch") binding = validateBindingForWrite({
-						...active.binding,
-						...mutation.patch,
-						threadId: mutation.threadId,
-						pendingSupervisionBranch: void 0
-					});
-					else binding = validateBindingForWrite({
-						...active.binding,
-						...mutation.patch,
-						threadId: mutation.threadId
-					});
-					return {
-						result: true,
-						next: {
-							version: 1,
-							state: "active",
-							binding,
-							...storedSessionGeneration(identity, current),
-							...ownedLease
-						}
-					};
-				}, mutation.kind === "clear" && !retainLegacyClear && !leaseContext.getStore()?.has(key) ? 1 : void 0);
-			});
-		},
-		async adoptSessionGeneration(identity, expectedPreviousSessionId) {
-			return await runBindingMutation(async () => {
-				const key = bindingStoreKey(identity);
-				const expectedSessionId = expectedPreviousSessionId.trim();
-				const targetSessionId = identity.sessionId.trim();
-				if (!expectedSessionId) throw new Error("Codex session generation adoption requires the previous session id");
-				return await transactKey(key, (current) => {
-					if (current?.state !== "active") return { result: "absent" };
-					if (current.sessionId === targetSessionId) return { result: "current" };
-					if (current.sessionId !== expectedSessionId) return { result: "conflict" };
-					return {
-						result: "adopted",
-						next: {
-							...current,
-							sessionId: targetSessionId
-						}
-					};
-				});
-			});
-		},
-		async resetSessionGeneration(identity) {
-			return await runBindingMutation(async () => {
-				const key = bindingStoreKey(identity);
-				return await transactKey(key, (current, leaseToken) => {
-					if (!current) return { result: "absent" };
-					if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
-					if (current.state === "cleared" && current.retired === true) return { result: "conflict" };
-					return {
-						result: "applied",
-						next: {
-							version: 1,
-							state: "cleared",
-							...storedSessionGeneration(identity, current),
-							...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
-						}
-					};
-				}, leaseContext.getStore()?.has(key) ? void 0 : 1);
-			});
-		},
-		async retireSessionGeneration(identity) {
-			return await runBindingMutation(async () => {
-				const key = bindingStoreKey(identity);
-				return await transactKey(key, (current, leaseToken) => {
-					if (!current) return { result: "absent" };
-					if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
-					if (current.state === "cleared" && current.retired === true) return { result: "applied" };
-					return {
-						result: "applied",
-						next: {
-							version: 1,
-							state: "cleared",
-							retired: true,
-							...storedSessionGeneration(identity, current),
-							...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
-						}
-					};
-				}, identity.sessionKey?.trim() ? void 0 : PHYSICAL_SESSION_RETIRE_TTL_MS);
-			});
-		},
-		async withThreadArchiveFence(run) {
-			pendingArchives += 1;
-			const operation = archiveTail.then(async () => {
-				await waitForBindingMutations();
-				return await archiveContext.run(true, run);
-			});
-			archiveTail = operation.then(() => void 0, () => void 0);
-			try {
-				return await operation;
-			} finally {
-				pendingArchives -= 1;
-			}
-		},
-		async withLease(identity, run) {
-			const key = bindingStoreKey(identity);
-			const owned = leaseContext.getStore();
-			const existingOwner = owned?.get(key);
-			if (existingOwner) {
-				const failureBeforeRun = existingOwner.failure;
-				if (failureBeforeRun) throw failureBeforeRun;
-				const result = await run();
-				const failureAfterRun = existingOwner.failure;
-				if (failureAfterRun) throw failureAfterRun;
-				return result;
-			}
-			const token = randomUUID();
-			if (!await transactKey(key, (current) => {
-				if (current?.state === "cleared" && current.retired === true && ownsStoredSessionGeneration(identity, current)) return { result: false };
-				const lease = {
-					token,
-					expiresAt: Date.now() + BINDING_LEASE_STALE_MS
-				};
-				if (current?.state === "active") return {
-					result: true,
-					next: {
-						...current,
-						...preservedSessionGeneration(identity, current),
-						lease
-					}
-				};
-				if (current?.state === "cleared" && current.retired === true) return {
-					result: true,
-					next: {
-						...current,
-						lease
-					}
-				};
-				return {
-					result: true,
-					next: {
-						version: 1,
-						state: "cleared",
-						...preservedSessionGeneration(identity, current),
-						lease
-					}
-				};
-			})) throw new Error(`Codex binding generation was retired: ${key}`);
-			const owner = { token };
-			const nested = new Map(owned);
-			nested.set(key, owner);
-			const heartbeat = setInterval(() => renewLease(key, owner), BINDING_LEASE_RENEW_INTERVAL_MS);
-			heartbeat.unref();
-			try {
-				const result = await leaseContext.run(nested, run);
-				if (owner.failure) throw owner.failure;
-				return result;
-			} finally {
-				clearInterval(heartbeat);
-				try {
-					const removeOwnedLease = (raw, matches) => {
-						const current = readStoredCodexAppServerBinding(raw);
-						if (!current || !matches(current) || current.lease?.token !== token) return;
-						const { lease: _lease, ...released } = current;
-						return released;
-					};
-					if (!update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "active"))) {
-						if (!update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "cleared" && current.retired === true), key.startsWith("session:") ? { ttlMs: PHYSICAL_SESSION_RETIRE_TTL_MS } : void 0)) update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "cleared"), { ttlMs: 1 });
-					}
-				} catch (error) {
-					embeddedAgentLog.warn("failed to release codex app-server binding lease", {
-						key,
-						error
-					});
-				}
-			}
-		}
-	};
-}
-function matchesPendingSupervisionBranch(binding, expected) {
-	const pending = binding?.pendingSupervisionBranch;
-	if (!pending || binding?.threadId !== expected.sourceThreadId) return false;
-	if (pending.sourceThreadId !== expected.sourceThreadId || pending.connectionFingerprint !== expected.connectionFingerprint || pending.lastTurnId !== expected.lastTurnId) return false;
-	const currentCleanup = pending.cleanupThreadIds ?? [];
-	const expectedCleanup = expected.cleanupThreadIds ?? [];
-	return currentCleanup.length === expectedCleanup.length && currentCleanup.every((threadId, index) => threadId === expectedCleanup[index]);
-}
-function isSameSupervisionOwner(current, replacement) {
-	return replacement.connectionScope === "supervision" && replacement.threadId === current.threadId && replacement.supervisionSourceThreadId === current.supervisionSourceThreadId;
-}
-function matchesPendingSupervisionClear(binding, threadId, expected) {
-	if (!expected) return false;
-	const sourceThreadId = expected.sourceThreadId;
-	return threadId === sourceThreadId && binding.supervisionSourceThreadId === sourceThreadId && matchesPendingSupervisionBranch(binding, expected);
-}
-/** Stable plugin-state key for one current binding owner. */
-function bindingStoreKey(identity) {
-	if (identity.kind === "session") {
-		const rawAgentId = identity.agentId.trim();
-		const sessionId = identity.sessionId.trim();
-		if (!rawAgentId) throw new Error("Codex app-server binding requires an agent id");
-		if (!sessionId) throw new Error("Codex app-server binding requires a session id");
-		const agentId = resolveSessionAgentIds$1({ agentId: rawAgentId }).sessionAgentId;
-		const sessionKey = identity.sessionKey?.trim();
-		if (sessionKey) return `session-key:${agentId}:${createHash("sha256").update(sessionKey).digest("base64url")}`;
-		return `session:${agentId}:${sessionId}`;
-	}
-	const bindingId = identity.bindingId.trim();
-	if (!bindingId) throw new Error("Codex app-server conversation binding requires a binding id");
-	return `conversation:${bindingId}`;
-}
-function readStoredCodexAppServerBinding(value) {
-	const result = storedBindingSchema.safeParse(value);
-	return result.success ? stripUndefinedValue(result.data) : void 0;
-}
-function storedSessionGeneration(identity, current) {
-	if (identity.kind === "session") return { sessionId: identity.sessionId };
-	return current?.sessionId ? { sessionId: current.sessionId } : {};
-}
-function preservedSessionGeneration(identity, current) {
-	if (current?.sessionId) return { sessionId: current.sessionId };
-	return storedSessionGeneration(identity, current);
-}
-function ownsStoredSessionGeneration(identity, current) {
-	return identity.kind !== "session" || !current?.sessionId || current.sessionId === identity.sessionId;
-}
-function validateBindingForWrite(binding) {
-	const validated = readCodexAppServerThreadBinding(binding);
-	if (!validated) throw new Error("Invalid Codex app-server thread binding");
-	return stripUndefinedBinding(validated);
-}
-/** Parses stored or shipped sidecar data into the current domain value. */
-function readCodexAppServerThreadBinding(value) {
-	const result = threadBindingSchema.safeParse(value);
-	if (!result.success) return;
-	return result.data;
-}
-function stripUndefinedBinding(binding) {
-	return stripUndefinedValue(binding);
-}
-function stripUndefinedValue(value) {
-	if (Array.isArray(value)) return value.map(stripUndefinedValue);
-	if (!value || typeof value !== "object") return value;
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, stripUndefinedValue(entry)]));
-}
-function readTimestamp(value) {
-	return optionalTimestampSchema.parse(value);
-}
-function readPluginAppPolicyContext(value, bindingSchemaVersion) {
-	const record = asOptionalRecord(value);
-	if (!record || typeof record.fingerprint !== "string") return;
-	const apps = asOptionalRecord(record.apps);
-	if (!apps) return;
-	const parsedApps = {};
-	for (const [appId, rawEntry] of Object.entries(apps)) {
-		const entry = asOptionalRecord(rawEntry);
-		if (!entry) return;
-		const destructiveApprovalMode = readDestructiveApprovalMode(entry.destructiveApprovalMode, bindingSchemaVersion);
-		const mcpServerNamesValid = Array.isArray(entry.mcpServerNames) && entry.mcpServerNames.every((serverName) => typeof serverName === "string");
-		if (entry.source === "account") {
-			if ("appId" in entry || typeof entry.appName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || entry.allowOpenWorld !== void 0 && typeof entry.allowOpenWorld !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
-			parsedApps[appId] = {
-				source: "account",
-				appName: entry.appName,
-				allowDestructiveActions: entry.allowDestructiveActions,
-				...typeof entry.allowOpenWorld === "boolean" ? { allowOpenWorld: entry.allowOpenWorld } : {},
-				...destructiveApprovalMode ? { destructiveApprovalMode } : {},
-				mcpServerNames: entry.mcpServerNames
-			};
-			continue;
-		}
-		if ("appId" in entry || entry.source !== void 0 && entry.source !== "plugin" || typeof entry.configKey !== "string" || typeof entry.marketplaceName !== "string" || !CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN.test(entry.marketplaceName) || typeof entry.pluginName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || entry.allowOpenWorld !== void 0 && typeof entry.allowOpenWorld !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
-		parsedApps[appId] = {
-			configKey: entry.configKey,
-			marketplaceName: entry.marketplaceName,
-			pluginName: entry.pluginName,
-			allowDestructiveActions: entry.allowDestructiveActions,
-			...typeof entry.allowOpenWorld === "boolean" ? { allowOpenWorld: entry.allowOpenWorld } : {},
-			...destructiveApprovalMode ? { destructiveApprovalMode } : {},
-			mcpServerNames: entry.mcpServerNames
-		};
-	}
-	const parsedPluginAppIds = {};
-	if (record.pluginAppIds !== void 0 && (!record.pluginAppIds || typeof record.pluginAppIds !== "object" || Array.isArray(record.pluginAppIds))) return;
-	if (record.pluginAppIds && typeof record.pluginAppIds === "object") for (const [configKey, appIds] of Object.entries(record.pluginAppIds)) {
-		if (!Array.isArray(appIds) || appIds.some((appId) => typeof appId !== "string")) return;
-		parsedPluginAppIds[configKey] = appIds;
-	}
-	return {
-		fingerprint: record.fingerprint,
-		apps: parsedApps,
-		pluginAppIds: parsedPluginAppIds
-	};
-}
-function readDestructiveApprovalMode(value, bindingSchemaVersion) {
-	if (value === void 0) return;
-	if (value === "allow" || value === "deny") return value;
-	if (value === "auto") return bindingSchemaVersion === 1 ? "allow" : "auto";
-	if (value === "ask" && bindingSchemaVersion === 2) return "ask";
-	if (value === "on-request" && bindingSchemaVersion === 1) return "auto";
-	return "invalid";
-}
-function sleep(ms) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, ms);
-	});
-}
-/** Returns true when an auth profile uses native Codex/OpenAI app-server auth. */
-function isCodexAppServerNativeAuthProfile(lookup) {
-	const authProfileId = lookup.authProfileId?.trim();
-	if (!authProfileId) return false;
-	try {
-		const credential = (lookup.authProfileStore ?? ensureAuthProfileStore(lookup.agentDir?.trim() || resolveDefaultAgentDir(lookup.config ?? {}), {
-			allowKeychainPrompt: false,
-			config: lookup.config,
-			externalCliProviderIds: [CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER],
-			externalCliProfileIds: [authProfileId]
-		})).profiles[authProfileId];
-		if (!credential || credential.type === "api_key") return false;
-		const provider = credential.provider?.trim();
-		return Boolean(provider && resolveProviderIdForAuth(provider, { config: lookup.config }) === CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER);
-	} catch (error) {
-		embeddedAgentLog.debug("failed to resolve codex app-server auth profile provider", {
-			authProfileId,
-			error
-		});
-		return false;
-	}
-}
-/** Hides redundant OpenAI provider attribution for native Codex auth bindings. */
-function normalizeCodexAppServerBindingModelProvider(params) {
-	const modelProvider = params.modelProvider?.trim();
-	if (!modelProvider) return;
-	if (isCodexAppServerNativeAuthProfile(params) && modelProvider.toLowerCase() === PUBLIC_OPENAI_MODEL_PROVIDER) return;
-	return modelProvider;
-}
-//#endregion
-export { resolveCodexAppServerUserHomeDir as A, isCodexRemoteExecPlacementSandbox as C, CODEX_PLUGINS_MARKETPLACE_NAME as D, resolveCodexPluginsPolicy as E, isCodexAppServerApprovalPolicyAllowedByRequirements as M, resolveOpenClawExecPolicyForCodexAppServer as N, CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME as O, isCodexFastServiceTier as P, withMcpElicitationsApprovalPolicy as S, readCodexPluginConfig as T, resolveCodexAppServerStartOptionsForAgent as _, hashCodexAppServerBindingFingerprint as a, assertCodexAppServerConnectionSecurity as b, reclaimCurrentCodexSessionGeneration as c, sessionBindingIdentity as d, session_binding_exports as f, resolveCodexAppServerRuntimeOptions as g, resolveCodexAppServerHomeScope as h, createCodexSessionGenerationSupersededError as i, resolveCodexModelBackedReviewerPolicyContext as j, canUseCodexModelBackedApprovalsReviewerForModel as k, resolveCodexRunSessionBindingAuthority as l, codexSandboxPolicyForTurn as m, assertCodexBindingMayBeReplaced as n, isCodexAppServerNativeAuthProfile as o, codexAppServerStartOptionsKey as p, bindingStoreKey as r, normalizeCodexAppServerBindingModelProvider as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t, scopeCodexRunBindingStore as u, resolveCodexComputerUseConfig as v, isCodexSandboxExecServerEnabled as w, shouldAutoApproveCodexAppServerApprovals as x, resolveCodexSupervisionAppServerRuntimeOptions as y };
+export { normalizeCodexServiceTier as A, isCodexRemoteExecPlacementSandbox as C, resolveOpenClawExecPolicyForCodexAppServer as D, resolveCodexPluginsPolicy as E, resolveCodexAppServerLocalHomeDir as F, resolveCodexAppServerUserHomeDir as I, withEphemeralCodexAuthStore as L, CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME as M, CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN as N, selectGuardianSandbox as O, resolveCodexAppServerHomeDir as P, isCodexPairedNodeRemoteExecPlacementSandbox as S, readCodexPluginConfig as T, parseAllowedSandboxModesFromCodexRequirements as _, resolveCodexAppServerStartOptionsForAgent as a, selectGuardianApprovalsReviewer as b, assertCodexAppServerConnectionSecurity as c, withMcpElicitationsApprovalPolicy as d, assertCodexModelBackedReviewerEffectiveConfig as f, parseAllowedApprovalsReviewersFromCodexRequirements as g, parseAllowedApprovalPoliciesFromCodexRequirements as h, resolveCodexAppServerRuntimeOptions as i, CODEX_PLUGINS_MARKETPLACE_NAME as j, isCodexFastServiceTier as k, resolveCodexAppServerNetworkProxy as l, resolveCodexModelBackedReviewerPolicyContext as m, codexSandboxPolicyForTurn as n, resolveCodexComputerUseConfig as o, canUseCodexModelBackedApprovalsReviewerForModel as p, resolveCodexAppServerHomeScope as r, resolveCodexSupervisionAppServerRuntimeOptions as s, codexAppServerStartOptionsKey as t, shouldAutoApproveCodexAppServerApprovals as u, readCodexRequirementsToml as v, isCodexSandboxExecServerEnabled as w, selectUserApprovalsReviewer as x, selectGuardianApprovalPolicy as y };