@openclaw/codex 2026.9.1 → 2026.9.2

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

@@ -1,9 +1,9 @@
-import { i as resolvePackagedCodexNativeCommand } from "./managed-binary-4-Vjz5GH.js";
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-CyPldczm.js";
+import { i as resolvePackagedCodexNativeCommand } from "./managed-binary-DcpnJF9x.js";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-CzTngV0j.js";
+import { createHash } from "node:crypto";
 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";
 //#region extensions/codex/src/app-server/runtime-artifact.ts

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

@@ -1,15 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { P as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN, j as normalizeCodexServiceTier } from "./config-BhmfC1s6.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 { 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 { 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";
 //#region extensions/codex/src/app-server/session-binding.ts
 /** SQLite-backed Codex app-server thread bindings. */
 var session_binding_exports = /* @__PURE__ */ __exportAll({
@@ -30,6 +28,7 @@ var session_binding_exports = /* @__PURE__ */ __exportAll({
 	readStoredCodexAppServerBinding: () => readStoredCodexAppServerBinding,
 	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
 	resolveCodexRunSessionBindingAuthority: () => resolveCodexRunSessionBindingAuthority,
+	resolveCodexSessionBinding: () => resolveCodexSessionBinding,
 	scopeCodexRunBindingStore: () => scopeCodexRunBindingStore,
 	sessionBindingIdentity: () => sessionBindingIdentity,
 	validateBindingForWrite: () => validateBindingForWrite
@@ -43,221 +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 } = resolveSessionAgentIdsStrict(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(),
-	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",
-		"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")}`;
 }
@@ -292,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,
@@ -324,7 +154,7 @@ function scopeCodexRunBindingStore(params) {
 		hasOtherThreadOwner: (threadId, identity) => params.bindingStore.hasOtherThreadOwner(threadId, identity ? mapIdentity(identity) : void 0),
 		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),
@@ -332,30 +162,62 @@ function scopeCodexRunBindingStore(params) {
 		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;
+async function reclaimPreparedCodexSessionGeneration(params, authority, assertCurrent = authority[3]) {
 	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
-	params.assertCurrent?.();
+	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
-	}, params.assertCurrent);
+	}, 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) {
@@ -562,13 +424,7 @@ function createCodexAppServerBindingStore(state) {
 		});
 	};
 	return {
-		async read(identity) {
-			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;
-		},
+		read: (identity) => readCurrentCodexAppServerBinding(state, identity),
 		async hasOtherThreadOwner(threadId, currentIdentity) {
 			const currentKey = currentIdentity ? bindingStoreKey(currentIdentity) : void 0;
 			return state.entries().some(({ key, value }) => {
@@ -685,7 +541,7 @@ function createCodexAppServerBindingStore(state) {
 				}, 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();
@@ -702,7 +558,7 @@ function createCodexAppServerBindingStore(state) {
 							sessionId: targetSessionId
 						}
 					};
-				});
+				}, void 0, assertCurrent);
 			});
 		},
 		resetSessionGeneration: (identity) => transitionSessionGeneration(identity, "reset"),
@@ -742,7 +598,8 @@ function createCodexAppServerBindingStore(state) {
 				}
 				return await withBindingLease(identity, async () => {
 					const owner = leaseContext.getStore().get(key);
-					const stored = readStoredCodexAppServerBinding(state.lookup(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;
@@ -800,26 +657,6 @@ function matchesPendingSupervisionBranch(binding, expected) {
 function isSameSupervisionOwner(current, replacement) {
 	return replacement.connectionScope === "supervision" && replacement.threadId === current.threadId && replacement.supervisionSourceThreadId === current.supervisionSourceThreadId;
 }
-/** 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 = 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}`;
-	}
-	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 } : {};
@@ -828,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;
@@ -942,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, validateBindingForWrite as p, 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 };