@openclaw/codex 2026.9.5 → 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 };