@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/{session-cli-DMc4oS2w.js → session-cli-BjLhpmS1.js}

@@ -1,4 +1,4 @@
-import "./session-catalog-DaLKVtpH.js";
+import "./session-catalog-B47uwekb.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";

package/dist/session-history-DWmMqiqW.js

@@ -0,0 +1,93 @@
+import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-LHldwvyh.js";
+import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
+import { SessionManager } from "openclaw/plugin-sdk/agent-sessions";
+//#region extensions/codex/src/app-server/session-history.ts
+function resolveCodexHistoryTarget(target, admission) {
+	if (target.sessionTarget) {
+		const { agentId, sessionId, sessionKey, storePath } = target.sessionTarget;
+		if (!agentId || !sessionId || !sessionKey || !storePath || sessionId !== target.sessionId || target.agentId !== void 0 && agentId !== target.agentId || target.sessionKey !== void 0 && sessionKey !== target.sessionKey) return { kind: "empty" };
+		return {
+			kind: "sqlite",
+			target: {
+				agentId,
+				sessionId,
+				sessionKey,
+				storePath
+			}
+		};
+	}
+	const sqliteMarker = parseSqliteSessionFileMarker(target.sessionFile);
+	if (sqliteMarker) {
+		if (sqliteMarker.sessionId !== target.sessionId || target.agentId !== void 0 && sqliteMarker.agentId !== target.agentId) return { kind: "empty" };
+		const sessionKey = resolveSqliteMarkerSessionKey(target, sqliteMarker);
+		return sessionKey ? {
+			kind: "sqlite",
+			target: {
+				agentId: sqliteMarker.agentId,
+				sessionId: sqliteMarker.sessionId,
+				sessionKey,
+				storePath: sqliteMarker.storePath
+			}
+		} : { kind: "empty" };
+	}
+	if (admission) {
+		if (admission.sessionId !== target.sessionId || target.agentId !== void 0 && admission.agentId !== target.agentId || target.sessionKey !== void 0 && admission.sessionKey !== target.sessionKey) return { kind: "empty" };
+		return {
+			kind: "sqlite",
+			target: {
+				agentId: admission.agentId,
+				sessionId: admission.sessionId,
+				sessionKey: admission.sessionKey,
+				storePath: admission.storePath
+			}
+		};
+	}
+	return {
+		kind: "file",
+		sessionFile: target.sessionFile
+	};
+}
+/** Returns sanitized session-context messages for consumers that need an owned array. */
+async function readCodexMirroredSessionHistoryMessages(target, admission, view = "native-evidence", signal) {
+	signal?.throwIfAborted();
+	try {
+		let result;
+		if (view === "native-evidence") {
+			const { readCodexHistoryMessagesInWorker } = await import("./session-history-worker-runtime.js");
+			result = await readCodexHistoryMessagesInWorker(target, admission, signal);
+		} else {
+			const resolved = resolveCodexHistoryTarget(target, admission);
+			const read = (messages) => Array.from(messages);
+			if (resolved.kind === "sqlite") {
+				const loaded = await SessionManager.openModelContextAsync(resolved.target, {
+					admission,
+					signal
+				});
+				result = consumeCodexHistory(loaded.buildSessionContext().messages, loaded.getHeader(), target.sessionId, read, "codex mirrored model context");
+			} else result = await readCodexNativeHistory(resolved, target.sessionId, read, admission);
+		}
+		signal?.throwIfAborted();
+		return result;
+	} catch {
+		signal?.throwIfAborted();
+		return;
+	}
+}
+function resolveSqliteMarkerSessionKey(target, marker) {
+	const explicitSessionKey = target.sessionKey?.trim();
+	if (explicitSessionKey) {
+		const explicitEntry = getSessionEntry({
+			agentId: marker.agentId,
+			sessionKey: explicitSessionKey,
+			storePath: marker.storePath
+		});
+		if (explicitEntry) return explicitEntry.sessionId === marker.sessionId ? explicitSessionKey : void 0;
+	}
+	return resolveTranscriptSessionKeyBySessionId({
+		agentId: marker.agentId,
+		sessionId: marker.sessionId,
+		storePath: marker.storePath
+	});
+}
+//#endregion
+export { resolveCodexHistoryTarget as n, readCodexMirroredSessionHistoryMessages as t };

package/dist/session-history-read-LHldwvyh.js

@@ -0,0 +1,36 @@
+import { n as sanitizeCodexHistoryImagePayloads } from "./image-payload-sanitizer-tupAr-2o.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs/promises";
+import { readCodexSessionContext } from "openclaw/plugin-sdk/codex-session-transcript-runtime";
+//#region extensions/codex/src/app-server/session-history-read.ts
+function consumeCodexHistory(messages, header, sessionId, read, imageLabel = "codex mirrored history") {
+	if (!isRecord(header) || header.type !== "session") return read([]);
+	if (typeof header.id !== "string") return;
+	if (header.id !== sessionId) return read([]);
+	return read((function* () {
+		for (const message of messages) yield sanitizeCodexHistoryImagePayloads(message, imageLabel);
+	})());
+}
+/** Keeps native evidence and its synchronous consumer inside the same readonly snapshot. */
+async function readCodexNativeHistory(target, sessionId, read, admission, onSnapshot) {
+	const consume = (messages, header, version) => {
+		onSnapshot?.(version);
+		return consumeCodexHistory(messages, header, sessionId, read);
+	};
+	try {
+		if (target.kind === "empty") return read([]);
+		if (target.kind === "sqlite") return readCodexSessionContext(target.target, consume, admission);
+		const { buildSessionContext, migrateSessionEntries, parseSessionEntries } = await import("openclaw/plugin-sdk/agent-sessions");
+		const entries = parseSessionEntries(await fs.readFile(target.sessionFile, "utf-8"));
+		return consume((function* () {
+			migrateSessionEntries(entries);
+			const sessionEntries = entries.filter((entry) => isRecord(entry) && entry.type !== "session");
+			yield* buildSessionContext(sessionEntries).messages;
+		})(), entries[0]);
+	} catch (error) {
+		if (isRecord(error) && error.code === "ENOENT") return read([]);
+		return;
+	}
+}
+//#endregion
+export { readCodexNativeHistory as n, consumeCodexHistory as t };

package/dist/session-history-worker-runtime.js

@@ -0,0 +1,48 @@
+import { n as runCodexHistoryWorkerInput, t as codexHistoryWorkerUrl } from "./session-history.worker-zZVcx0ME.js";
+import { n as resolveCodexHistoryTarget } from "./session-history-DWmMqiqW.js";
+import { WorkerTaskPool } from "openclaw/plugin-sdk/process-runtime";
+import { captureCodexSessionTranscriptReadAdmission, validateCodexSessionTranscriptContextVersion, validateCodexSessionTranscriptReadAdmission } from "openclaw/plugin-sdk/codex-session-transcript-runtime";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
+//#region extensions/codex/session-history-worker-runtime.ts
+const historyReads = new WorkerTaskPool({
+	workerUrl: codexHistoryWorkerUrl,
+	maxWorkers: 1
+});
+async function readHistory(target, operation, admission, signal) {
+	signal?.throwIfAborted();
+	const resolved = resolveCodexHistoryTarget(target, admission);
+	const receipt = admission ?? (resolved.kind === "sqlite" ? captureCodexSessionTranscriptReadAdmission(resolved.target) : void 0);
+	const input = {
+		...operation,
+		target: resolved,
+		sessionId: target.sessionId,
+		...receipt ? { admission: { ...receipt } } : {}
+	};
+	const result = resolved.kind === "sqlite" && isIncognitoSessionKey(resolved.target.sessionKey) ? await runCodexHistoryWorkerInput(input) : await historyReads.run(input, {
+		timeoutMs: 6e4,
+		signal
+	});
+	signal?.throwIfAborted();
+	if (resolved.kind === "sqlite") {
+		if (input.admission) validateCodexSessionTranscriptReadAdmission(resolved.target, input.admission);
+		else validateCodexSessionTranscriptContextVersion(resolved.target, result.version);
+	}
+	return result;
+}
+async function readCodexHistoryMessagesInWorker(target, admission, signal) {
+	const result = await readHistory(target, { kind: "messages" }, admission, signal);
+	return result.kind === "messages" ? result.messages : void 0;
+}
+async function projectCodexSettledHistoryInWorker(target, signal) {
+	const result = await readHistory(target, {
+		kind: "settled",
+		evidence: {
+			mirroredMessages: target.mirroredMessages,
+			settledMessages: target.settledMessages,
+			turnId: target.turnId
+		}
+	}, void 0, signal);
+	return result.kind === "settled" ? result.data : void 0;
+}
+//#endregion
+export { projectCodexSettledHistoryInWorker, readCodexHistoryMessagesInWorker };

package/dist/session-history.worker-zZVcx0ME.js

@@ -0,0 +1,267 @@
+import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
+import { s as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-attestation-Byl34PC-.js";
+import { n as readCodexNativeHistory } from "./session-history-read-LHldwvyh.js";
+import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { serveWorkerTasks } from "openclaw/plugin-sdk/process-runtime";
+import { Buffer } from "node:buffer";
+//#region extensions/codex/src/app-server/settled-turn-projection.ts
+const MAX_RESPONSE_ITEMS = 200;
+const MAX_PROJECTION_BYTES = 524288;
+const MAX_TEXT_BYTES = 65536;
+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;
+	if (Buffer.byteLength(value, "utf8") > maxBytes) throw new Error(`Codex settled-turn projection found oversized ${label}`);
+	return value;
+}
+function requireBoundedText(value, label, maxBytes = MAX_TEXT_BYTES) {
+	const text = readBoundedText(value, label, maxBytes);
+	if (!text) throw new Error(`Codex settled-turn projection found empty ${label}`);
+	return text;
+}
+function responseItemBytes(item) {
+	return Buffer.byteLength(JSON.stringify(item), "utf8");
+}
+function requireCallId(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 = normalizeOptionalString(value);
+	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) {
+	if (typeof value === "string") {
+		let parsed;
+		try {
+			parsed = JSON.parse(value);
+		} catch {
+			throw new Error("Codex settled-turn projection found invalid JSON tool arguments");
+		}
+		if (!isRecord(parsed)) throw new Error("Codex settled-turn projection requires object tool arguments");
+		return requireBoundedText(value, "tool arguments");
+	}
+	if (!isRecord(value)) throw new Error("Codex settled-turn projection requires object tool arguments");
+	let serialized;
+	try {
+		serialized = JSON.stringify(value);
+	} catch {
+		throw new Error("Codex settled-turn projection found unserializable tool arguments");
+	}
+	return requireBoundedText(serialized, "tool arguments");
+}
+function projectUserMessage(message) {
+	const upstreamUserText = readUpstreamUserText(message);
+	if (typeof message.content === "string") return {
+		type: "message",
+		role: "user",
+		content: [{
+			type: "input_text",
+			text: upstreamUserText ? requireBoundedText(upstreamUserText, "upstream user text", MAX_PROJECTION_BYTES) : requireBoundedText(message.content, "user message")
+		}]
+	};
+	if (!Array.isArray(message.content)) throw new Error("Codex settled-turn projection found unsupported user content");
+	const content = [];
+	let bytes = responseItemBytes({
+		type: "message",
+		role: "user",
+		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") throw new Error(`Codex settled-turn projection does not support user content ${value.type}`);
+		const text = readBoundedText(value.text, "user text");
+		if (text) {
+			const part = {
+				type: "input_text",
+				text
+			};
+			bytes += responseItemBytes(part) + (content.length > 0 ? 1 : 0);
+			if (bytes > MAX_PROJECTION_BYTES) throw new Error("Codex settled-turn projection exceeds the byte limit");
+			content.push(part);
+		}
+	}
+	if (content.length === 0) throw new Error("Codex settled-turn projection found an empty user message");
+	return {
+		type: "message",
+		role: "user",
+		content
+	};
+}
+function* projectAssistantMessage(message) {
+	const values = typeof message.content === "string" ? [{
+		type: "text",
+		text: message.content
+	}] : message.content;
+	if (!Array.isArray(values)) throw new Error("Codex settled-turn projection found unsupported assistant content");
+	for (const value of values) {
+		if (!isRecord(value)) throw new Error("Codex settled-turn projection found malformed assistant content");
+		if (value.type === "text") {
+			const text = readBoundedText(value.text, "assistant text");
+			if (text) yield { item: {
+				type: "message",
+				role: "assistant",
+				content: [{
+					type: "output_text",
+					text
+				}]
+			} };
+			continue;
+		}
+		if (value.type === "toolCall") {
+			const id = requireCallId(value.id ?? value.toolCallId);
+			const name = requireToolName(value.name ?? value.toolName);
+			yield {
+				call: {
+					id,
+					name
+				},
+				item: {
+					type: "function_call",
+					call_id: id,
+					name,
+					arguments: serializeToolArguments(value.arguments ?? value.input)
+				}
+			};
+			continue;
+		}
+		if (value.type === "thinking" || value.type === "reasoning") continue;
+		throw new Error(`Codex settled-turn projection does not support assistant content ${String(value.type)}`);
+	}
+}
+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");
+	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 = [];
+	let bytes = 0;
+	const appendText = (text) => {
+		bytes += Buffer.byteLength(text, "utf8") + (parts.length > 0 ? 1 : 0);
+		if (bytes > MAX_TEXT_BYTES) throw new Error("Codex settled-turn projection found oversized tool result output");
+		parts.push(text);
+	};
+	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") {
+			appendText(`[Image tool result: ${normalizeOptionalString(value.mimeType) ?? "unknown type"}]`);
+			continue;
+		}
+		if (value.type !== "text" && value.type !== "toolResult") throw new Error("Codex settled-turn projection found malformed tool result content");
+		const text = value.type === "text" ? readBoundedText(value.text, "tool result text") : readBoundedText(value.content ?? value.text, "tool result text");
+		if (text) appendText(text);
+	}
+	const resultText = parts.join("\n") || (isError ? "Tool failed without textual output." : "Tool completed without textual output.");
+	const output = requireBoundedText(isError ? `${TOOL_ERROR_STATUS_PREFIX}${resultText}` : resultText, "tool result output", isError ? MAX_TEXT_BYTES + Buffer.byteLength(TOOL_ERROR_STATUS_PREFIX, "utf8") : MAX_TEXT_BYTES);
+	return {
+		result: {
+			id,
+			name
+		},
+		item: {
+			type: "function_call_output",
+			call_id: id,
+			output
+		}
+	};
+}
+function* projectMessage(message) {
+	if (message.role === "user") yield { item: projectUserMessage(message) };
+	else if (message.role === "assistant") yield* projectAssistantMessage(message);
+	else if (message.role === "toolResult") yield projectToolResult(message);
+	else throw new Error(`Codex settled-turn projection does not support role ${message.role}`);
+}
+/** Consumes complete evidence or rejects at the existing limits, never truncating its history. */
+function projectSettledCodexMessages(messages) {
+	const items = [];
+	const calls = /* @__PURE__ */ new Map();
+	const results = /* @__PURE__ */ new Set();
+	let bytes = 0;
+	for (const message of messages) for (const { item, call, result } of projectMessage(message)) {
+		if (call) {
+			if (calls.has(call.id)) throw new Error("Codex settled-turn projection found a duplicate tool call");
+			calls.set(call.id, call.name);
+		}
+		if (result) {
+			if (calls.get(result.id) !== result.name || results.has(result.id)) throw new Error("Codex settled-turn projection found an ambiguous tool transcript");
+			results.add(result.id);
+		}
+		if (items.length === MAX_RESPONSE_ITEMS) throw new Error("Codex settled-turn projection exceeds the item limit");
+		bytes += responseItemBytes(item);
+		if (bytes > MAX_PROJECTION_BYTES) throw new Error("Codex settled-turn projection exceeds the byte limit");
+		items.push(item);
+	}
+	if (calls.size !== results.size) throw new Error("Codex settled-turn projection found an incomplete tool transcript");
+	if (results.size === 0) throw new Error("Codex settled-turn projection found no completed tool result");
+	return items;
+}
+//#endregion
+//#region extensions/codex/src/app-server/settled-turn-evidence.ts
+function rejectEvidence() {
+	throw new Error("Codex settled-turn transcript does not match the settled turn");
+}
+/** The worker consumes this verifier lazily; rejection never acquires the remaining payloads. */
+function projectVerifiedSettledCodexMessages(history, params) {
+	return projectSettledCodexMessages(verifiedSettledMessages(history, params));
+}
+/** Yields only the settled prefix, but exhausts suffix identity checks before accepting it. */
+function* verifiedSettledMessages(history, params) {
+	const promptIdentity = `${params.turnId}:prompt`;
+	const boundaryIndex = params.settledMessages.findLastIndex((message) => message.role === "toolResult");
+	const boundary = params.settledMessages[boundaryIndex];
+	const boundaryIdentity = boundary && readMirrorIdentity(boundary);
+	const requiredIds = params.settledMessages.slice(0, boundaryIndex + 1).flatMap((message) => readMirrorIdentity(message) ?? []);
+	if (!boundaryIdentity?.startsWith(`${params.turnId}:tool:`) || requiredIds.length !== boundaryIndex + 1 || new Set(requiredIds).size !== requiredIds.length || !requiredIds.includes(promptIdentity)) rejectEvidence();
+	const mirrored = params.mirroredMessages;
+	const mirroredIds = mirrored.flatMap((message) => readMirrorIdentity(message) ?? []);
+	const mirroredBoundaryIndex = mirrored.findIndex((message) => readMirrorIdentity(message) === boundaryIdentity);
+	if (new Set(mirroredIds).size !== mirroredIds.length || mirroredBoundaryIndex + 1 !== requiredIds.length || requiredIds.some((id, index) => readMirrorIdentity(mirrored[index]) !== id)) rejectEvidence();
+	const required = new Map(requiredIds.map((id, index) => [id, mirrored[index]]));
+	const seen = /* @__PURE__ */ new Set();
+	let matched = 0;
+	let throughBoundary = false;
+	for (const message of history) {
+		const identity = readMirrorIdentity(message);
+		if (identity) {
+			if (seen.has(identity)) rejectEvidence();
+			seen.add(identity);
+			const expected = required.get(identity);
+			if (expected) {
+				if (identity !== requiredIds[matched] || serializeCodexMirrorSourceEvidence(message) !== serializeCodexMirrorSourceEvidence(expected)) rejectEvidence();
+				matched += 1;
+			}
+		}
+		if (!throughBoundary) yield message;
+		throughBoundary ||= identity === boundaryIdentity;
+	}
+	if (!throughBoundary || matched !== requiredIds.length) rejectEvidence();
+}
+//#endregion
+//#region extensions/codex/session-history.worker.ts
+const codexHistoryWorkerUrl = new URL(import.meta.url);
+async function runCodexHistoryWorkerInput(input) {
+	const request = input;
+	let version;
+	const onSnapshot = (value) => {
+		version = value;
+	};
+	if (request.kind === "messages") return {
+		kind: request.kind,
+		messages: await readCodexNativeHistory(request.target, request.sessionId, (messages) => Array.from(messages), request.admission, onSnapshot),
+		version
+	};
+	if (request.kind === "settled") return {
+		kind: request.kind,
+		data: await readCodexNativeHistory(request.target, request.sessionId, (messages) => projectVerifiedSettledCodexMessages(messages, request.evidence), request.admission, onSnapshot),
+		version
+	};
+	throw new Error("Invalid Codex history worker operation");
+}
+serveWorkerTasks(runCodexHistoryWorkerInput);
+//#endregion
+export { runCodexHistoryWorkerInput as n, codexHistoryWorkerUrl as t };

package/dist/session-history.worker.js

@@ -0,0 +1,2 @@
+import { n as runCodexHistoryWorkerInput, t as codexHistoryWorkerUrl } from "./session-history.worker-zZVcx0ME.js";
+export { codexHistoryWorkerUrl, runCodexHistoryWorkerInput };

package/dist/session-initialization-BCFVnLL4.js

@@ -0,0 +1,75 @@
+import { d as validateBindingForWrite } from "./session-binding-record-CyaXZvTe.js";
+import "./session-binding-4Ki04sW-.js";
+import { isDeepStrictEqual } from "node:util";
+import { deleteSessionUpstreamLink, upsertSessionUpstreamLink } from "openclaw/plugin-sdk/session-catalog";
+//#region extensions/codex/src/app-server/session-initialization.ts
+const initializations = /* @__PURE__ */ new WeakMap();
+/** Associate the host's exact handle before any potentially committing plugin write. */
+function prepareCodexSessionInitialization(params) {
+	const { initialization, bindingStore, identity } = params;
+	initialization.assertCurrent();
+	let link;
+	const ownership = {
+		store: bindingStore,
+		identity: structuredClone(identity),
+		assertCleanupAllowed: params.assertCleanupAllowed,
+		cleanup: async () => {
+			initialization.assertRollbackCurrent();
+			if (link && deleteSessionUpstreamLink(link.sessionKey, link.agentId, {
+				expected: link,
+				assertCommitAllowed: initialization.assertRollbackCurrent
+			}) === "changed") throw new Error("Codex initialization link changed before cleanup");
+			initialization.assertRollbackCurrent();
+			await cleanup?.(initialization.assertRollbackCurrent);
+			initialization.assertRollbackCurrent();
+		}
+	};
+	initializations.set(initialization, ownership);
+	const cleanup = params.prepareCleanup?.();
+	return {
+		assertCurrent: initialization.assertCurrent,
+		async bind(binding) {
+			initialization.assertCurrent();
+			ownership.binding = validateBindingForWrite(binding);
+			if (!await bindingStore.mutate(identity, {
+				kind: "set",
+				if: { kind: "absent" },
+				binding: ownership.binding
+			}, initialization.assertCurrent)) {
+				ownership.binding = void 0;
+				throw new Error("Codex session binding changed during initialization");
+			}
+			initialization.assertCurrent();
+		},
+		link(input) {
+			initialization.assertCurrent();
+			const now = Date.now();
+			link = structuredClone({
+				...input,
+				createdAt: now,
+				updatedAt: now
+			});
+			if (!upsertSessionUpstreamLink(input, {
+				now,
+				ifAbsent: true,
+				assertCommitAllowed: initialization.assertCurrent
+			})) {
+				link = void 0;
+				throw new Error("Codex initialization link could not be persisted");
+			}
+			initialization.assertCurrent();
+		}
+	};
+}
+function getCodexSessionInitializationRollback(store, params, identity, binding) {
+	const handle = params.initialization;
+	if (!handle) return;
+	handle.assertRollbackCurrent();
+	const ownership = initializations.get(handle);
+	if (!ownership && !binding) return;
+	if (!ownership || ownership.store !== store || !isDeepStrictEqual(ownership.identity, identity) || binding && !isDeepStrictEqual(ownership.binding, binding)) throw new Error("Codex initialization binding owner changed before rollback");
+	ownership.assertCleanupAllowed?.();
+	return ownership.cleanup;
+}
+//#endregion
+export { prepareCodexSessionInitialization as n, getCodexSessionInitializationRollback as t };

package/dist/{session-permission-policy-BrNH1bjy.js → session-permission-policy-BaueHmSj.js}

@@ -1,6 +1,6 @@
-import { A as selectUserApprovalsReviewer, E as parseAllowedSandboxModesFromCodexRequirements, M as selectGuardianSandbox, O as selectGuardianApprovalPolicy, T as parseAllowedApprovalsReviewersFromCodexRequirements, k as selectGuardianApprovalsReviewer, l as resolveCodexAppServerNetworkProxy, w as parseAllowedApprovalPoliciesFromCodexRequirements, x as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-giW8X0QA.js";
-import { hostname } from "node:os";
+import { S as selectUserApprovalsReviewer, _ as parseAllowedApprovalsReviewersFromCodexRequirements, b as selectGuardianApprovalPolicy, g as parseAllowedApprovalPoliciesFromCodexRequirements, j as selectGuardianSandbox, m as canUseCodexModelBackedApprovalsReviewerForModel, u as resolveCodexAppServerNetworkProxy, v as parseAllowedSandboxModesFromCodexRequirements, x as selectGuardianApprovalsReviewer } from "./config-CyapYSji.js";
 import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
+import { hostname } from "node:os";
 //#region extensions/codex/src/app-server/app-server-policy.ts
 function resolveCodexAppServerForModelProvider(params) {
 	const explicitProvider = normalizeModelBackedReviewerProvider(params.provider);

package/dist/session-retirement-DNdmYdFc.js

@@ -0,0 +1,97 @@
+import { Et as hasCodexAppServerLiveThread, Ot as isCodexAppServerLiveThreadClaimed, _ as retainSharedCodexAppServerClientByInstanceId, jt as releaseCodexAppServerLiveThread } from "./shared-client-CKhX2kFt.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-Bp1ZOnk2.js";
+import { l as isIncognitoSessionKey, o as withCodexAppServerThreadMutation, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-CbucAmmp.js";
+import { t as getCodexSessionInitializationRollback } from "./session-initialization-BCFVnLL4.js";
+import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-B3bvQGcg.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
+	};
+	const remove = () => bindingStore.withSessionDeletion(identity, assertCurrent, async (binding, mutation) => {
+		assertCurrent();
+		const rollbackInitialization = getCodexSessionInitializationRollback(bindingStore, params, identity, binding);
+		if (binding?.connectionScope === "supervision" && !rollbackInitialization) 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 && rollbackInitialization) {
+					assertCurrent();
+					await rollbackInitialization();
+				}
+				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();
+			}
+		}
+	});
+	return params.initialization ? await bindingStore.withThreadArchiveFence(remove) : await remove();
+}
+/** 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 = params.bindingStore.read(params.identity);
+	if (!expectedBinding) return await retireGeneration();
+	return await withCodexAppServerThreadMutation(expectedBinding.threadId, () => params.bindingStore.withLease(params.identity, async () => {
+		const binding = params.bindingStore.read(params.identity);
+		if (!binding || !isSameCodexAppServerThreadOwner(binding, expectedBinding)) 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 };