@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/{upstream-prompt-provenance-ClRBije0.js → upstream-prompt-provenance-CFmsKwr9.js}

@@ -1,12 +1,12 @@
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/upstream-prompt-provenance.ts
 const UPSTREAM_USER_TEXT_META_KEY = "upstreamUserText";
 const MIRROR_IDENTITY_META_KEY = "mirrorIdentity";
+const CODEX_META_KEY = "__openclaw";
 function attachCodexMirrorIdentity(message, identity) {
-	const record = message;
-	const existing = record["__openclaw"];
-	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+	const baseMeta = asOptionalRecord(CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0) ?? {};
 	return {
-		...record,
+		...message,
 		__openclaw: {
 			...baseMeta,
 			[MIRROR_IDENTITY_META_KEY]: identity
@@ -14,17 +14,15 @@ function attachCodexMirrorIdentity(message, identity) {
 	};
 }
 function readMirrorIdentity(message) {
-	const meta = message["__openclaw"];
-	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
-	const id = meta[MIRROR_IDENTITY_META_KEY];
+	const record = asOptionalRecord(CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0);
+	if (!record) return;
+	const id = record[MIRROR_IDENTITY_META_KEY];
 	return typeof id === "string" && id ? id : void 0;
 }
 function attachUpstreamUserText(message, text) {
-	const record = message;
-	const existing = record["__openclaw"];
-	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+	const baseMeta = asOptionalRecord(CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0) ?? {};
 	return {
-		...record,
+		...message,
 		__openclaw: {
 			...baseMeta,
 			[UPSTREAM_USER_TEXT_META_KEY]: text
@@ -32,9 +30,9 @@ function attachUpstreamUserText(message, text) {
 	};
 }
 function readUpstreamUserText(message) {
-	const meta = message?.["__openclaw"];
-	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
-	const text = meta[UPSTREAM_USER_TEXT_META_KEY];
+	const record = asOptionalRecord(message && CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0);
+	if (!record) return;
+	const text = record[UPSTREAM_USER_TEXT_META_KEY];
 	return typeof text === "string" && text ? text : void 0;
 }
 //#endregion

package/dist/{upstream-session-fork-CE-_LdnP.js → upstream-session-fork-BACGlOFa.js}

@@ -1,7 +1,8 @@
-import { d as sessionBindingIdentity } from "./session-binding-DPxIvMgE.js";
-import { r as assertCodexThreadForkResponse } from "./protocol-validators-B4F7L8Rf.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
-import { i as createImportedCodexSession, n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-CrIFX06J.js";
+import { d as sessionBindingIdentity } from "./session-binding-q2WSTVmC.js";
+import { a as assertCodexThreadForkResponse } from "./protocol-validators-Bg5rpNxk.js";
+import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
+import { c as fingerprintCodexMirrorSourceMessage, l as readCodexMirrorSourceFingerprint, p as projectCodexUserItemText } from "./transcript-mirror-CkEQIna-.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-Bcy33kam.js";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readVisibleSessionTranscriptMessageEntries } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { deleteSessionUpstreamLink, upsertSessionUpstreamLink } from "openclaw/plugin-sdk/session-catalog";
@@ -17,31 +18,6 @@ function failure(code, message) {
 function asInputs(item) {
 	return Array.isArray(item.content) ? item.content : [];
 }
-function userMessageDisplay(item) {
-	let text = "";
-	let hasTextElement = false;
-	let hasImage = false;
-	let hasUnverifiableInput = false;
-	for (const input of asInputs(item)) if (input.type === "text") {
-		if (typeof input.text === "string") text += input.text;
-		hasTextElement ||= Array.isArray(input.textElements) && input.textElements.length > 0;
-	} else {
-		hasUnverifiableInput = true;
-		hasImage ||= input.type === "image" || input.type === "localImage";
-	}
-	return {
-		text,
-		visible: Boolean(text.trim()) || hasTextElement || hasImage,
-		hasUnverifiableInput
-	};
-}
-function isHiddenNestedReviewTurn(previous, turn) {
-	if (previous?.status !== "completed" || turn.status !== "interrupted" || turn.completedAt != null || !previous.items.some((item) => item.type === "enteredReviewMode") || !previous.items.some((item) => item.type === "exitedReviewMode")) return false;
-	const userMessages = turn.items.filter((item) => item.type === "userMessage");
-	const [firstUserMessage, secondUserMessage] = userMessages;
-	if (!firstUserMessage || !secondUserMessage || userMessages.length !== 2) return false;
-	return JSON.stringify(asInputs(firstUserMessage)) === JSON.stringify(asInputs(secondUserMessage));
-}
 function localMessageText(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return;
@@ -52,37 +28,35 @@ function localMessageText(content) {
 		if (typed.type !== "text" || typeof typed.text !== "string") return;
 		texts.push(typed.text);
 	}
-	return texts.join("");
+	return texts.join("\n");
 }
 function resolveCodexUpstreamForkBoundaryFromTurns(params) {
-	let visibleUserMessagesSeen = 0;
-	let reviewMode = false;
+	let localIndex = 0;
+	let matchedPrefix = false;
 	for (const [turnIndex, turn] of params.turns.entries()) {
-		const hiddenNestedReviewTurn = isHiddenNestedReviewTurn(params.turns[turnIndex - 1], turn);
 		let userMessagesInTurn = 0;
 		for (const item of turn.items) {
-			if (item.type === "enteredReviewMode") {
-				reviewMode = true;
-				continue;
-			}
-			if (item.type === "exitedReviewMode") {
-				reviewMode = false;
-				continue;
-			}
 			if (item.type !== "userMessage") continue;
 			const isSteer = userMessagesInTurn > 0;
 			userMessagesInTurn += 1;
-			if (reviewMode || hiddenNestedReviewTurn) continue;
-			const display = userMessageDisplay(item);
-			if (display.hasUnverifiableInput) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
-			if (!display.visible) continue;
-			const ordinal = visibleUserMessagesSeen;
-			if (ordinal > params.userMessageOrdinal) break;
-			const localText = params.localPrefixTexts[ordinal];
-			if (localText === void 0) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
-			if (display.text !== localText) return failure("drift-mismatch", "The local conversation no longer matches the Codex thread. Refresh the session and try again.");
-			if (ordinal !== params.userMessageOrdinal) {
-				visibleUserMessagesSeen += 1;
+			if (asInputs(item).some((input) => input.type !== "text")) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
+			const text = projectCodexUserItemText(item);
+			if (!text) continue;
+			const local = params.localPrefix[localIndex];
+			const identity = local && readMirrorIdentity(local.message);
+			const matchesIdentity = identity === `${turn.id}:${item.id}` || !isSteer && identity === `${turn.id}:prompt`;
+			if (!matchedPrefix && !matchesIdentity) continue;
+			matchedPrefix = true;
+			const localText = localMessageText(local && "content" in local.message ? local.message.content : void 0);
+			const upstreamText = local && readUpstreamUserText(local.message);
+			const upstreamPromptVerified = !upstreamText || local?.message.role === "user" && readCodexMirrorSourceFingerprint(local.message) === fingerprintCodexMirrorSourceMessage(local.message);
+			const expectedText = upstreamText ? projectCodexUserItemText({ content: [{
+				type: "text",
+				text: upstreamText
+			}] }) : localText;
+			if (!matchesIdentity || !upstreamPromptVerified || localText === void 0 || text !== expectedText) return failure("drift-mismatch", "The local conversation no longer matches the Codex thread. Refresh the session and try again.");
+			if (localIndex < params.localPrefix.length - 1) {
+				localIndex += 1;
 				continue;
 			}
 			if (isSteer) return failure("steer-message", "This message steered an existing Codex turn and cannot be forked independently. Fork from the turn's first message instead.");
@@ -104,7 +78,7 @@ function resolveCodexUpstreamForkBoundaryFromTurns(params) {
 			};
 		}
 	}
-	return failure("drift-mismatch", "The message could not be matched to the Codex thread. Refresh the session and try again.");
+	return failure("drift-mismatch", "The local history has no verified boundary in this Codex thread. Use native Codex to fork this conversation.");
 }
 async function listCodexUpstreamTurns(control, threadId) {
 	const turns = [];
@@ -128,24 +102,23 @@ async function listCodexUpstreamTurns(control, threadId) {
 }
 async function resolveCodexUpstreamForkBoundary(params) {
 	try {
-		if ((await params.control.readThread(params.threadId, false)).historyMode === "paginated") return failure("upstream-unavailable", "This Codex thread uses paginated history, which cannot be forked from OpenClaw yet.");
 		const visibleUserEntries = (await readVisibleSessionTranscriptMessageEntries({
 			agentId: params.agentId,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
 			storePath: params.storePath
 		})).filter((entry) => entry.role === "user");
-		const userMessageOrdinal = visibleUserEntries.findIndex((entry) => entry.entryId === params.entryId);
-		if (userMessageOrdinal < 0) return failure("drift-mismatch", "The local message could not be mapped to the Codex thread. Refresh the session and try again.");
-		const localPrefixTexts = visibleUserEntries.slice(0, userMessageOrdinal + 1).map((entry) => localMessageText("content" in entry.message ? entry.message.content : void 0));
+		const targetIndex = visibleUserEntries.findIndex((entry) => entry.entryId === params.entryId);
+		if (targetIndex < 0) return failure("drift-mismatch", "The local message could not be mapped to the Codex thread. Refresh the session and try again.");
+		const localPrefix = visibleUserEntries.slice(0, targetIndex + 1);
 		const resolved = resolveCodexUpstreamForkBoundaryFromTurns({
 			turns: await listCodexUpstreamTurns(params.control, params.threadId),
-			userMessageOrdinal,
-			localPrefixTexts
+			localPrefix
 		});
+		const target = localPrefix.at(-1)?.message;
 		return resolved.ok ? {
 			...resolved,
-			editorText: localPrefixTexts[userMessageOrdinal]
+			editorText: localMessageText(target && "content" in target ? target.content : void 0)
 		} : resolved;
 	} catch {
 		return failure("upstream-unavailable", "The Codex thread could not be read. Check that Codex is available, then try again.");
@@ -166,34 +139,43 @@ function readConnectionFingerprint(ref) {
 	if (!isRecord(ref)) return;
 	return typeof ref.connectionFingerprint === "string" && ref.connectionFingerprint.trim() ? ref.connectionFingerprint : void 0;
 }
-function normalizeTurnId(value) {
-	return normalizeOptionalString(value);
-}
 async function forkCodexUpstreamSession(params, options) {
 	try {
-		return await options.control.withPinnedConnection(async (control) => {
-			const incognito = isIncognitoSessionKey(params.targetKey);
-			const clientId = control.clientId?.trim();
-			if (incognito && !clientId) throw new Error("Incognito Codex forks require the live pinned app-server client");
+		const sourceFingerprint = params.upstream.kind === "codex-app-server" ? readConnectionFingerprint(params.upstream.ref) : void 0;
+		const requestControl = sourceFingerprint ? options.controlFactory.forUpstream(params.source.agentId, sourceFingerprint) : void 0;
+		if (!sourceFingerprint || !requestControl) return {
+			status: "failed",
+			code: "upstream-unavailable",
+			message: "This Codex thread is not available on the current connection. Reconnect to its host and try again."
+		};
+		return await requestControl.withPinnedConnection(async (control) => {
+			const sourceBinding = await options.bindingStore.read(sessionBindingIdentity({
+				...params.source,
+				config: options.resolveConfig?.()
+			}));
+			const supervised = sourceBinding?.connectionScope === "supervision";
+			const sourceThreadId = params.upstream.threadId;
 			let linked = false;
-			let bindingIdentity;
+			let createdBinding;
 			const compensateFork = async (forkedThreadId) => {
-				if (bindingIdentity) await options.bindingStore.mutate(bindingIdentity, {
-					kind: "clear",
-					threadId: forkedThreadId
-				}).catch(() => void 0);
+				if (createdBinding) {
+					if (!await options.bindingStore.mutate(createdBinding.identity, {
+						kind: "clear",
+						threadId: forkedThreadId,
+						expectedPendingSupervisionBranch: createdBinding.pending
+					}).catch(() => false)) return;
+				}
 				if (linked) deleteSessionUpstreamLink(params.targetKey, params.source.agentId);
 				await control.archiveThread(forkedThreadId).catch(() => void 0);
 			};
-			const sourceFingerprint = readConnectionFingerprint(params.upstream.ref);
-			if (params.upstream.kind !== "codex-app-server" || !sourceFingerprint || sourceFingerprint !== control.connectionFingerprint) return {
+			if (sourceFingerprint !== control.connectionFingerprint || supervised && (sourceBinding.supervisionSourceThreadId !== params.upstream.threadId || (sourceBinding.pendingSupervisionBranch?.connectionFingerprint ?? sourceBinding.appServerRuntimeFingerprint) !== sourceFingerprint)) return {
 				status: "failed",
 				code: "upstream-unavailable",
 				message: "This Codex thread is not available on the current connection. Reconnect to its host and try again."
 			};
 			const resolved = await resolveCodexUpstreamForkBoundary({
 				...params.source,
-				threadId: params.upstream.threadId,
+				threadId: sourceThreadId,
 				control
 			});
 			if (!resolved.ok) return {
@@ -201,7 +183,7 @@ async function forkCodexUpstreamSession(params, options) {
 				code: resolved.code,
 				message: resolved.message
 			};
-			const liveTurns = await listCodexUpstreamTurns(control, params.upstream.threadId);
+			const liveTurns = await listCodexUpstreamTurns(control, sourceThreadId);
 			const precheck = precheckCodexUpstreamForkBoundary({
 				boundary: resolved.boundary,
 				turns: liveTurns
@@ -212,27 +194,27 @@ async function forkCodexUpstreamSession(params, options) {
 				message: precheck.message
 			};
 			const rawResponse = await control.forkThread({
-				threadId: params.upstream.threadId,
+				threadId: sourceThreadId,
 				beforeTurnId: resolved.boundary.beforeTurnId,
-				...incognito ? { ephemeral: true } : {},
-				excludeTurns: !incognito
+				...params.sandbox === "required" ? { sandbox: "workspace-write" } : {},
+				excludeTurns: true
 			});
 			let response;
 			try {
 				response = assertCodexThreadForkResponse(rawResponse);
 			} catch (error) {
 				const orphanThreadId = isRecord(rawResponse.thread) && typeof rawResponse.thread.id === "string" ? rawResponse.thread.id.trim() : "";
-				if (orphanThreadId && orphanThreadId !== params.upstream.threadId) await control.archiveThread(orphanThreadId).catch(() => void 0);
+				if (orphanThreadId && orphanThreadId !== sourceThreadId && orphanThreadId !== sourceBinding?.threadId) await control.archiveThread(orphanThreadId).catch(() => void 0);
 				throw error;
 			}
 			const threadId = response.thread.id.trim();
 			if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
-			if (threadId === params.upstream.threadId) throw new Error("Codex thread/fork response reused the source thread id");
+			if (threadId === sourceThreadId || threadId === sourceBinding?.threadId) throw new Error("Codex thread/fork response reused the source thread id");
 			const forkedThreadId = threadId;
 			try {
-				const connectionFingerprint = control.connectionFingerprint;
+				const connectionFingerprint = normalizeOptionalString(control.connectionFingerprint);
 				if (!connectionFingerprint) throw new Error("Codex fork connection did not include a fingerprint");
-				const forkedTurns = incognito ? response.thread.turns ?? [] : await listCodexUpstreamTurns(control, threadId);
+				const forkedTurns = await listCodexUpstreamTurns(control, threadId);
 				const expectedLastTurnId = resolved.boundary.retainedMarker.turnId;
 				if ((forkedTurns.at(-1)?.id ?? null) !== expectedLastTurnId) {
 					await compensateFork(forkedThreadId);
@@ -246,8 +228,8 @@ async function forkCodexUpstreamSession(params, options) {
 					...response.thread,
 					turns: forkedTurns
 				};
-				const throughTurnId = codexLastTerminalTurnId(forkedThread, normalizeTurnId) ?? null;
-				const marker = codexUpstreamBaseline(forkedThread, normalizeTurnId);
+				const throughTurnId = codexLastTerminalTurnId(forkedThread, normalizeOptionalString) ?? null;
+				const marker = codexUpstreamBaseline(forkedThread, normalizeOptionalString);
 				const config = options.resolveConfig?.() ?? {};
 				return {
 					status: "created",
@@ -263,7 +245,7 @@ async function forkCodexUpstreamSession(params, options) {
 							modelSelectionLocked: true
 						},
 						afterImport: async (entry) => {
-							bindingIdentity = sessionBindingIdentity({
+							const bindingIdentity = sessionBindingIdentity({
 								agentId: entry.agentId,
 								sessionId: entry.sessionId,
 								sessionKey: entry.key,
@@ -283,17 +265,33 @@ async function forkCodexUpstreamSession(params, options) {
 								marker
 							});
 							if (!linked) throw new Error("Codex fork link could not be persisted");
+							createdBinding = {
+								identity: bindingIdentity,
+								pending: {
+									sourceThreadId: threadId,
+									connectionFingerprint,
+									...throughTurnId ? { lastTurnId: throughTurnId } : {}
+								}
+							};
 							if (!await options.bindingStore.mutate(bindingIdentity, {
 								kind: "set",
+								if: { kind: "absent" },
 								binding: {
 									threadId,
-									...incognito && clientId ? { clientId } : {},
+									connectionScope: "supervision",
+									supervisionSourceThreadId: threadId,
+									preserveNativeModel: true,
+									conversationSourceTransferComplete: true,
+									pendingSupervisionBranch: createdBinding.pending,
 									cwd: forkedThread.cwd ?? "",
 									model: response.model,
 									modelProvider: response.modelProvider ?? void 0,
 									historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
 								}
-							})) throw new Error("Codex session binding changed before the fork could be attached");
+							})) {
+								createdBinding = void 0;
+								throw new Error("Codex session binding changed before the fork could be attached");
+							}
 							return { pluginExtensions: entry.entry.pluginExtensions };
 						}
 					})).key,

package/dist/{usage-CHlV0e-o.js → usage-C2l8Mils.js}

@@ -1,6 +1,6 @@
-import { g as resolveCodexAppServerRuntimeOptions } from "./session-binding-DPxIvMgE.js";
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-DZXmOL8-.js";
-import { t as readCodexAppServerUsage } from "./request-BRl5_UfX.js";
+import { i as resolveCodexAppServerRuntimeOptions } from "./config-Cxw3Cl3k.js";
+import { n as readCodexAppServerUsage } from "./request-CCm4LaED.js";
+import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-hFtzt2Up.js";
 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/{web-search-provider.runtime-DRw2Vl42.js → web-search-provider.runtime-B2XgRdFv.js}

@@ -1,6 +1,6 @@
-import { ct as isJsonObject } from "./shared-client-kIBbGjk4.js";
-import { d as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-Bu1BTDXr.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-qgZmzy_4.js";
+import { Ht as isJsonObject } from "./shared-client-kNkljY-R.js";
+import { b as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-Ss-uwnC4.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-rq5tiSXk.js";
 import { normalizeOptionalString } 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

package/openclaw.plugin.json

@@ -1,9 +1,27 @@
 {
   "id": "codex",
+  "backupResources": [
+    {
+      "disposition": "regenerable",
+      "scope": "agent",
+      "relativePath": "codex-home/tmp/arg0"
+    },
+    {
+      "disposition": "regenerable",
+      "scope": "agent",
+      "relativePath": "codex-home/.tmp/plugins"
+    },
+    {
+      "disposition": "regenerable",
+      "scope": "agent",
+      "relativePath": "codex-home/.tmp/bundled-marketplaces"
+    }
+  ],
   "doctorContract": {
     "configRepair": true,
     "stateMigrations": true
   },
+  "doctorHealthChecks": true,
   "sessionRouteStateOwners": [
     {
       "id": "codex",
@@ -16,6 +34,13 @@
   ],
   "name": "Codex",
   "description": "Codex app-server harness and native session catalog.",
+  "cliCommands": [
+    {
+      "name": "codex",
+      "description": "Inspect and branch from Codex sessions through the Gateway",
+      "hasSubcommands": true
+    }
+  ],
   "contracts": {
     "mediaUnderstandingProviders": ["codex"],
     "migrationProviders": ["codex"],
@@ -45,6 +70,7 @@
     "onConfigPaths": [
       "plugins.entries.codex.config.appServer.transport",
       "plugins.entries.codex.config.sessionCatalog.enabled",
+      "plugins.entries.codex.config.sessionCatalog.homes",
       "plugins.entries.codex.config.supervision.enabled"
     ]
   },
@@ -73,7 +99,24 @@
         "type": "object",
         "additionalProperties": false,
         "properties": {
-          "enabled": { "type": "boolean", "default": true }
+          "enabled": { "type": "boolean", "default": true },
+          "homes": {
+            "type": "array",
+            "items": {
+              "anyOf": [
+                { "type": "string", "minLength": 1, "pattern": "\\S" },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": ["path"],
+                  "properties": {
+                    "path": { "type": "string", "minLength": 1, "pattern": "\\S" },
+                    "label": { "type": "string", "minLength": 1, "pattern": "\\S" }
+                  }
+                }
+              ]
+            }
+          }
         }
       },
       "discovery": {
@@ -392,6 +435,11 @@
       "label": "Discover Codex Sessions",
       "help": "List native Codex sessions in the sidebar from this Gateway and eligible paired nodes."
     },
+    "sessionCatalog.homes": {
+      "label": "Additional Codex Homes",
+      "help": "Existing local Codex home directories to include in native session discovery. String paths use the canonical directory basename as their label; object entries can override it with label. Paths are canonicalized and deduplicated. Requires appServer.transport=stdio and a Gateway restart.",
+      "advanced": true
+    },
     "codexDynamicToolsLoading": {
       "label": "Dynamic Tools Loading",
       "help": "Use searchable to defer OpenClaw dynamic tools behind Codex tool search, or direct to expose them in the initial context.",
@@ -467,7 +515,7 @@
     },
     "computerUse.autoRepair": {
       "label": "Auto Repair",
-      "help": "When true, failed Computer Use live tests repair stale scoped Computer Use MCP children before retrying once.",
+      "help": "When true, failed Computer Use live tests reload the Codex-owned MCP runtime before retrying once.",
       "advanced": true
     },
     "computerUse.marketplaceSource": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.8.1-beta.2",
+  "version": "2026.8.1",
   "description": "OpenClaw Codex app-server harness and native session supervision plugin.",
   "repository": {
     "type": "git",
@@ -8,10 +8,11 @@
   },
   "type": "module",
   "dependencies": {
-    "@openai/codex": "0.147.0",
-    "smol-toml": "1.7.1",
-    "typebox": "1.3.6",
-    "ws": "8.21.1",
+    "@openai/codex": "0.151.0",
+    "semver": "7.8.5",
+    "smol-toml": "1.8.0",
+    "typebox": "1.3.16",
+    "ws": "8.21.3",
     "zod": "4.4.3"
   },
   "devDependencies": {
@@ -35,10 +36,10 @@
       ]
     },
     "compat": {
-      "pluginApi": ">=2026.8.1-beta.2"
+      "pluginApi": ">=2026.8.1"
     },
     "build": {
-      "openclawVersion": "2026.8.1-beta.2"
+      "openclawVersion": "2026.8.1"
     },
     "release": {
       "publishToClawHub": true,
@@ -58,7 +59,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.8.1-beta.2"
+    "openclaw": ">=2026.8.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/app-server-policy-zcBDc1JU.js

@@ -1,49 +0,0 @@
-import { k as canUseCodexModelBackedApprovalsReviewerForModel } from "./session-binding-DPxIvMgE.js";
-//#region extensions/codex/src/app-server/app-server-policy.ts
-/**
-* Policy promotion for Codex app-server runs that can safely use OpenClaw tool
-* approvals.
-*/
-/**
-* Promotes implicit `never` approval policy to `untrusted` only when runtime
-* requirements allow OpenClaw to handle tool approvals.
-*/
-function resolveCodexAppServerForOpenClawToolPolicy(params) {
-	if (!params.shouldPromote || !params.canUseUntrustedApprovalPolicy || params.appServer.approvalPolicy !== "never") return params.appServer;
-	const explicitMode = params.execPolicy?.mode === "full" || params.pluginConfig.appServer?.mode !== void 0 || isCodexAppServerPolicyMode(params.env.OPENCLAW_CODEX_APP_SERVER_MODE);
-	const explicitApprovalPolicy = params.pluginConfig.appServer?.approvalPolicy !== void 0 || isConfiguredCodexAppServerApprovalPolicy(params.env.OPENCLAW_CODEX_APP_SERVER_APPROVAL_POLICY) || params.appServer.approvalPolicySource === "requirements";
-	if (explicitMode || explicitApprovalPolicy) return params.appServer;
-	return {
-		...params.appServer,
-		approvalPolicy: "untrusted"
-	};
-}
-function resolveCodexAppServerForModelProvider(params) {
-	const explicitProvider = normalizeModelBackedReviewerProvider(params.provider);
-	if (!isCodexModelBackedApprovalsReviewer(params.appServer.approvalsReviewer) || canUseCodexModelBackedApprovalsReviewerForModel({
-		modelProvider: explicitProvider,
-		model: params.model,
-		config: params.config,
-		env: params.env,
-		agentDir: params.agentDir,
-		codexConfigToml: params.codexConfigToml
-	})) return params.appServer;
-	return {
-		...params.appServer,
-		approvalsReviewer: "user"
-	};
-}
-function isCodexAppServerPolicyMode(value) {
-	return value === "guardian" || value === "yolo";
-}
-function isConfiguredCodexAppServerApprovalPolicy(value) {
-	return value === "never" || value === "on-request" || value === "on-failure" || value === "untrusted";
-}
-function isCodexModelBackedApprovalsReviewer(value) {
-	return value === "auto_review" || value === "guardian_subagent";
-}
-function normalizeModelBackedReviewerProvider(provider) {
-	return provider?.trim().toLowerCase() || void 0;
-}
-//#endregion
-export { resolveCodexAppServerForOpenClawToolPolicy as n, resolveCodexAppServerForModelProvider as t };

package/dist/incognito-session-ET_ufDH-.js

@@ -1,2 +0,0 @@
-import { isIncognitoSessionKey } from "openclaw/plugin-sdk/routing";
-export { isIncognitoSessionKey as t };