@openclaw/codex 2026.9.1-beta.1 → 2026.9.1

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

@@ -1,22 +1,23 @@
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-DhoGy33Z.js";
+import { i as resolvePackagedCodexNativeCommand } from "./managed-binary-4-Vjz5GH.js";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-CyPldczm.js";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { resolveWindowsExecutablePath, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
-import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 //#region extensions/codex/src/app-server/runtime-artifact.ts
 /** Exact local runtime artifact identity for verified Codex setup turns. */
 const ARTIFACT_ID_PREFIX = "codex-app-server:v1:";
 const ARTIFACT_HASH_DOMAIN = "openclaw-codex-app-server-runtime-artifact-v1\0";
-const MAX_ARTIFACT_ID_BYTES = 32 * 1024;
+const MAX_ARTIFACT_ID_BYTES = 32768;
 const MAX_ARTIFACT_PATH_BYTES = 4096;
 const MAX_ARTIFACT_INVOCATION_PATHS = 8;
 const MAX_ARTIFACT_DEPTH = 64;
 const MAX_ARTIFACT_ENTRIES = 32768;
 const MAX_ARTIFACT_FILES = 8192;
 const MAX_ARTIFACT_TOTAL_BYTES = 1024n * 1024n * 1024n;
-const READ_CHUNK_BYTES = 64 * 1024;
+const READ_CHUNK_BYTES = 65536;
 const CODE_MODE_HOST_PATH_ENV = "CODEX_CODE_MODE_HOST_PATH";
 const SAFE_NODE_OPTIONS_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
 	"--enable-network-family-autoselection",
@@ -363,6 +364,8 @@ async function captureFilesystemDescriptor(params) {
 	const spawnCwd = path.resolve(params.startOptions.cwd ?? process.cwd());
 	const commandPath = await resolveCommandPath(params.startOptions.command, env, spawnCwd);
 	const commandRealPath = await fs.realpath(commandPath);
+	let nativeCommand = params.spawnIdentity.nativeCommand;
+	let nativeCandidate = commandRealPath;
 	let invocationPaths;
 	if (process.platform === "win32") {
 		const program = resolveWindowsSpawnProgram({
@@ -372,7 +375,10 @@ async function captureFilesystemDescriptor(params) {
 			execPath: process.execPath,
 			packageName: "@openai/codex"
 		});
-		if (program.resolution === "node-entrypoint" && !params.spawnIdentity.nativeCommand) throw new Error("Codex runtime cannot attest a custom Node launcher without its native target");
+		const entrypoint = program.leadingArgv[0];
+		if (program.resolution === "node-entrypoint" && entrypoint && !nativeCommand) nativeCommand = resolvePackagedCodexNativeCommand(await fs.realpath(entrypoint));
+		if (program.resolution === "node-entrypoint" && !nativeCommand) throw new Error("Codex runtime cannot attest a custom Node launcher without its native target");
+		nativeCandidate = program.command;
 		const invocationCandidates = [
 			commandRealPath,
 			program.command,
@@ -383,17 +389,18 @@ async function captureFilesystemDescriptor(params) {
 			const resolved = await resolveCommandPath(candidate, env, spawnCwd);
 			invocationPaths.push(await fs.realpath(resolved));
 		}
-	} else invocationPaths = await resolvePosixInvocationPaths({
-		commandRealPath,
-		env,
-		cwd: spawnCwd,
-		nativeCommand: params.spawnIdentity.nativeCommand
-	});
+	} else {
+		nativeCommand ??= resolvePackagedCodexNativeCommand(commandRealPath);
+		invocationPaths = await resolvePosixInvocationPaths({
+			commandRealPath,
+			env,
+			cwd: spawnCwd,
+			nativeCommand
+		});
+	}
 	invocationPaths = [...new Set(invocationPaths)].toSorted(compareArtifactNames);
 	if (invocationPaths.length > MAX_ARTIFACT_INVOCATION_PATHS) throw new Error("Codex runtime launcher exceeds the bounded invocation file count");
-	const nativeCandidate = params.spawnIdentity.nativeCommand ?? invocationPaths[0];
-	if (!nativeCandidate) throw new Error("Codex runtime did not resolve a native executable");
-	const nativePath = await fs.realpath(await resolveCommandPath(nativeCandidate, env, spawnCwd));
+	const nativePath = await fs.realpath(await resolveCommandPath(nativeCommand ?? nativeCandidate, env, spawnCwd));
 	const packageRoot = await resolvePackageRoot(nativePath);
 	const configuredCodeModeHost = readEffectiveSpawnEnvironmentValue(env, CODE_MODE_HOST_PATH_ENV)?.trim();
 	const adjacentCodeModeHost = path.join(path.dirname(nativePath), process.platform === "win32" ? "codex-code-mode-host.exe" : "codex-code-mode-host");

package/dist/{session-binding-Bcynfd-_.js → session-binding-BHuTCRZQ.js}

@@ -1,10 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { P as normalizeCodexServiceTier, y as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-giW8X0QA.js";
+import { P as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN, j as normalizeCodexServiceTier } from "./config-BhmfC1s6.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";
@@ -29,7 +31,8 @@ var session_binding_exports = /* @__PURE__ */ __exportAll({
 	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
 	resolveCodexRunSessionBindingAuthority: () => resolveCodexRunSessionBindingAuthority,
 	scopeCodexRunBindingStore: () => scopeCodexRunBindingStore,
-	sessionBindingIdentity: () => sessionBindingIdentity
+	sessionBindingIdentity: () => sessionBindingIdentity,
+	validateBindingForWrite: () => validateBindingForWrite
 });
 const CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER = "openai";
 const PUBLIC_OPENAI_MODEL_PROVIDER = "openai";
@@ -42,7 +45,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 +150,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,20 +322,23 @@ 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)
 	};
 }
 /** Lets the authoritative OpenClaw session generation claim a stale stable binding row. */
 async function reclaimCurrentCodexSessionGeneration(params) {
+	params.assertCurrent?.();
 	const sessionKey = params.identity.sessionKey?.trim();
 	if (!sessionKey) return true;
 	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
+	params.assertCurrent?.();
 	if (plan.kind === "resolved") return plan.result;
 	try {
 		const storePath = params.storePath?.trim() || resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId });
@@ -348,7 +355,7 @@ async function reclaimCurrentCodexSessionGeneration(params) {
 	return await params.bindingStore.mutate(params.identity, {
 		kind: "reclaim-generation",
 		expectedPreviousSessionId: plan.expectedPreviousSessionId
-	});
+	}, params.assertCurrent);
 }
 /** Creates the single binding facade owned by the Codex plugin runtime. */
 function createCodexAppServerBindingStore(state) {
@@ -382,9 +389,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 +413,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 +452,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 +605,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 +643,8 @@ 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 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.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 +682,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 +705,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 +720,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) {
@@ -724,11 +800,6 @@ function matchesPendingSupervisionBranch(binding, expected) {
 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);
-}
 /** Stable plugin-state key for one current binding owner. */
 function bindingStoreKey(identity) {
 	if (identity.kind === "session") {
@@ -736,7 +807,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}`;
@@ -871,4 +942,4 @@ function normalizeCodexAppServerBindingModelProvider(params) {
 	return modelProvider;
 }
 //#endregion
-export { hashCodexAppServerBindingFingerprint as a, reclaimCurrentCodexSessionGeneration as c, sessionBindingIdentity as d, session_binding_exports as f, createCodexSessionGenerationSupersededError as i, resolveCodexRunSessionBindingAuthority as l, assertCodexBindingMayBeReplaced as n, isCodexAppServerNativeAuthProfile as o, bindingStoreKey as r, normalizeCodexAppServerBindingModelProvider as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t, scopeCodexRunBindingStore as u };
+export { hashCodexAppServerBindingFingerprint as a, reclaimCurrentCodexSessionGeneration as c, sessionBindingIdentity as d, session_binding_exports as f, createCodexSessionGenerationSupersededError as i, resolveCodexRunSessionBindingAuthority as l, assertCodexBindingMayBeReplaced as n, isCodexAppServerNativeAuthProfile as o, validateBindingForWrite as p, bindingStoreKey as r, normalizeCodexAppServerBindingModelProvider as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t, scopeCodexRunBindingStore as u };