@openclaw/codex 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{command-rpc-skzRq4wD.mjs → command-rpc-CuC5fPom.mjs}

@@ -1,21 +1,21 @@
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { n as CodexAppServerRpcError } from "./rpc-error-BlD2vuzn.mjs";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-B3WEZl4e.mjs";
-import { i as requestCodexAppServerJson, o as withCodexAppServerJsonClient } from "./request-BZOfsSXW.mjs";
-import "./config-DKhXquav.mjs";
-import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
-import { a as resolveCodexAppServerAuthProfileStore, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-B0okYl2D.mjs";
-import { tt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-CJCTeFpQ.mjs";
-import { c as isCodexAppServerIndeterminateTransportError, l as isCodexAppServerOverloadError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-qyUBJlGZ.mjs";
-import { o as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-B-S7ngS_.mjs";
-import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BLWz7stm.mjs";
-import { r as listCodexAppServerModels } from "./models-DfLmPV0k.mjs";
-import { n as createCodexSessionGenerationSupersededError } from "./session-binding-DGCYAfvD.mjs";
-import { t as resumeCodexAppServerThread } from "./thread-resume-GOry0AYh.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+import { o as isCodexAppServerOverloadError, r as CodexAppServerRpcError } from "./rpc-error-hmWM21RB.mjs";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-kQntafj_.mjs";
+import { a as withCodexAppServerJsonClient, r as requestCodexAppServerJson } from "./request-jSbhc1sg.mjs";
+import "./config-0Gxk3_eq.mjs";
+import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-cUYrqu_a.mjs";
+import { a as resolveCodexAppServerAuthProfileStore, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CgHQ8Vot.mjs";
+import { tt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-qhyYWbew.mjs";
+import { a as isCodexAppServerIndeterminateRequestCancellationError, o as isCodexAppServerIndeterminateTransportError } from "./client-C8lgBOoO.mjs";
+import { o as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-BH0hW2xU.mjs";
+import { r as prepareCodexAppServerAuthBinding } from "./auth-binding-BoMwpuPN.mjs";
+import { r as listCodexAppServerModels } from "./models-DSseKSMg.mjs";
+import { o as createCodexSessionGenerationSupersededError } from "./session-binding-Ce7BqiPN.mjs";
+import { t as resumeCodexAppServerThread } from "./thread-resume-BT6NHMkM.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
 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 { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-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";
@@ -210,24 +210,16 @@ async function safeCodexControlRequest(pluginConfig, method, requestParams, opti
 	return await safeValue(async () => await codexControlRequest(pluginConfig, method, requestParams, options));
 }
 async function readCodexStatusProbes(pluginConfig, config, agentDir) {
+	const options = {
+		config,
+		agentDir
+	};
 	const [models, account, limits, mcps, skills] = await Promise.all([
 		safeValue(() => listCodexAppServerModels(requestOptions(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
-		})
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, options),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, options),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }, options),
+		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, options)
 	]);
 	return {
 		models,

package/dist/.setup/{compact-8ttks5U5.mjs → compact-tUb9AYfH.mjs}

@@ -1,31 +1,62 @@
 import { n as readCodexRuntimeModelId } from "./model-runtime-BdqzOMkU.mjs";
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
-import { l as retainSharedCodexAppServerClientByInstanceId, p as waitForCodexAppServerClientExit } from "./shared-client-lifecycle-7xgtlo15.mjs";
-import { t as isIncognitoSessionKey } from "./incognito-session-DWYapfwf.mjs";
-import { n as CodexAppServerRpcError } from "./rpc-error-BlD2vuzn.mjs";
-import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-DTtN1KrX.mjs";
-import { F as consumeCodexAppServerLiveThread, K as retainCodexAppServerLiveThread, M as getCodexInferenceThreadQualification, U as protectCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientIfCurrent, q as revertCodexAppServerLiveThreadSkillsCatalog, s as createIsolatedCodexAppServerClient } from "./shared-client-CJCTeFpQ.mjs";
+import { m as sessionBindingIdentity } from "./session-binding-record-BZB8RgcF.mjs";
+import { E as waitForCodexAppServerClientExit, S as retainSharedCodexAppServerClientByInstanceId } from "./auth-cache-key-CGm0UJOr.mjs";
+import { t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-meta-Lkm5Lpf4.mjs";
+import { i as CodexAppServerScopedRequestRejectedError, r as CodexAppServerRpcError } from "./rpc-error-hmWM21RB.mjs";
+import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-C-08ez1w.mjs";
+import { F as consumeCodexAppServerLiveThread, K as retainCodexAppServerLiveThread, M as getCodexInferenceThreadQualification, U as protectCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientIfCurrent, q as revertCodexAppServerLiveThreadInstructions, s as createIsolatedCodexAppServerClient } from "./shared-client-qhyYWbew.mjs";
 import "./responses-oauth-twnuTaAa.mjs";
-import { s as isCodexAppServerIndeterminateRequestCancellationError, u as isCodexAppServerPrewriteRequestCancellationError } from "./client-qyUBJlGZ.mjs";
-import { b as readCodexNotificationTurnId, l as isCodexNoActiveTurnInterruptError, o as closeCodexStartupClientBestEffort, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError, y as readCodexNotificationThreadId } from "./attempt-client-cleanup-B-S7ngS_.mjs";
+import { a as isCodexAppServerIndeterminateRequestCancellationError, s as isCodexAppServerPrewriteRequestCancellationError } from "./client-C8lgBOoO.mjs";
+import { o as readCodexNotificationThreadId, s as readCodexNotificationTurnId } from "./turn-router-sS69wYnI.mjs";
+import { c as isCodexNoActiveTurnInterruptError, f as unsubscribeCodexThreadBestEffort, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-BH0hW2xU.mjs";
 import { n as readCodexThreadContextSnapshot, s as readCodexNotificationItem } from "./event-projector-usage-03R0I2dM.mjs";
-import { o as resolveCodexSessionBinding, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-DGCYAfvD.mjs";
-import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-BwkQXf9e.mjs";
-import { i as assertCodexSupervisionThreadLineage } from "./thread-policy-gNPzzpVp.mjs";
-import { t as resumeCodexAppServerThread } from "./thread-resume-GOry0AYh.mjs";
-import { s as withCodexAppServerThreadMutationHold, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-B6pPt21M.mjs";
+import { r as resolveCodexSessionBinding } from "./session-binding-Ce7BqiPN.mjs";
+import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-BUYOUp9X.mjs";
+import { i as assertCodexSupervisionThreadLineage } from "./thread-policy-DoNxbhqt.mjs";
+import { t as resumeCodexAppServerThread } from "./thread-resume-BT6NHMkM.mjs";
+import { s as withCodexAppServerThreadMutationHold, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DwuSrt3s.mjs";
+import { t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-WqE8yPge.mjs";
 import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-CMla5FPJ.mjs";
-import { t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-DjCz2eOw.mjs";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
-import { embeddedAgentLog, resolveCompactionTimeoutMs } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AgentHarnessSessionSupersededError, embeddedAgentLog, resolveCompactionTimeoutMs } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
 import { runWithAsyncWorkResources } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+import { createNativeSessionBindingAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
 import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 //#region extensions/codex/src/app-server/compact-helpers.ts
+/** Settles the consumed subscription without returning stale ownership to the next turn. */
+async function settleCodexCompactionSubscription(params) {
+	let retained = false;
+	try {
+		if (params.compacted) await params.authority.withCurrent(() => revertCodexAppServerLiveThreadInstructions(params.client, params.binding.threadId));
+		const ownership = params.ownership;
+		if (ownership) retained = await params.bindingStore.withLease(params.identity, async () => {
+			let pendingRetention;
+			try {
+				await params.authority.withCurrent(() => {
+					if (!isSameCodexAppServerThreadOwner(params.bindingStore.read(params.identity), params.binding)) return;
+					pendingRetention = retainCodexAppServerLiveThread(params.client, params.binding.threadId, ownership.release, ownership.configFingerprint, ownership.serviceTier, ownership.ephemeralPolicy && params.compacted ? {
+						...ownership.ephemeralPolicy,
+						refreshableInstructions: ownership.ephemeralPolicy.nativeRefreshableInstructions
+					} : ownership.ephemeralPolicy);
+				});
+			} catch (error) {
+				await pendingRetention;
+				throw error;
+			}
+			return pendingRetention ? await pendingRetention : false;
+		}, { authority: params.authority });
+	} catch (error) {
+		if (!(error instanceof AgentHarnessSessionSupersededError)) throw error;
+	} finally {
+		if (!retained) await params.release?.();
+	}
+}
 async function clearContextEngineProjectionBeforeNativeCompaction(params) {
 	const contextEngineBinding = params.binding.contextEngine;
 	if (!contextEngineBinding?.projection) return;
@@ -36,7 +67,7 @@ async function clearContextEngineProjectionBeforeNativeCompaction(params) {
 			...contextEngineBinding,
 			projection: void 0
 		} }
-	}, params.assertCurrent);
+	}, params.assertCurrent, params.authority);
 	embeddedAgentLog.info("cleared codex context-engine projection before native compaction", {
 		sessionId: params.sessionId,
 		threadId: params.binding.threadId,
@@ -76,6 +107,16 @@ function readIgnoredCompactionOverridePaths(params) {
 		return typeof value === "string" && value.trim() ? [`agents.defaults.compaction.${field}`] : [];
 	});
 }
+function resolveCodexCompactionExecutionBlock(params) {
+	return resolveCodexNativeExecutionBlock({
+		config: params.config,
+		sessionKey: params.sandboxSessionKey ?? params.sessionKey,
+		sessionId: params.sessionId,
+		agentId: params.sandboxAgentId ?? params.agentId,
+		sandbox: params.sandbox,
+		surface: "native compaction"
+	});
+}
 //#endregion
 //#region extensions/codex/src/app-server/compact-lifecycle.ts
 function watchCodexNativeCompactionCompletion(params) {
@@ -168,8 +209,7 @@ function watchCodexNativeCompactionCompletion(params) {
 		completionTimeout.unref?.();
 	};
 	removeNotificationHandler = params.client.addNotificationHandler((notification) => {
-		if (!requestStarted) return;
-		if (!isJsonObject(notification.params)) return;
+		if (!requestStarted || !isJsonObject(notification.params)) return;
 		if (readCodexNotificationThreadId(notification.params) !== params.threadId) return;
 		const notificationTurnId = readCodexNotificationTurnId(notification.params);
 		if (notification.method === "turn/started") {
@@ -325,15 +365,7 @@ async function maybeCompactCodexAppServerSession(params, options) {
 			}
 		});
 	}
-	const sandbox = params.sandbox;
-	const nativeExecutionBlock = resolveCodexNativeExecutionBlock({
-		config: params.config,
-		sessionKey: params.sandboxSessionKey ?? params.sessionKey,
-		sessionId: params.sessionId,
-		agentId: params.sandboxAgentId ?? params.agentId,
-		sandbox,
-		surface: "native compaction"
-	});
+	const nativeExecutionBlock = resolveCodexCompactionExecutionBlock(params);
 	if (nativeExecutionBlock) return {
 		ok: false,
 		compacted: false,
@@ -371,7 +403,10 @@ async function maybeCompactCodexAppServerSession(params, options) {
 		if (!params.abortSignal?.aborted) throw error;
 		return abortedResult(params, options.bindingStore.read(bindingIdentity)?.threadId);
 	}
-	const { binding: initialBinding, assertCurrent } = resolvedBinding;
+	const { binding: initialBinding, authority } = resolvedBinding;
+	const assertCurrent = authority.assertCurrent;
+	const settlementAuthority = createNativeSessionBindingAuthority(authority.lineage, () => {});
+	const assertSettlementCurrent = settlementAuthority.assertCurrent;
 	if (!initialBinding?.threadId) return failedCodexThreadBindingCompactionResult(params, {
 		reason: "no codex app-server thread binding",
 		recovery: "missing_thread_binding"
@@ -402,7 +437,7 @@ async function maybeCompactCodexAppServerSession(params, options) {
 			pluginConfig: options.pluginConfig,
 			config,
 			assertCurrent,
-			agentDir: resolveAgentDir(config, bindingIdentity.agentId)
+			agentDir: resolveAgentDir$1(config, bindingIdentity.agentId)
 		});
 	} catch (error) {
 		return {
@@ -452,11 +487,14 @@ async function maybeCompactCodexAppServerSession(params, options) {
 		};
 		try {
 			return await withCodexAppServerThreadMutationHold(binding.threadId, async (hold, start) => {
-				assertAdmissionCurrent();
+				await authority.withCurrent(assertAdmissionCurrent);
 				const boundClientLease = await retainSharedCodexAppServerClientByInstanceId(binding.clientId);
-				if (attempt.abortSignal.aborted) {
-					await boundClientLease?.release();
+				try {
+					await authority.withCurrent(assertAdmissionCurrent);
 					attempt.abortSignal.throwIfAborted();
+				} catch (error) {
+					await boundClientLease?.release();
+					throw error;
 				}
 				const client = boundClientLease?.client ?? await clientFactory({
 					startOptions: appServer.start,
@@ -481,6 +519,10 @@ async function maybeCompactCodexAppServerSession(params, options) {
 				let compactionSucceeded = false;
 				let temporaryClientExited = true;
 				let compactionRequestDefinitelyRejected = false;
+				let nativeRequestNeedsSettlement = false;
+				const leaseAuthority = createNativeSessionBindingAuthority(authority.lineage, () => {
+					if (!nativeRequestNeedsSettlement && !compactionRequestDefinitelyRejected) assertAdmissionCurrent();
+				});
 				let tokensAfter;
 				let modelOwner;
 				const releaseCompactionThread = async (threadId) => {
@@ -526,9 +568,11 @@ async function maybeCompactCodexAppServerSession(params, options) {
 						if (usesSupervisionConnection) throw new Error("cannot detach an unconfirmed supervised codex thread");
 						if (await options.bindingStore.mutate(bindingIdentity, {
 							kind: "clear",
-							threadId: binding.threadId
-						}, assertCurrent)) return;
-						if (options.bindingStore.read(bindingIdentity)?.threadId !== binding.threadId) return;
+							threadId: binding.threadId,
+							clientId: binding.clientId
+						}, assertSettlementCurrent, settlementAuthority)) return;
+						const currentBinding = options.bindingStore.read(bindingIdentity);
+						if (currentBinding?.threadId !== binding.threadId || currentBinding.clientId !== binding.clientId) return;
 						throw new Error("failed to detach unconfirmed codex app-server thread binding");
 					}
 				});
@@ -544,7 +588,8 @@ async function maybeCompactCodexAppServerSession(params, options) {
 									excludeTurns: true
 								},
 								timeoutMs: timeoutMs ?? appServer.requestTimeoutMs,
-								assertCurrent,
+								assertCurrent: assertAdmissionCurrent,
+								withCurrent: authority.withCurrent,
 								signal: attempt.abortSignal
 							});
 							releaseThreadSubscription = async () => releaseCompactionThread(binding.threadId);
@@ -554,10 +599,14 @@ async function maybeCompactCodexAppServerSession(params, options) {
 							const { thread } = await client.request("thread/read", {
 								threadId: binding.threadId,
 								includeTurns: false
-							}, { assertCurrent });
-							assertCurrent();
+							}, {
+								assertCurrent: assertAdmissionCurrent,
+								withCurrent: authority.withCurrent
+							});
 							retainedThreadOwnership.assertCurrent();
 							assertCodexSupervisionThreadLineage(binding, thread);
+							canRetainThreadOwnership = true;
+							assertAdmissionCurrent();
 						}
 						releaseThreadSubscription ??= async () => releaseCompactionThread(binding.threadId);
 					}
@@ -630,37 +679,34 @@ async function maybeCompactCodexAppServerSession(params, options) {
 							bindingStore: options.bindingStore,
 							identity: bindingIdentity,
 							binding,
-							assertCurrent: assertAdmissionCurrent
+							assertCurrent: assertAdmissionCurrent,
+							authority
 						});
 						assertAdmissionCurrent();
 						try {
 							canRetainThreadOwnership = false;
 							completionWatch.beginRequest();
+							nativeRequestNeedsSettlement = true;
 							await client.request("thread/compact/start", { threadId: binding.threadId }, {
 								...guardedRequestTimeoutMs === void 0 ? {} : { timeoutMs: guardedRequestTimeoutMs },
 								signal: attempt.abortSignal,
-								assertCurrent: () => {
-									try {
-										assertAdmissionCurrent();
-									} catch (error) {
-										compactionRequestDefinitelyRejected = true;
-										throw error;
-									}
-								}
+								withCurrent: authority.withCurrent,
+								assertCurrent: assertAdmissionCurrent
 							});
 							return {
 								started: true,
 								accepted: true
 							};
 						} catch (error) {
-							compactionRequestDefinitelyRejected ||= isCodexAppServerPrewriteRequestCancellationError(error) || error instanceof CodexAppServerRpcError;
+							compactionRequestDefinitelyRejected ||= error instanceof CodexAppServerScopedRequestRejectedError || isCodexAppServerPrewriteRequestCancellationError(error) || error instanceof CodexAppServerRpcError;
 							if (compactionRequestDefinitelyRejected) {
 								canRetainThreadOwnership = !isCodexThreadNotFoundError(error);
 								completionWatch.confirmRequestRejected();
+								nativeRequestNeedsSettlement = false;
 								if (error instanceof CodexAppServerRpcError || binding.contextEngine?.projection) await options.bindingStore.mutate(bindingIdentity, {
 									kind: "set",
 									binding
-								}, assertCurrent);
+								}, assertSettlementCurrent, settlementAuthority);
 							}
 							return {
 								started: true,
@@ -668,12 +714,16 @@ async function maybeCompactCodexAppServerSession(params, options) {
 								error
 							};
 						}
+					}, {
+						assertCurrent: () => nativeRequestNeedsSettlement || compactionRequestDefinitelyRejected ? assertSettlementCurrent() : assertAdmissionCurrent(),
+						authority: leaseAuthority
 					});
 					if (!guardedResult.started) return guardedResult.result;
 					if (!guardedResult.accepted) {
 						if (compactionRequestDefinitelyRejected) throw guardedResult.error;
 						if (!attempt.abortSignal.aborted || !isCodexAppServerIndeterminateRequestCancellationError(guardedResult.error)) {
 							await completionWatch.retireUnconfirmedRequest(`codex app-server compaction start was unconfirmed: ${coerceErrorMessage(guardedResult.error)}`);
+							nativeRequestNeedsSettlement = false;
 							throw guardedResult.error;
 						}
 					}
@@ -682,7 +732,8 @@ async function maybeCompactCodexAppServerSession(params, options) {
 						threadId: binding.threadId
 					});
 					const completion = await completionWatch.completion;
-					assertCurrent();
+					nativeRequestNeedsSettlement = false;
+					await settlementAuthority.withCurrent(assertSettlementCurrent);
 					if (!completion.completed) throw new Error(completion.reason);
 					compactionSucceeded = true;
 					tokensAfter = completion.tokensAfter;
@@ -696,13 +747,17 @@ async function maybeCompactCodexAppServerSession(params, options) {
 						itemId: completion.itemId,
 						timestamp: Date.now()
 					});
-					assertCurrent();
+					await settlementAuthority.withCurrent(assertSettlementCurrent);
 					embeddedAgentLog.info("completed codex app-server compaction", {
 						sessionId: attempt.sessionId,
 						threadId: binding.threadId
 					});
 					canRetainThreadOwnership = true;
 				} catch (error) {
+					if (nativeRequestNeedsSettlement) {
+						await completionWatch.retireUnconfirmedRequest(`codex app-server compaction ownership failed after request admission: ${coerceErrorMessage(error)}`);
+						nativeRequestNeedsSettlement = false;
+					}
 					if (isCodexThreadNotFoundError(error)) return failedCodexThreadBindingCompactionResult(attempt, {
 						threadId: binding.threadId,
 						reason: coerceErrorMessage(error),
@@ -722,19 +777,16 @@ async function maybeCompactCodexAppServerSession(params, options) {
 				} finally {
 					completionWatch.cancel();
 					try {
-						if (compactionSucceeded) revertCodexAppServerLiveThreadSkillsCatalog(client, binding.threadId);
-						if (canRetainThreadOwnership && retainedThreadOwnership) {
-							const ownership = retainedThreadOwnership;
-							const currentBinding = options.bindingStore.read(bindingIdentity);
-							if (!(isSameCodexAppServerThreadOwner(currentBinding, binding) && await options.bindingStore.withLease(bindingIdentity, async () => {
-								const leasedBinding = options.bindingStore.read(bindingIdentity);
-								if (!isSameCodexAppServerThreadOwner(leasedBinding, binding)) return false;
-								return await retainCodexAppServerLiveThread(client, binding.threadId, ownership.release, ownership.configFingerprint, ownership.serviceTier, ownership.ephemeralPolicy && compactionSucceeded ? {
-									...ownership.ephemeralPolicy,
-									skillsInstructions: ownership.ephemeralPolicy.nativeSkillsInstructions
-								} : ownership.ephemeralPolicy);
-							}))) await releaseThreadSubscription?.();
-						} else await releaseThreadSubscription?.();
+						await settleCodexCompactionSubscription({
+							client,
+							bindingStore: options.bindingStore,
+							identity: bindingIdentity,
+							binding,
+							authority: settlementAuthority,
+							ownership: canRetainThreadOwnership ? retainedThreadOwnership : void 0,
+							compacted: compactionSucceeded,
+							release: releaseThreadSubscription
+						});
 					} finally {
 						try {
 							await modelOwner?.unregister();