@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/{thread-ownership-DZeuKH1j.js → thread-ownership-CbucAmmp.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 { 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 = 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}`);
@@ -60,11 +71,11 @@ 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 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;
+	return await withCodexAppServerThreadMutation(expected.threadId, () => params.bindingStore.withLease(params.identity, async () => {
+		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, {
 			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-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/{plugin-app-cache-key-C1CAdfcP.js → thread-resume-BLgqkUc1.js}

@@ -1,11 +1,13 @@
-import { S as resolveCodexAppServerUserHomeDir } from "./config-giW8X0QA.js";
-import { St as resolveCodexAppServerLocalHomeDir, xt as resolveCodexAppServerHomeDir } from "./shared-client-DKz23hHY.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
 /**
@@ -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, defaultCodexAppInventoryCache as c, buildCodexPluginAppCacheKey as i, serializeCodexAppInventoryError as l, buildCodexAppServerConnectionFingerprint as n, resolveCodexCatalogConnectionHome as o, buildCodexAppServerRuntimeFingerprint as r, CodexAppInventoryCache as s, resumeCodexAppServerThread as t };