@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{effective-mcp-catalog-Bd73bqA8.js → .setup/effective-mcp-catalog-CvnvnGIe.mjs}

@@ -1,6 +1,6 @@
-import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
-import { _ as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-CscigXXL.js";
-import "./session-binding-CI8UuilT.js";
+import { m as sessionBindingIdentity } from "./session-binding-record-BGoz8wOK.mjs";
+import { _ as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-DA4VR4Eb.mjs";
+import "./session-binding-Cm0apEbd.mjs";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { assignMcpCatalogSafeServerNames } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/effective-mcp-catalog.ts

package/dist/{ephemeral-turn-D78_VmzO.js → .setup/ephemeral-turn-poidXgek.mjs}

@@ -1,8 +1,7 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
-import { T as readCodexTurnCompletedNotification } from "./client-B57KWPQx.js";
-import { p as getCodexAppServerTurnRouter } from "./attempt-client-cleanup-DKHzbwt5.js";
-import { o as isTerminalTurnStatus, s as readCodexNotificationItem } from "./attempt-notifications-C9XufG6l.js";
-import { t as CodexUsageProjection } from "./event-projector-usage-BfXmpOec.js";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { T as readCodexTurnCompletedNotification } from "./client-Cs08OXVQ.mjs";
+import { h as getCodexAppServerTurnRouter } from "./attempt-client-cleanup-CEv1cKwF.mjs";
+import { c as readCodexNotificationItem, s as isTerminalTurnStatus, t as CodexUsageProjection } from "./event-projector-usage-CnBS8Wa3.mjs";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
@@ -37,8 +36,11 @@ var CodexEphemeralTurn = class {
 						if (firstDelta) await options.onAssistantMessageStart?.();
 					} else if (notification.method === "rawResponse/completed") this.usage.record(params);
 					else if (notification.method === "turn/completed") {
-						this.turn = readCodexTurnCompletedNotification(params)?.turn ?? this.turn;
-						this.completion.resolve();
+						const completed = readCodexTurnCompletedNotification(params);
+						if (completed) {
+							this.turn = completed.turn;
+							this.completion.resolve();
+						}
 					} else if (notification.method === "error") {
 						this.usage.invalidateContext();
 						if (params.willRetry !== true) {

package/dist/{event-projector-assistant-message-BmBM4qBV.js → .setup/event-projector-assistant-message-BsruvNrH.mjs}

@@ -1,4 +1,5 @@
-import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-B_2mnqhb.js";
+import { g as codexProviderRefusalDetails } from "./event-projector-items-C6L_5ZiT.mjs";
+import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-B_2mnqhb.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/event-projector-assistant-message.ts
 const ZERO_USAGE = {
@@ -49,10 +50,7 @@ function createAttributedCodexAssistantMessage(attribution, text, options) {
 		...refusal ? { diagnostics: [{
 			type: "provider_refusal",
 			timestamp: Date.now(),
-			details: {
-				provider: "openai",
-				category: refusal.category
-			}
+			details: codexProviderRefusalDetails(refusal)
 		}] } : {},
 		timestamp: Date.now()
 	};
@@ -70,13 +68,16 @@ function createAssistantCommentaryMessage(params, text, itemId, timestamp) {
 		}
 	};
 }
-function createAssistantAsyncMessage(params, text, itemId, timestamp) {
+function createAssistantAsyncMessage(params, text, itemId, timestamp, questions) {
 	return {
 		...createNonterminalAssistantMessage(params, [{
 			type: "text",
 			text
 		}], timestamp),
-		openclawAsyncDelivery: { itemId }
+		openclawAsyncDelivery: {
+			itemId,
+			...questions ? { questions } : {}
+		}
 	};
 }
 function createAssistantReasoningMessage(params, text) {

package/dist/{event-projector-items-5VhsECCO.js → .setup/event-projector-items-C6L_5ZiT.mjs}

@@ -1,23 +1,51 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
 import { asFiniteNumber, normalizeOptionalString as normalizeOptionalString$1, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { Buffer } from "node:buffer";
 //#region extensions/codex/src/app-server/event-projector-values.ts
 const BIO_POLICY_SAFETY_ACCESS_BLOCK_PREFIX = "This content was flagged for possible biological risk.";
+/** Decode app-server v2 findings with the Codex UI's UTF-8 limits; never truncate a steer. */
+function readCodexMisalignmentReview(value) {
+	if (!isJsonObject(value)) return;
+	const explanation = value.detailedExplanation;
+	if (typeof explanation !== "string" || !explanation.trim() || Buffer.byteLength(explanation, "utf8") > 65536) return;
+	const message = isJsonObject(value.steer) ? value.steer.message : void 0;
+	return {
+		explanation,
+		...typeof message === "string" && message.trim() && Buffer.byteLength(message, "utf8") <= 1024 ? { continuation: { message } } : {},
+		...typeof value.errorType === "string" && value.errorType.trim() ? { errorType: value.errorType } : {}
+	};
+}
 /** Project only Codex's explicit refusal contracts; other policy errors retain their own paths. */
-function readCodexProviderRefusal(message, codexErrorInfo) {
+function readCodexProviderRefusal(message, codexErrorInfo, options) {
 	if (!message) return;
 	if (codexErrorInfo === "cyberPolicy") return {
 		category: "cyber",
 		message
 	};
-	if (codexErrorInfo === "misalignmentPolicyViolation") return {
-		category: "misalignment",
-		message
-	};
+	if (codexErrorInfo === "misalignmentPolicyViolation") {
+		const review = readCodexMisalignmentReview(options?.misalignment);
+		return {
+			category: "misalignment",
+			message,
+			...review ? { review } : {},
+			...options?.nativeThreadId ? { nativeThreadId: options.nativeThreadId } : {},
+			...options?.nativeTurnId ? { nativeTurnId: options.nativeTurnId } : {}
+		};
+	}
 	return message.startsWith(BIO_POLICY_SAFETY_ACCESS_BLOCK_PREFIX) ? {
 		category: "bio",
 		message
 	} : void 0;
 }
+function codexProviderRefusalDetails(refusal) {
+	return {
+		provider: "openai",
+		category: refusal.category,
+		...refusal.review ? { review: refusal.review } : {},
+		...refusal.nativeThreadId ? { nativeThreadId: refusal.nativeThreadId } : {},
+		...refusal.nativeTurnId ? { nativeTurnId: refusal.nativeTurnId } : {}
+	};
+}
 function readNonEmptyString(record, key) {
 	return normalizeOptionalString$1(record[key]);
 }
@@ -178,7 +206,13 @@ function shouldSynthesizeToolProgressForItem(item) {
 	}
 }
 function shouldRecordNativeToolTranscript(item) {
-	return shouldSynthesizeToolProgressForItem(item);
+	switch (item.type) {
+		case "commandExecution":
+		case "fileChange":
+		case "webSearch":
+		case "mcpToolCall": return true;
+		default: return false;
+	}
 }
 function isMutatingNativeToolItem(item) {
 	if (item.type === "commandExecution") return true;
@@ -197,4 +231,4 @@ function shouldClearTerminalPresentationForNativeItem(item) {
 	}
 }
 //#endregion
-export { readNonEmptyString as C, splitPlanText as D, readNullableString as E, readItemString as S, readNonNegativeInteger as T, normalizeOptionalString$1 as _, isNonSuccessItemStatus as a, readHookOutputEntries as b, itemName as c, matchesCodexSnapshotTurn as d, shouldClearTerminalPresentationForNativeItem as f, extractRawAssistantText as g, unknownItemStatus as h, isMutatingNativeToolItem as i, itemStatus as l, shouldSynthesizeToolProgressForItem as m, auditNativeToolTerminalStatus as n, isSideEffectingNativeToolItem as o, shouldRecordNativeToolTranscript as p, auditNativeToolUnfinishedStatus as r, itemKind as s, auditNativeToolName as t, itemTitle as u, readCodexErrorNotificationMessage as v, readNonEmptyStringArray as w, readItem as x, readCodexProviderRefusal as y };
+export { readItemString as C, readNullableString as D, readNonNegativeInteger as E, splitPlanText as O, readItem as S, readNonEmptyStringArray as T, extractRawAssistantText as _, isNonSuccessItemStatus as a, readCodexProviderRefusal as b, itemName as c, matchesCodexSnapshotTurn as d, shouldClearTerminalPresentationForNativeItem as f, codexProviderRefusalDetails as g, unknownItemStatus as h, isMutatingNativeToolItem as i, itemStatus as l, shouldSynthesizeToolProgressForItem as m, auditNativeToolTerminalStatus as n, isSideEffectingNativeToolItem as o, shouldRecordNativeToolTranscript as p, auditNativeToolUnfinishedStatus as r, itemKind as s, auditNativeToolName as t, itemTitle as u, normalizeOptionalString$1 as v, readNonEmptyString as w, readHookOutputEntries as x, readCodexErrorNotificationMessage as y };

package/dist/{attempt-notifications-C9XufG6l.js → .setup/event-projector-usage-CnBS8Wa3.mjs}

@@ -1,5 +1,6 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
-import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { asSafeIntegerInRange, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeUsage } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/attempt-notifications.ts
 const CODEX_TURN_ABORT_MARKER_START = "<turn_aborted>";
 const CODEX_TURN_ABORT_MARKER_END = "</turn_aborted>";
@@ -34,12 +35,6 @@ function isRawFunctionToolOutputCompletionNotification(notification) {
 	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
 	return item ? readStringField(item, "type") === "function_call_output" : false;
 }
-/** Distinguishes progress-only assistant items from conversation answers. */
-function isAssistantCommentaryCompletionNotification(notification) {
-	if (!isJsonObject(notification.params) || notification.method !== "item/completed") return false;
-	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
-	return Boolean(item && readStringField(item, "type") === "agentMessage" && (readStringField(item, "phase") === "commentary" || readStringField(item, "delivery") === "async"));
-}
 /** Returns true for terminal app-server thread status strings. */
 function isTerminalTurnStatus(status) {
 	return status === "completed" || status === "interrupted" || status === "failed";
@@ -106,4 +101,102 @@ function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
 //#endregion
-export { isRawFunctionToolOutputCompletionNotification as a, readNotificationItemId as c, isPendingOpenClawDynamicToolCompletionNotification as i, readRawResponseToolCallId as l, isAssistantCommentaryCompletionNotification as n, isTerminalTurnStatus as o, isCodexTurnAbortMarkerNotification as r, readCodexNotificationItem as s, codexExecutionToolName as t, updateActiveTurnItemIds as u };
+//#region extensions/codex/src/app-server/event-projector-usage.ts
+function readTokenCount(record, key) {
+	return asSafeIntegerInRange(record[key], { min: 0 });
+}
+function readCodexThreadTokenUsage(params) {
+	const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
+	const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
+	return last ? normalizeCodexResponseTokenUsage(last) : void 0;
+}
+function readCodexThreadContextSnapshot(params) {
+	const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
+	const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
+	const modelContextWindow = tokenUsage ? readTokenCount(tokenUsage, "modelContextWindow") : void 0;
+	const activeContextTokens = last ? readTokenCount(last, "totalTokens") : void 0;
+	const inputTokens = last ? readTokenCount(last, "inputTokens") : void 0;
+	const cachedInputTokens = last ? readTokenCount(last, "cachedInputTokens") : void 0;
+	const cacheWriteInputTokens = last ? readTokenCount(last, "cacheWriteInputTokens") : void 0;
+	const reasoningOutputTokens = last ? readTokenCount(last, "reasoningOutputTokens") : void 0;
+	return {
+		...activeContextTokens !== void 0 ? { activeContextTokens } : {},
+		...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+		...cacheWriteInputTokens !== void 0 ? { cacheWriteInputTokens } : {},
+		...inputTokens !== void 0 ? { inputTokens } : {},
+		...modelContextWindow && modelContextWindow > 0 ? { modelContextWindow } : {},
+		...inputTokens !== void 0 ? { promptTokens: inputTokens } : {},
+		...reasoningOutputTokens !== void 0 ? { reasoningOutputTokens } : {}
+	};
+}
+function normalizeCodexResponseTokenUsage(record) {
+	const totalTokens = readTokenCount(record, "totalTokens");
+	const inputTokens = readTokenCount(record, "inputTokens");
+	const cacheRead = readTokenCount(record, "cachedInputTokens");
+	const output = readTokenCount(record, "outputTokens");
+	const reasoningTokens = readTokenCount(record, "reasoningOutputTokens");
+	const cacheWrite = record.cacheWriteInputTokens === void 0 ? 0 : readTokenCount(record, "cacheWriteInputTokens");
+	const hasCoherentInput = inputTokens !== void 0 && cacheRead !== void 0 && cacheWrite !== void 0 && cacheRead + cacheWrite <= inputTokens;
+	const hasCoherentContext = hasCoherentInput && totalTokens !== void 0 && output !== void 0 && totalTokens === inputTokens + output;
+	const usage = normalizeUsage({
+		input: hasCoherentInput ? inputTokens - cacheRead - cacheWrite : void 0,
+		output,
+		cacheRead,
+		cacheWrite,
+		reasoningTokens,
+		total: totalTokens
+	});
+	if (!usage) return;
+	return {
+		...usage,
+		contextUsage: hasCoherentContext ? {
+			state: "available",
+			promptTokens: inputTokens,
+			totalTokens
+		} : { state: "unavailable" }
+	};
+}
+var CodexUsageProjection = class {
+	constructor() {
+		this.responseIds = /* @__PURE__ */ new Set();
+	}
+	get usage() {
+		const usage = this.responseUsage ?? this.threadUsage;
+		return usage ? {
+			...usage,
+			contextUsage: this.contextUsage
+		} : void 0;
+	}
+	get modelIterations() {
+		return this.responseIds.size;
+	}
+	invalidateContext() {
+		this.contextUsage = { state: "unavailable" };
+	}
+	recordThread(params) {
+		const usage = readCodexThreadTokenUsage(params);
+		this.threadUsage = usage ?? this.threadUsage;
+		if (!this.responseUsage && usage) this.contextUsage = usage.contextUsage;
+		return readCodexThreadContextSnapshot(params);
+	}
+	record(params, reportOutputTokens) {
+		const responseId = readStringField(params, "responseId");
+		if (!responseId || this.responseIds.has(responseId)) return;
+		this.responseIds.add(responseId);
+		const usage = isJsonObject(params.usage) ? normalizeCodexResponseTokenUsage(params.usage) : void 0;
+		this.contextUsage = usage?.contextUsage ?? { state: "unavailable" };
+		this.responseUsage ??= {};
+		for (const field of [
+			"input",
+			"output",
+			"cacheRead",
+			"cacheWrite",
+			"reasoningTokens",
+			"total"
+		]) if (usage?.[field] !== void 0) this.responseUsage[field] = (this.responseUsage[field] ?? 0) + usage[field];
+		const outputTokens = usage?.output;
+		if (outputTokens !== void 0) reportOutputTokens?.(outputTokens);
+	}
+};
+//#endregion
+export { isPendingOpenClawDynamicToolCompletionNotification as a, readCodexNotificationItem as c, updateActiveTurnItemIds as d, isCodexTurnAbortMarkerNotification as i, readNotificationItemId as l, readCodexThreadContextSnapshot as n, isRawFunctionToolOutputCompletionNotification as o, codexExecutionToolName as r, isTerminalTurnStatus as s, CodexUsageProjection as t, readRawResponseToolCallId as u };

package/dist/{harness-C7rRa7bm.js → .setup/harness-a_MsE4-_.mjs}

@@ -1,5 +1,6 @@
-import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
-import { t as codexBuildSymbol } from "./build-state-BCmg9-5p.js";
+import { CODEX_NATIVE_TOOL_REQUIREMENTS } from "../native-tool-policy.js";
+import { m as sessionBindingIdentity } from "./session-binding-record-BGoz8wOK.mjs";
+import { t as codexBuildSymbol } from "./build-state-C7EnDVgr.mjs";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/model-runtime.ts
@@ -73,6 +74,7 @@ function createCodexAppServerAgentHarness(options) {
 		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
 		conversationToolPolicySupport: "exact",
 		conversationToolPolicySafeDenyTools: CODEX_TOOL_POLICY_SAFE_DENY_NAMES,
+		conversationToolPolicyNativeTools: CODEX_NATIVE_TOOL_REQUIREMENTS,
 		deliveryDefaults: { visibleReplies: "message_tool" },
 		authBootstrap: "harness",
 		resolveSessionRuntimeOwnership: (params) => {
@@ -100,10 +102,11 @@ function createCodexAppServerAgentHarness(options) {
 				} } : {}
 			} : void 0;
 		},
-		...sessionCatalogControlFactory && sessionRuntime ? { sessionFork: {
+		...sessionCatalogControlFactory && sessionRuntime ? { sessionForkV2: {
+			executionEnvironment: "host-only",
 			upstreamKinds: ["codex-app-server"],
 			fork: async (params) => {
-				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-BZerMte_.js");
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-BUr4OUbC.mjs");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -116,7 +119,7 @@ function createCodexAppServerAgentHarness(options) {
 		taskHistory: {
 			taskKinds: ["codex-native"],
 			read: async (params) => {
-				const { readCodexNativeSubagentHistory } = await import("./native-subagent-history-DjtPloaU.js");
+				const { readCodexNativeSubagentHistory } = await import("./native-subagent-history-0nYYgo0k.mjs");
 				const assertCurrent = () => {
 					params.assertCurrent();
 					if (disposed) throw new Error("Agent harness is disposed");
@@ -131,26 +134,26 @@ function createCodexAppServerAgentHarness(options) {
 			}
 		},
 		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-CWlKVccJ.js").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-DhLWa_7K.mjs").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-BJ0rXBZ_.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-CLZ8udh-.mjs");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-tCk-mg_x.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-BML0r-ua.mjs");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		loadModelCatalog: async (params) => {
-			const { createCodexAppServerModelCatalog } = await import("./model-catalog-Dq2n8f_p.js");
+			const { createCodexAppServerModelCatalog } = await import("./model-catalog-CfXJf9Ay.mjs");
 			if (disposed) return [];
 			modelCatalog ??= createCodexAppServerModelCatalog(harnessRuntimeId);
 			return await modelCatalog.load(params, resolveAttemptPluginConfig(params.config));
 		},
 		readModelCatalogReadiness: (params) => modelCatalog?.read(params, resolveAttemptPluginConfig(params.config)),
 		loadMcpToolCatalog: async (params) => {
-			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-Bd73bqA8.js");
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-CvnvnGIe.mjs");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -193,21 +196,73 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-CvsAAGa0.js");
-			return runCodexAppServerAttempt(params, {
+			const { runCodexAppServerAttempt } = await import("./run-attempt-BHu11r7h.mjs");
+			const { planCodexCyberEscalation, readCodexCyberAttemptVerdict, recordCodexCyberTargetUnavailable, reserveCodexCyberProbe, resolveCodexCyberFailoverConfig } = await import("./cyber-failover-DYwbmf1o.mjs");
+			const { emitCodexCyberNotice } = await import("./cyber-failover-notice-e9G3J9-e.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: resolveAttemptPluginConfig(params.config),
+				pluginConfig,
 				runtime: sessionRuntime,
-				runtimeModelId: readCodexRuntimeModelId(params.model, params.modelId),
+				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("./isolated-completion-DWVb5U2J.js");
+			const { runCodexIsolatedCompletion } = await import("./isolated-completion-BIZFhTNG.mjs");
 			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runIsolatedCompletion: async (params) => {
@@ -223,11 +278,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-Dn91stmc.js");
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-DiAi6Kx6.mjs");
 			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-BGMJQf4U.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-BJ1wSDcB.mjs");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -237,20 +292,25 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-B_H3AOd7.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-Du5UvtxA.mjs");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		withSessionDeletion: async (params, run) => {
-			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-B2YfbAAT.js");
+			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-BH-S6qkJ.mjs");
 			params.assertCurrent();
 			return withCodexAppServerSessionDeletion(options.bindingStore, params, run);
 		},
+		withSessionContextReset: async (params, run) => {
+			const { withCodexAppServerSessionContextReset } = await import("./session-retirement-BH-S6qkJ.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("./session-binding-CI8UuilT.js").then((n) => n.c), import("./session-retirement-B2YfbAAT.js")]);
+				const [{ reclaimCurrentCodexSessionGeneration }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-Cm0apEbd.mjs").then((n) => n.s), import("./session-retirement-BH-S6qkJ.mjs")]);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
@@ -282,7 +342,7 @@ function createCodexAppServerAgentHarness(options) {
 /** Creates the private native-compaction bridge registered in host-owned capability state. */
 function createCodexAppServerNativeCompaction(options) {
 	return async (params) => {
-		const { maybeCompactCodexAppServerSession } = await import("./compact-B_H3AOd7.js");
+		const { maybeCompactCodexAppServerSession } = await import("./compact-Du5UvtxA.mjs");
 		return maybeCompactCodexAppServerSession(params, {
 			bindingStore: options.bindingStore,
 			pluginConfig: options.resolvePluginConfig?.() ?? options.pluginConfig,

package/dist/{inference-context-Dr_mzvk4.js → .setup/inference-context-D96l9-ew.mjs}

@@ -1,4 +1,4 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
 import { randomUUID } from "node:crypto";
 //#region extensions/codex/src/app-server/inference-context.ts
 const MAX_CONTEXT_BYTES = 262144;