@openclaw/codex 2026.9.2 → 2026.9.3

package/dist/{thread-ownership-CbucAmmp.js → thread-ownership-D6oASVRu.js}

@@ -1,14 +1,16 @@
-import { Mt as retainCodexAppServerLiveThread, Ot as isCodexAppServerLiveThreadClaimed, _ as retainSharedCodexAppServerClientByInstanceId, jt as releaseCodexAppServerLiveThread } from "./shared-client-CKhX2kFt.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-Bp1ZOnk2.js";
-import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
-import { isIncognitoSessionKey } from "openclaw/plugin-sdk/routing";
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { n as withCodexAppServerThreadMutation } from "./incognito-session-uhrBF6wJ.js";
+import { U as releaseCodexAppServerLiveThread, W as retainCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, z as isCodexAppServerLiveThreadClaimed } from "./shared-client-CVhez2Uo.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-D6cR54TV.js";
 //#region extensions/codex/src/app-server/thread-ownership.ts
-const nativeThreadOwners = resolveGlobalSingleton(Symbol.for("openclaw.codexNativeThreadOwners"), () => new KeyedAsyncQueue());
-/** Serialize OpenClaw-owned lifecycle changes, not native-internal thread controllers. */
-async function withCodexAppServerThreadMutation(threadId, run) {
-	return await nativeThreadOwners.enqueue(`thread:${threadId}`, run);
-}
+var thread_ownership_exports = /* @__PURE__ */ __exportAll({
+	isSameCodexAppServerThreadOwner: () => isSameCodexAppServerThreadOwner,
+	releaseCodexAppServerBindingSubscription: () => releaseCodexAppServerBindingSubscription,
+	retainCodexAppServerBindingSubscription: () => retainCodexAppServerBindingSubscription,
+	retireCodexConversationThreadBinding: () => retireCodexConversationThreadBinding,
+	rollbackCodexAppServerBindingSubscription: () => rollbackCodexAppServerBindingSubscription,
+	withExclusiveCodexAppServerThread: () => withExclusiveCodexAppServerThread
+});
 /** 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;
@@ -20,10 +22,6 @@ async function withExclusiveCodexAppServerThread(params) {
 		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 subscription with its persistent or ephemeral retention lifetime. */
 async function retainCodexAppServerBindingSubscription(client, threadId, ownership) {
 	return await retainCodexAppServerLiveThread(client, threadId, ownership?.release ?? (async (releasedThreadId, assertCurrent) => {
@@ -100,4 +98,4 @@ async function retireCodexConversationThreadBinding(params) {
 	}));
 }
 //#endregion
-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 };
+export { rollbackCodexAppServerBindingSubscription as a, retireCodexConversationThreadBinding as i, releaseCodexAppServerBindingSubscription as n, thread_ownership_exports as o, retainCodexAppServerBindingSubscription as r, withExclusiveCodexAppServerThread as s, isSameCodexAppServerThreadOwner as t };

package/dist/thread-policy-D8kI7yAO.js

@@ -0,0 +1,54 @@
+import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError } from "./client-BEKu4yDx.js";
+import { r as requestCodexAppServerClientJson, t as CodexAppServerScopedRequestRejectedError } from "./request-CGvGOpeR.js";
+import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/thread-policy.ts
+/** A refusal, not a failed native write: the ephemeral conversation must stay alive. */
+var CodexIncognitoPolicyChangeError = class extends AgentHarnessPreflightError {
+	constructor() {
+		super("Codex cannot change generic instructions in a live incognito conversation. No turn was sent and the conversation is preserved. Restore the previous instructions to continue it, or start a new incognito conversation for the changed policy.");
+		this.name = "CodexIncognitoPolicyChangeError";
+	}
+};
+/** Never replay a handoff: native persistence can precede an unsuccessful RPC response. */
+var CodexThreadPolicyHandoffError = class extends AgentHarnessPreflightError {
+	constructor(outcome, cause) {
+		super(`Codex session policy handoff failed: ${cause instanceof Error ? cause.message : String(cause)}. The conversation is preserved; reconnect before retrying.`, { cause });
+		this.outcome = outcome;
+		this.name = "CodexThreadPolicyHandoffError";
+	}
+};
+/** The complete body remains generic configuration for compaction and native child inheritance. */
+async function refreshCodexThreadPolicy(params) {
+	const text = "The following is the complete current OpenClaw-supplied generic instruction policy. It replaces earlier OpenClaw-supplied generic policy, including OpenClaw-carried workspace text and sections now absent. Independently supplied native managed, guardian, security, collaboration, and project instructions retain their authority. User requests retain their own authority.\n\n" + (params.developerInstructions === "" ? "The current OpenClaw generic policy is empty; earlier OpenClaw generic policy is withdrawn." : params.developerInstructions);
+	let outcome = "unknown";
+	try {
+		await requestCodexAppServerClientJson({
+			...params,
+			method: "thread/inject_items",
+			requestParams: {
+				threadId: params.threadId,
+				items: [{
+					type: "message",
+					role: "developer",
+					content: [{
+						type: "input_text",
+						text
+					}]
+				}]
+			}
+		});
+		outcome = "acknowledged";
+		params.assertCurrent();
+		params.signal?.throwIfAborted();
+	} catch (cause) {
+		if (outcome !== "acknowledged" && (cause instanceof CodexAppServerScopedRequestRejectedError || isCodexAppServerPrewriteRequestCancellationError(cause) || isCodexAppServerOverloadError(cause))) outcome = "not-written";
+		throw new CodexThreadPolicyHandoffError(outcome, cause);
+	}
+}
+/** Native lineage classifies the exact bound thread; it never grants session authority. */
+function assertCodexSupervisionThreadLineage(binding, thread) {
+	if (binding.connectionScope !== "supervision" || binding.pendingSupervisionBranch) return;
+	if (thread.id !== binding.threadId || !binding.supervisionSourceThreadId || thread.forkedFromId !== null && (typeof thread.forkedFromId !== "string" || !thread.forkedFromId.trim() || thread.forkedFromId === thread.id)) throw new Error("Codex supervision lineage could not be verified; reconnect before continuing.");
+}
+//#endregion
+export { refreshCodexThreadPolicy as i, CodexThreadPolicyHandoffError as n, assertCodexSupervisionThreadLineage as r, CodexIncognitoPolicyChangeError as t };

package/dist/thread-resume-T5cveyxA.js

@@ -0,0 +1,52 @@
+import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError, y as assertCodexThreadResumeResponse } from "./client-BEKu4yDx.js";
+import { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.js";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-CGvGOpeR.js";
+import { I as forgetCodexWorkspaceReferences, k as isCodexAppServerStartupError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CVhez2Uo.js";
+import { d as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-D6cR54TV.js";
+//#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;
+	let ownershipRejected = false;
+	const assertCurrent = params.assertCurrent && (() => {
+		try {
+			params.assertCurrent?.();
+		} catch (error) {
+			ownershipRejected = true;
+			throw error;
+		}
+	});
+	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
+		})));
+		assertCodexThreadResumeSubscription(threadId, response.thread.id);
+		forgetCodexWorkspaceReferences(params.client, threadId);
+	} catch (error) {
+		if (ownershipRejected || 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 { resumeCodexAppServerThread as t };

package/dist/timeout-BVw8aaM1.js

@@ -0,0 +1,33 @@
+import { withTimeout } from "openclaw/plugin-sdk/time-runtime";
+//#region extensions/codex/src/app-server/timeout.ts
+/**
+* Thin Codex app-server timeout adapter around OpenClaw's shared timeout helper.
+*/
+function resolveAbortError(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error("Codex app-server operation aborted", { cause: signal.reason });
+}
+/** Awaits a promise with a Codex-specific timeout error message. */
+async function withTimeout$1(promise, timeoutMs, timeoutMessage, createError) {
+	return await withTimeout(promise, timeoutMs, {
+		message: timeoutMessage,
+		...createError ? { createError } : {}
+	});
+}
+/** Bounds an operation by both its owner lifecycle and one total wall-clock budget. */
+async function withAbortableTimeout(params) {
+	const signal = params.signal;
+	if (signal?.aborted) throw resolveAbortError(signal);
+	let removeAbortListener;
+	const operation = signal ? Promise.race([params.promise, new Promise((_, reject) => {
+		const onAbort = () => reject(resolveAbortError(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+	})]) : params.promise;
+	try {
+		return await withTimeout$1(operation, params.timeoutMs, params.timeoutMessage, params.createTimeoutError);
+	} finally {
+		removeAbortListener?.();
+	}
+}
+//#endregion
+export { withTimeout$1 as n, withAbortableTimeout as t };

package/dist/{transcript-mirror-attestation-Byl34PC-.js → transcript-mirror-attestation-DibE0krH.js}

@@ -1,7 +1,19 @@
-import { i as readUpstreamUserText } from "./upstream-prompt-provenance-LphB8slG.js";
+import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 //#region extensions/codex/src/app-server/transcript-mirror-attestation.ts
+function isMirroredAgentMessage(message) {
+	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
+}
+function buildCodexMirrorDedupeIdentity(message) {
+	const identity = readMirrorIdentity(message);
+	if (identity) return identity;
+	const payload = JSON.stringify({
+		role: message.role,
+		content: message.content
+	});
+	return `${message.role}:${createHash("sha256").update(payload).digest("hex").slice(0, 16)}`;
+}
 const MIRROR_ORIGIN_META_KEY = "mirrorOrigin";
 const MIRROR_SOURCE_FINGERPRINT_META_KEY = "mirrorSourceFingerprint";
 const CODEX_APP_SERVER_MIRROR_ORIGIN = "codex-app-server";
@@ -34,7 +46,7 @@ function attachCodexMirrorAttestation(message, sourceFingerprint) {
 		}
 	};
 }
-function attachCodexMirrorRunId(message, runId, terminal = false) {
+function attachCodexMirrorRunId(message, runId, terminal = false, settlementWarning) {
 	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
 	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(existing) ?? {};
 	return {
@@ -42,7 +54,8 @@ function attachCodexMirrorRunId(message, runId, terminal = false) {
 		[CODEX_META_KEY]: {
 			...current,
 			runId,
-			...terminal ? { runTerminal: true } : {}
+			...terminal ? { runTerminal: true } : {},
+			...terminal && settlementWarning ? { settlementWarning } : {}
 		}
 	};
 }
@@ -73,4 +86,4 @@ function fingerprintCodexMirrorSourceMessage(message) {
 	return createHash("sha256").update(serializeCodexMirrorSourceEvidence(message)).digest("hex").slice(0, 32);
 }
 //#endregion
-export { hasCodexMirrorOrigin as a, fingerprintCodexMirrorSourceMessage as i, attachCodexMirrorAttestation as n, readCodexMirrorSourceFingerprint as o, attachCodexMirrorRunId as r, serializeCodexMirrorSourceEvidence as s, applyCodexTranscriptTaint as t };
+export { fingerprintCodexMirrorSourceMessage as a, readCodexMirrorSourceFingerprint as c, buildCodexMirrorDedupeIdentity as i, serializeCodexMirrorSourceEvidence as l, attachCodexMirrorAttestation as n, hasCodexMirrorOrigin as o, attachCodexMirrorRunId as r, isMirroredAgentMessage as s, applyCodexTranscriptTaint as t };

package/dist/{transcript-mirror-_njEB84z.js → transcript-mirror-t5TOccct.js}

@@ -1,196 +1,11 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { i as fingerprintCodexMirrorSourceMessage, n as attachCodexMirrorAttestation, o as readCodexMirrorSourceFingerprint, r as attachCodexMirrorRunId } from "./transcript-mirror-attestation-Byl34PC-.js";
+import { r as projectBoundedCodexThreadHistory } from "./session-catalog-home-id-D7-aLiNt.js";
+import { a as fingerprintCodexMirrorSourceMessage, c as readCodexMirrorSourceFingerprint, i as buildCodexMirrorDedupeIdentity, n as attachCodexMirrorAttestation, r as attachCodexMirrorRunId, s as isMirroredAgentMessage, t as applyCodexTranscriptTaint } from "./transcript-mirror-attestation-DibE0krH.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createHash } from "node:crypto";
-import path from "node:path";
 import { deliverAgentHarnessUserInputPrompt, embeddedAgentLog, formatErrorMessage, projectAgentHarnessTranscriptMessageForDisplay, restorePreparedUserTurnOperationalMetaForRuntime, runAgentHarnessBeforeMessageWriteHook } from "openclaw/plugin-sdk/agent-harness-runtime";
-import fsSync from "node:fs";
-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";
-//#region extensions/codex/src/session-catalog-home-id.ts
-function canonicalCodexCatalogHome(value) {
-	const resolved = path.resolve(value);
-	try {
-		return fsSync.realpathSync.native(resolved);
-	} catch {
-		return resolved;
-	}
-}
-/** One canonical identity for catalog discovery and durable ownership rows. */
-function codexCatalogHomeId(codexHome) {
-	return createHash("sha256").update("openclaw:codex-session-catalog-home:v1\0").update(canonicalCodexCatalogHome(codexHome)).digest("hex");
-}
-//#endregion
-//#region extensions/codex/src/app-server/transcript-history-projection.ts
-const CODEX_HISTORY_IMPORT_MAX_MESSAGES = 200;
-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";
-const CODEX_HISTORY_ASSISTANT_MODEL = "native-history";
-const CODEX_HISTORY_ZERO_USAGE = {
-	input: 0,
-	output: 0,
-	cacheRead: 0,
-	cacheWrite: 0,
-	totalTokens: 0,
-	cost: {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		total: 0
-	}
-};
-function normalizeImportedHistoryText(value) {
-	if (typeof value !== "string") return;
-	const text = value.trim();
-	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");
-	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;
-	const parts = [];
-	for (const value of item.content) {
-		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
-		const input = value;
-		if (input.type === "text") {
-			const text = normalizeImportedHistoryText(input.text);
-			if (text) parts.push(text);
-			continue;
-		}
-		if (input.type === "image" || input.type === "localImage") {
-			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}`);
-		}
-	}
-	return normalizeImportedHistoryText(parts.join("\n"));
-}
-function selectTurnsThroughBoundary(thread, throughTurnId) {
-	if (throughTurnId === null) return [];
-	const turns = thread.turns ?? [];
-	const boundaryIndex = turns.findIndex((turn) => turn.id === throughTurnId);
-	if (boundaryIndex < 0) throw new Error(`Codex history boundary turn not found: ${throughTurnId}`);
-	const boundary = turns[boundaryIndex];
-	if (boundary?.status !== "completed" && boundary?.status !== "interrupted" && boundary?.status !== "failed") throw new Error(`Codex history boundary turn is not terminal: ${throughTurnId}`);
-	return turns.slice(0, boundaryIndex + 1);
-}
-function projectCodexThreadHistory(params) {
-	const projected = [];
-	const threadTimestamp = typeof params.thread.createdAt === "number" && Number.isFinite(params.thread.createdAt) ? params.thread.createdAt * 1e3 : params.importedAt;
-	let itemOffset = 0;
-	for (const turn of selectTurnsThroughBoundary(params.thread, params.throughTurnId)) for (const value of turn.items) {
-		const item = value;
-		const itemId = normalizeOptionalString(item.id);
-		const identity = `${turn.id}:${itemId ?? itemOffset}`;
-		const timestampSeconds = item.type === "agentMessage" ? turn.completedAt ?? turn.startedAt : turn.startedAt ?? turn.completedAt;
-		const timestamp = typeof timestampSeconds === "number" && Number.isFinite(timestampSeconds) ? timestampSeconds * 1e3 + itemOffset : threadTimestamp + itemOffset;
-		const text = item.type === "userMessage" ? projectCodexUserItemText(item) : item.type === "agentMessage" ? normalizeImportedHistoryText(item.text) : void 0;
-		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: [{
-				type: "text",
-				text
-			}],
-			api: CODEX_HISTORY_ASSISTANT_API,
-			provider: normalizeOptionalString(params.modelProvider) ?? normalizeOptionalString(params.thread.modelProvider) ?? CODEX_HISTORY_ASSISTANT_PROVIDER,
-			model: CODEX_HISTORY_ASSISTANT_MODEL,
-			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);
-		projected.push({
-			message,
-			responseItem: {
-				type: "message",
-				role,
-				content: [{
-					type: role === "assistant" ? "output_text" : "input_text",
-					text
-				}],
-				...role === "assistant" && phase ? { phase } : {}
-			},
-			textBytes: Buffer.byteLength(text, "utf8")
-		});
-	}
-	return projected;
-}
-function selectBoundedCodexHistoryTail(projected) {
-	const selected = [];
-	let selectedBytes = 0;
-	for (let index = projected.length - 1; index >= 0; index -= 1) {
-		const candidate = projected[index];
-		if (!candidate) continue;
-		if (selected.length >= CODEX_HISTORY_IMPORT_MAX_MESSAGES || selectedBytes + candidate.textBytes > CODEX_HISTORY_IMPORT_MAX_BYTES) break;
-		selected.push(candidate);
-		selectedBytes += candidate.textBytes;
-	}
-	return selected.toReversed();
-}
-/** Projects one terminal Codex history prefix into transcript and Responses API items. */
-function projectBoundedCodexThreadHistory(params) {
-	const projected = projectCodexThreadHistory({
-		thread: params.thread,
-		throughTurnId: params.throughTurnId,
-		importedAt: params.importedAt,
-		...params.modelProvider ? { modelProvider: params.modelProvider } : {}
-	});
-	const selected = selectBoundedCodexHistoryTail(projected);
-	return {
-		importedMessages: selected.length,
-		omittedMessages: projected.length - selected.length,
-		responseItems: selected.filter(({ message }) => message.role !== "assistant" || message.stopReason !== "aborted" && message.stopReason !== "error" && !("openclawAsyncDelivery" in message)).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") || "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;
-		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/user-prompt-message.ts
 function buildSenderLabel(params) {
 	const label = params.senderName ?? params.senderUsername ?? params.senderE164 ?? params.senderId;
@@ -249,12 +64,15 @@ async function resolveFinalCodexMirrorMessages(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/transcript-mirror.ts
-function isMirroredAgentMessage(message) {
-	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
-}
+var transcript_mirror_exports = /* @__PURE__ */ __exportAll({
+	codexTranscriptMirrorRuntime: () => codexTranscriptMirrorRuntime,
+	createCodexAppServerUserMessagePersistenceNotifier: () => createCodexAppServerUserMessagePersistenceNotifier,
+	importCodexThreadHistoryToTranscript: () => importCodexThreadHistoryToTranscript,
+	mirrorPromptAtTurnStartBestEffort: () => mirrorPromptAtTurnStartBestEffort,
+	projectBoundedCodexThreadHistory: () => projectBoundedCodexThreadHistory
+});
 function readMirroredAssistantText(message) {
-	if (message?.role !== "assistant") return;
-	return message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n") || void 0;
+	return message?.role === "assistant" ? message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n") || void 0 : void 0;
 }
 /** Imports a bounded, user-visible Codex history tail into a new OpenClaw transcript. */
 async function importCodexThreadHistoryToTranscript(params) {
@@ -303,9 +121,10 @@ async function mirrorBestEffort(params) {
 			idempotencyScope: `codex-app-server:${params.threadId}`,
 			runId: params.params.runId,
 			runMirrorIdentityPrefix: `${params.turnId}:`,
-			terminalAssistantOwner: {
+			terminalAssistantOwner: params.params.deferTerminalLifecycle && params.result.terminal.kind === "failed" ? void 0 : {
 				mirrorIdentity: `${params.turnId}:assistant`,
-				runId: params.params.runId
+				runId: params.params.runId,
+				settlementWarning: params.settlementWarning
 			},
 			prepareAssistantTranscriptMessage: params.params.prepareAssistantTranscriptMessage,
 			config: params.params.config
@@ -406,27 +225,16 @@ async function mirrorPromptAtTurnStartBestEffort(params) {
 		});
 	}
 }
-function fingerprintMirrorMessageContent(message) {
-	const payload = JSON.stringify({
-		role: message.role,
-		content: message.content
-	});
-	return createHash("sha256").update(payload).digest("hex").slice(0, 16);
-}
-function buildMirrorDedupeIdentity(message) {
-	return readMirrorIdentity(message) || `${message.role}:${fingerprintMirrorMessageContent(message)}`;
-}
 async function mirror(params) {
 	const messages = params.messages.filter(isMirroredAgentMessage);
 	if (messages.length === 0) return {
-		assistantMirrorIdentitiesAppended: [],
 		assistantMirrorIdentitiesOwned: [],
 		anchorsByMirrorIdentity: /* @__PURE__ */ new Map(),
 		messagesPresent: [],
 		userMessageReceipts: []
 	};
 	const candidates = messages.map((message) => {
-		const dedupeIdentity = buildMirrorDedupeIdentity(message);
+		const dedupeIdentity = buildCodexMirrorDedupeIdentity(message);
 		const sourceFingerprint = fingerprintCodexMirrorSourceMessage(message);
 		return {
 			dedupeIdentity,
@@ -448,19 +256,20 @@ async function mirror(params) {
 	}, async (transcript) => {
 		assertWritable();
 		const nextAppendedUpdates = [];
-		const nextAssistantMirrorIdentitiesAppended = /* @__PURE__ */ new Set();
 		const nextAssistantMirrorIdentitiesOwned = /* @__PURE__ */ new Set();
 		const nextAnchorsByMirrorIdentity = /* @__PURE__ */ new Map();
 		const nextMessagesPresent = [];
 		const nextUserMessageReceipts = [];
 		const mirrorFacts = await transcript.readMessageFacts({ idempotencyKeys: candidateIdempotencyKeys });
 		assertWritable();
+		const taint = { tainted: false };
 		for (const { dedupeIdentity, idempotencyKey, message, sourceFingerprint } of candidates) {
+			const sourceMessage = applyCodexTranscriptTaint(message, taint);
 			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 ownedMessage = ownsRun && params.runId ? attachCodexMirrorRunId(message, params.runId, ownsTerminal) : message;
+			const ownedMessage = ownsRun && params.runId ? attachCodexMirrorRunId(sourceMessage, params.runId, ownsTerminal, terminalOwner?.settlementWarning) : sourceMessage;
 			const transcriptMessage = {
 				...attachCodexMirrorAttestation(ownedMessage, sourceFingerprint),
 				...idempotencyKey ? { idempotencyKey } : {}
@@ -509,8 +318,9 @@ async function mirror(params) {
 				idempotencyKey
 			} : attachCodexMirrorAttestation(restoredMessage, sourceFingerprint);
 			if (mirrorIdentity) messageToAppend = attachCodexMirrorIdentity(messageToAppend, mirrorIdentity);
-			if (ownsRun && params.runId) messageToAppend = attachCodexMirrorRunId(messageToAppend, params.runId, ownsTerminal);
+			if (ownsRun && params.runId) messageToAppend = attachCodexMirrorRunId(messageToAppend, params.runId, ownsTerminal, terminalOwner?.settlementWarning);
 			if (message.role === "assistant" && message.openclawAsyncDelivery) messageToAppend = Object.assign(messageToAppend, { openclawAsyncDelivery: { itemId: message.openclawAsyncDelivery.itemId } });
+			messageToAppend = applyCodexTranscriptTaint(messageToAppend, taint);
 			messageToAppend = projectAgentHarnessTranscriptMessageForDisplay({
 				hidden: message.display === false,
 				message: messageToAppend
@@ -539,14 +349,11 @@ async function mirror(params) {
 				appended: appended.appended,
 				message: appendedMessage
 			});
-			if (appended.appended) {
-				if (message.role === "assistant") nextAssistantMirrorIdentitiesAppended.add(dedupeIdentity);
-				nextAppendedUpdates.push({
-					messageId,
-					message: appendedMessage,
-					...messageSeq !== void 0 ? { messageSeq } : {}
-				});
-			}
+			if (appended.appended) nextAppendedUpdates.push({
+				messageId,
+				message: appendedMessage,
+				...messageSeq !== void 0 ? { messageSeq } : {}
+			});
 			if (idempotencyKey) {
 				mirrorFacts.existingIdempotencyKeys.add(idempotencyKey);
 				if (appended.anchor) mirrorFacts.anchorsByIdempotencyKey.set(idempotencyKey, appended.anchor);
@@ -554,7 +361,6 @@ async function mirror(params) {
 		}
 		return {
 			appendedUpdates: nextAppendedUpdates,
-			assistantMirrorIdentitiesAppended: [...nextAssistantMirrorIdentitiesAppended],
 			assistantMirrorIdentitiesOwned: [...nextAssistantMirrorIdentitiesOwned],
 			anchorsByMirrorIdentity: nextAnchorsByMirrorIdentity,
 			messagesPresent: nextMessagesPresent,
@@ -562,7 +368,7 @@ async function mirror(params) {
 		};
 	});
 	params.assertCurrent?.();
-	const { appendedUpdates, assistantMirrorIdentitiesAppended, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts } = mirrorBatch;
+	const { appendedUpdates, ...result } = mirrorBatch;
 	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;
@@ -580,13 +386,7 @@ async function mirror(params) {
 	} catch (error) {
 		embeddedAgentLog.warn("failed to publish codex app-server transcript update", { error: formatErrorMessage(error) });
 	}
-	return {
-		assistantMirrorIdentitiesAppended,
-		assistantMirrorIdentitiesOwned,
-		anchorsByMirrorIdentity,
-		messagesPresent,
-		userMessageReceipts
-	};
+	return result;
 }
 async function deliverAsyncMessageBestEffort(params) {
 	const mirrorIdentity = `${params.turnId}:async:${params.itemId}`;
@@ -596,13 +396,22 @@ async function deliverAsyncMessageBestEffort(params) {
 		params.itemId
 	].map(encodeURIComponent).join(":")}`;
 	const target = params.params.sessionTarget;
-	if (!target) {
-		if (!params.params.onBlockReply) return "retry";
+	let text;
+	if (target) {
+		let result;
 		try {
-			await deliverAsyncBlockReply(params.params.onBlockReply, params.text, deliveryIntentId);
-			return "settled";
+			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 deliver codex async agent message", {
+			embeddedAgentLog.warn("failed to persist codex async agent message", {
 				error: formatErrorMessage(error),
 				itemId: params.itemId,
 				runId: params.params.runId,
@@ -611,35 +420,16 @@ async function deliverAsyncMessageBestEffort(params) {
 			});
 			return "retry";
 		}
+		if (!result.assistantMirrorIdentitiesOwned.includes(mirrorIdentity)) return "retry";
+		text = readMirroredAssistantText(result.messagesPresent.find((message) => readMirrorIdentity(message) === mirrorIdentity));
+	} else {
+		if (!params.params.onBlockReply) return "retry";
+		text = params.text;
 	}
-	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);
+	if (params.params.onBlockReply && text !== void 0) try {
+		await deliverAsyncBlockReply(params.params.onBlockReply, text, deliveryIntentId);
 	} catch (error) {
-		embeddedAgentLog.warn("failed to deliver persisted codex async agent message", {
+		embeddedAgentLog.warn(target ? "failed to deliver persisted codex async agent message" : "failed to deliver codex async agent message", {
 			error: formatErrorMessage(error),
 			itemId: params.itemId,
 			runId: params.params.runId,
@@ -670,4 +460,4 @@ function resolveCodexMirrorTranscriptTarget(params) {
 	};
 }
 //#endregion
-export { buildCodexUserPromptMessage as a, projectBoundedCodexVisibleSessionHistory as c, codexCatalogHomeId as d, mirrorPromptAtTurnStartBestEffort as i, projectCodexUserItemText as l, createCodexAppServerUserMessagePersistenceNotifier as n, promptSnapshot as o, importCodexThreadHistoryToTranscript as r, projectBoundedCodexThreadHistory as s, codexTranscriptMirrorRuntime as t, canonicalCodexCatalogHome as u };
+export { transcript_mirror_exports as a, mirrorPromptAtTurnStartBestEffort as i, createCodexAppServerUserMessagePersistenceNotifier as n, buildCodexUserPromptMessage as o, importCodexThreadHistoryToTranscript as r, promptSnapshot as s, codexTranscriptMirrorRuntime as t };