@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/.setup/run-attempt-lifecycle-B7JbY4-F.mjs

@@ -0,0 +1,71 @@
+import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { awaitAgentEndSideEffects, embeddedAgentLog, emitAgentEvent, runAgentEndSideEffects } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/workspace-dir-cache.ts
+/** Process-local cache of Codex workspaces already created by the run loop. */
+const codexWorkspaceDirCache = /* @__PURE__ */ new Set();
+//#endregion
+//#region extensions/codex/src/app-server/run-attempt-lifecycle.ts
+const CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN = 4;
+function shouldKeepCodexSharedAbortOpen(params) {
+	const terminal = attemptTerminal.project(params.result.terminal);
+	if (params.explicitCancellationObserved || terminal.aborted || terminal.externalAbort) return false;
+	return params.trigger === "memory" || !params.attemptSucceeded;
+}
+function withCodexAppServerFastModeServiceTier(appServer, params) {
+	const fastMode = typeof params.fastMode === "function" ? params.fastMode() : params.fastMode;
+	const serviceTier = fastMode === void 0 ? appServer.serviceTier : fastMode ? "priority" : void 0;
+	if (serviceTier === appServer.serviceTier) return appServer;
+	if (serviceTier) return {
+		...appServer,
+		serviceTier
+	};
+	return {
+		...appServer,
+		serviceTier: null
+	};
+}
+function estimateCodexAppServerProjectedTurnTokens(params) {
+	const inputChars = params.prompt.length + (params.developerInstructions?.length ?? 0);
+	return Math.max(1, Math.ceil(inputChars / CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN));
+}
+async function ensureCodexWorkspaceDirOnce(workspaceDir) {
+	const normalized = path.resolve(workspaceDir);
+	if (codexWorkspaceDirCache.has(normalized)) return;
+	await fs.mkdir(normalized, { recursive: true });
+	codexWorkspaceDirCache.add(normalized);
+}
+async function emitCodexAppServerEvent(params, event) {
+	try {
+		emitAgentEvent({
+			runId: params.runId,
+			stream: event.stream,
+			data: event.data,
+			...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+		});
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
+	}
+	try {
+		await params.onAgentEvent?.(event);
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
+	}
+}
+async function runCodexAgentEndHook(params, hookParams) {
+	const sideEffectParams = {
+		...hookParams,
+		ctx: {
+			...hookParams.ctx,
+			config: params.config
+		}
+	};
+	if (!params.messageChannel && !params.messageProvider) {
+		await awaitAgentEndSideEffects(sideEffectParams);
+		return;
+	}
+	runAgentEndSideEffects(sideEffectParams);
+}
+//#endregion
+export { shouldKeepCodexSharedAbortOpen as a, runCodexAgentEndHook as i, ensureCodexWorkspaceDirOnce as n, withCodexAppServerFastModeServiceTier as o, estimateCodexAppServerProjectedTurnTokens as r, emitCodexAppServerEvent as t };

package/dist/{runtime-artifact-BJ0rXBZ_.js → .setup/runtime-artifact-CLZ8udh-.mjs}

@@ -1,11 +1,12 @@
-import { a as resolvePackagedCodexNativeCommand } from "./managed-binary-D22rNEcR.js";
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-BGjHoYLr.js";
+import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
+import { a as resolvePackagedCodexNativeCommand } from "./managed-binary-BnshlFag.mjs";
+import { n as resolveCodexAppServerSpawnEnv, r as resolveCodexAppServerSpawnInvocation } from "./transport-stdio-h2VHOskC.mjs";
 import { createHash } from "node:crypto";
-import { resolveWindowsExecutablePath, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
+import { resolveWindowsExecutablePath } from "openclaw/plugin-sdk/windows-spawn";
 import { constants } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
-import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
+import { isPathInside, sha256File } from "openclaw/plugin-sdk/file-access-runtime";
 //#region extensions/codex/src/app-server/runtime-artifact.ts
 /** Exact local runtime artifact identity for verified Codex setup turns. */
 const ARTIFACT_ID_PREFIX = "codex-app-server:v1:";
@@ -17,8 +18,6 @@ const MAX_ARTIFACT_DEPTH = 64;
 const MAX_ARTIFACT_ENTRIES = 32768;
 const MAX_ARTIFACT_FILES = 8192;
 const MAX_ARTIFACT_TOTAL_BYTES = 1024n * 1024n * 1024n;
-const READ_CHUNK_BYTES = 65536;
-const CODE_MODE_HOST_PATH_ENV = "CODEX_CODE_MODE_HOST_PATH";
 const SAFE_NODE_OPTIONS_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
 	"--enable-network-family-autoselection",
 	"--network-family-autoselection",
@@ -74,24 +73,17 @@ async function readRegularFileFingerprint(params) {
 		if (!before.isFile()) throw new Error(`Codex runtime artifact contains a non-regular file: ${params.filePath}`);
 		if (params.budget.fileCount + 1 > MAX_ARTIFACT_FILES) throw new Error("Codex runtime artifact exceeds the bounded file count");
 		if (params.budget.totalBytes + before.size > MAX_ARTIFACT_TOTAL_BYTES) throw new Error("Codex runtime artifact exceeds the bounded content size");
-		const hash = createHash("sha256");
-		const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
-		let offset = 0n;
-		while (offset < before.size) {
-			throwIfAborted(params.signal);
-			const length = Number(before.size - offset < BigInt(buffer.length) ? before.size - offset : BigInt(buffer.length));
-			const { bytesRead } = await handle.read(buffer, 0, length, Number(offset));
-			if (bytesRead === 0) throw new Error(`Codex runtime artifact changed while reading: ${params.filePath}`);
-			hash.update(buffer.subarray(0, bytesRead));
-			offset += BigInt(bytesRead);
-		}
+		const hash = await sha256File(handle, {
+			maxBytes: Number(before.size),
+			signal: params.signal
+		});
 		const after = await handle.stat({ bigint: true });
 		const current = await fs$1.stat(params.filePath, { bigint: true });
-		if (!sameOpenedFile(before, after) || !sameOpenedFile(after, current)) throw new Error(`Codex runtime artifact changed while reading: ${params.filePath}`);
+		if (BigInt(hash.bytes) !== before.size || !sameOpenedFile(before, after) || !sameOpenedFile(after, current)) throw new Error(`Codex runtime artifact changed while reading: ${params.filePath}`);
 		params.budget.fileCount += 1;
 		params.budget.totalBytes += after.size;
 		return {
-			contentHash: hash.digest("hex"),
+			contentHash: hash.digest,
 			mode: String(after.mode),
 			size: String(after.size)
 		};
@@ -351,38 +343,29 @@ async function resolveOptionalRegularFile(filePath) {
 function isMissingPathError(error) {
 	return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
-function readEffectiveSpawnEnvironmentValue(env, name) {
-	if (process.platform !== "win32") return env[name];
-	const effectiveKey = Object.keys(env).toSorted(compareArtifactNames).find((key) => key.toUpperCase() === name.toUpperCase());
-	return effectiveKey ? env[effectiveKey] : void 0;
-}
 async function captureFilesystemDescriptor(params) {
 	throwIfAborted(params.signal);
 	if (params.startOptions.transport !== "stdio") throw new Error("Verified Codex inference requires a local stdio runtime artifact; WebSocket attestation is unsupported");
+	if (isCodexAppServerProxyLaunch(params.startOptions.args)) throw new Error("Verified Codex inference requires a local runtime artifact; app-server proxy attestation is unsupported");
 	const env = resolveCodexAppServerSpawnEnv(params.startOptions);
 	assertSafeNodeOptions(env);
+	const invocation = resolveCodexAppServerSpawnInvocation(params.startOptions, env);
 	const spawnCwd = path.resolve(params.startOptions.cwd ?? process.cwd());
 	const commandPath = await resolveCommandPath(params.startOptions.command, env, spawnCwd);
 	const commandRealPath = await fs$1.realpath(commandPath);
 	let nativeCommand = params.spawnIdentity.nativeCommand;
-	let nativeCandidate = commandRealPath;
 	let invocationPaths;
-	if (process.platform === "win32") {
-		const program = resolveWindowsSpawnProgram({
-			command: params.startOptions.command,
-			platform: process.platform,
-			env,
-			execPath: process.execPath,
-			packageName: "@openai/codex"
-		});
-		const entrypoint = program.leadingArgv[0];
-		if (program.resolution === "node-entrypoint" && entrypoint && !nativeCommand) nativeCommand = resolvePackagedCodexNativeCommand(await fs$1.realpath(entrypoint));
-		if (program.resolution === "node-entrypoint" && !nativeCommand) throw new Error("Codex runtime cannot attest a custom Node launcher without its native target");
-		nativeCandidate = program.command;
+	if (process.platform === "win32" || invocation.resolution === "node-entrypoint") {
+		const entrypoint = invocation.resolution === "node-entrypoint" ? invocation.argv[0] : void 0;
+		if (entrypoint && !nativeCommand) {
+			const entrypointPath = await resolveCommandPath(entrypoint, env, spawnCwd);
+			nativeCommand = resolvePackagedCodexNativeCommand(await fs$1.realpath(entrypointPath));
+		}
+		if (invocation.resolution === "node-entrypoint" && !nativeCommand) throw new Error("Codex runtime cannot attest a custom Node launcher without its native target");
 		const invocationCandidates = [
 			commandRealPath,
-			program.command,
-			...program.leadingArgv
+			invocation.command,
+			...entrypoint ? [entrypoint] : []
 		];
 		invocationPaths = [];
 		for (const candidate of invocationCandidates) {
@@ -400,13 +383,10 @@ async function captureFilesystemDescriptor(params) {
 	}
 	invocationPaths = [...new Set(invocationPaths)].toSorted(compareArtifactNames);
 	if (invocationPaths.length > MAX_ARTIFACT_INVOCATION_PATHS) throw new Error("Codex runtime launcher exceeds the bounded invocation file count");
-	const nativePath = await fs$1.realpath(await resolveCommandPath(nativeCommand ?? nativeCandidate, env, spawnCwd));
+	const nativePath = await fs$1.realpath(await resolveCommandPath(nativeCommand ?? invocation.command, env, spawnCwd));
 	const packageRoot = await resolvePackageRoot(nativePath);
-	const configuredCodeModeHost = readEffectiveSpawnEnvironmentValue(env, CODE_MODE_HOST_PATH_ENV)?.trim();
-	const adjacentCodeModeHost = path.join(path.dirname(nativePath), process.platform === "win32" ? "codex-code-mode-host.exe" : "codex-code-mode-host");
-	const codeModeHostCandidatePath = configuredCodeModeHost ? path.isAbsolute(configuredCodeModeHost) ? configuredCodeModeHost : path.resolve(spawnCwd, configuredCodeModeHost) : adjacentCodeModeHost;
+	const codeModeHostCandidatePath = path.join(path.dirname(nativePath), process.platform === "win32" ? "codex-code-mode-host.exe" : "codex-code-mode-host");
 	const codeModeHostPath = await resolveOptionalRegularFile(codeModeHostCandidatePath);
-	if (configuredCodeModeHost && !codeModeHostPath) throw new Error("Configured Codex code-mode host runtime artifact is unavailable");
 	const descriptor = {
 		version: 1,
 		commandPath,
@@ -438,7 +418,11 @@ function validateFilesystemDescriptorShape(descriptor) {
 		"config",
 		"env"
 	].includes(descriptor.commandSource)) throw new Error("Invalid Codex runtime command source");
-	if (descriptor.managedCommandOrder !== void 0 && descriptor.managedCommandOrder !== "package-first" && descriptor.managedCommandOrder !== "desktop-first") throw new Error("Invalid Codex managed command order");
+	if (descriptor.managedCommandOrder !== void 0 && ![
+		"package-first",
+		"package-only",
+		"desktop-first"
+	].includes(descriptor.managedCommandOrder)) throw new Error("Invalid Codex managed command order");
 	if (descriptor.managedCommandOrder !== void 0 && descriptor.commandSource !== "resolved-managed") throw new Error("Invalid Codex managed runtime descriptor");
 	const canonicalInvocationPaths = [...new Set(descriptor.invocationPaths)].toSorted(compareArtifactNames);
 	if (canonicalInvocationPaths.length !== descriptor.invocationPaths.length || canonicalInvocationPaths.some((entry, index) => entry !== descriptor.invocationPaths[index])) throw new Error("Invalid Codex runtime invocation descriptor");

package/dist/{sandbox-guard-BxgyoM8M.js → .setup/sandbox-guard-C2sRMOEY.mjs}

@@ -1,6 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { y as isCodexRemoteExecPlacementSandbox } from "./protocol-5bh1G-H7.js";
-import { n as resolveCodexNativeExecutionPolicy, t as formatCodexNativeNodeExecBlock } from "./native-execution-policy-umd0tgh4.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { l as isCodexRemoteExecPlacementSandbox } from "./config-parsing-CcB9iPoq.mjs";
+import { n as resolveCodexNativeExecutionPolicy, t as formatCodexNativeNodeExecBlock } from "./native-execution-policy-umd0tgh4.mjs";
 import { tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveSandboxRuntimeStatus } from "openclaw/plugin-sdk/sandbox";

package/dist/{session-binding-CI8UuilT.js → .setup/session-binding-Cm0apEbd.mjs}

@@ -1,14 +1,13 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { m as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-utils-DujwEnhg.js";
-import { a as readCodexAppServerThreadBinding, c as readStoredCodexAppServerBinding, d as validateBindingForWrite, i as ownsStoredSessionGeneration, l as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, o as readCodexBindingTimestamp, r as bindingStoreKey, s as readCurrentCodexAppServerBinding, t as CodexSupervisionBindingReplacementError, u as stripUndefinedBinding } from "./session-binding-record-Bcvslnhf.js";
-import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
-import { n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-CwzO4_RG.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { _ as adoptCodexNativeSubagentSubmissions, a as ownsStoredSessionGeneration, c as readCodexBindingTimestamp, d as readCurrentCodexNativeSubagentSubmissions, f as readPluginAppPolicyContext, g as validateBindingForWrite, h as stripUndefinedBinding, i as matchesCodexNativeSubagentSubmissionBinding, l as readCurrentCodexAppServerBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, o as preserveCodexNativeSubagentSubmissions, p as readStoredCodexAppServerBinding, r as bindingStoreKey, s as readCodexAppServerThreadBinding, t as CodexSupervisionBindingReplacementError, u as readCurrentCodexAppServerBindings, v as mutateCodexNativeSubagentSubmissions } from "./session-binding-record-BGoz8wOK.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-WqZtZfXN.mjs";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import { AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { isDeepStrictEqual } from "node:util";
-import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+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,7 +27,6 @@ var session_binding_exports = /* @__PURE__ */ __exportAll({
 	reclaimCurrentCodexSessionGeneration: () => reclaimCurrentCodexSessionGeneration,
 	resolveCodexRunSessionBindingAuthority: () => resolveCodexRunSessionBindingAuthority,
 	resolveCodexSessionBinding: () => resolveCodexSessionBinding,
-	scopeCodexRunBindingStore: () => scopeCodexRunBindingStore,
 	sessionBindingIdentity: () => sessionBindingIdentity,
 	validateBindingForWrite: () => validateBindingForWrite
 });
@@ -155,24 +153,6 @@ function createStoredCodexAppServerBinding(value, options = {}) {
 function bindingLeaseLostError(key, cause) {
 	return new Error(`Lost Codex binding lease: ${key}`, cause === void 0 ? void 0 : { cause });
 }
-/** Carries one prepared run identity through callers that rederive it from public params. */
-function scopeCodexRunBindingStore(params) {
-	const mapSessionIdentity = (identity) => identity.agentId === params.logicalIdentity.agentId && identity.sessionId === params.logicalIdentity.sessionId && identity.sessionKey?.trim() === params.logicalIdentity.sessionKey?.trim() ? params.physicalIdentity : identity;
-	const mapIdentity = (identity) => identity.kind === "session" ? mapSessionIdentity(identity) : identity;
-	return {
-		...params.bindingStore,
-		read: (identity) => params.bindingStore.read(mapIdentity(identity)),
-		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, 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)
-	};
-}
 async function reclaimPreparedCodexSessionGeneration(params, authority, assertCurrent = authority[3]) {
 	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
 	assertCurrent();
@@ -436,6 +416,8 @@ function createCodexAppServerBindingStore(state) {
 	};
 	return {
 		read: (identity) => readCurrentCodexAppServerBinding(state, identity),
+		...state.lookupMany ? { readMany: (identities) => readCurrentCodexAppServerBindings(state, identities) } : {},
+		readNativeSubagentSubmissions: (identity, owner) => readCurrentCodexNativeSubagentSubmissions(state, identity, owner),
 		async hasOtherThreadOwner(threadId, currentIdentity) {
 			const currentKey = currentIdentity ? bindingStoreKey(currentIdentity) : void 0;
 			return state.entries().some(({ key, value }) => {
@@ -477,6 +459,26 @@ function createCodexAppServerBindingStore(state) {
 				const key = bindingStoreKey(identity);
 				const retainLegacyClear = mutation.kind === "clear" && key.startsWith("conversation:legacy-");
 				return await transactKey(key, (current, leaseToken) => {
+					if (mutation.kind === "record-native-subagent-submission" || mutation.kind === "consume-native-subagent-submission") {
+						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 } : {}
+							}
+						};
+					}
 					const ownsGeneration = ownsStoredSessionGeneration(identity, current);
 					const ownedLease = current?.lease && current.lease.token === leaseToken ? { lease: current.lease } : {};
 					if (mutation.kind === "reclaim-generation") {
@@ -539,12 +541,14 @@ function createCodexAppServerBindingStore(state) {
 						...mutation.patch,
 						threadId: mutation.threadId
 					});
+					const nativeSubagentSubmissions = active ? preserveCodexNativeSubagentSubmissions(active.binding, binding, active.nativeSubagentSubmissions) : void 0;
 					return {
 						result: true,
 						next: {
 							version: 1,
 							state: "active",
 							binding,
+							...nativeSubagentSubmissions !== void 0 ? { nativeSubagentSubmissions } : {},
 							...storedSessionGeneration(identity, current),
 							...ownedLease
 						}
@@ -562,11 +566,14 @@ function createCodexAppServerBindingStore(state) {
 					if (current?.state !== "active") return { result: "absent" };
 					if (current.sessionId === targetSessionId) return { result: "current" };
 					if (current.sessionId !== expectedSessionId) return { result: "conflict" };
+					const { nativeSubagentSubmissions, ...bindingOwner } = current;
+					const adoptedSubmissions = adoptCodexNativeSubagentSubmissions(nativeSubagentSubmissions);
 					return {
 						result: "adopted",
 						next: {
-							...current,
-							sessionId: targetSessionId
+							...bindingOwner,
+							sessionId: targetSessionId,
+							...adoptedSubmissions !== void 0 ? { nativeSubagentSubmissions: adoptedSubmissions } : {}
 						}
 					};
 				}, void 0, assertCurrent);
@@ -676,64 +683,10 @@ function preservedSessionGeneration(identity, current) {
 	if (current?.sessionId) return { sessionId: current.sessionId };
 	return storedSessionGeneration(identity, current);
 }
-function readPluginAppPolicyContext(value, bindingSchemaVersion) {
-	const record = asOptionalRecord(value);
-	if (!record || typeof record.fingerprint !== "string") return;
-	const apps = asOptionalRecord(record.apps);
-	if (!apps) return;
-	const parsedApps = {};
-	for (const [appId, rawEntry] of Object.entries(apps)) {
-		const entry = asOptionalRecord(rawEntry);
-		if (!entry) return;
-		const destructiveApprovalMode = readDestructiveApprovalMode(entry.destructiveApprovalMode, bindingSchemaVersion);
-		const mcpServerNamesValid = Array.isArray(entry.mcpServerNames) && entry.mcpServerNames.every((serverName) => typeof serverName === "string");
-		if (entry.source === "account") {
-			if ("appId" in entry || typeof entry.appName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || entry.allowOpenWorld !== void 0 && typeof entry.allowOpenWorld !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
-			parsedApps[appId] = {
-				source: "account",
-				appName: entry.appName,
-				allowDestructiveActions: entry.allowDestructiveActions,
-				...typeof entry.allowOpenWorld === "boolean" ? { allowOpenWorld: entry.allowOpenWorld } : {},
-				...destructiveApprovalMode ? { destructiveApprovalMode } : {},
-				mcpServerNames: entry.mcpServerNames
-			};
-			continue;
-		}
-		if ("appId" in entry || entry.source !== void 0 && entry.source !== "plugin" || typeof entry.configKey !== "string" || typeof entry.marketplaceName !== "string" || !CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN.test(entry.marketplaceName) || typeof entry.pluginName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || entry.allowOpenWorld !== void 0 && typeof entry.allowOpenWorld !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
-		parsedApps[appId] = {
-			configKey: entry.configKey,
-			marketplaceName: entry.marketplaceName,
-			pluginName: entry.pluginName,
-			allowDestructiveActions: entry.allowDestructiveActions,
-			...typeof entry.allowOpenWorld === "boolean" ? { allowOpenWorld: entry.allowOpenWorld } : {},
-			...destructiveApprovalMode ? { destructiveApprovalMode } : {},
-			mcpServerNames: entry.mcpServerNames
-		};
-	}
-	const parsedPluginAppIds = {};
-	if (record.pluginAppIds !== void 0 && (!record.pluginAppIds || typeof record.pluginAppIds !== "object" || Array.isArray(record.pluginAppIds))) return;
-	if (record.pluginAppIds && typeof record.pluginAppIds === "object") for (const [configKey, appIds] of Object.entries(record.pluginAppIds)) {
-		if (!Array.isArray(appIds) || appIds.some((appId) => typeof appId !== "string")) return;
-		parsedPluginAppIds[configKey] = appIds;
-	}
-	return {
-		fingerprint: record.fingerprint,
-		apps: parsedApps,
-		pluginAppIds: parsedPluginAppIds
-	};
-}
-function readDestructiveApprovalMode(value, bindingSchemaVersion) {
-	if (value === void 0) return;
-	if (value === "allow" || value === "deny") return value;
-	if (value === "auto") return bindingSchemaVersion === 1 ? "allow" : "auto";
-	if (value === "ask" && bindingSchemaVersion === 2) return "ask";
-	if (value === "on-request" && bindingSchemaVersion === 1) return "auto";
-	return "invalid";
-}
 function sleep(ms) {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
 	});
 }
 //#endregion
-export { resolveCodexRunSessionBindingAuthority as a, session_binding_exports as c, reclaimCurrentCodexSessionGeneration as i, createCodexSessionGenerationSupersededError as n, resolveCodexSessionBinding as o, hashCodexAppServerBindingFingerprint as r, scopeCodexRunBindingStore as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t };
+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 };