@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/command-rpc-BMqRQOFX.js

@@ -0,0 +1,226 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-BeqLPbtM.js";
+import { i as requestCodexAppServerJson, o as withCodexAppServerJsonClient } from "./request-CGvGOpeR.js";
+import "./config-JDfTI4VI.js";
+import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
+import { n as prepareCodexAppServerAuthBinding } from "./auth-binding-Co2Vfcf_.js";
+import { a as resolveCodexAppServerAuthProfileStore, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CwzO4_RG.js";
+import { Z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-CVhez2Uo.js";
+import { a as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-D6cR54TV.js";
+import { n as listCodexAppServerModels } from "./models-P9k2qAof.js";
+import { n as createCodexSessionGenerationSupersededError } from "./session-binding-CKSepwIC.js";
+import { t as resumeCodexAppServerThread } from "./thread-resume-T5cveyxA.js";
+import { resolveAgentDir, resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { prepareAgentRuntimeAuth } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { resolveSessionModelRef } from "openclaw/plugin-sdk/model-session-runtime";
+import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
+//#region extensions/codex/src/command-rpc.ts
+var command_rpc_exports = /* @__PURE__ */ __exportAll({
+	codexControlRequest: () => codexControlRequest,
+	readCodexStatusProbes: () => readCodexStatusProbes,
+	requestOptions: () => requestOptions,
+	safeCodexControlRequest: () => safeCodexControlRequest
+});
+async function prepareControlAuth(options, startOptions) {
+	if (!options.onResponse) return {
+		authProfileId: options.authProfileId ?? void 0,
+		clientOptions: { authProfileId: options.authProfileId }
+	};
+	if (!options.config || !options.sessionKey || !options.sessionId) throw new Error("Codex control subscription requires admitted session authority.");
+	const config = options.config;
+	const { sessionAgentId } = resolveSessionAgentIdsStrict({
+		config,
+		sessionKey: options.sessionKey,
+		agentId: options.agentId
+	});
+	const agentDir = options.agentDir ?? resolveAgentDir(config, sessionAgentId);
+	const workspaceDir = resolveAgentWorkspaceDir(config, sessionAgentId);
+	const entry = getSessionEntry({
+		agentId: sessionAgentId,
+		storePath: options.storePath?.trim() || resolveStorePath(config.session?.store, { agentId: sessionAgentId }),
+		sessionKey: options.sessionKey,
+		hydrateSkillPromptRefs: false,
+		readConsistency: "latest"
+	});
+	if (entry?.sessionId !== options.sessionId) throw createCodexSessionGenerationSupersededError(options.sessionId);
+	if (options.authProfileId === null || startOptions.homeScope === "user") return {
+		authProfileId: options.authProfileId ?? void 0,
+		clientOptions: { authProfileId: options.authProfileId }
+	};
+	const model = resolveSessionModelRef(config, entry, sessionAgentId);
+	const authProfileId = entry?.authProfileOverride ?? options.authProfileId;
+	const store = resolveCodexAppServerAuthProfileStore({
+		agentDir,
+		config,
+		authProfileId
+	});
+	const { plan, attempts } = prepareAgentRuntimeAuth({
+		provider: model.provider,
+		modelId: model.model,
+		config,
+		agentDir,
+		workspaceDir,
+		authProfileStore: store,
+		sessionAuthProfileId: authProfileId,
+		sessionAuthProfileSource: entry?.authProfileOverrideSource,
+		harnessId: "codex",
+		harnessAuthBootstrap: "harness"
+	});
+	const route = plan.modelRoute;
+	const resolvedAuth = route ? await resolveApiKeyForProvider({
+		provider: route.provider,
+		modelId: route.modelId,
+		modelApi: route.api,
+		cfg: config,
+		agentDir,
+		workspaceDir,
+		store,
+		profileId: attempts[0]?.profileId,
+		lockedProfile: plan.forwardedAuthProfileSource === "user",
+		allowAuthProfileFallback: attempts[0]?.allowAuthProfileFallback,
+		skipSetupProviderFallback: true
+	}) : void 0;
+	const handoff = await resolveCodexAppServerPreparedAuthHandoff({
+		authRequirement: route?.authRequirement,
+		resolvedApiKey: resolvedAuth?.apiKey,
+		authProfileId: route ? plan.forwardedAuthProfileId : resolveCodexAppServerAuthProfileId({
+			authProfileId: plan.forwardedAuthProfileId,
+			store,
+			config
+		}),
+		authProfileStore: store,
+		agentDir,
+		homeScope: startOptions.homeScope ?? "agent",
+		config,
+		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a forwarded OpenAI OAuth or token profile.",
+		subscriptionProfileUnusableError: "Prepared Codex subscription auth profile is unusable."
+	});
+	const binding = handoff.authProfileId ? await prepareCodexAppServerAuthBinding({
+		authProfileId: handoff.authProfileId,
+		authProfileStore: store,
+		agentDir,
+		config
+	}) : void 0;
+	return {
+		authProfileId: handoff.authProfileId,
+		clientOptions: {
+			...handoff.preparedAuth ? { preparedAuth: handoff.preparedAuth } : { authProfileId: handoff.authProfileId },
+			authRequirement: route?.authRequirement,
+			authProfileStore: binding?.authProfileStore ?? store,
+			authBindingFingerprint: binding?.fingerprint,
+			agentDir
+		}
+	};
+}
+function requestOptions(pluginConfig, limit, config, agentDir) {
+	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
+	return {
+		limit,
+		timeoutMs: runtime.requestTimeoutMs,
+		startOptions: runtime.start,
+		config,
+		agentDir
+	};
+}
+async function codexControlRequest(pluginConfig, method, requestParams, options = {}) {
+	const runtime = options.startOptions ? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig }) : resolveCodexAppServerRuntimeOptions({ pluginConfig });
+	const startOptions = options.startOptions ?? runtime.start;
+	const auth = await prepareControlAuth(options, startOptions);
+	const controlRequestOptions = {
+		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
+		assertCurrent: options.assertCurrent,
+		startOptions,
+		config: options.config,
+		sessionKey: options.sessionKey,
+		sessionId: options.sessionId,
+		agentDir: options.agentDir,
+		isolated: options.isolated,
+		...auth.clientOptions
+	};
+	if (options.onResponse || options.beforeRequest) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client, scope) => {
+		await options.beforeRequest?.(request, client, scope);
+		scope.assertCurrent();
+		let response;
+		if (method === "thread/resume") {
+			if (!isJsonObject(requestParams) || typeof requestParams.threadId !== "string") throw new Error("Codex thread/resume requires a thread id.");
+			response = await resumeCodexAppServerThread({
+				client,
+				request: {
+					...requestParams,
+					threadId: requestParams.threadId
+				},
+				requestResume: () => request({
+					method,
+					requestParams
+				}),
+				abandonClient: () => closeCodexStartupClientBestEffort(client)
+			});
+		} else response = await request({
+			method,
+			requestParams
+		});
+		await options.onResponse?.(response, client, {
+			authProfileId: auth.authProfileId,
+			assertCurrent: scope.assertCurrent
+		});
+		scope.assertCurrent();
+		return response;
+	});
+	return await requestCodexAppServerJson({
+		method,
+		requestParams,
+		...controlRequestOptions
+	});
+}
+async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
+	return await safeValue(async () => await codexControlRequest(pluginConfig, method, requestParams, options));
+}
+async function safeCodexModelList(pluginConfig, limit, config, agentDir) {
+	return await safeValue(async () => await listCodexAppServerModels(requestOptions(pluginConfig, limit, config, agentDir)));
+}
+async function readCodexStatusProbes(pluginConfig, config, agentDir) {
+	const [models, account, limits, mcps, skills] = await Promise.all([
+		safeCodexModelList(pluginConfig, 20, config, agentDir),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, {
+			config,
+			agentDir
+		}),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, {
+			config,
+			agentDir
+		}),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }, {
+			config,
+			agentDir
+		}),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, {
+			config,
+			agentDir
+		})
+	]);
+	return {
+		models,
+		account,
+		limits,
+		mcps,
+		skills
+	};
+}
+async function safeValue(read) {
+	try {
+		return {
+			ok: true,
+			value: await read()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: describeControlFailure(error)
+		};
+	}
+}
+//#endregion
+export { safeCodexControlRequest as a, requestOptions as i, command_rpc_exports as n, readCodexStatusProbes as r, codexControlRequest as t };

package/dist/{compact-_t0HQrUS.js → compact-CGJZ2rlb.js}

@@ -1,20 +1,26 @@
-import { $t as isJsonObject, At as retainCodexAppServerLiveThread, St as consumeCodexAppServerLiveThread, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, q as CodexAppServerRpcError } from "./shared-client-DxcfF9KX.js";
-import { d as sessionBindingIdentity, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-BHuTCRZQ.js";
-import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, g as readCodexNotificationThreadId, r as CodexAppServerUnsafeSubscriptionError, s as isCodexAlreadyTerminalInterruptError } from "./attempt-client-cleanup-DYHcRQAa.js";
-import { f as readCodexNotificationItem, i as readCodexThreadContextSnapshot } from "./event-projector-usage-C5mcrGjp.js";
-import { t as resumeCodexAppServerThread } from "./thread-resume-C7pyVKeW.js";
-import { l as isIncognitoSessionKey, o as withCodexAppServerThreadMutation, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-zGokd8i1.js";
-import { s as resolveCodexNativeExecutionBlock } from "./request-DYAI5FQE.js";
-import { r as assertCodexSupervisionThreadLineage } from "./thread-policy-g4KbJPzp.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-E6uDsPlx.js";
+import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
+import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
+import { u as isCodexAppServerPrewriteRequestCancellationError } from "./client-BEKu4yDx.js";
+import { n as withCodexAppServerThreadMutation, t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.js";
+import { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.js";
+import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-QqgcPCgk.js";
+import { P as consumeCodexAppServerLiveThread, W as retainCodexAppServerLiveThread, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CVhez2Uo.js";
+import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, c as isCodexNoActiveTurnInterruptError, d as unsubscribeCodexThreadBestEffort, g as readCodexNotificationThreadId, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-D6cR54TV.js";
+import { s as readCodexNotificationItem } from "./attempt-notifications--H8zXR5-.js";
+import { n as readCodexThreadContextSnapshot } from "./event-projector-usage-CIyrYYid.js";
+import { o as resolveCodexSessionBinding, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-CKSepwIC.js";
+import { r as assertCodexSupervisionThreadLineage } from "./thread-policy-D8kI7yAO.js";
+import { t as resumeCodexAppServerThread } from "./thread-resume-T5cveyxA.js";
+import { t as isSameCodexAppServerThreadOwner } from "./thread-ownership-D6oASVRu.js";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.js";
+import { t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-BcT66fWy.js";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { embeddedAgentLog, resolveCompactionTimeoutMs } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
-import { resolveDefaultAgentId as resolveDefaultAgentId$1 } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { embeddedAgentLog, resolveCompactionTimeoutMs } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 //#region extensions/codex/src/app-server/compact.ts
 const warnedIgnoredCompactionOverrides = createDedupeCache({
@@ -77,7 +83,7 @@ function watchCodexNativeCompactionCompletion(params) {
 			threadId: params.threadId,
 			turnId: compactionTurnId
 		}, { timeoutMs: Math.max(1, params.interruptGraceMs) }).catch((error) => {
-			if (isCodexAlreadyTerminalInterruptError(error)) {
+			if (isCodexNoActiveTurnInterruptError(error)) {
 				if (compactionItemCompleted) {
 					complete();
 					return;
@@ -292,7 +298,33 @@ async function compactCodexNativeThread(params, options) {
 		agentId: params.agentId,
 		config: params.config
 	});
-	const initialBinding = await options.bindingStore.read(bindingIdentity);
+	const abortedResult = (expectedThreadId, currentThreadId = expectedThreadId) => options.allowNonManualNativeRequest ? skippedCodexNativeCompactionResult(params, {
+		reason: "codex app-server compaction aborted before native compaction",
+		code: "aborted_before_native_compaction",
+		request: options.nativeCompactionRequest ?? "after_context_engine",
+		...expectedThreadId ? {
+			expectedThreadId,
+			currentThreadId
+		} : {}
+	}) : {
+		ok: false,
+		compacted: false,
+		reason: "codex app-server compaction aborted while waiting to start"
+	};
+	let resolvedBinding;
+	try {
+		resolvedBinding = await resolveCodexSessionBinding({
+			bindingStore: options.bindingStore,
+			identity: bindingIdentity,
+			config: params.config,
+			storePath: params.sessionTarget?.storePath,
+			signal: params.abortSignal
+		});
+	} catch (error) {
+		if (!params.abortSignal?.aborted) throw error;
+		return abortedResult(options.bindingStore.read(bindingIdentity)?.threadId);
+	}
+	const { binding: initialBinding, assertCurrent } = resolvedBinding;
 	if (!initialBinding?.threadId) return failedCodexThreadBindingCompactionResult(params, {
 		reason: "no codex app-server thread binding",
 		recovery: "missing_thread_binding"
@@ -312,7 +344,7 @@ async function compactCodexNativeThread(params, options) {
 	let connection;
 	try {
 		const config = params.config ?? {};
-		const agentId = params.agentId ?? readAgentIdFromSessionKey(params.sessionKey) ?? resolveDefaultAgentId$1(config);
+		const agentId = params.agentId ?? readAgentIdFromSessionKey(params.sessionKey) ?? resolveDefaultAgentId(config);
 		connection = resolveCodexBindingAppServerConnection({
 			binding,
 			authProfileId: requestedAuthProfileId ?? binding.authProfileId,
@@ -345,6 +377,7 @@ async function compactCodexNativeThread(params, options) {
 	};
 	try {
 		return await runExclusiveCodexNativeCompaction(binding.threadId, params.abortSignal, async () => {
+			assertCurrent();
 			const client = await clientFactory({
 				startOptions: appServer.start,
 				...preparedApiKey ? { preparedAuth: {
@@ -352,7 +385,8 @@ async function compactCodexNativeThread(params, options) {
 					apiKey: preparedApiKey
 				} } : { authProfileId: connection.clientAuthProfileId },
 				agentDir: params.agentDir,
-				config: params.config
+				config: params.config,
+				assertCurrent
 			});
 			let releaseThreadSubscription;
 			let retainedThreadOwnership;
@@ -380,15 +414,15 @@ async function compactCodexNativeThread(params, options) {
 						forceKillDelayMs: 250
 					});
 					if (appServer.start.transport === "stdio") {
-						if (transportStopped) return;
+						if (transportStopped.exited) return;
 						throw new Error("failed to stop unconfirmed codex app-server process");
 					}
 					if (usesSupervisionConnection) throw new Error("cannot detach an unconfirmed supervised codex thread");
 					if (await options.bindingStore.mutate(bindingIdentity, {
 						kind: "clear",
 						threadId: binding.threadId
-					})) return;
-					if ((await options.bindingStore.read(bindingIdentity))?.threadId !== binding.threadId) return;
+					}, assertCurrent)) return;
+					if (options.bindingStore.read(bindingIdentity)?.threadId !== binding.threadId) return;
 					throw new Error("failed to detach unconfirmed codex app-server thread binding");
 				}
 			});
@@ -404,6 +438,7 @@ async function compactCodexNativeThread(params, options) {
 								excludeTurns: true
 							},
 							timeoutMs: timeoutMs ?? appServer.requestTimeoutMs,
+							assertCurrent,
 							...params.abortSignal ? { signal: params.abortSignal } : {}
 						});
 						releaseThreadSubscription = async () => releaseCompactionThread(binding.threadId);
@@ -413,7 +448,8 @@ async function compactCodexNativeThread(params, options) {
 						const { thread } = await client.request("thread/read", {
 							threadId: binding.threadId,
 							includeTurns: false
-						});
+						}, { assertCurrent });
+						assertCurrent();
 						retainedThreadOwnership.assertCurrent();
 						assertCodexSupervisionThreadLineage(binding, thread);
 					}
@@ -422,7 +458,7 @@ async function compactCodexNativeThread(params, options) {
 			};
 			try {
 				const guardedResult = await options.bindingStore.withLease(bindingIdentity, async () => {
-					const currentBinding = await options.bindingStore.read(bindingIdentity);
+					const currentBinding = options.bindingStore.read(bindingIdentity);
 					if (params.abortSignal?.aborted) {
 						if (!options.allowNonManualNativeRequest) params.abortSignal.throwIfAborted();
 						return {
@@ -436,6 +472,7 @@ async function compactCodexNativeThread(params, options) {
 							})
 						};
 					}
+					assertCurrent();
 					if (!currentBinding || !isSameNativeCompactionBinding(currentBinding, binding)) {
 						embeddedAgentLog.warn("codex app-server compaction could not use the thread binding because it changed", {
 							sessionId: params.sessionId,
@@ -466,23 +503,38 @@ async function compactCodexNativeThread(params, options) {
 						sessionId: params.sessionId,
 						bindingStore: options.bindingStore,
 						identity: bindingIdentity,
-						binding
+						binding,
+						assertCurrent
 					});
+					assertCurrent();
 					try {
 						completionWatch.beginRequest();
-						if (guardedRequestTimeoutMs === void 0) await client.request("thread/compact/start", { threadId: binding.threadId });
-						else await client.request("thread/compact/start", { threadId: binding.threadId }, { timeoutMs: guardedRequestTimeoutMs });
+						await client.request("thread/compact/start", { threadId: binding.threadId }, {
+							...guardedRequestTimeoutMs === void 0 ? {} : { timeoutMs: guardedRequestTimeoutMs },
+							assertCurrent: () => {
+								try {
+									assertCurrent();
+								} catch (error) {
+									compactionRequestDefinitelyRejected = true;
+									throw error;
+								}
+							}
+						});
 						return {
 							started: true,
 							accepted: true
 						};
 					} catch (error) {
-						if (error instanceof CodexAppServerRpcError) {
-							await options.bindingStore.mutate(bindingIdentity, {
-								kind: "set",
-								binding
-							});
-							compactionRequestDefinitelyRejected = !isCodexThreadNotFoundError(error);
+						compactionRequestDefinitelyRejected ||= isCodexAppServerPrewriteRequestCancellationError(error);
+						if (compactionRequestDefinitelyRejected || error instanceof CodexAppServerRpcError) {
+							completionWatch.confirmRequestRejected();
+							if (!compactionRequestDefinitelyRejected) {
+								await options.bindingStore.mutate(bindingIdentity, {
+									kind: "set",
+									binding
+								}, assertCurrent);
+								compactionRequestDefinitelyRejected = !isCodexThreadNotFoundError(error);
+							}
 						}
 						return {
 							started: true,
@@ -493,8 +545,7 @@ async function compactCodexNativeThread(params, options) {
 				});
 				if (!guardedResult.started) return guardedResult.result;
 				if (!guardedResult.accepted) {
-					if (guardedResult.error instanceof CodexAppServerRpcError) completionWatch.confirmRequestRejected();
-					else await completionWatch.retireUnconfirmedRequest(`codex app-server compaction start was unconfirmed: ${coerceErrorMessage(guardedResult.error)}`);
+					if (!compactionRequestDefinitelyRejected && !(guardedResult.error instanceof CodexAppServerRpcError)) await completionWatch.retireUnconfirmedRequest(`codex app-server compaction start was unconfirmed: ${coerceErrorMessage(guardedResult.error)}`);
 					throw guardedResult.error;
 				}
 				embeddedAgentLog.info("started codex app-server compaction", {
@@ -502,6 +553,7 @@ async function compactCodexNativeThread(params, options) {
 					threadId: binding.threadId
 				});
 				const completion = await completionWatch.completion;
+				assertCurrent();
 				if (!completion.completed) throw new Error(completion.reason);
 				tokensAfter = completion.tokensAfter;
 				if (completion.turnId && completion.itemId) await persistCodexContextCompactionActivity({
@@ -514,6 +566,7 @@ async function compactCodexNativeThread(params, options) {
 					itemId: completion.itemId,
 					timestamp: Date.now()
 				});
+				assertCurrent();
 				embeddedAgentLog.info("completed codex app-server compaction", {
 					sessionId: params.sessionId,
 					threadId: binding.threadId
@@ -541,9 +594,9 @@ async function compactCodexNativeThread(params, options) {
 				try {
 					if ((compactionSucceeded || compactionRequestDefinitelyRejected) && retainedThreadOwnership) {
 						const ownership = retainedThreadOwnership;
-						const currentBinding = await options.bindingStore.read(bindingIdentity);
+						const currentBinding = options.bindingStore.read(bindingIdentity);
 						if (!(isSameCodexAppServerThreadOwner(currentBinding, binding) && await options.bindingStore.withLease(bindingIdentity, async () => {
-							const leasedBinding = await options.bindingStore.read(bindingIdentity);
+							const leasedBinding = options.bindingStore.read(bindingIdentity);
 							if (!isSameCodexAppServerThreadOwner(leasedBinding, binding)) return false;
 							return await retainCodexAppServerLiveThread(client, binding.threadId, ownership.release, ownership.configFingerprint, ownership.serviceTier);
 						}))) await releaseThreadSubscription?.();
@@ -570,20 +623,7 @@ async function compactCodexNativeThread(params, options) {
 			});
 		});
 	} catch (error) {
-		if (params.abortSignal?.aborted) {
-			if (options.allowNonManualNativeRequest) return skippedCodexNativeCompactionResult(params, {
-				reason: "codex app-server compaction aborted before native compaction",
-				code: "aborted_before_native_compaction",
-				request: options.nativeCompactionRequest ?? "after_context_engine",
-				expectedThreadId: initialBinding.threadId,
-				currentThreadId: binding.threadId
-			});
-			return {
-				ok: false,
-				compacted: false,
-				reason: "codex app-server compaction aborted while waiting to start"
-			};
-		}
+		if (params.abortSignal?.aborted) return abortedResult(initialBinding.threadId, binding.threadId);
 		throw error;
 	}
 }
@@ -644,7 +684,7 @@ async function clearContextEngineProjectionBeforeNativeCompaction(params) {
 			...contextEngineBinding,
 			projection: void 0
 		} }
-	});
+	}, params.assertCurrent);
 	embeddedAgentLog.info("cleared codex context-engine projection before native compaction", {
 		sessionId: params.sessionId,
 		threadId: params.binding.threadId,

package/dist/config-JDfTI4VI.js

@@ -0,0 +1,106 @@
+import { c as readExecAsk, f as readRecord, l as readExecSecurity } from "./config-utils-C57JiJrU.js";
+import { p as canUseCodexModelBackedApprovalsReviewerForModel$1 } from "./config-options-jnIFvwxD.js";
+import "./protocol-CAAcVIKF.js";
+import "./config-runtime-BWf6JLWG.js";
+import { resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { execPolicy } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { resolveExecApprovalsFromFile } from "openclaw/plugin-sdk/exec-approvals-runtime";
+import { resolveProviderIdForAuth } from "openclaw/plugin-sdk/provider-auth-aliases";
+//#region extensions/codex/src/app-server/config-exec-approvals.ts
+function resolveOpenClawExecPolicyFromConfig(params) {
+	const globalExec = readRecord(params.config?.tools?.exec);
+	const globalPolicy = applyOpenClawExecPolicyLayer(createDefaultOpenClawExecPolicy(), globalExec);
+	const agentId = params.agentId?.trim();
+	return applyOpenClawExecPolicyLayer(globalPolicy, agentId ? readRecord(resolveAgentConfig(params.config ?? {}, agentId)?.tools?.exec) : void 0);
+}
+function resolveOpenClawExecPolicyForCodexAppServer(params) {
+	if (params.permissionMode === "full") return {
+		...resolveOpenClawExecPolicyForMode("full"),
+		touched: true
+	};
+	const overridePolicy = applyOpenClawExecPolicyLayer(resolveOpenClawExecPolicyFromConfig({
+		config: params.config,
+		agentId: params.agentId
+	}), params.execOverrides);
+	return applyOpenClawExecApprovalFloors(overridePolicy, resolveOpenClawExecApprovalFloorsForCodexAppServer({
+		approvals: params.approvals,
+		agentId: params.agentId,
+		policy: overridePolicy
+	}));
+}
+function createDefaultOpenClawExecPolicy() {
+	return {
+		...resolveOpenClawExecPolicyForMode("full"),
+		touched: false
+	};
+}
+function applyOpenClawExecPolicyLayer(base, exec) {
+	if (!exec) return base;
+	const mode = readExecMode(exec.mode);
+	if (mode !== void 0) return {
+		...resolveOpenClawExecPolicyForMode(mode),
+		touched: true
+	};
+	const security = readExecSecurity(exec.security);
+	const ask = readExecAsk(exec.ask);
+	if (security === void 0 && ask === void 0) return base;
+	const nextSecurity = security ?? base.security;
+	const nextAsk = ask ?? base.ask;
+	return {
+		mode: execPolicy.resolveExecModePolicy({
+			security: nextSecurity,
+			ask: nextAsk
+		}).mode,
+		security: nextSecurity,
+		ask: nextAsk,
+		touched: true
+	};
+}
+function resolveOpenClawExecApprovalFloorsForCodexAppServer(params) {
+	if (!params.approvals) return;
+	return resolveExecApprovalsFromFile({
+		file: params.approvals,
+		agentId: params.agentId,
+		overrides: {
+			security: params.policy.security,
+			ask: params.policy.ask
+		}
+	}).agent;
+}
+function applyOpenClawExecApprovalFloors(base, approvalFloors) {
+	if (!approvalFloors) return base;
+	const nextSecurity = approvalFloors.security ? execPolicy.minSecurity(base.security, approvalFloors.security) : base.security;
+	const nextAsk = approvalFloors.ask ? execPolicy.maxAsk(base.ask, approvalFloors.ask) : base.ask;
+	if (nextSecurity === base.security && nextAsk === base.ask) return base;
+	return {
+		mode: execPolicy.resolveExecModePolicy({
+			security: nextSecurity,
+			ask: nextAsk
+		}).mode,
+		security: nextSecurity,
+		ask: nextAsk,
+		touched: true
+	};
+}
+function resolveOpenClawExecPolicyForMode(mode) {
+	const { security, ask } = execPolicy.resolveExecModePolicy({
+		mode,
+		security: "full",
+		ask: "off"
+	});
+	return {
+		mode,
+		security,
+		ask
+	};
+}
+function readExecMode(value) {
+	return value === "deny" || value === "allowlist" || value === "ask" || value === "auto" || value === "full" ? value : void 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/config-reviewer.ts
+function canUseCodexModelBackedApprovalsReviewerForModel(params) {
+	return canUseCodexModelBackedApprovalsReviewerForModel$1(params, resolveProviderIdForAuth);
+}
+//#endregion
+export { resolveOpenClawExecPolicyForCodexAppServer as n, canUseCodexModelBackedApprovalsReviewerForModel as t };