@openclaw/codex 2026.9.5 → 2026.9.6

package/dist/.setup/{session-catalog-node-adoption-BVRsYOSh.mjs → session-catalog-node-adoption-ITddWx_X.mjs}

@@ -1,4 +1,4 @@
-import { g as CatalogParamsError } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+import { v as CatalogParamsError } from "./session-catalog-native-projection-DowriLid.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
@@ -21,17 +21,25 @@ function adoptionSessionKeyRest(sessionKey) {
 	const trimmed = sessionKey.trim();
 	return parseAgentSessionKey(trimmed)?.rest ?? trimmed;
 }
-function nodeAdoptionSessionKey(hostId, threadId) {
-	const source = JSON.stringify([hostId, threadId]);
+function nodeAdoptedSourceKey(hostId, threadId, sourceHomeId) {
+	return sessionCatalogAdoptedSourceKey(JSON.stringify([hostId, sourceHomeId]), threadId);
+}
+function nodeAdoptionSessionKey(hostId, threadId, sourceHomeId) {
+	const source = JSON.stringify([
+		hostId,
+		sourceHomeId,
+		threadId
+	]);
 	return sessionCatalogAdoptedSessionKey(CODEX_NODE_SESSION_KEY_PREFIX, source);
 }
 function readNodeSessionMarker(entry) {
 	const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : void 0;
 	const marker = codex && isRecord(codex.sessionCatalog) ? codex.sessionCatalog : void 0;
-	if (!marker || typeof marker.sourceHostId !== "string" || !marker.sourceHostId.startsWith("node:") || typeof marker.sourceThreadId !== "string" || !marker.sourceThreadId.trim() || typeof marker.nodeId !== "string" || !marker.nodeId.trim()) return;
+	if (!marker || typeof marker.sourceHostId !== "string" || !marker.sourceHostId.startsWith("node:") || typeof marker.sourceThreadId !== "string" || !marker.sourceThreadId.trim() || typeof marker.nodeId !== "string" || !marker.nodeId.trim() || marker.sourceHomeId !== void 0 && (typeof marker.sourceHomeId !== "string" || !marker.sourceHomeId.trim() || marker.sourceHomeId.length > 256)) return;
 	return {
 		sourceHostId: marker.sourceHostId,
 		sourceThreadId: marker.sourceThreadId,
+		...typeof marker.sourceHomeId === "string" ? { sourceHomeId: marker.sourceHomeId } : {},
 		nodeId: marker.nodeId,
 		...marker.initializing === true ? { initializing: true } : {}
 	};
@@ -46,8 +54,8 @@ function listNodeAdoptedSessionEntries(params) {
 	})) {
 		const marker = readNodeSessionMarker(entry);
 		const sessionId = entry.sessionId?.trim();
-		if (!marker || marker.initializing === true && params.includeInitializing !== true || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !sessionId || adoptionSessionKeyRest(sessionKey) !== nodeAdoptionSessionKey(marker.sourceHostId, marker.sourceThreadId) || marker.sourceHostId !== `node:${marker.nodeId}`) continue;
-		const sourceKey = sessionCatalogAdoptedSourceKey(marker.sourceHostId, marker.sourceThreadId);
+		if (!marker || !marker.sourceHomeId || marker.initializing === true && params.includeInitializing !== true || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !sessionId || adoptionSessionKeyRest(sessionKey) !== nodeAdoptionSessionKey(marker.sourceHostId, marker.sourceThreadId, marker.sourceHomeId) || marker.sourceHostId !== `node:${marker.nodeId}`) continue;
+		const sourceKey = nodeAdoptedSourceKey(marker.sourceHostId, marker.sourceThreadId, marker.sourceHomeId);
 		if (adopted.has(sourceKey)) throw new Error(`multiple OpenClaw sessions adopt Codex thread ${marker.sourceThreadId} on ${marker.sourceHostId}`);
 		adopted.set(sourceKey, {
 			key: sessionKey,
@@ -59,12 +67,13 @@ function listNodeAdoptedSessionEntries(params) {
 	return adopted;
 }
 function findNodeAdoptedSessionEntry(params) {
-	return listNodeAdoptedSessionEntries(params).get(sessionCatalogAdoptedSourceKey(params.hostId, params.threadId));
+	return listNodeAdoptedSessionEntries(params).get(nodeAdoptedSourceKey(params.hostId, params.threadId, params.sourceHomeId));
 }
 function nodeSessionMarker(params) {
 	return {
 		sourceHostId: params.hostId,
 		sourceThreadId: params.threadId,
+		sourceHomeId: params.sourceHomeId,
 		nodeId: params.nodeId,
 		...params.initializing === true ? { initializing: true } : {}
 	};
@@ -79,7 +88,7 @@ async function finalizeNodeAdoptedSession(params) {
 			preserveActivity: true,
 			update: (entry) => {
 				const current = readNodeSessionMarker(entry);
-				if (entry.sessionId?.trim() !== params.adopted.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !current || current.sourceHostId !== params.marker.sourceHostId || current.sourceThreadId !== params.marker.sourceThreadId || current.nodeId !== params.marker.nodeId) throw changedError();
+				if (entry.sessionId?.trim() !== params.adopted.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true || !current || current.sourceHostId !== params.marker.sourceHostId || current.sourceThreadId !== params.marker.sourceThreadId || current.sourceHomeId !== params.marker.sourceHomeId || current.nodeId !== params.marker.nodeId) throw changedError();
 				if (current.initializing !== true) return {
 					archivedAt: void 0,
 					archivedBy: void 0,
@@ -106,7 +115,7 @@ async function finalizeNodeAdoptedSession(params) {
 			readConsistency: "latest"
 		});
 		const current = currentEntry ? readNodeSessionMarker(currentEntry) : void 0;
-		if (currentEntry?.sessionId?.trim() === params.adopted.sessionId && current?.initializing !== true && current?.sourceHostId === params.marker.sourceHostId && current.sourceThreadId === params.marker.sourceThreadId && current.nodeId === params.marker.nodeId) return;
+		if (currentEntry?.sessionId?.trim() === params.adopted.sessionId && current?.initializing !== true && current?.sourceHostId === params.marker.sourceHostId && current.sourceThreadId === params.marker.sourceThreadId && current.sourceHomeId === params.marker.sourceHomeId && current.nodeId === params.marker.nodeId) return;
 		throw error;
 	}
 	if (!finalized) throw changedError();
@@ -118,6 +127,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 		runtime: params.api.runtime,
 		hostId: params.hostId,
 		threadId: params.record.threadId,
+		sourceHomeId: params.sourceHomeId,
 		includeInitializing: true
 	});
 	if (existing) return existing;
@@ -125,6 +135,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 		...nodeSessionMarker({
 			hostId: params.hostId,
 			threadId: params.record.threadId,
+			sourceHomeId: params.sourceHomeId,
 			nodeId: params.nodeId
 		}),
 		initializing: true
@@ -132,7 +143,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 	try {
 		const created = await params.api.runtime.agent.session.createSessionEntry({
 			cfg: params.config,
-			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId),
+			key: nodeAdoptionSessionKey(params.hostId, params.record.threadId, params.sourceHomeId),
 			agentId: params.agentId,
 			recoverMatchingInitialEntry: true,
 			displayName: params.record.name ?? void 0,
@@ -144,7 +155,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 			},
 			afterCreate: async (entry) => {
 				const storePath = resolveStorePath(params.config.session?.store, { agentId: entry.agentId });
-				const { importCodexThreadHistoryToTranscript } = await import("./transcript-mirror-D4qp_leP.mjs").then((n) => n.a);
+				const { importCodexThreadHistoryToTranscript } = await import("./transcript-mirror-BtHDBp1G.mjs").then((n) => n.a);
 				await importCodexThreadHistoryToTranscript({
 					thread: params.history.thread,
 					throughTurnId: params.history.throughTurnId,
@@ -172,6 +183,7 @@ async function createOrReuseNodeAdoptedSession(params) {
 			runtime: params.api.runtime,
 			hostId: params.hostId,
 			threadId: params.record.threadId,
+			sourceHomeId: params.sourceHomeId,
 			includeInitializing: true
 		});
 		if (raced) return raced;
@@ -179,4 +191,4 @@ async function createOrReuseNodeAdoptedSession(params) {
 	}
 }
 //#endregion
-export { adoptionSessionKeyRest, continueOperations, createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, listNodeAdoptedSessionEntries, nodeSessionMarker, runSessionActionExclusive };
+export { CODEX_NODE_SESSION_KEY_PREFIX, adoptionSessionKeyRest, continueOperations, createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, listNodeAdoptedSessionEntries, nodeAdoptedSourceKey, nodeSessionMarker, readNodeSessionMarker, runSessionActionExclusive };

package/dist/.setup/{session-catalog-node-continue-Dowv8osw.mjs → session-catalog-node-continue-6g6qi4A9.mjs}

@@ -1,10 +1,10 @@
-import { A as parseTranscriptPage, B as unwrapNodeInvokePayload, E as isInteractiveThreadSource, O as parseCatalogPage, S as catalogError, T as filterCatalogPageByTitle, b as NODE_INVOKE_TIMEOUT_MS, f as CODEX_APP_SERVER_THREADS_LIST_COMMAND, g as CatalogParamsError, p as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, x as boundedCatalogString } from "./session-catalog-native-projection-ChV3cCtm.mjs";
+import { A as parseCatalogPage, C as boundedCatalogString, D as filterCatalogPageByTitle, H as unwrapNodeInvokePayload, M as parseTranscriptPage, O as isInteractiveThreadSource, S as NODE_INVOKE_TIMEOUT_MS, h as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, m as CODEX_APP_SERVER_THREADS_LIST_COMMAND, v as CatalogParamsError, w as catalogError } from "./session-catalog-native-projection-DowriLid.mjs";
 import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-CrcyZk6O.mjs";
-import { n as withTimeout } from "./timeout-DZF05XrR.mjs";
-import { t as CODEX_CLI_SESSION_RESUME_COMMAND } from "./node-cli-sessions-Cl8b2ZF3.mjs";
-import { o as lookupNodeCodexCatalogRecord } from "./session-catalog-fUdWDx-U.mjs";
+import { i as withTimeout } from "./timeout-C910MdAB.mjs";
+import { r as CODEX_CLI_SESSION_SOURCE_UPGRADE_MESSAGE, t as CODEX_CLI_SESSION_RESUME_COMMAND } from "./node-cli-sessions-r3avj02l.mjs";
+import { o as lookupNodeCodexCatalogRecord } from "./session-catalog-Pno1xGcl.mjs";
 import { t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.mjs";
-import { createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, nodeSessionMarker, runSessionActionExclusive } from "./session-catalog-node-adoption-BVRsYOSh.mjs";
+import { createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, nodeAdoptedSourceKey, nodeSessionMarker, runSessionActionExclusive } from "./session-catalog-node-adoption-ITddWx_X.mjs";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { createSessionCatalogAdoptionCoordinator, publishSessionCatalogHost, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 //#region extensions/codex/src/session-catalog-node-continue.ts
@@ -26,7 +26,7 @@ function compareNodeLabels(left, right) {
 	return 0;
 }
 function canContinueCodexOnNode(node) {
-	return node.connected === true && CODEX_NODE_CONTINUE_COMMANDS.every((command) => node.commands?.includes(command) === true && node.invocableCommands?.includes(command) === true);
+	return node.connected === true && node.caps?.includes("codex-cli-session-source") === true && CODEX_NODE_CONTINUE_COMMANDS.every((command) => node.commands?.includes(command) === true && node.invocableCommands?.includes(command) === true);
 }
 async function listPairedNode(params) {
 	const hostId = `node:${params.node.nodeId}`;
@@ -79,10 +79,8 @@ async function listPairedNode(params) {
 			...common,
 			connected: true,
 			...page,
-			sessions: page.sessions.map((session) => {
-				const adopted = params.adoptedSessions.get(sessionCatalogAdoptedSourceKey(hostId, session.threadId));
-				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
-			})
+			canContinueCodex: common.canContinueCodex && page.canContinueCodex === true && Boolean(page.sourceHomeId),
+			sessions: page.sessions.map((session) => Object.assign({}, session, page.sourceHomeId ? { sourceHomeId: page.sourceHomeId } : {}))
 		};
 	}).catch((error) => ({
 		...common,
@@ -106,7 +104,10 @@ async function requireNodeForCodexContinue(params) {
 	const nodeId = params.hostId.slice(5).trim();
 	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
 	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId);
-	if (!node || !canContinueCodexOnNode(node)) throw new CatalogParamsError("paired node does not permit Codex session continuation");
+	if (!node || !canContinueCodexOnNode(node)) {
+		if (node?.connected && !node.caps?.includes("codex-cli-session-source")) throw new CatalogParamsError(CODEX_CLI_SESSION_SOURCE_UPGRADE_MESSAGE);
+		throw new CatalogParamsError("paired node does not permit Codex session continuation");
+	}
 	return {
 		node,
 		nodeId
@@ -125,6 +126,7 @@ async function readNodeCodexHistory(params) {
 		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
 		params: {
 			agentId: params.agentId,
+			sourceHomeId: params.sourceHomeId,
 			threadId: params.record.threadId,
 			limit: 50
 		},
@@ -153,9 +155,12 @@ async function continueNodeCodexSessionInner(params) {
 		agentId: params.agentId,
 		runtime: params.api.runtime,
 		nodeId,
-		threadId: params.threadId
+		threadId: params.threadId,
+		sourceHomeId: params.sourceHomeId
 	});
 	if (lookup.kind !== "found") throw new CatalogParamsError(lookup.kind === "cursor-cycle" ? "Codex session eligibility could not be verified" : "Codex session is unavailable on the paired node");
+	if (lookup.canContinueCodex !== true || !lookup.sourceHomeId) throw new CatalogParamsError("Codex session source does not support Chat continuation; use a local stdio source or update the node.");
+	const sourceHomeId = lookup.sourceHomeId;
 	const record = lookup.record;
 	requireContinuableNodeRecord(record);
 	const existing = findNodeAdoptedSessionEntry({
@@ -164,6 +169,7 @@ async function continueNodeCodexSessionInner(params) {
 		runtime: params.api.runtime,
 		hostId: params.hostId,
 		threadId: params.threadId,
+		sourceHomeId,
 		includeInitializing: true
 	});
 	let adopted;
@@ -176,6 +182,7 @@ async function continueNodeCodexSessionInner(params) {
 			agentId: params.agentId,
 			runtime: params.api.runtime,
 			nodeId,
+			sourceHomeId,
 			record
 		});
 		adopted = await createOrReuseNodeAdoptedSession({
@@ -184,6 +191,7 @@ async function continueNodeCodexSessionInner(params) {
 			config: params.config,
 			hostId: params.hostId,
 			nodeId,
+			sourceHomeId,
 			record,
 			history
 		});
@@ -192,6 +200,7 @@ async function continueNodeCodexSessionInner(params) {
 	const marker = nodeSessionMarker({
 		hostId: params.hostId,
 		threadId: params.threadId,
+		sourceHomeId,
 		nodeId
 	});
 	return {
@@ -223,7 +232,7 @@ async function continueNodeCodexSession(params) {
 		agentId: params.agentId
 	}).sessionAgentId;
 	const sourceKey = sessionCatalogAdoptedSourceKey(`node:${nodeId}`, params.threadId);
-	const operationKey = sessionCatalogAdoptedSourceKey(agentId, sourceKey);
+	const operationKey = sessionCatalogAdoptedSourceKey(agentId, params.sourceHomeId ? nodeAdoptedSourceKey(`node:${nodeId}`, params.threadId, params.sourceHomeId) : sourceKey);
 	return await continueNodeAdoption({
 		sourceKey: operationKey,
 		findExisting: () => void 0,

package/dist/.setup/{session-catalog-projection-C1Bj9Jl-.mjs → session-catalog-projection-zK_PUsiE.mjs}

@@ -1,12 +1,12 @@
-import { H as detachCodexCatalogString, L as selectCodexCatalogPreviewInput, M as readControlCursor, R as toCatalogSession, c as getCodexCatalogSource, r as projectCodexCatalogNativeThread, s as copyCodexCatalogSource, u as setCodexCatalogSource, x as boundedCatalogString, z as truncateCodexCatalogPreview } from "./session-catalog-native-projection-ChV3cCtm.mjs";
-import { n as codexCatalogRowRecency } from "./session-catalog-index-order-Cc5BzlQr.mjs";
-import { s as isOpenClawManagedCodexThread } from "./session-catalog-events-jMcYfQyd.mjs";
+import { B as toCatalogSession, C as boundedCatalogString, P as readControlCursor, V as truncateCodexCatalogPreview, W as detachCodexCatalogString, c as copyCodexCatalogSource, f as setCodexCatalogSource, l as getCodexCatalogSource, r as projectCodexCatalogNativeThread, z as selectCodexCatalogPreviewInput } from "./session-catalog-native-projection-DowriLid.mjs";
+import { a as isOpenClawManagedCodexThread } from "./session-catalog-events-Bj6j94E_.mjs";
+import { n as codexCatalogRowRecency } from "./session-catalog-index-order-hcdz07yN.mjs";
 import { asFiniteNumber, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import { extractErrorCode, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { constants, createZstdDecompress } from "node:zlib";
-import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 //#region extensions/codex/src/session-catalog-rollouts.ts
 const WINDOW_BYTES = 131072;
@@ -74,6 +74,14 @@ var NewestRolloutCandidates = class {
 function codexCatalogRolloutLogicalPath(rolloutPath) {
 	return rolloutPath.replace(/\.zst$/u, "");
 }
+function resolveCodexCatalogRolloutFingerprint(rolloutPath, previous, files) {
+	const logicalPath = rolloutPath && codexCatalogRolloutLogicalPath(rolloutPath);
+	if (!logicalPath) return;
+	return files?.get(logicalPath) ?? files?.get(`${logicalPath}.zst`) ?? (previous?.rolloutPath && codexCatalogRolloutLogicalPath(previous.rolloutPath) === logicalPath ? previous.fingerprint : void 0);
+}
+function indexCodexCatalogRowsByRollout(rows) {
+	return new Map([...rows].flatMap((row) => row.rolloutPath ? [[codexCatalogRolloutLogicalPath(row.rolloutPath), row]] : []));
+}
 /** Absence is meaningful only inside the layout visited by the currency scan. */
 function isCodexCatalogRolloutPathCovered(sessionsRoot, rolloutPath) {
 	const directories = path.relative(sessionsRoot, rolloutPath).split(path.sep);
@@ -411,4 +419,4 @@ function mergeCodexCatalogRolloutRow(row, existing, fingerprint) {
 	return merged;
 }
 //#endregion
-export { CodexCatalogProjectionCapacityError, CodexCatalogProjections, canReuseCodexCatalogPreview, scanCodexCatalogRollouts as i, mergeCodexCatalogRolloutRow, isCodexCatalogRolloutPathCovered as n, projectCodexCatalogDeltaPage, projectCodexCatalogPage, projectCodexCatalogThread, readCodexCatalogRollout as r, codexCatalogRolloutLogicalPath as t };
+export { CodexCatalogProjectionCapacityError, CodexCatalogProjections, resolveCodexCatalogRolloutFingerprint as a, canReuseCodexCatalogPreview, readCodexCatalogRollout as i, mergeCodexCatalogRolloutRow, indexCodexCatalogRowsByRollout as n, scanCodexCatalogRollouts as o, projectCodexCatalogDeltaPage, projectCodexCatalogPage, projectCodexCatalogThread, isCodexCatalogRolloutPathCovered as r, codexCatalogRolloutLogicalPath as t };

package/dist/.setup/{session-cli-DIj-IE-E.mjs → session-cli-irrD-uo7.mjs}

@@ -1,10 +1,10 @@
-import "./session-catalog-native-projection-ChV3cCtm.mjs";
-import "./session-catalog-fUdWDx-U.mjs";
+import "./session-catalog-native-projection-DowriLid.mjs";
+import "./session-catalog-Pno1xGcl.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { addGatewayClientOptions, callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
-import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
+import { addGatewayClientOptions, callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
 //#region extensions/codex/src/session-cli.ts
 const CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS = 75e3;
 function requestedAgentId(options) {

package/dist/.setup/{session-history-C--SrLI8.mjs → session-history-BrqhSCf9.mjs}

@@ -48,37 +48,32 @@ function resolveCodexHistoryTarget(target, admission) {
 	};
 }
 /** Returns sanitized session-context messages for consumers that need an owned array. */
-async function readCodexMirroredSessionHistoryMessages(target, admission, view = "native-evidence", signal, contextTokenBudget) {
+async function readCodexMirroredSessionHistoryMessages(target, admission, signal, contextTokenBudget) {
 	signal?.throwIfAborted();
 	try {
 		let result;
-		if (view === "native-evidence") {
-			const { readCodexHistoryMessagesInWorker } = await import("../session-history-worker-runtime.js");
-			result = await readCodexHistoryMessagesInWorker(target, admission, signal);
+		const resolved = resolveCodexHistoryTarget(target, admission);
+		const read = (messages) => Array.from(messages);
+		if (resolved.kind === "sqlite") {
+			const loaded = await SessionManager.openModelContextAsync(resolved.target, {
+				admission,
+				signal,
+				limits: {
+					maxBytes: Math.min(67108864, Math.max(1024, Math.floor((contextTokenBudget ?? 128e3) * 8))),
+					maxEvents: 1e4,
+					toolResultOverflow: "omit"
+				}
+			});
+			result = consumeCodexHistory(loaded.buildSessionContext().messages, loaded.getHeader(), target.sessionId, read, "codex mirrored model context");
 		} 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,
-					limits: {
-						maxBytes: Math.min(67108864, Math.max(1024, Math.floor((contextTokenBudget ?? 128e3) * 8))),
-						maxEvents: 1e4
-					}
-				});
-				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;
-			}
+			const history = await readCodexNativeHistory(resolved, target.sessionId, read, admission);
+			result = history.status === "ok" ? history.value : void 0;
 		}
 		signal?.throwIfAborted();
 		return result;
 	} catch (error) {
 		signal?.throwIfAborted();
-		if (view === "model-context") throw error;
-		return;
+		throw error;
 	}
 }
 function resolveSqliteMarkerSessionKey(target, marker) {

package/dist/.setup/{session-history-import-JHXT5Xfi.mjs → session-history-import-D-3wAgOP.mjs}

@@ -1,7 +1,7 @@
-import { p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
-import "./session-binding-_0W_fHRr.mjs";
-import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-D4qp_leP.mjs";
-import { n as prepareCodexSessionInitialization } from "./session-initialization-DH1z6fXn.mjs";
+import { m as sessionBindingIdentity } from "./session-binding-record-BGoz8wOK.mjs";
+import "./session-binding-Cm0apEbd.mjs";
+import { r as importCodexThreadHistoryToTranscript } from "./transcript-mirror-BtHDBp1G.mjs";
+import { n as prepareCodexSessionInitialization } from "./session-initialization-rcgbZiid.mjs";
 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. */

package/dist/.setup/{session-history.worker-CpNj7H_P.mjs → session-history.worker-CaCh0xF_.mjs}

@@ -3,8 +3,8 @@ import { t as CodexHistoryRejection } from "./history-rejection-B4nOXNXF.mjs";
 import { n as readCodexNativeHistory } from "./session-history-read-B3ZfSUbF.mjs";
 import { l as serializeCodexMirrorSourceEvidence } from "./transcript-mirror-attestation-CzM-94NC.mjs";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { serveWorkerTasks } from "openclaw/plugin-sdk/process-runtime";
 import { Buffer } from "node:buffer";
+import { serveWorkerTasks } from "openclaw/plugin-sdk/worker-task-server";
 //#region extensions/codex/src/app-server/settled-turn-projection.ts
 const MAX_RESPONSE_ITEMS = 200;
 const MAX_PROJECTION_BYTES = 524288;
@@ -354,23 +354,10 @@ async function runCodexHistoryWorkerInput(input) {
 	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");
+	return {
+		result: await readCodexNativeHistory(request.target, request.sessionId, (messages) => projectVerifiedSettledCodexMessages(messages, request.evidence), request.admission, onSnapshot),
+		version
+	};
 }
 serveWorkerTasks(runCodexHistoryWorkerInput);
 //#endregion

package/dist/.setup/{session-initialization-DH1z6fXn.mjs → session-initialization-rcgbZiid.mjs}

@@ -1,5 +1,5 @@
-import { h as validateBindingForWrite } from "./session-binding-record-TH3xA0zj.mjs";
-import "./session-binding-_0W_fHRr.mjs";
+import { g as validateBindingForWrite } from "./session-binding-record-BGoz8wOK.mjs";
+import "./session-binding-Cm0apEbd.mjs";
 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/.setup/{session-permission-policy-DhurXY0l.mjs → session-permission-policy-BI1QK_98.mjs}

@@ -1,5 +1,5 @@
-import { D as selectGuardianApprovalPolicy, O as selectGuardianApprovalsReviewer, S as parseAllowedSandboxModesFromCodexRequirements, a as resolveCodexAppServerNetworkProxy, b as parseAllowedApprovalPoliciesFromCodexRequirements, k as selectUserApprovalsReviewer, x as parseAllowedApprovalsReviewersFromCodexRequirements, z as selectGuardianSandbox } from "./config-security-BRQ2mgW9.mjs";
-import { t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-CedDWjM-.mjs";
+import { S as selectUserApprovalsReviewer, _ as parseAllowedApprovalsReviewersFromCodexRequirements, a as resolveCodexAppServerNetworkProxy, b as selectGuardianApprovalPolicy, g as parseAllowedApprovalPoliciesFromCodexRequirements, j as selectGuardianSandbox, v as parseAllowedSandboxModesFromCodexRequirements, x as selectGuardianApprovalsReviewer } from "./config-security-BEReZ6go.mjs";
+import { t as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-BoTP_mrL.mjs";
 import { hostname } from "node:os";
 import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 //#region extensions/codex/src/app-server/app-server-policy.ts

package/dist/.setup/{session-retirement-CU87AOg9.mjs → session-retirement-BH-S6qkJ.mjs}

@@ -1,9 +1,9 @@
 import { n as withCodexAppServerThreadMutation, t as isIncognitoSessionKey } from "./incognito-session-uhrBF6wJ.mjs";
-import { I as hasCodexAppServerLiveThread, U as releaseCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, z as isCodexAppServerLiveThreadClaimed } from "./shared-client-BpTtuLQ5.mjs";
-import { a as closeCodexStartupClientBestEffort, f as unsubscribeCodexThreadBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-BpYKdTA0.mjs";
-import { t as isSameCodexAppServerThreadOwner } from "./thread-ownership-skomxnIt.mjs";
-import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-B1hxzIOy.mjs";
-import { t as getCodexSessionInitializationRollback } from "./session-initialization-DH1z6fXn.mjs";
+import { I as hasCodexAppServerLiveThread, U as releaseCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, z as isCodexAppServerLiveThreadClaimed } from "./shared-client-DA4VR4Eb.mjs";
+import { n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CEv1cKwF.mjs";
+import { t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DcTtAcXj.mjs";
+import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-D3filLY2.mjs";
+import { t as getCodexSessionInitializationRollback } from "./session-initialization-rcgbZiid.mjs";
 //#region extensions/codex/src/app-server/session-retirement.ts
 async function releaseSessionSubscription(client, binding, sessionKey, assertCurrent) {
 	assertCurrent?.();
@@ -25,6 +25,25 @@ async function releaseSessionSubscription(client, binding, sessionKey, assertCur
 }
 /** Prepare exact binding deletion before the session owner commits either database. */
 async function withCodexAppServerSessionDeletion(bindingStore, params, run) {
+	return withCodexAppServerSessionMutation(bindingStore, params, run);
+}
+/** Retire the old native context when the host commits a rewind or branch switch. */
+async function withCodexAppServerSessionContextReset(bindingStore, params, run) {
+	params.assertCurrent();
+	const plan = await bindingStore.prepareSessionGenerationReclaim({
+		kind: "session",
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId
+	});
+	params.assertCurrent();
+	const sessionId = plan.kind === "verify" && plan.expectedPreviousSessionId === params.previousSessionId ? plan.expectedPreviousSessionId : params.sessionId;
+	return withCodexAppServerSessionMutation(bindingStore, {
+		...params,
+		sessionId
+	}, run);
+}
+async function withCodexAppServerSessionMutation(bindingStore, params, run) {
 	const { assertCurrent } = params;
 	const identity = {
 		kind: "session",
@@ -95,4 +114,4 @@ async function retireCodexAppServerSessionGeneration(params) {
 	}));
 }
 //#endregion
-export { retireCodexAppServerSessionGeneration, withCodexAppServerSessionDeletion };
+export { retireCodexAppServerSessionGeneration, withCodexAppServerSessionContextReset, withCodexAppServerSessionDeletion };

package/dist/.setup/{settled-turn-finalizer-CiY2bLFK.mjs → settled-turn-finalizer-DiAi6Kx6.mjs}

@@ -1,11 +1,11 @@
-import { g as assertCodexPassiveTurnItems } from "./client-vXs2929Q.mjs";
 import { r as readMirrorIdentity, t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
 import { a as fingerprintCodexMirrorSourceMessage, c as readCodexMirrorSourceFingerprint } from "./transcript-mirror-attestation-CzM-94NC.mjs";
-import { Z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-BpTtuLQ5.mjs";
-import { t as codexTranscriptMirrorRuntime } from "./transcript-mirror-D4qp_leP.mjs";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-BtlZcivC.mjs";
+import { Z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-DA4VR4Eb.mjs";
+import { _ as assertCodexPassiveTurnItems } from "./client-Cs08OXVQ.mjs";
+import { t as codexTranscriptMirrorRuntime } from "./transcript-mirror-BtHDBp1G.mjs";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-B2HScEgT.mjs";
 import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-B_2mnqhb.mjs";
-import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-DNUR1s0A.mjs";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BsruvNrH.mjs";
 import { t as CodexSettledTurnContext } from "./settled-turn-context-fmwouT5I.mjs";
 import { isSilentReplyText } from "openclaw/plugin-sdk/reply-runtime";
 //#region extensions/codex/src/app-server/settled-turn-finalizer.ts
@@ -68,14 +68,14 @@ async function runCodexSettledTurnFinalization(operation, options) {
 		provider: modelProvider,
 		api: resolveCodexLocalRuntimeAttribution(attempt).api
 	};
-	assertCodexPassiveTurnItems(bounded.items, attempt.prompt, "settled-turn finalization");
-	const text = isSilentReplyText(bounded.text) ? "" : bounded.text.trim();
+	assertCodexPassiveTurnItems(bounded.items, attempt.prompt, "settled-turn finalization", { allowManagedHookPrompts: bounded.managedHooksEnabled });
+	const text = bounded.text.trim();
 	const assistant = createAttributedCodexAssistantMessage(attribution, text, {
 		tokenUsage: bounded.usage,
 		aborted: false,
 		promptError: null
 	});
-	if (!text) return {
+	if (!text || isSilentReplyText(text)) return {
 		assistant,
 		...bounded.usage ? { usage: bounded.usage } : {}
 	};