@openclaw/codex 2026.7.1-beta.2 → 2026.7.1-beta.4

package/dist/doctor-contract-api.js

@@ -1,3 +1,396 @@
+import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { listAgentIds, resolveAgentDir, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
+import { isDeepStrictEqual } from "node:util";
+import { listSessionEntries, resolveSessionFilePath, resolveStorePath, updateSessionStoreEntry } from "openclaw/plugin-sdk/session-store-runtime";
+import { withFileLock } from "openclaw/plugin-sdk/file-lock";
+//#region extensions/codex/src/migration/session-binding-sidecars.ts
+const LEGACY_BINDING_SUFFIX = ".codex-app-server.json";
+const CODEX_AGENT_HARNESS_ID = "codex";
+const MAX_SESSION_DIRECTORY_DEPTH = 16;
+const LEGACY_BINDING_LOCK_OPTIONS = {
+	retries: {
+		retries: 75,
+		factor: 1,
+		minTimeout: 1e3,
+		maxTimeout: 1e3
+	},
+	stale: 12e4
+};
+async function collectSessionSurfaces(params) {
+	const surfaces = /* @__PURE__ */ new Map();
+	const stateRoot = await canonicalizePath(params.stateDir);
+	const add = async (root, storePath, agentId, scan) => {
+		const canonicalRoot = await canonicalizePath(root);
+		const surface = surfaces.get(canonicalRoot) ?? {
+			root: canonicalRoot,
+			scan: false,
+			storePaths: /* @__PURE__ */ new Set(),
+			agentIds: /* @__PURE__ */ new Set()
+		};
+		surface.scan ||= scan;
+		surface.storePaths.add(path.resolve(storePath));
+		surface.agentIds.add(agentId);
+		surfaces.set(canonicalRoot, surface);
+	};
+	const agentIds = new Set(listAgentIds(params.config));
+	const agentsDir = path.join(params.stateDir, "agents");
+	for (const entry of await readDirectoryEntries(agentsDir)) {
+		if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+		const agentId = resolveSessionAgentIds({
+			agentId: entry.name,
+			config: params.config
+		}).sessionAgentId;
+		agentIds.add(agentId);
+		const root = path.join(agentsDir, entry.name, "sessions");
+		await add(root, path.join(root, "sessions.json"), agentId, true);
+	}
+	for (const agentId of agentIds) {
+		const storePath = resolveStorePath(params.config.session?.store, {
+			agentId,
+			env: params.env
+		});
+		const root = path.dirname(storePath);
+		await add(root, storePath, agentId, isPathWithin(stateRoot, await canonicalizePath(root)));
+	}
+	const legacyRoot = path.join(params.stateDir, "sessions");
+	const defaultAgentId = resolveSessionAgentIds({ config: params.config }).defaultAgentId;
+	await add(legacyRoot, path.join(legacyRoot, "sessions.json"), defaultAgentId, true);
+	return [...surfaces.values()].toSorted((a, b) => a.root.localeCompare(b.root));
+}
+async function collectLegacyBindingSources(params, options = {}) {
+	const surfaces = await collectSessionSurfaces(params);
+	const sources = /* @__PURE__ */ new Map();
+	const addSource = async (sidecarPath, surface) => {
+		const canonicalSidecar = await canonicalizePath(sidecarPath);
+		const source = sources.get(canonicalSidecar) ?? {
+			sidecarPath: canonicalSidecar,
+			transcriptPath: sidecarPath.slice(0, -22),
+			agentIds: /* @__PURE__ */ new Set()
+		};
+		for (const agentId of surface.agentIds) source.agentIds.add(agentId);
+		sources.set(canonicalSidecar, source);
+		return source;
+	};
+	for (const surface of surfaces) {
+		const sidecars = surface.scan ? walkSidecars(surface.root) : iterateIndexedSidecars(surface, params);
+		for await (const sidecarPath of sidecars) {
+			const source = await addSource(sidecarPath, surface);
+			if (options.firstOnly) return {
+				sources: [source],
+				surfaces
+			};
+		}
+	}
+	return {
+		sources: [...sources.values()].toSorted((a, b) => a.sidecarPath.localeCompare(b.sidecarPath)),
+		surfaces
+	};
+}
+async function* iterateIndexedSidecars(surface, params) {
+	for (const storePath of surface.storePaths) {
+		let entries;
+		try {
+			entries = listSessionEntries({
+				storePath,
+				hydrateSkillPromptRefs: false
+			});
+		} catch {
+			continue;
+		}
+		for (const { sessionKey, entry } of entries) {
+			const sessionId = entry.sessionId?.trim();
+			if (!sessionId) continue;
+			const agentId = resolveLegacyBindingOwnerAgentId({
+				sessionKey,
+				config: params.config,
+				storeAgentIds: surface.agentIds
+			});
+			let transcriptPath;
+			try {
+				transcriptPath = resolveSessionFilePath(sessionId, entry, {
+					sessionsDir: path.dirname(storePath),
+					agentId
+				});
+			} catch {
+				continue;
+			}
+			const sidecarPath = `${transcriptPath}${LEGACY_BINDING_SUFFIX}`;
+			if (await isRegularFile(sidecarPath)) yield sidecarPath;
+		}
+	}
+}
+async function* walkSidecars(root) {
+	const pending = [{
+		directory: root,
+		depth: 0
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		for (const entry of (await readDirectoryEntries(current.directory)).toSorted((a, b) => a.name.localeCompare(b.name))) {
+			if (entry.isSymbolicLink()) continue;
+			const entryPath = path.join(current.directory, entry.name);
+			if (entry.isFile() && entry.name.endsWith(LEGACY_BINDING_SUFFIX)) yield entryPath;
+			else if (entry.isDirectory() && current.depth < MAX_SESSION_DIRECTORY_DEPTH) pending.push({
+				directory: entryPath,
+				depth: current.depth + 1
+			});
+		}
+	}
+}
+async function collectBindingOwners(sources, surfaces, params) {
+	const sourcePaths = new Set(await Promise.all(sources.map((source) => canonicalizePath(source.transcriptPath))));
+	const owners = /* @__PURE__ */ new Map();
+	const storePaths = new Set(surfaces.flatMap((surface) => [...surface.storePaths]));
+	const storeAgentIds = /* @__PURE__ */ new Map();
+	for (const surface of surfaces) for (const storePath of surface.storePaths) {
+		const agents = storeAgentIds.get(storePath) ?? /* @__PURE__ */ new Set();
+		for (const agentId of surface.agentIds) agents.add(agentId);
+		storeAgentIds.set(storePath, agents);
+	}
+	for (const storePath of storePaths) {
+		let entries;
+		try {
+			entries = listSessionEntries({
+				storePath,
+				hydrateSkillPromptRefs: false
+			});
+		} catch {
+			continue;
+		}
+		const sessionsDir = path.dirname(storePath);
+		for (const { sessionKey, entry } of entries) {
+			const sessionId = entry.sessionId?.trim();
+			if (!sessionId) continue;
+			const agentId = resolveLegacyBindingOwnerAgentId({
+				sessionKey,
+				config: params.config,
+				storeAgentIds: storeAgentIds.get(storePath)
+			});
+			let transcriptPath;
+			let legacyTranscriptPath;
+			try {
+				legacyTranscriptPath = resolveLegacySessionFileLocator(sessionsDir, entry, sessionId);
+				transcriptPath = await canonicalizePath(resolveSessionFilePath(sessionId, entry, {
+					sessionsDir,
+					agentId
+				}));
+			} catch {
+				continue;
+			}
+			if (!sourcePaths.has(transcriptPath)) continue;
+			const owner = {
+				agentId,
+				sessionId,
+				sessionKey,
+				storePath,
+				transcriptPath: legacyTranscriptPath,
+				...entry.agentHarnessId?.trim() ? { agentHarnessId: entry.agentHarnessId.trim() } : {}
+			};
+			const candidates = owners.get(transcriptPath) ?? /* @__PURE__ */ new Map();
+			candidates.set(`${agentId}\0${sessionId}\0${sessionKey}\0${storePath}`, owner);
+			owners.set(transcriptPath, candidates);
+		}
+	}
+	return new Map([...owners].map(([key, values]) => [key, [...values.values()]]));
+}
+function resolveLegacySessionFileLocator(sessionsDir, entry, sessionId) {
+	const sessionFile = entry.sessionFile?.trim();
+	return path.resolve(sessionsDir, sessionFile || `${sessionId}.jsonl`);
+}
+function resolveLegacyBindingOwnerAgentId(params) {
+	if (params.sessionKey.trim().toLowerCase().startsWith("agent:")) return resolveSessionAgentIds({
+		sessionKey: params.sessionKey,
+		config: params.config
+	}).sessionAgentId;
+	const storeAgentId = params.storeAgentIds?.size === 1 ? [...params.storeAgentIds][0] : void 0;
+	return resolveSessionAgentIds({
+		sessionKey: params.sessionKey,
+		config: params.config,
+		...storeAgentId ? { agentId: storeAgentId } : {}
+	}).sessionAgentId;
+}
+function copyBindingForSession(stored, sessionId) {
+	return stored.state === "active" ? {
+		version: 1,
+		state: "active",
+		binding: stored.binding,
+		sessionId
+	} : {
+		version: 1,
+		state: "cleared",
+		sessionId,
+		...stored.retired ? { retired: true } : {}
+	};
+}
+async function migrateSource(source, owner, params, store) {
+	let importedKeys = 0;
+	const retain = (reason) => ({
+		archived: false,
+		importedKeys,
+		warning: `Left Codex binding sidecar in place because ${reason}: ${source.sidecarPath}`
+	});
+	try {
+		return await withFileLock(source.sidecarPath, LEGACY_BINDING_LOCK_OPTIONS, async () => {
+			const [contents, stat] = await Promise.all([fs.readFile(source.sidecarPath, "utf8"), fs.stat(source.sidecarPath)]);
+			const raw = JSON.parse(contents);
+			const [{ bindingStoreKey, createStoredCodexAppServerBinding, readCodexAppServerThreadBinding }, { legacyCodexConversationBindingId }] = await Promise.all([import("./session-binding-Dc03iwRF.js").then((n) => n.s), import("./conversation-binding-data-BHRpYbX3.js").then((n) => n.t)]);
+			const agentId = owner?.agentId ?? (source.agentIds.size === 1 ? [...source.agentIds][0] : void 0);
+			const baseStored = createStoredCodexAppServerBinding(raw, {
+				now: stat.mtime.toISOString(),
+				lookup: {
+					config: params.config,
+					...agentId ? { agentDir: resolveAgentDir(params.config, agentId, params.env) } : {}
+				}
+			});
+			if (!baseStored) return retain("its binding is invalid");
+			if (owner?.agentHarnessId && owner.agentHarnessId !== CODEX_AGENT_HARNESS_ID) return retain(`its session is owned by agent harness ${owner.agentHarnessId}`);
+			const sourceSessionFile = typeof raw.sessionFile === "string" && raw.sessionFile.trim() ? raw.sessionFile : source.transcriptPath;
+			const ownerSessionFile = typeof raw.sessionFile === "string" && raw.sessionFile.trim() ? raw.sessionFile : owner?.transcriptPath;
+			const conversationKeys = [sourceSessionFile, ...ownerSessionFile && ownerSessionFile !== sourceSessionFile ? [ownerSessionFile] : []].map((sessionFile) => bindingStoreKey({
+				kind: "conversation",
+				bindingId: legacyCodexConversationBindingId(sessionFile)
+			}));
+			let currentConversation;
+			for (const key of conversationKeys) currentConversation ??= await store.lookup(key);
+			const stored = currentConversation ?? baseStored;
+			if (stored.state !== "active" && stored.state !== "cleared") return retain(`canonical plugin state changed at ${conversationKeys[0]}`);
+			const sessionKey = owner ? bindingStoreKey({
+				kind: "session",
+				agentId: owner.agentId,
+				sessionId: owner.sessionId,
+				sessionKey: owner.sessionKey
+			}) : void 0;
+			const entries = [...conversationKeys.map((key) => ({
+				key,
+				value: stored
+			})), ...owner && sessionKey ? [{
+				key: sessionKey,
+				value: copyBindingForSession(stored, owner.sessionId)
+			}] : []];
+			const hasExpected = (value, expected) => expected.state === "cleared" ? value?.state === "cleared" && value.sessionId === expected.sessionId && value.retired === expected.retired : value?.state === "active" && value.sessionId === expected.sessionId && isDeepStrictEqual(readCodexAppServerThreadBinding(value.binding), expected.binding);
+			for (const entry of entries) {
+				const current = await store.lookup(entry.key);
+				if (current !== void 0 && !hasExpected(current, entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+			}
+			for (const entry of entries) {
+				if (await store.registerIfAbsent(entry.key, entry.value)) importedKeys++;
+				if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+			}
+			if (!owner) return {
+				archived: false,
+				importedKeys,
+				warning: `Left Codex binding sidecar in place after importing its conversation binding because its session owner could not be resolved: ${source.sidecarPath}`
+			};
+			const ownershipWarning = await recordSessionOwner(owner);
+			if (ownershipWarning) return retain(ownershipWarning);
+			for (const entry of entries) if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+			const archivePath = `${source.sidecarPath}.migrated`;
+			if (await pathExists(archivePath)) return retain(`its archive already exists at ${archivePath}`);
+			await fs.rename(source.sidecarPath, archivePath);
+			return {
+				archived: true,
+				importedKeys
+			};
+		});
+	} catch (error) {
+		return retain(`migration or archiving failed: ${String(error)}`);
+	}
+}
+async function recordSessionOwner(owner) {
+	const updated = await updateSessionStoreEntry({
+		storePath: owner.storePath,
+		sessionKey: owner.sessionKey,
+		skipMaintenance: true,
+		requireWriteSuccess: true,
+		update: (entry) => {
+			if (entry.sessionId.trim() !== owner.sessionId) return null;
+			return entry.agentHarnessId?.trim() ? null : { agentHarnessId: CODEX_AGENT_HARNESS_ID };
+		}
+	});
+	if (!updated || updated.sessionId.trim() !== owner.sessionId) return "its session owner changed before Codex ownership could be recorded";
+	const harnessId = updated.agentHarnessId?.trim();
+	return harnessId === CODEX_AGENT_HARNESS_ID ? void 0 : harnessId ? `its session is owned by agent harness ${harnessId}` : "Codex harness ownership could not be recorded on its session";
+}
+async function readDirectoryEntries(directory) {
+	try {
+		return await fs.readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if ([
+			"EACCES",
+			"ENOENT",
+			"ENOTDIR",
+			"EPERM"
+		].includes(error.code ?? "")) return [];
+		throw error;
+	}
+}
+async function isRegularFile(filePath) {
+	try {
+		return (await fs.stat(filePath)).isFile();
+	} catch {
+		return false;
+	}
+}
+function isPathWithin(root, candidate) {
+	const relative = path.relative(root, candidate);
+	return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+async function canonicalizePath(filePath) {
+	try {
+		return await fs.realpath(filePath);
+	} catch {
+		return path.resolve(filePath);
+	}
+}
+async function pathExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const stateMigrations = [{
+	id: "codex-app-server-sidecars-to-plugin-state",
+	label: "Codex app-server thread bindings",
+	async detectLegacyState(params) {
+		const { sources } = await collectLegacyBindingSources(params, { firstOnly: true });
+		return sources.length > 0 ? { preview: [`- Codex app-server bindings: legacy sidecar -> plugin state (${CODEX_APP_SERVER_BINDING_NAMESPACE})`] } : null;
+	},
+	async migrateLegacyState(params) {
+		const changes = [];
+		const warnings = [];
+		const { sources, surfaces } = await collectLegacyBindingSources(params);
+		if (sources.length === 0) return {
+			changes,
+			warnings
+		};
+		const owners = await collectBindingOwners(sources, surfaces, params);
+		const store = params.context.openPluginStateKeyedStore({
+			namespace: CODEX_APP_SERVER_BINDING_NAMESPACE,
+			maxEntries: CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
+			overflowPolicy: "reject-new"
+		});
+		let migrated = 0;
+		let partialImports = 0;
+		for (const source of sources) {
+			const candidates = owners.get(await canonicalizePath(source.transcriptPath)) ?? [];
+			const result = await migrateSource(source, candidates.length === 1 ? candidates[0] : void 0, params, store);
+			if (result.warning) warnings.push(result.warning);
+			if (result.archived) migrated++;
+			else partialImports += result.importedKeys;
+		}
+		if (migrated > 0) changes.push(`Migrated ${migrated} Codex app-server binding sidecar(s) to plugin state and archived the legacy sources`);
+		if (partialImports > 0) changes.push(`Migrated ${partialImports} safe Codex app-server binding row(s) to plugin state; retained legacy sidecars needing review`);
+		return {
+			changes,
+			warnings
+		};
+	}
+}];
+//#endregion
 //#region extensions/codex/doctor-contract-api.ts
 function asRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -12,36 +405,55 @@ function hasLegacyPluginDestructivePolicy(value) {
 	const plugins = asRecord(codexPlugins.plugins);
 	return Object.values(plugins ?? {}).some((plugin) => asRecord(plugin)?.allow_destructive_actions === "on-request");
 }
+function hasRetiredOnFailureApprovalPolicy(value) {
+	return asRecord(value)?.approvalPolicy === "on-failure";
+}
 /** Legacy Codex config keys that doctor should report or repair. */
-const legacyConfigRules = [{
-	path: [
-		"plugins",
-		"entries",
-		"codex",
-		"config"
-	],
-	message: "plugins.entries.codex.config.codexDynamicToolsProfile is retired; Codex app-server always keeps Codex-native workspace tools native. Run \"openclaw doctor --fix\".",
-	match: hasRetiredDynamicToolsProfile
-}, {
-	path: [
-		"plugins",
-		"entries",
-		"codex",
-		"config",
-		"codexPlugins"
-	],
-	message: "plugins.entries.codex.config.codexPlugins.allow_destructive_actions=\"on-request\" was renamed to \"auto\". Run \"openclaw doctor --fix\".",
-	match: hasLegacyPluginDestructivePolicy
-}];
+const legacyConfigRules = [
+	{
+		path: [
+			"plugins",
+			"entries",
+			"codex",
+			"config"
+		],
+		message: "plugins.entries.codex.config.codexDynamicToolsProfile is retired; Codex app-server always keeps Codex-native workspace tools native. Run \"openclaw doctor --fix\".",
+		match: hasRetiredDynamicToolsProfile
+	},
+	{
+		path: [
+			"plugins",
+			"entries",
+			"codex",
+			"config",
+			"codexPlugins"
+		],
+		message: "plugins.entries.codex.config.codexPlugins.allow_destructive_actions=\"on-request\" was renamed to \"auto\". Run \"openclaw doctor --fix\".",
+		match: hasLegacyPluginDestructivePolicy
+	},
+	{
+		path: [
+			"plugins",
+			"entries",
+			"codex",
+			"config",
+			"appServer"
+		],
+		message: "plugins.entries.codex.config.appServer.approvalPolicy=\"on-failure\" was retired by Codex 0.143; use \"on-request\". Run \"openclaw doctor --fix\".",
+		match: hasRetiredOnFailureApprovalPolicy
+	}
+];
 /**
 * Removes retired Codex plugin config keys while preserving unrelated config.
 */
 function normalizeCompatibilityConfig({ cfg }) {
 	const rawPluginConfig = asRecord(asRecord(cfg.plugins?.entries?.codex)?.config);
 	const rawCodexPlugins = asRecord(rawPluginConfig?.codexPlugins);
+	const rawAppServer = asRecord(rawPluginConfig?.appServer);
 	const shouldRemoveDynamicToolsProfile = rawPluginConfig !== null && hasRetiredDynamicToolsProfile(rawPluginConfig);
 	const shouldRewriteDestructivePolicy = hasLegacyPluginDestructivePolicy(rawCodexPlugins);
-	if (!rawPluginConfig || !shouldRemoveDynamicToolsProfile && !shouldRewriteDestructivePolicy) return {
+	const shouldRewriteApprovalPolicy = hasRetiredOnFailureApprovalPolicy(rawAppServer);
+	if (!rawPluginConfig || !shouldRemoveDynamicToolsProfile && !shouldRewriteDestructivePolicy && !shouldRewriteApprovalPolicy) return {
 		config: cfg,
 		changes: []
 	};
@@ -66,6 +478,11 @@ function normalizeCompatibilityConfig({ cfg }) {
 		}
 		changes.push("Renamed plugins.entries.codex.config.codexPlugins allow_destructive_actions=\"on-request\" values to \"auto\".");
 	}
+	if (shouldRewriteApprovalPolicy) {
+		const nextAppServer = asRecord(nextPluginConfig.appServer);
+		if (nextAppServer?.approvalPolicy === "on-failure") nextAppServer.approvalPolicy = "on-request";
+		changes.push("Renamed plugins.entries.codex.config.appServer.approvalPolicy=\"on-failure\" to \"on-request\".");
+	}
 	return {
 		config: nextConfig,
 		changes
@@ -89,4 +506,4 @@ const sessionRouteStateOwners = [{
 	]
 }];
 //#endregion
-export { legacyConfigRules, normalizeCompatibilityConfig, sessionRouteStateOwners };
+export { legacyConfigRules, normalizeCompatibilityConfig, sessionRouteStateOwners, stateMigrations };

package/dist/harness.js

@@ -1,5 +1,5 @@
 //#region extensions/codex/harness.ts
-const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = new Set(["codex", "openai"]);
+const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = /* @__PURE__ */ new Set(["codex", "openai"]);
 const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
 	"bootstrap",
 	"assemble-before-prompt",
@@ -32,38 +32,57 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-DikbXia_.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-8SPLiDlT.js");
 			return runCodexAppServerAttempt(params, {
+				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				nativeHookRelay: { enabled: true }
 			});
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-Ca9wqmd0.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-DkjXvYv7.js");
 			return runCodexAppServerSideQuestion(params, {
+				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				nativeHookRelay: { enabled: true }
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-CILptrPS.js");
-			return maybeCompactCodexAppServerSession(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+			const { maybeCompactCodexAppServerSession } = await import("./compact-CZzbcygx.js");
+			return maybeCompactCodexAppServerSession(params, {
+				bindingStore: options.bindingStore,
+				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
+			});
 		},
 		compactAfterContextEngine: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-CILptrPS.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-CZzbcygx.js");
 			return maybeCompactCodexAppServerSession(params, {
+				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				allowNonManualNativeRequest: true
 			});
 		},
 		reset: async (params) => {
-			if (params.sessionFile) {
-				const { clearCodexAppServerBinding } = await import("./session-binding-Cm0Gg7Z1.js").then((n) => n.s);
-				await clearCodexAppServerBinding(params.sessionFile);
+			if (params.sessionId) {
+				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-Dc03iwRF.js").then((n) => n.s);
+				const identity = sessionBindingIdentity({
+					agentId: params.agentId,
+					sessionId: params.sessionId,
+					sessionKey: params.sessionKey
+				});
+				let retired = await options.bindingStore.retireSessionGeneration(identity);
+				if (retired === "conflict") {
+					if (await reclaimCurrentCodexSessionGeneration({
+						bindingStore: options.bindingStore,
+						identity,
+						config: options.resolveConfig?.()
+					})) retired = await options.bindingStore.retireSessionGeneration(identity);
+				}
+				if (retired === "conflict") throw new Error(`Codex binding generation changed before session ${params.sessionId} could reset`);
 			}
 		},
 		dispose: async () => {
-			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-rR6TDJA3.js").then((n) => n.c);
+			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-4ICy3U6d.js").then((n) => n.c);
 			await clearSharedCodexAppServerClientAndWait();
 		}
 	};