@openclaw/codex 2026.8.1-beta.3 → 2026.8.2

package/dist/{thread-ownership-i2NBwDUL.js → thread-ownership-RkaoZCmQ.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-B1tT5U6r.js";
+import { a as closeCodexStartupClientBestEffort, f as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CpVfwctT.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-BFt1-ZDa.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-CcYL77O6.js";
+import { $ as CodexAppServerRpcError, J as isCodexAppServerOverloadError, P as isCodexAppServerStartupError, Y as isCodexAppServerPrewriteRequestCancellationError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-B1tT5U6r.js";
+import { o as assertCodexThreadResumeResponse } from "./protocol-validators-Bg5rpNxk.js";
+import { f as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CpVfwctT.js";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-BWxweEdK.js";
 import { createRequire } from "node:module";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
@@ -13,7 +16,7 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 * identity and safe to refresh in the background.
 */
 /** Default app inventory cache freshness window. */
-const CODEX_APP_INVENTORY_CACHE_TTL_MS = 3600 * 1e3;
+const CODEX_APP_INVENTORY_CACHE_TTL_MS = 36e5;
 const CODEX_APP_READ_BATCH_LIMIT = 100;
 const MAX_SERIALIZED_ERROR_MESSAGE_LENGTH = 500;
 /** In-memory app inventory cache with coalesced refreshes per key. */
@@ -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
@@ -330,7 +337,8 @@ function isSensitiveErrorDataKey(key) {
 * Builds stable Codex plugin/app inventory cache keys from app-server startup,
 * auth, account, and version inputs without storing secret material.
 */
-const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require: createRequire(import.meta.url) });
+const require = createRequire(import.meta.url);
+const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require });
 let catalogConnectionHomes = /* @__PURE__ */ new Map();
 function catalogConnectionHomeKey(fingerprint, agentDir) {
 	return `${agentDir ?? ""}\0${fingerprint}`;
@@ -348,7 +356,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 +428,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-1ep4XjzF.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 { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.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";
@@ -8,8 +8,8 @@ import { publishSessionTranscriptUpdateByIdentity } from "openclaw/plugin-sdk/se
 import { Buffer } from "node:buffer";
 //#region extensions/codex/src/app-server/transcript-history-projection.ts
 const CODEX_HISTORY_IMPORT_MAX_MESSAGES = 200;
-const CODEX_HISTORY_IMPORT_MAX_BYTES = 512 * 1024;
-const CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES = 64 * 1024;
+const CODEX_HISTORY_IMPORT_MAX_BYTES = 524288;
+const CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES = 65536;
 const CODEX_HISTORY_TRUNCATION_SUFFIX = "\n\n[Message truncated during Codex history import.]";
 const CODEX_HISTORY_ASSISTANT_API = "openai-chatgpt-responses";
 const CODEX_HISTORY_ASSISTANT_PROVIDER = "openai";
@@ -34,7 +34,8 @@ function normalizeImportedHistoryText(value) {
 	if (!text) return;
 	if (Buffer.byteLength(text, "utf8") <= CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES) return text;
 	const suffixBytes = Buffer.byteLength(CODEX_HISTORY_TRUNCATION_SUFFIX, "utf8");
-	return `${truncateUtf8Prefix(text, Math.max(0, CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES - suffixBytes))}${CODEX_HISTORY_TRUNCATION_SUFFIX}`;
+	const contentLimitBytes = Math.max(0, CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES - suffixBytes);
+	return `${truncateUtf8Prefix(text, contentLimitBytes)}${CODEX_HISTORY_TRUNCATION_SUFFIX}`;
 }
 function projectCodexUserItemText(item) {
 	if (!Array.isArray(item.content)) return;
@@ -82,6 +83,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 +97,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 +145,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 +154,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 +179,22 @@ 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 existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const metadata = asOptionalRecord(existing);
+	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 : {};
@@ -188,7 +208,8 @@ function attachCodexMirrorAttestation(message, sourceFingerprint) {
 	};
 }
 function attachCodexMirrorRunId(message, runId, terminal = false) {
-	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0) ?? {};
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(existing) ?? {};
 	return {
 		...message,
 		[CODEX_META_KEY]: {
@@ -198,6 +219,10 @@ function attachCodexMirrorRunId(message, runId, terminal = false) {
 		}
 	};
 }
+function hasCodexMirrorOrigin(message) {
+	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	return asOptionalRecord(meta)?.[MIRROR_ORIGIN_META_KEY] === CODEX_APP_SERVER_MIRROR_ORIGIN;
+}
 function readCodexMirrorSourceFingerprint(message) {
 	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
 	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
@@ -270,6 +295,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 +347,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 +461,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 +480,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 +518,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 +535,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 +560,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 +575,7 @@ async function mirror(params) {
 		}
 		return {
 			appendedUpdates: nextAppendedUpdates,
+			assistantMirrorIdentitiesAppended: [...nextAssistantMirrorIdentitiesAppended],
 			assistantMirrorIdentitiesOwned: [...nextAssistantMirrorIdentitiesOwned],
 			anchorsByMirrorIdentity: nextAnchorsByMirrorIdentity,
 			messagesPresent: nextMessagesPresent,
@@ -562,6 +601,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 +609,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 +691,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, serializeCodexMirrorSourceEvidence as d, projectBoundedCodexThreadHistory as f, mirrorPromptAtTurnStartBestEffort as i, hasCodexMirrorOrigin as l, projectCodexUserItemText as m, createCodexAppServerUserMessagePersistenceNotifier as n, promptSnapshot as o, projectBoundedCodexVisibleSessionHistory as p, importCodexThreadHistoryToTranscript as r, applyCodexTranscriptTaint as s, codexTranscriptMirrorRuntime as t, readCodexMirrorSourceFingerprint as u };