@openclaw/codex 2026.9.7 → 2026.10.1-beta.1

package/dist/.setup/workspace-write-sandbox-probe-DmUHLrrl.mjs

@@ -0,0 +1,118 @@
+import { a as resolveCodexPrivateLauncher, n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
+import { n as resolveCodexAppServerSpawnEnv, r as resolveCodexAppServerSpawnInvocation } from "./transport-stdio-a0HDa2Mj.mjs";
+import { t as resolveCodexDoctorStartOptions } from "./doctor-start-options-DPW9JxIE.mjs";
+import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
+//#region extensions/codex/src/workspace-write-sandbox-probe.ts
+const PROBE_ARGS = [
+	"sandbox",
+	"-c",
+	"sandbox_mode=\"workspace-write\"",
+	"-c",
+	"sandbox_workspace_write.network_access=false",
+	"--",
+	"true"
+];
+const PROBE_TIMEOUT_MS = 2e4;
+const BWRAP_DENIAL = /^bwrap: (?:loopback: Failed RTM_NEW(?:ADDR|LINK)|setting up uid map: Permission denied|No permissions to create a new namespace)\b/u;
+function renderCommand(argv) {
+	return argv.map((arg) => /^[\w./:=+@%,-]+$/u.test(arg) ? arg : `'${arg.replaceAll("'", "'\\''")}'`).join(" ");
+}
+/** Runs Codex's own Linux sandbox so network isolation also exercises bwrap loopback setup. */
+async function probeCodexWorkspaceWriteSandbox(params) {
+	let command;
+	try {
+		if (process.platform !== "linux") return {
+			status: "skipped",
+			reason: "Codex bwrap is only used on Linux."
+		};
+		const baseEnv = params.env ?? process.env;
+		const selection = await resolveCodexDoctorStartOptions({
+			...params,
+			env: baseEnv
+		});
+		if (selection.status === "skipped") return selection;
+		const start = selection.start;
+		if (isCodexAppServerProxyLaunch(start.args)) return {
+			status: "skipped",
+			reason: "Codex app-server proxy forwards to an externally owned runtime."
+		};
+		command = renderCommand([start.command, ...PROBE_ARGS]);
+		const launchCwd = start.cwd ?? process.cwd();
+		const { launcherArgs } = resolveCodexPrivateLauncher({
+			command: start.command,
+			args: start.args,
+			cwd: launchCwd
+		});
+		const env = resolveCodexAppServerSpawnEnv(start, baseEnv);
+		const invocation = resolveCodexAppServerSpawnInvocation({
+			...start,
+			command: start.command.includes("/") ? path.resolve(launchCwd, start.command) : start.command,
+			args: [...launcherArgs, ...PROBE_ARGS]
+		}, env);
+		const argv = [invocation.command, ...invocation.argv];
+		command = renderCommand(argv);
+		const root = await fs.mkdtemp(path.join(resolvePreferredOpenClawTmpDir(), "openclaw-codex-sandbox-probe-"));
+		try {
+			const codexHome = path.join(root, "codex-home");
+			const cwd = path.join(root, "workspace");
+			await fs.mkdir(codexHome);
+			await fs.mkdir(cwd);
+			const result = await runUtf8CommandWithTimeout(argv, {
+				cwd,
+				baseEnv: {
+					...env,
+					CODEX_HOME: codexHome
+				},
+				input: "",
+				timeoutMs: PROBE_TIMEOUT_MS,
+				maxOutputBytes: 65536,
+				outputCapture: "head",
+				terminateOnOutputLimit: true,
+				killProcessTree: true,
+				killSignal: "SIGKILL",
+				killGraceMs: 0
+			});
+			if (result.outputLimitExceeded || result.termination !== "exit" || result.signal) return {
+				status: "inconclusive",
+				command,
+				reason: result.outputLimitExceeded ? "Sandbox probe output exceeded its capture limit." : result.termination === "timeout" ? `Sandbox probe timed out after ${PROBE_TIMEOUT_MS} ms.` : `Sandbox probe ended with ${result.signal ?? result.termination}.`
+			};
+			if (result.code === 0) return {
+				status: "ok",
+				command
+			};
+			const denial = `${result.stdout}\n${result.stderr}`.split(/\r?\n/u).map((line) => line.trim()).find((line) => BWRAP_DENIAL.test(line));
+			if (result.code !== null && denial) return {
+				status: "denied",
+				command,
+				denial
+			};
+			return {
+				status: "inconclusive",
+				command,
+				reason: `Sandbox probe exited with ${result.code ?? "no exit code"} without a recognized bwrap denial.`
+			};
+		} finally {
+			await fs.rm(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	} catch (error) {
+		const reason = coerceErrorMessage(error);
+		return command ? {
+			status: "inconclusive",
+			command,
+			reason
+		} : {
+			status: "inconclusive",
+			reason
+		};
+	}
+}
+//#endregion
+export { probeCodexWorkspaceWriteSandbox };

package/dist/api.js

@@ -1,17 +1,11 @@
-import { d as readCodexPluginConfig } from "./.setup/config-parsing-b088LyhT.mjs";
-import { a as resolveCodexAppServerStartOptionsForAgent } from "./.setup/config-options-CzyWLTJt.mjs";
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, s as CODEX_APP_SERVER_VERSION, t as isManagedCodexDesktopCommand } from "./.setup/managed-binary-kiWRhNRE.mjs";
+import { i as resolveManagedCodexNativeCommand, s as CODEX_APP_SERVER_VERSION } from "./.setup/managed-binary-C1VFoVPf.mjs";
 import { t as codexNativeProfileRecoveryHealthCheck } from "./.setup/auth-profile-health-oHizqgye.mjs";
 import { n as findCodexAppServerSpawnError, t as describeCodexSpawnError } from "./.setup/spawn-error-CL3n6MAa.mjs";
-import "./.setup/config-DKhXquav.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./.setup/config-runtime-C0NbLms1.mjs";
-import { listAgentIds, resolveAgentDir } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { t as resolveCodexDoctorStartOptions } from "./.setup/doctor-start-options-DPW9JxIE.mjs";
 import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import path from "node:path";
 import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { fileURLToPath } from "node:url";
-import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
-import { resolveEffectiveAgentRuntime } from "openclaw/plugin-sdk/command-auth-native";
 //#region extensions/codex/src/doctor.ts
 const CODEX_MANAGED_APP_SERVER_CHECK_ID = "codex/managed-app-server";
 const CODEX_VERSION_TIMEOUT_MS = 5e3;
@@ -46,9 +40,6 @@ async function runVersionCommand(command, env) {
 	return result;
 }
 function createCodexManagedAppServerHealthCheck(params) {
-	const resolveStartOptions = params.deps?.resolveStartOptions ?? resolveManagedCodexAppServerStartOptions;
-	const resolveAgentStartOptions = params.deps?.resolveAgentStartOptions ?? resolveCodexAppServerStartOptionsForAgent;
-	const isDesktopCommand = params.deps?.isDesktopCommand ?? isManagedCodexDesktopCommand;
 	const resolveNativeCommand = params.deps?.resolveNativeCommand ?? resolveManagedCodexNativeCommand;
 	return {
 		id: CODEX_MANAGED_APP_SERVER_CHECK_ID,
@@ -57,54 +48,29 @@ function createCodexManagedAppServerHealthCheck(params) {
 		source: "codex",
 		defaultEnabled: false,
 		async detect(ctx) {
-			const pluginConfig = ctx.cfg.plugins?.entries?.codex?.config;
-			const start = resolveCodexAppServerRuntimeOptions({
-				pluginConfig,
-				env: ctx.env ?? process.env
-			}).start;
-			if (start.transport !== "stdio" || start.commandSource !== "managed") return [];
 			const env = ctx.env ?? process.env;
 			const isFinalization = ctx.mode === "fix" && env.OPENCLAW_UPDATE_POST_CORE === "1";
 			const versionFailureSeverity = isFinalization ? "warning" : "error";
 			const versionFailureHint = isFinalization ? "Codex readiness will be rechecked by its plugin after restart; inspect the Codex plugin if the warning persists." : void 0;
-			const candidates = [];
-			for (const agentId of listAgentIds(ctx.cfg)) {
-				const model = resolveDefaultModelForAgent({
+			let selection;
+			try {
+				selection = await resolveCodexDoctorStartOptions({
 					cfg: ctx.cfg,
-					agentId
+					env,
+					pluginRoot: params.pluginRoot,
+					managedOnly: true,
+					deps: params.deps
 				});
-				if (resolveEffectiveAgentRuntime({
-					cfg: ctx.cfg,
-					provider: model.provider,
-					modelId: model.model,
-					agentId
-				}) !== "codex") continue;
-				candidates.push(resolveAgentStartOptions({
-					startOptions: start,
-					agentDir: resolveAgentDir(ctx.cfg, agentId, env),
-					env
-				}));
-			}
-			if (ctx.cfg.plugins?.entries?.codex?.enabled === true && readCodexPluginConfig(pluginConfig).sessionCatalog?.enabled !== false) candidates.push({
-				...start,
-				managedCommandOrder: "package-only"
-			});
-			let resolved;
-			for (const candidate of candidates) {
-				try {
-					resolved = await resolveStartOptions(candidate, { pluginRoot: params.pluginRoot });
-				} catch (error) {
-					return [managedCodexFinding({
-						message: `Managed Codex app-server could not be resolved: ${coerceErrorMessage(error)}`,
-						path: params.pluginRoot,
-						requirement: `an executable Codex ${CODEX_APP_SERVER_VERSION} managed artifact`,
-						fixHint: "Reinstall the staged OpenClaw package with its @openai/codex platform dependency, then rerun the candidate check."
-					})];
-				}
-				if (!isDesktopCommand(resolved.command)) break;
-				resolved = void 0;
+			} catch (error) {
+				return [managedCodexFinding({
+					message: `Managed Codex app-server could not be resolved: ${coerceErrorMessage(error)}`,
+					path: params.pluginRoot,
+					requirement: `an executable Codex ${CODEX_APP_SERVER_VERSION} managed artifact`,
+					fixHint: "Reinstall the staged OpenClaw package with its @openai/codex platform dependency, then rerun the candidate check."
+				})];
 			}
-			if (!resolved) return [];
+			if (selection.status === "skipped") return [];
+			const resolved = selection.start;
 			const nativeCommand = resolveNativeCommand(resolved.command);
 			if (!nativeCommand) return [managedCodexFinding({
 				message: "Managed Codex app-server resolved a launcher without a native artifact.",
@@ -126,7 +92,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 				})];
 			}
 			const detectedVersion = parseCodexVersion(`${output.stdout}\n${output.stderr}`);
-			if (detectedVersion !== "0.158.0") return [managedCodexFinding({
+			if (detectedVersion !== "0.160.0") return [managedCodexFinding({
 				severity: versionFailureSeverity,
 				message: detectedVersion ? `Managed Codex app-server version mismatch: expected ${CODEX_APP_SERVER_VERSION}, detected ${detectedVersion}.` : `Managed Codex app-server did not report a parseable version; expected ${CODEX_APP_SERVER_VERSION}.`,
 				path: nativeCommand,
@@ -147,6 +113,20 @@ function registerCodexManagedAppServerDoctorChecks$1(host, deps) {
 //#endregion
 //#region extensions/codex/api.ts
 const CODEX_PLUGIN_ROOT = path.dirname(fileURLToPath(import.meta.url));
+async function probeCodexWorkspaceWriteSandbox(params) {
+	try {
+		const { probeCodexWorkspaceWriteSandbox: probe } = await import("./.setup/workspace-write-sandbox-probe-DmUHLrrl.mjs");
+		return await probe({
+			...params,
+			pluginRoot: CODEX_PLUGIN_ROOT
+		});
+	} catch (error) {
+		return {
+			status: "inconclusive",
+			reason: coerceErrorMessage(error)
+		};
+	}
+}
 function registerCodexManagedAppServerDoctorChecks(host) {
 	registerCodexManagedAppServerDoctorChecks$1({
 		...host,
@@ -155,4 +135,4 @@ function registerCodexManagedAppServerDoctorChecks(host) {
 	if (!host.getHealthCheck(codexNativeProfileRecoveryHealthCheck.id)) host.registerHealthCheck(codexNativeProfileRecoveryHealthCheck);
 }
 //#endregion
-export { CODEX_MANAGED_APP_SERVER_CHECK_ID, registerCodexManagedAppServerDoctorChecks };
+export { CODEX_MANAGED_APP_SERVER_CHECK_ID, probeCodexWorkspaceWriteSandbox, registerCodexManagedAppServerDoctorChecks };

package/dist/catalog-page.worker.js

@@ -1,4 +1,4 @@
-import { t as createCodexCatalogDecoder } from "./.setup/client-catalog-response-5HHLdcde.mjs";
+import { t as createCodexCatalogDecoder } from "./.setup/client-catalog-response-CmvIiDdj.mjs";
 import { serveWorkerTasks } from "openclaw/plugin-sdk/worker-task-server";
 //#region extensions/codex/catalog-page.worker.ts
 const decode = createCodexCatalogDecoder();

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./.setup/session-cli-Cn_nCqfq.mjs");
+		const { registerCodexSessionCli } = await import("./.setup/session-cli-kH4vuGod.mjs");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/doctor-contract-api.js

@@ -1,4 +1,4 @@
-import { n as CODEX_APP_SERVER_BINDING_NAMESPACE } from "./.setup/session-binding-meta-B7aEMU7g.mjs";
+import { i as CODEX_APP_SERVER_BINDING_NAMESPACE } from "./.setup/session-binding-meta-Lkm5Lpf4.mjs";
 import { asNullableRecord, asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { setImmediate } from "node:timers/promises";
@@ -193,31 +193,19 @@ function normalizeCompatibilityConfig({ cfg }) {
 	const rawPluginConfig = asNullableRecord(rawEntry?.config);
 	const rawCodexPlugins = asNullableRecord(rawPluginConfig?.codexPlugins);
 	const rawAppServer = asNullableRecord(rawPluginConfig?.appServer);
-	const shouldRemoveDynamicToolsProfile = rawPluginConfig !== null && hasRetiredDynamicToolsProfile(rawPluginConfig);
-	const shouldRewriteDestructivePolicy = hasLegacyPluginDestructivePolicy(rawCodexPlugins);
-	const shouldRewriteApprovalPolicy = hasRetiredApprovalPolicy(rawAppServer);
-	const shouldRemoveTurnIdleTimeouts = hasRetiredTurnIdleTimeout(rawAppServer);
-	const shouldRemoveBlankNetworkProxyFields = hasBlankNetworkProxyOptionalFields(rawAppServer);
-	if (!rawPluginConfig || !shouldRemoveDynamicToolsProfile && !shouldRewriteDestructivePolicy && !shouldRewriteApprovalPolicy && !shouldRemoveTurnIdleTimeouts && !shouldRemoveBlankNetworkProxyFields) return {
+	if (!rawPluginConfig || !hasRetiredDynamicToolsProfile(rawPluginConfig) && !hasLegacyPluginDestructivePolicy(rawCodexPlugins) && !hasRetiredApprovalPolicy(rawAppServer) && !hasRetiredTurnIdleTimeout(rawAppServer) && !hasBlankNetworkProxyOptionalFields(rawAppServer)) return {
 		config: cfg,
 		changes: []
 	};
 	const nextConfig = structuredClone(cfg);
-	const nextPlugins = asNullableRecord(nextConfig.plugins);
-	const nextEntries = asNullableRecord(nextPlugins?.entries);
-	const nextEntry = asNullableRecord(nextEntries?.codex);
-	const nextPluginConfig = asNullableRecord(nextEntry?.config);
-	if (!nextPluginConfig) return {
-		config: cfg,
-		changes: []
-	};
+	const nextPluginConfig = nextConfig.plugins.entries.codex.config;
 	const changes = [];
-	if (shouldRemoveDynamicToolsProfile) {
+	if (hasRetiredDynamicToolsProfile(nextPluginConfig)) {
 		delete nextPluginConfig.codexDynamicToolsProfile;
 		changes.push("Removed retired plugins.entries.codex.config.codexDynamicToolsProfile; Codex app-server always keeps Codex-native workspace tools native.");
 	}
-	if (shouldRewriteDestructivePolicy) {
-		const nextCodexPlugins = asNullableRecord(nextPluginConfig.codexPlugins);
+	const nextCodexPlugins = asNullableRecord(nextPluginConfig.codexPlugins);
+	if (hasLegacyPluginDestructivePolicy(nextCodexPlugins)) {
 		if (nextCodexPlugins?.allow_destructive_actions === "on-request") nextCodexPlugins.allow_destructive_actions = "auto";
 		const nextPluginPolicies = asNullableRecord(nextCodexPlugins?.plugins);
 		for (const plugin of Object.values(nextPluginPolicies ?? {})) {
@@ -227,13 +215,13 @@ function normalizeCompatibilityConfig({ cfg }) {
 		changes.push("Renamed plugins.entries.codex.config.codexPlugins allow_destructive_actions=\"on-request\" values to \"auto\".");
 	}
 	const nextAppServer = asNullableRecord(nextPluginConfig.appServer);
-	if (nextAppServer && shouldRemoveTurnIdleTimeouts) {
+	if (nextAppServer && hasRetiredTurnIdleTimeout(nextAppServer)) {
 		for (const key of RETIRED_TURN_IDLE_TIMEOUT_KEYS) if (Object.hasOwn(nextAppServer, key)) {
 			delete nextAppServer[key];
 			changes.push(`Removed retired plugins.entries.codex.config.appServer.${key}; native Codex owns provider liveness and turn completion. agents.defaults.timeoutSeconds was not changed.`);
 		}
 	}
-	if (nextAppServer && shouldRemoveBlankNetworkProxyFields) {
+	if (nextAppServer && hasBlankNetworkProxyOptionalFields(nextAppServer)) {
 		const nextNetworkProxy = asNullableRecord(nextAppServer.networkProxy);
 		for (const [target, key, configPath] of [[
 			nextNetworkProxy,
@@ -248,8 +236,8 @@ function normalizeCompatibilityConfig({ cfg }) {
 			changes.push(`Removed blank plugins.entries.codex.config.appServer.${configPath}; the default now applies.`);
 		}
 	}
-	if (shouldRewriteApprovalPolicy) {
-		if (nextAppServer?.approvalPolicy === "on-failure" || nextAppServer?.approvalPolicy === "untrusted") nextAppServer.approvalPolicy = "on-request";
+	if (nextAppServer && hasRetiredApprovalPolicy(nextAppServer)) {
+		nextAppServer.approvalPolicy = "on-request";
 		changes.push("Renamed retired plugins.entries.codex.config.appServer.approvalPolicy to \"on-request\".");
 	}
 	return {
@@ -261,15 +249,15 @@ const stateMigrations = [
 	{
 		id: "codex-app-server-sidecars-to-plugin-state",
 		label: "Codex app-server thread bindings",
-		detectLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-jo6H8dFr.mjs")).detectLegacySessionBindingSidecars(params),
-		migrateLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-jo6H8dFr.mjs")).migrateLegacySessionBindingSidecars(params)
+		detectLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-BrdV95Fg.mjs")).detectLegacySessionBindingSidecars(params),
+		migrateLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-BrdV95Fg.mjs")).migrateLegacySessionBindingSidecars(params)
 	},
 	{
 		id: "codex-native-task-assignments",
 		label: "Codex native pending assignments",
-		collectBackupResources: async (params) => (await import("./.setup/native-task-assignments-DMQ0g3hu.mjs")).codexNativeTaskAssignmentMigration.collectBackupResources(params),
-		detectLegacyState: async (params) => (await import("./.setup/native-task-assignments-DMQ0g3hu.mjs")).codexNativeTaskAssignmentMigration.detectLegacyState(params),
-		migrateLegacyState: async (params) => (await import("./.setup/native-task-assignments-DMQ0g3hu.mjs")).codexNativeTaskAssignmentMigration.migrateLegacyState(params)
+		collectBackupResources: async (params) => (await import("./.setup/native-task-assignments-C6KVqiN1.mjs")).codexNativeTaskAssignmentMigration.collectBackupResources(params),
+		detectLegacyState: async (params) => (await import("./.setup/native-task-assignments-C6KVqiN1.mjs")).codexNativeTaskAssignmentMigration.detectLegacyState(params),
+		migrateLegacyState: async (params) => (await import("./.setup/native-task-assignments-C6KVqiN1.mjs")).codexNativeTaskAssignmentMigration.migrateLegacyState(params)
 	},
 	codexOrphanedSessionBindingMigration
 ];

package/dist/harness.js

@@ -1,8 +1,9 @@
 import { CODEX_NATIVE_TOOL_REQUIREMENTS } from "./native-tool-policy.js";
 import { n as readCodexRuntimeModelId } from "./.setup/model-runtime-BdqzOMkU.mjs";
-import { v as sessionBindingIdentity } from "./.setup/session-binding-record-Oe9L-CNY.mjs";
-import { t as codexBuildSymbol } from "./.setup/build-state-Da1_z0kd.mjs";
+import { m as sessionBindingIdentity } from "./.setup/session-binding-record-BZB8RgcF.mjs";
+import { t as codexBuildSymbol } from "./.setup/build-state-CIi3Ckqu.mjs";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/harness.ts
 const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = /* @__PURE__ */ new Set(["codex", "openai"]);
 /** Keep the shipped callback loadable on older hosts without inventing source authority. */
@@ -60,6 +61,7 @@ function createCodexAppServerAgentHarness(options) {
 	let modelCatalog;
 	let disposed = false;
 	const resolveAttemptPluginConfig = (config) => resolvePluginConfigObject(config, "codex") ?? options.resolvePluginConfig?.() ?? options.pluginConfig;
+	const resolveIsolatedCompletionRuntime = ({ authorizationOwner }) => authorizationOwner === "host" ? "openclaw" : "self";
 	return {
 		id: harnessRuntimeId,
 		label: options?.label ?? "Codex agent harness",
@@ -79,6 +81,7 @@ function createCodexAppServerAgentHarness(options) {
 		conversationToolPolicyNativeTools: CODEX_NATIVE_TOOL_REQUIREMENTS,
 		deliveryDefaults: { visibleReplies: "message_tool" },
 		authBootstrap: "harness",
+		resolveIsolatedCompletionRuntime,
 		resolveSessionRuntimeOwnership: (params) => {
 			const assertCurrent = () => {
 				params.assertCurrent();
@@ -108,7 +111,7 @@ function createCodexAppServerAgentHarness(options) {
 			executionEnvironment: "host-only",
 			upstreamKinds: ["codex-app-server"],
 			fork: async (params) => {
-				const { forkCodexUpstreamSession } = await import("./.setup/upstream-session-fork-CBeVjBpT.mjs");
+				const { forkCodexUpstreamSession } = await import("./.setup/upstream-session-fork-LYlaQnbt.mjs");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -119,29 +122,41 @@ function createCodexAppServerAgentHarness(options) {
 			}
 		} } : {},
 		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./.setup/auth-binding-BLWz7stm.mjs").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./.setup/auth-binding-BoMwpuPN.mjs").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./.setup/runtime-artifact-DDQ-HGXf.mjs");
-			const { isCodexConfiguredConnectionArtifact } = await import("./.setup/runtime-artifact-connection-D68qQn1m.mjs");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./.setup/runtime-artifact-CUTOOnKw.mjs");
+			const { isCodexConfiguredConnectionArtifact } = await import("./.setup/runtime-artifact-connection-CADz3_BY.mjs");
 			if (!isCodexConfiguredConnectionArtifact(binding.id)) return validateCodexAppServerRuntimeArtifact(binding);
-			const { resolveCodexAppServerRuntimeOptions } = await import("./.setup/config-DKhXquav.mjs").then((n) => n.t);
+			const { resolveCodexAppServerRuntimeOptions } = await import("./.setup/config-0Gxk3_eq.mjs").then((n) => n.t);
 			return validateCodexAppServerRuntimeArtifact(binding, void 0, resolveCodexAppServerRuntimeOptions({ pluginConfig: resolveAttemptPluginConfig(options.resolveConfig?.()) }).start);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./.setup/usage-BMzNxeR_.mjs");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./.setup/usage-Dmx7B0W2.mjs");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		loadModelCatalog: async (params) => {
-			const { createCodexAppServerModelCatalog } = await import("./.setup/model-catalog-PAuZgJC6.mjs");
+			const { createCodexAppServerModelCatalog } = await import("./.setup/model-catalog-Dj_uvusa.mjs");
 			if (disposed) return { entries: [] };
 			modelCatalog ??= createCodexAppServerModelCatalog(harnessRuntimeId);
 			return { entries: await modelCatalog.load(params, resolveAttemptPluginConfig(params.config)) };
 		},
 		readModelCatalogReadiness: (params) => modelCatalog?.read(params, resolveAttemptPluginConfig(params.config)),
+		filterModelServiceTiers: ({ config, serviceTiers }) => {
+			return asOptionalRecord(asOptionalRecord(resolveAttemptPluginConfig(config))?.appServer)?.enableUltrafast === false ? serviceTiers.filter((tier) => tier !== "ultrafast") : serviceTiers;
+		},
+		acquireMcpAppRuntime: async (params) => {
+			const { acquireCodexMcpAppRuntime } = await import("./.setup/effective-mcp-catalog-BysTBZCW.mjs");
+			if (disposed) return;
+			params.assertCurrent();
+			return await acquireCodexMcpAppRuntime(params, {
+				bindingStore: options.bindingStore,
+				pluginConfig: resolveAttemptPluginConfig(params.config)
+			});
+		},
 		loadMcpToolCatalog: async (params) => {
-			const { loadCodexEffectiveMcpCatalog } = await import("./.setup/effective-mcp-catalog-CxUtC-xG.mjs");
+			const { loadCodexEffectiveMcpCatalog } = await import("./.setup/effective-mcp-catalog-BysTBZCW.mjs");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -184,9 +199,9 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./.setup/run-attempt-D8RZUOzY.mjs");
-			const { planCodexCyberEscalation, readCodexCyberAttemptVerdict, recordCodexCyberTargetUnavailable, reserveCodexCyberProbe, resolveCodexCyberFailoverConfig } = await import("./.setup/cyber-failover-XV0nNRZu.mjs");
-			const { emitCodexCyberNotice } = await import("./.setup/cyber-failover-notice-RNpGpTyP.mjs");
+			const { runCodexAppServerAttempt } = await import("./.setup/run-attempt-CgvFoW7R.mjs");
+			const { planCodexCyberEscalation, readCodexCyberAttemptVerdict, recordCodexCyberTargetUnavailable, reserveCodexCyberProbe, resolveCodexCyberFailoverConfig } = await import("./.setup/cyber-failover-Bb1J6hS1.mjs");
+			const { emitCodexCyberNotice } = await import("./.setup/cyber-failover-notice-XR03ef31.mjs");
 			const pluginConfig = resolveAttemptPluginConfig(params.config);
 			const attemptModel = readCodexRuntimeModelId(params.model, params.modelId);
 			const runAttemptOnModel = (model, isRetry = false) => runCodexAppServerAttempt(isRetry ? {
@@ -246,11 +261,11 @@ function createCodexAppServerAgentHarness(options) {
 			return escalated;
 		},
 		runIsolatedCompletionV2: async (params) => {
-			if (params.authorization.owner === "host") {
+			if (resolveIsolatedCompletionRuntime({ authorizationOwner: params.authorization.owner }) === "openclaw") {
 				const { runHostPreparedIsolatedCompletion } = await import("openclaw/plugin-sdk/simple-completion-runtime");
 				return runHostPreparedIsolatedCompletion(params);
 			}
-			const { runCodexIsolatedCompletion } = await import("./.setup/isolated-completion-Dm3PzxJk.mjs");
+			const { runCodexIsolatedCompletion } = await import("./.setup/isolated-completion-D5gbKm6k.mjs");
 			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runIsolatedCompletion: async (params) => {
@@ -266,11 +281,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./.setup/settled-turn-finalizer-BsvEabkw.mjs");
+			const { runCodexSettledTurnFinalization } = await import("./.setup/settled-turn-finalizer-CDxCejjC.mjs");
 			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./.setup/side-question-C4kCmQy1.mjs");
+			const { runCodexAppServerSideQuestion } = await import("./.setup/side-question-B7T0_GEC.mjs");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -281,25 +296,25 @@ function createCodexAppServerAgentHarness(options) {
 		},
 		compact: async (params) => {
 			const admittedParams = requireCodexCompactionCapabilities(params);
-			const { maybeCompactCodexAppServerSession } = await import("./.setup/compact-C2WamavS.mjs");
+			const { maybeCompactCodexAppServerSession } = await import("./.setup/compact-BLSAd-ru.mjs");
 			return maybeCompactCodexAppServerSession(admittedParams, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		withSessionDeletion: async (params, run) => {
-			const { withCodexAppServerSessionDeletion } = await import("./.setup/session-retirement-qMTxkNx2.mjs");
+			const { withCodexAppServerSessionDeletion } = await import("./.setup/session-retirement-aC60o6P3.mjs");
 			params.assertCurrent();
 			return withCodexAppServerSessionDeletion(options.bindingStore, params, run);
 		},
 		withSessionContextReset: async (params, run) => {
-			const { withCodexAppServerSessionContextReset } = await import("./.setup/session-retirement-qMTxkNx2.mjs");
+			const { withCodexAppServerSessionContextReset } = await import("./.setup/session-retirement-aC60o6P3.mjs");
 			params.assertCurrent();
 			return withCodexAppServerSessionContextReset(options.bindingStore, params, run);
 		},
 		reset: async (params) => {
 			if (params.sessionId && params.reason !== "deleted") {
-				const [{ reclaimCurrentCodexSessionGeneration }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./.setup/session-binding-DGCYAfvD.mjs").then((n) => n.s), import("./.setup/session-retirement-qMTxkNx2.mjs")]);
+				const [{ reclaimCurrentCodexSessionGeneration }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./.setup/session-binding-Ce7BqiPN.mjs").then((n) => n.i), import("./.setup/session-retirement-aC60o6P3.mjs")]);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
@@ -332,7 +347,7 @@ function createCodexAppServerAgentHarness(options) {
 function createCodexAppServerNativeCompaction(options) {
 	return async (params) => {
 		const admittedParams = requireCodexCompactionCapabilities(params);
-		const { maybeCompactCodexAppServerSession } = await import("./.setup/compact-C2WamavS.mjs");
+		const { maybeCompactCodexAppServerSession } = await import("./.setup/compact-BLSAd-ru.mjs");
 		return maybeCompactCodexAppServerSession(admittedParams, {
 			bindingStore: options.bindingStore,
 			pluginConfig: options.resolvePluginConfig?.() ?? options.pluginConfig,