@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

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

@@ -1,13 +1,13 @@
 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 { g as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-utils-C57JiJrU.js";
+import { a as readCodexBindingTimestamp, c as readStoredCodexAppServerBinding, d as validateBindingForWrite, i as readCodexBindingSessionEntry, l as sessionBindingIdentity, n as ownsStoredSessionGeneration, o as readCodexSessionOwnershipBinding, r as readCodexAppServerThreadBinding, s as readCurrentCodexAppServerBinding, t as bindingStoreKey, u as stripUndefinedBinding } from "./session-binding-record-CyaXZvTe.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 { z } from "zod";
+import { AgentHarnessPreflightError, AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { isDeepStrictEqual } from "node:util";
+import { ensureAuthProfileStore, resolveDefaultAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-binding.ts
 /** SQLite-backed Codex app-server thread bindings. */
 var session_binding_exports = /* @__PURE__ */ __exportAll({
@@ -28,8 +28,10 @@ var session_binding_exports = /* @__PURE__ */ __exportAll({
 	readStoredCodexAppServerBinding: () => readStoredCodexAppServerBinding,
 	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
 	resolveCodexRunSessionBindingAuthority: () => resolveCodexRunSessionBindingAuthority,
+	resolveCodexSessionBinding: () => resolveCodexSessionBinding,
 	scopeCodexRunBindingStore: () => scopeCodexRunBindingStore,
-	sessionBindingIdentity: () => sessionBindingIdentity
+	sessionBindingIdentity: () => sessionBindingIdentity,
+	validateBindingForWrite: () => validateBindingForWrite
 });
 const CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER = "openai";
 const PUBLIC_OPENAI_MODEL_PROVIDER = "openai";
@@ -40,220 +42,52 @@ const BINDING_LEASE_STALE_MS = 65e3;
 const BINDING_LEASE_WAIT_MS = 7e4;
 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 sessionKey = params.sessionKey?.trim();
-	return {
-		kind: "session",
-		agentId: sessionAgentId,
-		sessionId: params.sessionId,
-		...sessionKey ? { sessionKey } : {}
-	};
-}
 /** Decides whether a run may share the durable stable-key binding owner. */
 function resolveCodexRunSessionBindingAuthority(params) {
-	const sessionKey = params.identity.sessionKey?.trim();
-	if (!sessionKey) return "ephemeral";
-	try {
-		const storePath = params.storePath?.trim() || resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId });
-		const entry = getSessionEntry({
-			agentId: params.identity.agentId,
-			hydrateSkillPromptRefs: false,
-			readConsistency: "latest",
-			sessionKey,
-			storePath
-		});
-		if (!entry) return "ephemeral";
-		return entry.sessionId === params.identity.sessionId ? "current" : "superseded";
-	} catch {
-		return "superseded";
-	}
+	return captureCodexSessionGenerationAuthority(params)[0];
+}
+function captureCodexSessionGenerationAuthority(params, assertCallerCurrent = () => {}) {
+	const readEntry = () => {
+		try {
+			return readCodexBindingSessionEntry(params);
+		} catch {
+			return null;
+		}
+	};
+	const entry = readEntry();
+	const current = entry?.sessionId === params.identity.sessionId;
+	const authority = entry === void 0 ? "ephemeral" : current ? "current" : "superseded";
+	const previousSessionId = current ? entry.previousSessionId : void 0;
+	const assertHostCurrent = () => {
+		if (authority === "ephemeral") return;
+		const latest = readEntry();
+		if (authority !== "current" || !latest || latest.sessionId !== params.identity.sessionId || latest.previousSessionId !== previousSessionId) throw createCodexSessionGenerationSupersededError(params.identity.sessionId);
+	};
+	const assertCurrent = () => {
+		assertCallerCurrent();
+		assertHostCurrent();
+	};
+	return [
+		authority,
+		previousSessionId,
+		assertHostCurrent,
+		assertCurrent
+	];
 }
 /** Builds the terminal coordination error used when a newer OpenClaw session owns the binding. */
 function createCodexSessionGenerationSupersededError(sessionId) {
 	return new AgentHarnessSessionSupersededError(`Codex session generation is no longer current: ${sessionId}`);
 }
-const optionalStringSchema = z.string().optional().catch(void 0);
-const optionalBooleanSchema = z.boolean().optional().catch(void 0);
-const optionalNonBlankStringSchema = z.string().refine((value) => Boolean(value.trim())).optional().catch(void 0);
-const optionalTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value))).optional().catch(void 0);
-const pendingSupervisionBranchSchema = z.object({
-	sourceThreadId: z.string().trim().min(1),
-	connectionFingerprint: z.string().trim().min(1).optional(),
-	lastTurnId: z.string().trim().min(1).optional(),
-	cleanupThreadIds: z.array(z.string().trim().min(1)).max(2).optional()
-}).strict().superRefine((pending, context) => {
-	const cleanupThreadIds = pending.cleanupThreadIds ?? [];
-	if (new Set(cleanupThreadIds).size !== cleanupThreadIds.length) context.addIssue({
-		code: "custom",
-		message: "pending supervision cleanup thread ids must be unique"
-	});
-	if (cleanupThreadIds.includes(pending.sourceThreadId)) context.addIssue({
-		code: "custom",
-		message: "pending supervision cleanup cannot target its source"
-	});
-});
-const contextEngineProjectionSchema = z.object({
-	schemaVersion: z.literal(1),
-	mode: z.literal("thread_bootstrap"),
-	epoch: z.string().refine((value) => Boolean(value.trim())),
-	fingerprint: optionalStringSchema
-}).strict();
-const contextEngineSchema = z.object({
-	schemaVersion: z.literal(1),
-	engineId: z.string(),
-	policyFingerprint: z.string(),
-	projection: contextEngineProjectionSchema.optional().catch(void 0)
-}).strict();
-const destructiveApprovalModeSchema = z.enum([
-	"allow",
-	"deny",
-	"auto",
-	"ask"
-]).optional().catch(void 0);
-const accountAppPolicyEntrySchema = z.object({
-	source: z.literal("account"),
-	appName: z.string(),
-	allowDestructiveActions: z.boolean(),
-	allowOpenWorld: z.boolean().optional(),
-	destructiveApprovalMode: destructiveApprovalModeSchema,
-	mcpServerNames: z.array(z.string())
-}).strict();
-const pluginAppPolicyEntrySchema = z.object({
-	source: z.literal("plugin").optional(),
-	configKey: z.string(),
-	marketplaceName: z.string().regex(CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN),
-	pluginName: z.string(),
-	allowDestructiveActions: z.boolean(),
-	allowOpenWorld: z.boolean().optional(),
-	destructiveApprovalMode: destructiveApprovalModeSchema,
-	mcpServerNames: z.array(z.string())
-}).strict();
-const pluginAppPolicyContextSchema = z.object({
-	fingerprint: z.string(),
-	apps: z.record(z.string(), z.union([accountAppPolicyEntrySchema, pluginAppPolicyEntrySchema])),
-	pluginAppIds: z.record(z.string(), z.array(z.string())).default({})
-}).strict();
-const threadBindingSchema = z.object({
-	threadId: z.string().refine((value) => Boolean(value.trim())),
-	clientId: optionalStringSchema,
-	cwd: z.string(),
-	rolloutPath: optionalNonBlankStringSchema,
-	connectionScope: z.literal("supervision").optional(),
-	supervisionSourceThreadId: z.string().trim().min(1).optional(),
-	authProfileId: optionalStringSchema,
-	agentWorkspaceDeveloperInstructions: optionalNonBlankStringSchema,
-	model: optionalStringSchema,
-	preserveNativeModel: z.literal(true).optional().catch(void 0),
-	pendingSupervisionBranch: pendingSupervisionBranchSchema.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",
-		"on-request",
-		"untrusted"
-	]).optional()).catch(void 0),
-	sandbox: z.enum([
-		"read-only",
-		"workspace-write",
-		"danger-full-access"
-	]).optional().catch(void 0),
-	serviceTier: z.preprocess(normalizeCodexServiceTier, z.custom((value) => typeof value === "string").optional()).optional().catch(void 0),
-	networkProxyProfileName: optionalStringSchema,
-	networkProxyConfigFingerprint: optionalStringSchema,
-	dynamicToolsFingerprint: optionalStringSchema,
-	dynamicToolsContainDeferred: optionalBooleanSchema,
-	webSearchThreadConfigFingerprint: optionalStringSchema,
-	nativeSkillIsolationFingerprint: optionalStringSchema,
-	userMcpServersFingerprint: optionalStringSchema,
-	mcpServersFingerprint: optionalStringSchema,
-	configuredMcpOwnershipVersion: z.literal(1).optional().catch(void 0),
-	ringZeroConfigFingerprint: optionalStringSchema,
-	ringZeroClientInstanceId: optionalStringSchema,
-	/** Durable fact preventing a later unrestricted turn from widening this thread. */
-	nativeToolPolicyRestricted: z.literal(true).optional().catch(void 0),
-	nativeHookRelayGeneration: optionalNonBlankStringSchema,
-	appServerRuntimeFingerprint: optionalStringSchema,
-	pluginAppsFingerprint: optionalStringSchema,
-	pluginAppsInputFingerprint: optionalStringSchema,
-	pluginAppPolicyContext: pluginAppPolicyContextSchema.optional().catch(void 0),
-	contextEngine: contextEngineSchema.optional().catch(void 0),
-	environmentSelectionFingerprint: optionalStringSchema,
-	conversationStartId: optionalStringSchema,
-	conversationSourceTransferComplete: z.literal(true).optional().catch(void 0),
-	historyCoveredThrough: optionalTimestampSchema,
-	continuityCalibration: z.object({
-		promptChars: z.number().int().positive(),
-		inputTokens: z.number().int().positive()
-	}).optional().catch(void 0)
-}).superRefine((binding, context) => {
-	if (binding.connectionScope === "supervision") {
-		if (!binding.supervisionSourceThreadId) context.addIssue({
-			code: "custom",
-			message: "supervision connection ownership requires its native source thread id"
-		});
-		if (binding.preserveNativeModel !== true) context.addIssue({
-			code: "custom",
-			message: "supervision connection ownership requires native model ownership"
-		});
-		if (binding.conversationSourceTransferComplete !== true) context.addIssue({
-			code: "custom",
-			message: "supervision connection ownership requires a completed source transfer"
-		});
-		if (!binding.pendingSupervisionBranch && (!binding.model?.trim() || !binding.modelProvider)) context.addIssue({
-			code: "custom",
-			message: "materialized supervision bindings require a native model and provider"
-		});
-	}
-	if (binding.supervisionSourceThreadId && binding.connectionScope !== "supervision") context.addIssue({
-		code: "custom",
-		message: "a supervision source thread id requires supervision connection ownership"
-	});
-	if (!binding.pendingSupervisionBranch) return;
-	if (binding.threadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
-		code: "custom",
-		message: "pending supervision source must match the provisional thread binding"
-	});
-	if (binding.supervisionSourceThreadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
-		code: "custom",
-		message: "pending supervision source must match its durable source identity"
-	});
-	if (binding.preserveNativeModel !== true) context.addIssue({
-		code: "custom",
-		message: "pending supervision bindings must defer model selection to Codex App Server"
-	});
-	if (binding.connectionScope !== "supervision") context.addIssue({
-		code: "custom",
-		message: "pending supervision bindings require supervision connection ownership"
-	});
-});
 var CodexSupervisionBindingReplacementError = class extends Error {
 	constructor(threadId, operation) {
 		super(`Refusing to replace supervised Codex thread ${threadId} while ${operation}; its native user-home connection and model ownership must be preserved`);
 		this.name = "CodexSupervisionBindingReplacementError";
 	}
 };
-function assertCodexBindingMayBeReplaced(binding, operation) {
+function assertCodexBindingMayBeReplaced(binding, operation, expected) {
+	if (expected) throw new AgentHarnessPreflightError(`Codex native model ownership prevents ${operation}. Continue or compact the original session in its native runtime, or create a new chat with a concrete model; the original binding was preserved.`);
 	if (binding?.connectionScope === "supervision") throw new CodexSupervisionBindingReplacementError(binding.threadId, operation);
 }
-const bindingLeaseSchema = z.object({
-	token: z.string().refine((value) => Boolean(value.trim())),
-	expiresAt: z.number().finite()
-});
-const storedSessionIdSchema = z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0);
-const storedBindingSchema = z.discriminatedUnion("state", [z.object({
-	version: z.literal(1),
-	state: z.literal("active"),
-	binding: threadBindingSchema,
-	sessionId: storedSessionIdSchema,
-	lease: bindingLeaseSchema.optional().catch(void 0)
-}), z.object({
-	version: z.literal(1),
-	state: z.literal("cleared"),
-	sessionId: storedSessionIdSchema,
-	lease: bindingLeaseSchema.optional().catch(void 0),
-	retired: z.literal(true).optional().catch(void 0)
-})]);
 function hashCodexAppServerBindingFingerprint(canonical) {
 	return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
 }
@@ -288,7 +122,7 @@ function createStoredCodexAppServerBinding(value, options = {}) {
 	const record = normalizeLegacyBindingFingerprints(rawRecord);
 	if (record.schemaVersion !== 1 && record.schemaVersion !== 2) return;
 	const pluginAppPolicyContext = readPluginAppPolicyContext(record.pluginAppPolicyContext, record.schemaVersion);
-	const historyCoveredThrough = readTimestamp(record.historyCoveredThrough) ?? readTimestamp(record.updatedAt) ?? readTimestamp(record.createdAt) ?? readTimestamp(options.now) ?? (/* @__PURE__ */ new Date()).toISOString();
+	const historyCoveredThrough = readCodexBindingTimestamp(record.historyCoveredThrough) ?? readCodexBindingTimestamp(record.updatedAt) ?? readCodexBindingTimestamp(record.createdAt) ?? readCodexBindingTimestamp(options.now) ?? (/* @__PURE__ */ new Date()).toISOString();
 	const authProfileId = typeof record.authProfileId === "string" ? record.authProfileId : void 0;
 	const binding = readCodexAppServerThreadBinding({
 		...record,
@@ -318,37 +152,72 @@ 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),
+		adoptSessionGeneration: (identity, expectedPreviousSessionId, assertCurrent) => params.bindingStore.adoptSessionGeneration(mapSessionIdentity(identity), expectedPreviousSessionId, assertCurrent),
 		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) {
-	const sessionKey = params.identity.sessionKey?.trim();
-	if (!sessionKey) return true;
+async function reclaimPreparedCodexSessionGeneration(params, authority, assertCurrent = authority[3]) {
 	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
+	assertCurrent();
 	if (plan.kind === "resolved") return plan.result;
-	try {
-		const storePath = params.storePath?.trim() || resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId });
-		if (getSessionEntry({
-			agentId: params.identity.agentId,
-			hydrateSkillPromptRefs: false,
-			readConsistency: "latest",
-			sessionKey,
-			storePath
-		})?.sessionId !== params.identity.sessionId) return false;
-	} catch {
-		return false;
+	const [state, previousSessionId, assertHostCurrent] = authority;
+	if (state !== "current") return false;
+	params.onHostGenerationVerified?.(assertHostCurrent);
+	if (previousSessionId === plan.expectedPreviousSessionId) {
+		const adopted = await params.bindingStore.adoptSessionGeneration(params.identity, previousSessionId, assertCurrent);
+		if (adopted !== "absent") return adopted !== "conflict";
 	}
-	return await params.bindingStore.mutate(params.identity, {
+	if (params.reclaimStale === false) return false;
+	return params.bindingStore.mutate(params.identity, {
 		kind: "reclaim-generation",
 		expectedPreviousSessionId: plan.expectedPreviousSessionId
-	});
+	}, assertCurrent);
+}
+/** Lets the authoritative OpenClaw session generation claim a stale stable binding row. */
+async function reclaimCurrentCodexSessionGeneration(params) {
+	params.assertCurrent?.();
+	if (!params.identity.sessionKey?.trim()) return true;
+	const authority = captureCodexSessionGenerationAuthority(params, params.assertCurrent);
+	if (authority[0] === "superseded") return false;
+	return reclaimPreparedCodexSessionGeneration(params, authority);
+}
+/** Resolve continuity before selecting native queues, catalogs, or connections. */
+async function resolveCodexSessionBinding(params) {
+	let assertCurrent = params.assertCurrent ?? (() => {});
+	const assertAdmissionCurrent = () => {
+		assertCurrent();
+		params.signal?.throwIfAborted();
+	};
+	assertAdmissionCurrent();
+	params.assertBinding?.(readCodexSessionOwnershipBinding(params));
+	const identity = params.identity;
+	const authority = identity.kind === "session" && identity.sessionKey?.trim() ? captureCodexSessionGenerationAuthority({
+		...params,
+		identity
+	}, assertCurrent) : void 0;
+	assertCurrent = authority?.[3] ?? assertCurrent;
+	assertAdmissionCurrent();
+	let binding = params.bindingStore.read(identity);
+	if (!binding && authority && identity.kind === "session") {
+		if (!await reclaimPreparedCodexSessionGeneration({
+			...params,
+			identity,
+			reclaimStale: params.reclaimStale === true
+		}, authority, assertAdmissionCurrent) && params.reclaimStale) throw createCodexSessionGenerationSupersededError(identity.sessionId);
+		binding = params.bindingStore.read(identity);
+	}
+	assertAdmissionCurrent();
+	params.assertBinding?.(binding);
+	return {
+		binding,
+		assertCurrent
+	};
 }
 /** Creates the single binding facade owned by the Codex plugin runtime. */
 function createCodexAppServerBindingStore(state) {
@@ -382,9 +251,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 +275,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,14 +314,117 @@ function createCodexAppServerBindingStore(state) {
 			await sleep(BINDING_LEASE_RETRY_INTERVAL_MS);
 		}
 	};
-	return {
-		async read(identity) {
+	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 raw = state.lookup(key);
-			const stored = readStoredCodexAppServerBinding(raw);
-			if (raw !== void 0 && !stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
-			return stored?.state === "active" && ownsStoredSessionGeneration(identity, stored) ? stored.binding : void 0;
-		},
+			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 {
+		read: (identity) => readCurrentCodexAppServerBinding(state, identity),
 		async hasOtherThreadOwner(threadId, currentIdentity) {
 			const currentKey = currentIdentity ? bindingStoreKey(currentIdentity) : void 0;
 			return state.entries().some(({ key, value }) => {
@@ -485,7 +461,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 +499,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,10 +538,10 @@ 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) {
+		async adoptSessionGeneration(identity, expectedPreviousSessionId, assertCurrent) {
 			return await runBindingMutation(async () => {
 				const key = bindingStoreKey(identity);
 				const expectedSessionId = expectedPreviousSessionId.trim();
@@ -583,48 +558,11 @@ function createCodexAppServerBindingStore(state) {
 							sessionId: targetSessionId
 						}
 					};
-				});
-			});
-		},
-		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);
+				}, void 0, assertCurrent);
 			});
 		},
+		resetSessionGeneration: (identity) => transitionSessionGeneration(identity, "reset"),
+		retireSessionGeneration: (identity) => transitionSessionGeneration(identity, "retire"),
 		async withThreadArchiveFence(run) {
 			pendingArchives += 1;
 			const operation = archiveTail.then(async () => {
@@ -638,79 +576,74 @@ 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 expected = state.lookup(key);
+					const stored = readStoredCodexAppServerBinding(expected);
+					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,31 +657,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") {
-		const rawAgentId = identity.agentId.trim();
-		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 sessionKey = identity.sessionKey?.trim();
-		if (sessionKey) return `session-key:${agentId}:${createHash("sha256").update(sessionKey).digest("base64url")}`;
-		return `session:${agentId}:${sessionId}`;
-	}
-	const bindingId = identity.bindingId.trim();
-	if (!bindingId) throw new Error("Codex app-server conversation binding requires a binding id");
-	return `conversation:${bindingId}`;
-}
-function readStoredCodexAppServerBinding(value) {
-	const result = storedBindingSchema.safeParse(value);
-	return result.success ? stripUndefinedValue(result.data) : void 0;
-}
 function storedSessionGeneration(identity, current) {
 	if (identity.kind === "session") return { sessionId: identity.sessionId };
 	return current?.sessionId ? { sessionId: current.sessionId } : {};
@@ -757,31 +665,6 @@ function preservedSessionGeneration(identity, current) {
 	if (current?.sessionId) return { sessionId: current.sessionId };
 	return storedSessionGeneration(identity, current);
 }
-function ownsStoredSessionGeneration(identity, current) {
-	return identity.kind !== "session" || !current?.sessionId || current.sessionId === identity.sessionId;
-}
-function validateBindingForWrite(binding) {
-	const validated = readCodexAppServerThreadBinding(binding);
-	if (!validated) throw new Error("Invalid Codex app-server thread binding");
-	return stripUndefinedBinding(validated);
-}
-/** Parses stored or shipped sidecar data into the current domain value. */
-function readCodexAppServerThreadBinding(value) {
-	const result = threadBindingSchema.safeParse(value);
-	if (!result.success) return;
-	return result.data;
-}
-function stripUndefinedBinding(binding) {
-	return stripUndefinedValue(binding);
-}
-function stripUndefinedValue(value) {
-	if (Array.isArray(value)) return value.map(stripUndefinedValue);
-	if (!value || typeof value !== "object") return value;
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, stripUndefinedValue(entry)]));
-}
-function readTimestamp(value) {
-	return optionalTimestampSchema.parse(value);
-}
 function readPluginAppPolicyContext(value, bindingSchemaVersion) {
 	const record = asOptionalRecord(value);
 	if (!record || typeof record.fingerprint !== "string") return;
@@ -871,4 +754,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 { isCodexAppServerNativeAuthProfile as a, resolveCodexRunSessionBindingAuthority as c, session_binding_exports as d, hashCodexAppServerBindingFingerprint as i, resolveCodexSessionBinding as l, assertCodexBindingMayBeReplaced as n, normalizeCodexAppServerBindingModelProvider as o, createCodexSessionGenerationSupersededError as r, reclaimCurrentCodexSessionGeneration as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t, scopeCodexRunBindingStore as u };