@openclaw/codex 2026.8.2 → 2026.9.1

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

@@ -1,10 +1,11 @@
-import { Ct as retainCodexAppServerLiveThread, St as releaseCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, bt as isCodexAppServerLiveThreadClaimed } from "./shared-client-B1tT5U6r.js";
-import { a as closeCodexStartupClientBestEffort, f as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CpVfwctT.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();
-/** Serialize connection-scoped unsubscribe with attach/resume of the same native thread. */
+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);
 }
@@ -23,7 +24,7 @@ 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, assertCurrent) => {
 		if (!await unsubscribeCodexThreadBestEffort(client, {
@@ -35,7 +36,7 @@ async function retainCodexAppServerBindingSubscription(client, threadId, ownersh
 			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) {
@@ -72,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",
@@ -96,7 +97,7 @@ async function retireCodexConversationThreadBinding(params) {
 			}
 			throw error;
 		}
-	});
+	}));
 }
 //#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 };

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/{thread-resume-BFt1-ZDa.js → thread-resume-C7pyVKeW.js}

@@ -1,8 +1,7 @@
-import { F as resolveCodexAppServerLocalHomeDir, I as resolveCodexAppServerUserHomeDir, P as resolveCodexAppServerHomeDir } from "./config-CcYL77O6.js";
-import { $ as CodexAppServerRpcError, J as isCodexAppServerOverloadError, P as isCodexAppServerStartupError, Y as isCodexAppServerPrewriteRequestCancellationError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-B1tT5U6r.js";
-import { o as assertCodexThreadResumeResponse } from "./protocol-validators-Bg5rpNxk.js";
-import { f as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CpVfwctT.js";
-import { t as CodexAppServerScopedRequestRejectedError } from "./request-BWxweEdK.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";
@@ -434,15 +433,24 @@ function fingerprintCodexPluginAppCacheCredentials(startOptions) {
 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: params.assertCurrent
+			assertCurrent
 		})));
 		assertCodexThreadResumeSubscription(threadId, response.thread.id);
 	} catch (error) {
-		if (params.isPrewriteOwnershipError?.(error) || isCodexAppServerStartSelectionChangedError(error) || isCodexAppServerStartupError(error) || error instanceof CodexAppServerScopedRequestRejectedError || isCodexAppServerPrewriteRequestCancellationError(error) || isCodexAppServerOverloadError(error)) throw error;
+		if (ownershipRejected || isCodexAppServerStartSelectionChangedError(error) || isCodexAppServerStartupError(error) || error instanceof CodexAppServerScopedRequestRejectedError || isCodexAppServerPrewriteRequestCancellationError(error) || isCodexAppServerOverloadError(error)) throw error;
 		if (error instanceof CodexAppServerRpcError) {
 			if (await unsubscribeCodexThreadBestEffort(params.client, {
 				threadId,

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

@@ -1,11 +1,27 @@
 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 = 524288;
@@ -301,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) {
@@ -422,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,
@@ -454,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);
@@ -480,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();
@@ -492,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)));
@@ -540,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)) {
@@ -583,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;
@@ -691,4 +728,4 @@ function resolveCodexMirrorTranscriptTarget(params) {
 	};
 }
 //#endregion
-export { buildCodexUserPromptMessage as a, fingerprintCodexMirrorSourceMessage as c, serializeCodexMirrorSourceEvidence as d, projectBoundedCodexThreadHistory as f, 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, 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 };

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

@@ -1,4 +1,4 @@
-import { t as normalizeCodexAppServerArgs } from "./launch-args-sXOAg0SX.js";
+import { n as normalizeCodexAppServerArgs } from "./launch-args-RXQwn8zV.js";
 import { readFile, readdir } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
@@ -115,6 +115,8 @@ async function readProcessOutput(args, deadline) {
 			inspector.unref();
 		}, Math.max(1, remainingMs));
 		timer.unref?.();
+	}).catch((error) => {
+		throw inspectionFailure(error);
 	});
 }
 function parseProcesses(output, selected) {