@openclaw/codex 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/thread-ownership-6kOQHlyC.js

@@ -0,0 +1,92 @@
+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 { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+//#region extensions/codex/src/app-server/thread-ownership.ts
+const nativeThreadOwners = new KeyedAsyncQueue();
+/** 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 () => {
+		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();
+	});
+}
+/** Serializes bound turns and retirement so detach cannot unsubscribe an active turn. */
+async function withCodexConversationThreadActivity(bindingId, run) {
+	return await nativeThreadOwners.enqueue(`conversation:${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) => {
+		if (!await unsubscribeCodexThreadBestEffort(client, {
+			threadId: releasedThreadId,
+			timeoutMs: 5e3
+		})) {
+			await closeCodexStartupClientBestEffort(client);
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex thread subscription could not be released: ${releasedThreadId}`);
+		}
+	}), ownership?.configFingerprint, ownership?.serviceTier);
+}
+/** Rolls back the exact subscription Codex created before its binding was committed. */
+async function rollbackCodexAppServerBindingSubscription(client, threadId, retained) {
+	if (retained && await releaseCodexAppServerLiveThread(client, threadId)) return;
+	if (isCodexAppServerLiveThreadClaimed(client, threadId)) return;
+	if (!await unsubscribeCodexThreadBestEffort(client, {
+		threadId,
+		timeoutMs: 5e3
+	})) await closeCodexStartupClientBestEffort(client);
+}
+/** Releases only the physical client and native thread recorded by the displaced binding owner. */
+async function releaseCodexAppServerBindingSubscription(binding, options = {}) {
+	const clientLease = retainSharedCodexAppServerClientByInstanceId(binding.clientId);
+	if (!clientLease) return;
+	try {
+		if (await releaseCodexAppServerLiveThread(clientLease.client, binding.threadId)) return;
+		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
+		})) {
+			await closeCodexStartupClientBestEffort(clientLease.client);
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex retired thread subscription could not be released: ${binding.threadId}`);
+		}
+	} finally {
+		clientLease.release();
+	}
+}
+/** Clears and releases one exact conversation generation without touching its replacement. */
+async function retireCodexConversationThreadBinding(params) {
+	const expected = await params.bindingStore.read(params.identity);
+	if (!expected || params.expectedThreadId && expected.threadId !== params.expectedThreadId) return false;
+	return await params.bindingStore.withLease(params.identity, async () => {
+		const current = await params.bindingStore.read(params.identity);
+		if (current?.threadId !== expected.threadId || params.expectedStartId && current.conversationStartId !== params.expectedStartId) return false;
+		await releaseCodexAppServerBindingSubscription(current, { allowUntracked: params.allowUntracked });
+		const cleared = await params.bindingStore.mutate(params.identity, {
+			kind: "clear",
+			threadId: current.threadId
+		});
+		if (!cleared || !params.afterClear) return cleared;
+		try {
+			await params.afterClear();
+			return true;
+		} catch (error) {
+			try {
+				if (!await params.bindingStore.mutate(params.identity, {
+					kind: "set",
+					binding: current,
+					if: { kind: "absent" }
+				})) throw new Error("the previous Codex binding generation could not be restored", { cause: error });
+			} catch (restorationError) {
+				throw new AggregateError([error, restorationError], `Codex conversation detachment failed and native thread ${current.threadId} could not be restored; run /codex resume ${current.threadId} to recover it`, { cause: restorationError });
+			}
+			throw error;
+		}
+	});
+}
+//#endregion
+export { rollbackCodexAppServerBindingSubscription as a, retireCodexConversationThreadBinding as i, releaseCodexAppServerBindingSubscription as n, withCodexConversationThreadActivity as o, retainCodexAppServerBindingSubscription as r, withExclusiveCodexAppServerThread as s, isSameCodexAppServerThreadOwner as t };

package/dist/thread-resume-CPrJNQVM.js

@@ -0,0 +1,30 @@
+import { F as isCodexAppServerPrewriteRequestCancellationError, s as isCodexAppServerStartSelectionChangedError, z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
+import { i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DMLXUfa8.js";
+import { i as assertCodexThreadResumeResponse } from "./protocol-validators-B4F7L8Rf.js";
+//#region extensions/codex/src/app-server/thread-resume.ts
+/** Owns Codex thread/resume subscription safety. */
+/** Resumes one thread and retires the physical client when acceptance is indeterminate. */
+async function resumeCodexAppServerThread(params) {
+	const threadId = params.request.threadId;
+	let response;
+	try {
+		response = assertCodexThreadResumeResponse(await params.client.request("thread/resume", params.request, {
+			...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {}
+		}));
+		assertCodexThreadResumeSubscription(threadId, response.thread.id);
+	} catch (error) {
+		if (isCodexAppServerStartSelectionChangedError(error) || isCodexAppServerPrewriteRequestCancellationError(error)) throw error;
+		if (error instanceof CodexAppServerRpcError) 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 { resumeCodexAppServerThread as t };

package/dist/{transcript-mirror-uKA-A4tB.js → transcript-mirror-B9gGgnJS.js}

@@ -1,137 +1,11 @@
+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 { createHash } from "node:crypto";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-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";
-import { publishSessionTranscriptUpdateByIdentity, withSessionTranscriptWriteLock } from "openclaw/plugin-sdk/session-transcript-runtime";
-//#region extensions/codex/src/app-server/upstream-prompt-provenance.ts
-const UPSTREAM_USER_TEXT_META_KEY = "upstreamUserText";
-const MIRROR_IDENTITY_META_KEY = "mirrorIdentity";
-function attachCodexMirrorIdentity(message, identity) {
-	const record = message;
-	const existing = record["__openclaw"];
-	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
-	return {
-		...record,
-		__openclaw: {
-			...baseMeta,
-			[MIRROR_IDENTITY_META_KEY]: identity
-		}
-	};
-}
-function readMirrorIdentity(message) {
-	const meta = message["__openclaw"];
-	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
-	const id = meta[MIRROR_IDENTITY_META_KEY];
-	return typeof id === "string" && id ? id : void 0;
-}
-function attachUpstreamUserText(message, text) {
-	const record = message;
-	const existing = record["__openclaw"];
-	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
-	return {
-		...record,
-		__openclaw: {
-			...baseMeta,
-			[UPSTREAM_USER_TEXT_META_KEY]: text
-		}
-	};
-}
-function readUpstreamUserText(message) {
-	const meta = message?.["__openclaw"];
-	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
-	const text = meta[UPSTREAM_USER_TEXT_META_KEY];
-	return typeof text === "string" && text ? text : void 0;
-}
-//#endregion
-//#region extensions/codex/src/app-server/transcript-mirror-attestation.ts
-const MIRROR_ORIGIN_META_KEY = "mirrorOrigin";
-const MIRROR_SOURCE_FINGERPRINT_META_KEY = "mirrorSourceFingerprint";
-const CODEX_APP_SERVER_MIRROR_ORIGIN = "codex-app-server";
-function attachCodexMirrorAttestation(message, sourceFingerprint) {
-	const record = message;
-	const existing = record["__openclaw"];
-	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
-	return {
-		...record,
-		__openclaw: {
-			...baseMeta,
-			[MIRROR_ORIGIN_META_KEY]: CODEX_APP_SERVER_MIRROR_ORIGIN,
-			...sourceFingerprint ? { [MIRROR_SOURCE_FINGERPRINT_META_KEY]: sourceFingerprint } : {}
-		}
-	};
-}
-function readCodexMirrorSourceFingerprint(message) {
-	const meta = message["__openclaw"];
-	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;
-	return JSON.stringify({
-		role: message.role,
-		content: record.content,
-		...message.role === "user" ? { upstreamUserText: readUpstreamUserText(message) } : {},
-		...message.role === "toolResult" ? {
-			toolCallId: record.toolCallId,
-			toolName: record.toolName,
-			isError: record.isError === true
-		} : {}
-	});
-}
-function fingerprintCodexMirrorSourceMessage(message) {
-	return createHash("sha256").update(serializeCodexMirrorSourceEvidence(message)).digest("hex").slice(0, 32);
-}
-//#endregion
-//#region extensions/codex/src/app-server/user-prompt-message.ts
-function buildSenderLabel(params) {
-	const label = params.senderName ?? params.senderUsername ?? params.senderE164 ?? params.senderId;
-	if (!label) return;
-	return !params.senderId || label.includes(params.senderId) ? label : `${label} (${params.senderId})`;
-}
-function buildFromPrepared(params, preparedUserMessage) {
-	const senderId = normalizeOptionalString(params.senderId);
-	const senderName = normalizeOptionalString(params.senderName);
-	const senderUsername = normalizeOptionalString(params.senderUsername);
-	const senderE164 = normalizeOptionalString(params.senderE164);
-	const senderLabel = buildSenderLabel({
-		senderId,
-		senderName,
-		senderUsername,
-		senderE164
-	});
-	const sourceChannel = normalizeOptionalString(params.inputProvenance?.sourceChannel ?? params.messageChannel ?? params.messageProvider);
-	return {
-		role: "user",
-		timestamp: Date.now(),
-		...params.inputProvenance ? { provenance: params.inputProvenance } : {},
-		...sourceChannel ? { sourceChannel } : {},
-		...senderId ? { senderId } : {},
-		...senderName ? { senderName } : {},
-		...senderUsername ? { senderUsername } : {},
-		...senderE164 ? { senderE164 } : {},
-		...senderLabel ? { senderLabel } : {},
-		...preparedUserMessage ? preparedUserMessage : { content: params.prompt }
-	};
-}
-function buildCodexUserPromptMessage(params) {
-	return buildFromPrepared(params, params.userTurnTranscriptRecorder?.message);
-}
-function buildCodexUpstreamPromptMessage(params, identity, upstreamUserText) {
-	const message = attachCodexMirrorIdentity(buildCodexUserPromptMessage(params), identity);
-	return upstreamUserText ? attachUpstreamUserText(message, upstreamUserText) : message;
-}
-function promptSnapshot(params, turnId, upstreamUserText) {
-	return params.suppressNextUserMessagePersistence ? [] : [buildCodexUpstreamPromptMessage(params, `${turnId}:prompt`, upstreamUserText)];
-}
-async function buildResolvedCodexUserPromptMessage(params) {
-	return buildFromPrepared(params, await params.userTurnTranscriptRecorder?.resolveMessage() ?? params.userTurnTranscriptRecorder?.message);
-}
-//#endregion
-//#region extensions/codex/src/app-server/transcript-mirror.ts
-function isMirroredAgentMessage(message) {
-	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
-}
+//#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;
@@ -186,6 +60,7 @@ function projectCodexUserItemText(item) {
 			parts.push("[Image attachment]");
 			continue;
 		}
+		if (input.type === "audio" || input.type === "localAudio" || input.type === "local_audio") parts.push("[Audio attachment]");
 		if (input.type === "skill" || input.type === "mention") {
 			const name = normalizeOptionalString(input.name);
 			if (name) parts.push(`${input.type === "skill" ? "$" : "@"}${name}`);
@@ -226,7 +101,8 @@ function projectCodexThreadHistory(params) {
 			provider: normalizeOptionalString(params.modelProvider) ?? normalizeOptionalString(params.thread.modelProvider) ?? CODEX_HISTORY_ASSISTANT_PROVIDER,
 			model: CODEX_HISTORY_ASSISTANT_MODEL,
 			usage: CODEX_HISTORY_ZERO_USAGE,
-			stopReason: "stop",
+			stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop",
+			...turn.status === "failed" && turn.error?.message ? { errorMessage: turn.error.message } : {},
 			timestamp
 		}, identity) : attachCodexMirrorIdentity({
 			role,
@@ -274,10 +150,124 @@ function projectBoundedCodexThreadHistory(params) {
 	return {
 		importedMessages: selected.length,
 		omittedMessages: projected.length - selected.length,
-		responseItems: selected.map(({ responseItem }) => responseItem),
+		responseItems: selected.filter(({ message }) => message.role !== "assistant" || message.stopReason !== "aborted" && message.stopReason !== "error").map(({ responseItem }) => responseItem),
 		transcriptMessages: selected.map(({ message }) => message)
 	};
 }
+/** Projects only visible local user/assistant messages through the same bounded history policy. */
+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;
+		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;
+		projected.push({
+			message: entry.message,
+			responseItem: {
+				type: "message",
+				role: entry.role,
+				content: [{
+					type: entry.role === "assistant" ? "output_text" : "input_text",
+					text
+				}]
+			},
+			textBytes: Buffer.byteLength(text, "utf8")
+		});
+	}
+	return selectBoundedCodexHistoryTail(projected).map(({ responseItem }) => responseItem);
+}
+//#endregion
+//#region extensions/codex/src/app-server/transcript-mirror-attestation.ts
+const MIRROR_ORIGIN_META_KEY = "mirrorOrigin";
+const MIRROR_SOURCE_FINGERPRINT_META_KEY = "mirrorSourceFingerprint";
+const CODEX_APP_SERVER_MIRROR_ORIGIN = "codex-app-server";
+function attachCodexMirrorAttestation(message, sourceFingerprint) {
+	const record = message;
+	const existing = record["__openclaw"];
+	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+	return {
+		...record,
+		__openclaw: {
+			...baseMeta,
+			[MIRROR_ORIGIN_META_KEY]: CODEX_APP_SERVER_MIRROR_ORIGIN,
+			...sourceFingerprint ? { [MIRROR_SOURCE_FINGERPRINT_META_KEY]: sourceFingerprint } : {}
+		}
+	};
+}
+function readCodexMirrorSourceFingerprint(message) {
+	const meta = message["__openclaw"];
+	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;
+	return JSON.stringify({
+		role: message.role,
+		content: record.content,
+		...message.role === "user" ? { upstreamUserText: readUpstreamUserText(message) } : {},
+		...message.role === "toolResult" ? {
+			toolCallId: record.toolCallId,
+			toolName: record.toolName,
+			isError: record.isError === true
+		} : {}
+	});
+}
+function fingerprintCodexMirrorSourceMessage(message) {
+	return createHash("sha256").update(serializeCodexMirrorSourceEvidence(message)).digest("hex").slice(0, 32);
+}
+//#endregion
+//#region extensions/codex/src/app-server/user-prompt-message.ts
+function buildSenderLabel(params) {
+	const label = params.senderName ?? params.senderUsername ?? params.senderE164 ?? params.senderId;
+	if (!label) return;
+	return !params.senderId || label.includes(params.senderId) ? label : `${label} (${params.senderId})`;
+}
+function buildFromPrepared(params, preparedUserMessage) {
+	const senderId = normalizeOptionalString(params.senderId);
+	const senderName = normalizeOptionalString(params.senderName);
+	const senderUsername = normalizeOptionalString(params.senderUsername);
+	const senderE164 = normalizeOptionalString(params.senderE164);
+	const senderLabel = buildSenderLabel({
+		senderId,
+		senderName,
+		senderUsername,
+		senderE164
+	});
+	const sourceChannel = normalizeOptionalString(params.inputProvenance?.sourceChannel ?? params.messageChannel ?? params.messageProvider);
+	return {
+		role: "user",
+		timestamp: Date.now(),
+		...params.inputProvenance ? { provenance: params.inputProvenance } : {},
+		...sourceChannel ? { sourceChannel } : {},
+		...senderId ? { senderId } : {},
+		...senderName ? { senderName } : {},
+		...senderUsername ? { senderUsername } : {},
+		...senderE164 ? { senderE164 } : {},
+		...senderLabel ? { senderLabel } : {},
+		...preparedUserMessage ? preparedUserMessage : { content: params.prompt }
+	};
+}
+function buildCodexUserPromptMessage(params) {
+	return buildFromPrepared(params, params.userTurnTranscriptRecorder?.message);
+}
+function buildCodexUpstreamPromptMessage(params, identity, upstreamUserText) {
+	const message = attachCodexMirrorIdentity(buildCodexUserPromptMessage(params), identity);
+	return upstreamUserText ? attachUpstreamUserText(message, upstreamUserText) : message;
+}
+function promptSnapshot(params, turnId, upstreamUserText) {
+	return params.suppressNextUserMessagePersistence ? [] : [buildCodexUpstreamPromptMessage(params, `${turnId}:prompt`, upstreamUserText)];
+}
+async function buildResolvedCodexUserPromptMessage(params) {
+	return buildFromPrepared(params, await params.userTurnTranscriptRecorder?.resolveMessage() ?? params.userTurnTranscriptRecorder?.message);
+}
+//#endregion
+//#region extensions/codex/src/app-server/transcript-mirror.ts
+function isMirroredAgentMessage(message) {
+	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
+}
 /** Imports a bounded, user-visible Codex history tail into a new OpenClaw transcript. */
 async function importCodexThreadHistoryToTranscript(params) {
 	const projection = projectBoundedCodexThreadHistory({
@@ -302,6 +292,10 @@ async function importCodexThreadHistoryToTranscript(params) {
 	};
 }
 async function mirrorBestEffort(params) {
+	if (!params.params.sessionTarget) return {
+		assistantTranscriptOwned: false,
+		mirroredMessages: []
+	};
 	try {
 		const messages = await resolveFinalCodexMirrorMessages({
 			params: params.params,
@@ -318,8 +312,8 @@ async function mirrorBestEffort(params) {
 			idempotencyScope: `codex-app-server:${params.threadId}`,
 			config: params.params.config
 		});
-		for (const message of mirrorResult.userMessagesPresent) try {
-			params.notifyUserMessagePersisted(message);
+		for (const receipt of mirrorResult.userMessageReceipts) try {
+			params.notifyUserMessagePersisted(receipt.message, receipt.anchor);
 		} catch (error) {
 			embeddedAgentLog.warn("failed to notify codex app-server user-message persistence", { error: formatErrorMessage(error) });
 		}
@@ -335,13 +329,21 @@ async function mirrorBestEffort(params) {
 		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 terminalMessage = mirroredMessages.at(-1);
+		const terminalMirrorIdentity = terminalMessage ? readMirrorIdentity(terminalMessage) : void 0;
+		const terminalAnchor = (terminalMirrorIdentity ? mirrorResult.anchorsByMirrorIdentity.get(terminalMirrorIdentity) : void 0) ?? params.params.userTurnTranscriptRecorder?.getAdmissionReceipt();
 		return {
 			assistantTranscriptOwned,
 			...assistantTranscriptIdempotencyKey ? { assistantTranscriptIdempotencyKey } : {},
+			...terminalAnchor ? { terminalAnchor } : {},
 			mirroredMessages
 		};
 	} catch (error) {
-		embeddedAgentLog.warn("failed to mirror codex app-server transcript", { error });
+		embeddedAgentLog.warn("failed to mirror codex app-server transcript", {
+			error: formatErrorMessage(error),
+			runId: params.params.runId,
+			sessionId: params.params.sessionId
+		});
 		return {
 			assistantTranscriptOwned: false,
 			mirroredMessages: []
@@ -362,10 +364,10 @@ async function resolveFinalCodexMirrorMessages(params) {
 }
 function createCodexAppServerUserMessagePersistenceNotifier(runParams) {
 	let notified = false;
-	return (message) => {
+	return (message, anchor) => {
 		if (notified) return;
 		notified = true;
-		runParams.userTurnTranscriptRecorder?.markRuntimePersisted(message);
+		runParams.userTurnTranscriptRecorder?.markRuntimePersisted(message, anchor);
 		try {
 			runParams.onUserMessagePersisted?.(message);
 		} catch (error) {
@@ -374,7 +376,7 @@ function createCodexAppServerUserMessagePersistenceNotifier(runParams) {
 	};
 }
 async function mirrorPromptAtTurnStartBestEffort(params) {
-	if (params.params.suppressNextUserMessagePersistence) return;
+	if (params.params.suppressNextUserMessagePersistence || !params.params.sessionTarget) return;
 	try {
 		const mirrorPromise = (async () => {
 			const userPromptMessage = projectAgentHarnessTranscriptMessageForDisplay({
@@ -391,12 +393,16 @@ async function mirrorPromptAtTurnStartBestEffort(params) {
 				idempotencyScope: `codex-app-server:${params.threadId}`,
 				config: params.params.config
 			});
-			for (const message of mirrorResult.userMessagesPresent) params.notifyUserMessagePersisted(message);
+			for (const receipt of mirrorResult.userMessageReceipts) params.notifyUserMessagePersisted(receipt.message, receipt.anchor);
 		})();
 		params.params.userTurnTranscriptRecorder?.markRuntimePersistencePending(mirrorPromise);
 		await mirrorPromise;
 	} catch (error) {
-		embeddedAgentLog.warn("failed to mirror codex app-server prompt at turn start", { error });
+		embeddedAgentLog.warn("failed to mirror codex app-server prompt at turn start", {
+			error: formatErrorMessage(error),
+			runId: params.params.runId,
+			sessionId: params.params.sessionId
+		});
 	}
 }
 function fingerprintMirrorMessageContent(message) {
@@ -415,33 +421,53 @@ async function mirror(params) {
 	const messages = params.messages.filter(isMirroredAgentMessage);
 	if (messages.length === 0) return {
 		assistantMirrorIdentitiesOwned: [],
+		anchorsByMirrorIdentity: /* @__PURE__ */ new Map(),
 		messagesPresent: [],
+		userMessageReceipts: [],
 		userMessagesPresent: []
 	};
+	const candidates = messages.map((message) => {
+		const dedupeIdentity = buildMirrorDedupeIdentity(message);
+		const sourceFingerprint = fingerprintCodexMirrorSourceMessage(message);
+		return {
+			dedupeIdentity,
+			idempotencyKey: (message.role === "user" ? normalizeOptionalString(message.idempotencyKey) : 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, messagesPresent, userMessagesPresent } = await withSessionTranscriptWriteLock({
+	const { appendedUpdates, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts, userMessagesPresent } = await withCodexSessionTranscriptMirrorWriteLock({
 		...transcriptTarget,
 		config: params.config
 	}, async (transcript) => {
 		const nextAppendedUpdates = [];
 		const nextAssistantMirrorIdentitiesOwned = /* @__PURE__ */ new Set();
+		const nextAnchorsByMirrorIdentity = /* @__PURE__ */ new Map();
 		const nextMessagesPresent = [];
+		const nextUserMessageReceipts = [];
 		const nextUserMessagesPresent = [];
-		const mirrorState = readTranscriptMirrorState(await transcript.readEvents());
-		let nextMessageSeq = mirrorState.messageCount;
-		for (const message of messages) {
-			const dedupeIdentity = buildMirrorDedupeIdentity(message);
-			const sourceFingerprint = fingerprintCodexMirrorSourceMessage(message);
-			const idempotencyKey = (message.role === "user" ? normalizeOptionalString(message.idempotencyKey) : void 0) ?? (params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0);
+		const mirrorFacts = await transcript.readMessageFacts({ idempotencyKeys: candidateIdempotencyKeys });
+		for (const { dedupeIdentity, idempotencyKey, message, sourceFingerprint } of candidates) {
 			const transcriptMessage = {
 				...attachCodexMirrorAttestation(message, sourceFingerprint),
 				...idempotencyKey ? { idempotencyKey } : {}
 			};
-			if (idempotencyKey && mirrorState.idempotencyKeys.has(idempotencyKey)) {
-				const persistedMessage = mirrorState.messagesByIdempotencyKey.get(idempotencyKey);
-				if (persistedMessage) nextMessagesPresent.push(persistedMessage);
-				const persistedUserMessage = persistedMessage?.role === "user" ? persistedMessage : void 0;
-				if (persistedUserMessage) nextUserMessagesPresent.push(persistedUserMessage);
+			if (idempotencyKey && mirrorFacts.existingIdempotencyKeys.has(idempotencyKey)) {
+				const persistedMessage = mirrorFacts.messagesByIdempotencyKey.get(idempotencyKey);
+				const persistedAnchor = mirrorFacts.anchorsByIdempotencyKey.get(idempotencyKey);
+				if (persistedMessage && isMirroredAgentMessage(persistedMessage)) {
+					nextMessagesPresent.push(persistedMessage);
+					if (persistedMessage.role === "user") {
+						nextUserMessagesPresent.push(persistedMessage);
+						if (persistedAnchor) nextUserMessageReceipts.push({
+							anchor: persistedAnchor,
+							message: persistedMessage
+						});
+					}
+				}
+				if (persistedAnchor) nextAnchorsByMirrorIdentity.set(dedupeIdentity, persistedAnchor);
 				if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
 				continue;
 			}
@@ -464,31 +490,42 @@ async function mirror(params) {
 				hidden: message.display === false,
 				message: messageToAppend
 			});
-			const appended = await transcript.appendMessage({
+			const { messageSeq, result: appended } = await transcript.appendMessageWithMessageSequence({
 				message: messageToAppend,
-				idempotencyLookup: idempotencyKey ? "caller-checked" : "scan",
+				idempotencyLookup: "scan",
 				cwd: params.cwd
 			});
 			if (!appended) continue;
 			const { messageId, message: appendedMessage } = appended;
 			if (isMirroredAgentMessage(appendedMessage)) {
 				nextMessagesPresent.push(appendedMessage);
-				if (idempotencyKey) mirrorState.messagesByIdempotencyKey.set(idempotencyKey, appendedMessage);
+				if (idempotencyKey) mirrorFacts.messagesByIdempotencyKey.set(idempotencyKey, appendedMessage);
 			}
 			if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
-			if (appendedMessage.role === "user") nextUserMessagesPresent.push(appendedMessage);
-			nextMessageSeq += 1;
-			nextAppendedUpdates.push({
+			if (appended.anchor) nextAnchorsByMirrorIdentity.set(dedupeIdentity, appended.anchor);
+			if (appendedMessage.role === "user" && appended.anchor) {
+				nextUserMessagesPresent.push(appendedMessage);
+				nextUserMessageReceipts.push({
+					anchor: appended.anchor,
+					message: appendedMessage
+				});
+			}
+			if (appended.appended) nextAppendedUpdates.push({
 				messageId,
 				message: appendedMessage,
-				messageSeq: nextMessageSeq
+				...messageSeq !== void 0 ? { messageSeq } : {}
 			});
-			if (idempotencyKey) mirrorState.idempotencyKeys.add(idempotencyKey);
+			if (idempotencyKey) {
+				mirrorFacts.existingIdempotencyKeys.add(idempotencyKey);
+				if (appended.anchor) mirrorFacts.anchorsByIdempotencyKey.set(idempotencyKey, appended.anchor);
+			}
 		}
 		return {
 			appendedUpdates: nextAppendedUpdates,
 			assistantMirrorIdentitiesOwned: [...nextAssistantMirrorIdentitiesOwned],
+			anchorsByMirrorIdentity: nextAnchorsByMirrorIdentity,
 			messagesPresent: nextMessagesPresent,
+			userMessageReceipts: nextUserMessageReceipts,
 			userMessagesPresent: nextUserMessagesPresent
 		};
 	});
@@ -499,7 +536,7 @@ async function mirror(params) {
 				...params.agentId ? { agentId: params.agentId } : {},
 				message: update.message,
 				messageId: update.messageId,
-				messageSeq: update.messageSeq,
+				...update.messageSeq !== void 0 ? { messageSeq: update.messageSeq } : {},
 				sessionKey: transcriptTarget.sessionKey
 			}
 		});
@@ -508,7 +545,9 @@ async function mirror(params) {
 	}
 	return {
 		assistantMirrorIdentitiesOwned,
+		anchorsByMirrorIdentity,
 		messagesPresent,
+		userMessageReceipts,
 		userMessagesPresent
 	};
 }
@@ -527,24 +566,5 @@ function resolveCodexMirrorTranscriptTarget(params) {
 		storePath
 	};
 }
-function readTranscriptMirrorState(events) {
-	const idempotencyKeys = /* @__PURE__ */ new Set();
-	const messagesByIdempotencyKey = /* @__PURE__ */ new Map();
-	let messageCount = 0;
-	for (const event of events) {
-		if (!event || typeof event !== "object" || Array.isArray(event)) continue;
-		const parsed = event;
-		if (parsed.type === "message") messageCount += 1;
-		if (typeof parsed.message?.idempotencyKey === "string") {
-			idempotencyKeys.add(parsed.message.idempotencyKey);
-			if (isMirroredAgentMessage(parsed.message)) messagesByIdempotencyKey.set(parsed.message.idempotencyKey, parsed.message);
-		}
-	}
-	return {
-		idempotencyKeys,
-		messagesByIdempotencyKey,
-		messageCount
-	};
-}
 //#endregion
-export { projectBoundedCodexThreadHistory as a, fingerprintCodexMirrorSourceMessage as c, attachCodexMirrorIdentity as d, readMirrorIdentity as f, mirrorPromptAtTurnStartBestEffort as i, readCodexMirrorSourceFingerprint as l, createCodexAppServerUserMessagePersistenceNotifier as n, buildCodexUserPromptMessage as o, readUpstreamUserText as p, importCodexThreadHistoryToTranscript as r, promptSnapshot as s, codexTranscriptMirrorRuntime as t, serializeCodexMirrorSourceEvidence as u };
+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 };