@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/session-catalog-home-id-BNwAJ9D7.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import fsSync from "node:fs";
+//#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
+export { codexCatalogHomeId as n, canonicalCodexCatalogHome as t };

package/dist/{session-cli-2PZaFLRh.js → session-cli-B1hKvfkI.js}

@@ -1,10 +1,15 @@
-import { a as CODEX_LOCAL_SESSION_HOST_ID } from "./session-catalog-DyOgR4WH.js";
+import "./session-catalog-ezP_UcRM.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { addGatewayClientOptions, callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
 //#region extensions/codex/src/session-cli.ts
 const CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS = 75e3;
+function requestedAgentId(options) {
+	const agentId = options.agent?.trim();
+	return agentId ? normalizeAgentId(agentId) : void 0;
+}
 function writeLine(value = "") {
 	process.stdout.write(`${value}\n`);
 }
@@ -80,12 +85,14 @@ function filterHosts(result, selector) {
 	} : result;
 }
 async function listCodexSessions(options) {
+	const agentId = requestedAgentId(options);
 	const host = options.host?.trim() || void 0;
 	const cursor = options.cursor?.trim() || void 0;
 	if (cursor && !host) throw new Error("--cursor requires --host so the cursor is routed to one Codex host");
 	const search = options.search?.trim() || void 0;
 	const limitPerHost = parsePageLimit(options.limit);
 	const params = {
+		...agentId ? { agentId } : {},
 		...search ? { search } : {},
 		...limitPerHost !== void 0 ? { limitPerHost } : {},
 		...host ? { hostIds: [host] } : {},
@@ -122,10 +129,13 @@ function readThreadId(value) {
 }
 async function continueCodexSession(threadIdValue, options) {
 	const threadId = readThreadId(threadIdValue);
+	const agentId = requestedAgentId(options);
+	const hostId = options.host?.trim() || "gateway:local";
 	const raw = await callGatewayFromCli("sessions.catalog.continue", gatewayOptions(options), {
 		catalogId: "codex",
-		hostId: CODEX_LOCAL_SESSION_HOST_ID,
-		threadId
+		hostId,
+		threadId,
+		...agentId ? { agentId } : {}
 	}, {
 		mode: "cli",
 		scopes: ["operator.write"]
@@ -140,11 +150,14 @@ async function continueCodexSession(threadIdValue, options) {
 }
 async function archiveCodexSession(threadIdValue, options) {
 	const threadId = readThreadId(threadIdValue);
+	const agentId = requestedAgentId(options);
+	const hostId = options.host?.trim() || "gateway:local";
 	if (options.confirmNoOtherRunner !== true) throw new Error("--confirm-no-other-runner is required because Codex client and runner activity is process-local");
 	const raw = await callGatewayFromCli("sessions.catalog.archive", gatewayOptions(options), {
 		catalogId: "codex",
-		hostId: CODEX_LOCAL_SESSION_HOST_ID,
+		hostId,
 		threadId,
+		...agentId ? { agentId } : {},
 		confirmNoOtherRunner: true
 	}, {
 		mode: "cli",
@@ -161,13 +174,13 @@ async function archiveCodexSession(threadIdValue, options) {
 /** Registers the plugin-owned Codex session supervision CLI. */
 function registerCodexSessionCli(program) {
 	const codex = program.command("codex").description("Inspect and branch from Codex sessions through the Gateway");
-	addGatewayClientOptions(codex.command("sessions").description("List non-archived Codex app-server sessions across connected hosts").option("--search <text>", "Search session titles (case-insensitive)").option("--host <id>", "Filter by stable host id").option("--limit <count>", "Maximum sessions returned per host").option("--cursor <cursor>", "Continue one host page (requires --host)").option("--json", "Print the structured catalog response", false), { timeoutMs: CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS }).action(async (options) => {
+	addGatewayClientOptions(codex.command("sessions").description("List non-archived Codex app-server sessions across connected hosts").option("--agent <id>", "Agent id that owns the Codex sessions").option("--search <text>", "Search session titles (case-insensitive)").option("--host <id>", "Filter by stable host id").option("--limit <count>", "Maximum sessions returned per host").option("--cursor <cursor>", "Continue one host page (requires --host)").option("--json", "Print the structured catalog response", false), { timeoutMs: CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS }).action(async (options) => {
 		await listCodexSessions(options);
 	});
-	addGatewayClientOptions(codex.command("continue <thread-id>").description("Continue a Gateway-local Codex thread as an OpenClaw branch").option("--json", "Print the structured response", false)).action(async (threadId, options) => {
+	addGatewayClientOptions(codex.command("continue <thread-id>").description("Continue a Gateway-local Codex thread as an OpenClaw branch").option("--agent <id>", "Agent id that owns the Codex session").option("--host <id>", "Stable local host id from codex sessions").option("--json", "Print the structured response", false)).action(async (threadId, options) => {
 		await continueCodexSession(threadId, options);
 	});
-	addGatewayClientOptions(codex.command("archive <thread-id>").description("Archive a stored or idle Gateway-local Codex thread").option("--confirm-no-other-runner", "Confirm no other Codex client or OpenClaw runner is using this thread", false).option("--json", "Print the structured response", false)).action(async (threadId, options) => {
+	addGatewayClientOptions(codex.command("archive <thread-id>").description("Archive a stored or idle Gateway-local Codex thread").option("--agent <id>", "Agent id that owns the Codex session").option("--host <id>", "Stable local host id from codex sessions").option("--confirm-no-other-runner", "Confirm no other Codex client or OpenClaw runner is using this thread", false).option("--json", "Print the structured response", false)).action(async (threadId, options) => {
 		await archiveCodexSession(threadId, options);
 	});
 }

package/dist/session-retirement-CE4iMiLh.js

@@ -0,0 +1,36 @@
+import { J as releaseCodexAppServerLiveThread, d as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-Dw-rzii0.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-URjUlCHg.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
+import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-GGq3RnOo.js";
+//#region extensions/codex/src/app-server/session-retirement.ts
+/** Retire binding and native subscription under the same generation/physical-client ownership fence. */
+async function retireCodexAppServerSessionGeneration(params) {
+	const retireGeneration = () => params.mode === "reset" ? params.bindingStore.resetSessionGeneration(params.identity) : params.bindingStore.retireSessionGeneration(params.identity);
+	const expectedBinding = await params.bindingStore.read(params.identity);
+	if (!expectedBinding) return await retireGeneration();
+	return await params.bindingStore.withLease(params.identity, async () => {
+		const binding = await params.bindingStore.read(params.identity);
+		if (binding?.threadId !== expectedBinding.threadId) return "conflict";
+		const result = await retireGeneration();
+		if (result !== "applied" || !binding?.clientId) return result;
+		const clientLease = retainSharedCodexAppServerClientByInstanceId(binding.clientId);
+		if (!clientLease) return result;
+		try {
+			codexNativeSubagentMonitorRuntime.retireParent(clientLease.client, binding.threadId);
+			if (!await releaseCodexAppServerLiveThread(clientLease.client, binding.threadId) && isIncognitoSessionKey(params.identity.sessionKey)) {
+				if (!await unsubscribeCodexThreadBestEffort(clientLease.client, {
+					threadId: binding.threadId,
+					timeoutMs: 5e3
+				})) {
+					await closeCodexStartupClientBestEffort(clientLease.client);
+					throw new CodexAppServerUnsafeSubscriptionError(`Codex retired session subscription could not be released: ${binding.threadId}`);
+				}
+			}
+		} finally {
+			clientLease.release();
+		}
+		return result;
+	});
+}
+//#endregion
+export { retireCodexAppServerSessionGeneration };

package/dist/{session-upstream-marker-B6U7tLw5.js → session-upstream-marker-D_2npHlA.js}

@@ -1,4 +1,4 @@
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-DzsdNCf5.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-BU0_LKAL.js";
 import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-history-import.ts
 /** Creates a session whose transcript is derived from one verified Codex thread snapshot. */

package/dist/{settled-turn-finalizer-CXY2Z9dT.js → settled-turn-finalizer-Dx1onIqg.js}

@@ -1,8 +1,9 @@
-import { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
-import { c as fingerprintCodexMirrorSourceMessage, d as attachCodexMirrorIdentity, f as readMirrorIdentity, l as readCodexMirrorSourceFingerprint, p as readUpstreamUserText, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-DzsdNCf5.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-D2ZAgZVz.js";
-import { n as createAssistantMessage } from "./event-projector-assistant-message-DTgnPPVF.js";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
+import { i as readUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
+import { c as readCodexMirrorSourceFingerprint, s as fingerprintCodexMirrorSourceMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BU0_LKAL.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-4BjrZEwW.js";
+import { n as createAssistantMessage } from "./event-projector-assistant-message-BwxV4d6N.js";
+import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { Buffer } from "node:buffer";
 import { isSilentReplyText } from "openclaw/plugin-sdk/reply-runtime";
 //#region extensions/codex/src/app-server/settled-turn-projection.ts
@@ -11,9 +12,6 @@ const MAX_PROJECTION_BYTES = 512 * 1024;
 const MAX_TEXT_BYTES = 64 * 1024;
 const TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/u;
 const TOOL_ERROR_STATUS_PREFIX = "[Tool result status: error]\n";
-function readNonEmptyString(value) {
-	return typeof value === "string" ? value.trim() || void 0 : void 0;
-}
 function readBoundedText(value, label, maxBytes = MAX_TEXT_BYTES) {
 	if (typeof value !== "string" || !value.trim()) return;
 	if (Buffer.byteLength(value, "utf8") > maxBytes) throw new Error(`Codex settled-turn projection found oversized ${label}`);
@@ -28,12 +26,12 @@ function responseItemBytes(item) {
 	return Buffer.byteLength(JSON.stringify(item), "utf8");
 }
 function requireCallId(value) {
-	const callId = readNonEmptyString(value);
+	const callId = normalizeOptionalString(value);
 	if (!callId || callId.length > 256) throw new Error("Codex settled-turn projection found an invalid tool call id");
 	return callId;
 }
 function requireToolName(value) {
-	const name = readNonEmptyString(value);
+	const name = normalizeOptionalString(value);
 	if (!name || !TOOL_NAME_PATTERN.test(name)) throw new Error("Codex settled-turn projection found an invalid tool name");
 	return name;
 }
@@ -58,27 +56,26 @@ function serializeToolArguments(value) {
 	return requireBoundedText(serialized, "tool arguments");
 }
 function projectUserMessage(message) {
-	const record = message;
 	const upstreamUserText = readUpstreamUserText(message);
-	if (upstreamUserText && typeof record.content === "string") return [{
+	if (upstreamUserText && typeof message.content === "string") return [{
 		type: "message",
 		role: "user",
 		content: [{
 			type: "input_text",
-			text: requireBoundedText(upstreamUserText, "upstream user text")
+			text: requireBoundedText(upstreamUserText, "upstream user text", MAX_PROJECTION_BYTES)
 		}]
 	}];
-	if (typeof record.content === "string") return [{
+	if (typeof message.content === "string") return [{
 		type: "message",
 		role: "user",
 		content: [{
 			type: "input_text",
-			text: requireBoundedText(record.content, "user message")
+			text: requireBoundedText(message.content, "user message")
 		}]
 	}];
-	if (!Array.isArray(record.content)) throw new Error("Codex settled-turn projection found unsupported user content");
+	if (!Array.isArray(message.content)) throw new Error("Codex settled-turn projection found unsupported user content");
 	const content = [];
-	for (const value of record.content) {
+	for (const value of message.content) {
 		if (!isRecord(value)) throw new Error("Codex settled-turn projection found malformed user content");
 		if (value.type === "text") {
 			const text = readBoundedText(value.text, "user text");
@@ -88,7 +85,7 @@ function projectUserMessage(message) {
 			});
 			continue;
 		}
-		throw new Error(`Codex settled-turn projection does not support user content ${String(value.type)}`);
+		throw new Error(`Codex settled-turn projection does not support user content ${value.type}`);
 	}
 	if (content.length === 0) throw new Error("Codex settled-turn projection found an empty user message");
 	return [{
@@ -146,13 +143,14 @@ function projectToolResult(message) {
 	const id = requireCallId(message.toolCallId);
 	const name = requireToolName(message.toolName);
 	if (!Array.isArray(message.content)) throw new Error("Codex settled-turn projection found unsupported tool result content");
-	if (message.isError !== void 0 && typeof message.isError !== "boolean") throw new Error("Codex settled-turn projection found invalid tool result status");
-	const isError = message.isError === true;
+	const isErrorValue = message.isError;
+	if (isErrorValue !== void 0 && typeof isErrorValue !== "boolean") throw new Error("Codex settled-turn projection found invalid tool result status");
+	const isError = isErrorValue === true;
 	const parts = [];
 	for (const value of message.content) {
 		if (!isRecord(value)) throw new Error("Codex settled-turn projection found malformed tool result content");
 		if (value.type === "image") {
-			const mimeType = readNonEmptyString(value.mimeType) ?? "unknown type";
+			const mimeType = normalizeOptionalString(value.mimeType) ?? "unknown type";
 			parts.push(`[Image tool result: ${mimeType}]`);
 			continue;
 		}
@@ -175,17 +173,16 @@ function projectToolResult(message) {
 	};
 }
 function projectMessage(message) {
-	const record = message;
 	let items;
 	let calls = [];
 	let results = [];
 	if (message.role === "user") items = projectUserMessage(message);
 	else if (message.role === "assistant") {
-		const projected = projectAssistantMessage(record);
+		const projected = projectAssistantMessage(message);
 		items = projected.items;
 		calls = projected.calls;
 	} else if (message.role === "toolResult") {
-		const projected = projectToolResult(record);
+		const projected = projectToolResult(message);
 		items = [projected.item];
 		results = [projected.result];
 	} else throw new Error(`Codex settled-turn projection does not support role ${message.role}`);
@@ -246,6 +243,7 @@ async function runCodexSettledTurnFinalization(operation, options) {
 			mode: "required",
 			id: attempt.modelId
 		},
+		modelProvider: "openai",
 		profile: attempt.authProfileId,
 		timeoutMs: attempt.runTimeoutOverrideMs ?? attempt.timeoutMs,
 		signal: attempt.abortSignal,
@@ -262,7 +260,8 @@ async function runCodexSettledTurnFinalization(operation, options) {
 		requiredModalities: ["text"],
 		isolation: "private-stdio",
 		historyItems,
-		requireNoExternalCapabilities: true
+		requireNoExternalCapabilities: true,
+		allowEmptyText: true
 	});
 	let promptEchoSeen = false;
 	let unexpectedItem;
@@ -281,7 +280,15 @@ async function runCodexSettledTurnFinalization(operation, options) {
 	}
 	if (unexpectedItem) throw new Error(`Codex settled-turn finalization returned unexpected native item: ${unexpectedItem.type}`);
 	const text = bounded.text.trim();
-	if (!text || isSilentReplyText(text)) throw new Error("Codex settled-turn finalization completed without a visible answer");
+	if (!text) return {
+		assistant: createAssistantMessage(attempt, "", {
+			tokenUsage: bounded.usage,
+			aborted: false,
+			promptError: null
+		}),
+		...bounded.usage ? { usage: bounded.usage } : {}
+	};
+	if (isSilentReplyText(text)) throw new Error("Codex settled-turn finalization completed without a visible answer");
 	const mirrorIdentity = `settled-finalizer:${attempt.runId}`;
 	const assistant = attachCodexMirrorIdentity(createAssistantMessage(attempt, text, {
 		tokenUsage: bounded.usage,
@@ -296,6 +303,11 @@ async function runCodexSettledTurnFinalization(operation, options) {
 		cwd: attempt.workspaceDir,
 		messages: [assistant],
 		idempotencyScope: `codex-settled-finalizer:${attempt.runId}`,
+		runId: attempt.runId,
+		terminalAssistantOwner: {
+			mirrorIdentity,
+			runId: attempt.runId
+		},
 		config: attempt.config,
 		skipBeforeMessageWriteHooks: true
 	});
@@ -303,8 +315,8 @@ async function runCodexSettledTurnFinalization(operation, options) {
 	const expectedFingerprint = fingerprintCodexMirrorSourceMessage(assistant);
 	if (!mirrorResult.assistantMirrorIdentitiesOwned.includes(mirrorIdentity) || !persistedMessage || persistedMessage.role !== "assistant" || readCodexMirrorSourceFingerprint(persistedMessage) !== expectedFingerprint) throw new Error("Codex settled-turn final answer transcript attestation mismatch");
 	const persistedAssistant = persistedMessage;
-	const persistedAssistantRecord = persistedAssistant;
-	const assistantTranscriptIdempotencyKey = typeof persistedAssistantRecord.idempotencyKey === "string" ? persistedAssistantRecord.idempotencyKey.trim() : "";
+	const persistedIdempotencyKey = "idempotencyKey" in persistedAssistant ? persistedAssistant.idempotencyKey : void 0;
+	const assistantTranscriptIdempotencyKey = typeof persistedIdempotencyKey === "string" ? persistedIdempotencyKey.trim() : "";
 	return {
 		assistant: persistedAssistant,
 		assistantTranscriptOwned: true,