@openclaw/codex 2026.9.6 → 2026.9.7

package/dist/.setup/native-subagent-pending-assignments-DwkCzLvD.mjs

@@ -0,0 +1,203 @@
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { asOptionalRecord, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+//#region extensions/codex/src/app-server/native-subagent-history-owner.ts
+const nonBlankString = z.string().refine((value) => Boolean(value.trim()));
+const codexNativeSubagentHistoryOwnerSchema = z.object({
+	parentThreadId: nonBlankString,
+	sessionId: nonBlankString,
+	lifecycleRevision: nonBlankString.optional(),
+	connectionFingerprint: z.string().regex(/^[a-f0-9]{64}$/u)
+});
+/** Automatic recovery may follow native rotation only within the same host lifecycle and connection. */
+function matchesCodexNativeSubagentHistoryOwner(stored, current) {
+	return stored.connectionFingerprint === current.connectionFingerprint && stored.lifecycleRevision === current.lifecycleRevision && (stored.lifecycleRevision !== void 0 || stored.sessionId === current.sessionId);
+}
+function codexNativeSubagentHistoryConnectionFingerprint(binding) {
+	if (!binding.appServerRuntimeFingerprint) return;
+	return createHash("sha256").update(JSON.stringify([
+		binding.appServerRuntimeFingerprint,
+		binding.connectionScope ?? null,
+		binding.authProfileId ?? null
+	])).digest("hex");
+}
+function createCodexNativeSubagentHistoryOwner(params) {
+	const connectionFingerprint = codexNativeSubagentHistoryConnectionFingerprint(params.binding);
+	return connectionFingerprint ? {
+		parentThreadId: params.parentThreadId,
+		sessionId: params.sessionId,
+		...params.lifecycleRevision ? { lifecycleRevision: params.lifecycleRevision } : {},
+		connectionFingerprint
+	} : void 0;
+}
+function readCodexNativeSubagentHistoryOwner(detail) {
+	const value = asOptionalRecord(detail)?.nativeHistory;
+	if (value === void 0) return;
+	const owner = codexNativeSubagentHistoryOwnerSchema.safeParse(value);
+	if (!owner.success) throw new Error("Subagent history owner is invalid.");
+	const { lifecycleRevision, ...required } = owner.data;
+	return lifecycleRevision === void 0 ? required : {
+		...required,
+		lifecycleRevision
+	};
+}
+function assertHistoryOwnerMatchesRegistration(saved, current, parentThreadId, requireSaved = false) {
+	if (requireSaved && !saved) throw new Error("Subagent completion history owner is missing.");
+	if (saved && (!current || saved.parentThreadId !== parentThreadId || saved.connectionFingerprint !== current.connectionFingerprint || saved.sessionId !== current.sessionId || saved.lifecycleRevision !== current.lifecycleRevision)) throw new Error("Subagent completion history owner is contradictory.");
+}
+//#endregion
+//#region extensions/codex/src/app-server/native-subagent-assignment.ts
+/**
+* Shared identifiers for Codex native subagent execution and completion receipts.
+*/
+/** Run ID prefix for native child thread assignments. */
+const CODEX_NATIVE_SUBAGENT_RUN_ID_PREFIX = "codex-thread:";
+/** Initial assignments use the thread locator; follow-ups belong to a native turn. */
+function codexNativeSubagentRunId(threadId, turnId) {
+	return `${CODEX_NATIVE_SUBAGENT_RUN_ID_PREFIX}${threadId.trim()}${turnId ? `:turn:${turnId}` : ""}`;
+}
+function readCodexNativeSubagentRunId(runId) {
+	if (!runId?.startsWith(CODEX_NATIVE_SUBAGENT_RUN_ID_PREFIX)) return;
+	const [threadId, turnId] = runId.slice(13).split(":turn:");
+	return threadId?.trim() ? {
+		threadId,
+		...turnId ? { turnId } : {}
+	} : void 0;
+}
+function readNativeSubagentThreadIds(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => typeof entry === "string" && entry.trim() !== "");
+}
+function readThreadParentThreadId(thread) {
+	return readStringField(thread, "parentThreadId")?.trim() ?? readStringField(readThreadSpawnSource(thread), "parent_thread_id")?.trim();
+}
+function readThreadSpawnSource(thread) {
+	const source = isJsonObject(thread?.source) ? thread.source : void 0;
+	const subAgent = isJsonObject(source?.subAgent) ? source.subAgent : void 0;
+	return isJsonObject(subAgent?.thread_spawn) ? subAgent.thread_spawn : void 0;
+}
+function normalizeIdentifier(value) {
+	return value?.replace(/[^a-z0-9]/giu, "").toLowerCase();
+}
+//#endregion
+//#region extensions/codex/src/app-server/native-subagent-submission.ts
+const identifier$1 = z.string().refine((value) => Boolean(value.trim()));
+const submissionSchema = z.object({
+	parentTurnId: identifier$1,
+	callId: identifier$1,
+	childThreadId: identifier$1,
+	submissionId: identifier$1,
+	predecessorRunId: identifier$1,
+	predecessorNativeTurnId: identifier$1
+}).strict();
+const submissionsSchema = z.object({
+	version: z.literal(1),
+	owner: codexNativeSubagentHistoryOwnerSchema,
+	receipts: z.array(submissionSchema)
+}).strict().refine(({ receipts }) => new Set(receipts.map(({ parentTurnId, callId }) => JSON.stringify([parentTurnId, callId]))).size === receipts.length);
+function matchesCodexNativeSubagentSubmissionOwner(stored, current) {
+	return stored.parentThreadId === current.parentThreadId && matchesCodexNativeSubagentHistoryOwner(stored, current);
+}
+function readCodexNativeSubagentSubmissions(value) {
+	if (value === void 0) return;
+	const parsed = submissionsSchema.safeParse(value);
+	if (!parsed.success) throw new Error("Invalid Codex native subagent submission metadata.");
+	return parsed.data;
+}
+function mutateCodexNativeSubagentSubmissions(params) {
+	const current = readCodexNativeSubagentSubmissions(params.current);
+	const owner = codexNativeSubagentHistoryOwnerSchema.parse(params.owner);
+	const receipt = submissionSchema.parse(params.receipt);
+	if (current && !matchesCodexNativeSubagentSubmissionOwner(current.owner, owner)) return { applied: false };
+	const receipts = current?.receipts ?? [];
+	const existing = receipts.find((entry) => entry.parentTurnId === receipt.parentTurnId && entry.callId === receipt.callId);
+	if (existing && !isDeepStrictEqual(existing, receipt)) return { applied: false };
+	if (params.consume) {
+		if (!current) return { applied: false };
+		const remaining = receipts.filter((entry) => entry !== existing);
+		return {
+			applied: true,
+			...remaining.length ? { next: {
+				version: 1,
+				owner: current.owner,
+				receipts: remaining
+			} } : {}
+		};
+	}
+	return {
+		applied: true,
+		next: {
+			version: 1,
+			owner: current?.owner ?? owner,
+			receipts: existing ? receipts : [...receipts, receipt]
+		}
+	};
+}
+/** Physical adoption cannot establish continuity for an unstamped receipt. */
+function adoptCodexNativeSubagentSubmissions(value) {
+	if (value === void 0) return;
+	const parsed = submissionsSchema.safeParse(value);
+	return !parsed.success || parsed.data.owner.lifecycleRevision ? value : void 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/native-subagent-pending-assignments.ts
+const identifier = z.string().trim().min(1);
+const assignmentSchema = z.object({
+	runId: identifier,
+	childThreadId: identifier,
+	nativeTurnId: identifier.optional(),
+	nativeParentThreadId: identifier,
+	owner: codexNativeSubagentHistoryOwnerSchema,
+	submission: submissionSchema.optional(),
+	recordedCompletion: z.object({
+		childThreadId: identifier,
+		status: z.enum([
+			"succeeded",
+			"failed",
+			"cancelled"
+		]),
+		statusLabel: z.literal("recorded_task_result"),
+		result: z.string().min(1),
+		completedAt: z.number().finite().optional()
+	}).strict().optional()
+}).strict().refine((entry) => !entry.recordedCompletion || entry.recordedCompletion.childThreadId === entry.childThreadId).refine((entry) => !entry.submission || entry.submission.childThreadId === entry.childThreadId && entry.nativeTurnId === entry.submission.submissionId && entry.runId === codexNativeSubagentRunId(entry.childThreadId, entry.submission.submissionId)).refine((entry) => entry.runId === codexNativeSubagentRunId(entry.childThreadId) || entry.nativeTurnId !== void 0 && readCodexNativeSubagentRunId(entry.runId)?.threadId === entry.childThreadId);
+const inventorySchema = z.object({
+	version: z.literal(1),
+	assignments: z.array(assignmentSchema)
+}).strict().refine(({ assignments }) => new Set(assignments.map((entry) => entry.runId)).size === assignments.length);
+/** Native parent rotation is not physical requester or connection adoption. */
+function matchesNativeAssignmentLifecycle(saved, current) {
+	return saved.sessionId === current.sessionId && saved.lifecycleRevision === current.lifecycleRevision && saved.connectionFingerprint === current.connectionFingerprint;
+}
+function readNativePendingAssignments(value) {
+	if (value === void 0) return;
+	const parsed = inventorySchema.safeParse(value);
+	if (!parsed.success) throw new Error("Invalid Codex native pending assignment metadata.");
+	return parsed.data;
+}
+function mutateNativePendingAssignments(params) {
+	const current = readNativePendingAssignments(params.current);
+	const assignment = assignmentSchema.parse(params.assignment);
+	const owner = codexNativeSubagentHistoryOwnerSchema.parse(params.owner);
+	if (!matchesNativeAssignmentLifecycle(assignment.owner, owner)) return { applied: false };
+	const assignments = current?.assignments ?? [];
+	const existing = assignments.find((entry) => entry.runId === assignment.runId);
+	if (existing && (!isDeepStrictEqual(existing.owner, assignment.owner) || existing.nativeParentThreadId !== assignment.nativeParentThreadId || existing.childThreadId !== assignment.childThreadId)) return { applied: false };
+	if (params.consume && (!existing || existing.nativeTurnId !== assignment.nativeTurnId)) return { applied: false };
+	const remaining = assignments.filter((entry) => entry !== existing);
+	if (!params.consume) remaining.push(existing?.recordedCompletion && !assignment.recordedCompletion ? {
+		...assignment,
+		recordedCompletion: existing.recordedCompletion
+	} : assignment);
+	return {
+		applied: true,
+		next: remaining.length ? {
+			version: 1,
+			assignments: remaining
+		} : void 0
+	};
+}
+//#endregion
+export { readCodexNativeSubagentHistoryOwner as _, matchesCodexNativeSubagentSubmissionOwner as a, codexNativeSubagentRunId as c, readNativeSubagentThreadIds as d, readThreadParentThreadId as f, createCodexNativeSubagentHistoryOwner as g, codexNativeSubagentHistoryConnectionFingerprint as h, adoptCodexNativeSubagentSubmissions as i, normalizeIdentifier as l, assertHistoryOwnerMatchesRegistration as m, mutateNativePendingAssignments as n, mutateCodexNativeSubagentSubmissions as o, readThreadSpawnSource as p, readNativePendingAssignments as r, readCodexNativeSubagentSubmissions as s, matchesNativeAssignmentLifecycle as t, readCodexNativeSubagentRunId as u };

package/dist/.setup/native-task-assignments-DMQ0g3hu.mjs

@@ -0,0 +1,194 @@
+import { _ as readCodexNativeSubagentHistoryOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, u as readCodexNativeSubagentRunId } from "./native-subagent-pending-assignments-DwkCzLvD.mjs";
+import { _ as readStoredCodexAppServerBinding, r as bindingStoreKey } from "./session-binding-record-Oe9L-CNY.mjs";
+import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.mjs";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { extractErrorCode } from "openclaw/plugin-sdk/error-runtime";
+import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { executeSqliteQuerySync, getNodeSqliteKysely, openNodeSqliteDatabase, prepareSqliteReadOnlyLocation, tableExists } from "openclaw/plugin-sdk/sqlite-runtime";
+//#region extensions/codex/src/migration/native-task-assignments.ts
+const importSchema = z.object({
+	version: z.literal(1),
+	taskIds: z.array(z.string().min(1))
+}).strict();
+const detailSchema = z.object({ nativeTurnId: z.string().trim().min(1).optional() });
+function databasePath(params) {
+	return path.join(params.stateDir, "state", "openclaw.sqlite");
+}
+const missingOwnerMessage = "missing original requester session, lifecycle and connection facts (nativeHistory); inspect the original child in its native Codex account, or restore the pre-upgrade backup with its matching OpenClaw version to finish delivery";
+function taskIdentity(task) {
+	try {
+		const owner = readCodexNativeSubagentHistoryOwner(task.detail_json ? JSON.parse(task.detail_json) : {});
+		return task.agent_id && task.requester_session_key && owner ? {
+			kind: "session",
+			agentId: task.agent_id,
+			sessionKey: task.requester_session_key,
+			sessionId: owner.sessionId
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+async function inspect(params) {
+	const source = databasePath(params);
+	try {
+		await fs.access(source);
+	} catch (error) {
+		if (extractErrorCode(error) === "ENOENT") return [];
+		throw error;
+	}
+	const snapshot = await prepareSqliteReadOnlyLocation(source, { preserveSourceArtifacts: true });
+	try {
+		const db = openNodeSqliteDatabase(snapshot.location, { readOnly: true });
+		try {
+			if (!tableExists(db, "task_runs") || !tableExists(db, "plugin_state_entries")) return [];
+			const sql = getNodeSqliteKysely(db);
+			return executeSqliteQuerySync(db, sql.selectFrom("task_runs").select([
+				"task_id",
+				"runtime",
+				"task_kind",
+				"run_id",
+				"agent_id",
+				"requester_session_key",
+				"owner_key",
+				"scope_kind",
+				"status",
+				"delivery_status",
+				"ended_at",
+				"terminal_summary",
+				"detail_json"
+			]).select((eb) => eb.selectFrom("task_runs as all_runs").select((count) => count.fn.countAll().as("count")).whereRef("all_runs.run_id", "=", "task_runs.run_id").where("all_runs.runtime", "=", "subagent").where("all_runs.task_kind", "=", "codex-native").as("run_count")).where("runtime", "=", "subagent").where("task_kind", "=", "codex-native").where("delivery_status", "!=", "delivered").where((eb) => eb.or([
+				eb("status", "in", ["queued", "running"]),
+				eb("delivery_status", "=", "pending"),
+				eb.and([eb("delivery_status", "=", "not_applicable"), eb("ended_at", ">=", Date.now() - 6e4)])
+			]))).rows.filter((row) => {
+				const identity = taskIdentity(row);
+				if (!identity) return true;
+				const binding = executeSqliteQuerySync(db, sql.selectFrom("plugin_state_entries").select("value_json").where("plugin_id", "=", "codex").where("namespace", "=", CODEX_APP_SERVER_BINDING_NAMESPACE).where("entry_key", "=", bindingStoreKey(identity)).where((eb) => eb.or([eb("expires_at", "is", null), eb("expires_at", ">", Date.now())]))).rows[0];
+				try {
+					const stored = binding && readStoredCodexAppServerBinding(JSON.parse(binding.value_json));
+					const imported = importSchema.safeParse(stored?.nativeSubagentTaskImport);
+					return !imported.success || !imported.data.taskIds.includes(row.task_id);
+				} catch {
+					return true;
+				}
+			});
+		} finally {
+			db.close();
+		}
+	} finally {
+		await snapshot.cleanupAsync();
+	}
+}
+function prepareAssignment(task, stored, params) {
+	const identity = taskIdentity(task);
+	const native = readCodexNativeSubagentRunId(task.run_id ?? void 0);
+	const detail = task.detail_json ? JSON.parse(task.detail_json) : {};
+	const owner = readCodexNativeSubagentHistoryOwner(detail);
+	if (!owner) throw new Error(missingOwnerMessage);
+	if (!identity || !native || !task.run_id || stored.state !== "active" || stored.binding.pendingSupervisionBranch) throw new Error("current requester binding is unavailable; reconnect the original requester and run openclaw doctor --fix");
+	const session = getSessionEntry({
+		agentId: identity.agentId,
+		sessionKey: identity.sessionKey,
+		env: params.env,
+		storePath: resolveStorePath(params.config.session?.store, {
+			agentId: identity.agentId,
+			env: params.env
+		}),
+		readConsistency: "latest"
+	});
+	if (!session || session.sessionId !== owner.sessionId || stored.sessionId !== owner.sessionId || session.lifecycleRevision !== owner.lifecycleRevision || session.agentHarnessId !== void 0 && session.agentHarnessId !== "codex" || codexNativeSubagentHistoryConnectionFingerprint(stored.binding) !== owner.connectionFingerprint) throw new Error("requester session, lifecycle, or connection ownership no longer matches; inspect the original child in its native Codex account");
+	if (task.scope_kind !== "session" || task.owner_key !== identity.sessionKey) throw new Error("Task requester ownership does not match its session; inspect the original child in its native Codex account");
+	const nativeTurnId = detailSchema.parse(detail).nativeTurnId ?? native.turnId;
+	return {
+		runId: task.run_id,
+		childThreadId: native.threadId,
+		...nativeTurnId ? { nativeTurnId } : {},
+		nativeParentThreadId: owner.parentThreadId,
+		owner,
+		...(task.status === "succeeded" || task.status === "failed" || task.status === "cancelled") && task.terminal_summary ? { recordedCompletion: {
+			childThreadId: native.threadId,
+			status: task.status,
+			statusLabel: "recorded_task_result",
+			result: task.terminal_summary,
+			...task.ended_at !== null ? { completedAt: task.ended_at } : {}
+		} } : {}
+	};
+}
+const codexNativeTaskAssignmentMigration = {
+	id: "codex-native-task-assignments",
+	label: "Codex native pending assignments",
+	collectBackupResources: (params) => [{
+		path: databasePath(params),
+		kind: "sqlite"
+	}],
+	async detectLegacyState(params) {
+		return (await inspect(params)).length > 0 ? { preview: ["- Preserve native Codex child recovery before retiring Tasks"] } : null;
+	},
+	async migrateLegacyState(params) {
+		const rows = await inspect(params);
+		const warnings = [];
+		if (rows.length === 0) return {
+			changes: [],
+			warnings
+		};
+		let imported = 0;
+		const store = params.context.openPluginStateKeyedStore({
+			namespace: CODEX_APP_SERVER_BINDING_NAMESPACE,
+			maxEntries: CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
+			overflowPolicy: "reject-new",
+			env: params.env
+		});
+		for (const task of rows) try {
+			const identity = taskIdentity(task);
+			if (!identity) throw new Error(missingOwnerMessage);
+			if (!store.observe || !store.compareAndApply || !store.withCurrent) throw new Error("current requester identity or atomic binding storage is unavailable; run openclaw doctor --fix with the current version");
+			if (task.run_count !== 1) throw new Error("duplicate native assignment identity; inspect the retained Task records before repairing them");
+			const key = bindingStoreKey(identity);
+			const observed = await store.observe(key);
+			const stored = readStoredCodexAppServerBinding(observed.value);
+			if (!stored) throw new Error("original requester binding is unavailable; inspect the child in its native Codex account");
+			const marker = stored.nativeSubagentTaskImport === void 0 ? {
+				version: 1,
+				taskIds: []
+			} : importSchema.parse(stored.nativeSubagentTaskImport);
+			if (marker.taskIds.includes(task.task_id)) continue;
+			const assignment = prepareAssignment(task, stored, params);
+			if (stored.state !== "active" || observed.value?.state !== "active") continue;
+			const assignments = readNativePendingAssignments(stored.nativeSubagentAssignments)?.assignments ?? [];
+			const existing = assignments.find((value) => value.runId === assignment.runId);
+			if (existing && !isDeepStrictEqual(existing, assignment)) throw new Error("a newer binding assignment already owns this result; preserve both records for inspection");
+			const next = {
+				...stored,
+				...observed.value,
+				nativeSubagentAssignments: {
+					version: 1,
+					assignments: existing ? assignments : [...assignments, assignment]
+				},
+				nativeSubagentTaskImport: {
+					version: 1,
+					taskIds: [...marker.taskIds, task.task_id]
+				}
+			};
+			if ((await store.withCurrent({ assertCurrent: () => {
+				prepareAssignment(task, stored, params);
+			} }).compareAndApply(key, observed.comparison, {
+				operation: "update",
+				action: "set",
+				value: next
+			})).status === "conflict") throw new Error("binding changed during import; run openclaw doctor --fix again");
+			imported += 1;
+		} catch (error) {
+			warnings.push(`Native Codex task ${task.task_id} (${task.run_id ?? "unknown child"}) was preserved without migration: ${String(error)}`);
+		}
+		return {
+			changes: imported ? [`Preserved ${imported} native Codex assignment(s) in their existing parent bindings`] : [],
+			warnings,
+			...warnings.length ? { warningDisposition: "recoverable" } : {}
+		};
+	}
+};
+//#endregion
+export { codexNativeTaskAssignmentMigration };

package/dist/.setup/{node-cli-sessions-r3avj02l.mjs → node-cli-sessions-HC4W6FLI.mjs}

@@ -1,10 +1,10 @@
-import { p as resolveCodexAppServerUserHomeDir } from "./config-security-BEReZ6go.mjs";
-import { N as readBoundedOptionalString } from "./session-catalog-native-projection-DowriLid.mjs";
-import { s as codexCatalogHomeId } from "./session-catalog-events-Bj6j94E_.mjs";
-import { o as formatCodexDisplayText } from "./command-formatters-Bmqvr9tO.mjs";
+import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { r as resolveCodexAppServerUserHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-R3ckE3Co.mjs";
+import { t as codexCatalogHomeId } from "./session-catalog-home-id-vlih0B_g.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { runCommandBuffered, withCommandProcessScope } from "openclaw/plugin-sdk/process-runtime";
+import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import path from "node:path";
 import fs from "node:fs/promises";
@@ -187,7 +187,7 @@ async function resumeCodexCliSessionOnNode(params) {
 	let catalogAgentId;
 	let catalogHomeId;
 	if (params.sessionKey) {
-		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-ITddWx_X.mjs");
+		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-DgXvSGu0.mjs");
 		const entry = params.runtime.agent.session.getSessionEntry({
 			sessionKey: params.sessionKey,
 			readConsistency: "latest"
@@ -201,7 +201,7 @@ async function resumeCodexCliSessionOnNode(params) {
 			catalogHomeId = marker.sourceHomeId;
 		}
 	}
-	const payload = unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+	const raw = await params.runtime.nodes.invoke({
 		nodeId: params.nodeId,
 		command: CODEX_CLI_SESSION_RESUME_COMMAND,
 		params: {
@@ -214,7 +214,8 @@ async function resumeCodexCliSessionOnNode(params) {
 		},
 		timeoutMs: (params.timeoutMs ?? DEFAULT_RESUME_TIMEOUT_MS) + 5e3,
 		scopes: ["operator.write"]
-	}));
+	});
+	const payload = unwrapNodeInvokePayload(raw, "Codex CLI node command returned malformed payloadJSON.");
 	if (!isRecord(payload) || payload.ok !== true || typeof payload.text !== "string") throw new Error("Codex CLI resume returned an invalid payload.");
 	return {
 		ok: true,
@@ -230,7 +231,7 @@ function formatCodexCliSessions(params) {
 	})].join("\n");
 }
 async function listLocalCodexCliSessions(paramsJSON) {
-	const params = readRecordParam(paramsJSON);
+	const params = parseJsonRecord(paramsJSON);
 	const limit = normalizeLimit(params.limit);
 	const filter = typeof params.filter === "string" ? params.filter.trim().toLowerCase() : "";
 	const codexHome = resolveCodexAppServerUserHomeDir();
@@ -243,7 +244,7 @@ async function listLocalCodexCliSessions(paramsJSON) {
 			session.cwd,
 			session.lastMessage
 		].some((value) => value?.toLowerCase().includes(filter));
-	}).toSorted((a, b) => compareOptionalStringsDesc(a.updatedAt, b.updatedAt)).slice(0, limit);
+	}).toSorted((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "")).slice(0, limit);
 	return JSON.stringify({
 		sessions,
 		codexHome
@@ -251,7 +252,7 @@ async function listLocalCodexCliSessions(paramsJSON) {
 }
 async function resumeLocalCodexCliSession(paramsJSON, resolveCatalogSource, context) {
 	context?.signal?.throwIfAborted();
-	const params = readRecordParam(paramsJSON);
+	const params = parseJsonRecord(paramsJSON);
 	const sessionId = typeof params.sessionId === "string" ? params.sessionId.trim() : "";
 	const prompt = typeof params.prompt === "string" ? params.prompt.trim() : "";
 	const expectedHomeId = readBoundedOptionalString(params, "sourceHomeId", 256);
@@ -346,15 +347,8 @@ async function runCodexExecResume(params) {
 async function readHistorySessions(codexHome) {
 	const summaries = /* @__PURE__ */ new Map();
 	if (!(await visitJsonlLines(path.join(codexHome, "history.jsonl"), (line) => {
-		const trimmed = line.trim();
-		if (!trimmed) return;
-		let parsed;
-		try {
-			parsed = JSON.parse(trimmed);
-		} catch {
-			return;
-		}
-		if (!isRecord(parsed) || typeof parsed.session_id !== "string") return;
+		const parsed = parseJsonRecord(line.trim());
+		if (typeof parsed.session_id !== "string") return;
 		const sessionId = parsed.session_id.trim();
 		if (!sessionId) return;
 		const entry = summaries.get(sessionId) ?? {
@@ -392,15 +386,7 @@ async function readSessionFileSummary(file) {
 	let lastMessage;
 	let messageCount = 0;
 	const result = await visitJsonlLines(file, (line) => {
-		const trimmed = line.trim();
-		if (!trimmed) return;
-		let parsed;
-		try {
-			parsed = JSON.parse(trimmed);
-		} catch {
-			return;
-		}
-		if (!isRecord(parsed)) return;
+		const parsed = parseJsonRecord(line.trim());
 		if (typeof parsed.timestamp === "string" && parsed.timestamp.trim()) updatedAt = parsed.timestamp.trim();
 		if (parsed.type === "session_meta" && isRecord(parsed.payload)) {
 			if (typeof parsed.payload.id === "string" && parsed.payload.id.trim()) sessionId = parsed.payload.id.trim();
@@ -413,8 +399,7 @@ async function readSessionFileSummary(file) {
 			lastMessage = truncateText(messageText, 140);
 		}
 	});
-	if (!result.ok) return null;
-	if (result.lineCount === 0) return null;
+	if (!result.ok || result.lineCount === 0) return null;
 	if (!sessionId) sessionId = readSessionIdFromFilename(file) ?? "";
 	if (!sessionId) return null;
 	return {
@@ -443,9 +428,7 @@ async function findSessionFiles(dir, maxDepth) {
 	return files;
 }
 function readResponseItemMessageText(parsed) {
-	if (parsed.type !== "response_item" || !isRecord(parsed.payload)) return;
-	if (parsed.payload.type !== "message") return;
-	if ((typeof parsed.payload.role === "string" ? parsed.payload.role : "") !== "user") return;
+	if (parsed.type !== "response_item" || !isRecord(parsed.payload) || parsed.payload.type !== "message" || parsed.payload.role !== "user") return;
 	const parts = (Array.isArray(parsed.payload.content) ? parsed.payload.content : []).flatMap((entry) => {
 		if (!isRecord(entry)) return [];
 		const text = typeof entry.text === "string" ? entry.text : typeof entry.input_text === "string" ? entry.input_text : void 0;
@@ -474,7 +457,7 @@ async function resolveCodexCliNode(params) {
 	return expectDefined(usable[0], "single usable Codex CLI node");
 }
 function parseCodexCliSessionsListResult(raw) {
-	const payload = unwrapNodeInvokePayload(raw);
+	const payload = unwrapNodeInvokePayload(raw, "Codex CLI node command returned malformed payloadJSON.");
 	if (!isRecord(payload) || !Array.isArray(payload.sessions)) throw new Error("Codex CLI session list returned an invalid payload.");
 	return {
 		codexHome: typeof payload.codexHome === "string" ? payload.codexHome : "",
@@ -491,17 +474,7 @@ function parseCodexCliSessionsListResult(raw) {
 		})
 	};
 }
-function unwrapNodeInvokePayload(raw) {
-	const record = isRecord(raw) ? raw : {};
-	if (typeof record.payloadJSON === "string" && record.payloadJSON.trim()) try {
-		return JSON.parse(record.payloadJSON);
-	} catch (error) {
-		throw new Error("Codex CLI node command returned malformed payloadJSON.", { cause: error });
-	}
-	if ("payload" in record) return record.payload;
-	return raw;
-}
-function readRecordParam(paramsJSON) {
+function parseJsonRecord(paramsJSON) {
 	if (!paramsJSON?.trim()) return {};
 	try {
 		const parsed = JSON.parse(paramsJSON);
@@ -527,9 +500,6 @@ function truncateText(value, max) {
 	if (value.length <= max) return value;
 	return `${truncateUtf16Safe(value, Math.max(0, max - 3))}...`;
 }
-function compareOptionalStringsDesc(a, b) {
-	return (b ?? "").localeCompare(a ?? "");
-}
 function readNodeId(node) {
 	if (!node.nodeId) throw new Error("Codex CLI node did not include a node id.");
 	return node.nodeId;

package/dist/.setup/{node-exec-server.runtime-BDwWXVpK.mjs → node-exec-server.runtime-BgBfWQqo.mjs}

@@ -1,5 +1,5 @@
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-BnshlFag.mjs";
-import { a as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-h2VHOskC.mjs";
+import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-kiWRhNRE.mjs";
+import { a as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-Bdegpn2V.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { stripVTControlCharacters } from "node:util";
 import { killProcessTree } from "openclaw/plugin-sdk/process-runtime";
@@ -113,10 +113,7 @@ async function runCodexNodeExecServer(params) {
 		}
 	};
 	let close = releaseResources;
-	let rejectDisconnected;
-	const disconnected = new Promise((_resolve, reject) => {
-		rejectDisconnected = reject;
-	});
+	const { promise: disconnected, reject: rejectDisconnected } = createDeferred();
 	disconnected.catch(() => {});
 	const onAbort = () => {
 		const error = nodeExecServerAbortError(io.signal);