@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

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

@@ -1,15 +1,20 @@
-import { K as releaseCodexAppServerLiveThread, W as isCodexAppServerLiveThreadClaimed, d as retainSharedCodexAppServerClientByInstanceId, q as retainCodexAppServerLiveThread } from "./shared-client-kIBbGjk4.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DMLXUfa8.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-C3H2CVp6.js → thread-resume-DF54hagX.js}

@@ -1,5 +1,8 @@
-import { A as resolveCodexAppServerUserHomeDir } from "./session-binding-DPxIvMgE.js";
-import { dt as resolveCodexAppServerLocalHomeDir, ut as resolveCodexAppServerHomeDir } from "./shared-client-kIBbGjk4.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
@@ -331,6 +338,14 @@ function isSensitiveErrorDataKey(key) {
 * auth, account, and version inputs without storing secret material.
 */
 const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require: createRequire(import.meta.url) });
+let catalogConnectionHomes = /* @__PURE__ */ new Map();
+function catalogConnectionHomeKey(fingerprint, agentDir) {
+	return `${agentDir ?? ""}\0${fingerprint}`;
+}
+/** Replaces the lifecycle-owned catalog connection snapshot used by supervised bindings. */
+function replaceCodexCatalogConnectionHomes(homes) {
+	catalogConnectionHomes = new Map(homes.map((home) => [catalogConnectionHomeKey(home.fingerprint, home.agentDir), home.codexHome]));
+}
 /** Builds the full app inventory cache key for Codex plugin/app discovery. */
 function buildCodexPluginAppCacheKey(params) {
 	return buildCodexAppInventoryCacheKey({
@@ -340,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. */
@@ -364,6 +382,10 @@ function buildCodexAppServerConnectionFingerprint(appServer, agentDir) {
 		cwd: appServer.start.cwd ?? null
 	});
 }
+/** Looks up a snapshotted catalog store without repeating filesystem discovery on a run. */
+function resolveCodexCatalogConnectionHome(fingerprint, agentDir) {
+	return catalogConnectionHomes.get(catalogConnectionHomeKey(fingerprint, agentDir));
+}
 function resolveCodexAppServerConnectionHome(start, agentDir) {
 	const configured = start.env?.CODEX_HOME?.trim();
 	if (configured) return configured;
@@ -405,4 +427,40 @@ function fingerprintCodexPluginAppCacheCredentials(startOptions) {
 	return `sha256:${hash.digest("hex")}`;
 }
 //#endregion
-export { serializeCodexAppInventoryError as a, defaultCodexAppInventoryCache as i, buildCodexAppServerRuntimeFingerprint as n, buildCodexPluginAppCacheKey as r, 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-B9gGgnJS.js → transcript-mirror-CkEQIna-.js}

@@ -1,7 +1,8 @@
-import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-ClRBije0.js";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { embeddedAgentLog, formatErrorMessage, projectAgentHarnessTranscriptMessageForDisplay, runAgentHarnessBeforeMessageWriteHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+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 { 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";
 import { publishSessionTranscriptUpdateByIdentity } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { Buffer } from "node:buffer";
@@ -27,16 +28,6 @@ const CODEX_HISTORY_ZERO_USAGE = {
 		total: 0
 	}
 };
-function isUtf8ContinuationByte(byte) {
-	return byte !== void 0 && (byte & 192) === 128;
-}
-function truncateUtf8Prefix(value, maxBytes) {
-	const bytes = Buffer.from(value);
-	if (bytes.byteLength <= maxBytes) return value;
-	let end = Math.max(0, maxBytes);
-	while (end > 0 && isUtf8ContinuationByte(bytes[end])) end -= 1;
-	return bytes.subarray(0, end).toString("utf8");
-}
 function normalizeImportedHistoryText(value) {
 	if (typeof value !== "string") return;
 	const text = value.trim();
@@ -91,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: [{
@@ -103,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: {
@@ -150,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)
 	};
 }
@@ -159,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;
@@ -183,35 +177,61 @@ function projectBoundedCodexVisibleSessionHistory(entries) {
 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 record = message;
-	const existing = record["__openclaw"];
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
 	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
 	return {
-		...record,
-		__openclaw: {
+		...message,
+		[CODEX_META_KEY]: {
 			...baseMeta,
 			[MIRROR_ORIGIN_META_KEY]: CODEX_APP_SERVER_MIRROR_ORIGIN,
 			...sourceFingerprint ? { [MIRROR_SOURCE_FINGERPRINT_META_KEY]: sourceFingerprint } : {}
 		}
 	};
 }
+function attachCodexMirrorRunId(message, runId, terminal = false) {
+	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0) ?? {};
+	return {
+		...message,
+		[CODEX_META_KEY]: {
+			...current,
+			runId,
+			...terminal ? { runTerminal: true } : {}
+		}
+	};
+}
 function readCodexMirrorSourceFingerprint(message) {
-	const meta = message["__openclaw"];
+	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
 	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
 	const value = meta[MIRROR_SOURCE_FINGERPRINT_META_KEY];
 	return typeof value === "string" && value ? value : void 0;
 }
 function serializeCodexMirrorSourceEvidence(message) {
-	const record = message;
+	const content = "content" in message ? message.content : void 0;
 	return JSON.stringify({
 		role: message.role,
-		content: record.content,
+		content,
 		...message.role === "user" ? { upstreamUserText: readUpstreamUserText(message) } : {},
 		...message.role === "toolResult" ? {
-			toolCallId: record.toolCallId,
-			toolName: record.toolName,
-			isError: record.isError === true
+			toolCallId: message.toolCallId,
+			toolName: message.toolName,
+			isError: message.isError
 		} : {}
 	});
 }
@@ -247,7 +267,7 @@ function buildFromPrepared(params, preparedUserMessage) {
 		...senderUsername ? { senderUsername } : {},
 		...senderE164 ? { senderE164 } : {},
 		...senderLabel ? { senderLabel } : {},
-		...preparedUserMessage ? preparedUserMessage : { content: params.prompt }
+		...preparedUserMessage ?? { content: params.transcriptPrompt ?? params.prompt }
 	};
 }
 function buildCodexUserPromptMessage(params) {
@@ -268,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({
@@ -310,6 +334,13 @@ async function mirrorBestEffort(params) {
 			cwd: params.cwd,
 			messages,
 			idempotencyScope: `codex-app-server:${params.threadId}`,
+			runId: params.params.runId,
+			runMirrorIdentityPrefix: `${params.turnId}:`,
+			terminalAssistantOwner: {
+				mirrorIdentity: `${params.turnId}:assistant`,
+				runId: params.params.runId
+			},
+			prepareAssistantTranscriptMessage: params.params.prepareAssistantTranscriptMessage,
 			config: params.params.config
 		});
 		for (const receipt of mirrorResult.userMessageReceipts) try {
@@ -327,8 +358,9 @@ async function mirrorBestEffort(params) {
 			return identity !== void 0 && readCodexMirrorSourceFingerprint(message) === expectedFingerprints.get(identity);
 		});
 		const assistantMirrorIdentity = `${params.turnId}:assistant`;
-		const assistantTranscriptOwned = mirrorResult.assistantMirrorIdentitiesOwned.includes(assistantMirrorIdentity);
-		const assistantTranscriptIdempotencyKey = normalizeOptionalString((assistantTranscriptOwned ? mirroredMessages.find((message) => readMirrorIdentity(message) === assistantMirrorIdentity) : void 0)?.idempotencyKey);
+		const assistantTranscriptMessage = mirroredMessages.find((message) => readMirrorIdentity(message) === assistantMirrorIdentity);
+		const assistantTranscriptOwned = Boolean(assistantTranscriptMessage && mirrorResult.assistantMirrorIdentitiesOwned.includes(assistantMirrorIdentity));
+		const assistantTranscriptIdempotencyKey = normalizeOptionalString(assistantTranscriptMessage?.idempotencyKey);
 		const terminalMessage = mirroredMessages.at(-1);
 		const terminalMirrorIdentity = terminalMessage ? readMirrorIdentity(terminalMessage) : void 0;
 		const terminalAnchor = (terminalMirrorIdentity ? mirrorResult.anchorsByMirrorIdentity.get(terminalMirrorIdentity) : void 0) ?? params.params.userTurnTranscriptRecorder?.getAdmissionReceipt();
@@ -391,6 +423,8 @@ async function mirrorPromptAtTurnStartBestEffort(params) {
 				cwd: params.cwd,
 				messages: [userPromptMessage],
 				idempotencyScope: `codex-app-server:${params.threadId}`,
+				runId: params.params.runId,
+				runMirrorIdentityPrefix: `${params.turnId}:`,
 				config: params.params.config
 			});
 			for (const receipt of mirrorResult.userMessageReceipts) params.notifyUserMessagePersisted(receipt.message, receipt.anchor);
@@ -420,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: [],
@@ -431,18 +466,19 @@ async function mirror(params) {
 		const sourceFingerprint = fingerprintCodexMirrorSourceMessage(message);
 		return {
 			dedupeIdentity,
-			idempotencyKey: (message.role === "user" ? normalizeOptionalString(message.idempotencyKey) : void 0) ?? (params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0),
+			idempotencyKey: (message.role === "user" ? normalizeOptionalString("idempotencyKey" in message ? message.idempotencyKey : void 0) : void 0) ?? (params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0),
 			message,
 			sourceFingerprint
 		};
 	});
 	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 = [];
@@ -450,8 +486,12 @@ async function mirror(params) {
 		const nextUserMessagesPresent = [];
 		const mirrorFacts = await transcript.readMessageFacts({ idempotencyKeys: candidateIdempotencyKeys });
 		for (const { dedupeIdentity, idempotencyKey, message, sourceFingerprint } of candidates) {
+			const mirrorIdentity = readMirrorIdentity(message);
+			const ownsRun = Boolean(params.runId && (!params.runMirrorIdentityPrefix || mirrorIdentity?.startsWith(params.runMirrorIdentityPrefix)));
+			const terminalOwner = params.terminalAssistantOwner;
+			const ownsTerminal = Boolean(ownsRun && terminalOwner && mirrorIdentity === terminalOwner.mirrorIdentity);
 			const transcriptMessage = {
-				...attachCodexMirrorAttestation(message, sourceFingerprint),
+				...attachCodexMirrorAttestation(ownsRun && params.runId ? attachCodexMirrorRunId(message, params.runId, ownsTerminal) : message, sourceFingerprint),
 				...idempotencyKey ? { idempotencyKey } : {}
 			};
 			if (idempotencyKey && mirrorFacts.existingIdempotencyKeys.has(idempotencyKey)) {
@@ -471,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);
@@ -484,8 +526,9 @@ async function mirror(params) {
 				...attachCodexMirrorAttestation(nextMessage, sourceFingerprint),
 				idempotencyKey
 			} : attachCodexMirrorAttestation(nextMessage, sourceFingerprint);
-			const mirrorIdentity = readMirrorIdentity(message);
 			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
@@ -510,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);
@@ -522,6 +568,7 @@ async function mirror(params) {
 		}
 		return {
 			appendedUpdates: nextAppendedUpdates,
+			assistantMirrorIdentitiesAppended: [...nextAssistantMirrorIdentitiesAppended],
 			assistantMirrorIdentitiesOwned: [...nextAssistantMirrorIdentitiesOwned],
 			anchorsByMirrorIdentity: nextAnchorsByMirrorIdentity,
 			messagesPresent: nextMessagesPresent,
@@ -530,6 +577,8 @@ async function mirror(params) {
 		};
 	});
 	for (const update of appendedUpdates) try {
+		const terminalOwner = params.terminalAssistantOwner;
+		const terminalRunId = update.message.role === "assistant" && terminalOwner && readMirrorIdentity(update.message) === terminalOwner.mirrorIdentity ? terminalOwner.runId : void 0;
 		await publishSessionTranscriptUpdateByIdentity({
 			...transcriptTarget,
 			update: {
@@ -537,6 +586,7 @@ async function mirror(params) {
 				message: update.message,
 				messageId: update.messageId,
 				...update.messageSeq !== void 0 ? { messageSeq: update.messageSeq } : {},
+				...terminalRunId ? { runId: terminalRunId } : {},
 				sessionKey: transcriptTarget.sessionKey
 			}
 		});
@@ -544,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,
@@ -551,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();
@@ -567,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 };