@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

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

@@ -0,0 +1,112 @@
+import { Ht as isJsonObject } from "./shared-client-kNkljY-R.js";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import fsSync from "node:fs";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
+import { createZstdDecompress } from "node:zlib";
+//#region extensions/codex/src/session-catalog-provenance.ts
+const MAX_SESSION_META_BYTES = 1024 * 1024;
+const SESSION_META_READ_CHUNK_BYTES = 64 * 1024;
+const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
+const provenanceByPath = /* @__PURE__ */ new Map();
+function cacheProvenance(key, value) {
+	provenanceByPath.delete(key);
+	provenanceByPath.set(key, value);
+	while (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) {
+		const oldest = provenanceByPath.keys().next().value;
+		if (oldest === void 0) break;
+		provenanceByPath.delete(oldest);
+	}
+}
+/** Undefined means the metadata line is not durable enough to cache yet. */
+async function readCodexSessionMeta(sessionsRoot, rolloutPath, threadId) {
+	let safeRoot;
+	try {
+		safeRoot = await root(sessionsRoot, {
+			hardlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER,
+			symlinks: "reject"
+		});
+	} catch {
+		return;
+	}
+	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
+	for (const candidate of candidates) {
+		let opened;
+		try {
+			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
+		} catch {
+			continue;
+		}
+		const input = opened.handle.createReadStream({
+			autoClose: false,
+			highWaterMark: SESSION_META_READ_CHUNK_BYTES
+		});
+		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
+		try {
+			const chunks = [];
+			let bytesReadTotal = 0;
+			let line;
+			for await (const value of reader) {
+				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
+				if (remaining <= 0) break;
+				const bounded = chunk.subarray(0, remaining);
+				bytesReadTotal += bounded.length;
+				const newline = bounded.indexOf(10);
+				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
+				if (newline >= 0) {
+					line = Buffer.concat(chunks).toString("utf8");
+					break;
+				}
+			}
+			if (!line) continue;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (!isJsonObject(parsed) || parsed.type !== "session_meta" || !isJsonObject(parsed.payload)) return null;
+			const payload = parsed.payload;
+			return payload.id === threadId ? payload : null;
+		} catch {
+			continue;
+		} finally {
+			reader.destroy();
+			input.destroy();
+			await opened.handle.close().catch(() => void 0);
+		}
+	}
+}
+/**
+* Codex 0.147 reports OpenClaw app-server rollouts as `vscode`, so the rollout's
+* immutable session metadata is the authoritative historical provenance.
+*/
+async function isOpenClawManagedCodexThread(thread, localSessionsRoot) {
+	const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+	if (!localSessionsRoot || !rolloutPath) return false;
+	const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
+	const cached = provenanceByPath.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const metadata = await readCodexSessionMeta(localSessionsRoot, rolloutPath, thread.id);
+	const managed = metadata === void 0 ? void 0 : metadata?.originator === "openclaw";
+	if (managed !== void 0) cacheProvenance(cacheKey, managed);
+	return managed ?? false;
+}
+//#endregion
+//#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 { readCodexSessionMeta as i, codexCatalogHomeId as n, isOpenClawManagedCodexThread as r, canonicalCodexCatalogHome as t };

package/dist/{session-cli-7hgXZDV7.js → session-cli-BuDjm5Ou.js}

@@ -1,10 +1,15 @@
-import { a as CODEX_LOCAL_SESSION_HOST_ID } from "./session-catalog-xwNi_SDM.js";
+import "./session-catalog-C2Tae4rI.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-permission-policy-gLm40Vtq.js

@@ -0,0 +1,160 @@
+import { O as selectGuardianSandbox, _ as parseAllowedSandboxModesFromCodexRequirements, b as selectGuardianApprovalsReviewer, g as parseAllowedApprovalsReviewersFromCodexRequirements, h as parseAllowedApprovalPoliciesFromCodexRequirements, l as resolveCodexAppServerNetworkProxy, p as canUseCodexModelBackedApprovalsReviewerForModel, x as selectUserApprovalsReviewer, y as selectGuardianApprovalPolicy } from "./config-Cxw3Cl3k.js";
+import { hostname } from "node:os";
+import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
+//#region extensions/codex/src/app-server/app-server-policy.ts
+function resolveCodexAppServerForModelProvider(params) {
+	const explicitProvider = normalizeModelBackedReviewerProvider(params.provider);
+	if (!isCodexModelBackedApprovalsReviewer(params.appServer.approvalsReviewer) || canUseCodexModelBackedApprovalsReviewerForModel({
+		modelProvider: explicitProvider,
+		model: params.model,
+		config: params.config,
+		env: {
+			...params.env ?? process.env,
+			...params.appServer.start.env
+		},
+		agentDir: params.agentDir,
+		codexConfigToml: params.codexConfigToml,
+		homeScope: params.appServer.start.homeScope,
+		codexArgs: params.appServer.start.args
+	})) return params.appServer;
+	return {
+		...params.appServer,
+		approvalsReviewer: "user"
+	};
+}
+function isCodexModelBackedApprovalsReviewer(value) {
+	return value === "auto_review" || value === "guardian_subagent";
+}
+function normalizeModelBackedReviewerProvider(provider) {
+	return provider?.trim().toLowerCase() || void 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/session-permission-policy.ts
+const CODEX_SESSION_PERMISSION_EXEC_MODES = {
+	"read-only": "deny",
+	guarded: "ask",
+	workspace: "auto",
+	full: "full"
+};
+function tupleForMode(mode, canUseAutoReview) {
+	switch (mode) {
+		case "read-only": return {
+			sandbox: "read-only",
+			approvalPolicy: "on-request",
+			approvalsReviewer: "user"
+		};
+		case "guarded": return {
+			sandbox: "workspace-write",
+			approvalPolicy: "on-request",
+			approvalsReviewer: "user"
+		};
+		case "workspace": return {
+			sandbox: "workspace-write",
+			approvalPolicy: "on-request",
+			approvalsReviewer: canUseAutoReview ? "auto_review" : "user"
+		};
+		case "full": return {
+			sandbox: "danger-full-access",
+			approvalPolicy: "never",
+			approvalsReviewer: "user"
+		};
+	}
+	return mode;
+}
+function requirementsAllowTuple(tuple, allowed) {
+	return (allowed.sandboxes === void 0 || allowed.sandboxes.has(tuple.sandbox)) && (allowed.approvalPolicies === void 0 || allowed.approvalPolicies.has(tuple.approvalPolicy)) && (allowed.reviewers === void 0 || allowed.reviewers.has(tuple.approvalsReviewer));
+}
+function tightenTupleForExecMode(tuple, execMode, requiresPerCommandApproval) {
+	switch (execMode) {
+		case "deny":
+		case "allowlist": return {
+			sandbox: "read-only",
+			approvalPolicy: "on-request",
+			approvalsReviewer: "user"
+		};
+		case "ask": return {
+			...tuple,
+			approvalPolicy: requiresPerCommandApproval ? "untrusted" : "on-request",
+			approvalsReviewer: "user"
+		};
+		case "auto":
+		case "full":
+		case void 0: return tuple;
+	}
+	return execMode;
+}
+function clampSessionPermissionTuple(params) {
+	if (!params.requirementsToml) return params.requested;
+	const allowed = {
+		sandboxes: parseAllowedSandboxModesFromCodexRequirements(params.requirementsToml, params.hostName ?? hostname()),
+		approvalPolicies: parseAllowedApprovalPoliciesFromCodexRequirements(params.requirementsToml),
+		reviewers: parseAllowedApprovalsReviewersFromCodexRequirements(params.requirementsToml)
+	};
+	if (requirementsAllowTuple(params.requested, allowed)) return params.requested;
+	if (params.requested.approvalPolicy === "untrusted" && allowed.approvalPolicies?.has("untrusted") === false) throw new Error("tools.exec.ask=always requires Codex app-server per-command approvals");
+	const userReviewRequired = params.mode === "read-only" || params.mode === "guarded" || params.mode === "workspace" && !params.canUseAutoReview;
+	const sandboxAuthority = {
+		"read-only": 0,
+		"workspace-write": 1,
+		"danger-full-access": 2
+	};
+	const allowedSandboxes = new Set([
+		"read-only",
+		"workspace-write",
+		"danger-full-access"
+	].filter((sandbox) => sandboxAuthority[sandbox] <= sandboxAuthority[params.requested.sandbox] && (allowed.sandboxes === void 0 || allowed.sandboxes.has(sandbox))));
+	if (allowedSandboxes.size === 0) throw new Error(`Codex session permission mode=${params.mode} cannot satisfy managed sandbox requirements without widening access`);
+	return {
+		sandbox: selectGuardianSandbox(allowedSandboxes),
+		approvalPolicy: params.requested.approvalPolicy === "untrusted" ? "untrusted" : selectGuardianApprovalPolicy(allowed.approvalPolicies, userReviewRequired ? "ask" : "auto"),
+		approvalsReviewer: userReviewRequired ? selectUserApprovalsReviewer(allowed.reviewers) : selectGuardianApprovalsReviewer(allowed.reviewers, "auto")
+	};
+}
+/** Applies one complete session-mode tuple without mixing requirements-clamped fields. */
+function applyCodexSessionPermissionPolicy(params) {
+	if (!params.permissionMode) return params.appServer;
+	const sessionRoot = params.sessionRoot?.trim() || params.defaultRoot;
+	if (params.policyLocked) return {
+		...params.appServer,
+		sessionRoot
+	};
+	const requested = tightenTupleForExecMode(tupleForMode(params.permissionMode, params.canUseAutoReview), params.execMode, params.appServer.approvalPolicy === "untrusted");
+	const tuple = params.appServer.start.transport === "stdio" ? clampSessionPermissionTuple({
+		mode: params.permissionMode,
+		requested,
+		requirementsToml: params.requirementsToml,
+		hostName: params.hostName,
+		canUseAutoReview: params.canUseAutoReview
+	}) : requested;
+	const networkProxy = params.appServer.networkProxy ? resolveCodexAppServerNetworkProxy(params.pluginConfig.appServer?.networkProxy, tuple.sandbox).networkProxy : void 0;
+	const resolved = {
+		...params.appServer,
+		...tuple,
+		sessionRoot
+	};
+	if (networkProxy) resolved.networkProxy = networkProxy;
+	else delete resolved.networkProxy;
+	return resolved;
+}
+function resolveCodexEffectiveSessionPermissionPolicy(params) {
+	if (!params.permissionMode) return;
+	const root = params.sessionRoot?.trim() || params.defaultRoot;
+	const { sandbox, approvalPolicy, approvalsReviewer } = params.appServer;
+	const fullAccess = params.permissionMode === "full" && sandbox === "danger-full-access" && approvalPolicy === "never";
+	const guardianReview = params.permissionMode !== "guarded" && sandbox === "workspace-write" && approvalPolicy === "on-request" && approvalsReviewer !== "user";
+	const mode = params.permissionMode === "read-only" || sandbox === "read-only" ? "read-only" : fullAccess ? "full" : guardianReview ? "workspace" : "guarded";
+	return {
+		mode,
+		root,
+		execMode: CODEX_SESSION_PERMISSION_EXEC_MODES[mode]
+	};
+}
+/** Keeps relative execution inside the prepared root without filesystem rediscovery. */
+function resolveCodexSessionPermissionCwd(params) {
+	if (!params.permissionMode) return params.requestedCwd ?? params.fallbackCwd;
+	const sessionRoot = params.sessionRoot?.trim() || params.defaultRoot;
+	const requestedCwd = params.requestedCwd?.trim();
+	return requestedCwd && isPathInside(sessionRoot, requestedCwd) ? requestedCwd : sessionRoot;
+}
+//#endregion
+export { resolveCodexAppServerForModelProvider as a, resolveCodexSessionPermissionCwd as i, applyCodexSessionPermissionPolicy as n, resolveCodexEffectiveSessionPermissionPolicy as r, CODEX_SESSION_PERMISSION_EXEC_MODES as t };

package/dist/session-retirement-CdkI0bvb.js

@@ -0,0 +1,90 @@
+import { St as releaseCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, bt as isCodexAppServerLiveThreadClaimed, vt as hasCodexAppServerLiveThread } from "./shared-client-kNkljY-R.js";
+import { a as closeCodexStartupClientBestEffort, f as unsubscribeCodexThreadBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CVPvp9dL.js";
+import { l as isIncognitoSessionKey, o as withCodexAppServerThreadMutation } from "./thread-ownership-CeYBqg_4.js";
+import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-CwFyoylz.js";
+//#region extensions/codex/src/app-server/session-retirement.ts
+async function releaseSessionSubscription(client, binding, sessionKey, assertCurrent) {
+	assertCurrent?.();
+	codexNativeSubagentMonitorRuntime.retireParent(client, binding.threadId);
+	const released = await releaseCodexAppServerLiveThread(client, binding.threadId, assertCurrent);
+	assertCurrent?.();
+	if (!released && isIncognitoSessionKey(sessionKey)) {
+		const unsubscribed = await unsubscribeCodexThreadBestEffort(client, {
+			threadId: binding.threadId,
+			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
+			assertCurrent
+		});
+		assertCurrent?.();
+		if (!unsubscribed) {
+			await closeCodexStartupClientBestEffort(client);
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex retired session subscription could not be released: ${binding.threadId}`);
+		}
+	}
+}
+/** Prepare exact binding deletion before the session owner commits either database. */
+async function withCodexAppServerSessionDeletion(bindingStore, params, run) {
+	const { assertCurrent } = params;
+	const identity = {
+		kind: "session",
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId
+	};
+	return await bindingStore.withSessionDeletion(identity, assertCurrent, async (binding, mutation) => {
+		assertCurrent();
+		if (binding?.connectionScope === "supervision") throw new Error("Cannot delete a session while its Codex binding is owned by supervision");
+		const clientLease = binding?.clientId ? retainSharedCodexAppServerClientByInstanceId(binding.clientId) : void 0;
+		const assertUnclaimed = () => {
+			assertCurrent();
+			if (clientLease && binding && isCodexAppServerLiveThreadClaimed(clientLease.client, binding.threadId)) throw new Error("Cannot delete a session while its Codex thread is claimed by active work");
+		};
+		let committed = false;
+		try {
+			assertUnclaimed();
+			return await run({
+				commit() {
+					assertUnclaimed();
+					mutation.commit();
+					committed = true;
+				},
+				rollback() {
+					mutation.rollback();
+					committed = false;
+				}
+			});
+		} finally {
+			try {
+				if (committed && binding && clientLease) await withCodexAppServerThreadMutation(binding.threadId, async () => {
+					assertCurrent();
+					if (!hasCodexAppServerLiveThread(clientLease.client, binding.threadId) && !isIncognitoSessionKey(params.sessionKey)) return;
+					if (await bindingStore.hasOtherThreadOwner(binding.threadId)) return;
+					await releaseSessionSubscription(clientLease.client, binding, params.sessionKey, assertUnclaimed);
+				});
+			} finally {
+				clientLease?.release();
+			}
+		}
+	});
+}
+/** 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 {
+			await releaseSessionSubscription(clientLease.client, binding, params.identity.sessionKey);
+		} finally {
+			clientLease.release();
+		}
+		return result;
+	});
+}
+//#endregion
+export { retireCodexAppServerSessionGeneration, withCodexAppServerSessionDeletion };

package/dist/{session-upstream-marker-CrIFX06J.js → session-upstream-marker-Bcy33kam.js}

@@ -1,15 +1,14 @@
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-B9gGgnJS.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-CkEQIna-.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. */
 async function createImportedCodexSession(params) {
-	const label = params.thread.name?.trim() || void 0;
 	const spawnedCwd = params.thread.cwd?.trim() || void 0;
 	const createParams = {
 		cfg: params.config,
 		key: params.key,
 		agentId: params.agentId,
-		...label ? { label } : {},
+		...params.displayName !== void 0 ? { displayName: params.displayName } : {},
 		...spawnedCwd ? { spawnedCwd } : {},
 		initialEntry: params.initialEntry,
 		afterCreate: async (entry) => {

package/dist/{settled-turn-finalizer-BRWBO4MO.js → settled-turn-finalizer-B8JJcxCi.js}

@@ -1,8 +1,8 @@
-import { ct as isJsonObject } from "./shared-client-kIBbGjk4.js";
-import { i as readUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-ClRBije0.js";
-import { c as readCodexMirrorSourceFingerprint, s as fingerprintCodexMirrorSourceMessage, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-B9gGgnJS.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-qgZmzy_4.js";
-import { n as createAssistantMessage } from "./event-projector-assistant-message-BwxV4d6N.js";
+import { Ht as isJsonObject } from "./shared-client-kNkljY-R.js";
+import { i as readUpstreamUserText, r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
+import { c as fingerprintCodexMirrorSourceMessage, l as readCodexMirrorSourceFingerprint, t as codexTranscriptMirrorRuntime } from "./transcript-mirror-CkEQIna-.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-rq5tiSXk.js";
+import { r as createAssistantMessage } from "./event-projector-assistant-message-C5-Ds8mA.js";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { Buffer } from "node:buffer";
 import { isSilentReplyText } from "openclaw/plugin-sdk/reply-runtime";
@@ -10,7 +10,7 @@ import { isSilentReplyText } from "openclaw/plugin-sdk/reply-runtime";
 const MAX_RESPONSE_ITEMS = 200;
 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_NAME_PATTERN = /^[a-zA-Z0-9._-]{1,128}$/u;
 const TOOL_ERROR_STATUS_PREFIX = "[Tool result status: error]\n";
 function readBoundedText(value, label, maxBytes = MAX_TEXT_BYTES) {
 	if (typeof value !== "string" || !value.trim()) return;
@@ -32,7 +32,7 @@ function requireCallId(value) {
 }
 function requireToolName(value) {
 	const name = normalizeOptionalString(value);
-	if (!name || !TOOL_NAME_PATTERN.test(name)) throw new Error("Codex settled-turn projection found an invalid tool name");
+	if (!name || !TOOL_NAME_PATTERN.test(name)) throw new Error(`Codex settled-turn projection found an invalid tool name${name ? `: ${name.slice(0, 64)}` : ""}`);
 	return name;
 }
 function serializeToolArguments(value) {
@@ -56,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");
@@ -86,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 [{
@@ -144,8 +143,9 @@ 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");
@@ -173,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}`);
@@ -304,6 +303,12 @@ async function runCodexSettledTurnFinalization(operation, options) {
 		cwd: attempt.workspaceDir,
 		messages: [assistant],
 		idempotencyScope: `codex-settled-finalizer:${attempt.runId}`,
+		runId: attempt.runId,
+		terminalAssistantOwner: {
+			mirrorIdentity,
+			runId: attempt.runId
+		},
+		prepareAssistantTranscriptMessage: attempt.prepareAssistantTranscriptMessage,
 		config: attempt.config,
 		skipBeforeMessageWriteHooks: true
 	});
@@ -311,8 +316,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,