@openclaw/codex 2026.9.6 → 2026.9.8

package/dist/.setup/session-binding-DGCYAfvD.mjs

@@ -0,0 +1,443 @@
+import { i as adoptCodexNativeSubagentSubmissions, n as mutateNativePendingAssignments, o as mutateCodexNativeSubagentSubmissions } from "./native-subagent-pending-assignments-DwkCzLvD.mjs";
+import { _ as readStoredCodexAppServerBinding, a as matchesPendingSupervisionBranch, b as validateBindingForWrite, c as preserveNativePendingAssignments, d as readCodexBindingTimestamp, f as readCurrentCodexAppServerBinding, g as readPluginAppPolicyContext, h as readCurrentNativePendingAssignments, i as matchesCodexNativeSubagentSubmissionBinding, l as preserveNativeTaskImport, m as readCurrentCodexNativeSubagentSubmissions, n as assertCodexBindingMayBeReplaced, o as ownsStoredSessionGeneration, p as readCurrentCodexAppServerBindings, r as bindingStoreKey, s as preserveCodexNativeSubagentSubmissions, t as CodexSupervisionBindingReplacementError, u as readCodexAppServerThreadBinding, v as sessionBindingIdentity, y as stripUndefinedBinding } from "./session-binding-record-Oe9L-CNY.mjs";
+import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.mjs";
+import { n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-B0okYl2D.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+import { AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { captureNativeSessionGenerationAuthority, createNativeSessionBindingLifecycle, reclaimNativeSessionGeneration, resolveNativeSessionBinding } from "openclaw/plugin-sdk/agent-harness-session-runtime";
+//#region extensions/codex/src/app-server/session-binding-native-mutations.ts
+/** The caller supplies the transaction's freshly parsed row and current-authority closure. */
+function mutateNativeSubagentBinding({ identity, current, mutation, assertCurrent }) {
+	if (mutation.kind === "record-native-subagent-assignment" || mutation.kind === "consume-native-subagent-assignment") {
+		if (!assertCurrent) throw new Error("Codex native assignment mutation requires current authority.");
+		assertCurrent();
+		if (current?.state !== "active" || !ownsStoredSessionGeneration(identity, current) || identity.kind === "session" && mutation.owner.sessionId !== identity.sessionId || !matchesCodexNativeSubagentSubmissionBinding(current.binding, mutation.owner)) return { result: false };
+		const changed = mutateNativePendingAssignments({
+			current: current.nativeSubagentAssignments,
+			owner: mutation.owner,
+			assignment: mutation.assignment,
+			consume: mutation.kind === "consume-native-subagent-assignment"
+		});
+		if (!changed.applied) return { result: false };
+		const { nativeSubagentAssignments: _previous, ...bindingOwner } = current;
+		return {
+			result: true,
+			next: {
+				...bindingOwner,
+				...changed.next ? { nativeSubagentAssignments: changed.next } : {}
+			}
+		};
+	}
+	if (!assertCurrent) throw new Error("Codex native subagent submission mutation requires current authority.");
+	assertCurrent();
+	if (current?.state !== "active" || !ownsStoredSessionGeneration(identity, current) || identity.kind === "session" && mutation.owner.sessionId !== identity.sessionId || !matchesCodexNativeSubagentSubmissionBinding(current.binding, mutation.owner)) return { result: false };
+	const changed = mutateCodexNativeSubagentSubmissions({
+		current: current.nativeSubagentSubmissions,
+		owner: mutation.owner,
+		receipt: mutation.receipt,
+		consume: mutation.kind === "consume-native-subagent-submission"
+	});
+	if (!changed.applied) return { result: false };
+	const { nativeSubagentSubmissions: _previous, ...bindingOwner } = current;
+	return {
+		result: true,
+		next: {
+			...bindingOwner,
+			...changed.next ? { nativeSubagentSubmissions: changed.next } : {}
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/session-binding.ts
+/** SQLite-backed Codex app-server thread bindings. */
+var session_binding_exports = /* @__PURE__ */ __exportAll({
+	CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS: () => CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS,
+	CODEX_APP_SERVER_BINDING_MAX_ENTRIES: () => CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
+	CODEX_APP_SERVER_BINDING_NAMESPACE: () => CODEX_APP_SERVER_BINDING_NAMESPACE,
+	CodexSupervisionBindingReplacementError: () => CodexSupervisionBindingReplacementError,
+	assertCodexBindingMayBeReplaced: () => assertCodexBindingMayBeReplaced,
+	bindingStoreKey: () => bindingStoreKey,
+	createCodexAppServerBindingStore: () => createCodexAppServerBindingStore,
+	createCodexSessionGenerationSupersededError: () => createCodexSessionGenerationSupersededError,
+	createStoredCodexAppServerBinding: () => createStoredCodexAppServerBinding,
+	hashCodexAppServerBindingFingerprint: () => hashCodexAppServerBindingFingerprint,
+	normalizeStoredCodexAppServerBindingFingerprints: () => normalizeStoredCodexAppServerBindingFingerprints,
+	readCodexAppServerThreadBinding: () => readCodexAppServerThreadBinding,
+	readStoredCodexAppServerBinding: () => readStoredCodexAppServerBinding,
+	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
+	resolveCodexRunSessionBindingAuthority: () => resolveCodexRunSessionBindingAuthority,
+	resolveCodexSessionBinding: () => resolveCodexSessionBinding,
+	sessionBindingIdentity: () => sessionBindingIdentity,
+	validateBindingForWrite: () => validateBindingForWrite
+});
+const BINDING_LEASE_RETRY_INTERVAL_MS = 1e3;
+const BOUNDED_BINDING_FINGERPRINT_PATTERN = /^sha256:[a-f0-9]{64}$/i;
+const CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS = 6e4;
+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;
+/** Decides whether a run may share the durable stable-key binding owner. */
+function resolveCodexRunSessionBindingAuthority(params) {
+	return captureNativeSessionGenerationAuthority({
+		...params,
+		target: params.identity,
+		createSupersededError: createCodexSessionGenerationSupersededError
+	}).state;
+}
+/** 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}`);
+}
+function hashCodexAppServerBindingFingerprint(canonical) {
+	return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+}
+function normalizeLegacyBindingFingerprint(value) {
+	if (typeof value !== "string" || value === "" || value === "[]" || BOUNDED_BINDING_FINGERPRINT_PATTERN.test(value)) return value;
+	return hashCodexAppServerBindingFingerprint(value);
+}
+function normalizeLegacyBindingFingerprints(record) {
+	let normalized = record;
+	for (const key of ["dynamicToolsFingerprint", "userMcpServersFingerprint"]) {
+		const value = record[key];
+		const next = normalizeLegacyBindingFingerprint(value);
+		if (next === value) continue;
+		if (normalized === record) normalized = { ...record };
+		Object.assign(normalized, { [key]: next });
+	}
+	return normalized;
+}
+function normalizeStoredCodexAppServerBindingFingerprints(value) {
+	const stored = readStoredCodexAppServerBinding(value);
+	if (!stored || stored.state !== "active") return stored;
+	const binding = normalizeLegacyBindingFingerprints(stored.binding);
+	return binding === stored.binding ? stored : readStoredCodexAppServerBinding({
+		...stored,
+		binding
+	});
+}
+/** Encodes a migrated sidecar binding as one canonical plugin-state row. */
+function createStoredCodexAppServerBinding(value, options = {}) {
+	const rawRecord = asOptionalRecord(value);
+	if (!rawRecord) return;
+	const record = normalizeLegacyBindingFingerprints(rawRecord);
+	if (record.schemaVersion !== 1 && record.schemaVersion !== 2) return;
+	const pluginAppPolicyContext = readPluginAppPolicyContext(record.pluginAppPolicyContext, record.schemaVersion);
+	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,
+		modelProvider: normalizeCodexAppServerBindingModelProvider({
+			...options.lookup,
+			authProfileId,
+			modelProvider: typeof record.modelProvider === "string" ? record.modelProvider : void 0
+		}),
+		cwd: typeof record.cwd === "string" ? record.cwd : "",
+		pluginAppPolicyContext,
+		historyCoveredThrough
+	});
+	return binding ? {
+		version: 1,
+		state: "active",
+		binding: stripUndefinedBinding(binding)
+	} : void 0;
+}
+function bindingLeaseLostError(key, cause) {
+	return new Error(`Lost Codex binding lease: ${key}`, cause === void 0 ? void 0 : { cause });
+}
+/** Lets the authoritative OpenClaw session generation claim a stale stable binding row. */
+async function reclaimCurrentCodexSessionGeneration(params) {
+	return await reclaimNativeSessionGeneration({
+		...params,
+		target: params.identity,
+		generation: codexSessionGenerationOperations(params.bindingStore, params.identity),
+		createSupersededError: createCodexSessionGenerationSupersededError
+	});
+}
+/** Resolve continuity before selecting native queues, catalogs, or connections. */
+async function resolveCodexSessionBinding(params) {
+	const identity = params.identity;
+	return await resolveNativeSessionBinding({
+		...params,
+		...identity.kind === "session" ? {
+			target: identity,
+			generation: codexSessionGenerationOperations(params.bindingStore, identity)
+		} : {},
+		readBinding: (sessionId) => params.bindingStore.read(sessionId && identity.kind === "session" ? {
+			...identity,
+			sessionId
+		} : identity),
+		createSupersededError: createCodexSessionGenerationSupersededError
+	});
+}
+/** Creates the single binding facade owned by the Codex plugin runtime. */
+function createCodexAppServerBindingStore(state) {
+	const lifecycle = createNativeSessionBindingLifecycle(state, {
+		readRecord: readStoredCodexAppServerBinding,
+		lease: {
+			staleMs: BINDING_LEASE_STALE_MS,
+			waitMs: BINDING_LEASE_WAIT_MS,
+			retryIntervalMs: BINDING_LEASE_RETRY_INTERVAL_MS,
+			renewIntervalMs: BINDING_LEASE_RENEW_INTERVAL_MS
+		},
+		releaseTtlMs: (key, current) => current.nativeSubagentTaskImport !== void 0 || current.state === "active" || current.retired === true && !key.startsWith("session:") ? void 0 : current.retired === true ? PHYSICAL_SESSION_RETIRE_TTL_MS : 1,
+		onReleaseFailure: (key, error) => embeddedAgentLog.warn("failed to release codex app-server binding lease", {
+			key,
+			error
+		}),
+		errors: {
+			atomicUpdatesRequired: "Codex app-server bindings require atomic plugin-state updates",
+			invalidRow: (key) => /* @__PURE__ */ new Error(`Invalid Codex app-server binding row: ${key}`),
+			lostLease: bindingLeaseLostError,
+			leaseTimeout: (key) => /* @__PURE__ */ new Error(`Timed out waiting for Codex binding lease: ${key}`),
+			acquisitionRejected: (key) => /* @__PURE__ */ new Error(`Codex binding generation was retired: ${key}`),
+			mutationBlocked: "Codex binding mutation blocked while a native archive is in progress; retry",
+			conditionalDeletionRequired: "Codex session deletion requires conditional plugin-state deletion",
+			deletionChanged: "Codex binding changed before session deletion",
+			rollbackChanged: "Codex binding changed before session deletion rollback"
+		}
+	});
+	const prepareLease = (identity, options = {}) => ({
+		assertCurrent: options.assertCurrent,
+		prepareLease(current, lease) {
+			if (current?.state === "cleared" && current.retired === true && ownsStoredSessionGeneration(identity, current) && !options.allowRetired) return;
+			if (current?.state === "active") return {
+				...current,
+				...preservedSessionGeneration(identity, current),
+				lease
+			};
+			if (current?.state === "cleared" && current.retired === true) return {
+				...current,
+				lease
+			};
+			return {
+				version: 1,
+				state: "cleared",
+				...preservedSessionGeneration(identity, current),
+				...preserveNativeTaskImport(current),
+				lease
+			};
+		}
+	});
+	const transitionSessionGeneration = async (identity, mode) => {
+		return await lifecycle.withMutation(async () => {
+			const key = bindingStoreKey(identity);
+			const ttlMs = mode === "reset" ? lifecycle.hasLease(key) ? void 0 : 1 : identity.sessionKey?.trim() ? void 0 : PHYSICAL_SESSION_RETIRE_TTL_MS;
+			return await lifecycle.transact(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),
+						...preserveNativeTaskImport(current),
+						...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
+					}
+				};
+			}, (next) => next.nativeSubagentTaskImport !== void 0 ? void 0 : ttlMs);
+		});
+	};
+	return {
+		read: (identity) => readCurrentCodexAppServerBinding(state, identity),
+		...state.lookupMany ? { readMany: (identities) => readCurrentCodexAppServerBindings(state, identities) } : {},
+		readNativeSubagentAssignments: (identity, owner) => readCurrentNativePendingAssignments(state, identity, owner),
+		readNativeSubagentSubmissions: (identity, owner) => readCurrentCodexNativeSubagentSubmissions(state, identity, owner),
+		async hasOtherThreadOwner(threadId, currentIdentity) {
+			const currentKey = currentIdentity ? bindingStoreKey(currentIdentity) : void 0;
+			return state.entries().some(({ key, value }) => {
+				const stored = readStoredCodexAppServerBinding(value);
+				if (!stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+				const isCurrentOwner = currentIdentity !== void 0 && key === currentKey && (currentIdentity.kind === "conversation" || stored.sessionId === currentIdentity.sessionId.trim());
+				return stored.state === "active" && stored.binding.threadId === threadId && !isCurrentOwner;
+			});
+		},
+		async prepareSessionGenerationReclaim(identity) {
+			const key = bindingStoreKey(identity);
+			const raw = state.lookup(key);
+			const current = readStoredCodexAppServerBinding(raw);
+			if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+			if (!current) return {
+				kind: "resolved",
+				result: true
+			};
+			const currentSessionId = current.sessionId;
+			if (!currentSessionId) return {
+				kind: "resolved",
+				result: current.state !== "cleared" || current.retired !== true
+			};
+			if (currentSessionId === identity.sessionId) return current.state === "cleared" && current.retired === true ? {
+				kind: "verify",
+				expectedPreviousSessionId: currentSessionId
+			} : {
+				kind: "resolved",
+				result: true
+			};
+			return {
+				kind: "verify",
+				expectedPreviousSessionId: currentSessionId
+			};
+		},
+		async mutate(identity, mutation, assertCurrent) {
+			return await lifecycle.withMutation(async () => {
+				const key = bindingStoreKey(identity);
+				const retainLegacyClear = mutation.kind === "clear" && key.startsWith("conversation:legacy-");
+				return await lifecycle.transact(key, (current, leaseToken) => {
+					if (mutation.kind === "record-native-subagent-assignment" || mutation.kind === "consume-native-subagent-assignment" || mutation.kind === "record-native-subagent-submission" || mutation.kind === "consume-native-subagent-submission") return mutateNativeSubagentBinding({
+						identity,
+						current,
+						mutation,
+						assertCurrent
+					});
+					const ownsGeneration = ownsStoredSessionGeneration(identity, current);
+					const ownedLease = current?.lease && current.lease.token === leaseToken ? { lease: current.lease } : {};
+					if (mutation.kind === "reclaim-generation") {
+						if (identity.kind !== "session" || !identity.sessionKey?.trim()) return { result: false };
+						if (!current) return { result: true };
+						if (ownsGeneration) {
+							if (current.state === "cleared" && current.retired === true && current.sessionId === mutation.expectedPreviousSessionId) return {
+								result: true,
+								next: {
+									version: 1,
+									state: "cleared",
+									sessionId: identity.sessionId,
+									...preserveNativeTaskImport(current),
+									...ownedLease
+								}
+							};
+							return { result: current.state !== "cleared" || current.retired !== true };
+						}
+						if (current.sessionId !== mutation.expectedPreviousSessionId) return { result: false };
+						if (current.state === "active" && current.binding.connectionScope === "supervision") return { result: false };
+						return {
+							result: true,
+							next: {
+								version: 1,
+								state: "cleared",
+								sessionId: identity.sessionId,
+								...preserveNativeTaskImport(current),
+								...ownedLease
+							}
+						};
+					}
+					const storedActive = current?.state === "active" ? current : void 0;
+					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 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" && (!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,
+						next: {
+							version: 1,
+							state: "cleared",
+							...storedSessionGeneration(identity, current),
+							...preserveNativeTaskImport(current),
+							...ownedLease
+						}
+					};
+					let binding;
+					if (mutation.kind === "set" || mutation.kind === "replace-thread") binding = validateBindingForWrite(mutation.binding);
+					else if (mutation.kind === "patch-pending-supervision-branch") binding = validateBindingForWrite({
+						...active.binding,
+						pendingSupervisionBranch: mutation.pending
+					});
+					else if (mutation.kind === "commit-pending-supervision-branch") binding = validateBindingForWrite({
+						...active.binding,
+						...mutation.patch,
+						threadId: mutation.threadId,
+						pendingSupervisionBranch: void 0
+					});
+					else binding = validateBindingForWrite({
+						...active.binding,
+						...mutation.patch,
+						threadId: mutation.threadId
+					});
+					const nativeSubagentSubmissions = active ? preserveCodexNativeSubagentSubmissions(active.binding, binding, active.nativeSubagentSubmissions) : void 0;
+					const nativeSubagentAssignments = active ? preserveNativePendingAssignments(active.binding, binding, active.nativeSubagentAssignments) : void 0;
+					return {
+						result: true,
+						next: {
+							version: 1,
+							state: "active",
+							binding,
+							...nativeSubagentAssignments !== void 0 ? { nativeSubagentAssignments } : {},
+							...nativeSubagentSubmissions !== void 0 ? { nativeSubagentSubmissions } : {},
+							...storedSessionGeneration(identity, current),
+							...preserveNativeTaskImport(current),
+							...ownedLease
+						}
+					};
+				}, (next) => mutation.kind === "clear" && next.nativeSubagentTaskImport === void 0 && !retainLegacyClear && !lifecycle.hasLease(key) ? 1 : void 0, assertCurrent);
+			});
+		},
+		async adoptSessionGeneration(identity, expectedPreviousSessionId, assertCurrent) {
+			return await lifecycle.withMutation(async () => {
+				const key = bindingStoreKey(identity);
+				const expectedSessionId = expectedPreviousSessionId.trim();
+				const targetSessionId = identity.sessionId.trim();
+				if (!expectedSessionId) throw new Error("Codex session generation adoption requires the previous session id");
+				return await lifecycle.transact(key, (current) => {
+					if (current?.state !== "active") return { result: "absent" };
+					if (current.sessionId === targetSessionId) return { result: "current" };
+					if (current.sessionId !== expectedSessionId) return { result: "conflict" };
+					const { nativeSubagentSubmissions, nativeSubagentAssignments: _assignments, ...bindingOwner } = current;
+					const adoptedSubmissions = adoptCodexNativeSubagentSubmissions(nativeSubagentSubmissions);
+					return {
+						result: "adopted",
+						next: {
+							...bindingOwner,
+							sessionId: targetSessionId,
+							...adoptedSubmissions !== void 0 ? { nativeSubagentSubmissions: adoptedSubmissions } : {}
+						}
+					};
+				}, void 0, assertCurrent);
+			});
+		},
+		resetSessionGeneration: (identity) => transitionSessionGeneration(identity, "reset"),
+		retireSessionGeneration: (identity) => transitionSessionGeneration(identity, "retire"),
+		withThreadArchiveFence: lifecycle.withExclusiveMutationFence,
+		async withSessionDeletion(identity, assertCurrent, run) {
+			return await lifecycle.withDeletion(bindingStoreKey(identity), {
+				...prepareLease(identity, {
+					allowRetired: true,
+					assertCurrent
+				}),
+				assertCurrent,
+				assertRecordCurrent(stored) {
+					if (!stored || !ownsStoredSessionGeneration(identity, stored)) throw new Error("Codex binding generation changed before session deletion");
+				}
+			}, (stored, mutation) => run(stored?.state === "active" ? stored.binding : void 0, mutation));
+		},
+		withLease: (identity, run) => lifecycle.withLease(bindingStoreKey(identity), run, prepareLease(identity))
+	};
+}
+function codexSessionGenerationOperations(store, identity) {
+	return {
+		prepareReclaim: () => store.prepareSessionGenerationReclaim(identity),
+		adopt: (expectedPreviousSessionId, assertCurrent) => store.adoptSessionGeneration(identity, expectedPreviousSessionId, assertCurrent),
+		reclaim: (expectedPreviousSessionId, assertCurrent) => store.mutate(identity, {
+			kind: "reclaim-generation",
+			expectedPreviousSessionId
+		}, assertCurrent)
+	};
+}
+function isSameSupervisionOwner(current, replacement) {
+	return replacement.connectionScope === "supervision" && replacement.threadId === current.threadId && replacement.supervisionSourceThreadId === current.supervisionSourceThreadId;
+}
+function storedSessionGeneration(identity, current) {
+	if (identity.kind === "session") return { sessionId: identity.sessionId };
+	return current?.sessionId ? { sessionId: current.sessionId } : {};
+}
+function preservedSessionGeneration(identity, current) {
+	if (current?.sessionId) return { sessionId: current.sessionId };
+	return storedSessionGeneration(identity, current);
+}
+//#endregion
+export { resolveCodexRunSessionBindingAuthority as a, reclaimCurrentCodexSessionGeneration as i, createCodexSessionGenerationSupersededError as n, resolveCodexSessionBinding as o, hashCodexAppServerBindingFingerprint as r, session_binding_exports as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t };