@openclaw/codex 2026.9.6 → 2026.9.7

package/dist/.setup/{usage-BML0r-ua.mjs → usage-BMzNxeR_.mjs}

@@ -1,7 +1,7 @@
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-CMU3DUD0.mjs";
-import { n as readCodexAppServerUsage } from "./request-D2L0zMrq.mjs";
-import "./config-BoTP_mrL.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
+import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-B7-X2TgG.mjs";
+import { n as readCodexAppServerUsage } from "./request-BHZ1nz8d.mjs";
+import "./config-DKhXquav.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
 import { CODEX_APP_SERVER_AUTH_MARKER } from "openclaw/plugin-sdk/agent-runtime";
 //#region extensions/codex/src/app-server/usage.ts
 /** Handles the synthetic usage credential for a Codex-backed OpenAI route. */

package/dist/.setup/{usage-limit-error-DUMbefVY.mjs → usage-limit-error-QXerDo3i.mjs}

@@ -1,15 +1,11 @@
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CMU3DUD0.mjs";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-CDXOOFdZ.mjs";
-import { J as rememberCodexRateLimitsRead, K as readCodexRateLimitsRevision, q as readRecentCodexRateLimits } from "./shared-client-DA4VR4Eb.mjs";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-B7-X2TgG.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-B3WEZl4e.mjs";
+import { X as readRecentCodexRateLimits, Y as readCodexRateLimitsRevision, Z as rememberCodexRateLimitsRead } from "./shared-client-DqyTMYug.mjs";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { markAuthProfileBlockedUntil } from "openclaw/plugin-sdk/agent-runtime";
 import { embeddedAgentLog, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/usage-limit-error.ts
-/**
-* Enriches Codex usage-limit failures with current rate-limit information and
-* marks blocked auth profiles when Codex exposes a reset time.
-*/
 const CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS = 5e3;
 var CodexUsageLimitPromptError = class extends Error {
 	constructor(..._args) {
@@ -39,7 +35,6 @@ function resolveCodexPromptError(source) {
 		...info === "serverOverloaded" ? { code: "OVERLOADED" } : {}
 	});
 }
-/** Marks a Codex auth profile blocked until the reset time advertised by rate limits. */
 async function markCodexAuthProfileBlockedFromRateLimits(params) {
 	const authProfileId = params.authProfileId?.trim();
 	if (!authProfileId || !params.params.authProfileStore) return;
@@ -62,7 +57,6 @@ async function markCodexAuthProfileBlockedFromRateLimits(params) {
 		});
 	}
 }
-/** Formats a turn-start usage-limit error, refreshing rate limits when needed. */
 async function formatCodexTurnStartUsageLimitError(params) {
 	return refreshCodexUsageLimitError({
 		client: params.client,
@@ -71,7 +65,6 @@ async function formatCodexTurnStartUsageLimitError(params) {
 		signal: params.signal
 	});
 }
-/** Refreshes a generic prompt usage-limit message into a reset-aware message. */
 async function refreshCodexUsageLimitPromptError(params) {
 	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(params.message)) return;
 	return refreshCodexUsageLimitError({
@@ -87,15 +80,7 @@ async function refreshCodexUsageLimitPromptError(params) {
 }
 async function refreshCodexUsageLimitError(params) {
 	const initialMessage = formatCodexUsageLimitErrorMessage(params.source);
-	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(initialMessage)) return initialMessage ? {
-		message: initialMessage,
-		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
-	} : void 0;
-	const rateLimits = await readCodexRateLimitsFromAppServerForUsageLimitError({
-		client: params.client,
-		timeoutMs: params.timeoutMs,
-		signal: params.signal
-	});
+	const rateLimits = shouldRefreshCodexRateLimitsForUsageLimitMessage(initialMessage) ? await readCodexRateLimitsFromAppServerForUsageLimitError(params) : void 0;
 	if (!rateLimits) return initialMessage ? {
 		message: initialMessage,
 		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}

package/dist/.setup/{web-search-provider.runtime-CDKlN-Rv.mjs → web-search-provider.runtime-P77OUeoo.mjs}

@@ -1,7 +1,7 @@
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { f as buildCodexNativeWebSearchThreadConfig } from "./thread-requests-BLvGkP2R.mjs";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-B2HScEgT.mjs";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { f as buildCodexNativeWebSearchThreadConfig } from "./thread-requests-B_bRnMGN.mjs";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-CbjoN2OW.mjs";
+import { normalizeOptionalString, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readStringParam, resolveSearchTimeoutSeconds, wrapWebContent } from "openclaw/plugin-sdk/provider-web-search";
 //#region extensions/codex/src/web-search-provider.runtime.ts
 async function executeCodexWebSearchProviderTool(ctx, args, executionContext, options) {
@@ -46,11 +46,11 @@ async function executeCodexWebSearchProviderTool(ctx, args, executionContext, op
 }
 function summarizeCodexWebSearchItem(item) {
 	const action = isJsonObject(item.action) ? item.action : void 0;
-	const actionType = readNonEmptyString(action, "type");
-	const queries = actionType === "search" ? readNonEmptyStringArray(action, "queries") : [];
-	const query = normalizeOptionalString(item.query) ?? (actionType === "search" ? readNonEmptyString(action, "query") : void 0) ?? queries[0];
-	const url = readNonEmptyString(action, "url");
-	const pattern = readNonEmptyString(action, "pattern");
+	const actionType = normalizeOptionalString(action?.type);
+	const queries = actionType === "search" ? normalizeTrimmedStringList(action?.queries) : [];
+	const query = normalizeOptionalString(item.query) ?? (actionType === "search" ? normalizeOptionalString(action?.query) : void 0) ?? queries[0];
+	const url = normalizeOptionalString(action?.url);
+	const pattern = normalizeOptionalString(action?.pattern);
 	return {
 		...query ? { query } : {},
 		...queries.length > 0 ? { queries } : {},
@@ -59,16 +59,5 @@ function summarizeCodexWebSearchItem(item) {
 		...pattern ? { pattern } : {}
 	};
 }
-function readNonEmptyString(record, key) {
-	return record ? normalizeOptionalString(record[key]) : void 0;
-}
-function readNonEmptyStringArray(record, key) {
-	const value = record?.[key];
-	if (!Array.isArray(value)) return [];
-	return value.flatMap((entry) => {
-		const normalized = normalizeOptionalString(entry);
-		return normalized ? [normalized] : [];
-	});
-}
 //#endregion
 export { executeCodexWebSearchProviderTool };

package/dist/api.js

@@ -1,13 +1,14 @@
-import { d as readCodexPluginConfig } from "./.setup/config-parsing-CcB9iPoq.mjs";
-import { a as resolveCodexAppServerStartOptionsForAgent } from "./.setup/config-options-BvaRs51b.mjs";
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, s as CODEX_APP_SERVER_VERSION, t as isManagedCodexDesktopCommand } from "./.setup/managed-binary-BnshlFag.mjs";
+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 { 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-BoTP_mrL.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./.setup/config-runtime-C8Rw1m1m.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 { 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";
@@ -26,9 +27,6 @@ function managedCodexFinding(params) {
 		...params.fixHint ? { fixHint: params.fixHint } : {}
 	};
 }
-function readErrorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 function parseCodexVersion(output) {
 	return /(?:^|\s)(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)(?:\s|$)/u.exec(output)?.[1];
 }
@@ -97,7 +95,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 					resolved = await resolveStartOptions(candidate, { pluginRoot: params.pluginRoot });
 				} catch (error) {
 					return [managedCodexFinding({
-						message: `Managed Codex app-server could not be resolved: ${readErrorMessage(error)}`,
+						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."
@@ -120,7 +118,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 			} catch (error) {
 				const spawnFailure = findCodexAppServerSpawnError(describeCodexSpawnError(error, nativeCommand));
 				return [managedCodexFinding({
-					message: spawnFailure?.message ?? `Managed Codex app-server version check failed: ${readErrorMessage(error)}`,
+					message: spawnFailure?.message ?? `Managed Codex app-server version check failed: ${coerceErrorMessage(error)}`,
 					severity: spawnFailure && resolved.managedCommandOrder === "package-only" ? "warning" : versionFailureSeverity,
 					path: nativeCommand,
 					requirement: `Codex ${CODEX_APP_SERVER_VERSION} must report its version within ${CODEX_VERSION_TIMEOUT_MS} ms`,
@@ -128,7 +126,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 				})];
 			}
 			const detectedVersion = parseCodexVersion(`${output.stdout}\n${output.stderr}`);
-			if (detectedVersion !== "0.155.1") return [managedCodexFinding({
+			if (detectedVersion !== "0.158.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,

package/dist/catalog-page.worker.js

@@ -1,4 +1,4 @@
-import { t as createCodexCatalogDecoder } from "./.setup/client-catalog-response-BMgt_4q4.mjs";
+import { t as createCodexCatalogDecoder } from "./.setup/client-catalog-response-5HHLdcde.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-irrD-uo7.mjs");
+		const { registerCodexSessionCli } = await import("./.setup/session-cli-Cn_nCqfq.mjs");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/doctor-contract-api.js

@@ -114,6 +114,11 @@ function hasRetiredApprovalPolicy(value) {
 	const approvalPolicy = asNullableRecord(value)?.approvalPolicy;
 	return approvalPolicy === "on-failure" || approvalPolicy === "untrusted";
 }
+function hasBlankNetworkProxyOptionalFields(value) {
+	const appServer = asNullableRecord(value);
+	const networkProxy = asNullableRecord(appServer?.networkProxy);
+	return networkProxy?.enabled === true && [networkProxy.profileName, appServer?.remoteWorkspaceRoot].some((field) => typeof field === "string" && !field.trim());
+}
 const RETIRED_TURN_IDLE_TIMEOUT_KEYS = [
 	"turnCompletionIdleTimeoutMs",
 	"turnAssistantCompletionIdleTimeoutMs",
@@ -167,10 +172,21 @@ const legacyConfigRules = [
 		],
 		message: "Codex app-server turn idle timeouts are retired; native Codex owns provider liveness and turn completion. The existing agents.defaults.timeoutSeconds run limit remains unchanged. Run \"openclaw doctor --fix\" to remove the old settings.",
 		match: hasRetiredTurnIdleTimeout
+	},
+	{
+		path: [
+			"plugins",
+			"entries",
+			"codex",
+			"config",
+			"appServer"
+		],
+		message: "Blank plugins.entries.codex.config.appServer.networkProxy.profileName or appServer.remoteWorkspaceRoot must be removed to use the defaults with network restrictions. Run \"openclaw doctor --fix\".",
+		match: hasBlankNetworkProxyOptionalFields
 	}
 ];
 /**
-* Removes retired Codex plugin config keys while preserving unrelated config.
+* Repairs legacy Codex plugin config while preserving unrelated config.
 */
 function normalizeCompatibilityConfig({ cfg }) {
 	const rawEntry = asNullableRecord(cfg.plugins?.entries?.codex);
@@ -181,7 +197,8 @@ function normalizeCompatibilityConfig({ cfg }) {
 	const shouldRewriteDestructivePolicy = hasLegacyPluginDestructivePolicy(rawCodexPlugins);
 	const shouldRewriteApprovalPolicy = hasRetiredApprovalPolicy(rawAppServer);
 	const shouldRemoveTurnIdleTimeouts = hasRetiredTurnIdleTimeout(rawAppServer);
-	if (!rawPluginConfig || !shouldRemoveDynamicToolsProfile && !shouldRewriteDestructivePolicy && !shouldRewriteApprovalPolicy && !shouldRemoveTurnIdleTimeouts) return {
+	const shouldRemoveBlankNetworkProxyFields = hasBlankNetworkProxyOptionalFields(rawAppServer);
+	if (!rawPluginConfig || !shouldRemoveDynamicToolsProfile && !shouldRewriteDestructivePolicy && !shouldRewriteApprovalPolicy && !shouldRemoveTurnIdleTimeouts && !shouldRemoveBlankNetworkProxyFields) return {
 		config: cfg,
 		changes: []
 	};
@@ -216,6 +233,21 @@ function normalizeCompatibilityConfig({ cfg }) {
 			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) {
+		const nextNetworkProxy = asNullableRecord(nextAppServer.networkProxy);
+		for (const [target, key, configPath] of [[
+			nextNetworkProxy,
+			"profileName",
+			"networkProxy.profileName"
+		], [
+			nextAppServer,
+			"remoteWorkspaceRoot",
+			"remoteWorkspaceRoot"
+		]]) if (target && typeof target[key] === "string" && !target[key].trim()) {
+			delete target[key];
+			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";
 		changes.push("Renamed retired plugins.entries.codex.config.appServer.approvalPolicy to \"on-request\".");
@@ -225,11 +257,21 @@ function normalizeCompatibilityConfig({ cfg }) {
 		changes
 	};
 }
-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-BlB5EvIS.mjs")).detectLegacySessionBindingSidecars(params),
-	migrateLegacyState: async (params) => (await import("./.setup/session-binding-sidecars-BlB5EvIS.mjs")).migrateLegacySessionBindingSidecars(params)
-}, codexOrphanedSessionBindingMigration];
+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)
+	},
+	{
+		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)
+	},
+	codexOrphanedSessionBindingMigration
+];
 //#endregion
 export { legacyConfigRules, normalizeCompatibilityConfig, stateMigrations };

package/dist/harness.js

@@ -1,2 +1,345 @@
-import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./.setup/harness-a_MsE4-_.mjs";
+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 { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-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. */
+function requireCodexCompactionCapabilities(params) {
+	const capabilities = params.hostCapabilities;
+	if (capabilities?.kind !== "agent-harness-host-capability" || capabilities.version !== 1 || typeof capabilities.assertActive !== "function" || typeof capabilities.retainSourceAuthority !== "function") throw new Error("This host did not provide compaction source authority. Update OpenClaw before compacting this session.");
+	capabilities.assertActive();
+	return {
+		...params,
+		hostCapabilities: capabilities
+	};
+}
+const SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER = codexBuildSymbol("openclaw.codexAppServerClientDisposer");
+const CODEX_TOOL_POLICY_SAFE_DENY_NAMES = [
+	"web_fetch",
+	"x_search",
+	"memory_search",
+	"memory_get",
+	"dashboard",
+	"canvas",
+	"show_widget",
+	"message",
+	"heartbeat_respond",
+	"automations",
+	"gateway",
+	"skill_workshop",
+	"image_generate",
+	"music_generate",
+	"video_generate",
+	"tts"
+];
+const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
+	"bootstrap",
+	"assemble-before-prompt",
+	"after-turn",
+	"maintain",
+	"compact",
+	"runtime-llm-complete",
+	"thread-bootstrap-projection"
+];
+async function disposeSharedCodexAppServerClients() {
+	const dispose = globalThis[SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER];
+	await dispose?.();
+}
+/**
+* Creates the Codex app-server harness used for attempts, side questions,
+* compaction, reset, and disposal.
+*/
+function createCodexAppServerAgentHarness(options) {
+	const harnessRuntimeId = options?.id ?? "codex";
+	const normalizedHarnessRuntimeId = harnessRuntimeId.trim().toLowerCase();
+	const providerIds = new Set([...options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS].map((id) => id.trim().toLowerCase()));
+	const sessionCatalogControlFactory = options.sessionCatalogControlFactory;
+	const sessionRuntime = options.runtime;
+	let modelCatalog;
+	let disposed = false;
+	const resolveAttemptPluginConfig = (config) => resolvePluginConfigObject(config, "codex") ?? options.resolvePluginConfig?.() ?? options.pluginConfig;
+	return {
+		id: harnessRuntimeId,
+		label: options?.label ?? "Codex agent harness",
+		autoSelection: { providerIds: [...providerIds] },
+		cloudPlacement: {
+			mode: "remote-exec",
+			devicePlacement: {
+				requiredNodeCommands: ["codex.exec-server.stdio.v1"],
+				consumesWorkerSlot: false
+			}
+		},
+		delegatedExecutionPluginIds: ["voice-call"],
+		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
+		conversationToolPolicySupport: "exact",
+		nativeModelPolicySupport: "exact",
+		conversationToolPolicySafeDenyTools: CODEX_TOOL_POLICY_SAFE_DENY_NAMES,
+		conversationToolPolicyNativeTools: CODEX_NATIVE_TOOL_REQUIREMENTS,
+		deliveryDefaults: { visibleReplies: "message_tool" },
+		authBootstrap: "harness",
+		resolveSessionRuntimeOwnership: (params) => {
+			const assertCurrent = () => {
+				params.assertCurrent();
+				if (disposed) throw new Error("Codex agent harness is disposed");
+			};
+			assertCurrent();
+			const identity = sessionBindingIdentity(params);
+			let binding = options.bindingStore.read(identity);
+			if (!binding) {
+				const previousSessionId = params.readPreviousSessionId?.();
+				binding = previousSessionId ? options.bindingStore.read({
+					...identity,
+					sessionId: previousSessionId
+				}) : void 0;
+			}
+			assertCurrent();
+			return binding?.preserveNativeModel === true ? {
+				model: "native",
+				auth: binding.connectionScope === "supervision" ? "native" : "host",
+				...binding.model?.trim() && binding.modelProvider ? { modelRef: {
+					provider: binding.modelProvider,
+					model: binding.model
+				} } : {}
+			} : void 0;
+		},
+		...sessionCatalogControlFactory && sessionRuntime ? { sessionForkV2: {
+			executionEnvironment: "host-only",
+			upstreamKinds: ["codex-app-server"],
+			fork: async (params) => {
+				const { forkCodexUpstreamSession } = await import("./.setup/upstream-session-fork-CBeVjBpT.mjs");
+				return await forkCodexUpstreamSession(params, {
+					bindingStore: options.bindingStore,
+					controlFactory: sessionCatalogControlFactory,
+					harnessRuntimeId,
+					resolveConfig: options.resolveConfig,
+					runtime: sessionRuntime
+				});
+			}
+		} } : {},
+		authBinding: { fingerprint: async (params) => {
+			const { fingerprintCodexAppServerAuthBinding } = await import("./.setup/auth-binding-BLWz7stm.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");
+			if (!isCodexConfiguredConnectionArtifact(binding.id)) return validateCodexAppServerRuntimeArtifact(binding);
+			const { resolveCodexAppServerRuntimeOptions } = await import("./.setup/config-DKhXquav.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");
+			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
+		loadModelCatalog: async (params) => {
+			const { createCodexAppServerModelCatalog } = await import("./.setup/model-catalog-PAuZgJC6.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)),
+		loadMcpToolCatalog: async (params) => {
+			const { loadCodexEffectiveMcpCatalog } = await import("./.setup/effective-mcp-catalog-CxUtC-xG.mjs");
+			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
+		},
+		supports: (ctx) => {
+			const provider = ctx.provider.trim().toLowerCase();
+			if (!providerIds.has(provider)) return {
+				supported: false,
+				reason: `provider is not one of: ${[...providerIds].toSorted().join(", ")}`
+			};
+			if (ctx.modelProvider?.requestTransportOverrides === "present") return {
+				supported: false,
+				reason: "Codex cannot reproduce authored request transport overrides",
+				fallbackRuntime: "openclaw"
+			};
+			const preparedAuth = ctx.modelProvider?.preparedAuth;
+			const runtimePolicy = ctx.modelProvider?.runtimePolicy;
+			const nativeAccountOwnsUnobservedModel = provider === "openai" && ctx.requestedRuntime === "codex" && Boolean(ctx.modelId?.trim()) && (preparedAuth === void 0 || preparedAuth.source === "harness") && preparedAuth?.mode === void 0 && preparedAuth?.requirement === void 0 && ctx.modelProvider?.api === void 0 && ctx.modelProvider?.baseUrl === void 0 && ctx.modelProvider?.azureApiVersion === void 0 && ctx.modelProvider?.request === void 0;
+			if (runtimePolicy) {
+				if (!runtimePolicy.compatibleIds.some((id) => id.trim().toLowerCase() === normalizedHarnessRuntimeId)) return {
+					supported: false,
+					reason: "Codex cannot reproduce the prepared provider route"
+				};
+			} else if (ctx.modelProvider && provider !== "codex" && !nativeAccountOwnsUnobservedModel) return {
+				supported: false,
+				reason: "provider route compatibility with Codex is not declared"
+			};
+			if (preparedAuth?.requirement === "subscription") {
+				if (!(preparedAuth.source === "profile" && (preparedAuth.mode === "oauth" || preparedAuth.mode === "token"))) return {
+					supported: false,
+					reason: "Codex subscription auth requires a prepared OAuth or token profile"
+				};
+			} else if (preparedAuth?.requirement === "api-key") {
+				if (!(preparedAuth.source !== "none" && preparedAuth.source !== "harness" && (preparedAuth.mode === "api-key" || preparedAuth.mode === "api_key"))) return {
+					supported: false,
+					reason: "Codex Platform auth requires a prepared API key"
+				};
+			}
+			return {
+				supported: true,
+				priority: 100
+			};
+		},
+		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 pluginConfig = resolveAttemptPluginConfig(params.config);
+			const attemptModel = readCodexRuntimeModelId(params.model, params.modelId);
+			const runAttemptOnModel = (model, isRetry = false) => runCodexAppServerAttempt(isRetry ? {
+				...params,
+				suppressNextUserMessagePersistence: true
+			} : params, {
+				bindingStore: options.bindingStore,
+				pluginConfig,
+				runtime: sessionRuntime,
+				runtimeModelId: model,
+				nativeHookRelay: { enabled: true }
+			});
+			const cyberFailover = resolveCodexCyberFailoverConfig(pluginConfig);
+			const workspace = {
+				agentId: params.agentId,
+				authProfileId: params.authProfileId
+			};
+			const result = await runAttemptOnModel(attemptModel);
+			const refusal = readCodexCyberAttemptVerdict(result);
+			if (!refusal.cyberRefused) return result;
+			const plan = planCodexCyberEscalation({
+				config: cyberFailover,
+				currentModel: attemptModel,
+				replaySafe: refusal.replaySafe,
+				workspace
+			});
+			if (plan.kind !== "escalate") {
+				if (plan.reason === "target_unavailable") await emitCodexCyberNotice(params, {
+					state: "unavailable",
+					model: attemptModel,
+					fallbackModel: cyberFailover.model
+				});
+				return result;
+			}
+			const releaseProbe = reserveCodexCyberProbe({
+				model: plan.model,
+				workspace
+			});
+			let escalated;
+			try {
+				escalated = await runAttemptOnModel(plan.model, true);
+			} finally {
+				releaseProbe();
+			}
+			const outcome = readCodexCyberAttemptVerdict(escalated);
+			if (outcome.unavailable) recordCodexCyberTargetUnavailable({
+				model: plan.model,
+				workspace,
+				cooloffMs: cyberFailover.cooloffMs
+			});
+			if (outcome.answered || outcome.unavailable) await emitCodexCyberNotice(params, {
+				state: outcome.answered ? "escalated" : "unavailable",
+				model: attemptModel,
+				fallbackModel: plan.model
+			});
+			if (outcome.unavailable && outcome.replaySafe && escalated.terminal.kind === "failed" && escalated.toolMetas.length === 0) return result;
+			return escalated;
+		},
+		runIsolatedCompletionV2: async (params) => {
+			if (params.authorization.owner === "host") {
+				const { runHostPreparedIsolatedCompletion } = await import("openclaw/plugin-sdk/simple-completion-runtime");
+				return runHostPreparedIsolatedCompletion(params);
+			}
+			const { runCodexIsolatedCompletion } = await import("./.setup/isolated-completion-Dm3PzxJk.mjs");
+			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
+		runIsolatedCompletion: async (params) => {
+			const { runHostPreparedIsolatedCompletion } = await import("openclaw/plugin-sdk/simple-completion-runtime");
+			return runHostPreparedIsolatedCompletion({
+				...params,
+				authorization: {
+					owner: "host",
+					model: params.model,
+					auth: params.auth,
+					sourceAuthFingerprint: params.sourceAuthFingerprint
+				}
+			});
+		},
+		finalizeSettledTurn: async (params) => {
+			const { runCodexSettledTurnFinalization } = await import("./.setup/settled-turn-finalizer-BsvEabkw.mjs");
+			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
+		runSideQuestion: async (params) => {
+			const { runCodexAppServerSideQuestion } = await import("./.setup/side-question-C4kCmQy1.mjs");
+			return runCodexAppServerSideQuestion(params, {
+				bindingStore: options.bindingStore,
+				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
+				runtime: sessionRuntime,
+				runtimeModelId: readCodexRuntimeModelId(params.runtimeModel, params.model),
+				nativeHookRelay: { enabled: true }
+			});
+		},
+		compact: async (params) => {
+			const admittedParams = requireCodexCompactionCapabilities(params);
+			const { maybeCompactCodexAppServerSession } = await import("./.setup/compact-C2WamavS.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");
+			params.assertCurrent();
+			return withCodexAppServerSessionDeletion(options.bindingStore, params, run);
+		},
+		withSessionContextReset: async (params, run) => {
+			const { withCodexAppServerSessionContextReset } = await import("./.setup/session-retirement-qMTxkNx2.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 identity = sessionBindingIdentity({
+					agentId: params.agentId,
+					sessionId: params.sessionId,
+					sessionKey: params.sessionKey
+				});
+				const resetGeneration = () => retireCodexAppServerSessionGeneration({
+					bindingStore: options.bindingStore,
+					identity,
+					mode: "reset"
+				});
+				let reset = await resetGeneration();
+				if (reset === "conflict") {
+					if (await reclaimCurrentCodexSessionGeneration({
+						bindingStore: options.bindingStore,
+						identity,
+						config: options.resolveConfig?.()
+					})) reset = await resetGeneration();
+				}
+				if (reset === "conflict") throw new Error(`Codex binding generation changed before session ${params.sessionId} could reset`);
+			}
+		},
+		dispose: async () => {
+			disposed = true;
+			modelCatalog?.dispose();
+			await disposeSharedCodexAppServerClients();
+		}
+	};
+}
+/** Creates the private native-compaction bridge registered in host-owned capability state. */
+function createCodexAppServerNativeCompaction(options) {
+	return async (params) => {
+		const admittedParams = requireCodexCompactionCapabilities(params);
+		const { maybeCompactCodexAppServerSession } = await import("./.setup/compact-C2WamavS.mjs");
+		return maybeCompactCodexAppServerSession(admittedParams, {
+			bindingStore: options.bindingStore,
+			pluginConfig: options.resolvePluginConfig?.() ?? options.pluginConfig,
+			allowNonManualNativeRequest: true,
+			nativeCompactionRequest: admittedParams.nativeCompactionRequest
+		});
+	};
+}
+//#endregion
 export { createCodexAppServerAgentHarness, createCodexAppServerNativeCompaction };