@xopcai/xopc 0.0.94 → 0.0.96

package/dist/src/session/store.js

@@ -1,415 +1,85 @@
-import { resolveStateDir } from "../config/paths-state.js";
-import { init_agent_scope, listAgentEntries, resolveDefaultAgentId } from "../agent/agent-scope.js";
-import { init_session_key, parseSessionKey } from "../routing/session-key.js";
-import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { init_artifacts, parseCompactionCheckpointTranscriptFileName } from "./parity/artifacts.js";
-import { init_session_id, validateSessionId } from "./parity/session-id.js";
-import { archiveFileOnDisk, init_transcript_paths, resolveSessionFilePath, resolveSessionTranscriptPathInDir } from "./parity/transcript-paths.js";
-import { FILENAMES, init_paths, resolveSessionsDir } from "../config/paths.js";
-import { loadEntriesFromFile } from "./parity/load-jsonl-entries.js";
-import { mergeLlmMessagesPreservingContextRows } from "./session-context-for-llm.js";
-import { appendPiTranscriptContextEntry, persistMergedTranscriptRows, readTranscriptRowsFromFile, rowsToLlmMessages, writeTranscriptJsonl } from "./parity/jsonl-transcript-io.js";
-import { invalidateSessionSearchIndexCache } from "./search-index-cache.js";
+import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import "./types.js";
+import { buildSessionContextForLlm, mergeLlmMessagesPreservingContextRows } from "./session-context-for-llm.js";
+import { estimateTokensFromMessages } from "../storage/sqlite/row-mappers.js";
+import { deleteSessionRecord, ensureSessionRecord, getGlobalSessionStats, getSessionMetadata, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord } from "../storage/sqlite/session-repository.js";
+import { appendTranscriptEntry, captureCompactionCheckpoint, getCompactionCheckpointDetail, listCompactionCheckpoints, loadCheckpointRows, loadLlmMessagesForSession, loadTranscriptRowsForSession, replaceTranscriptRows, restoreCompactionCheckpoint } from "../storage/sqlite/transcript-repository.js";
+import "../storage/sqlite/index.js";
 import { readPostCompactionContext } from "../agent/reply/post-compaction-context.js";
 import { SessionCompactor } from "../agent/memory/compaction.js";
 import { SlidingWindow } from "../agent/memory/window.js";
 import { normalizeCompactionCheckpointId } from "./compaction-checkpoints.js";
-import "./types.js";
-import { readSessionsJsonFile, withSessionsJsonLock } from "./parity/sessions-json-file.js";
-import { buildSessionsJsonStatsPatch, incrementSessionsJsonStatsForAppend, isAppendOnlyLlmTranscriptMessage, patchSessionsJsonEntryStats } from "./parity/sessions-json-patch.js";
-import { countTranscriptMessageRows, readDisplayMessagePageFromTranscriptFile } from "./parity/transcript-pagination.js";
-import { join } from "path";
-import { existsSync } from "fs";
-import { copyFile, mkdir, readdir, stat, unlink } from "fs/promises";
-import { randomUUID } from "node:crypto";
-import { performance } from "node:perf_hooks";
+import { isAppendOnlyLlmTranscriptMessage } from "./transcript-stats.js";
 //#region src/session/store.ts
-init_paths();
-init_agent_scope();
-init_session_key();
+init_paths_state();
 init_logger();
-init_artifacts();
-init_transcript_paths();
-init_session_id();
 const log = createLogger("SessionStore");
 const INDEX_VERSION = "1.0";
-const DELETED_MARKER = ".jsonl.deleted.";
-const ALL_SESSIONS_MAP_CACHE_TTL_MS = 2e3;
 var SessionStore = class {
-	sessionsDir;
-	archiveDir;
-	storePath;
 	window;
 	compactor;
-	storeMutationDepth = 0;
-	storeMutationChain = Promise.resolve();
-	allSessionsMapCache;
-	/** Cache of per-agent sessions dirs to avoid re-resolution on every call. */
-	agentSessionsDirCache = /* @__PURE__ */ new Map();
 	constructor(options, windowConfig, compactionConfig) {
 		this.options = options;
-		const agentId = options.agentId ?? resolveDefaultAgentId(options.config);
-		this.sessionsDir = options.sessionsDir ?? resolveSessionsDir(options.config, agentId);
-		this.archiveDir = join(this.sessionsDir, "archive");
-		this.storePath = join(this.sessionsDir, FILENAMES.SESSIONS_MAP);
 		this.window = new SlidingWindow(windowConfig);
 		this.compactor = new SessionCompactor(compactionConfig);
 	}
-	getSessionsRoot() {
-		return this.sessionsDir;
-	}
-	/**
-	* OpenClaw-aligned: resolve the sessions directory for a given session key.
-	* Extracts agentId from the session key and routes to `agents/<agentId>/sessions/`.
-	* Falls back to the default sessions directory when agentId cannot be parsed
-	* or when `sessionsDir` was explicitly provided in options.
-	*/
-	resolveSessionsDirForKey(sessionKey) {
-		if (this.options.sessionsDir) return this.sessionsDir;
-		const parsed = parseSessionKey(sessionKey);
-		if (!parsed) return this.sessionsDir;
-		const agentId = parsed.agentId;
-		const cached = this.agentSessionsDirCache.get(agentId);
-		if (cached) return cached;
-		const resolved = resolveSessionsDir(this.options.config, agentId);
-		this.agentSessionsDirCache.set(agentId, resolved);
-		return resolved;
-	}
-	resolveStorePathForKey(sessionKey) {
-		return join(this.resolveSessionsDirForKey(sessionKey), FILENAMES.SESSIONS_MAP);
+	resolveWorkspaceCwd(sessionKey) {
+		return resolveEffectiveAgentProfileForSession(this.options.config, sessionKey).resolvedWorkspacePath;
 	}
 	async runStoreMutation(fn) {
-		if (this.storeMutationDepth > 0) return fn();
-		const run = this.storeMutationChain.then(async () => {
-			this.storeMutationDepth++;
-			try {
-				return await fn();
-			} finally {
-				this.storeMutationDepth--;
-			}
-		});
-		this.storeMutationChain = run.then(() => void 0).catch(() => void 0);
-		return run;
+		return fn();
 	}
 	async initialize() {
-		await mkdir(this.sessionsDir, { recursive: true });
-		await mkdir(this.archiveDir, { recursive: true });
-		if (!existsSync(this.storePath)) await withSessionsJsonLock(this.storePath, async () => void 0);
-		log.debug("Session store initialized (sessions.json + JSONL)");
-	}
-	transcriptPathForEntry(entry, sessionsDir) {
-		return resolveSessionFilePath(entry.sessionId, entry, { sessionsDir: sessionsDir ?? this.sessionsDir });
-	}
-	async readMapForKey(sessionKey) {
-		return readSessionsJsonFile(this.resolveStorePathForKey(sessionKey));
-	}
-	async readMap() {
-		return readSessionsJsonFile(this.storePath);
-	}
-	invalidateAllSessionsMapCache() {
-		this.allSessionsMapCache = void 0;
-	}
-	async discoverSessionMapPaths() {
-		const agents = listAgentEntries(this.options.config);
-		const defaultId = resolveDefaultAgentId(this.options.config);
-		const agentIds = new Set([defaultId, ...agents.map((agent) => agent.id)]);
-		const agentsRoot = join(resolveStateDir(process.env), "agents");
-		if (existsSync(agentsRoot)) {
-			const entries = await readdir(agentsRoot, { withFileTypes: true }).catch(() => []);
-			for (const entry of entries) if (entry.isDirectory()) agentIds.add(entry.name);
-		}
-		return [...agentIds].map((agentId) => ({
-			agentId,
-			mapPath: join(resolveSessionsDir(this.options.config, agentId), FILENAMES.SESSIONS_MAP)
-		}));
-	}
-	/**
-	* Unified cross-agent aggregation entry for global session views.
-	* Reads configured agents plus existing per-agent session maps under the state directory.
-	*/
-	async readAllMaps() {
-		if (this.options.sessionsDir) return this.readMap();
-		const nowMs = Date.now();
-		if (this.allSessionsMapCache && this.allSessionsMapCache.expiresAtMs > nowMs) {
-			log.debug({ sessionCount: Object.keys(this.allSessionsMapCache.map).length }, "All session maps cache hit");
-			return this.allSessionsMapCache.map;
-		}
-		const startedAt = performance.now();
-		const paths = await this.discoverSessionMapPaths();
-		const merged = {};
-		let scannedMapCount = 0;
-		for (const { mapPath } of paths) {
-			if (!existsSync(mapPath)) continue;
-			const map = await readSessionsJsonFile(mapPath);
-			Object.assign(merged, map);
-			scannedMapCount++;
-		}
-		this.allSessionsMapCache = {
-			expiresAtMs: nowMs + ALL_SESSIONS_MAP_CACHE_TTL_MS,
-			map: merged
-		};
-		log.debug({
-			candidateAgentCount: paths.length,
-			scannedMapCount,
-			sessionCount: Object.keys(merged).length,
-			durationMs: Math.round(performance.now() - startedAt)
-		}, "All session maps scanned");
-		return merged;
-	}
-	async getDiskEntry(sessionKey) {
-		return (await this.readMapForKey(sessionKey))[sessionKey];
-	}
-	buildDefaultMetadata(key) {
-		const { channel, chatId } = this.parseSessionKey(key);
-		const routing = this.extractRoutingFromKey(key);
-		const isCronSession = channel === "cron";
-		const isHeartbeatSession = channel === "heartbeat";
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		return {
-			key,
-			status: "active",
-			tags: [],
-			createdAt: now,
-			updatedAt: now,
-			lastAccessedAt: now,
-			messageCount: 0,
-			estimatedTokens: 0,
-			compactedCount: 0,
-			sourceChannel: channel,
-			sourceChatId: chatId,
-			routing,
-			...isCronSession ? {
-				sessionType: "cron",
-				customData: { cronJobId: chatId }
-			} : {},
-			...isHeartbeatSession ? {
-				sessionType: "heartbeat",
-				customData: { heartbeatTarget: chatId }
-			} : {},
-			stats: {
-				messageCount: 0,
-				tokenCount: 0
-			}
-		};
+		requireXopcDatabase();
+		log.debug("Session store initialized (SQLite)");
 	}
-	parseSessionKey(key) {
-		const parts = key.split(":");
-		if (parts.length >= 2 && parts[0] === "heartbeat") return {
-			channel: "heartbeat",
-			chatId: parts.slice(1).join(":")
-		};
-		const parsed = parseSessionKey(key);
-		if (parsed) {
-			if (parsed.source === "cron") return {
-				channel: "cron",
-				chatId: parsed.peerId
-			};
-			return {
-				channel: parsed.source,
-				chatId: [
-					parsed.accountId,
-					parsed.peerKind,
-					parsed.peerId
-				].join(":")
-			};
-		}
-		return {
-			channel: "unknown",
-			chatId: key
-		};
-	}
-	extractRoutingFromKey(key) {
-		const parsed = parseSessionKey(key);
-		if (!parsed) return;
-		return {
-			agentId: parsed.agentId?.toLowerCase() || "main",
-			source: parsed.source?.toLowerCase() || "unknown",
-			accountId: parsed.accountId?.toLowerCase() || "default",
-			peerKind: parsed.peerKind?.toLowerCase() || "dm",
-			peerId: parsed.peerId?.toLowerCase() || "unknown",
-			threadId: parsed.threadId,
-			scopeId: parsed.scopeId
-		};
+	getSessionsRoot() {
+		return resolveStateDir();
 	}
-	/** Resolve on-disk transcript path; creates session row + empty JSONL when missing. */
 	async resolveTranscriptPath(sessionKey) {
-		const entry = await this.ensureSession(sessionKey);
-		const sessionsDir = this.resolveSessionsDirForKey(sessionKey);
-		const absPath = this.transcriptPathForEntry(entry, sessionsDir);
+		requireXopcDatabase();
 		return {
-			sessionId: entry.sessionId,
-			absPath,
-			sessionsDir
+			sessionId: ensureSessionRecord(sessionKey, this.resolveWorkspaceCwd(sessionKey)).transcriptId,
+			sessionKey
 		};
 	}
-	/** Ensure sessions.json has an entry and transcript file exist for `sessionKey`. */
-	async ensureSession(sessionKey) {
-		const keyStorePath = this.resolveStorePathForKey(sessionKey);
-		const keySessionsDir = this.resolveSessionsDirForKey(sessionKey);
-		await mkdir(keySessionsDir, { recursive: true });
-		let changed = false;
-		const entry = await withSessionsJsonLock(keyStorePath, async (map) => {
-			const existing = map[sessionKey];
-			if (existing?.pluginExtensions?.xopc?.metadata) return existing;
-			let nextEntry = existing;
-			if (!nextEntry) {
-				const sessionId = randomUUID();
-				validateSessionId(sessionId);
-				const sessionFile = `${sessionId}.jsonl`;
-				const now = Date.now();
-				const metadata = this.buildDefaultMetadata(sessionKey);
-				metadata.transcriptId = sessionId;
-				nextEntry = {
-					sessionId,
-					updatedAt: now,
-					sessionStartedAt: now,
-					sessionFile,
-					pluginExtensions: { xopc: { metadata } }
-				};
-				map[sessionKey] = nextEntry;
-				await writeTranscriptJsonl({
-					absPath: resolveSessionTranscriptPathInDir(sessionId, keySessionsDir),
-					sessionId,
-					cwd: process.cwd(),
-					rows: []
-				});
-				changed = true;
-			} else if (!nextEntry.pluginExtensions?.xopc?.metadata) {
-				const metadata = this.buildDefaultMetadata(sessionKey);
-				metadata.transcriptId = nextEntry.sessionId;
-				nextEntry.pluginExtensions = { xopc: { metadata } };
-				map[sessionKey] = nextEntry;
-				changed = true;
-			}
-			return nextEntry;
+	async appendTranscriptMessage(sessionKey, message) {
+		return this.runStoreMutation(async () => {
+			requireXopcDatabase();
+			ensureSessionRecord(sessionKey, this.resolveWorkspaceCwd(sessionKey));
+			appendTranscriptEntry(sessionKey, message);
 		});
-		if (changed) this.invalidateAllSessionsMapCache();
-		return entry;
-	}
-	metadataFromEntry(sessionKey, entry) {
-		const base = entry.pluginExtensions?.xopc?.metadata ?? this.buildDefaultMetadata(sessionKey);
-		const { channel: keySource, chatId: keyChatId } = this.parseSessionKey(sessionKey);
-		const diskSc = typeof base.sourceChannel === "string" ? base.sourceChannel.trim() : "";
-		const diskChat = typeof base.sourceChatId === "string" ? base.sourceChatId.trim() : "";
-		return {
-			...base,
-			key: sessionKey,
-			transcriptId: entry.sessionId,
-			sourceChannel: diskSc || keySource,
-			sourceChatId: diskChat || keyChatId
-		};
 	}
 	async getByAgent(agentId) {
-		const map = await this.readAllMaps();
-		const out = [];
-		for (const [key, e] of Object.entries(map)) {
-			const m = this.metadataFromEntry(key, e);
-			if (m.routing?.agentId?.toLowerCase() === agentId.toLowerCase()) out.push(m);
-		}
-		return out;
+		requireXopcDatabase();
+		return listSessionsByAgent(agentId);
 	}
 	async getByAccount(accountId) {
-		const map = await this.readAllMaps();
-		const out = [];
-		for (const [key, e] of Object.entries(map)) {
-			const m = this.metadataFromEntry(key, e);
-			if (m.routing?.accountId === accountId) out.push(m);
-		}
-		return out;
+		const { items } = await this.list({ limit: 1e5 });
+		return items.filter((m) => m.routing?.accountId === accountId);
 	}
 	async getByPeer(peerKind, peerId) {
-		const map = await this.readAllMaps();
-		const out = [];
-		for (const [key, e] of Object.entries(map)) {
-			const m = this.metadataFromEntry(key, e);
-			if (m.routing?.peerKind === peerKind && m.routing.peerId === peerId) out.push(m);
-		}
-		return out;
+		const { items } = await this.list({ limit: 1e5 });
+		return items.filter((m) => m.routing?.peerKind === peerKind && m.routing.peerId === peerId);
 	}
 	async getMainSession(channel, accountId) {
-		const map = await this.readAllMaps();
-		for (const [key, e] of Object.entries(map)) {
-			const m = this.metadataFromEntry(key, e);
-			if (m.routing?.source === channel && m.routing.accountId === accountId && m.routing.peerKind === "dm" && m.routing.peerId === "main") return m;
-		}
-		return null;
+		const { items } = await this.list({ limit: 1e5 });
+		return items.find((m) => m.routing?.source === channel && m.routing.accountId === accountId && m.routing.peerKind === "dm" && m.routing.peerId === "main") ?? null;
 	}
 	async refreshIndex() {}
 	async list(query = {}) {
-		const map = await this.readAllMaps();
-		let sessions = Object.entries(map).map(([k, e]) => this.metadataFromEntry(k, e));
-		if (query.status) {
-			const statuses = Array.isArray(query.status) ? query.status : [query.status];
-			sessions = sessions.filter((s) => statuses.includes(s.status));
-		}
-		if (query.channel) {
-			const rawChannels = query.channel.split(",").map((c) => c.trim().toLowerCase()).filter(Boolean);
-			/**
-			* `ui` is a legacy console source; treat as webchat when filtering web sessions.
-			* `webui` matches slash-command normalization to `gateway` (see `chat-commands/session-key.ts`).
-			*/
-			const channels = [...new Set(rawChannels.flatMap((c) => {
-				if (c === "webchat") return ["webchat", "ui"];
-				if (c === "gateway") return ["gateway", "webui"];
-				return [c];
-			}))];
-			if (channels.length === 0) sessions = [];
-			else if (channels.length === 1) {
-				const ch = channels[0];
-				sessions = sessions.filter((s) => (s.sourceChannel ?? "").toLowerCase() === ch);
-			} else sessions = sessions.filter((s) => channels.includes((s.sourceChannel ?? "").toLowerCase()));
-		}
-		if (query.tags?.length) sessions = sessions.filter((s) => query.tags.some((t) => s.tags.includes(t)));
-		if (query.search) {
-			const q = query.search.toLowerCase();
-			const metadataMatches = sessions.filter((session) => this.sessionMetadataMatchesSearch(session, q));
-			const metadataMatchedKeys = new Set(metadataMatches.map((session) => session.key));
-			const contentMatches = [];
-			const candidates = sessions.filter((session) => !metadataMatchedKeys.has(session.key));
-			for (const candidate of candidates) if (await this.sessionContentMatchesSearch(candidate.key, q)) contentMatches.push(candidate);
-			sessions = [...metadataMatches, ...contentMatches];
-		}
-		const sortBy = query.sortBy || "updatedAt";
-		const sortOrder = query.sortOrder || "desc";
-		sessions.sort((a, b) => {
-			const av = a[sortBy];
-			const bv = b[sortBy];
-			const c = av < bv ? -1 : av > bv ? 1 : 0;
-			return sortOrder === "asc" ? c : -c;
-		});
-		const total = sessions.length;
-		const limit = query.limit || 50;
-		const offset = query.offset || 0;
-		return {
-			items: sessions.slice(offset, offset + limit),
-			total,
-			limit,
-			offset,
-			hasMore: offset + limit < total
-		};
-	}
-	sessionMetadataMatchesSearch(session, query) {
-		return Boolean(session.key.toLowerCase().includes(query) || session.name?.toLowerCase().includes(query) || session.sourceChannel.toLowerCase().includes(query) || session.sourceChatId.toLowerCase().includes(query) || session.tags.some((tag) => tag.toLowerCase().includes(query)));
-	}
-	async sessionContentMatchesSearch(sessionKey, query) {
-		return (await this.loadDisplayMessages(sessionKey)).some((message) => {
-			if (this.extractTextContent(this.messageContent(message)).toLowerCase().includes(query)) return true;
-			const attachments = message.attachments;
-			if (!Array.isArray(attachments)) return false;
-			return attachments.some((attachment) => {
-				if (!attachment || typeof attachment !== "object") return false;
-				const name = attachment.name;
-				return typeof name === "string" && name.toLowerCase().includes(query);
-			});
-		});
+		requireXopcDatabase();
+		return listSessionMetadata(query);
 	}
 	async get(key, options) {
 		const metadata = await this.getMetadata(key);
 		if (!metadata) return null;
 		const messages = await this.loadDisplayMessages(key);
-		return await this.buildSessionDetail(key, metadata, messages, options);
+		return this.buildSessionDetail(key, metadata, messages, options);
 	}
 	async getMessagePage(key, options = {}) {
 		const metadata = await this.getMetadata(key);
@@ -418,44 +88,22 @@ var SessionStore = class {
 		const offset = Math.max(0, Math.trunc(options.offset ?? 0));
 		const parsedBefore = options.before ? Number.parseInt(options.before, 10) : void 0;
 		const hasBeforeCursor = parsedBefore !== void 0 && Number.isFinite(parsedBefore);
-		if ((await this.listCompactionCheckpoints(key)).length === 0) {
-			const entry = await this.getDiskEntry(key);
-			if (!entry) return null;
-			const keySessionsDir = this.resolveSessionsDirForKey(key);
-			const page = await readDisplayMessagePageFromTranscriptFile(this.transcriptPathForEntry(entry, keySessionsDir), {
-				limit,
-				offset: hasBeforeCursor ? void 0 : offset,
-				beforeIndex: hasBeforeCursor ? parsedBefore : void 0
-			});
-			const session = await this.buildSessionDetail(key, metadata, page.messages, options);
-			const nextBeforeCursor = page.startIndex > 0 ? String(page.startIndex) : void 0;
-			return {
-				session,
-				pagination: {
-					total: page.total,
-					limit,
-					offset,
-					hasMore: page.startIndex > 0,
-					...hasBeforeCursor ? { before: String(page.endIndex) } : {},
-					...nextBeforeCursor ? { nextBeforeCursor } : {}
-				}
-			};
-		}
-		const messages = await this.loadDisplayMessages(key);
-		const total = messages.length;
-		const endExclusive = hasBeforeCursor ? Math.min(total, Math.max(0, Math.trunc(parsedBefore))) : Math.max(0, total - offset);
-		const startInclusive = Math.max(0, endExclusive - limit);
-		const pageMessages = messages.slice(startInclusive, endExclusive);
-		const session = await this.buildSessionDetail(key, metadata, pageMessages, options);
-		const nextBeforeCursor = startInclusive > 0 ? String(startInclusive) : void 0;
+		const displayMessages = await this.loadDisplayMessages(key);
+		const page = this.paginateDisplayMessages(displayMessages, {
+			limit,
+			offset: hasBeforeCursor ? void 0 : offset,
+			beforeEndIndex: hasBeforeCursor ? parsedBefore : void 0
+		});
+		const session = await this.buildSessionDetail(key, metadata, page.messages, options);
+		const nextBeforeCursor = page.startIndex > 0 ? String(page.startIndex) : void 0;
 		return {
 			session,
 			pagination: {
-				total,
+				total: page.total,
 				limit,
 				offset,
-				hasMore: startInclusive > 0,
-				...hasBeforeCursor ? { before: String(endExclusive) } : {},
+				hasMore: hasBeforeCursor ? page.startIndex > 0 : offset + limit < page.total,
+				...hasBeforeCursor ? { before: String(page.endIndex) } : {},
 				...nextBeforeCursor ? { nextBeforeCursor } : {}
 			}
 		};
@@ -482,114 +130,40 @@ var SessionStore = class {
 		};
 	}
 	async loadTranscriptRows(key) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return [];
-		return readTranscriptRowsFromFile(this.transcriptPathForEntry(entry, this.resolveSessionsDirForKey(key)));
+		requireXopcDatabase();
+		return loadTranscriptRowsForSession(key);
 	}
 	async getMetadata(key) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return null;
-		return this.metadataFromEntry(key, entry);
+		requireXopcDatabase();
+		return getSessionMetadata(key);
 	}
 	async updateMetadata(key, updates) {
 		return this.runStoreMutation(async () => {
-			await withSessionsJsonLock(this.resolveStorePathForKey(key), async (map) => {
-				const entry = map[key];
-				if (!entry?.pluginExtensions?.xopc?.metadata) throw new Error(`Session not found: ${key}`);
-				const meta = {
-					...entry.pluginExtensions.xopc.metadata,
-					...updates,
-					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				};
-				entry.pluginExtensions.xopc.metadata = meta;
-				entry.updatedAt = Date.now();
-				map[key] = entry;
-			});
-			this.invalidateAllSessionsMapCache();
-			invalidateSessionSearchIndexCache();
+			requireXopcDatabase();
+			patchSessionMetadata(key, updates);
 			log.debug({
 				key,
 				updates
 			}, "Session metadata updated");
 		});
 	}
-	/**
-	* Reset transcript for an existing session key: archive the current JSONL as
-	* `*.reset.*`, assign a new `sessionId`, and preserve per-session overrides
-	* on the disk entry (thinking/verbose) and in `sessions/config/*.json`.
-	*/
 	async reset(key) {
 		return this.runStoreMutation(async () => {
-			const existing = await this.getDiskEntry(key);
-			if (!existing?.pluginExtensions?.xopc?.metadata) return null;
-			const previousSessionId = existing.sessionId;
-			const keySessionsDir = this.resolveSessionsDirForKey(key);
-			const abs = this.transcriptPathForEntry(existing, keySessionsDir);
-			if (existsSync(abs)) try {
-				archiveFileOnDisk(abs, "reset");
-			} catch (err) {
-				log.warn({
-					err,
-					key
-				}, "Transcript archive on reset failed");
-			}
-			const sessionId = randomUUID();
-			validateSessionId(sessionId);
-			const now = Date.now();
-			await writeTranscriptJsonl({
-				absPath: resolveSessionTranscriptPathInDir(sessionId, keySessionsDir),
-				sessionId,
-				cwd: process.cwd(),
-				rows: []
-			});
-			await withSessionsJsonLock(this.resolveStorePathForKey(key), async (map) => {
-				const e = map[key];
-				if (!e?.pluginExtensions?.xopc?.metadata) return;
-				e.sessionId = sessionId;
-				e.sessionFile = `${sessionId}.jsonl`;
-				e.updatedAt = now;
-				e.sessionStartedAt = now;
-				e.lastInteractionAt = void 0;
-				patchSessionsJsonEntryStats(e, buildSessionsJsonStatsPatch(0, 0));
-				const meta = e.pluginExtensions.xopc.metadata;
-				meta.transcriptId = sessionId;
-				meta.updatedAt = new Date(now).toISOString();
-				map[key] = e;
-			});
-			this.invalidateAllSessionsMapCache();
-			invalidateSessionSearchIndexCache();
-			log.info({
+			requireXopcDatabase();
+			const outcome = resetSessionRecord(key, this.resolveWorkspaceCwd(key));
+			if (outcome) log.info({
 				key,
-				previousSessionId,
-				sessionId
+				...outcome
 			}, "Session reset");
-			return {
-				sessionId,
-				previousSessionId
-			};
+			return outcome;
 		});
 	}
 	async delete(key) {
 		return this.runStoreMutation(async () => {
-			const entry = await this.getDiskEntry(key);
-			if (!entry) return false;
-			const keySessionsDir = this.resolveSessionsDirForKey(key);
-			const abs = this.transcriptPathForEntry(entry, keySessionsDir);
-			await withSessionsJsonLock(this.resolveStorePathForKey(key), async (map) => {
-				delete map[key];
-			});
-			try {
-				if (existsSync(abs)) archiveFileOnDisk(abs, "deleted");
-			} catch (err) {
-				log.warn({
-					err,
-					key
-				}, "Transcript archive on delete failed");
-			}
-			this.invalidateAllSessionsMapCache();
-			invalidateSessionSearchIndexCache();
-			log.info({ key }, "Session deleted");
-			return true;
+			requireXopcDatabase();
+			const ok = deleteSessionRecord(key);
+			if (ok) log.info({ key }, "Session deleted");
+			return ok;
 		});
 	}
 	async deleteMany(keys) {
@@ -608,8 +182,6 @@ var SessionStore = class {
 	}
 	async setStatus(key, status) {
 		await this.updateMetadata(key, { status });
-		if (status === "archived") await this.moveToArchive(key);
-		else await this.moveFromArchive(key);
 	}
 	async archive(key) {
 		await this.setStatus(key, "archived");
@@ -623,200 +195,62 @@ var SessionStore = class {
 	async unpin(key) {
 		await this.setStatus(key, "active");
 	}
-	async moveToArchive(key) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return;
-		const keySessionsDir = this.resolveSessionsDirForKey(key);
-		const abs = this.transcriptPathForEntry(entry, keySessionsDir);
-		if (existsSync(abs)) try {
-			archiveFileOnDisk(abs, "deleted");
-		} catch (err) {
-			log.warn({
-				err,
-				key
-			}, "Archive transcript rename failed");
-		}
-	}
-	async findMostRecentDeletedTranscript(sessionId, sessionsDir) {
-		let names;
-		try {
-			names = await readdir(sessionsDir);
-		} catch {
-			return null;
-		}
-		const prefix = `${sessionId}${DELETED_MARKER}`;
-		const hits = names.filter((n) => n.startsWith(prefix) && n.endsWith("Z"));
-		hits.sort().reverse();
-		const first = hits[0];
-		return first ? join(sessionsDir, first) : null;
-	}
-	async moveFromArchive(key) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return;
-		const keySessionsDir = this.resolveSessionsDirForKey(key);
-		const target = resolveSessionTranscriptPathInDir(entry.sessionId, keySessionsDir);
-		if (existsSync(target)) return;
-		const src = await this.findMostRecentDeletedTranscript(entry.sessionId, keySessionsDir);
-		if (!src) return;
-		try {
-			const { rename } = await import("fs/promises");
-			await rename(src, target);
-		} catch (err) {
-			log.warn({
-				err,
-				key,
-				src,
-				target
-			}, "Unarchive transcript rename failed");
-		}
-	}
-	async loadMessages(key, options) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return [];
-		const keySessionsDir = this.resolveSessionsDirForKey(key);
-		const primary = this.transcriptPathForEntry(entry, keySessionsDir);
-		if (existsSync(primary)) return rowsToLlmMessages(await readTranscriptRowsFromFile(primary));
-		if (options?.fromArchive) {
-			const archived = await this.findMostRecentDeletedTranscript(entry.sessionId, keySessionsDir);
-			if (!archived) return [];
-			return rowsToLlmMessages(await readTranscriptRowsFromFile(archived));
-		}
-		return [];
-	}
-	async loadDisplayMessages(key) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return [];
-		const keySessionsDir = this.resolveSessionsDirForKey(key);
-		const primary = this.transcriptPathForEntry(entry, keySessionsDir);
-		const transcriptPaths = [];
-		const checkpoints = await this.listCompactionCheckpoints(key);
-		for (const checkpoint of [...checkpoints].reverse()) transcriptPaths.push(join(keySessionsDir, `${this.checkpointBasename(entry.sessionId)}${checkpoint.id}.jsonl`));
-		transcriptPaths.push(primary);
-		const messages = [];
-		const seenMessages = /* @__PURE__ */ new Set();
-		for (const transcriptPath of transcriptPaths) {
-			if (!existsSync(transcriptPath)) continue;
-			const rows = await readTranscriptRowsFromFile(transcriptPath);
-			for (const message of rowsToLlmMessages(rows)) {
-				if (this.isCompactionSummaryMessage(message)) continue;
-				const key = this.displayMessageIdentity(message);
-				if (seenMessages.has(key)) continue;
-				seenMessages.add(key);
-				messages.push(message);
-			}
-		}
-		return messages;
+	async loadMessages(_key, _options) {
+		requireXopcDatabase();
+		return loadLlmMessagesForSession(_key);
 	}
 	async loadTranscriptDocument(key) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return null;
-		const path = this.transcriptPathForEntry(entry, this.resolveSessionsDirForKey(key));
-		if (!existsSync(path)) return null;
-		const entries = loadEntriesFromFile(path);
-		const header = entries.find((e) => e.type === "session");
-		if (!header || typeof header.id !== "string") return null;
-		const sessionHeader = header;
-		const rows = await readTranscriptRowsFromFile(path);
-		const compactions = entries.filter((e) => e.type === "compaction").map((c) => ({
-			at: c.timestamp,
-			summary: c.summary,
-			firstKeptIndex: Number.parseInt(String(c.firstKeptEntryId), 10) || 0,
-			tokensBefore: c.tokensBefore,
-			tokensAfter: typeof c.details === "object" && c.details && "tokensAfter" in c.details && typeof c.details.tokensAfter === "number" ? c.details.tokensAfter : 0
-		}));
+		const metadata = await this.getMetadata(key);
+		if (!metadata?.transcriptId) return null;
+		const rows = await this.loadTranscriptRows(key);
+		const compactions = [];
+		for (const row of rows) if (row.type === "compaction") {
+			const c = row;
+			compactions.push({
+				at: c.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+				summary: c.summary ?? "",
+				firstKeptIndex: Number(c.firstKeptIndex ?? 0),
+				tokensBefore: c.tokensBefore ?? 0,
+				tokensAfter: c.tokensAfter ?? 0
+			});
+		}
 		return {
 			type: "xopc_session_transcript",
 			version: 1,
-			id: sessionHeader.id,
-			createdAt: sessionHeader.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			id: metadata.transcriptId,
+			createdAt: metadata.createdAt,
+			updatedAt: metadata.updatedAt,
 			messages: rows,
 			...compactions.length > 0 ? { compactions } : {}
 		};
 	}
-	async writeTranscriptAndSyncIndex(key, rows, opts) {
-		const entry = await this.ensureSession(key);
-		const keySessionsDir = this.resolveSessionsDirForKey(key);
-		const abs = this.transcriptPathForEntry(entry, keySessionsDir);
-		const llm = rowsToLlmMessages(rows);
-		await persistMergedTranscriptRows({
-			absPath: abs,
-			sessionId: entry.sessionId,
-			cwd: process.cwd(),
-			rows,
-			appendCompaction: opts?.appendCompaction
-		});
-		await withSessionsJsonLock(this.resolveStorePathForKey(key), async (map) => {
-			const e = map[key];
-			if (!e?.pluginExtensions?.xopc?.metadata) return;
-			patchSessionsJsonEntryStats(e, buildSessionsJsonStatsPatch(llm.length, this.estimateTokens(llm)));
-			map[key] = e;
-		});
-		this.invalidateAllSessionsMapCache();
-		invalidateSessionSearchIndexCache();
-	}
-	/** Incremental sessions.json stats after guard append (OpenClaw transcript-events). */
-	async syncSessionsJsonFromTranscriptUpdate(update) {
+	async syncEmbeddedTranscriptUpdate(update) {
 		const sessionKey = update.sessionKey?.trim();
-		if (!sessionKey || !existsSync(update.sessionFile)) return;
+		if (!sessionKey) return;
 		return this.runStoreMutation(async () => {
-			await withSessionsJsonLock(this.resolveStorePathForKey(sessionKey), async (map) => {
-				const e = map[sessionKey];
-				if (!e?.pluginExtensions?.xopc?.metadata) return;
-				if (update.message && isAppendOnlyLlmTranscriptMessage(update.message)) {
-					incrementSessionsJsonStatsForAppend(e);
-					map[sessionKey] = e;
-					return;
-				}
-				const messageCount = await countTranscriptMessageRows(update.sessionFile);
-				const llm = rowsToLlmMessages(await readTranscriptRowsFromFile(update.sessionFile));
-				patchSessionsJsonEntryStats(e, buildSessionsJsonStatsPatch(messageCount, this.estimateTokens(llm)));
-				map[sessionKey] = e;
-			});
-			this.invalidateAllSessionsMapCache();
-			invalidateSessionSearchIndexCache();
+			requireXopcDatabase();
+			ensureSessionRecord(sessionKey, this.resolveWorkspaceCwd(sessionKey));
+			if (update.message && isAppendOnlyLlmTranscriptMessage(update.message)) appendTranscriptEntry(sessionKey, update.message);
 		});
 	}
 	async appendTranscriptContextEntry(key, entry) {
 		return this.runStoreMutation(async () => {
-			await this.ensureSession(key);
-			const disk = await this.getDiskEntry(key);
-			if (!disk) return;
-			const keySessionsDir = this.resolveSessionsDirForKey(key);
-			const absPath = this.transcriptPathForEntry(disk, keySessionsDir);
-			const row = {
+			requireXopcDatabase();
+			ensureSessionRecord(key, this.resolveWorkspaceCwd(key));
+			appendTranscriptEntry(key, {
 				kind: "context",
 				id: typeof entry.id === "string" ? entry.id : void 0,
 				text: typeof entry.text === "string" ? entry.text : void 0,
 				data: entry.data,
 				createdAt: entry.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-			};
-			await appendPiTranscriptContextEntry({
-				absPath,
-				cwd: process.cwd(),
-				entry: row,
-				sessionKey: key
-			});
-			const llm = rowsToLlmMessages(existsSync(absPath) ? await readTranscriptRowsFromFile(absPath) : []);
-			await withSessionsJsonLock(this.resolveStorePathForKey(key), async (map) => {
-				const e = map[key];
-				if (!e?.pluginExtensions?.xopc?.metadata) return;
-				patchSessionsJsonEntryStats(e, buildSessionsJsonStatsPatch(llm.length, this.estimateTokens(llm)));
-				map[key] = e;
 			});
-			this.invalidateAllSessionsMapCache();
-			invalidateSessionSearchIndexCache();
 		});
 	}
-	/**
-	* Bulk write entry point used by compaction, tests, and admin tools.
-	* Runtime agent turns must persist via {@link guardSessionManager} + appendMessage.
-	*/
 	async saveMessages(key, messages) {
 		return this.runStoreMutation(async () => {
-			await this.ensureSession(key);
-			const merged = mergeLlmMessagesPreservingContextRows(await this.loadTranscriptRows(key), messages);
-			await this.writeTranscriptAndSyncIndex(key, merged);
+			requireXopcDatabase();
+			ensureSessionRecord(key, this.resolveWorkspaceCwd(key));
+			replaceTranscriptRows(key, mergeLlmMessagesPreservingContextRows(await this.loadTranscriptRows(key), messages));
 		});
 	}
 	getWindowStats(messages) {
@@ -833,62 +267,12 @@ var SessionStore = class {
 			stats: result
 		};
 	}
-	checkpointBasename(sessionId) {
-		return `${sessionId}.checkpoint.`;
-	}
-	async pruneCompactionCheckpoints(sessionId, sessionsDir) {
-		const MAX = 15;
-		const prefix = this.checkpointBasename(sessionId);
-		let names;
-		try {
-			names = await readdir(sessionsDir);
-		} catch {
-			return;
-		}
-		const candidates = names.filter((n) => n.startsWith(prefix) && n.endsWith(".jsonl"));
-		if (candidates.length <= MAX) return;
-		const stats = await Promise.all(candidates.map(async (name) => {
-			const p = join(sessionsDir, name);
-			try {
-				return {
-					p,
-					mtimeMs: (await stat(p)).mtimeMs
-				};
-			} catch {
-				return {
-					p: join(sessionsDir, name),
-					mtimeMs: 0
-				};
-			}
-		}));
-		stats.sort((a, b) => a.mtimeMs - b.mtimeMs);
-		for (let i = 0; i < stats.length - MAX; i++) try {
-			await unlink(stats[i].p);
-		} catch {}
-	}
-	async captureCompactionCheckpoint(sessionId, transcriptAbs, sessionsDir) {
-		if (!existsSync(transcriptAbs)) return;
-		const dest = join(sessionsDir, `${sessionId}.checkpoint.${randomUUID()}.jsonl`);
-		try {
-			await copyFile(transcriptAbs, dest);
-			await this.pruneCompactionCheckpoints(sessionId, sessionsDir);
-		} catch (err) {
-			log.warn({
-				err,
-				sessionId
-			}, "Compaction checkpoint copy failed");
-		}
-	}
 	async applyCompaction(key, messages, result) {
 		const compacted = this.compactor.applyCompaction(messages, result);
 		return this.runStoreMutation(async () => {
-			const entry = await this.getDiskEntry(key);
-			if (!entry) return compacted;
-			const keySessionsDir = this.resolveSessionsDirForKey(key);
-			const abs = this.transcriptPathForEntry(entry, keySessionsDir);
-			await this.captureCompactionCheckpoint(entry.sessionId, abs, keySessionsDir);
 			const merged = mergeLlmMessagesPreservingContextRows(await this.loadTranscriptRows(key), compacted);
-			await this.writeTranscriptAndSyncIndex(key, merged, { appendCompaction: {
+			captureCompactionCheckpoint(key);
+			replaceTranscriptRows(key, merged, { appendCompaction: {
 				at: (/* @__PURE__ */ new Date()).toISOString(),
 				summary: result.summary,
 				firstKeptIndex: result.firstKeptIndex,
@@ -923,72 +307,21 @@ var SessionStore = class {
 		};
 	}
 	async listCompactionCheckpoints(key) {
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return [];
-		const keySessionsDir = this.resolveSessionsDirForKey(key);
-		const sessionId = entry.sessionId;
-		const prefix = this.checkpointBasename(sessionId);
-		let names;
-		try {
-			names = await readdir(keySessionsDir);
-		} catch {
-			return [];
-		}
-		const files = names.filter((n) => n.startsWith(prefix) && n.endsWith(".jsonl"));
-		const valid = (await Promise.all(files.map(async (name) => {
-			const p = join(keySessionsDir, name);
-			const id = parseCompactionCheckpointTranscriptFileName(name)?.checkpointId;
-			if (!id || !normalizeCompactionCheckpointId(id)) return null;
-			try {
-				const s = await stat(p);
-				return {
-					id: normalizeCompactionCheckpointId(id),
-					sizeBytes: s.size,
-					modifiedAt: new Date(s.mtimeMs).toISOString()
-				};
-			} catch {
-				return null;
-			}
-		}))).filter((r) => r !== null);
-		valid.sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
-		return valid;
+		requireXopcDatabase();
+		return listCompactionCheckpoints(key);
 	}
 	async getCompactionCheckpointDetail(key, checkpointId) {
+		requireXopcDatabase();
 		const id = normalizeCompactionCheckpointId(checkpointId);
 		if (!id) return null;
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return null;
-		const cpPath = join(this.resolveSessionsDirForKey(key), `${this.checkpointBasename(entry.sessionId)}${id}.jsonl`);
-		if (!existsSync(cpPath)) return null;
-		try {
-			const llm = rowsToLlmMessages(await readTranscriptRowsFromFile(cpPath));
-			const s = await stat(cpPath);
-			return {
-				id,
-				sizeBytes: s.size,
-				modifiedAt: new Date(s.mtimeMs).toISOString(),
-				messageCount: llm.length
-			};
-		} catch {
-			return null;
-		}
+		return getCompactionCheckpointDetail(key, id);
 	}
 	async restoreCompactionCheckpoint(key, checkpointId) {
-		const id = normalizeCompactionCheckpointId(checkpointId);
-		if (!id) throw new Error("Invalid checkpoint id");
 		return this.runStoreMutation(async () => {
-			const entry = await this.getDiskEntry(key);
-			if (!entry) throw new Error(`Session not found: ${key}`);
-			const keySessionsDir = this.resolveSessionsDirForKey(key);
-			const cpPath = join(keySessionsDir, `${this.checkpointBasename(entry.sessionId)}${id}.jsonl`);
-			if (!existsSync(cpPath)) throw new Error(`Checkpoint not found: ${id}`);
-			await copyFile(cpPath, this.transcriptPathForEntry(entry, keySessionsDir));
-			const messages = await this.loadMessages(key);
-			await this.saveMessages(key, messages);
-			log.info({
-				key,
-				checkpointId: id
-			}, "Session transcript restored from compaction checkpoint");
+			requireXopcDatabase();
+			const id = normalizeCompactionCheckpointId(checkpointId);
+			if (!id) throw new Error(`Invalid checkpoint id: ${checkpointId}`);
+			restoreCompactionCheckpoint(key, id);
 		});
 	}
 	async deleteSession(key) {
@@ -1002,66 +335,34 @@ var SessionStore = class {
 	}
 	async searchInSession(key, keyword) {
 		const messages = await this.loadDisplayMessages(key);
-		const keywordLower = keyword.toLowerCase();
-		return this.convertMessages(messages.filter((m) => {
-			return this.extractTextContent(this.messageContent(m)).toLowerCase().includes(keywordLower);
-		}));
+		const q = keyword.toLowerCase();
+		return this.convertMessages(messages.filter((m) => this.extractTextContent(this.messageContent(m)).toLowerCase().includes(q)));
 	}
 	async exportSession(key, format) {
-		const detail = await this.get(key);
-		if (!detail) throw new Error(`Session not found: ${key}`);
-		if (format === "json") {
-			const transcriptRows = await this.loadTranscriptRows(key);
-			const exportData = {
-				version: INDEX_VERSION,
-				exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				metadata: detail,
-				messages: detail.messages,
-				transcriptRows
-			};
-			return JSON.stringify(exportData, null, 2);
-		}
+		const metadata = await this.getMetadata(key);
+		if (!metadata) throw new Error(`Session not found: ${key}`);
+		const rows = await this.loadTranscriptRows(key);
+		const messages = this.convertMessages(buildSessionContextForLlm(rows));
+		const payload = {
+			version: INDEX_VERSION,
+			exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			metadata,
+			messages,
+			transcriptRows: rows
+		};
+		if (format === "json") return JSON.stringify(payload, null, 2);
 		const lines = [
-			`# ${detail.name || detail.key}`,
-			"",
-			`- **Channel:** ${detail.sourceChannel}`,
-			`- **Created:** ${detail.createdAt}`,
-			`- **Messages:** ${detail.messageCount}`,
-			`- **Tags:** ${detail.tags.join(", ") || "none"}`,
+			`# ${metadata.name ?? metadata.key}`,
 			"",
-			"---",
+			`Exported: ${payload.exportedAt}`,
 			""
 		];
-		for (const msg of detail.messages) {
-			const role = msg.role === "assistant" ? "Assistant" : msg.role === "user" ? "User" : msg.role;
-			lines.push(`## ${role}`, "");
-			const body = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content, null, 2);
-			lines.push(body, "", "---", "");
-		}
+		for (const msg of messages) lines.push(`## ${msg.role}`, "", typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content), "");
 		return lines.join("\n");
 	}
 	async getStats() {
-		const sessions = (await this.list({ limit: 1e5 })).items;
-		const byChannel = {};
-		for (const s of sessions) byChannel[s.sourceChannel] = (byChannel[s.sourceChannel] || 0) + 1;
-		let oldestSession;
-		let newestSession;
-		if (sessions.length > 0) {
-			const sorted = [...sessions].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-			oldestSession = sorted[0].createdAt;
-			newestSession = sorted[sorted.length - 1].createdAt;
-		}
-		return {
-			totalSessions: sessions.length,
-			activeSessions: sessions.filter((s) => s.status === "active" || s.status === "idle").length,
-			archivedSessions: sessions.filter((s) => s.status === "archived").length,
-			pinnedSessions: sessions.filter((s) => s.status === "pinned").length,
-			totalMessages: sessions.reduce((sum, s) => sum + s.messageCount, 0),
-			totalTokens: sessions.reduce((sum, s) => sum + s.estimatedTokens, 0),
-			oldestSession,
-			newestSession,
-			byChannel
-		};
+		requireXopcDatabase();
+		return getGlobalSessionStats();
 	}
 	async archiveOld(olderThanDays) {
 		const cutoff = /* @__PURE__ */ new Date();
@@ -1077,17 +378,44 @@ var SessionStore = class {
 		return archived;
 	}
 	estimateTokens(messages) {
-		let total = 0;
-		for (const msg of messages) total += Math.ceil(this.extractTextContent(this.messageContent(msg)).length / 4);
-		return total;
+		return estimateTokensFromMessages(messages);
 	}
-	messageContent(msg) {
-		return msg.content;
+	async loadDisplayMessages(key) {
+		requireXopcDatabase();
+		const checkpoints = listCompactionCheckpoints(key);
+		const rowSets = [];
+		for (const checkpoint of [...checkpoints].reverse()) rowSets.push(loadCheckpointRows(key, checkpoint.id));
+		rowSets.push(await this.loadTranscriptRows(key));
+		const messages = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const rows of rowSets) for (const message of buildSessionContextForLlm(rows)) {
+			if (this.isCompactionSummaryMessage(message)) continue;
+			const identity = this.displayMessageIdentity(message);
+			if (seen.has(identity)) continue;
+			seen.add(identity);
+			messages.push(message);
+		}
+		return messages;
 	}
-	isCompactionSummaryMessage(msg) {
-		if (msg.role !== "user") return false;
-		const text = this.extractTextContent(this.messageContent(msg)).trim();
-		return /^\[Previous conversation summary\]/i.test(text);
+	paginateDisplayMessages(messages, options = {}) {
+		const total = messages.length;
+		const limit = Math.min(200, Math.max(1, Math.trunc(options.limit ?? 50)));
+		const offset = Math.max(0, Math.trunc(options.offset ?? 0));
+		let startIndex;
+		let endIndex;
+		if (options.beforeEndIndex !== void 0 && Number.isFinite(options.beforeEndIndex)) {
+			endIndex = Math.min(total, Math.max(0, Math.trunc(options.beforeEndIndex)));
+			startIndex = Math.max(0, endIndex - limit);
+		} else {
+			endIndex = Math.max(0, total - offset);
+			startIndex = Math.max(0, endIndex - limit);
+		}
+		return {
+			messages: messages.slice(startIndex, endIndex),
+			total,
+			startIndex,
+			endIndex
+		};
 	}
 	displayMessageIdentity(message) {
 		const record = message;
@@ -1099,6 +427,14 @@ var SessionStore = class {
 			content: this.messageContent(message)
 		});
 	}
+	messageContent(msg) {
+		return msg.content;
+	}
+	isCompactionSummaryMessage(msg) {
+		if (msg.role !== "user") return false;
+		const text = this.extractTextContent(this.messageContent(msg)).trim();
+		return /^\[Previous conversation summary\]/i.test(text);
+	}
 	extractTextContent(content) {
 		if (typeof content === "string") return content;
 		if (Array.isArray(content)) {
@@ -1119,22 +455,11 @@ var SessionStore = class {
 			sessionKey: key
 		});
 		if (!contextText?.trim()) return;
-		const entry = await this.getDiskEntry(key);
-		if (!entry) return;
-		const keySessionsDir = this.resolveSessionsDirForKey(key);
-		const abs = this.transcriptPathForEntry(entry, keySessionsDir);
-		const workspaceDir = resolveEffectiveAgentProfileForSession(this.options.config, key).resolvedWorkspacePath;
 		try {
-			await appendPiTranscriptContextEntry({
-				absPath: abs,
-				cwd: workspaceDir,
-				sessionKey: key,
-				entry: {
-					kind: "context",
-					id: `post-compaction-${Date.now()}`,
-					text: contextText,
-					createdAt: (/* @__PURE__ */ new Date()).toISOString()
-				}
+			await this.appendTranscriptContextEntry(key, {
+				id: `post-compaction-${Date.now()}`,
+				text: contextText,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
 			});
 		} catch (err) {
 			log.warn({
@@ -1161,7 +486,7 @@ var SessionStore = class {
 				const inputTokens = typeof rawUsage.input === "number" ? rawUsage.input : void 0;
 				const outputTokens = typeof rawUsage.output === "number" ? rawUsage.output : void 0;
 				const totalTokens = typeof rawUsage.totalTokens === "number" ? rawUsage.totalTokens : typeof rawUsage.total === "number" ? rawUsage.total : void 0;
-				if (inputTokens != null || outputTokens != null || totalTokens != null) row.usage = {
+				if (inputTokens !== void 0 || outputTokens !== void 0 || totalTokens !== void 0) row.usage = {
 					inputTokens,
 					outputTokens,
 					totalTokens