@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/storage/sqlite/transcript-repository.d.ts

@@ -9,7 +9,7 @@ export interface TranscriptSourceEntry {
     row: TranscriptStoredRow;
 }
 export interface CompactionSourceSnapshot {
-    sessionId: string;
+    transcriptId: string;
     lastSeq: number;
     entries: TranscriptSourceEntry[];
 }
@@ -20,22 +20,22 @@ export interface SessionTranscriptRecallMatch {
     createdAt: number;
     content: string;
 }
-export declare function appendTranscriptEntry(sessionKey: string, row: TranscriptStoredRow, opts?: {
-    sessionId?: string;
+export declare function appendTranscriptEntry(conversationId: string, row: TranscriptStoredRow, opts?: {
+    transcriptId?: string;
     tokenDelta?: number;
 }): TranscriptEntryRow;
-export declare function appendCompactionBoundaryIfUnchanged(sessionKey: string, expected: Pick<CompactionSourceSnapshot, 'sessionId' | 'lastSeq'>, row: Omit<XopcTranscriptCompactionEntry, 'baseSeq'>): TranscriptEntryRow | null;
-export declare function loadCompactionSourceSnapshot(sessionKey: string): CompactionSourceSnapshot | null;
-export declare function searchSessionTranscript(sessionKey: string, query: string, options?: {
+export declare function appendCompactionBoundaryIfUnchanged(conversationId: string, expected: Pick<CompactionSourceSnapshot, 'transcriptId' | 'lastSeq'>, row: Omit<XopcTranscriptCompactionEntry, 'baseSeq'>): TranscriptEntryRow | null;
+export declare function loadCompactionSourceSnapshot(conversationId: string): CompactionSourceSnapshot | null;
+export declare function searchSessionTranscript(conversationId: string, query: string, options?: {
     limit?: number;
     beforeSeq?: number;
 }): SessionTranscriptRecallMatch[];
-export declare function loadTranscriptRowsForSession(sessionKey: string): TranscriptStoredRow[];
-export declare function loadTranscriptHistoryRowsForSession(sessionKey: string): TranscriptStoredRow[];
-export declare function loadTranscriptRows(sessionId: string): TranscriptStoredRow[];
-export declare function loadLlmMessagesForSession(sessionKey: string): AgentMessage[];
-export declare function replaceTranscriptRows(sessionKey: string, rows: TranscriptStoredRow[]): void;
-export declare function paginateTranscriptMessages(sessionKey: string, options?: {
+export declare function loadTranscriptRowsForSession(conversationId: string): TranscriptStoredRow[];
+export declare function loadTranscriptHistoryRowsForSession(conversationId: string): TranscriptStoredRow[];
+export declare function loadTranscriptRows(transcriptId: string): TranscriptStoredRow[];
+export declare function loadLlmMessagesForSession(conversationId: string): AgentMessage[];
+export declare function replaceTranscriptRows(conversationId: string, rows: TranscriptStoredRow[]): void;
+export declare function paginateTranscriptMessages(conversationId: string, options?: {
     offset?: number;
     limit?: number;
     beforeIndex?: number;
@@ -49,5 +49,5 @@ export declare function paginateTranscriptMessages(sessionKey: string, options?:
     startSeq: number;
     endSeq: number;
 };
-export declare function listCompactionBoundaries(sessionKey: string): CompactionBoundarySummary[];
-export declare function restoreBeforeCompactionBoundary(sessionKey: string, compactionId: string): void;
+export declare function listCompactionBoundaries(conversationId: string): CompactionBoundarySummary[];
+export declare function restoreBeforeCompactionBoundary(conversationId: string, compactionId: string): void;

package/dist/src/storage/sqlite/transcript-repository.js

@@ -1,28 +1,33 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { readCurrentSessionId } from "./session-instance-repository.js";
-import { buildSessionContextForLlm, isRuntimeOnlyTranscriptMessage } from "../../session/session-context-for-llm.js";
-import { classifyStoredRow, estimateTokensFromMessages, extractFtsContent, transcriptEntryRowToStoredRow } from "./row-mappers.js";
-import { escapeFts5Query } from "./fts.js";
-import { getCurrentSessionId } from "./session-repository.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { readCurrentTranscriptId } from "./session-instance-repository.js";
+import { buildSessionContextForLlm, init_session_context_for_llm, isRuntimeOnlyTranscriptMessage } from "../../session/session-context-for-llm.js";
+import { classifyStoredRow, estimateTokensFromMessages, extractFtsContent, init_row_mappers, transcriptEntryRowToStoredRow } from "./row-mappers.js";
+import { escapeFts5Query, init_fts } from "./fts.js";
+import { getCurrentTranscriptId, init_session_repository } from "./session-repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/transcript-repository.ts
-function nextSeq(db, sessionId) {
-	return (db.prepare(`SELECT COALESCE(MAX(seq), 0) AS max_seq FROM transcript_entries WHERE session_id = ?`).get(sessionId).max_seq ?? 0) + 1;
+init_session_context_for_llm();
+init_row_mappers();
+init_session_repository();
+init_fts();
+init_transaction();
+function nextSeq(db, transcriptId) {
+	return (db.prepare(`SELECT COALESCE(MAX(seq), 0) AS max_seq FROM transcript_entries WHERE transcript_id = ?`).get(transcriptId).max_seq ?? 0) + 1;
 }
 function insertEntry(db, params) {
 	const { entryKind, role } = classifyStoredRow(params.row);
 	const entryId = params.entryId ?? randomUUID();
-	const seq = nextSeq(db, params.sessionId);
+	const seq = nextSeq(db, params.transcriptId);
 	const createdAt = params.createdAt ?? Date.now();
 	const payloadJson = JSON.stringify(params.row);
-	db.prepare(`INSERT INTO transcript_entries (entry_id, session_id, seq, entry_kind, role, payload_json, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(entryId, params.sessionId, seq, entryKind, role, payloadJson, createdAt);
+	db.prepare(`INSERT INTO transcript_entries (entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(entryId, params.transcriptId, seq, entryKind, role, payloadJson, createdAt);
 	const content = extractFtsContent(params.row);
-	if (content.trim()) db.prepare(`INSERT INTO transcript_fts (content, session_key, session_id, entry_id)
-       VALUES (?, ?, ?, ?)`).run(content, params.sessionKey, params.sessionId, entryId);
+	if (content.trim()) db.prepare(`INSERT INTO transcript_fts (content, conversation_id, transcript_id, entry_id)
+       VALUES (?, ?, ?, ?)`).run(content, params.conversationId, params.transcriptId, entryId);
 	return {
 		entry_id: entryId,
-		session_id: params.sessionId,
+		transcript_id: params.transcriptId,
 		seq,
 		entry_kind: entryKind,
 		role,
@@ -34,7 +39,7 @@ function isUserMessageRow(row) {
 	const classified = classifyStoredRow(row);
 	return classified.entryKind === "message" && classified.role === "user";
 }
-function withSessionInputContextMetadata(db, sessionKey, row) {
+function withSessionInputContextMetadata(db, conversationId, row) {
 	if (!isUserMessageRow(row)) return row;
 	const message = row;
 	const turnId = typeof message.turnId === "string" ? message.turnId.trim() : "";
@@ -42,8 +47,8 @@ function withSessionInputContextMetadata(db, sessionKey, row) {
 	const metadata = message.metadata && typeof message.metadata === "object" && !Array.isArray(message.metadata) ? message.metadata : {};
 	if (Array.isArray(metadata.sourceContexts) && metadata.sourceContexts.length > 0) return row;
 	const input = db.prepare(`SELECT context_refs_json FROM session_inputs
-     WHERE session_key = ? AND run_id = ? AND context_refs_json IS NOT NULL
-     LIMIT 1`).get(sessionKey, turnId);
+     WHERE conversation_id = ? AND run_id = ? AND context_refs_json IS NOT NULL
+     LIMIT 1`).get(conversationId, turnId);
 	if (!input) return row;
 	try {
 		const sourceContexts = JSON.parse(input.context_refs_json);
@@ -59,15 +64,15 @@ function withSessionInputContextMetadata(db, sessionKey, row) {
 		return row;
 	}
 }
-function appendTranscriptEntry(sessionKey, row, opts) {
+function appendTranscriptEntry(conversationId, row, opts) {
 	if (isRuntimeOnlyTranscriptMessage(row)) throw new Error("Runtime-only messages cannot be persisted in a session transcript");
 	return runSqliteWriteTransaction((db) => {
-		const sessionId = opts?.sessionId ?? readCurrentSessionId(db, sessionKey);
-		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
-		const persistedRow = withSessionInputContextMetadata(db, sessionKey, row);
+		const transcriptId = opts?.transcriptId ?? readCurrentTranscriptId(db, conversationId);
+		if (!transcriptId) throw new Error(`Session not found: ${conversationId}`);
+		const persistedRow = withSessionInputContextMetadata(db, conversationId, row);
 		const inserted = insertEntry(db, {
-			sessionId,
-			sessionKey,
+			transcriptId,
+			conversationId,
 			row: persistedRow
 		});
 		if (classifyStoredRow(persistedRow).entryKind === "message") {
@@ -81,24 +86,24 @@ function appendTranscriptEntry(sessionKey, row, opts) {
           updated_at = ?,
           last_accessed_at = ?,
           last_interaction_at = ?
-        WHERE session_key = ?`).run(tokenDelta, now, now, now, sessionKey);
+        WHERE conversation_id = ?`).run(tokenDelta, now, now, now, conversationId);
 		}
 		return inserted;
 	});
 }
-function appendCompactionBoundaryIfUnchanged(sessionKey, expected, row) {
+function appendCompactionBoundaryIfUnchanged(conversationId, expected, row) {
 	return runSqliteWriteTransaction((db) => {
-		const sessionId = readCurrentSessionId(db, sessionKey);
-		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
-		if (sessionId !== expected.sessionId) return null;
-		if (nextSeq(db, sessionId) - 1 !== expected.lastSeq) return null;
+		const transcriptId = readCurrentTranscriptId(db, conversationId);
+		if (!transcriptId) throw new Error(`Session not found: ${conversationId}`);
+		if (transcriptId !== expected.transcriptId) return null;
+		if (nextSeq(db, transcriptId) - 1 !== expected.lastSeq) return null;
 		const boundary = {
 			...row,
 			baseSeq: expected.lastSeq
 		};
 		const inserted = insertEntry(db, {
-			sessionId,
-			sessionKey,
+			transcriptId,
+			conversationId,
 			row: boundary
 		});
 		const now = Date.now();
@@ -109,20 +114,20 @@ function appendCompactionBoundaryIfUnchanged(sessionKey, expected, row) {
         updated_at = ?,
         last_accessed_at = ?,
         last_interaction_at = ?
-       WHERE session_key = ?`).run(boundary.messages.length, boundary.tokensAfter, now, now, now, sessionKey);
+       WHERE conversation_id = ?`).run(boundary.messages.length, boundary.tokensAfter, now, now, now, conversationId);
 		return inserted;
 	});
 }
-function loadCompactionSourceSnapshot(sessionKey) {
+function loadCompactionSourceSnapshot(conversationId) {
 	const db = getSqliteDatabase();
-	const sessionId = getCurrentSessionId(sessionKey);
-	if (!sessionId) return null;
-	const rows = db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+	const transcriptId = getCurrentTranscriptId(conversationId);
+	if (!transcriptId) return null;
+	const rows = db.prepare(`SELECT entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at
        FROM transcript_entries
-       WHERE session_id = ?
-       ORDER BY seq ASC`).all(sessionId);
+       WHERE transcript_id = ?
+       ORDER BY seq ASC`).all(transcriptId);
 	return {
-		sessionId,
+		transcriptId,
 		lastSeq: rows.at(-1)?.seq ?? 0,
 		entries: rows.map((entry) => ({
 			entryId: entry.entry_id,
@@ -132,32 +137,32 @@ function loadCompactionSourceSnapshot(sessionKey) {
 		}))
 	};
 }
-function searchSessionTranscript(sessionKey, query, options = {}) {
-	const sessionId = getCurrentSessionId(sessionKey);
+function searchSessionTranscript(conversationId, query, options = {}) {
+	const transcriptId = getCurrentTranscriptId(conversationId);
 	const normalized = query.trim();
-	if (!sessionId || !normalized) return [];
+	if (!transcriptId || !normalized) return [];
 	const limit = Math.min(20, Math.max(1, options.limit ?? 8));
 	const beforeSeq = options.beforeSeq ?? Number.MAX_SAFE_INTEGER;
 	const db = getSqliteDatabase();
 	const ftsRows = db.prepare(`SELECT e.entry_id, e.seq, e.role, e.created_at, f.content
        FROM transcript_fts f
        JOIN transcript_entries e
-         ON e.session_id = f.session_id AND e.entry_id = f.entry_id
+         ON e.transcript_id = f.transcript_id AND e.entry_id = f.entry_id
        WHERE transcript_fts MATCH ?
-         AND f.session_id = ?
+         AND f.transcript_id = ?
          AND e.entry_kind <> 'compaction'
          AND e.seq < ?
        ORDER BY bm25(transcript_fts), e.seq DESC
-       LIMIT ?`).all(escapeFts5Query(normalized), sessionId, beforeSeq, limit);
+       LIMIT ?`).all(escapeFts5Query(normalized), transcriptId, beforeSeq, limit);
 	const escapedLike = normalized.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
 	const literalRows = db.prepare(`SELECT entry_id, seq, role, created_at, payload_json AS content
        FROM transcript_entries
-       WHERE session_id = ?
+       WHERE transcript_id = ?
          AND entry_kind <> 'compaction'
          AND seq < ?
          AND payload_json LIKE ? ESCAPE '\\'
        ORDER BY seq DESC
-       LIMIT ?`).all(sessionId, beforeSeq, `%${escapedLike}%`, limit);
+       LIMIT ?`).all(transcriptId, beforeSeq, `%${escapedLike}%`, limit);
 	const seen = /* @__PURE__ */ new Set();
 	return [...ftsRows, ...literalRows].flatMap((row) => {
 		const result = row;
@@ -172,48 +177,48 @@ function searchSessionTranscript(sessionKey, query, options = {}) {
 		}];
 	}).slice(0, limit);
 }
-function loadTranscriptRowsForSession(sessionKey) {
-	const sessionId = getCurrentSessionId(sessionKey);
-	if (!sessionId) return [];
-	return loadTranscriptRows(sessionId);
+function loadTranscriptRowsForSession(conversationId) {
+	const transcriptId = getCurrentTranscriptId(conversationId);
+	if (!transcriptId) return [];
+	return loadTranscriptRows(transcriptId);
 }
-function loadTranscriptHistoryRowsForSession(sessionKey) {
-	if (!getCurrentSessionId(sessionKey)) return [];
-	return getSqliteDatabase().prepare(`SELECT e.entry_id, e.session_id, e.seq, e.entry_kind, e.role, e.payload_json, e.created_at
+function loadTranscriptHistoryRowsForSession(conversationId) {
+	if (!getCurrentTranscriptId(conversationId)) return [];
+	return getSqliteDatabase().prepare(`SELECT e.entry_id, e.transcript_id, e.seq, e.entry_kind, e.role, e.payload_json, e.created_at
        FROM transcript_entries e
-       JOIN transcripts t ON t.session_id = e.session_id
-       WHERE t.session_key = ?
+       JOIN transcripts t ON t.transcript_id = e.transcript_id
+       WHERE t.conversation_id = ?
          AND (t.status = 'active' OR t.archive_reason IN ('reset', 'stale'))
-       ORDER BY t.created_at ASC, t.rowid ASC, e.seq ASC`).all(sessionKey).map(transcriptEntryRowToStoredRow);
+       ORDER BY t.created_at ASC, t.rowid ASC, e.seq ASC`).all(conversationId).map(transcriptEntryRowToStoredRow);
 }
-function loadTranscriptRows(sessionId) {
-	return getSqliteDatabase().prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+function loadTranscriptRows(transcriptId) {
+	return getSqliteDatabase().prepare(`SELECT entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at
        FROM transcript_entries
-       WHERE session_id = ?
-       ORDER BY seq ASC`).all(sessionId).map(transcriptEntryRowToStoredRow);
+       WHERE transcript_id = ?
+       ORDER BY seq ASC`).all(transcriptId).map(transcriptEntryRowToStoredRow);
 }
-function loadLlmMessagesForSession(sessionKey) {
-	const sessionId = getCurrentSessionId(sessionKey);
-	if (!sessionId) return [];
-	return buildSessionContextForLlm(getSqliteDatabase().prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+function loadLlmMessagesForSession(conversationId) {
+	const transcriptId = getCurrentTranscriptId(conversationId);
+	if (!transcriptId) return [];
+	return buildSessionContextForLlm(getSqliteDatabase().prepare(`SELECT entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at
        FROM transcript_entries
-       WHERE session_id = ?
+       WHERE transcript_id = ?
          AND seq >= COALESCE(
-           (SELECT MAX(seq) FROM transcript_entries WHERE session_id = ? AND entry_kind = 'compaction'),
+           (SELECT MAX(seq) FROM transcript_entries WHERE transcript_id = ? AND entry_kind = 'compaction'),
            1
          )
-       ORDER BY seq ASC`).all(sessionId, sessionId).map(transcriptEntryRowToStoredRow));
+       ORDER BY seq ASC`).all(transcriptId, transcriptId).map(transcriptEntryRowToStoredRow));
 }
-function replaceTranscriptRows(sessionKey, rows) {
+function replaceTranscriptRows(conversationId, rows) {
 	if (rows.some(isRuntimeOnlyTranscriptMessage)) throw new Error("Runtime-only messages cannot be persisted in a session transcript");
 	runSqliteWriteTransaction((db) => {
-		const sessionId = readCurrentSessionId(db, sessionKey);
-		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
-		db.prepare(`DELETE FROM transcript_fts WHERE session_id = ?`).run(sessionId);
-		db.prepare(`DELETE FROM transcript_entries WHERE session_id = ?`).run(sessionId);
+		const transcriptId = readCurrentTranscriptId(db, conversationId);
+		if (!transcriptId) throw new Error(`Session not found: ${conversationId}`);
+		db.prepare(`DELETE FROM transcript_fts WHERE transcript_id = ?`).run(transcriptId);
+		db.prepare(`DELETE FROM transcript_entries WHERE transcript_id = ?`).run(transcriptId);
 		for (const row of rows) insertEntry(db, {
-			sessionId,
-			sessionKey,
+			transcriptId,
+			conversationId,
 			row
 		});
 		const llm = buildSessionContextForLlm(rows);
@@ -226,12 +231,12 @@ function replaceTranscriptRows(sessionKey, rows) {
         updated_at = ?,
         last_accessed_at = ?,
         last_interaction_at = ?
-      WHERE session_key = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, sessionKey);
+      WHERE conversation_id = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, conversationId);
 	});
 }
-function paginateTranscriptMessages(sessionKey, options = {}) {
-	const sessionId = getCurrentSessionId(sessionKey);
-	if (!sessionId) return {
+function paginateTranscriptMessages(conversationId, options = {}) {
+	const transcriptId = getCurrentTranscriptId(conversationId);
+	if (!transcriptId) return {
 		rows: [],
 		messages: [],
 		total: 0,
@@ -242,11 +247,11 @@ function paginateTranscriptMessages(sessionKey, options = {}) {
 	const kinds = options.includeContext ? ["message", "context"] : ["message"];
 	const kindPlaceholders = kinds.map(() => "?").join(", ");
 	const includeArchived = options.includeArchived === true;
-	const transcriptWhere = includeArchived ? `t.session_key = ? AND (t.status = 'active' OR t.archive_reason IN ('reset', 'stale'))` : "e.session_id = ?";
-	const transcriptArg = includeArchived ? sessionKey : sessionId;
+	const transcriptWhere = includeArchived ? `t.conversation_id = ? AND (t.status = 'active' OR t.archive_reason IN ('reset', 'stale'))` : "e.transcript_id = ?";
+	const transcriptArg = includeArchived ? conversationId : transcriptId;
 	const total = db.prepare(`SELECT COUNT(*) AS total
        FROM transcript_entries e
-       JOIN transcripts t ON t.session_id = e.session_id
+       JOIN transcripts t ON t.transcript_id = e.transcript_id
        WHERE ${transcriptWhere} AND e.entry_kind IN (${kindPlaceholders})`).get(transcriptArg, ...kinds).total;
 	const limit = Math.min(200, Math.max(1, Math.trunc(options.limit ?? 50)));
 	const offset = Math.max(0, Math.trunc(options.offset ?? 0));
@@ -254,20 +259,20 @@ function paginateTranscriptMessages(sessionKey, options = {}) {
 	if (options.beforeIndex !== void 0 && Number.isFinite(options.beforeIndex)) {
 		const endExclusive = Math.min(total, Math.max(0, Math.trunc(options.beforeIndex)));
 		const startInclusive = Math.max(0, endExclusive - limit);
-		rows = db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+		rows = db.prepare(`SELECT entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at
          FROM (
-           SELECT e.entry_id, e.session_id, e.seq, e.entry_kind, e.role, e.payload_json, e.created_at,
+           SELECT e.entry_id, e.transcript_id, e.seq, e.entry_kind, e.role, e.payload_json, e.created_at,
                   ROW_NUMBER() OVER (ORDER BY t.created_at ASC, t.rowid ASC, e.seq ASC) - 1 AS idx
            FROM transcript_entries e
-           JOIN transcripts t ON t.session_id = e.session_id
+           JOIN transcripts t ON t.transcript_id = e.transcript_id
            WHERE ${transcriptWhere} AND e.entry_kind IN (${kindPlaceholders})
          )
          WHERE idx >= ? AND idx < ?
          ORDER BY idx ASC`).all(transcriptArg, ...kinds, startInclusive, endExclusive);
 	} else {
-		rows = db.prepare(`SELECT e.entry_id, e.session_id, e.seq, e.entry_kind, e.role, e.payload_json, e.created_at
+		rows = db.prepare(`SELECT e.entry_id, e.transcript_id, e.seq, e.entry_kind, e.role, e.payload_json, e.created_at
          FROM transcript_entries e
-         JOIN transcripts t ON t.session_id = e.session_id
+         JOIN transcripts t ON t.transcript_id = e.transcript_id
          WHERE ${transcriptWhere} AND e.entry_kind IN (${kindPlaceholders})
          ORDER BY t.created_at DESC, t.rowid DESC, e.seq DESC
          LIMIT ? OFFSET ?`).all(transcriptArg, ...kinds, limit, offset);
@@ -282,14 +287,14 @@ function paginateTranscriptMessages(sessionKey, options = {}) {
 		endSeq: rows[rows.length - 1]?.seq ?? 0
 	};
 }
-function listCompactionBoundaries(sessionKey) {
+function listCompactionBoundaries(conversationId) {
 	const db = getSqliteDatabase();
-	const sessionId = getCurrentSessionId(sessionKey);
-	if (!sessionId) return [];
+	const transcriptId = getCurrentTranscriptId(conversationId);
+	if (!transcriptId) return [];
 	return db.prepare(`SELECT entry_id, seq, payload_json, created_at
        FROM transcript_entries
-       WHERE session_id = ? AND entry_kind = 'compaction'
-       ORDER BY seq DESC`).all(sessionId).map((row) => {
+       WHERE transcript_id = ? AND entry_kind = 'compaction'
+       ORDER BY seq DESC`).all(transcriptId).map((row) => {
 		const payload = JSON.parse(row.payload_json);
 		return {
 			id: row.entry_id,
@@ -303,22 +308,22 @@ function listCompactionBoundaries(sessionKey) {
 		};
 	});
 }
-function restoreBeforeCompactionBoundary(sessionKey, compactionId) {
+function restoreBeforeCompactionBoundary(conversationId, compactionId) {
 	runSqliteWriteTransaction((db) => {
-		const sessionId = readCurrentSessionId(db, sessionKey);
-		if (!sessionId) throw new Error(`Session not found: ${sessionKey}`);
+		const transcriptId = readCurrentTranscriptId(db, conversationId);
+		if (!transcriptId) throw new Error(`Session not found: ${conversationId}`);
 		const boundary = db.prepare(`SELECT seq FROM transcript_entries
-         WHERE session_id = ? AND entry_id = ? AND entry_kind = 'compaction'`).get(sessionId, compactionId);
+         WHERE transcript_id = ? AND entry_id = ? AND entry_kind = 'compaction'`).get(transcriptId, compactionId);
 		if (!boundary) throw new Error(`Compaction boundary not found: ${compactionId}`);
 		const removedEntryIds = db.prepare(`SELECT entry_id
          FROM transcript_entries
-         WHERE session_id = ? AND seq >= ?`).all(sessionId, boundary.seq);
+         WHERE transcript_id = ? AND seq >= ?`).all(transcriptId, boundary.seq);
 		for (const entry of removedEntryIds) db.prepare(`DELETE FROM transcript_fts WHERE entry_id = ?`).run(entry.entry_id);
-		db.prepare(`DELETE FROM transcript_entries WHERE session_id = ? AND seq >= ?`).run(sessionId, boundary.seq);
-		const remainingEntries = db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+		db.prepare(`DELETE FROM transcript_entries WHERE transcript_id = ? AND seq >= ?`).run(transcriptId, boundary.seq);
+		const remainingEntries = db.prepare(`SELECT entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at
          FROM transcript_entries
-         WHERE session_id = ?
-         ORDER BY seq ASC`).all(sessionId);
+         WHERE transcript_id = ?
+         ORDER BY seq ASC`).all(transcriptId);
 		const restoredMessages = buildSessionContextForLlm(remainingEntries.map(transcriptEntryRowToStoredRow));
 		if (restoredMessages.length === 0) throw new Error(`No restorable context exists before compaction boundary: ${compactionId}`);
 		const tokensAfter = estimateTokensFromMessages(restoredMessages);
@@ -331,7 +336,7 @@ function restoreBeforeCompactionBoundary(sessionKey, compactionId) {
         updated_at = ?,
         last_accessed_at = ?,
         last_interaction_at = ?
-      WHERE session_key = ?`).run(restoredMessages.length, tokensAfter, compactedCount, now, now, now, sessionKey);
+      WHERE conversation_id = ?`).run(restoredMessages.length, tokensAfter, compactedCount, now, now, now, conversationId);
 	});
 }
 //#endregion

package/dist/src/storage/sqlite/user-people-repository.js

@@ -1,6 +1,7 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
 import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
 //#region src/storage/sqlite/user-people-repository.ts
+init_transaction();
 function sourceMetadata(sourceInstanceId) {
 	if (!sourceInstanceId.startsWith("composio:")) return {};
 	const connectorId = sourceInstanceId.split(":")[1];

package/dist/src/storage/sqlite/user-trust-repository.js

@@ -1,6 +1,7 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
 import { DEFAULT_USER_TRUST_LEVEL, isUserTrustLevel } from "../../user-context/trust-policy.js";
 //#region src/storage/sqlite/user-trust-repository.ts
+init_transaction();
 function fromRow(row) {
 	return {
 		principalId: row.principal_id,

package/dist/src/support/collect-support-report.js

@@ -32,8 +32,8 @@ function sanitizeDoctorCheck(check, redactor) {
 }
 function sanitizeLogEntry(entry, redactor) {
 	redactor.addIdentifier(entry.requestId, "request");
-	redactor.addIdentifier(entry.sessionKey, "session");
-	redactor.addIdentifier(entry.sessionId, "session");
+	redactor.addIdentifier(entry.conversationId, "session");
+	redactor.addIdentifier(entry.transcriptId, "session");
 	const meta = asRecord(entry.meta);
 	const error = asRecord(entry.err) ?? asRecord(meta?.err);
 	const phase = typeof entry.phase === "string" ? entry.phase : typeof meta?.phase === "string" ? meta.phase : void 0;
@@ -49,7 +49,7 @@ function sanitizeLogEntry(entry, redactor) {
 		module: redactor.text(entry.module, 300),
 		phase: redactor.text(phase, 300),
 		requestId: redactor.identifier(entry.requestId, "request"),
-		sessionId: redactor.identifier(entry.sessionId, "session"),
+		transcriptId: redactor.identifier(entry.transcriptId, "session"),
 		...sanitizedError && Object.values(sanitizedError).some(Boolean) ? { error: sanitizedError } : {}
 	};
 }
@@ -72,14 +72,14 @@ async function collectRelevantLogs(params) {
 		});
 		if (logs.length > 0) return logs;
 	}
-	if (params.input.sessionKey) {
+	if (params.input.conversationId) {
 		const logs = await params.query({
 			...base,
-			sessionKey: params.input.sessionKey
+			conversationId: params.input.conversationId
 		});
 		if (logs.length > 0) return logs;
 	}
-	if (params.input.requestId || params.input.sessionKey) return [];
+	if (params.input.requestId || params.input.conversationId) return [];
 	return params.query(base);
 }
 function codeBlock(value) {
@@ -146,7 +146,7 @@ async function collectSupportReport(input, deps = {}) {
 		}
 	};
 	redactor.addIdentifier(input.requestId, "request");
-	redactor.addIdentifier(input.sessionKey, "session");
+	redactor.addIdentifier(input.conversationId, "session");
 	let rawLogs = [];
 	let logCollectionError;
 	try {

package/dist/src/support/types.d.ts

@@ -4,7 +4,7 @@ export declare const SupportReportInputSchema: z.ZodObject<{
     expected: z.ZodOptional<z.ZodString>;
     reproduction: z.ZodOptional<z.ZodString>;
     occurredAt: z.ZodOptional<z.ZodString>;
-    sessionKey: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
     requestId: z.ZodOptional<z.ZodString>;
     clientContext: z.ZodOptional<z.ZodObject<{
         currentPage: z.ZodOptional<z.ZodString>;
@@ -31,7 +31,7 @@ export type SupportLogEntry = {
     module?: string;
     phase?: string;
     requestId?: string;
-    sessionId?: string;
+    transcriptId?: string;
     error?: {
         name?: string;
         message?: string;

package/dist/src/support/types.js

@@ -5,7 +5,7 @@ const SupportReportInputSchema = z.object({
 	expected: z.string().trim().max(5e3).optional(),
 	reproduction: z.string().trim().max(1e4).optional(),
 	occurredAt: z.string().datetime().optional(),
-	sessionKey: z.string().trim().max(1e3).optional(),
+	conversationId: z.string().trim().max(1e3).optional(),
 	requestId: z.string().trim().max(1e3).optional(),
 	clientContext: z.object({
 		currentPage: z.string().trim().max(2e3).optional(),

package/dist/src/tasks/execution-context.d.ts

@@ -4,7 +4,7 @@ export type ExecutionOrigin = 'chat' | 'task' | 'workflow' | 'automation' | 'bro
 export type ExecutionTrigger = 'user' | 'schedule' | 'webhook' | 'proactive' | 'retry';
 export interface ExecutionContext {
     runId: string;
-    sessionKey: string;
+    conversationId: string;
     channel: string;
     agentId?: string;
     executionEnvironmentId?: string;
@@ -18,7 +18,7 @@ export interface ExecutionContext {
 }
 export declare function resolveExecutionContext(input: {
     runId: string;
-    sessionKey: string;
+    conversationId: string;
     channel: string;
     metadata: SessionMetadata;
     agentId?: string;

package/dist/src/tasks/execution-context.js

@@ -39,11 +39,11 @@ function metadataTrigger(metadata) {
 	return "user";
 }
 function resolveExecutionContext(input) {
-	const taskId = isXopcDatabaseOpen() ? new TaskConversationRepository().resolveActiveExecutionSession(input.sessionKey)?.taskId : void 0;
-	const environment = getExecutionEnvironmentForSession(input.sessionKey);
+	const taskId = isXopcDatabaseOpen() ? new TaskConversationRepository().resolveActiveExecutionSession(input.conversationId)?.taskId : void 0;
+	const environment = getExecutionEnvironmentForSession(input.conversationId);
 	return {
 		runId: input.runId,
-		sessionKey: input.sessionKey,
+		conversationId: input.conversationId,
 		channel: input.channel,
 		agentId: input.agentId,
 		...environment ? {

package/dist/src/tasks/home-query-service.d.ts

@@ -12,7 +12,7 @@ type HomeWorkflowRun = {
     definitionId: string;
     title: string;
     status: WorkflowRunSummary['status'];
-    sessionKey?: string;
+    conversationId?: string;
     createdAtMs: number;
     startedAtMs?: number;
     completedAtMs?: number;
@@ -32,7 +32,7 @@ interface HomeGatewayPort {
     readonly proactiveInbox: ProactiveInboxService;
     readonly sessions: {
         listActiveRuns(): Array<{
-            sessionKey: string;
+            conversationId: string;
             runId: string;
         }>;
         getSession(key: string): Promise<{

package/dist/src/tasks/home-query-service.js

@@ -15,7 +15,7 @@ function toHomeWorkflowRun(run) {
 		definitionId: run.definitionId,
 		title: run.title,
 		status: run.status,
-		sessionKey: run.metadata?.sessionKey,
+		conversationId: run.metadata?.conversationId,
 		createdAtMs: run.createdAtMs,
 		startedAtMs: run.startedAtMs,
 		completedAtMs: run.completedAtMs,
@@ -221,7 +221,7 @@ function buildHomeWorkbench(input) {
 		const openAction = {
 			type: "open",
 			label: copy.viewProgress,
-			href: run.sessionKey ? `/chat/${encodeURIComponent(run.sessionKey)}` : `/workflows?runId=${encodeURIComponent(run.id)}`
+			href: run.conversationId ? `/chat/${encodeURIComponent(run.conversationId)}` : `/workflows?runId=${encodeURIComponent(run.id)}`
 		};
 		return {
 			id: `workflow:${run.id}`,
@@ -308,14 +308,14 @@ var HomeQueryService = class {
 			})),
 			Promise.all(activeRuns.map(async (run) => ({
 				...run,
-				session: await this.service.sessions.getSession(run.sessionKey)
+				session: await this.service.sessions.getSession(run.conversationId)
 			})))
 		]);
 		const runningConversations = activeRunSessions.filter((item) => Boolean(item.session)).map((item) => {
 			const session = item.session;
 			const updatedAt = Date.parse(session.lastInteractionAt ?? session.updatedAt);
 			return {
-				sessionKey: item.sessionKey,
+				conversationId: item.conversationId,
 				runId: item.runId,
 				...session.name?.trim() ? { title: session.name.trim() } : {},
 				...session.routing?.agentId ? { agentId: session.routing.agentId } : {},
@@ -382,7 +382,7 @@ var HomeQueryService = class {
 			reason: run.status === "timeout" ? "run_timeout" : "run_failed",
 			href: `/workflows?runId=${encodeURIComponent(run.id)}`,
 			updatedAt: run.completedAtMs ?? run.startedAtMs ?? run.createdAtMs,
-			sessionKey: run.sessionKey
+			conversationId: run.conversationId
 		})), ...latestAutomationRuns.filter((run) => run.status === "failed" || run.status === "timeout").filter((run) => automationsById.get(run.automationId)?.notificationPolicy !== "none").filter((run) => !isHomeAttentionAcknowledged("automation_run", run.id)).map((run) => ({
 			id: `automation_run:${run.id}`,
 			kind: "automation_run",
@@ -392,7 +392,7 @@ var HomeQueryService = class {
 			reason: run.status === "timeout" ? "run_timeout" : "run_failed",
 			href: `/automations?run=${encodeURIComponent(run.id)}`,
 			updatedAt: run.endedAtMs ?? run.startedAtMs ?? run.createdAtMs,
-			sessionKey: run.sessionKey
+			conversationId: run.conversationId
 		}))].sort((left, right) => right.updatedAt - left.updatedAt);
 		const governed = this.#attentionGovernor.project({
 			decisions: decisionCandidates,