@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{compact-D_uvHurS.js → compact-COqgBRny.js}

@@ -1,23 +1,34 @@
-import { W as isJsonObject, a as getLeasedSharedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, v as CodexAppServerRpcError } from "./shared-client-DTbvH-XV.js";
-import { d as sessionBindingIdentity, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-BXpo9ymA.js";
-import { _ as readCodexNotificationItem } from "./attempt-notifications-AP-a-Q5k.js";
-import { n as resolveCodexNativeExecutionBlock } from "./sandbox-guard-NuhpXmPB.js";
-import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-CU6_AnOb.js";
+import { B as CodexAppServerRpcError, U as consumeCodexAppServerLiveThread, Y as retainCodexAppServerLiveThread, a as getLeasedSharedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
+import { d as sessionBindingIdentity, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-BTrLf9Qm.js";
+import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, g as readCodexNotificationThreadId, r as CodexAppServerUnsafeSubscriptionError, s as isCodexAlreadyTerminalInterruptError } from "./attempt-client-cleanup-URjUlCHg.js";
+import { i as readCodexThreadContextSnapshot, x as readCodexNotificationItem } from "./event-projector-usage-CLwNEJqW.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
+import { t as resumeCodexAppServerThread } from "./thread-resume-CdJk2Ehf.js";
+import { n as resolveCodexNativeExecutionBlock } from "./sandbox-guard-C1qEeZ5C.js";
+import { t as isSameCodexAppServerThreadOwner } from "./thread-ownership-i2NBwDUL.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-DAvZwp96.js";
+import { t as persistCodexContextCompactionActivity } from "./context-compaction-activity-BOeJf7yo.js";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { embeddedAgentLog, resolveCompactionTimeoutMs } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { resolveAgentDir as resolveAgentDir$1, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-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 { AsyncLocalStorage } from "node:async_hooks";
+import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 //#region extensions/codex/src/app-server/compact.ts
 /**
 * Native Codex app-server compaction bridge for bound OpenClaw sessions.
 */
-const warnedIgnoredCompactionOverrides = /* @__PURE__ */ new Set();
-const codexNativeCompactionQueues = /* @__PURE__ */ new Map();
+const warnedIgnoredCompactionOverrides = createDedupeCache({
+	ttlMs: 0,
+	maxSize: 4096
+});
+const codexNativeCompactionQueue = new KeyedAsyncQueue();
 const CODEX_NATIVE_COMPACTION_INTERRUPT_GRACE_MS = 3e4;
-const CODEX_NO_ACTIVE_TURN_ERROR_CODE = -32600;
-const CODEX_NO_ACTIVE_TURN_ERROR_MESSAGE = "no active turn to interrupt";
-function isAlreadyTerminalInterruptError(error) {
-	return error instanceof CodexAppServerRpcError && error.code === CODEX_NO_ACTIVE_TURN_ERROR_CODE && error.message === CODEX_NO_ACTIVE_TURN_ERROR_MESSAGE;
-}
 function watchCodexNativeCompactionCompletion(params) {
+	const runOutsideBindingLease = AsyncLocalStorage.snapshot();
 	let settled = false;
 	let requestStarted = false;
 	let abortRequested = false;
@@ -26,10 +37,8 @@ function watchCodexNativeCompactionCompletion(params) {
 	let compactionTurnId;
 	let compactionItemId;
 	let compactionItemCompleted = false;
-	let resolveCompletion = (_result) => {};
-	const completion = new Promise((resolve) => {
-		resolveCompletion = resolve;
-	});
+	let tokensAfter;
+	const { promise: completion, resolve: resolveCompletion } = createDeferred();
 	let removeNotificationHandler = () => {};
 	let removeCloseHandler = () => {};
 	let removeAbortHandler = () => {};
@@ -45,17 +54,24 @@ function watchCodexNativeCompactionCompletion(params) {
 		clearTimeout(interruptGraceTimeout);
 		resolveCompletion(result);
 	};
+	const complete = () => finish({
+		completed: true,
+		...compactionTurnId ? { turnId: compactionTurnId } : {},
+		...compactionItemId ? { itemId: compactionItemId } : {},
+		...tokensAfter !== void 0 ? { tokensAfter } : {}
+	});
+	const fail = (reason) => finish({
+		completed: false,
+		reason
+	});
 	const retireUnconfirmed = (reason) => {
 		if (settled || retirementStarted) return;
 		retirementStarted = true;
-		params.retireUnconfirmed().then(() => finish({
-			completed: false,
-			reason
-		})).catch((error) => {
+		runOutsideBindingLease(() => params.retireUnconfirmed()).then(() => fail(reason)).catch((error) => {
 			embeddedAgentLog.error("failed to retire unconfirmed codex app-server compaction", {
 				threadId: params.threadId,
 				turnId: compactionTurnId,
-				reason: formatCompactionError(error)
+				reason: coerceErrorMessage(error)
 			});
 		});
 	};
@@ -65,23 +81,19 @@ function watchCodexNativeCompactionCompletion(params) {
 		params.client.request("turn/interrupt", {
 			threadId: params.threadId,
 			turnId: compactionTurnId
-		}, { timeoutMs: Math.max(1, params.interruptGraceMs) }).then(() => {
-			finish({
-				completed: false,
-				reason: "codex app-server confirmed native compaction interruption"
-			});
-		}).catch((error) => {
-			if (isAlreadyTerminalInterruptError(error)) {
-				finish(compactionItemCompleted ? { completed: true } : {
-					completed: false,
-					reason: "codex app-server compaction reached terminal state without a completed compaction item"
-				});
+		}, { timeoutMs: Math.max(1, params.interruptGraceMs) }).catch((error) => {
+			if (isCodexAlreadyTerminalInterruptError(error)) {
+				if (compactionItemCompleted) {
+					complete();
+					return;
+				}
+				fail("codex app-server compaction reached terminal state without a completed compaction item");
 				return;
 			}
 			embeddedAgentLog.warn("codex app-server compaction interrupt request failed", {
 				threadId: params.threadId,
 				turnId: compactionTurnId,
-				reason: formatCompactionError(error)
+				reason: coerceErrorMessage(error)
 			});
 		});
 	};
@@ -121,6 +133,10 @@ function watchCodexNativeCompactionCompletion(params) {
 			return;
 		}
 		if (compactionTurnId && notificationTurnId !== compactionTurnId) return;
+		if (notification.method === "thread/tokenUsage/updated") {
+			tokensAfter = readCodexThreadContextSnapshot(notification.params).activeContextTokens ?? tokensAfter;
+			return;
+		}
 		const item = readCodexNotificationItem(notification.params);
 		if (item?.type === "contextCompaction") {
 			if (notification.method === "item/started") {
@@ -138,27 +154,15 @@ function watchCodexNativeCompactionCompletion(params) {
 		const turn = isJsonObject(notification.params.turn) ? notification.params.turn : void 0;
 		const status = typeof turn?.status === "string" ? turn.status : void 0;
 		if (status !== "completed") {
-			finish({
-				completed: false,
-				reason: `codex app-server compaction turn ended with status ${status ?? "unknown"}`
-			});
+			fail(`codex app-server compaction turn ended with status ${status ?? "unknown"}`);
 			return;
 		}
-		if (!compactionItemId) {
-			finish({
-				completed: false,
-				reason: "codex app-server compaction turn completed without a compaction item"
-			});
+		const incompleteReason = !compactionItemId ? "codex app-server compaction turn completed without a compaction item" : !compactionItemCompleted ? "codex app-server compaction turn completed before its compaction item" : void 0;
+		if (incompleteReason) {
+			fail(incompleteReason);
 			return;
 		}
-		if (!compactionItemCompleted) {
-			finish({
-				completed: false,
-				reason: "codex app-server compaction turn completed before its compaction item"
-			});
-			return;
-		}
-		finish({ completed: true });
+		complete();
 	});
 	removeCloseHandler = params.client.addCloseHandler(() => {
 		retireUnconfirmed("codex app-server closed before native compaction completed");
@@ -179,57 +183,35 @@ function watchCodexNativeCompactionCompletion(params) {
 			beginCompletionTimeout();
 			if (abortRequested) beginInterruptGrace();
 		},
-		confirmRequestRejected: () => finish({
-			completed: false,
-			reason: "codex app-server rejected the compaction request"
-		}),
+		confirmRequestRejected: () => fail("codex app-server rejected the compaction request"),
 		retireUnconfirmedRequest: async (reason) => {
 			retireUnconfirmed(reason);
 			return await completion;
 		},
 		cancel: () => {
-			if (!requestStarted) finish({
-				completed: false,
-				reason: "compaction request did not start"
-			});
+			if (!requestStarted) fail("compaction request did not start");
 		}
 	};
 }
 async function runExclusiveCodexNativeCompaction(threadId, signal, run) {
-	const previous = codexNativeCompactionQueues.get(threadId) ?? Promise.resolve();
-	let releaseCurrent;
-	const current = new Promise((resolve) => {
-		releaseCurrent = resolve;
-	});
-	const queued = previous.then(() => current, () => current);
-	codexNativeCompactionQueues.set(threadId, queued);
-	try {
-		await waitForCodexNativeCompactionQueue(previous, signal);
+	signal?.throwIfAborted();
+	let started = false;
+	const queued = codexNativeCompactionQueue.enqueue(threadId, async () => {
+		started = true;
 		signal?.throwIfAborted();
-		return await run();
-	} finally {
-		releaseCurrent();
-		queued.then(() => {
-			if (codexNativeCompactionQueues.get(threadId) === queued) codexNativeCompactionQueues.delete(threadId);
-		});
-	}
-}
-async function waitForCodexNativeCompactionQueue(previous, signal) {
-	if (!signal) {
-		await previous.catch(() => void 0);
-		return;
-	}
-	signal.throwIfAborted();
+		return run();
+	});
+	if (!signal) return queued;
 	let removeAbortListener = () => {};
 	const aborted = new Promise((_, reject) => {
 		const onAbort = () => {
-			reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("compaction aborted"));
+			if (!started) reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("compaction aborted"));
 		};
 		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
 		signal.addEventListener("abort", onAbort, { once: true });
 	});
 	try {
-		await Promise.race([previous.catch(() => void 0), aborted]);
+		return await Promise.race([queued, aborted]);
 	} finally {
 		removeAbortListener();
 	}
@@ -246,8 +228,7 @@ function warnIfIgnoringOpenClawCompactionOverrides(params) {
 	const ignoredConfig = readIgnoredCompactionOverridePaths(params);
 	if (ignoredConfig.length === 0) return;
 	const warningKey = ignoredConfig.join("\0");
-	if (warnedIgnoredCompactionOverrides.has(warningKey)) return;
-	warnedIgnoredCompactionOverrides.add(warningKey);
+	if (warnedIgnoredCompactionOverrides.check(warningKey)) return;
 	embeddedAgentLog.warn("ignoring OpenClaw compaction overrides for Codex app-server compaction; Codex uses native server-side compaction", {
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
@@ -258,34 +239,19 @@ function readIgnoredCompactionOverridePaths(params) {
 	const ignored = /* @__PURE__ */ new Set();
 	for (const entry of readCompactionOverrideEntries(params)) {
 		const localProvider = typeof entry.record.provider === "string" ? entry.record.provider.trim() : "";
-		const inheritedProvider = !localProvider && typeof entry.inheritedRecord?.provider === "string" ? entry.inheritedRecord.provider.trim() : "";
-		const providerPath = localProvider ? `${entry.path}.compaction.provider` : inheritedProvider && entry.inheritedPath ? `${entry.inheritedPath}.compaction.provider` : void 0;
 		if (typeof entry.record.model === "string" && entry.record.model.trim()) ignored.add(`${entry.path}.compaction.model`);
 		if (typeof entry.record.thinkingLevel === "string" && entry.record.thinkingLevel.trim()) ignored.add(`${entry.path}.compaction.thinkingLevel`);
-		if (providerPath) ignored.add(providerPath);
+		if (localProvider) ignored.add(`${entry.path}.compaction.provider`);
 	}
 	return [...ignored];
 }
 function readCompactionOverrideEntries(params) {
 	const entries = [];
-	const defaultCompaction = readRecord(readRecord(params.config?.agents)?.defaults)?.compaction;
-	const defaultRecord = readRecord(defaultCompaction);
+	const defaultRecord = asOptionalRecord(params.config?.agents?.defaults?.compaction);
 	if (defaultRecord) entries.push({
 		path: "agents.defaults",
 		record: defaultRecord
 	});
-	const agentId = readAgentIdFromSessionKey(params.sessionKey ?? params.sandboxSessionKey);
-	if (!agentId) return entries;
-	const agentCompaction = readRecord((Array.isArray(params.config?.agents?.list) ? params.config.agents.list : []).find((agent) => {
-		return (typeof agent?.id === "string" ? agent.id.trim().toLowerCase() : "") === agentId;
-	}))?.compaction;
-	const agentRecord = readRecord(agentCompaction);
-	if (agentRecord) entries.push({
-		path: `agents.list.${agentId}`,
-		record: agentRecord,
-		inheritedRecord: defaultRecord,
-		inheritedPath: "agents.defaults"
-	});
 	return entries;
 }
 function readAgentIdFromSessionKey(sessionKey) {
@@ -293,9 +259,6 @@ function readAgentIdFromSessionKey(sessionKey) {
 	if (parts.length < 3 || parts[0] !== "agent") return;
 	return parts[1]?.trim() || void 0;
 }
-function readRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
 async function compactCodexNativeThread(params, options) {
 	if (params.trigger !== "manual" && !options.allowNonManualNativeRequest) {
 		embeddedAgentLog.info("skipping codex app-server compaction for non-manual trigger", {
@@ -303,27 +266,24 @@ async function compactCodexNativeThread(params, options) {
 			sessionKey: params.sessionKey,
 			trigger: params.trigger
 		});
-		return {
-			ok: true,
+		return codexNativeCompactionResult(params, {
 			compacted: false,
 			reason: "codex app-server owns automatic compaction",
-			result: {
-				summary: "",
-				firstKeptEntryId: "",
-				tokensBefore: params.currentTokenCount ?? 0,
-				details: {
-					backend: "codex-app-server",
-					skipped: true,
-					reason: "non_manual_trigger",
-					trigger: params.trigger ?? "unknown"
-				}
+			details: {
+				backend: "codex-app-server",
+				skipped: true,
+				reason: "non_manual_trigger",
+				trigger: params.trigger ?? "unknown"
 			}
-		};
+		});
 	}
+	const sandbox = params.sandbox;
 	const nativeExecutionBlock = resolveCodexNativeExecutionBlock({
 		config: params.config,
 		sessionKey: params.sandboxSessionKey ?? params.sessionKey,
 		sessionId: params.sessionId,
+		agentId: params.agentId,
+		sandbox,
 		surface: "native compaction"
 	});
 	if (nativeExecutionBlock) return {
@@ -342,12 +302,22 @@ async function compactCodexNativeThread(params, options) {
 		reason: "no codex app-server thread binding",
 		recovery: "missing_thread_binding"
 	});
+	if (params.nativeToolSurface === "host-isolated" || initialBinding.nativeToolPolicyRestricted === true || initialBinding.ringZeroConfigFingerprint !== void 0) return codexNativeCompactionResult(params, {
+		compacted: false,
+		reason: "native compaction is unavailable for a host-isolated Codex session",
+		details: {
+			backend: "codex-app-server",
+			skipped: true,
+			reason: "native_tool_policy_restricted",
+			expectedThreadId: initialBinding.threadId
+		}
+	});
 	let binding = initialBinding;
 	const requestedAuthProfileId = params.authProfileId?.trim() || void 0;
 	let connection;
 	try {
 		const config = params.config ?? {};
-		const agentId = params.agentId ?? readAgentIdFromSessionKey(params.sessionKey) ?? resolveDefaultAgentId(config);
+		const agentId = params.agentId ?? readAgentIdFromSessionKey(params.sessionKey) ?? resolveDefaultAgentId$1(config);
 		connection = resolveCodexBindingAppServerConnection({
 			binding,
 			authProfileId: requestedAuthProfileId ?? binding.authProfileId,
@@ -359,7 +329,7 @@ async function compactCodexNativeThread(params, options) {
 		return {
 			ok: false,
 			compacted: false,
-			reason: formatCompactionError(error)
+			reason: coerceErrorMessage(error)
 		};
 	}
 	const { appServer, usesSupervisionConnection } = connection;
@@ -389,6 +359,19 @@ async function compactCodexNativeThread(params, options) {
 				agentDir: params.agentDir,
 				config: params.config
 			});
+			let releaseThreadSubscription;
+			let retainedThreadOwnership;
+			let compactionSucceeded = false;
+			let compactionRequestDefinitelyRejected = false;
+			let tokensAfter;
+			const releaseCompactionThread = async (threadId) => {
+				if (await unsubscribeCodexThreadBestEffort(client, {
+					threadId,
+					timeoutMs: 5e3
+				})) return;
+				await closeCodexStartupClientBestEffort(client);
+				throw new CodexAppServerUnsafeSubscriptionError(`Codex compaction thread subscription could not be released: ${threadId}`);
+			};
 			const completionWatch = watchCodexNativeCompactionCompletion({
 				client,
 				threadId: binding.threadId,
@@ -396,6 +379,7 @@ async function compactCodexNativeThread(params, options) {
 				timeoutMs: options.nativeCompletionTimeoutMs ?? resolveCompactionTimeoutMs(params.config),
 				interruptGraceMs: options.nativeInterruptGraceMs ?? CODEX_NATIVE_COMPACTION_INTERRUPT_GRACE_MS,
 				retireUnconfirmed: async () => {
+					releaseThreadSubscription = void 0;
 					const transportStopped = await client.closeAndWait({
 						exitTimeoutMs: 5e3,
 						forceKillDelayMs: 250
@@ -413,84 +397,98 @@ async function compactCodexNativeThread(params, options) {
 					throw new Error("failed to detach unconfirmed codex app-server thread binding");
 				}
 			});
-			const beginNativeCompactionRequest = async (timeoutMs) => {
-				completionWatch.beginRequest();
-				const requestParams = { threadId: binding.threadId };
-				if (timeoutMs === void 0) await client.request("thread/compact/start", requestParams);
-				else await client.request("thread/compact/start", requestParams, { timeoutMs });
-			};
-			const settleNativeCompactionRequestError = async (error) => {
-				if (error instanceof CodexAppServerRpcError) completionWatch.confirmRequestRejected();
-				else await completionWatch.retireUnconfirmedRequest(`codex app-server compaction start was unconfirmed: ${formatCompactionError(error)}`);
+			const acquireThreadSubscription = async (timeoutMs) => {
+				if (!isIncognitoSessionKey(params.sessionKey)) {
+					retainedThreadOwnership = await consumeCodexAppServerLiveThread(client, binding.threadId);
+					if (!retainedThreadOwnership) await resumeCodexAppServerThread({
+						client,
+						abandonClient: async () => closeCodexStartupClientBestEffort(client),
+						request: {
+							threadId: binding.threadId,
+							excludeTurns: true
+						},
+						timeoutMs: timeoutMs ?? appServer.requestTimeoutMs,
+						...params.abortSignal ? { signal: params.abortSignal } : {}
+					});
+					releaseThreadSubscription = async () => releaseCompactionThread(binding.threadId);
+				}
 			};
 			try {
-				if (options.allowNonManualNativeRequest) {
-					const guardedResult = await options.bindingStore.withLease(bindingIdentity, async () => {
-						const currentBinding = await options.bindingStore.read(bindingIdentity);
-						if (params.abortSignal?.aborted) return {
+				const guardedResult = await options.bindingStore.withLease(bindingIdentity, async () => {
+					const currentBinding = await options.bindingStore.read(bindingIdentity);
+					if (params.abortSignal?.aborted) {
+						if (!options.allowNonManualNativeRequest) params.abortSignal.throwIfAborted();
+						return {
 							started: false,
 							result: skippedCodexNativeCompactionResult(params, {
 								reason: "codex app-server compaction aborted before native compaction",
 								code: "aborted_before_native_compaction",
+								request: options.nativeCompactionRequest ?? "after_context_engine",
 								expectedThreadId: binding.threadId,
 								currentThreadId: currentBinding?.threadId
 							})
 						};
-						if (!currentBinding || !isSameNativeCompactionBinding(currentBinding, binding)) {
-							embeddedAgentLog.warn("skipping codex app-server compaction because the thread binding changed", {
-								sessionId: params.sessionId,
-								sessionKey: params.sessionKey,
-								expectedThreadId: binding.threadId,
-								currentThreadId: currentBinding?.threadId
-							});
-							return {
-								started: false,
-								result: skippedCodexNativeCompactionResult(params, {
-									reason: "codex app-server binding changed before native compaction",
-									code: "binding_changed_before_native_compaction",
-									expectedThreadId: binding.threadId,
-									currentThreadId: currentBinding?.threadId
-								})
-							};
-						}
-						binding = currentBinding;
-						await clearContextEngineProjectionBeforeNativeCompaction({
+					}
+					if (!currentBinding || !isSameNativeCompactionBinding(currentBinding, binding)) {
+						embeddedAgentLog.warn("codex app-server compaction could not use the thread binding because it changed", {
 							sessionId: params.sessionId,
-							bindingStore: options.bindingStore,
-							identity: bindingIdentity,
-							binding
+							sessionKey: params.sessionKey,
+							expectedThreadId: binding.threadId,
+							currentThreadId: currentBinding?.threadId
 						});
-						try {
-							await beginNativeCompactionRequest(Math.min(appServer.requestTimeoutMs, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS));
-							return {
-								started: true,
-								accepted: true
-							};
-						} catch (error) {
+						const isRequiredPreflight = options.nativeCompactionRequest === "required_preflight";
+						return {
+							started: false,
+							result: options.allowNonManualNativeRequest && !isRequiredPreflight ? skippedCodexNativeCompactionResult(params, {
+								reason: "codex app-server binding changed before native compaction",
+								code: "binding_changed_before_native_compaction",
+								request: options.nativeCompactionRequest ?? "after_context_engine",
+								expectedThreadId: binding.threadId,
+								currentThreadId: currentBinding?.threadId
+							}) : failedCodexThreadBindingCompactionResult(params, {
+								threadId: currentBinding?.threadId ?? binding.threadId,
+								reason: "codex app-server binding changed before native compaction",
+								recovery: "stale_thread_binding"
+							})
+						};
+					}
+					binding = currentBinding;
+					const guardedRequestTimeoutMs = options.allowNonManualNativeRequest ? Math.min(appServer.requestTimeoutMs, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS) : void 0;
+					await acquireThreadSubscription(guardedRequestTimeoutMs);
+					await clearContextEngineProjectionBeforeNativeCompaction({
+						sessionId: params.sessionId,
+						bindingStore: options.bindingStore,
+						identity: bindingIdentity,
+						binding
+					});
+					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 });
+						return {
+							started: true,
+							accepted: true
+						};
+					} catch (error) {
+						if (error instanceof CodexAppServerRpcError) {
 							await options.bindingStore.mutate(bindingIdentity, {
 								kind: "set",
 								binding
 							});
-							return {
-								started: true,
-								accepted: false,
-								error
-							};
+							compactionRequestDefinitelyRejected = !isCodexThreadNotFoundError(error);
 						}
-					});
-					if (!guardedResult.started) return guardedResult.result;
-					if (!guardedResult.accepted) {
-						await settleNativeCompactionRequestError(guardedResult.error);
-						throw guardedResult.error;
-					}
-				} else {
-					params.abortSignal?.throwIfAborted();
-					try {
-						await beginNativeCompactionRequest();
-					} catch (error) {
-						await settleNativeCompactionRequestError(error);
-						throw error;
+						return {
+							started: true,
+							accepted: false,
+							error
+						};
 					}
+				});
+				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)}`);
+					throw guardedResult.error;
 				}
 				embeddedAgentLog.info("started codex app-server compaction", {
 					sessionId: params.sessionId,
@@ -498,58 +496,76 @@ async function compactCodexNativeThread(params, options) {
 				});
 				const completion = await completionWatch.completion;
 				if (!completion.completed) throw new Error(completion.reason);
+				tokensAfter = completion.tokensAfter;
+				if (completion.turnId && completion.itemId) await persistCodexContextCompactionActivity({
+					sessionTarget: params.sessionTarget,
+					config: params.config,
+					cwd: params.workspaceDir,
+					runId: params.runId,
+					threadId: binding.threadId,
+					turnId: completion.turnId,
+					itemId: completion.itemId,
+					timestamp: Date.now()
+				});
 				embeddedAgentLog.info("completed codex app-server compaction", {
 					sessionId: params.sessionId,
 					threadId: binding.threadId
 				});
+				compactionSucceeded = true;
 			} catch (error) {
 				if (isCodexThreadNotFoundError(error)) return failedCodexThreadBindingCompactionResult(params, {
 					threadId: binding.threadId,
-					reason: formatCompactionError(error),
+					reason: coerceErrorMessage(error),
 					recovery: "stale_thread_binding"
 				});
 				embeddedAgentLog.warn("codex app-server compaction failed", {
 					sessionId: params.sessionId,
 					sessionKey: params.sessionKey,
 					threadId: binding.threadId,
-					reason: formatCompactionError(error)
+					reason: coerceErrorMessage(error)
 				});
 				return {
 					ok: false,
 					compacted: false,
-					reason: formatCompactionError(error)
+					reason: coerceErrorMessage(error)
 				};
 			} finally {
 				completionWatch.cancel();
-				if (shouldReleaseDefaultLease) releaseLeasedSharedCodexAppServerClient(client);
+				try {
+					if ((compactionSucceeded || compactionRequestDefinitelyRejected) && retainedThreadOwnership) {
+						const ownership = retainedThreadOwnership;
+						if (!(isSameCodexAppServerThreadOwner(await options.bindingStore.read(bindingIdentity), binding) && await options.bindingStore.withLease(bindingIdentity, async () => {
+							if (!isSameCodexAppServerThreadOwner(await options.bindingStore.read(bindingIdentity), binding)) return false;
+							return await retainCodexAppServerLiveThread(client, binding.threadId, ownership.release, ownership.configFingerprint, ownership.serviceTier);
+						}))) await releaseThreadSubscription?.();
+					} else await releaseThreadSubscription?.();
+				} finally {
+					if (shouldReleaseDefaultLease) releaseLeasedSharedCodexAppServerClient(client);
+				}
 			}
-			const resultDetails = {
+			const details = {
 				backend: "codex-app-server",
 				threadId: binding.threadId,
 				signal: "thread/compact/start",
 				pending: false,
 				completed: true,
 				...options.allowNonManualNativeRequest ? {
-					request: "after_context_engine",
+					request: options.nativeCompactionRequest ?? "after_context_engine",
 					trigger: params.trigger ?? "unknown"
 				} : {}
 			};
-			return {
-				ok: true,
+			return codexNativeCompactionResult(params, {
 				compacted: true,
-				result: {
-					summary: "",
-					firstKeptEntryId: "",
-					tokensBefore: params.currentTokenCount ?? 0,
-					details: resultDetails
-				}
-			};
+				tokensAfter,
+				details
+			});
 		});
 	} 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
 			});
@@ -562,27 +578,35 @@ async function compactCodexNativeThread(params, options) {
 		throw error;
 	}
 }
-function skippedCodexNativeCompactionResult(params, skipped) {
+function codexNativeCompactionResult(params, outcome) {
 	return {
 		ok: true,
-		compacted: false,
-		reason: skipped.reason,
+		compacted: outcome.compacted,
+		...outcome.reason ? { reason: outcome.reason } : {},
 		result: {
 			summary: "",
 			firstKeptEntryId: "",
 			tokensBefore: params.currentTokenCount ?? 0,
-			details: {
-				backend: "codex-app-server",
-				skipped: true,
-				reason: skipped.code,
-				request: "after_context_engine",
-				trigger: params.trigger ?? "unknown",
-				...skipped.expectedThreadId ? { expectedThreadId: skipped.expectedThreadId } : {},
-				...skipped.currentThreadId ? { currentThreadId: skipped.currentThreadId } : {}
-			}
+			...outcome.tokensAfter !== void 0 ? { tokensAfter: outcome.tokensAfter } : {},
+			details: outcome.details
 		}
 	};
 }
+function skippedCodexNativeCompactionResult(params, skipped) {
+	return codexNativeCompactionResult(params, {
+		compacted: false,
+		reason: skipped.reason,
+		details: {
+			backend: "codex-app-server",
+			skipped: true,
+			reason: skipped.code,
+			request: skipped.request ?? "after_context_engine",
+			trigger: params.trigger ?? "unknown",
+			...skipped.expectedThreadId ? { expectedThreadId: skipped.expectedThreadId } : {},
+			...skipped.currentThreadId ? { currentThreadId: skipped.currentThreadId } : {}
+		}
+	});
+}
 function failedCodexThreadBindingCompactionResult(params, recovery) {
 	embeddedAgentLog.warn("codex app-server compaction could not use thread binding", {
 		sessionId: params.sessionId,
@@ -620,14 +644,10 @@ async function clearContextEngineProjectionBeforeNativeCompaction(params) {
 	});
 }
 function isSameNativeCompactionBinding(current, expected) {
-	return current.threadId === expected.threadId && current.authProfileId === expected.authProfileId && current.contextEngine?.engineId === expected.contextEngine?.engineId && current.contextEngine?.policyFingerprint === expected.contextEngine?.policyFingerprint && current.contextEngine?.projection?.mode === expected.contextEngine?.projection?.mode && current.contextEngine?.projection?.epoch === expected.contextEngine?.projection?.epoch && current.contextEngine?.projection?.fingerprint === expected.contextEngine?.projection?.fingerprint;
+	return isSameCodexAppServerThreadOwner(current, expected) && current.authProfileId === expected.authProfileId && current.contextEngine?.engineId === expected.contextEngine?.engineId && current.contextEngine?.policyFingerprint === expected.contextEngine?.policyFingerprint && current.contextEngine?.projection?.mode === expected.contextEngine?.projection?.mode && current.contextEngine?.projection?.epoch === expected.contextEngine?.projection?.epoch && current.contextEngine?.projection?.fingerprint === expected.contextEngine?.projection?.fingerprint;
 }
 function isCodexThreadNotFoundError(error) {
-	return formatCompactionError(error).toLowerCase().includes("thread not found");
-}
-function formatCompactionError(error) {
-	if (error instanceof Error) return error.message;
-	return String(error);
+	return coerceErrorMessage(error).toLowerCase().includes("thread not found");
 }
 //#endregion
 export { maybeCompactCodexAppServerSession };