@openclaw/codex 2026.9.1-beta.1 → 2026.9.1

package/dist/{thread-ownership-DZeuKH1j.js → thread-ownership-zGokd8i1.js}

@@ -1,15 +1,21 @@
-import { $ as releaseCodexAppServerLiveThread, Z as isCodexAppServerLiveThreadClaimed, et as retainCodexAppServerLiveThread, h as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-DKz23hHY.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-bfsmcQ6m.js";
+import { At as retainCodexAppServerLiveThread, Et as isCodexAppServerLiveThreadClaimed, _ as retainSharedCodexAppServerClientByInstanceId, kt as releaseCodexAppServerLiveThread } from "./shared-client-DxcfF9KX.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DYHcRQAa.js";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/routing";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 //#region extensions/codex/src/app-server/thread-ownership.ts
-const nativeThreadOwners = new KeyedAsyncQueue();
+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);
+}
 /** 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();
 	});
@@ -18,17 +24,19 @@ async function withExclusiveCodexAppServerThread(params) {
 async function withCodexConversationThreadActivity(bindingId, run) {
 	return await nativeThreadOwners.enqueue(`conversation:${bindingId}`, run);
 }
-/** Publishes one owned persistent subscription into the shared bounded idle registry. */
+/** 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) => {
+	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}`);
 		}
-	}), ownership?.configFingerprint, ownership?.serviceTier);
+	}), ownership?.configFingerprint, ownership?.serviceTier, ownership?.ephemeralPolicy);
 }
 /** Rolls back the exact subscription Codex created before its binding was committed. */
 async function rollbackCodexAppServerBindingSubscription(client, threadId, retained) {
@@ -41,15 +49,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}`);
@@ -62,9 +73,9 @@ async function releaseCodexAppServerBindingSubscription(binding, options = {}) {
 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 () => {
+	return await withCodexAppServerThreadMutation(expected.threadId, () => 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;
+		if (!current || !isSameCodexAppServerThreadOwner(current, expected) || params.expectedStartId && current?.conversationStartId !== params.expectedStartId) return false;
 		await releaseCodexAppServerBindingSubscription(current, { allowUntracked: params.allowUntracked });
 		const cleared = await params.bindingStore.mutate(params.identity, {
 			kind: "clear",
@@ -86,7 +97,7 @@ async function retireCodexConversationThreadBinding(params) {
 			}
 			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 };
+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/thread-policy-g4KbJPzp.js

@@ -0,0 +1,54 @@
+import { H as isCodexAppServerOverloadError, U as isCodexAppServerPrewriteRequestCancellationError } from "./shared-client-DxcfF9KX.js";
+import { r as requestCodexAppServerClientJson, t as CodexAppServerScopedRequestRejectedError } from "./request-DYAI5FQE.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/{plugin-app-cache-key-C1CAdfcP.js → thread-resume-C7pyVKeW.js}

@@ -1,5 +1,7 @@
-import { S as resolveCodexAppServerUserHomeDir } from "./config-giW8X0QA.js";
-import { St as resolveCodexAppServerLocalHomeDir, xt as resolveCodexAppServerHomeDir } from "./shared-client-DKz23hHY.js";
+import { $ as assertCodexThreadResumeResponse, H as isCodexAppServerOverloadError, M as isCodexAppServerStartupError, U as isCodexAppServerPrewriteRequestCancellationError, q as CodexAppServerRpcError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-DxcfF9KX.js";
+import { F as resolveCodexAppServerHomeDir, I as resolveCodexAppServerLocalHomeDir, L as resolveCodexAppServerUserHomeDir } from "./config-BhmfC1s6.js";
+import { d as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DYHcRQAa.js";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-DYAI5FQE.js";
 import { createRequire } from "node:module";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
@@ -13,7 +15,7 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 * identity and safe to refresh in the background.
 */
 /** Default app inventory cache freshness window. */
-const CODEX_APP_INVENTORY_CACHE_TTL_MS = 3600 * 1e3;
+const CODEX_APP_INVENTORY_CACHE_TTL_MS = 36e5;
 const CODEX_APP_READ_BATCH_LIMIT = 100;
 const MAX_SERIALIZED_ERROR_MESSAGE_LENGTH = 500;
 /** In-memory app inventory cache with coalesced refreshes per key. */
@@ -264,7 +266,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 +288,8 @@ async function readInstalledApps(request, options) {
 				installUrl: metadata.installUrl ?? null,
 				isAccessible: true,
 				isEnabled: installedApp.enabled,
-				pluginDisplayNames: metadata.pluginDisplayNames
+				pluginDisplayNames: metadata.pluginDisplayNames,
+				...metadata.toolSummaries ? { toolSummaries: metadata.toolSummaries } : {}
 			}];
 		}),
 		installedApps: apps
@@ -330,7 +336,8 @@ function isSensitiveErrorDataKey(key) {
 * Builds stable Codex plugin/app inventory cache keys from app-server startup,
 * auth, account, and version inputs without storing secret material.
 */
-const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require: createRequire(import.meta.url) });
+const require = createRequire(import.meta.url);
+const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require });
 let catalogConnectionHomes = /* @__PURE__ */ new Map();
 function catalogConnectionHomeKey(fingerprint, agentDir) {
 	return `${agentDir ?? ""}\0${fingerprint}`;
@@ -420,4 +427,49 @@ function fingerprintCodexPluginAppCacheCredentials(startOptions) {
 	return `sha256:${hash.digest("hex")}`;
 }
 //#endregion
-export { resolveCodexCatalogConnectionHome as a, replaceCodexCatalogConnectionHomes as i, buildCodexAppServerRuntimeFingerprint as n, defaultCodexAppInventoryCache as o, buildCodexPluginAppCacheKey as r, serializeCodexAppInventoryError as s, buildCodexAppServerConnectionFingerprint as t };
+//#region extensions/codex/src/app-server/thread-resume.ts
+/** Owns Codex thread/resume subscription safety. */
+/** Resumes one thread, releasing or isolating every possible native subscription. */
+async function resumeCodexAppServerThread(params) {
+	const threadId = params.request.threadId;
+	let response;
+	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);
+	} 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 { 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-DsCMWBca.js → transcript-mirror-DTUxFWa_.js}

@@ -1,15 +1,31 @@
-import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
+import { i as readUpstreamUserText, n as attachUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
 import { deliverAgentHarnessUserInputPrompt, embeddedAgentLog, formatErrorMessage, projectAgentHarnessTranscriptMessageForDisplay, runAgentHarnessBeforeMessageWriteHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
+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 = 512 * 1024;
-const CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES = 64 * 1024;
+const CODEX_HISTORY_IMPORT_MAX_BYTES = 524288;
+const CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES = 65536;
 const CODEX_HISTORY_TRUNCATION_SUFFIX = "\n\n[Message truncated during Codex history import.]";
 const CODEX_HISTORY_ASSISTANT_API = "openai-chatgpt-responses";
 const CODEX_HISTORY_ASSISTANT_PROVIDER = "openai";
@@ -34,7 +50,8 @@ function normalizeImportedHistoryText(value) {
 	if (!text) return;
 	if (Buffer.byteLength(text, "utf8") <= CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES) return text;
 	const suffixBytes = Buffer.byteLength(CODEX_HISTORY_TRUNCATION_SUFFIX, "utf8");
-	return `${truncateUtf8Prefix(text, Math.max(0, CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES - suffixBytes))}${CODEX_HISTORY_TRUNCATION_SUFFIX}`;
+	const contentLimitBytes = Math.max(0, CODEX_HISTORY_IMPORT_MAX_MESSAGE_BYTES - suffixBytes);
+	return `${truncateUtf8Prefix(text, contentLimitBytes)}${CODEX_HISTORY_TRUNCATION_SUFFIX}`;
 }
 function projectCodexUserItemText(item) {
 	if (!Array.isArray(item.content)) return;
@@ -178,6 +195,22 @@ const MIRROR_ORIGIN_META_KEY = "mirrorOrigin";
 const MIRROR_SOURCE_FINGERPRINT_META_KEY = "mirrorSourceFingerprint";
 const CODEX_APP_SERVER_MIRROR_ORIGIN = "codex-app-server";
 const CODEX_META_KEY = "__openclaw";
+function applyCodexTranscriptTaint(message, state) {
+	if (message.role === "user") {
+		state.tainted = false;
+		return message;
+	}
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const metadata = asOptionalRecord(existing);
+	state.tainted ||= metadata?.turnTainted === true || metadata?.resultContentSource === "network";
+	return message.role === "assistant" && state.tainted ? {
+		...message,
+		__openclaw: {
+			...metadata,
+			turnTainted: true
+		}
+	} : message;
+}
 function attachCodexMirrorAttestation(message, sourceFingerprint) {
 	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
 	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
@@ -191,7 +224,8 @@ function attachCodexMirrorAttestation(message, sourceFingerprint) {
 	};
 }
 function attachCodexMirrorRunId(message, runId, terminal = false) {
-	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0) ?? {};
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(existing) ?? {};
 	return {
 		...message,
 		[CODEX_META_KEY]: {
@@ -201,6 +235,10 @@ function attachCodexMirrorRunId(message, runId, terminal = false) {
 		}
 	};
 }
+function hasCodexMirrorOrigin(message) {
+	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	return asOptionalRecord(meta)?.[MIRROR_ORIGIN_META_KEY] === CODEX_APP_SERVER_MIRROR_ORIGIN;
+}
 function readCodexMirrorSourceFingerprint(message) {
 	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
 	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
@@ -279,25 +317,26 @@ function readMirroredAssistantText(message) {
 }
 /** Imports a bounded, user-visible Codex history tail into a new OpenClaw transcript. */
 async function importCodexThreadHistoryToTranscript(params) {
-	const projection = projectBoundedCodexThreadHistory({
+	const { transcriptMessages, importedMessages, omittedMessages } = projectBoundedCodexThreadHistory({
 		thread: params.thread,
 		throughTurnId: params.throughTurnId,
 		importedAt: Date.now(),
 		...params.modelProvider ? { modelProvider: params.modelProvider } : {}
 	});
-	if (projection.transcriptMessages.length > 0) await mirror({
+	if (transcriptMessages.length > 0) await mirror({
+		assertCurrent: params.assertCurrent,
 		storePath: params.storePath,
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
 		...params.agentId ? { agentId: params.agentId } : {},
 		...params.cwd ? { cwd: params.cwd } : {},
 		...params.config ? { config: params.config } : {},
-		messages: projection.transcriptMessages,
+		messages: transcriptMessages,
 		idempotencyScope: `codex-app-server:${params.thread.id}:history`
 	});
 	return {
-		importedMessages: projection.importedMessages,
-		omittedMessages: projection.omittedMessages
+		importedMessages,
+		omittedMessages
 	};
 }
 async function mirrorBestEffort(params) {
@@ -325,6 +364,7 @@ async function mirrorBestEffort(params) {
 				mirrorIdentity: `${params.turnId}:assistant`,
 				runId: params.params.runId
 			},
+			prepareAssistantTranscriptMessage: params.params.prepareAssistantTranscriptMessage,
 			config: params.params.config
 		});
 		for (const receipt of mirrorResult.userMessageReceipts) try {
@@ -399,7 +439,18 @@ async function mirrorPromptAtTurnStartBestEffort(params) {
 				hidden: params.params.trigger === "memory",
 				message: attachUpstreamUserText(attachCodexMirrorIdentity(await buildResolvedCodexUserPromptMessage(params.params), `${params.turnId}:prompt`), params.upstreamUserText)
 			});
+			if (params.params.userTurnTranscriptRecorder?.getAdmissionReceipt()) {
+				const annotate = params.params.hostCapabilities.annotateCurrentUserTurn;
+				if (!annotate || userPromptMessage.role !== "user") throw new Error("current host admission is unavailable for native prompt annotation");
+				await annotate({
+					mirrorIdentity: `${params.turnId}:prompt`,
+					upstreamUserText: params.upstreamUserText,
+					mirrorOrigin: "codex-app-server",
+					mirrorSourceFingerprint: fingerprintCodexMirrorSourceMessage(userPromptMessage)
+				});
+			}
 			const mirrorResult = await mirror({
+				assertCurrent: params.params.hostCapabilities.assertActive,
 				agentId: params.agentId,
 				sessionKey: params.sessionKey,
 				sessionId: params.params.sessionId,
@@ -431,9 +482,7 @@ function fingerprintMirrorMessageContent(message) {
 	return createHash("sha256").update(payload).digest("hex").slice(0, 16);
 }
 function buildMirrorDedupeIdentity(message) {
-	const explicit = readMirrorIdentity(message);
-	if (explicit) return explicit;
-	return `${message.role}:${fingerprintMirrorMessageContent(message)}`;
+	return readMirrorIdentity(message) || `${message.role}:${fingerprintMirrorMessageContent(message)}`;
 }
 async function mirror(params) {
 	const messages = params.messages.filter(isMirroredAgentMessage);
@@ -457,10 +506,12 @@ async function mirror(params) {
 	});
 	const candidateIdempotencyKeys = candidates.flatMap(({ idempotencyKey }) => idempotencyKey ? [idempotencyKey] : []);
 	const transcriptTarget = resolveCodexMirrorTranscriptTarget(params);
-	const { appendedUpdates, assistantMirrorIdentitiesAppended, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts, userMessagesPresent } = await withCodexSessionTranscriptMirrorWriteLock({
+	params.assertCurrent?.();
+	const mirrorBatch = await withCodexSessionTranscriptMirrorWriteLock({
 		...transcriptTarget,
 		config: params.config
 	}, async (transcript) => {
+		params.assertCurrent?.();
 		const nextAppendedUpdates = [];
 		const nextAssistantMirrorIdentitiesAppended = /* @__PURE__ */ new Set();
 		const nextAssistantMirrorIdentitiesOwned = /* @__PURE__ */ new Set();
@@ -469,6 +520,7 @@ async function mirror(params) {
 		const nextUserMessageReceipts = [];
 		const nextUserMessagesPresent = [];
 		const mirrorFacts = await transcript.readMessageFacts({ idempotencyKeys: candidateIdempotencyKeys });
+		params.assertCurrent?.();
 		for (const { dedupeIdentity, idempotencyKey, message, sourceFingerprint } of candidates) {
 			const mirrorIdentity = readMirrorIdentity(message);
 			const ownsRun = Boolean(params.runId && (!params.runMirrorIdentityPrefix || mirrorIdentity?.startsWith(params.runMirrorIdentityPrefix)));
@@ -495,10 +547,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);
@@ -515,11 +569,17 @@ async function mirror(params) {
 				hidden: message.display === false,
 				message: messageToAppend
 			});
+			params.assertCurrent?.();
 			const { messageSeq, result: appended } = await transcript.appendMessageWithMessageSequence({
 				message: messageToAppend,
+				...params.assertCurrent ? { prepareMessageAfterIdempotencyCheck: (preparedMessage) => {
+					params.assertCurrent?.();
+					return preparedMessage;
+				} } : {},
 				idempotencyLookup: "scan",
 				cwd: params.cwd
 			});
+			params.assertCurrent?.();
 			if (!appended) continue;
 			const { messageId, message: appendedMessage } = appended;
 			if (isMirroredAgentMessage(appendedMessage)) {
@@ -558,6 +618,8 @@ async function mirror(params) {
 			userMessagesPresent: nextUserMessagesPresent
 		};
 	});
+	params.assertCurrent?.();
+	const { appendedUpdates, assistantMirrorIdentitiesAppended, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts, userMessagesPresent } = 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;
@@ -666,4 +728,4 @@ function resolveCodexMirrorTranscriptTarget(params) {
 	};
 }
 //#endregion
-export { buildCodexUserPromptMessage as a, readCodexMirrorSourceFingerprint as c, projectBoundedCodexVisibleSessionHistory as d, mirrorPromptAtTurnStartBestEffort as i, serializeCodexMirrorSourceEvidence as l, createCodexAppServerUserMessagePersistenceNotifier as n, promptSnapshot as o, importCodexThreadHistoryToTranscript as r, fingerprintCodexMirrorSourceMessage as s, codexTranscriptMirrorRuntime as t, projectBoundedCodexThreadHistory as u };
+export { buildCodexUserPromptMessage as a, fingerprintCodexMirrorSourceMessage as c, serializeCodexMirrorSourceEvidence as d, projectBoundedCodexThreadHistory as f, codexCatalogHomeId as g, canonicalCodexCatalogHome as h, mirrorPromptAtTurnStartBestEffort as i, hasCodexMirrorOrigin as l, projectCodexUserItemText as m, createCodexAppServerUserMessagePersistenceNotifier as n, promptSnapshot as o, projectBoundedCodexVisibleSessionHistory as p, importCodexThreadHistoryToTranscript as r, applyCodexTranscriptTaint as s, codexTranscriptMirrorRuntime as t, readCodexMirrorSourceFingerprint as u };