@xopcai/xopc 0.0.285 → 0.0.286

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

@@ -1,40 +1,26 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { readCurrentSessionId } from "./session-instance-repository.js";
-import { buildDefaultSessionMetadata } from "./session-metadata.js";
-import { buildGlobalSessionStats, metadataToSessionInsert, sessionRowToMetadata } from "./row-mappers.js";
-import { cancelConnectionObjective } from "./connection-wait-repository.js";
-import { notifyUserContextChange } from "../../user-context/changes.js";
-import { validateSessionId } from "../../session/session-id.js";
-import { SESSION_PURPOSE_SQL, SESSION_SOURCE_SQL } from "./session-identity-sql.js";
-import { buildFts5SearchQuery } from "./fts.js";
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { validateConversationId, validateTranscriptId } from "../../../packages/gateway-contract/src/conversation-identity.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { init_session_instance_repository, readCurrentTranscriptId } from "./session-instance-repository.js";
+import { buildDefaultSessionMetadata, init_session_metadata } from "./session-metadata.js";
+import { buildGlobalSessionStats, init_row_mappers, metadataToSessionInsert, sessionRowToMetadata } from "./row-mappers.js";
+import { cancelConnectionObjective, init_connection_wait_repository } from "./connection-wait-repository.js";
+import { init_changes, notifyUserContextChange } from "../../user-context/changes.js";
+import { SESSION_PURPOSE_SQL, SESSION_SOURCE_SQL, init_session_identity_sql } from "./session-identity-sql.js";
+import { buildFts5SearchQuery, init_fts } from "./fts.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/session-repository.ts
-const SESSION_COLUMNS = `
-  s.session_key, s.agent_id, s.session_id, s.status, s.name, s.tags_json,
-  s.created_at, s.updated_at, s.last_accessed_at, s.session_started_at, s.last_interaction_at,
-  s.source_channel, s.source_chat_id, s.session_type, s.hidden_from_session_list,
-  s.parent_session_key, s.workflow_run_id, s.workflow_definition_id, s.workflow_agent_id, s.workflow_agent_label,
-  s.project_id, s.routing_json, s.custom_data_json,
-  s.message_count, s.estimated_tokens, s.compacted_count,
-  s.last_flushed_at, s.flush_count,
-  s.thinking_level, s.verbose_level,
-  t.cwd AS cwd
-`;
-const SESSION_FROM_JOIN = `
-  FROM sessions s
-  LEFT JOIN transcripts t ON t.session_id = s.session_id
-`;
-const SELECT_SESSION = `SELECT ${SESSION_COLUMNS} ${SESSION_FROM_JOIN} WHERE s.session_key = ?`;
-function readSessionRow(db, sessionKey) {
-	return db.prepare(SELECT_SESSION).get(sessionKey);
+function readSessionRow(db, conversationId) {
+	return db.prepare(SELECT_SESSION).get(conversationId);
 }
-function insertSessionAndTranscript(db, sessionKey, sessionId, cwd, metadata) {
-	const row = metadataToSessionInsert(sessionKey, sessionId, metadata);
+function insertSessionAndTranscript(db, conversationId, transcriptId, cwd, metadata) {
+	const row = metadataToSessionInsert(conversationId, transcriptId, metadata);
 	db.prepare(`INSERT INTO sessions (
-      session_key, agent_id, session_id, status, name, tags_json,
+      conversation_id, agent_id, active_transcript_id, status, name, tags_json,
       created_at, updated_at, last_accessed_at, session_started_at, last_interaction_at,
       source_channel, source_chat_id, session_type, hidden_from_session_list,
-      parent_session_key, workflow_run_id, workflow_definition_id, workflow_agent_id, workflow_agent_label,
+      parent_conversation_id, workflow_run_id, workflow_definition_id, workflow_agent_id, workflow_agent_label,
       project_id, routing_json, custom_data_json,
       message_count, estimated_tokens, compacted_count,
       last_flushed_at, flush_count,
@@ -47,32 +33,39 @@ function insertSessionAndTranscript(db, sessionKey, sessionId, cwd, metadata) {
       ?, ?, ?,
       ?, ?, ?, ?, ?, ?,
       ?, ?
-    )`).run(row.sessionKey, row.agentId, row.sessionId, row.status, row.name, row.tagsJson, row.createdAt, row.updatedAt, row.lastAccessedAt, row.sessionStartedAt, row.lastInteractionAt, row.sourceChannel, row.sourceChatId, row.sessionType, row.hiddenFromSessionList, row.parentSessionKey, row.workflowRunId, row.workflowDefinitionId, row.workflowAgentId, row.workflowAgentLabel, row.projectId, row.routingJson, row.customDataJson, row.messageCount, row.estimatedTokens, row.compactedCount, row.lastFlushedAt, row.flushCount, row.thinkingLevel, row.verboseLevel);
+    )`).run(row.conversationId, row.agentId, row.transcriptId, row.status, row.name, row.tagsJson, row.createdAt, row.updatedAt, row.lastAccessedAt, row.sessionStartedAt, row.lastInteractionAt, row.sourceChannel, row.sourceChatId, row.sessionType, row.hiddenFromSessionList, row.parentConversationId, row.workflowRunId, row.workflowDefinitionId, row.workflowAgentId, row.workflowAgentLabel, row.projectId, row.routingJson, row.customDataJson, row.messageCount, row.estimatedTokens, row.compactedCount, row.lastFlushedAt, row.flushCount, row.thinkingLevel, row.verboseLevel);
 	const now = Date.now();
-	db.prepare(`INSERT INTO transcripts (session_id, session_key, status, created_at, cwd)
-     VALUES (?, ?, 'active', ?, ?)`).run(sessionId, sessionKey, now, cwd);
+	db.prepare(`INSERT INTO transcripts (transcript_id, conversation_id, status, created_at, cwd)
+     VALUES (?, ?, 'active', ?, ?)`).run(transcriptId, conversationId, now, cwd);
 }
-function ensureSessionInTransaction(db, sessionKey, cwd, seed) {
-	const existing = readSessionRow(db, sessionKey);
-	if (existing) return sessionRowToMetadata(sessionKey, existing);
-	const sessionId = validateSessionId(randomUUID());
-	const metadata = buildDefaultSessionMetadata(sessionKey, seed);
-	metadata.sessionId = sessionId;
-	insertSessionAndTranscript(db, sessionKey, sessionId, cwd, metadata);
-	const row = readSessionRow(db, sessionKey);
-	if (!row) throw new Error(`Failed to create session: ${sessionKey}`);
-	return sessionRowToMetadata(sessionKey, row);
+function ensureSessionInTransaction(db, conversationId, cwd, seed) {
+	validateConversationId(conversationId);
+	const existing = readSessionRow(db, conversationId);
+	if (existing) {
+		if (!existing.cwd && cwd) {
+			db.prepare("UPDATE transcripts SET cwd=? WHERE transcript_id=?").run(cwd, existing.active_transcript_id);
+			existing.cwd = cwd;
+		}
+		return sessionRowToMetadata(conversationId, existing);
+	}
+	const transcriptId = validateTranscriptId(randomUUID());
+	const metadata = buildDefaultSessionMetadata(conversationId, seed);
+	metadata.transcriptId = transcriptId;
+	insertSessionAndTranscript(db, conversationId, transcriptId, cwd, metadata);
+	const row = readSessionRow(db, conversationId);
+	if (!row) throw new Error(`Failed to create session: ${conversationId}`);
+	return sessionRowToMetadata(conversationId, row);
 }
-function ensureSessionRecord(sessionKey, cwd, seed) {
-	return runSqliteWriteTransaction((db) => ensureSessionInTransaction(db, sessionKey, cwd, seed));
+function ensureSessionRecord(conversationId, cwd, seed) {
+	return runSqliteWriteTransaction((db) => ensureSessionInTransaction(db, conversationId, cwd, seed));
 }
-function getSessionMetadata(sessionKey) {
-	const row = readSessionRow(getSqliteDatabase(), sessionKey);
+function getSessionMetadata(conversationId) {
+	const row = readSessionRow(getSqliteDatabase(), conversationId);
 	if (!row) return null;
-	return sessionRowToMetadata(sessionKey, row);
+	return sessionRowToMetadata(conversationId, row);
 }
-function getCurrentSessionId(sessionKey) {
-	return readCurrentSessionId(getSqliteDatabase(), sessionKey);
+function getCurrentTranscriptId(conversationId) {
+	return readCurrentTranscriptId(getSqliteDatabase(), conversationId);
 }
 function listSessionMetadata(query = {}) {
 	const db = getSqliteDatabase();
@@ -114,10 +107,10 @@ function listSessionMetadata(query = {}) {
 		const clauses = [`s.updated_at >= ?`];
 		params.push(query.updatedAfter);
 		if (query.includePinned) clauses.push(`s.status = 'pinned'`);
-		const includeSessionKey = query.includeSessionKey?.trim();
-		if (includeSessionKey) {
-			clauses.push(`s.session_key = ?`);
-			params.push(includeSessionKey);
+		const includeConversationId = query.includeConversationId?.trim();
+		if (includeConversationId) {
+			clauses.push(`s.conversation_id = ?`);
+			params.push(includeConversationId);
 		}
 		conditions.push(`(${clauses.join(" OR ")})`);
 	}
@@ -145,9 +138,9 @@ function listSessionMetadata(query = {}) {
 	if (query.search?.trim()) {
 		const rawSearch = query.search.trim();
 		const like = `%${rawSearch.toLowerCase()}%`;
-		conditions.push(`(s.session_key IN (
-      SELECT session_key FROM transcript_fts WHERE transcript_fts MATCH ?
-    ) OR LOWER(s.session_key) LIKE ?
+		conditions.push(`(s.conversation_id IN (
+      SELECT conversation_id FROM transcript_fts WHERE transcript_fts MATCH ?
+    ) OR LOWER(s.conversation_id) LIKE ?
       OR LOWER(COALESCE(s.name, '')) LIKE ?
       OR LOWER(s.source_channel) LIKE ?
       OR LOWER(s.source_chat_id) LIKE ?
@@ -162,8 +155,8 @@ function listSessionMetadata(query = {}) {
 	const offset = query.offset ?? 0;
 	return {
 		items: db.prepare(`SELECT ${SESSION_COLUMNS} ${SESSION_FROM_JOIN} ${where}
-       ORDER BY ${sortColumn} ${sortOrder}, s.session_key ASC
-       LIMIT ? OFFSET ?`).all(...params, limit, offset).map((row) => sessionRowToMetadata(row.session_key, row)),
+       ORDER BY ${sortColumn} ${sortOrder}, s.conversation_id ASC
+       LIMIT ? OFFSET ?`).all(...params, limit, offset).map((row) => sessionRowToMetadata(row.conversation_id, row)),
 		total,
 		limit,
 		offset,
@@ -178,18 +171,20 @@ function sessionSortColumn(sortBy) {
 		default: return "s.updated_at";
 	}
 }
-function patchSessionMetadata(sessionKey, updates) {
+function patchSessionMetadata(conversationId, updates) {
 	if ("projectId" in updates) notifyUserContextChange({
 		kind: "session-reset",
-		id: sessionKey
+		id: conversationId
 	});
 	return runSqliteWriteTransaction((db) => {
-		const existing = readSessionRow(db, sessionKey);
-		if (!existing) throw new Error(`Session not found: ${sessionKey}`);
+		const existing = readSessionRow(db, conversationId);
+		if (!existing) throw new Error(`Session not found: ${conversationId}`);
+		const requestedAgentId = updates.agentId ?? updates.routing?.agentId;
+		if (requestedAgentId && requestedAgentId.trim().toLowerCase() !== existing.agent_id) throw new Error("Changing a conversation agent requires a new conversation");
 		const merged = {
-			...sessionRowToMetadata(sessionKey, existing),
+			...sessionRowToMetadata(conversationId, existing),
 			...updates,
-			key: sessionKey
+			key: conversationId
 		};
 		const now = Date.now();
 		db.prepare(`UPDATE sessions SET
@@ -204,7 +199,7 @@ function patchSessionMetadata(sessionKey, updates) {
         source_chat_id = ?,
         session_type = ?,
         hidden_from_session_list = ?,
-        parent_session_key = ?,
+        parent_conversation_id = ?,
         workflow_run_id = ?,
         workflow_definition_id = ?,
         workflow_agent_id = ?,
@@ -219,13 +214,13 @@ function patchSessionMetadata(sessionKey, updates) {
         flush_count = ?,
         thinking_level = ?,
         verbose_level = ?
-      WHERE session_key = ?`).run(merged.status, merged.name ?? null, JSON.stringify(merged.tags ?? []), Date.parse(merged.updatedAt) || now, Date.parse(merged.lastAccessedAt) || now, merged.sessionStartedAt ? Date.parse(merged.sessionStartedAt) : existing.session_started_at, merged.lastInteractionAt ? Date.parse(merged.lastInteractionAt) : existing.last_interaction_at, merged.sourceChannel, merged.sourceChatId, merged.sessionType, merged.hiddenFromSessionList ? 1 : 0, merged.parentSessionKey ?? null, merged.workflowRunId ?? null, merged.workflowDefinitionId ?? null, merged.workflowAgentId ?? null, merged.workflowAgentLabel ?? null, merged.projectId ?? null, merged.routing ? JSON.stringify(merged.routing) : null, merged.customData ? JSON.stringify(merged.customData) : null, merged.messageCount, merged.estimatedTokens, merged.compactedCount, merged.lastFlushedAt ?? null, merged.flushCount ?? 0, existing.thinking_level, existing.verbose_level, sessionKey);
-		const row = readSessionRow(db, sessionKey);
-		if (!row) throw new Error(`Session not found after patch: ${sessionKey}`);
-		return sessionRowToMetadata(sessionKey, row);
+      WHERE conversation_id = ?`).run(merged.status, merged.name ?? null, JSON.stringify(merged.tags ?? []), Date.parse(merged.updatedAt) || now, Date.parse(merged.lastAccessedAt) || now, merged.sessionStartedAt ? Date.parse(merged.sessionStartedAt) : existing.session_started_at, merged.lastInteractionAt ? Date.parse(merged.lastInteractionAt) : existing.last_interaction_at, merged.sourceChannel, merged.sourceChatId, merged.sessionType, merged.hiddenFromSessionList ? 1 : 0, merged.parentConversationId ?? null, merged.workflowRunId ?? null, merged.workflowDefinitionId ?? null, merged.workflowAgentId ?? null, merged.workflowAgentLabel ?? null, merged.projectId ?? null, merged.routing ? JSON.stringify(merged.routing) : null, merged.customData ? JSON.stringify(merged.customData) : null, merged.messageCount, merged.estimatedTokens, merged.compactedCount, merged.lastFlushedAt ?? null, merged.flushCount ?? 0, existing.thinking_level, existing.verbose_level, conversationId);
+		const row = readSessionRow(db, conversationId);
+		if (!row) throw new Error(`Session not found after patch: ${conversationId}`);
+		return sessionRowToMetadata(conversationId, row);
 	});
 }
-function updateSessionStats(sessionKey, stats) {
+function updateSessionStats(conversationId, stats) {
 	runSqliteWriteTransaction((db) => {
 		const now = stats.lastInteractionAt ?? Date.now();
 		db.prepare(`UPDATE sessions SET
@@ -234,10 +229,10 @@ function updateSessionStats(sessionKey, stats) {
         updated_at = ?,
         last_accessed_at = ?,
         last_interaction_at = ?
-      WHERE session_key = ?`).run(stats.messageCount, stats.estimatedTokens, now, now, now, sessionKey);
+      WHERE conversation_id = ?`).run(stats.messageCount, stats.estimatedTokens, now, now, now, conversationId);
 	});
 }
-function incrementSessionStatsOnAppend(sessionKey, tokenDelta = 0) {
+function incrementSessionStatsOnAppend(conversationId, tokenDelta = 0) {
 	runSqliteWriteTransaction((db) => {
 		const now = Date.now();
 		db.prepare(`UPDATE sessions SET
@@ -246,70 +241,70 @@ function incrementSessionStatsOnAppend(sessionKey, tokenDelta = 0) {
         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);
 	});
 }
-function resetSessionRecord(sessionKey, cwd) {
+function resetSessionRecord(conversationId, cwd) {
 	notifyUserContextChange({
 		kind: "session-reset",
-		id: sessionKey
+		id: conversationId
 	});
 	return runSqliteWriteTransaction((db) => {
-		const existing = readSessionRow(db, sessionKey);
+		const existing = readSessionRow(db, conversationId);
 		if (!existing) return null;
-		cancelConnectionObjective(sessionKey);
-		const previousSessionId = existing.session_id;
+		cancelConnectionObjective(conversationId);
+		const previousTranscriptId = existing.active_transcript_id;
 		const now = Date.now();
 		db.prepare(`UPDATE transcripts SET status = 'archived', archive_reason = 'reset', archived_at = ?
-       WHERE session_id = ?`).run(now, previousSessionId);
-		const newSessionId = validateSessionId(randomUUID());
-		db.prepare(`INSERT INTO transcripts (session_id, session_key, status, created_at, cwd)
-       VALUES (?, ?, 'active', ?, ?)`).run(newSessionId, sessionKey, now, cwd);
+       WHERE transcript_id = ?`).run(now, previousTranscriptId);
+		const newTranscriptId = validateTranscriptId(randomUUID());
+		db.prepare(`INSERT INTO transcripts (transcript_id, conversation_id, status, created_at, cwd)
+       VALUES (?, ?, 'active', ?, ?)`).run(newTranscriptId, conversationId, now, cwd);
 		db.prepare(`UPDATE sessions SET
-        session_id = ?,
+        active_transcript_id = ?,
         updated_at = ?,
         session_started_at = ?,
         last_interaction_at = NULL,
         message_count = 0,
         estimated_tokens = 0
-      WHERE session_key = ?`).run(newSessionId, now, now, sessionKey);
+      WHERE conversation_id = ?`).run(newTranscriptId, now, now, conversationId);
 		return {
-			sessionId: newSessionId,
-			previousSessionId
+			transcriptId: newTranscriptId,
+			previousTranscriptId
 		};
 	});
 }
-function deleteSessionRecord(sessionKey) {
+function deleteSessionRecord(conversationId) {
 	notifyUserContextChange({
 		kind: "session-reset",
-		id: sessionKey
+		id: conversationId
 	});
 	return runSqliteWriteTransaction((db) => {
-		const existing = readSessionRow(db, sessionKey);
+		const existing = readSessionRow(db, conversationId);
 		if (!existing) return false;
 		const now = Date.now();
 		db.prepare(`UPDATE transcripts SET status = 'archived', archive_reason = 'delete', archived_at = ?
-       WHERE session_id = ?`).run(now, existing.session_id);
-		cancelConnectionObjective(sessionKey);
-		db.prepare(`DELETE FROM sessions WHERE session_key = ?`).run(sessionKey);
+       WHERE transcript_id = ?`).run(now, existing.active_transcript_id);
+		cancelConnectionObjective(conversationId);
+		db.prepare(`DELETE FROM sessions WHERE conversation_id = ?`).run(conversationId);
 		return true;
 	});
 }
 function listSessionsByAgent(agentId) {
 	return getSqliteDatabase().prepare(`SELECT ${SESSION_COLUMNS} ${SESSION_FROM_JOIN}
        WHERE s.agent_id = ?
-       ORDER BY s.updated_at DESC`).all(agentId.toLowerCase()).map((row) => sessionRowToMetadata(row.session_key, row));
+       ORDER BY s.updated_at DESC`).all(agentId.toLowerCase()).map((row) => sessionRowToMetadata(row.conversation_id, row));
 }
-function getSessionPersistedLevels(sessionKey) {
-	const row = getSqliteDatabase().prepare(`SELECT thinking_level, verbose_level FROM sessions WHERE session_key = ?`).get(sessionKey);
+function getSessionPersistedLevels(conversationId) {
+	const row = getSqliteDatabase().prepare(`SELECT thinking_level, verbose_level FROM sessions WHERE conversation_id = ?`).get(conversationId);
 	if (!row) return null;
 	return {
 		thinkingLevel: row.thinking_level,
 		verboseLevel: row.verbose_level
 	};
 }
-function findSessionKeyBySessionId(sessionId) {
-	return getSqliteDatabase().prepare(`SELECT session_key FROM sessions WHERE session_id = ?`).get(sessionId)?.session_key ?? null;
+function findConversationIdByTranscriptId(transcriptId) {
+	return getSqliteDatabase().prepare(`SELECT conversation_id FROM sessions WHERE active_transcript_id = ?`).get(transcriptId)?.conversation_id ?? null;
 }
 function getGlobalSessionStats() {
 	return buildGlobalSessionStats(listSessionMetadata({
@@ -317,8 +312,37 @@ function getGlobalSessionStats() {
 		offset: 0
 	}).items);
 }
-function resolveSessionAgentId(sessionKey) {
-	return getSessionMetadata(sessionKey)?.routing?.agentId ?? "main";
+function resolveSessionAgentId(conversationId) {
+	return getSessionMetadata(conversationId)?.routing?.agentId ?? "main";
 }
+var SESSION_COLUMNS, SESSION_FROM_JOIN, SELECT_SESSION;
+var init_session_repository = __esmMin((() => {
+	init_connection_wait_repository();
+	init_src();
+	init_changes();
+	init_session_metadata();
+	init_session_instance_repository();
+	init_row_mappers();
+	init_transaction();
+	init_session_identity_sql();
+	init_fts();
+	SESSION_COLUMNS = `
+  s.conversation_id, s.agent_id, s.active_transcript_id, s.status, s.name, s.tags_json,
+  s.created_at, s.updated_at, s.last_accessed_at, s.session_started_at, s.last_interaction_at,
+  s.source_channel, s.source_chat_id, s.session_type, s.hidden_from_session_list,
+  s.parent_conversation_id, s.workflow_run_id, s.workflow_definition_id, s.workflow_agent_id, s.workflow_agent_label,
+  s.project_id, s.routing_json, s.custom_data_json,
+  s.message_count, s.estimated_tokens, s.compacted_count,
+  s.last_flushed_at, s.flush_count,
+  s.thinking_level, s.verbose_level,
+  t.cwd AS cwd
+`;
+	SESSION_FROM_JOIN = `
+  FROM sessions s
+  LEFT JOIN transcripts t ON t.transcript_id = s.active_transcript_id
+`;
+	SELECT_SESSION = `SELECT ${SESSION_COLUMNS} ${SESSION_FROM_JOIN} WHERE s.conversation_id = ?`;
+}));
 //#endregion
-export { deleteSessionRecord, ensureSessionInTransaction, ensureSessionRecord, findSessionKeyBySessionId, getCurrentSessionId, getGlobalSessionStats, getSessionMetadata, getSessionPersistedLevels, incrementSessionStatsOnAppend, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, readCurrentSessionId, resetSessionRecord, resolveSessionAgentId, updateSessionStats };
+init_session_repository();
+export { deleteSessionRecord, ensureSessionInTransaction, ensureSessionRecord, findConversationIdByTranscriptId, getCurrentTranscriptId, getGlobalSessionStats, getSessionMetadata, getSessionPersistedLevels, incrementSessionStatsOnAppend, init_session_repository, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, readCurrentTranscriptId, resetSessionRecord, resolveSessionAgentId, updateSessionStats };

package/dist/src/storage/sqlite/session-task-plan-repository.d.ts

@@ -5,15 +5,15 @@ export type SessionTaskPlanItem = {
     status: SessionTaskPlanItemStatus;
 };
 export type SessionTaskPlan = {
-    sessionId: string;
+    transcriptId: string;
     planId: string;
     items: SessionTaskPlanItem[];
     revision: number;
     updatedAt: number;
 };
-export declare function getSessionTaskPlan(sessionKey: string, planId?: string): SessionTaskPlan | undefined;
+export declare function getSessionTaskPlan(conversationId: string, planId?: string): SessionTaskPlan | undefined;
 export declare function setSessionTaskPlan(input: {
-    sessionKey: string;
+    conversationId: string;
     planId?: string;
     items: SessionTaskPlanItem[];
     now?: number;

package/dist/src/storage/sqlite/session-task-plan-repository.js

@@ -1,6 +1,8 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { getCurrentSessionId } from "./session-repository.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { getCurrentTranscriptId, init_session_repository } from "./session-repository.js";
 //#region src/storage/sqlite/session-task-plan-repository.ts
+init_session_repository();
+init_transaction();
 const VALID_STATUSES = new Set([
 	"pending",
 	"in_progress",
@@ -29,47 +31,47 @@ function parseItems(value) {
 }
 function fromRow(row) {
 	return {
-		sessionId: row.session_id,
+		transcriptId: row.transcript_id,
 		planId: row.plan_id,
 		items: parseItems(row.items_json),
 		revision: row.revision,
 		updatedAt: row.updated_at
 	};
 }
-function getSessionTaskPlan(sessionKey, planId = "todo") {
-	const sessionId = getCurrentSessionId(sessionKey);
-	if (!sessionId) return void 0;
-	const row = getSqliteDatabase().prepare(`SELECT session_id, plan_id, items_json, revision, updated_at
+function getSessionTaskPlan(conversationId, planId = "todo") {
+	const transcriptId = getCurrentTranscriptId(conversationId);
+	if (!transcriptId) return void 0;
+	const row = getSqliteDatabase().prepare(`SELECT transcript_id, plan_id, items_json, revision, updated_at
      FROM session_task_plans
-     WHERE session_id = ? AND plan_id = ?`).get(sessionId, planId);
+     WHERE transcript_id = ? AND plan_id = ?`).get(transcriptId, planId);
 	return row ? fromRow(row) : void 0;
 }
 function setSessionTaskPlan(input) {
 	const planId = input.planId?.trim() || "todo";
 	if (!input.items.some((item) => item.status === "pending" || item.status === "in_progress")) {
-		deleteSessionTaskPlan(input.sessionKey, planId);
+		deleteSessionTaskPlan(input.conversationId, planId);
 		return;
 	}
-	const sessionId = getCurrentSessionId(input.sessionKey);
-	if (!sessionId) return void 0;
+	const transcriptId = getCurrentTranscriptId(input.conversationId);
+	if (!transcriptId) return void 0;
 	const now = input.now ?? Date.now();
 	runSqliteWriteTransaction((db) => {
-		db.prepare(`INSERT INTO session_task_plans (session_id, plan_id, items_json, revision, updated_at)
+		db.prepare(`INSERT INTO session_task_plans (transcript_id, plan_id, items_json, revision, updated_at)
        VALUES (?, ?, ?, 1, ?)
-       ON CONFLICT(session_id, plan_id) DO UPDATE SET
+       ON CONFLICT(transcript_id, plan_id) DO UPDATE SET
          items_json = excluded.items_json,
          revision = session_task_plans.revision + 1,
-         updated_at = excluded.updated_at`).run(sessionId, planId, JSON.stringify(input.items), now);
+         updated_at = excluded.updated_at`).run(transcriptId, planId, JSON.stringify(input.items), now);
 	});
-	return getSessionTaskPlan(input.sessionKey, planId);
+	return getSessionTaskPlan(input.conversationId, planId);
 }
-function deleteSessionTaskPlan(sessionKey, planId = "todo") {
-	const sessionId = getCurrentSessionId(sessionKey);
-	if (!sessionId) return false;
+function deleteSessionTaskPlan(conversationId, planId = "todo") {
+	const transcriptId = getCurrentTranscriptId(conversationId);
+	if (!transcriptId) return false;
 	let deleted = false;
 	runSqliteWriteTransaction((db) => {
 		deleted = db.prepare(`DELETE FROM session_task_plans
-       WHERE session_id = ? AND plan_id = ?`).run(sessionId, planId).changes > 0;
+       WHERE transcript_id = ? AND plan_id = ?`).run(transcriptId, planId).changes > 0;
 	});
 	return deleted;
 }

package/dist/src/storage/sqlite/session-turn-replace-repository.d.ts

@@ -2,7 +2,7 @@ import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { TurnOrigin } from '@xopcai/endpoint-tools-protocol';
 import type { AgentSourceContext, SourceContextRefSummary } from '../../agent/source-context/types.js';
 export type ReplaceLatestSessionTurnInput = {
-    sessionKey: string;
+    conversationId: string;
     targetTurnId: string;
     clientMessageId: string;
     content: string;
@@ -23,7 +23,7 @@ export type ReplaceLatestSessionTurnResult = {
     code: 'TARGET_NOT_FOUND' | 'NOT_LATEST' | 'SESSION_BUSY';
 };
 /** Validate before aborting a run; the transactional mutation validates again. */
-export declare function validateLatestSessionTurnTarget(sessionKey: string, targetTurnId: string): {
+export declare function validateLatestSessionTurnTarget(conversationId: string, targetTurnId: string): {
     ok: true;
 } | {
     ok: false;

package/dist/src/storage/sqlite/session-turn-replace-repository.js

@@ -1,9 +1,13 @@
-import { getXopcDatabase } from "./connection.js";
-import { runSqliteWriteTransaction } from "./transaction.js";
-import { buildSessionContextForLlm, buildSessionDisplayMessages } from "../../session/session-context-for-llm.js";
-import { estimateTokensFromMessages, transcriptEntryRowToStoredRow } from "./row-mappers.js";
+import { getXopcDatabase, init_connection } from "./connection.js";
+import { init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { buildSessionContextForLlm, buildSessionDisplayMessages, init_session_context_for_llm } from "../../session/session-context-for-llm.js";
+import { estimateTokensFromMessages, init_row_mappers, transcriptEntryRowToStoredRow } from "./row-mappers.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/session-turn-replace-repository.ts
+init_session_context_for_llm();
+init_row_mappers();
+init_connection();
+init_transaction();
 function isUserRow(row) {
 	return row.role === "user";
 }
@@ -27,15 +31,15 @@ function validateTargetRows(rows, targetTurnId) {
 	};
 }
 /** Validate before aborting a run; the transactional mutation validates again. */
-function validateLatestSessionTurnTarget(sessionKey, targetTurnId) {
+function validateLatestSessionTurnTarget(conversationId, targetTurnId) {
 	const { db } = getXopcDatabase();
-	const session = db.prepare(`SELECT session_id FROM sessions WHERE session_key = ?`).get(sessionKey);
+	const session = db.prepare(`SELECT active_transcript_id AS transcript_id FROM sessions WHERE conversation_id = ?`).get(conversationId);
 	if (!session) return {
 		ok: false,
 		code: "TARGET_NOT_FOUND"
 	};
-	const result = validateTargetRows(db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
-       FROM transcript_entries WHERE session_id = ? ORDER BY seq ASC`).all(session.session_id).map(transcriptEntryRowToStoredRow), targetTurnId);
+	const result = validateTargetRows(db.prepare(`SELECT entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at
+       FROM transcript_entries WHERE transcript_id = ? ORDER BY seq ASC`).all(session.transcript_id).map(transcriptEntryRowToStoredRow), targetTurnId);
 	return result.ok ? { ok: true } : result;
 }
 /**
@@ -45,7 +49,7 @@ function validateLatestSessionTurnTarget(sessionKey, targetTurnId) {
 */
 function replaceLatestSessionTurnAndQueueInput(input) {
 	return runSqliteWriteTransaction((db) => {
-		const existing = db.prepare(`SELECT id FROM session_inputs WHERE session_key = ? AND client_message_id = ?`).get(input.sessionKey, input.clientMessageId);
+		const existing = db.prepare(`SELECT id FROM session_inputs WHERE conversation_id = ? AND client_message_id = ?`).get(input.conversationId, input.clientMessageId);
 		if (existing) return {
 			ok: true,
 			idempotent: true,
@@ -53,23 +57,23 @@ function replaceLatestSessionTurnAndQueueInput(input) {
 			removedMessages: [],
 			remainingMessages: []
 		};
-		const session = db.prepare(`SELECT session_id FROM sessions WHERE session_key = ?`).get(input.sessionKey);
+		const session = db.prepare(`SELECT active_transcript_id AS transcript_id FROM sessions WHERE conversation_id = ?`).get(input.conversationId);
 		if (!session) return {
 			ok: false,
 			code: "TARGET_NOT_FOUND"
 		};
-		db.prepare(`INSERT INTO session_input_runtime(session_key, revision, updated_at_ms)
-       VALUES (?, 0, ?) ON CONFLICT(session_key) DO NOTHING`).run(input.sessionKey, Date.now());
-		const runtime = db.prepare(`SELECT active_run_id FROM session_input_runtime WHERE session_key = ?`).get(input.sessionKey);
+		db.prepare(`INSERT INTO session_input_runtime(conversation_id, revision, updated_at_ms)
+       VALUES (?, 0, ?) ON CONFLICT(conversation_id) DO NOTHING`).run(input.conversationId, Date.now());
+		const runtime = db.prepare(`SELECT active_run_id FROM session_input_runtime WHERE conversation_id = ?`).get(input.conversationId);
 		const pending = db.prepare(`SELECT 1 AS found FROM session_inputs
-         WHERE session_key = ? AND status IN ('queued', 'running', 'injecting', 'interrupted')
-         LIMIT 1`).get(input.sessionKey);
+         WHERE conversation_id = ? AND status IN ('queued', 'running', 'injecting', 'interrupted')
+         LIMIT 1`).get(input.conversationId);
 		if (runtime?.active_run_id || pending) return {
 			ok: false,
 			code: "SESSION_BUSY"
 		};
-		const entries = db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
-         FROM transcript_entries WHERE session_id = ? ORDER BY seq ASC`).all(session.session_id);
+		const entries = db.prepare(`SELECT entry_id, transcript_id, seq, entry_kind, role, payload_json, created_at
+         FROM transcript_entries WHERE transcript_id = ? ORDER BY seq ASC`).all(session.transcript_id);
 		const target = validateTargetRows(entries.map(transcriptEntryRowToStoredRow), input.targetTurnId);
 		if (target.ok === false) return target;
 		const targetSeq = entries[target.targetIndex].seq;
@@ -87,17 +91,17 @@ function replaceLatestSessionTurnAndQueueInput(input) {
 		const llm = buildSessionContextForLlm(remainingRows);
 		const now = Date.now();
 		db.prepare(`UPDATE sessions SET message_count = ?, estimated_tokens = ?, compacted_count = 0,
-       updated_at = ?, last_accessed_at = ?, last_interaction_at = ? WHERE session_key = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, input.sessionKey);
+       updated_at = ?, last_accessed_at = ?, last_interaction_at = ? WHERE conversation_id = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, input.conversationId);
 		const maxPosition = db.prepare(`SELECT COALESCE(MAX(position), 0) AS value FROM session_inputs
-         WHERE session_key = ? AND status IN ('queued', 'running', 'injecting', 'interrupted')`).get(input.sessionKey);
+         WHERE conversation_id = ? AND status IN ('queued', 'running', 'injecting', 'interrupted')`).get(input.conversationId);
 		const inputId = randomUUID();
-		db.prepare(`INSERT INTO session_inputs(id, session_key, client_message_id,
+		db.prepare(`INSERT INTO session_inputs(id, conversation_id, client_message_id,
        requested_delivery, effective_delivery, status, content, attachments_json,
        context_refs_json, context_snapshots_json, thinking, origin_json, position,
        target_run_id, version, created_at_ms, updated_at_ms)
-       VALUES (?, ?, ?, 'next', 'next', 'queued', ?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?)`).run(inputId, input.sessionKey, input.clientMessageId, input.content, input.attachments ? JSON.stringify(input.attachments) : null, input.contextRefs ? JSON.stringify(input.contextRefs) : null, input.contextSnapshots ? JSON.stringify(input.contextSnapshots) : null, input.thinking ?? null, JSON.stringify(input.origin), maxPosition.value + 1, now, now);
+       VALUES (?, ?, ?, 'next', 'next', 'queued', ?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?)`).run(inputId, input.conversationId, input.clientMessageId, input.content, input.attachments ? JSON.stringify(input.attachments) : null, input.contextRefs ? JSON.stringify(input.contextRefs) : null, input.contextSnapshots ? JSON.stringify(input.contextSnapshots) : null, input.thinking ?? null, JSON.stringify(input.origin), maxPosition.value + 1, now, now);
 		db.prepare(`UPDATE session_input_runtime SET revision = revision + 1, updated_at_ms = ?
-       WHERE session_key = ?`).run(now, input.sessionKey);
+       WHERE conversation_id = ?`).run(now, input.conversationId);
 		return {
 			ok: true,
 			idempotent: false,

package/dist/src/storage/sqlite/transaction.js

@@ -1,13 +1,10 @@
-import { getXopcDatabase } from "./connection.js";
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { getXopcDatabase, init_connection } from "./connection.js";
 //#region src/storage/sqlite/transaction.ts
-const RETRYABLE_COMMIT_CODES = new Set(["SQLITE_BUSY", "SQLITE_LOCKED"]);
-const MAX_COMMIT_ATTEMPTS = 8;
-let nextSavepointId = 0;
 function nextSavepointName() {
 	nextSavepointId += 1;
 	return `xopc_tx_${nextSavepointId}`;
 }
-const transactionDepthByDatabase = /* @__PURE__ */ new WeakMap();
 function getTransactionDepth(db) {
 	return transactionDepthByDatabase.get(db) ?? 0;
 }
@@ -109,5 +106,14 @@ function runSqliteWriteTransaction(fn) {
 function getSqliteDatabase() {
 	return getXopcDatabase().db;
 }
+var RETRYABLE_COMMIT_CODES, MAX_COMMIT_ATTEMPTS, nextSavepointId, transactionDepthByDatabase;
+var init_transaction = __esmMin((() => {
+	init_connection();
+	RETRYABLE_COMMIT_CODES = new Set(["SQLITE_BUSY", "SQLITE_LOCKED"]);
+	MAX_COMMIT_ATTEMPTS = 8;
+	nextSavepointId = 0;
+	transactionDepthByDatabase = /* @__PURE__ */ new WeakMap();
+}));
 //#endregion
-export { getSqliteDatabase, runSqliteWriteTransaction };
+init_transaction();
+export { getSqliteDatabase, init_transaction, runSqliteWriteTransaction };