@openclaw/codex 2026.8.1-beta.3 → 2026.8.1

package/dist/{runtime-artifact-BvyT1uyd.js → runtime-artifact-DeBvleJw.js}

@@ -1,4 +1,4 @@
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-DhoGy33Z.js";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-C7-s9TLG.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createHash } from "node:crypto";

package/dist/{session-binding-BTrLf9Qm.js → session-binding-q2WSTVmC.js}

@@ -1,10 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { N as normalizeCodexServiceTier, y as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-CpNeo5AE.js";
+import { A as normalizeCodexServiceTier, N as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-Cxw3Cl3k.js";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import { ensureAuthProfileStore, resolveDefaultAgentDir, resolveProviderIdForAuth, resolveSessionAgentIds as resolveSessionAgentIds$1 } from "openclaw/plugin-sdk/agent-runtime";
+import { isDeepStrictEqual } from "node:util";
+import { ensureAuthProfileStore, resolveDefaultAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { z } from "zod";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
@@ -42,7 +44,7 @@ const BINDING_LEASE_RENEW_INTERVAL_MS = Math.floor(BINDING_LEASE_STALE_MS / 3);
 const PHYSICAL_SESSION_RETIRE_TTL_MS = BINDING_LEASE_WAIT_MS;
 /** Resolves the same agent scope OpenClaw uses for transcript/session ownership. */
 function sessionBindingIdentity(params) {
-	const { sessionAgentId } = resolveSessionAgentIds$1(params);
+	const { sessionAgentId } = resolveSessionAgentIdsStrict(params);
 	const sessionKey = params.sessionKey?.trim();
 	return {
 		kind: "session",
@@ -147,6 +149,7 @@ const threadBindingSchema = z.object({
 	model: optionalStringSchema,
 	preserveNativeModel: z.literal(true).optional().catch(void 0),
 	pendingSupervisionBranch: pendingSupervisionBranchSchema.optional(),
+	pendingResumeConfiguration: z.literal(true).optional(),
 	modelProvider: z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0),
 	approvalPolicy: z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum([
 		"never",
@@ -318,11 +321,12 @@ function scopeCodexRunBindingStore(params) {
 		...params.bindingStore,
 		read: (identity) => params.bindingStore.read(mapIdentity(identity)),
 		hasOtherThreadOwner: (threadId, identity) => params.bindingStore.hasOtherThreadOwner(threadId, identity ? mapIdentity(identity) : void 0),
-		mutate: (identity, mutation) => params.bindingStore.mutate(mapIdentity(identity), mutation),
+		mutate: (identity, mutation, assertCurrent) => params.bindingStore.mutate(mapIdentity(identity), mutation, assertCurrent),
 		prepareSessionGenerationReclaim: (identity) => params.bindingStore.prepareSessionGenerationReclaim(mapSessionIdentity(identity)),
 		adoptSessionGeneration: (identity, expectedPreviousSessionId) => params.bindingStore.adoptSessionGeneration(mapSessionIdentity(identity), expectedPreviousSessionId),
 		resetSessionGeneration: (identity) => params.bindingStore.resetSessionGeneration(mapSessionIdentity(identity)),
 		retireSessionGeneration: (identity) => params.bindingStore.retireSessionGeneration(mapSessionIdentity(identity)),
+		withSessionDeletion: (identity, assertCurrent, run) => params.bindingStore.withSessionDeletion(mapSessionIdentity(identity), assertCurrent, run),
 		withThreadArchiveFence: (run) => params.bindingStore.withThreadArchiveFence(run),
 		withLease: (identity, run) => params.bindingStore.withLease(mapIdentity(identity), run)
 	};
@@ -382,9 +386,10 @@ function createCodexAppServerBindingStore(state) {
 		}
 	};
 	const renewLease = (key, owner) => {
-		if (owner.failure) return;
+		if (owner.failure || owner.phase !== "held") return;
 		try {
 			let renewed = false;
+			owner.assertCurrent?.();
 			const stored = update(key, (raw) => {
 				const current = readStoredCodexAppServerBinding(raw);
 				if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
@@ -405,15 +410,18 @@ function createCodexAppServerBindingStore(state) {
 			owner.failure = bindingLeaseLostError(key, error);
 		}
 	};
-	const transactKey = async (key, apply, ttlMs) => {
+	const transactKey = async (key, apply, ttlMs, assertCurrent) => {
 		const deadline = Date.now() + BINDING_LEASE_WAIT_MS;
 		while (true) {
 			let busy = false;
 			let leaseLost = false;
 			let result;
 			const ownedLease = leaseContext.getStore()?.get(key);
+			if (ownedLease && ownedLease.phase !== "held") throw bindingLeaseLostError(key);
 			if (ownedLease?.failure) throw ownedLease.failure;
 			const ownedToken = ownedLease?.token;
+			assertCurrent?.();
+			ownedLease?.assertCurrent?.();
 			update(key, (raw) => {
 				const current = readStoredCodexAppServerBinding(raw);
 				if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
@@ -441,6 +449,115 @@ function createCodexAppServerBindingStore(state) {
 			await sleep(BINDING_LEASE_RETRY_INTERVAL_MS);
 		}
 	};
+	const withBindingLease = async (identity, run, options = {}) => {
+		options.assertCurrent?.();
+		const key = bindingStoreKey(identity);
+		const owned = leaseContext.getStore();
+		const existingOwner = owned?.get(key);
+		if (existingOwner) {
+			if (existingOwner.phase !== "held") throw bindingLeaseLostError(key);
+			const failureBeforeRun = existingOwner.failure;
+			if (failureBeforeRun) throw failureBeforeRun;
+			const result = await run();
+			options.assertCurrent?.();
+			const failureAfterRun = existingOwner.failure;
+			if (failureAfterRun) throw failureAfterRun;
+			return result;
+		}
+		const token = randomUUID();
+		const acquired = await transactKey(key, (current) => {
+			if (current?.state === "cleared" && current.retired === true && ownsStoredSessionGeneration(identity, current) && !options.allowRetired) return { result: false };
+			const lease = {
+				token,
+				expiresAt: Date.now() + BINDING_LEASE_STALE_MS
+			};
+			if (current?.state === "active") return {
+				result: true,
+				next: {
+					...current,
+					...preservedSessionGeneration(identity, current),
+					lease
+				}
+			};
+			if (current?.state === "cleared" && current.retired === true) return {
+				result: true,
+				next: {
+					...current,
+					lease
+				}
+			};
+			return {
+				result: true,
+				next: {
+					version: 1,
+					state: "cleared",
+					...preservedSessionGeneration(identity, current),
+					lease
+				}
+			};
+		}, void 0, options.assertCurrent);
+		options.assertCurrent?.();
+		if (!acquired) throw new Error(`Codex binding generation was retired: ${key}`);
+		const owner = {
+			token,
+			phase: "held",
+			assertCurrent: options.assertCurrent
+		};
+		const nested = new Map(owned);
+		nested.set(key, owner);
+		const heartbeat = setInterval(() => renewLease(key, owner), BINDING_LEASE_RENEW_INTERVAL_MS);
+		heartbeat.unref();
+		try {
+			const result = await leaseContext.run(nested, run);
+			options.assertCurrent?.();
+			if (owner.failure) throw owner.failure;
+			return result;
+		} finally {
+			clearInterval(heartbeat);
+			owner.phase = "closed";
+			options.assertCurrent?.();
+			try {
+				const current = readStoredCodexAppServerBinding(state.lookup(key));
+				if (current?.lease?.token === token) {
+					const ttlMs = current.state === "active" || current.retired === true && !key.startsWith("session:") ? void 0 : current.retired === true ? PHYSICAL_SESSION_RETIRE_TTL_MS : 1;
+					options.assertCurrent?.();
+					update(key, (raw) => {
+						const stored = readStoredCodexAppServerBinding(raw);
+						if (stored?.lease?.token !== token) return;
+						const { lease: _lease, ...released } = stored;
+						return released;
+					}, ttlMs === void 0 ? void 0 : { ttlMs });
+				}
+			} catch (error) {
+				options.assertCurrent?.();
+				embeddedAgentLog.warn("failed to release codex app-server binding lease", {
+					key,
+					error
+				});
+			}
+		}
+	};
+	const transitionSessionGeneration = async (identity, mode) => {
+		return await runBindingMutation(async () => {
+			const key = bindingStoreKey(identity);
+			const ttlMs = mode === "reset" ? leaseContext.getStore()?.has(key) ? void 0 : 1 : identity.sessionKey?.trim() ? void 0 : PHYSICAL_SESSION_RETIRE_TTL_MS;
+			return await transactKey(key, (current, leaseToken) => {
+				if (!current) return { result: "absent" };
+				if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
+				if (current.state === "cleared" && current.retired === true) return { result: mode === "retire" ? "applied" : "conflict" };
+				return {
+					result: "applied",
+					next: {
+						version: 1,
+						state: "cleared",
+						...mode === "retire" ? { retired: true } : {},
+						...storedSessionGeneration(identity, current),
+						...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
+					}
+				};
+			}, ttlMs);
+		});
+	};
 	return {
 		async read(identity) {
 			const key = bindingStoreKey(identity);
@@ -485,7 +602,7 @@ function createCodexAppServerBindingStore(state) {
 				expectedPreviousSessionId: currentSessionId
 			};
 		},
-		async mutate(identity, mutation) {
+		async mutate(identity, mutation, assertCurrent) {
 			return await runBindingMutation(async () => {
 				const key = bindingStoreKey(identity);
 				const retainLegacyClear = mutation.kind === "clear" && key.startsWith("conversation:legacy-");
@@ -523,9 +640,9 @@ function createCodexAppServerBindingStore(state) {
 					const active = ownsGeneration ? storedActive : void 0;
 					const retiredGeneration = current?.state === "cleared" && current.retired === true && ownsGeneration;
 					const preservesSupervisionOwner = mutation.kind === "set" && active?.binding.connectionScope === "supervision" && isSameSupervisionOwner(active.binding, mutation.binding);
-					const clearsPendingSupervisionOwner = mutation.kind === "clear" && active?.binding.connectionScope === "supervision" && matchesPendingSupervisionClear(active.binding, mutation.threadId, mutation.expectedPendingSupervisionBranch);
+					const clearsPendingSupervisionOwner = mutation.kind === "clear" && matchesPendingSupervisionClear(active?.binding, mutation.threadId, mutation.expectedPendingSupervisionBranch);
 					const replacesExpectedOrdinaryOwner = mutation.kind === "replace-thread" && active?.binding.threadId === mutation.expectedThreadId && active.binding.connectionScope !== "supervision" && mutation.binding.connectionScope !== "supervision" && mutation.binding.threadId !== mutation.expectedThreadId;
-					if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration || active?.binding.connectionScope === "supervision" && !preservesSupervisionOwner) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || mutation.kind === "replace-thread" && !replacesExpectedOrdinaryOwner || (mutation.kind === "patch-pending-supervision-branch" || mutation.kind === "commit-pending-supervision-branch") && !matchesPendingSupervisionBranch(active?.binding, mutation.expected) || mutation.kind === "clear" && (mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || !ownsGeneration || active?.binding.connectionScope === "supervision" && !clearsPendingSupervisionOwner)) return { result: false };
+					if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration || active?.binding.connectionScope === "supervision" && !preservesSupervisionOwner) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || mutation.kind === "replace-thread" && !replacesExpectedOrdinaryOwner || (mutation.kind === "patch-pending-supervision-branch" || mutation.kind === "commit-pending-supervision-branch") && !matchesPendingSupervisionBranch(active?.binding, mutation.expected) || mutation.kind === "clear" && (!ownsGeneration || (mutation.expectedPendingSupervisionBranch ? !clearsPendingSupervisionOwner : mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || active?.binding.connectionScope === "supervision"))) return { result: false };
 					if (mutation.kind === "clear" && retiredGeneration) return { result: true };
 					if (mutation.kind === "clear") return {
 						result: true,
@@ -563,7 +680,7 @@ function createCodexAppServerBindingStore(state) {
 							...ownedLease
 						}
 					};
-				}, mutation.kind === "clear" && !retainLegacyClear && !leaseContext.getStore()?.has(key) ? 1 : void 0);
+				}, mutation.kind === "clear" && !retainLegacyClear && !leaseContext.getStore()?.has(key) ? 1 : void 0, assertCurrent);
 			});
 		},
 		async adoptSessionGeneration(identity, expectedPreviousSessionId) {
@@ -586,45 +703,8 @@ function createCodexAppServerBindingStore(state) {
 				});
 			});
 		},
-		async resetSessionGeneration(identity) {
-			return await runBindingMutation(async () => {
-				const key = bindingStoreKey(identity);
-				return await transactKey(key, (current, leaseToken) => {
-					if (!current) return { result: "absent" };
-					if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
-					if (current.state === "cleared" && current.retired === true) return { result: "conflict" };
-					return {
-						result: "applied",
-						next: {
-							version: 1,
-							state: "cleared",
-							...storedSessionGeneration(identity, current),
-							...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
-						}
-					};
-				}, leaseContext.getStore()?.has(key) ? void 0 : 1);
-			});
-		},
-		async retireSessionGeneration(identity) {
-			return await runBindingMutation(async () => {
-				const key = bindingStoreKey(identity);
-				return await transactKey(key, (current, leaseToken) => {
-					if (!current) return { result: "absent" };
-					if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
-					if (current.state === "cleared" && current.retired === true) return { result: "applied" };
-					return {
-						result: "applied",
-						next: {
-							version: 1,
-							state: "cleared",
-							retired: true,
-							...storedSessionGeneration(identity, current),
-							...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
-						}
-					};
-				}, identity.sessionKey?.trim() ? void 0 : PHYSICAL_SESSION_RETIRE_TTL_MS);
-			});
-		},
+		resetSessionGeneration: (identity) => transitionSessionGeneration(identity, "reset"),
+		retireSessionGeneration: (identity) => transitionSessionGeneration(identity, "retire"),
 		async withThreadArchiveFence(run) {
 			pendingArchives += 1;
 			const operation = archiveTail.then(async () => {
@@ -638,79 +718,73 @@ function createCodexAppServerBindingStore(state) {
 				pendingArchives -= 1;
 			}
 		},
-		async withLease(identity, run) {
+		async withSessionDeletion(identity, assertCurrent, run) {
 			const key = bindingStoreKey(identity);
-			const owned = leaseContext.getStore();
-			const existingOwner = owned?.get(key);
-			if (existingOwner) {
-				const failureBeforeRun = existingOwner.failure;
-				if (failureBeforeRun) throw failureBeforeRun;
-				const result = await run();
-				const failureAfterRun = existingOwner.failure;
-				if (failureAfterRun) throw failureAfterRun;
-				return result;
-			}
-			const token = randomUUID();
-			if (!await transactKey(key, (current) => {
-				if (current?.state === "cleared" && current.retired === true && ownsStoredSessionGeneration(identity, current)) return { result: false };
-				const lease = {
-					token,
-					expiresAt: Date.now() + BINDING_LEASE_STALE_MS
-				};
-				if (current?.state === "active") return {
-					result: true,
-					next: {
-						...current,
-						...preservedSessionGeneration(identity, current),
-						lease
-					}
-				};
-				if (current?.state === "cleared" && current.retired === true) return {
-					result: true,
-					next: {
-						...current,
-						lease
-					}
-				};
-				return {
-					result: true,
-					next: {
-						version: 1,
-						state: "cleared",
-						...preservedSessionGeneration(identity, current),
-						lease
+			const deleteIf = state.deleteIf?.bind(state);
+			if (!deleteIf) throw new Error("Codex session deletion requires conditional plugin-state deletion");
+			return await runBindingMutation(async () => {
+				assertCurrent();
+				if (state.lookup(key) === void 0) {
+					let active = true;
+					try {
+						return await run(void 0, {
+							commit() {
+								assertCurrent();
+								if (!active || state.lookup(key) !== void 0) throw new Error("Codex binding changed before session deletion");
+							},
+							rollback() {}
+						});
+					} finally {
+						active = false;
 					}
-				};
-			})) throw new Error(`Codex binding generation was retired: ${key}`);
-			const owner = { token };
-			const nested = new Map(owned);
-			nested.set(key, owner);
-			const heartbeat = setInterval(() => renewLease(key, owner), BINDING_LEASE_RENEW_INTERVAL_MS);
-			heartbeat.unref();
-			try {
-				const result = await leaseContext.run(nested, run);
-				if (owner.failure) throw owner.failure;
-				return result;
-			} finally {
-				clearInterval(heartbeat);
-				try {
-					const removeOwnedLease = (raw, matches) => {
-						const current = readStoredCodexAppServerBinding(raw);
-						if (!current || !matches(current) || current.lease?.token !== token) return;
-						const { lease: _lease, ...released } = current;
-						return released;
+				}
+				return await withBindingLease(identity, async () => {
+					const owner = leaseContext.getStore().get(key);
+					const stored = readStoredCodexAppServerBinding(state.lookup(key));
+					if (!stored || !ownsStoredSessionGeneration(identity, stored)) throw new Error("Codex binding generation changed before session deletion");
+					const { lease: _lease, ...expectedValue } = stored;
+					let deleted;
+					let active = true;
+					const assertActive = () => {
+						assertCurrent();
+						if (!active || owner.phase === "closed" || owner.failure) throw owner.failure ?? bindingLeaseLostError(key);
 					};
-					if (!update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "active"))) {
-						if (!update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "cleared" && current.retired === true), key.startsWith("session:") ? { ttlMs: PHYSICAL_SESSION_RETIRE_TTL_MS } : void 0)) update(key, (raw) => removeOwnedLease(raw, (current) => current.state === "cleared"), { ttlMs: 1 });
+					try {
+						return await run(stored.state === "active" ? stored.binding : void 0, {
+							commit() {
+								assertActive();
+								if (deleted) return;
+								const current = state.lookup(key);
+								const { lease, ...value } = readStoredCodexAppServerBinding(current) ?? {};
+								if (!current || lease?.token !== owner.token || lease.expiresAt <= Date.now() || !isDeepStrictEqual(value, expectedValue) || !deleteIf(key, (raw) => isDeepStrictEqual(raw, current))) throw new Error("Codex binding changed before session deletion");
+								deleted = current;
+								owner.phase = "deleted";
+							},
+							rollback() {
+								assertActive();
+								if (!deleted) return;
+								const restored = {
+									...deleted,
+									lease: {
+										token: owner.token,
+										expiresAt: Date.now() + BINDING_LEASE_STALE_MS
+									}
+								};
+								if (!state.registerIfAbsent(key, restored)) throw new Error("Codex binding changed before session deletion rollback");
+								deleted = void 0;
+								owner.phase = "held";
+							}
+						});
+					} finally {
+						active = false;
 					}
-				} catch (error) {
-					embeddedAgentLog.warn("failed to release codex app-server binding lease", {
-						key,
-						error
-					});
-				}
-			}
-		}
+				}, {
+					allowRetired: true,
+					assertCurrent
+				});
+			});
+		},
+		withLease: withBindingLease
 	};
 }
 function matchesPendingSupervisionBranch(binding, expected) {
@@ -725,9 +799,8 @@ function isSameSupervisionOwner(current, replacement) {
 	return replacement.connectionScope === "supervision" && replacement.threadId === current.threadId && replacement.supervisionSourceThreadId === current.supervisionSourceThreadId;
 }
 function matchesPendingSupervisionClear(binding, threadId, expected) {
-	if (!expected) return false;
-	const sourceThreadId = expected.sourceThreadId;
-	return threadId === sourceThreadId && binding.supervisionSourceThreadId === sourceThreadId && matchesPendingSupervisionBranch(binding, expected);
+	if (!expected || threadId !== expected.sourceThreadId) return false;
+	return !binding || binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && matchesPendingSupervisionBranch(binding, expected);
 }
 /** Stable plugin-state key for one current binding owner. */
 function bindingStoreKey(identity) {
@@ -736,7 +809,7 @@ function bindingStoreKey(identity) {
 		const sessionId = identity.sessionId.trim();
 		if (!rawAgentId) throw new Error("Codex app-server binding requires an agent id");
 		if (!sessionId) throw new Error("Codex app-server binding requires a session id");
-		const agentId = resolveSessionAgentIds$1({ agentId: rawAgentId }).sessionAgentId;
+		const agentId = resolveSessionAgentIdsStrict({ agentId: rawAgentId }).sessionAgentId;
 		const sessionKey = identity.sessionKey?.trim();
 		if (sessionKey) return `session-key:${agentId}:${createHash("sha256").update(sessionKey).digest("base64url")}`;
 		return `session:${agentId}:${sessionId}`;