@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/session-history-Cz-tOOYj.js

@@ -0,0 +1,96 @@
+import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-cxPUxyVV.js";
+import { SessionManager } from "openclaw/plugin-sdk/agent-sessions";
+import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
+//#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 {
+				const history = await readCodexNativeHistory(resolved, target.sessionId, read, admission);
+				result = history.status === "ok" ? history.value : void 0;
+			}
+		}
+		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-upstream-marker-C351-5Qw.js → session-history-import-DFN7sWRU.js}

@@ -1,6 +1,7 @@
-import { d as sessionBindingIdentity } from "./session-binding-BHuTCRZQ.js";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-DTUxFWa_.js";
-import { n as prepareCodexSessionInitialization } from "./session-initialization-BeWzjGiR.js";
+import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
+import "./session-binding-CKSepwIC.js";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-t5TOccct.js";
+import { n as prepareCodexSessionInitialization } from "./session-initialization-Jo86C60I.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. */
@@ -49,49 +50,4 @@ async function createImportedCodexSession(params) {
 	}) : await params.runtime.agent.session.createSessionEntry(createParams);
 }
 //#endregion
-//#region extensions/codex/src/session-upstream-marker.ts
-function lastIdentifiableTurn(thread, normalizeTurnId) {
-	for (let index = (thread.turns?.length ?? 0) - 1; index >= 0; index -= 1) {
-		const turn = thread.turns?.[index];
-		const turnId = normalizeTurnId(turn?.id);
-		if (turn && turnId) return {
-			...turn,
-			id: turnId
-		};
-	}
-}
-function codexUpstreamBaseline(thread, normalizeTurnId) {
-	const turn = lastIdentifiableTurn(thread, normalizeTurnId);
-	return {
-		turnId: turn?.id ?? null,
-		userMessageCount: turn?.items.filter((item) => item.type === "userMessage").length ?? 0
-	};
-}
-function codexLastTerminalTurnId(thread, normalizeTurnId) {
-	for (let index = (thread.turns?.length ?? 0) - 1; index >= 0; index -= 1) {
-		const turn = thread.turns?.[index];
-		const turnId = normalizeTurnId(turn?.id);
-		if (!turn || !turnId) continue;
-		if (turn.status === "completed" || turn.status === "interrupted" || turn.status === "failed") return turnId;
-	}
-}
-/** Build the upstream link seed for a continued Codex session, if a baseline exists. */
-function codexUpstreamContinueResult(sessionKey, threadId, baseline) {
-	if (!baseline) return { sessionKey };
-	return {
-		sessionKey,
-		upstream: {
-			kind: "codex-app-server",
-			ref: {
-				connectionFingerprint: baseline.connectionFingerprint,
-				threadId
-			},
-			marker: {
-				turnId: baseline.turnId,
-				userMessageCount: baseline.userMessageCount
-			}
-		}
-	};
-}
-//#endregion
-export { createImportedCodexSession as i, codexUpstreamBaseline as n, codexUpstreamContinueResult as r, codexLastTerminalTurnId as t };
+export { createImportedCodexSession };

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

@@ -0,0 +1,50 @@
+import { n as codexHistoryRejectionReason, t as CodexHistoryRejection } from "./history-rejection-B4nOXNXF.js";
+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 { SessionTranscriptReadFenceError, 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") throw new CodexHistoryRejection("malformed_header");
+	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) => {
+		try {
+			onSnapshot?.(version);
+			return {
+				status: "ok",
+				value: consumeCodexHistory(messages, header, sessionId, read)
+			};
+		} catch (error) {
+			return {
+				status: "rejected",
+				reason: codexHistoryRejectionReason(error)
+			};
+		}
+	};
+	try {
+		if (target.kind === "empty") return consume([], void 0);
+		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 consume([], void 0);
+		return {
+			status: "rejected",
+			reason: error instanceof SessionTranscriptReadFenceError || isRecord(error) && (error.code === "EACCES" || error.code === "EPERM") ? "access_rejected" : codexHistoryRejectionReason(error)
+		};
+	}
+}
+//#endregion
+export { readCodexNativeHistory as n, consumeCodexHistory as t };

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

@@ -0,0 +1,60 @@
+import { n as codexHistoryRejectionReason } from "./history-rejection-B4nOXNXF.js";
+import { n as runCodexHistoryWorkerInput, t as codexHistoryWorkerUrl } from "./session-history.worker-CNEvGaU5.js";
+import { n as resolveCodexHistoryTarget } from "./session-history-Cz-tOOYj.js";
+import { WorkerTaskPool } from "openclaw/plugin-sdk/process-runtime";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
+import { SessionTranscriptReadFenceError, captureCodexSessionTranscriptReadAdmission, validateCodexSessionTranscriptContextVersion, validateCodexSessionTranscriptReadAdmission } from "openclaw/plugin-sdk/codex-session-transcript-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") try {
+		if (input.admission) validateCodexSessionTranscriptReadAdmission(resolved.target, input.admission);
+		else validateCodexSessionTranscriptContextVersion(resolved.target, result.version);
+	} catch (error) {
+		return {
+			...result,
+			result: {
+				status: "rejected",
+				reason: error instanceof SessionTranscriptReadFenceError ? "snapshot_invalidated" : codexHistoryRejectionReason(error)
+			}
+		};
+	}
+	return result;
+}
+async function readCodexHistoryMessagesInWorker(target, admission, signal) {
+	const result = await readHistory(target, { kind: "messages" }, admission, signal);
+	return result.kind === "messages" && result.result.status === "ok" ? result.result.value : 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.result : {
+		status: "rejected",
+		reason: "history_read_failed"
+	};
+}
+//#endregion
+export { projectCodexSettledHistoryInWorker, readCodexHistoryMessagesInWorker };

package/dist/{settled-turn-context-D3SNWtUn.js → session-history.worker-CNEvGaU5.js}

@@ -1,8 +1,9 @@
-import { d as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-DTUxFWa_.js";
 import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { t as readCodexMirroredSessionHistory } from "./session-history-C5J1AKzG.js";
+import { t as CodexHistoryRejection } from "./history-rejection-B4nOXNXF.js";
+import { n as readCodexNativeHistory } from "./session-history-read-cxPUxyVV.js";
+import { l as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-attestation-DibE0krH.js";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { embeddedAgentLog, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-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;
@@ -10,14 +11,14 @@ 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) {
+function readBoundedText(value, 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}`);
+	if (Buffer.byteLength(value, "utf8") > maxBytes) throw new CodexHistoryRejection("field_limit");
 	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}`);
+function requireBoundedText(value, maxBytes = MAX_TEXT_BYTES) {
+	const text = readBoundedText(value, maxBytes);
+	if (!text) throw new CodexHistoryRejection("invalid_content");
 	return text;
 }
 function responseItemBytes(item) {
@@ -25,12 +26,12 @@ function responseItemBytes(item) {
 }
 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");
+	if (!callId || callId.length > 256) throw new CodexHistoryRejection("invalid_content");
 	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)}` : ""}`);
+	if (!name || !TOOL_NAME_PATTERN.test(name)) throw new CodexHistoryRejection("invalid_content");
 	return name;
 }
 function serializeToolArguments(value) {
@@ -39,19 +40,19 @@ function serializeToolArguments(value) {
 		try {
 			parsed = JSON.parse(value);
 		} catch {
-			throw new Error("Codex settled-turn projection found invalid JSON tool arguments");
+			throw new CodexHistoryRejection("invalid_content");
 		}
-		if (!isRecord(parsed)) throw new Error("Codex settled-turn projection requires object tool arguments");
-		return requireBoundedText(value, "tool arguments");
+		if (!isRecord(parsed)) throw new CodexHistoryRejection("invalid_content");
+		return requireBoundedText(value);
 	}
-	if (!isRecord(value)) throw new Error("Codex settled-turn projection requires object tool arguments");
+	if (!isRecord(value)) throw new CodexHistoryRejection("invalid_content");
 	let serialized;
 	try {
 		serialized = JSON.stringify(value);
 	} catch {
-		throw new Error("Codex settled-turn projection found unserializable tool arguments");
+		throw new CodexHistoryRejection("invalid_content");
 	}
-	return requireBoundedText(serialized, "tool arguments");
+	return requireBoundedText(serialized);
 }
 function projectUserMessage(message) {
 	const upstreamUserText = readUpstreamUserText(message);
@@ -60,10 +61,10 @@ function projectUserMessage(message) {
 		role: "user",
 		content: [{
 			type: "input_text",
-			text: upstreamUserText ? requireBoundedText(upstreamUserText, "upstream user text", MAX_PROJECTION_BYTES) : requireBoundedText(message.content, "user message")
+			text: upstreamUserText ? requireBoundedText(upstreamUserText, MAX_PROJECTION_BYTES) : requireBoundedText(message.content)
 		}]
 	};
-	if (!Array.isArray(message.content)) throw new Error("Codex settled-turn projection found unsupported user content");
+	if (!Array.isArray(message.content)) throw new CodexHistoryRejection("unsupported_content");
 	const content = [];
 	let bytes = responseItemBytes({
 		type: "message",
@@ -71,20 +72,20 @@ function projectUserMessage(message) {
 		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 (!isRecord(value)) throw new CodexHistoryRejection("invalid_content");
+		if (value.type !== "text") throw new CodexHistoryRejection(value.type === "image" ? "unsupported_user_image" : "unsupported_content");
+		const text = readBoundedText(value.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");
+			if (bytes > MAX_PROJECTION_BYTES) throw new CodexHistoryRejection("byte_limit");
 			content.push(part);
 		}
 	}
-	if (content.length === 0) throw new Error("Codex settled-turn projection found an empty user message");
+	if (content.length === 0) throw new CodexHistoryRejection("invalid_content");
 	return {
 		type: "message",
 		role: "user",
@@ -96,11 +97,11 @@ function* projectAssistantMessage(message) {
 		type: "text",
 		text: message.content
 	}] : message.content;
-	if (!Array.isArray(values)) throw new Error("Codex settled-turn projection found unsupported assistant content");
+	if (!Array.isArray(values)) throw new CodexHistoryRejection("unsupported_content");
 	for (const value of values) {
-		if (!isRecord(value)) throw new Error("Codex settled-turn projection found malformed assistant content");
+		if (!isRecord(value)) throw new CodexHistoryRejection("invalid_content");
 		if (value.type === "text") {
-			const text = readBoundedText(value.text, "assistant text");
+			const text = readBoundedText(value.text);
 			if (text) yield { item: {
 				type: "message",
 				role: "assistant",
@@ -129,35 +130,35 @@ function* projectAssistantMessage(message) {
 			continue;
 		}
 		if (value.type === "thinking" || value.type === "reasoning") continue;
-		throw new Error(`Codex settled-turn projection does not support assistant content ${String(value.type)}`);
+		throw new CodexHistoryRejection("unsupported_content");
 	}
 }
 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 (!Array.isArray(message.content)) throw new CodexHistoryRejection("unsupported_content");
 	const isErrorValue = message.isError;
-	if (isErrorValue !== void 0 && typeof isErrorValue !== "boolean") throw new Error("Codex settled-turn projection found invalid tool result status");
+	if (isErrorValue !== void 0 && typeof isErrorValue !== "boolean") throw new CodexHistoryRejection("invalid_content");
 	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");
+		if (bytes > MAX_TEXT_BYTES) throw new CodexHistoryRejection("field_limit");
 		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 (!isRecord(value)) throw new CodexHistoryRejection("invalid_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 (value.type !== "text" && value.type !== "toolResult") throw new CodexHistoryRejection("invalid_content");
+		const text = value.type === "text" ? readBoundedText(value.text) : readBoundedText(value.content ?? value.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);
+	const output = requireBoundedText(isError ? `${TOOL_ERROR_STATUS_PREFIX}${resultText}` : resultText, isError ? MAX_TEXT_BYTES + Buffer.byteLength(TOOL_ERROR_STATUS_PREFIX, "utf8") : MAX_TEXT_BYTES);
 	return {
 		result: {
 			id,
@@ -174,7 +175,7 @@ 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}`);
+	else throw new CodexHistoryRejection("unsupported_content");
 }
 /** Consumes complete evidence or rejects at the existing limits, never truncating its history. */
 function projectSettledCodexMessages(messages) {
@@ -184,41 +185,30 @@ function projectSettledCodexMessages(messages) {
 	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");
+			if (calls.has(call.id)) throw new CodexHistoryRejection("invalid_pairing");
 			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");
+			if (calls.get(result.id) !== result.name || results.has(result.id)) throw new CodexHistoryRejection("invalid_pairing");
 			results.add(result.id);
 		}
-		if (items.length === MAX_RESPONSE_ITEMS) throw new Error("Codex settled-turn projection exceeds the item limit");
+		if (items.length === MAX_RESPONSE_ITEMS) throw new CodexHistoryRejection("item_limit");
 		bytes += responseItemBytes(item);
-		if (bytes > MAX_PROJECTION_BYTES) throw new Error("Codex settled-turn projection exceeds the byte limit");
+		if (bytes > MAX_PROJECTION_BYTES) throw new CodexHistoryRejection("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");
+	if (calls.size !== results.size) throw new CodexHistoryRejection("incomplete_pairing");
+	if (results.size === 0) throw new CodexHistoryRejection("incomplete_pairing");
 	return items;
 }
 //#endregion
-//#region extensions/codex/src/app-server/settled-turn-context.ts
-function freezeProjection(value) {
-	if (value !== null && typeof value === "object") {
-		for (const child of Object.values(value)) freezeProjection(child);
-		Object.freeze(value);
-	}
-}
-/** Only the Codex owner interprets this bounded, detached replay projection. */
-var CodexSettledTurnContext = class {
-	constructor(data) {
-		this.data = data;
-		this.source = "harness";
-		freezeProjection(data);
-		Object.freeze(this);
-	}
-};
+//#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");
+	throw new CodexHistoryRejection("provenance_rejected");
+}
+/** 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) {
@@ -252,17 +242,33 @@ function* verifiedSettledMessages(history, params) {
 	}
 	if (!throughBoundary || matched !== requiredIds.length) rejectEvidence();
 }
-/** Verifies and freezes a complete replay projection while reading the active branch. */
-async function captureCodexSettledTurnFinalizationContext(params) {
-	try {
-		return await readCodexMirroredSessionHistory(params, (messages) => new CodexSettledTurnContext(projectSettledCodexMessages(verifiedSettledMessages(messages, params))));
-	} catch (error) {
-		embeddedAgentLog.warn("codex settled-turn finalization context capture failed", {
-			error: formatErrorMessage(error),
-			turnId: params.turnId
-		});
-		return;
+//#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") {
+		const result = await readCodexNativeHistory(request.target, request.sessionId, (messages) => Array.from(messages), request.admission, onSnapshot);
+		return {
+			kind: request.kind,
+			result,
+			version
+		};
+	}
+	if (request.kind === "settled") {
+		const result = await readCodexNativeHistory(request.target, request.sessionId, (messages) => projectVerifiedSettledCodexMessages(messages, request.evidence), request.admission, onSnapshot);
+		return {
+			kind: request.kind,
+			result,
+			version
+		};
 	}
+	throw new Error("Invalid Codex history worker operation");
 }
+serveWorkerTasks(runCodexHistoryWorkerInput);
 //#endregion
-export { captureCodexSettledTurnFinalizationContext as n, CodexSettledTurnContext as t };
+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-CNEvGaU5.js";
+export { codexHistoryWorkerUrl, runCodexHistoryWorkerInput };

package/dist/{session-initialization-BeWzjGiR.js → session-initialization-Jo86C60I.js}

@@ -1,4 +1,5 @@
-import { p as validateBindingForWrite } from "./session-binding-BHuTCRZQ.js";
+import { d as validateBindingForWrite } from "./session-binding-record-CaZjYwNS.js";
+import "./session-binding-CKSepwIC.js";
 import { isDeepStrictEqual } from "node:util";
 import { deleteSessionUpstreamLink, upsertSessionUpstreamLink } from "openclaw/plugin-sdk/session-catalog";
 //#region extensions/codex/src/app-server/session-initialization.ts

package/dist/{session-permission-policy-DeWVTCMj.js → session-permission-policy-B22InTp_.js}

@@ -1,11 +1,11 @@
-import { S as selectUserApprovalsReviewer, _ as parseAllowedApprovalsReviewersFromCodexRequirements, b as selectGuardianApprovalPolicy, g as parseAllowedApprovalPoliciesFromCodexRequirements, k as selectGuardianSandbox, m as canUseCodexModelBackedApprovalsReviewerForModel, u as resolveCodexAppServerNetworkProxy, v as parseAllowedSandboxModesFromCodexRequirements, x as selectGuardianApprovalsReviewer } from "./config-BhmfC1s6.js";
-import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
+import { C as selectUserApprovalsReviewer, S as selectGuardianApprovalsReviewer, _ as parseAllowedApprovalPoliciesFromCodexRequirements, l as resolveCodexAppServerNetworkProxy, v as parseAllowedApprovalsReviewersFromCodexRequirements, w as selectGuardianSandbox, x as selectGuardianApprovalPolicy, y as parseAllowedSandboxModesFromCodexRequirements } from "./config-options-jnIFvwxD.js";
+import { t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-JDfTI4VI.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,
+		modelProvider: params.provider,
 		model: params.model,
 		config: params.config,
 		env: {
@@ -25,9 +25,6 @@ function resolveCodexAppServerForModelProvider(params) {
 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 = {

package/dist/{session-retirement-BujDjXVF.js → session-retirement-BSNG_mhf.js}

@@ -1,8 +1,9 @@
-import { Et as isCodexAppServerLiveThreadClaimed, _ as retainSharedCodexAppServerClientByInstanceId, kt as releaseCodexAppServerLiveThread, wt as hasCodexAppServerLiveThread } from "./shared-client-DxcfF9KX.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DYHcRQAa.js";
-import { l as isIncognitoSessionKey, o as withCodexAppServerThreadMutation, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-zGokd8i1.js";
-import { t as getCodexSessionInitializationRollback } from "./session-initialization-BeWzjGiR.js";
-import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-CnH147jH.js";
+import { n as withCodexAppServerThreadMutation, t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.js";
+import { L as hasCodexAppServerLiveThread, U as releaseCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, z as isCodexAppServerLiveThreadClaimed } from "./shared-client-CVhez2Uo.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-D6cR54TV.js";
+import { t as isSameCodexAppServerThreadOwner } from "./thread-ownership-D6oASVRu.js";
+import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-BbCUKRwC.js";
+import { t as getCodexSessionInitializationRollback } from "./session-initialization-Jo86C60I.js";
 //#region extensions/codex/src/app-server/session-retirement.ts
 async function releaseSessionSubscription(client, binding, sessionKey, assertCurrent) {
 	assertCurrent?.();
@@ -76,10 +77,10 @@ async function withCodexAppServerSessionDeletion(bindingStore, params, run) {
 /** 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);
+	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 = await params.bindingStore.read(params.identity);
+		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;