@openclaw/codex 2026.8.1-beta.3 → 2026.8.1

package/dist/{thread-ownership-i2NBwDUL.js → thread-ownership-CeYBqg_4.js}

@@ -1,15 +1,20 @@
-import { J as releaseCodexAppServerLiveThread, K as isCodexAppServerLiveThreadClaimed, Y as retainCodexAppServerLiveThread, d as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-Dw-rzii0.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-URjUlCHg.js";
+import { Ct as retainCodexAppServerLiveThread, St as releaseCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, bt as isCodexAppServerLiveThreadClaimed } from "./shared-client-kNkljY-R.js";
+import { a as closeCodexStartupClientBestEffort, f as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CVPvp9dL.js";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/routing";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 //#region extensions/codex/src/app-server/thread-ownership.ts
 const nativeThreadOwners = new KeyedAsyncQueue();
+/** Serialize connection-scoped unsubscribe with attach/resume of the same native thread. */
+async function withCodexAppServerThreadMutation(threadId, run) {
+	return await nativeThreadOwners.enqueue(`thread:${threadId}`, run);
+}
 /** Codex subscriptions belong to a physical connection, not the native thread ID alone. */
 function isSameCodexAppServerThreadOwner(current, expected) {
 	return current !== void 0 && expected !== void 0 && current.threadId === expected.threadId && current.clientId === expected.clientId;
 }
 /** Fences native subscription and commit together; Codex subscriptions are not reference-counted. */
 async function withExclusiveCodexAppServerThread(params) {
-	return await nativeThreadOwners.enqueue(`thread:${params.threadId}`, async () => {
+	return await withCodexAppServerThreadMutation(params.threadId, async () => {
 		if (await params.bindingStore.hasOtherThreadOwner(params.threadId, params.identity)) throw new Error(`Codex thread ${params.threadId} is owned by another OpenClaw session or conversation.`);
 		return await params.run();
 	});
@@ -20,11 +25,13 @@ async function withCodexConversationThreadActivity(bindingId, run) {
 }
 /** Publishes one owned persistent subscription into the shared bounded idle registry. */
 async function retainCodexAppServerBindingSubscription(client, threadId, ownership) {
-	return await retainCodexAppServerLiveThread(client, threadId, ownership?.release ?? (async (releasedThreadId) => {
+	return await retainCodexAppServerLiveThread(client, threadId, ownership?.release ?? (async (releasedThreadId, assertCurrent) => {
 		if (!await unsubscribeCodexThreadBestEffort(client, {
 			threadId: releasedThreadId,
-			timeoutMs: 5e3
+			timeoutMs: 5e3,
+			assertCurrent
 		})) {
+			assertCurrent?.();
 			await closeCodexStartupClientBestEffort(client);
 			throw new CodexAppServerUnsafeSubscriptionError(`Codex thread subscription could not be released: ${releasedThreadId}`);
 		}
@@ -41,15 +48,18 @@ async function rollbackCodexAppServerBindingSubscription(client, threadId, retai
 }
 /** Releases only the physical client and native thread recorded by the displaced binding owner. */
 async function releaseCodexAppServerBindingSubscription(binding, options = {}) {
+	options.assertCurrent?.();
 	const clientLease = retainSharedCodexAppServerClientByInstanceId(binding.clientId);
 	if (!clientLease) return;
 	try {
-		if (await releaseCodexAppServerLiveThread(clientLease.client, binding.threadId)) return;
+		if (await releaseCodexAppServerLiveThread(clientLease.client, binding.threadId, options.assertCurrent)) return;
+		options.assertCurrent?.();
 		if (isCodexAppServerLiveThreadClaimed(clientLease.client, binding.threadId)) throw new Error(`Codex thread ${binding.threadId} has an active run; stop it before changing its owner.`);
 		if (!options.allowUntracked) return;
 		if (!await unsubscribeCodexThreadBestEffort(clientLease.client, {
 			threadId: binding.threadId,
-			timeoutMs: 5e3
+			timeoutMs: 5e3,
+			assertCurrent: options.assertCurrent
 		})) {
 			await closeCodexStartupClientBestEffort(clientLease.client);
 			throw new CodexAppServerUnsafeSubscriptionError(`Codex retired thread subscription could not be released: ${binding.threadId}`);
@@ -89,4 +99,4 @@ async function retireCodexConversationThreadBinding(params) {
 	});
 }
 //#endregion
-export { rollbackCodexAppServerBindingSubscription as a, retireCodexConversationThreadBinding as i, releaseCodexAppServerBindingSubscription as n, withCodexConversationThreadActivity as o, retainCodexAppServerBindingSubscription as r, withExclusiveCodexAppServerThread as s, isSameCodexAppServerThreadOwner as t };
+export { rollbackCodexAppServerBindingSubscription as a, withExclusiveCodexAppServerThread as c, retireCodexConversationThreadBinding as i, isIncognitoSessionKey as l, releaseCodexAppServerBindingSubscription as n, withCodexAppServerThreadMutation as o, retainCodexAppServerBindingSubscription as r, withCodexConversationThreadActivity as s, isSameCodexAppServerThreadOwner as t };

package/dist/{plugin-app-cache-key-DMNQ8Zi8.js → thread-resume-DF54hagX.js}

@@ -1,5 +1,8 @@
-import { x as resolveCodexAppServerUserHomeDir } from "./config-CpNeo5AE.js";
-import { ft as resolveCodexAppServerHomeDir, pt as resolveCodexAppServerLocalHomeDir } from "./shared-client-Dw-rzii0.js";
+import { F as resolveCodexAppServerLocalHomeDir, I as resolveCodexAppServerUserHomeDir, P as resolveCodexAppServerHomeDir } from "./config-Cxw3Cl3k.js";
+import { $ as CodexAppServerRpcError, J as isCodexAppServerOverloadError, P as isCodexAppServerStartupError, Y as isCodexAppServerPrewriteRequestCancellationError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-kNkljY-R.js";
+import { o as assertCodexThreadResumeResponse } from "./protocol-validators-Bg5rpNxk.js";
+import { f as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CVPvp9dL.js";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-CCm4LaED.js";
 import { createRequire } from "node:module";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
@@ -264,7 +267,10 @@ async function readInstalledApps(request, options) {
 		apps: [],
 		installedApps: []
 	};
-	const metadataResponses = await Promise.all(Array.from({ length: Math.ceil(apps.length / CODEX_APP_READ_BATCH_LIMIT) }, (_, index) => request("app/read", { appIds: apps.slice(index * CODEX_APP_READ_BATCH_LIMIT, (index + 1) * CODEX_APP_READ_BATCH_LIMIT).map((app) => app.id) })));
+	const metadataResponses = await Promise.all(Array.from({ length: Math.ceil(apps.length / CODEX_APP_READ_BATCH_LIMIT) }, (_, index) => request("app/read", {
+		appIds: apps.slice(index * CODEX_APP_READ_BATCH_LIMIT, (index + 1) * CODEX_APP_READ_BATCH_LIMIT).map((app) => app.id),
+		includeTools: true
+	})));
 	const metadataById = new Map(metadataResponses.flatMap((response) => response.apps).map((metadata) => [metadata.id, metadata]));
 	return {
 		apps: apps.flatMap((installedApp) => {
@@ -283,7 +289,8 @@ async function readInstalledApps(request, options) {
 				installUrl: metadata.installUrl ?? null,
 				isAccessible: true,
 				isEnabled: installedApp.enabled,
-				pluginDisplayNames: metadata.pluginDisplayNames
+				pluginDisplayNames: metadata.pluginDisplayNames,
+				...metadata.toolSummaries ? { toolSummaries: metadata.toolSummaries } : {}
 			}];
 		}),
 		installedApps: apps
@@ -348,7 +355,10 @@ function buildCodexPluginAppCacheKey(params) {
 		accountId: params.accountId,
 		envApiKeyFingerprint: params.envApiKeyFingerprint,
 		appServerVersion: params.appServerVersion ?? params.runtimeIdentity?.serverVersion,
-		runtimeIdentity: params.runtimeIdentity
+		runtimeIdentity: params.desktopGenerationFingerprint ? {
+			...params.runtimeIdentity,
+			desktopGeneration: params.desktopGenerationFingerprint
+		} : params.runtimeIdentity
 	}, OPENCLAW_VERSION, CODEX_PLUGIN_VERSION);
 }
 /** Builds a durable thread-binding fingerprint for one initialized app-server runtime. */
@@ -417,4 +427,40 @@ function fingerprintCodexPluginAppCacheCredentials(startOptions) {
 	return `sha256:${hash.digest("hex")}`;
 }
 //#endregion
-export { resolveCodexCatalogConnectionHome as a, replaceCodexCatalogConnectionHomes as i, buildCodexAppServerRuntimeFingerprint as n, defaultCodexAppInventoryCache as o, buildCodexPluginAppCacheKey as r, serializeCodexAppInventoryError as s, buildCodexAppServerConnectionFingerprint as t };
+//#region extensions/codex/src/app-server/thread-resume.ts
+/** Owns Codex thread/resume subscription safety. */
+/** Resumes one thread, releasing or isolating every possible native subscription. */
+async function resumeCodexAppServerThread(params) {
+	const threadId = params.request.threadId;
+	let response;
+	try {
+		response = assertCodexThreadResumeResponse(await (params.requestResume ? params.requestResume(params.request) : params.client.request("thread/resume", params.request, {
+			...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {},
+			assertCurrent: params.assertCurrent
+		})));
+		assertCodexThreadResumeSubscription(threadId, response.thread.id);
+	} catch (error) {
+		if (params.isPrewriteOwnershipError?.(error) || isCodexAppServerStartSelectionChangedError(error) || isCodexAppServerStartupError(error) || error instanceof CodexAppServerScopedRequestRejectedError || isCodexAppServerPrewriteRequestCancellationError(error) || isCodexAppServerOverloadError(error)) throw error;
+		if (error instanceof CodexAppServerRpcError) {
+			if (await unsubscribeCodexThreadBestEffort(params.client, {
+				threadId,
+				timeoutMs: 5e3,
+				assertCurrent: params.assertCurrent
+			}).catch(() => false)) {
+				params.onSubscriptionReleased?.();
+				throw error;
+			}
+		}
+		try {
+			await params.abandonClient();
+		} catch (abandonError) {
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex thread/resume client could not be retired for ${threadId}`, { cause: abandonError });
+		}
+		if (error instanceof CodexAppServerUnsafeSubscriptionError) throw error;
+		throw new CodexAppServerUnsafeSubscriptionError(error instanceof Error ? error.message : `Codex thread/resume outcome is indeterminate for ${threadId}`, { cause: error });
+	}
+	return response;
+}
+//#endregion
+export { replaceCodexCatalogConnectionHomes as a, serializeCodexAppInventoryError as c, buildCodexPluginAppCacheKey as i, buildCodexAppServerConnectionFingerprint as n, resolveCodexCatalogConnectionHome as o, buildCodexAppServerRuntimeFingerprint as r, defaultCodexAppInventoryCache as s, resumeCodexAppServerThread as t };

package/dist/{transcript-mirror-BU0_LKAL.js → transcript-mirror-CkEQIna-.js}

@@ -1,6 +1,6 @@
 import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { embeddedAgentLog, formatErrorMessage, projectAgentHarnessTranscriptMessageForDisplay, runAgentHarnessBeforeMessageWriteHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { deliverAgentHarnessUserInputPrompt, embeddedAgentLog, formatErrorMessage, projectAgentHarnessTranscriptMessageForDisplay, runAgentHarnessBeforeMessageWriteHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
 import { truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
 import { withCodexSessionTranscriptMirrorWriteLock } from "openclaw/plugin-sdk/codex-session-transcript-runtime";
@@ -82,6 +82,8 @@ function projectCodexThreadHistory(params) {
 		const role = item.type === "userMessage" ? "user" : item.type === "agentMessage" ? "assistant" : void 0;
 		itemOffset += 1;
 		if (!text || !role) continue;
+		const phase = item.phase === "commentary" || item.phase === "final_answer" ? item.phase : void 0;
+		const asyncDelivery = item.delivery === "async";
 		const message = role === "assistant" ? attachCodexMirrorIdentity({
 			role,
 			content: [{
@@ -94,13 +96,14 @@ function projectCodexThreadHistory(params) {
 			usage: CODEX_HISTORY_ZERO_USAGE,
 			stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop",
 			...turn.status === "failed" && turn.error?.message ? { errorMessage: turn.error.message } : {},
+			...phase ? { phase } : {},
+			...asyncDelivery && itemId ? { openclawAsyncDelivery: { itemId } } : {},
 			timestamp
 		}, identity) : attachCodexMirrorIdentity({
 			role,
 			content: text,
 			timestamp
 		}, identity);
-		const phase = item.phase === "commentary" || item.phase === "final_answer" ? item.phase : void 0;
 		projected.push({
 			message,
 			responseItem: {
@@ -141,7 +144,7 @@ function projectBoundedCodexThreadHistory(params) {
 	return {
 		importedMessages: selected.length,
 		omittedMessages: projected.length - selected.length,
-		responseItems: selected.filter(({ message }) => message.role !== "assistant" || message.stopReason !== "aborted" && message.stopReason !== "error").map(({ responseItem }) => responseItem),
+		responseItems: selected.filter(({ message }) => message.role !== "assistant" || message.stopReason !== "aborted" && message.stopReason !== "error" && !("openclawAsyncDelivery" in message)).map(({ responseItem }) => responseItem),
 		transcriptMessages: selected.map(({ message }) => message)
 	};
 }
@@ -150,7 +153,7 @@ function projectBoundedCodexVisibleSessionHistory(entries) {
 	const projected = [];
 	for (const entry of entries) {
 		if (entry.role !== "user" && entry.role !== "assistant" || !("content" in entry.message)) continue;
-		if (entry.role === "assistant" && "stopReason" in entry.message && (entry.message.stopReason === "aborted" || entry.message.stopReason === "error")) continue;
+		if (entry.role === "assistant" && ("stopReason" in entry.message && (entry.message.stopReason === "aborted" || entry.message.stopReason === "error") || "openclawAsyncDelivery" in entry.message)) continue;
 		const content = entry.message.content;
 		const text = normalizeImportedHistoryText(typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((part) => part && typeof part === "object" && "text" in part && typeof part.text === "string" ? [part.text] : []).join("\n") : void 0);
 		if (!text) continue;
@@ -175,6 +178,21 @@ const MIRROR_ORIGIN_META_KEY = "mirrorOrigin";
 const MIRROR_SOURCE_FINGERPRINT_META_KEY = "mirrorSourceFingerprint";
 const CODEX_APP_SERVER_MIRROR_ORIGIN = "codex-app-server";
 const CODEX_META_KEY = "__openclaw";
+function applyCodexTranscriptTaint(message, state) {
+	if (message.role === "user") {
+		state.tainted = false;
+		return message;
+	}
+	const metadata = asOptionalRecord(CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0);
+	state.tainted ||= metadata?.turnTainted === true || metadata?.resultContentSource === "network";
+	return message.role === "assistant" && state.tainted ? {
+		...message,
+		__openclaw: {
+			...metadata,
+			turnTainted: true
+		}
+	} : message;
+}
 function attachCodexMirrorAttestation(message, sourceFingerprint) {
 	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
 	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
@@ -270,6 +288,10 @@ async function buildResolvedCodexUserPromptMessage(params) {
 function isMirroredAgentMessage(message) {
 	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
 }
+function readMirroredAssistantText(message) {
+	if (message?.role !== "assistant") return;
+	return message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n") || void 0;
+}
 /** Imports a bounded, user-visible Codex history tail into a new OpenClaw transcript. */
 async function importCodexThreadHistoryToTranscript(params) {
 	const projection = projectBoundedCodexThreadHistory({
@@ -318,6 +340,7 @@ async function mirrorBestEffort(params) {
 				mirrorIdentity: `${params.turnId}:assistant`,
 				runId: params.params.runId
 			},
+			prepareAssistantTranscriptMessage: params.params.prepareAssistantTranscriptMessage,
 			config: params.params.config
 		});
 		for (const receipt of mirrorResult.userMessageReceipts) try {
@@ -431,6 +454,7 @@ function buildMirrorDedupeIdentity(message) {
 async function mirror(params) {
 	const messages = params.messages.filter(isMirroredAgentMessage);
 	if (messages.length === 0) return {
+		assistantMirrorIdentitiesAppended: [],
 		assistantMirrorIdentitiesOwned: [],
 		anchorsByMirrorIdentity: /* @__PURE__ */ new Map(),
 		messagesPresent: [],
@@ -449,11 +473,12 @@ async function mirror(params) {
 	});
 	const candidateIdempotencyKeys = candidates.flatMap(({ idempotencyKey }) => idempotencyKey ? [idempotencyKey] : []);
 	const transcriptTarget = resolveCodexMirrorTranscriptTarget(params);
-	const { appendedUpdates, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts, userMessagesPresent } = await withCodexSessionTranscriptMirrorWriteLock({
+	const { appendedUpdates, assistantMirrorIdentitiesAppended, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts, userMessagesPresent } = await withCodexSessionTranscriptMirrorWriteLock({
 		...transcriptTarget,
 		config: params.config
 	}, async (transcript) => {
 		const nextAppendedUpdates = [];
+		const nextAssistantMirrorIdentitiesAppended = /* @__PURE__ */ new Set();
 		const nextAssistantMirrorIdentitiesOwned = /* @__PURE__ */ new Set();
 		const nextAnchorsByMirrorIdentity = /* @__PURE__ */ new Map();
 		const nextMessagesPresent = [];
@@ -486,10 +511,12 @@ async function mirror(params) {
 				if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
 				continue;
 			}
-			const nextMessage = params.skipBeforeMessageWriteHooks ? transcriptMessage : runAgentHarnessBeforeMessageWriteHook({
+			const nextMessage = runAgentHarnessBeforeMessageWriteHook({
 				message: transcriptMessage,
 				agentId: params.agentId,
-				sessionKey: params.sessionKey
+				sessionKey: params.sessionKey,
+				skipBeforeMessageWriteHooks: params.skipBeforeMessageWriteHooks,
+				prepareAssistantTranscriptMessage: ownsTerminal ? params.prepareAssistantTranscriptMessage : void 0
 			});
 			if (!nextMessage) {
 				if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
@@ -501,6 +528,7 @@ async function mirror(params) {
 			} : attachCodexMirrorAttestation(nextMessage, sourceFingerprint);
 			if (mirrorIdentity) messageToAppend = attachCodexMirrorIdentity(messageToAppend, mirrorIdentity);
 			if (ownsRun && params.runId) messageToAppend = attachCodexMirrorRunId(messageToAppend, params.runId, ownsTerminal);
+			if (message.role === "assistant" && message.openclawAsyncDelivery) messageToAppend = Object.assign(messageToAppend, { openclawAsyncDelivery: { itemId: message.openclawAsyncDelivery.itemId } });
 			messageToAppend = projectAgentHarnessTranscriptMessageForDisplay({
 				hidden: message.display === false,
 				message: messageToAppend
@@ -525,11 +553,14 @@ async function mirror(params) {
 					message: appendedMessage
 				});
 			}
-			if (appended.appended) nextAppendedUpdates.push({
-				messageId,
-				message: appendedMessage,
-				...messageSeq !== void 0 ? { messageSeq } : {}
-			});
+			if (appended.appended) {
+				if (message.role === "assistant") nextAssistantMirrorIdentitiesAppended.add(dedupeIdentity);
+				nextAppendedUpdates.push({
+					messageId,
+					message: appendedMessage,
+					...messageSeq !== void 0 ? { messageSeq } : {}
+				});
+			}
 			if (idempotencyKey) {
 				mirrorFacts.existingIdempotencyKeys.add(idempotencyKey);
 				if (appended.anchor) mirrorFacts.anchorsByIdempotencyKey.set(idempotencyKey, appended.anchor);
@@ -537,6 +568,7 @@ async function mirror(params) {
 		}
 		return {
 			appendedUpdates: nextAppendedUpdates,
+			assistantMirrorIdentitiesAppended: [...nextAssistantMirrorIdentitiesAppended],
 			assistantMirrorIdentitiesOwned: [...nextAssistantMirrorIdentitiesOwned],
 			anchorsByMirrorIdentity: nextAnchorsByMirrorIdentity,
 			messagesPresent: nextMessagesPresent,
@@ -562,6 +594,7 @@ async function mirror(params) {
 		embeddedAgentLog.warn("failed to publish codex app-server transcript update", { error: formatErrorMessage(error) });
 	}
 	return {
+		assistantMirrorIdentitiesAppended,
 		assistantMirrorIdentitiesOwned,
 		anchorsByMirrorIdentity,
 		messagesPresent,
@@ -569,10 +602,76 @@ async function mirror(params) {
 		userMessagesPresent
 	};
 }
+async function deliverAsyncMessageBestEffort(params) {
+	const mirrorIdentity = `${params.turnId}:async:${params.itemId}`;
+	const deliveryIntentId = `block-reply:v1:codex-app-server:${[
+		params.threadId,
+		params.turnId,
+		params.itemId
+	].map(encodeURIComponent).join(":")}`;
+	const target = params.params.sessionTarget;
+	if (!target) {
+		if (!params.params.onBlockReply) return "retry";
+		try {
+			await deliverAsyncBlockReply(params.params.onBlockReply, params.text, deliveryIntentId);
+			return "settled";
+		} catch (error) {
+			embeddedAgentLog.warn("failed to deliver codex async agent message", {
+				error: formatErrorMessage(error),
+				itemId: params.itemId,
+				runId: params.params.runId,
+				threadId: params.threadId,
+				turnId: params.turnId
+			});
+			return "retry";
+		}
+	}
+	let result;
+	try {
+		result = await mirror({
+			agentId: target.agentId ?? params.params.agentId,
+			sessionId: target.sessionId ?? params.params.sessionId,
+			sessionKey: target.sessionKey ?? params.params.sessionKey,
+			storePath: target.storePath,
+			cwd: params.cwd,
+			config: params.params.config,
+			messages: [attachCodexMirrorIdentity(params.message, mirrorIdentity)],
+			idempotencyScope: `codex-app-server:${params.threadId}`
+		});
+	} catch (error) {
+		embeddedAgentLog.warn("failed to persist codex async agent message", {
+			error: formatErrorMessage(error),
+			itemId: params.itemId,
+			runId: params.params.runId,
+			threadId: params.threadId,
+			turnId: params.turnId
+		});
+		return "retry";
+	}
+	if (!result.assistantMirrorIdentitiesOwned.includes(mirrorIdentity)) return "retry";
+	const persistedText = readMirroredAssistantText(result.messagesPresent.find((message) => readMirrorIdentity(message) === mirrorIdentity));
+	if (params.params.onBlockReply && persistedText !== void 0) try {
+		await deliverAsyncBlockReply(params.params.onBlockReply, persistedText, deliveryIntentId);
+	} catch (error) {
+		embeddedAgentLog.warn("failed to deliver persisted codex async agent message", {
+			error: formatErrorMessage(error),
+			itemId: params.itemId,
+			runId: params.params.runId,
+			threadId: params.threadId,
+			turnId: params.turnId
+		});
+		return "retry";
+	}
+	return "settled";
+}
 const codexTranscriptMirrorRuntime = {
+	deliverAsyncMessageBestEffort,
 	mirror,
 	mirrorBestEffort
 };
+async function deliverAsyncBlockReply(onBlockReply, text, deliveryIntentId) {
+	await deliverAgentHarnessUserInputPrompt({ onBlockReply: (payload) => onBlockReply(payload, { deliveryIntentId }) }, [], { intro: text });
+}
 function resolveCodexMirrorTranscriptTarget(params) {
 	const sessionKey = params.sessionKey?.trim();
 	const storePath = params.storePath?.trim();
@@ -585,4 +684,4 @@ function resolveCodexMirrorTranscriptTarget(params) {
 	};
 }
 //#endregion
-export { buildCodexUserPromptMessage as a, readCodexMirrorSourceFingerprint as c, projectBoundedCodexVisibleSessionHistory as d, mirrorPromptAtTurnStartBestEffort as i, serializeCodexMirrorSourceEvidence as l, createCodexAppServerUserMessagePersistenceNotifier as n, promptSnapshot as o, importCodexThreadHistoryToTranscript as r, fingerprintCodexMirrorSourceMessage as s, codexTranscriptMirrorRuntime as t, projectBoundedCodexThreadHistory as u };
+export { buildCodexUserPromptMessage as a, fingerprintCodexMirrorSourceMessage as c, projectBoundedCodexThreadHistory as d, projectBoundedCodexVisibleSessionHistory as f, mirrorPromptAtTurnStartBestEffort as i, readCodexMirrorSourceFingerprint as l, createCodexAppServerUserMessagePersistenceNotifier as n, promptSnapshot as o, projectCodexUserItemText as p, importCodexThreadHistoryToTranscript as r, applyCodexTranscriptTaint as s, codexTranscriptMirrorRuntime as t, serializeCodexMirrorSourceEvidence as u };