@openclaw/codex 2026.9.1 → 2026.9.2

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

@@ -1,7 +1,7 @@
-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 { 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";
 //#region extensions/codex/src/app-server/thread-ownership.ts
 const nativeThreadOwners = resolveGlobalSingleton(Symbol.for("openclaw.codexNativeThreadOwners"), () => new KeyedAsyncQueue());
@@ -71,10 +71,10 @@ async function releaseCodexAppServerBindingSubscription(binding, options = {}) {
 }
 /** Clears and releases one exact conversation generation without touching its replacement. */
 async function retireCodexConversationThreadBinding(params) {
-	const expected = await params.bindingStore.read(params.identity);
+	const expected = params.bindingStore.read(params.identity);
 	if (!expected || params.expectedThreadId && expected.threadId !== params.expectedThreadId) return false;
 	return await withCodexAppServerThreadMutation(expected.threadId, () => params.bindingStore.withLease(params.identity, async () => {
-		const current = await params.bindingStore.read(params.identity);
+		const current = params.bindingStore.read(params.identity);
 		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, {

package/dist/thread-policy-CTalhWFy.js

@@ -0,0 +1,105 @@
+import { O as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-CyapYSji.js";
+import { H as isCodexAppServerOverloadError, U as isCodexAppServerPrewriteRequestCancellationError } from "./shared-client-CKhX2kFt.js";
+import { n as buildCodexAppServerConnectionFingerprint, o as resolveCodexCatalogConnectionHome } from "./thread-resume-BLgqkUc1.js";
+import { r as requestCodexAppServerClientJson, t as CodexAppServerScopedRequestRejectedError } from "./request-C8H22rPi.js";
+import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/binding-connection.ts
+/** Prevents a prepared native session from becoming a fresh thread after its binding changes. */
+function assertCodexSessionRuntimeOwnership(binding, expected) {
+	if (!expected) return;
+	const auth = binding?.connectionScope === "supervision" ? "native" : "host";
+	const hostModelChanged = expected.auth === "host" && (!expected.modelRef || binding?.model !== expected.modelRef.model || binding?.modelProvider !== expected.modelRef.provider);
+	if (binding?.preserveNativeModel !== true || auth !== expected.auth || hostModelChanged) throw new AgentHarnessPreflightError("Codex native session ownership is missing or changed. Reattach the original native session or create a new chat with a concrete model; no replacement thread was started.");
+}
+/** Requires the native model pair after a supervised pending branch has materialized. */
+function requireCodexSupervisionModelSelection(binding) {
+	const model = binding.model?.trim();
+	const modelProvider = binding.modelProvider?.trim();
+	if (binding.connectionScope !== "supervision" || !model || !modelProvider) throw new Error("Codex supervised binding is missing its native model and provider; refusing request selection");
+	return {
+		model,
+		modelProvider
+	};
+}
+/** Resolves connection and auth ownership exclusively from the private thread binding. */
+function resolveCodexBindingAppServerConnection(params) {
+	const { binding, authProfileId, ...runtimeParams } = params;
+	const usesSupervisionConnection = binding?.connectionScope === "supervision";
+	if (usesSupervisionConnection && readCodexPluginConfig(runtimeParams.pluginConfig).supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
+	let appServer = (usesSupervisionConnection ? resolveCodexSupervisionAppServerRuntimeOptions : resolveCodexAppServerRuntimeOptions)(runtimeParams);
+	if (usesSupervisionConnection) {
+		const persistedFingerprint = binding.pendingSupervisionBranch?.connectionFingerprint ?? binding.appServerRuntimeFingerprint;
+		const catalogHome = persistedFingerprint ? resolveCodexCatalogConnectionHome(persistedFingerprint, runtimeParams.agentDir) : void 0;
+		if (catalogHome) appServer = {
+			...appServer,
+			start: {
+				...appServer.start,
+				homeScope: "user",
+				env: {
+					...appServer.start.env,
+					CODEX_HOME: catalogHome
+				}
+			}
+		};
+		const currentFingerprint = buildCodexAppServerConnectionFingerprint(appServer, runtimeParams.agentDir);
+		if (!persistedFingerprint || persistedFingerprint !== currentFingerprint) throw new Error("Codex supervision connection changed; refusing to operate on its bound native thread");
+	}
+	return {
+		appServer,
+		usesSupervisionConnection,
+		requestAuthProfileId: usesSupervisionConnection ? void 0 : authProfileId,
+		clientAuthProfileId: usesSupervisionConnection ? null : authProfileId
+	};
+}
+//#endregion
+//#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 { assertCodexSessionRuntimeOwnership as a, refreshCodexThreadPolicy as i, CodexThreadPolicyHandoffError as n, requireCodexSupervisionModelSelection as o, assertCodexSupervisionThreadLineage as r, resolveCodexBindingAppServerConnection as s, CodexIncognitoPolicyChangeError as t };

package/dist/{thread-resume-C7pyVKeW.js → thread-resume-BLgqkUc1.js}

@@ -1,13 +1,13 @@
-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 { M as resolveCodexAppServerHomeDir, N as resolveCodexAppServerLocalHomeDir, P as resolveCodexAppServerUserHomeDir } from "./config-CyapYSji.js";
+import { H as isCodexAppServerOverloadError, M as isCodexAppServerStartupError, U as isCodexAppServerPrewriteRequestCancellationError, q as CodexAppServerRpcError, tt as assertCodexThreadResumeResponse, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CKhX2kFt.js";
+import { d as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-Bp1ZOnk2.js";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-C8H22rPi.js";
 import { createRequire } from "node:module";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
+import { createHash } from "node:crypto";
 import { isFutureDateTimestampMs, resolveDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
 import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { createHash } from "node:crypto";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/app-inventory-cache.ts
 /**
@@ -472,4 +472,4 @@ async function resumeCodexAppServerThread(params) {
 	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 };
+export { replaceCodexCatalogConnectionHomes as a, defaultCodexAppInventoryCache as c, buildCodexPluginAppCacheKey as i, serializeCodexAppInventoryError as l, buildCodexAppServerConnectionFingerprint as n, resolveCodexCatalogConnectionHome as o, buildCodexAppServerRuntimeFingerprint as r, CodexAppInventoryCache as s, resumeCodexAppServerThread as t };

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

@@ -1,8 +1,9 @@
 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 { i as fingerprintCodexMirrorSourceMessage, n as attachCodexMirrorAttestation, o as readCodexMirrorSourceFingerprint, r as attachCodexMirrorRunId } from "./transcript-mirror-attestation-Byl34PC-.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";
@@ -190,78 +191,6 @@ function projectBoundedCodexVisibleSessionHistory(entries) {
 	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";
-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 : {};
-	return {
-		...message,
-		[CODEX_META_KEY]: {
-			...baseMeta,
-			[MIRROR_ORIGIN_META_KEY]: CODEX_APP_SERVER_MIRROR_ORIGIN,
-			...sourceFingerprint ? { [MIRROR_SOURCE_FINGERPRINT_META_KEY]: sourceFingerprint } : {}
-		}
-	};
-}
-function attachCodexMirrorRunId(message, runId, terminal = false) {
-	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
-	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(existing) ?? {};
-	return {
-		...message,
-		[CODEX_META_KEY]: {
-			...current,
-			runId,
-			...terminal ? { runTerminal: true } : {}
-		}
-	};
-}
-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;
-	const value = meta[MIRROR_SOURCE_FINGERPRINT_META_KEY];
-	return typeof value === "string" && value ? value : void 0;
-}
-function serializeCodexMirrorSourceEvidence(message) {
-	const content = "content" in message ? message.content : void 0;
-	return JSON.stringify({
-		role: message.role,
-		content,
-		...message.role === "user" ? { upstreamUserText: readUpstreamUserText(message) } : {},
-		...message.role === "toolResult" ? {
-			toolCallId: message.toolCallId,
-			toolName: message.toolName,
-			isError: message.isError
-		} : {}
-	});
-}
-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;
@@ -306,6 +235,18 @@ function promptSnapshot(params, turnId, upstreamUserText) {
 async function buildResolvedCodexUserPromptMessage(params) {
 	return buildFromPrepared(params, await params.userTurnTranscriptRecorder?.resolveMessage() ?? params.userTurnTranscriptRecorder?.message);
 }
+async function resolveFinalCodexMirrorMessages(params) {
+	if (params.params.suppressNextUserMessagePersistence || !params.params.userTurnTranscriptRecorder) return params.messagesSnapshot;
+	const previousPrompt = params.messagesSnapshot.find((message) => message.role === "user");
+	const resolvedBase = attachCodexMirrorIdentity(await buildResolvedCodexUserPromptMessage(params.params), `${params.turnId}:prompt`);
+	const upstreamUserText = readUpstreamUserText(previousPrompt);
+	const resolvedPrompt = upstreamUserText ? attachUpstreamUserText(resolvedBase, upstreamUserText) : resolvedBase;
+	const firstUserIndex = params.messagesSnapshot.findIndex((message) => message.role === "user");
+	if (firstUserIndex === -1) return [resolvedPrompt, ...params.messagesSnapshot];
+	const messages = params.messagesSnapshot.slice();
+	messages[firstUserIndex] = resolvedPrompt;
+	return messages;
+}
 //#endregion
 //#region extensions/codex/src/app-server/transcript-mirror.ts
 function isMirroredAgentMessage(message) {
@@ -350,7 +291,9 @@ async function mirrorBestEffort(params) {
 			messagesSnapshot: params.result.messagesSnapshot,
 			turnId: params.turnId
 		});
+		params.assertWriteCurrent?.();
 		const mirrorResult = await mirror({
+			assertWriteCurrent: params.assertWriteCurrent,
 			agentId: params.agentId,
 			sessionKey: params.sessionKey,
 			sessionId: params.params.sessionId,
@@ -368,7 +311,7 @@ async function mirrorBestEffort(params) {
 			config: params.params.config
 		});
 		for (const receipt of mirrorResult.userMessageReceipts) try {
-			params.notifyUserMessagePersisted(receipt.message, receipt.anchor);
+			params.notifyUserMessagePersisted(receipt);
 		} catch (error) {
 			embeddedAgentLog.warn("failed to notify codex app-server user-message persistence", { error: formatErrorMessage(error) });
 		}
@@ -406,26 +349,14 @@ async function mirrorBestEffort(params) {
 		};
 	}
 }
-async function resolveFinalCodexMirrorMessages(params) {
-	if (params.params.suppressNextUserMessagePersistence || !params.params.userTurnTranscriptRecorder) return params.messagesSnapshot;
-	const promptSnapshot = params.messagesSnapshot.find((message) => message.role === "user");
-	const resolvedBase = attachCodexMirrorIdentity(await buildResolvedCodexUserPromptMessage(params.params), `${params.turnId}:prompt`);
-	const upstreamUserText = readUpstreamUserText(promptSnapshot);
-	const resolvedPrompt = upstreamUserText ? attachUpstreamUserText(resolvedBase, upstreamUserText) : resolvedBase;
-	const firstUserIndex = params.messagesSnapshot.findIndex((message) => message.role === "user");
-	if (firstUserIndex === -1) return [resolvedPrompt, ...params.messagesSnapshot];
-	const messages = params.messagesSnapshot.slice();
-	messages[firstUserIndex] = resolvedPrompt;
-	return messages;
-}
 function createCodexAppServerUserMessagePersistenceNotifier(runParams) {
 	let notified = false;
-	return (message, anchor) => {
+	return (receipt) => {
 		if (notified) return;
 		notified = true;
-		runParams.userTurnTranscriptRecorder?.markRuntimePersisted(message, anchor);
+		runParams.userTurnTranscriptRecorder?.markRuntimePersisted(receipt.message, receipt.anchor, receipt);
 		try {
-			runParams.onUserMessagePersisted?.(message);
+			runParams.onUserMessagePersisted?.(receipt.message);
 		} catch (error) {
 			embeddedAgentLog.warn("codex app-server user persistence notification failed", { error: formatErrorMessage(error) });
 		}
@@ -439,7 +370,8 @@ 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 recorder = params.params.userTurnTranscriptRecorder;
+			if (recorder?.getAdmissionReceipt() && recorder.getPersistedMessage?.()?.display !== false) {
 				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({
@@ -462,7 +394,7 @@ async function mirrorPromptAtTurnStartBestEffort(params) {
 				runMirrorIdentityPrefix: `${params.turnId}:`,
 				config: params.params.config
 			});
-			for (const receipt of mirrorResult.userMessageReceipts) params.notifyUserMessagePersisted(receipt.message, receipt.anchor);
+			for (const receipt of mirrorResult.userMessageReceipts) params.notifyUserMessagePersisted(receipt);
 		})();
 		params.params.userTurnTranscriptRecorder?.markRuntimePersistencePending(mirrorPromise);
 		await mirrorPromise;
@@ -491,8 +423,7 @@ async function mirror(params) {
 		assistantMirrorIdentitiesOwned: [],
 		anchorsByMirrorIdentity: /* @__PURE__ */ new Map(),
 		messagesPresent: [],
-		userMessageReceipts: [],
-		userMessagesPresent: []
+		userMessageReceipts: []
 	};
 	const candidates = messages.map((message) => {
 		const dedupeIdentity = buildMirrorDedupeIdentity(message);
@@ -506,28 +437,32 @@ async function mirror(params) {
 	});
 	const candidateIdempotencyKeys = candidates.flatMap(({ idempotencyKey }) => idempotencyKey ? [idempotencyKey] : []);
 	const transcriptTarget = resolveCodexMirrorTranscriptTarget(params);
-	params.assertCurrent?.();
+	const assertWritable = () => {
+		params.assertCurrent?.();
+		params.assertWriteCurrent?.();
+	};
+	assertWritable();
 	const mirrorBatch = await withCodexSessionTranscriptMirrorWriteLock({
 		...transcriptTarget,
 		config: params.config
 	}, async (transcript) => {
-		params.assertCurrent?.();
+		assertWritable();
 		const nextAppendedUpdates = [];
 		const nextAssistantMirrorIdentitiesAppended = /* @__PURE__ */ new Set();
 		const nextAssistantMirrorIdentitiesOwned = /* @__PURE__ */ new Set();
 		const nextAnchorsByMirrorIdentity = /* @__PURE__ */ new Map();
 		const nextMessagesPresent = [];
 		const nextUserMessageReceipts = [];
-		const nextUserMessagesPresent = [];
 		const mirrorFacts = await transcript.readMessageFacts({ idempotencyKeys: candidateIdempotencyKeys });
-		params.assertCurrent?.();
+		assertWritable();
 		for (const { dedupeIdentity, idempotencyKey, message, sourceFingerprint } of candidates) {
 			const mirrorIdentity = readMirrorIdentity(message);
 			const ownsRun = Boolean(params.runId && (!params.runMirrorIdentityPrefix || mirrorIdentity?.startsWith(params.runMirrorIdentityPrefix)));
 			const terminalOwner = params.terminalAssistantOwner;
 			const ownsTerminal = Boolean(ownsRun && terminalOwner && mirrorIdentity === terminalOwner.mirrorIdentity);
+			const ownedMessage = ownsRun && params.runId ? attachCodexMirrorRunId(message, params.runId, ownsTerminal) : message;
 			const transcriptMessage = {
-				...attachCodexMirrorAttestation(ownsRun && params.runId ? attachCodexMirrorRunId(message, params.runId, ownsTerminal) : message, sourceFingerprint),
+				...attachCodexMirrorAttestation(ownedMessage, sourceFingerprint),
 				...idempotencyKey ? { idempotencyKey } : {}
 			};
 			if (idempotencyKey && mirrorFacts.existingIdempotencyKeys.has(idempotencyKey)) {
@@ -535,18 +470,25 @@ async function mirror(params) {
 				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 (persistedMessage.role === "user" && persistedAnchor) nextUserMessageReceipts.push({
+						anchor: persistedAnchor,
+						appended: false,
+						message: persistedMessage
+					});
 				}
 				if (persistedAnchor) nextAnchorsByMirrorIdentity.set(dedupeIdentity, persistedAnchor);
 				if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
 				continue;
 			}
+			assertWritable();
+			const preparedUserMessage = transcriptMessage.role === "user" ? {
+				...transcriptMessage,
+				__openclaw: { ...Reflect.get(transcriptMessage, "__openclaw") }
+			} : void 0;
+			if (preparedUserMessage?.["__openclaw"].humanMentions !== void 0) {
+				preparedUserMessage.content = structuredClone(preparedUserMessage.content);
+				preparedUserMessage["__openclaw"].humanMentions = structuredClone(preparedUserMessage["__openclaw"].humanMentions);
+			}
 			const nextMessage = runAgentHarnessBeforeMessageWriteHook({
 				message: transcriptMessage,
 				agentId: params.agentId,
@@ -558,10 +500,14 @@ async function mirror(params) {
 				if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
 				continue;
 			}
+			const restoredMessage = restorePreparedUserTurnOperationalMetaForRuntime({
+				runtimeMessage: nextMessage,
+				preparedMessage: preparedUserMessage
+			});
 			let messageToAppend = idempotencyKey ? {
-				...attachCodexMirrorAttestation(nextMessage, sourceFingerprint),
+				...attachCodexMirrorAttestation(restoredMessage, sourceFingerprint),
 				idempotencyKey
-			} : attachCodexMirrorAttestation(nextMessage, sourceFingerprint);
+			} : attachCodexMirrorAttestation(restoredMessage, sourceFingerprint);
 			if (mirrorIdentity) messageToAppend = attachCodexMirrorIdentity(messageToAppend, mirrorIdentity);
 			if (ownsRun && params.runId) messageToAppend = attachCodexMirrorRunId(messageToAppend, params.runId, ownsTerminal);
 			if (message.role === "assistant" && message.openclawAsyncDelivery) messageToAppend = Object.assign(messageToAppend, { openclawAsyncDelivery: { itemId: message.openclawAsyncDelivery.itemId } });
@@ -569,11 +515,11 @@ async function mirror(params) {
 				hidden: message.display === false,
 				message: messageToAppend
 			});
-			params.assertCurrent?.();
+			assertWritable();
 			const { messageSeq, result: appended } = await transcript.appendMessageWithMessageSequence({
 				message: messageToAppend,
-				...params.assertCurrent ? { prepareMessageAfterIdempotencyCheck: (preparedMessage) => {
-					params.assertCurrent?.();
+				...params.assertCurrent || params.assertWriteCurrent ? { prepareMessageAfterIdempotencyCheck: (preparedMessage) => {
+					assertWritable();
 					return preparedMessage;
 				} } : {},
 				idempotencyLookup: "scan",
@@ -588,13 +534,11 @@ async function mirror(params) {
 			}
 			if (message.role === "assistant") nextAssistantMirrorIdentitiesOwned.add(dedupeIdentity);
 			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 (appendedMessage.role === "user" && appended.anchor) nextUserMessageReceipts.push({
+				anchor: appended.anchor,
+				appended: appended.appended,
+				message: appendedMessage
+			});
 			if (appended.appended) {
 				if (message.role === "assistant") nextAssistantMirrorIdentitiesAppended.add(dedupeIdentity);
 				nextAppendedUpdates.push({
@@ -614,12 +558,11 @@ async function mirror(params) {
 			assistantMirrorIdentitiesOwned: [...nextAssistantMirrorIdentitiesOwned],
 			anchorsByMirrorIdentity: nextAnchorsByMirrorIdentity,
 			messagesPresent: nextMessagesPresent,
-			userMessageReceipts: nextUserMessageReceipts,
-			userMessagesPresent: nextUserMessagesPresent
+			userMessageReceipts: nextUserMessageReceipts
 		};
 	});
 	params.assertCurrent?.();
-	const { appendedUpdates, assistantMirrorIdentitiesAppended, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts, userMessagesPresent } = mirrorBatch;
+	const { appendedUpdates, assistantMirrorIdentitiesAppended, assistantMirrorIdentitiesOwned, anchorsByMirrorIdentity, messagesPresent, userMessageReceipts } = 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;
@@ -642,8 +585,7 @@ async function mirror(params) {
 		assistantMirrorIdentitiesOwned,
 		anchorsByMirrorIdentity,
 		messagesPresent,
-		userMessageReceipts,
-		userMessagesPresent
+		userMessageReceipts
 	};
 }
 async function deliverAsyncMessageBestEffort(params) {
@@ -728,4 +670,4 @@ function resolveCodexMirrorTranscriptTarget(params) {
 	};
 }
 //#endregion
-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 };
+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 };

package/dist/transcript-mirror-attestation-Byl34PC-.js

@@ -0,0 +1,76 @@
+import { i as readUpstreamUserText } 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
+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 : {};
+	return {
+		...message,
+		[CODEX_META_KEY]: {
+			...baseMeta,
+			[MIRROR_ORIGIN_META_KEY]: CODEX_APP_SERVER_MIRROR_ORIGIN,
+			...sourceFingerprint ? { [MIRROR_SOURCE_FINGERPRINT_META_KEY]: sourceFingerprint } : {}
+		}
+	};
+}
+function attachCodexMirrorRunId(message, runId, terminal = false) {
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(existing) ?? {};
+	return {
+		...message,
+		[CODEX_META_KEY]: {
+			...current,
+			runId,
+			...terminal ? { runTerminal: true } : {}
+		}
+	};
+}
+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;
+	const value = meta[MIRROR_SOURCE_FINGERPRINT_META_KEY];
+	return typeof value === "string" && value ? value : void 0;
+}
+function serializeCodexMirrorSourceEvidence(message) {
+	const content = "content" in message ? message.content : void 0;
+	return JSON.stringify({
+		role: message.role,
+		content,
+		...message.role === "user" ? { upstreamUserText: readUpstreamUserText(message) } : {},
+		...message.role === "toolResult" ? {
+			toolCallId: message.toolCallId,
+			toolName: message.toolName,
+			isError: message.isError
+		} : {}
+	});
+}
+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 };

package/dist/{transport-stdio-CyPldczm.js → transport-stdio-CzTngV0j.js}

@@ -1,8 +1,8 @@
-import { n as normalizeCodexAppServerArgs } from "./launch-args-RXQwn8zV.js";
-import { readFile, readdir } from "node:fs/promises";
+import { p as normalizeCodexAppServerArgs } from "./managed-binary-DcpnJF9x.js";
 import { createHash, randomUUID } from "node:crypto";
-import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { z } from "zod";
+import { readFile, readdir } from "node:fs/promises";
+import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { execFile, spawn } from "node:child_process";
 import { once } from "node:events";
 import { setImmediate } from "node:timers/promises";
@@ -407,6 +407,7 @@ function signalProcess(pid, signal) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/transport-process-registration.ts
+const PROCESS_REGISTRATION_INSPECTION_MS = 1e4;
 const processIdentity = z.object({
 	pid: z.number().int().positive().safe(),
 	pgid: z.number().int().positive().safe(),
@@ -428,13 +429,13 @@ async function openProcessRegistrationStore() {
 		overflowPolicy: "reject-new"
 	});
 }
-async function reapRegisteredCodexAppServerOrphans(requestedDeadline) {
+async function reapRegisteredCodexAppServerOrphans() {
 	const store = await openProcessRegistrationStore();
-	const deadline = requestedDeadline ?? Date.now() + 1e4;
+	const deadline = Date.now() + PROCESS_REGISTRATION_INSPECTION_MS;
 	for (const entry of store.entries()) {
 		if (Date.now() >= deadline) throw new Error("Codex orphan cleanup exceeded its startup budget. Retry to finish cleanup.");
 		const registration = registrationSchema.parse(entry.value);
-		const snapshot = await readCodexAppServerProcessSnapshot(void 0, [registration.parent.pid, registration.child.pid]);
+		const snapshot = await readCodexAppServerProcessSnapshot(deadline, [registration.parent.pid, registration.child.pid]);
 		const parent = snapshot.find((row) => row.pid === registration.parent.pid);
 		if (parent?.startedAt === registration.parent.startedAt && !parent.state.startsWith("Z")) continue;
 		const child = snapshot.find((row) => row.pid === registration.child.pid);
@@ -479,11 +480,12 @@ async function prepareCodexAppServerProcessRegistration() {
 	return async (child) => {
 		await once(child, "spawn");
 		if (!child.pid) throw new ProcessInspectionError("unavailable");
-		const snapshot = await readCodexAppServerProcessSnapshot(void 0, [child.pid]);
+		const deadline = Date.now() + PROCESS_REGISTRATION_INSPECTION_MS;
+		const snapshot = await readCodexAppServerProcessSnapshot(deadline, [child.pid]);
 		const parent = snapshot.find((row) => row.pid === process.pid);
 		const spawned = snapshot.find((row) => row.pid === child.pid);
 		if (!parent || !spawned || spawned.ppid !== process.pid) throw new Error("Cannot register the Codex child process: its direct-parent identity is unavailable. Retry.");
-		const command = await readCodexAppServerProcessCommand(spawned, Date.now() + 2e3);
+		const command = await readCodexAppServerProcessCommand(spawned, deadline);
 		if (child.exitCode !== null || child.signalCode !== null) throw new Error("Cannot register the Codex child process command: the child exited during inspection. Retry.");
 		const key = randomUUID();
 		store.register(key, {