proofscan 0.10.62 → 0.11.1

package/dist/db/events-store.js

@@ -13,8 +13,9 @@ export class EventsStore {
         return getEventsDb(this.configDir);
     }
     // ==================== Sessions ====================
-    createSession(connectorId, options) {
-        const targetId = options?.targetId || connectorId;
+    createSession(targetId, options) {
+        // Support legacy connectorId for backward compatibility
+        const connectorId = options?.connectorId || targetId;
         const session = {
             session_id: randomUUID(),
             connector_id: connectorId,
@@ -46,20 +47,26 @@ export class EventsStore {
         const stmt = this.db.prepare(`SELECT * FROM sessions WHERE session_id = ?`);
         return stmt.get(sessionId);
     }
-    getSessionsByConnector(connectorId, limit) {
+    getSessionsByTarget(targetId, limit) {
         let sql = `
       SELECT s.*,
         (SELECT COUNT(*) FROM events WHERE session_id = s.session_id) as event_count,
         (SELECT COUNT(*) FROM rpc_calls WHERE session_id = s.session_id) as rpc_count
       FROM sessions s
-      WHERE s.connector_id = ?
+      WHERE s.target_id = ?
       ORDER BY s.started_at DESC
     `;
         if (limit) {
             sql += ` LIMIT ${limit}`;
         }
         const stmt = this.db.prepare(sql);
-        return stmt.all(connectorId);
+        return stmt.all(targetId);
+    }
+    /**
+     * @deprecated Use getSessionsByTarget instead
+     */
+    getSessionsByConnector(connectorId, limit) {
+        return this.getSessionsByTarget(connectorId, limit);
     }
     getAllSessions(limit) {
         let sql = `
@@ -155,17 +162,57 @@ export class EventsStore {
         const stmt = this.db.prepare(sql);
         return stmt.all(sessionId);
     }
-    getRecentEventsByConnector(connectorId, limit = 20) {
+    /**
+     * Get events with pagination support (Phase 6.2)
+     *
+     * @param sessionId - Session ID
+     * @param options - Pagination options
+     * @param options.limit - Maximum number of events to return (default: 50, max: 200)
+     * @param options.before - Event ID for pagination cursor (exclusive)
+     * @returns Events in descending order (newest first)
+     */
+    getEvents(sessionId, options = {}) {
+        // Enforce max limit of 200
+        let limit = options.limit ?? 50;
+        if (limit > 200) {
+            limit = 200;
+        }
+        let sql = `SELECT * FROM events WHERE session_id = ?`;
+        const params = [sessionId];
+        // Exclusive cursor: get events older than the specified event_id
+        // Use composite cursor (ts, event_id) for stable pagination with same-timestamp events
+        if (options.before) {
+            const cursorStmt = this.db.prepare(`SELECT ts, event_id FROM events WHERE event_id = ?`);
+            const cursorEvent = cursorStmt.get(options.before);
+            if (cursorEvent) {
+                // Events with earlier timestamp, OR same timestamp but earlier event_id
+                sql += ` AND (ts < ? OR (ts = ? AND event_id < ?))`;
+                params.push(cursorEvent.ts, cursorEvent.ts, cursorEvent.event_id);
+            }
+        }
+        // Order by ts DESC, event_id DESC for deterministic ordering with same-timestamp events
+        sql += ` ORDER BY ts DESC, event_id DESC LIMIT ?`;
+        params.push(limit);
+        const stmt = this.db.prepare(sql);
+        return stmt.all(...params);
+    }
+    getRecentEventsByTarget(targetId, limit = 20) {
         const stmt = this.db.prepare(`
       SELECT e.* FROM events e
       JOIN sessions s ON e.session_id = s.session_id
-      WHERE s.connector_id = ?
+      WHERE s.target_id = ?
       ORDER BY e.ts DESC
       LIMIT ?
     `);
-        const events = stmt.all(connectorId, limit);
+        const events = stmt.all(targetId, limit);
         return events.reverse(); // Return in chronological order
     }
+    /**
+     * @deprecated Use getRecentEventsByTarget instead
+     */
+    getRecentEventsByConnector(connectorId, limit = 20) {
+        return this.getRecentEventsByTarget(connectorId, limit);
+    }
     // ==================== RPC Calls ====================
     saveRpcCall(sessionId, rpcId, method) {
         const rpcCall = {
@@ -203,19 +250,21 @@ export class EventsStore {
      * Get sessions that can be pruned (not protected)
      */
     getPruneCandidates(options = {}) {
-        const { keepLast, before, connectorId } = options;
+        const { keepLast, before, targetId, connectorId } = options;
         const candidates = [];
+        // Use targetId if provided, otherwise fall back to connectorId
+        const filterId = targetId || connectorId;
         // Get all unprotected sessions
         let sql = `
-      SELECT s.session_id, s.connector_id, s.started_at, s.protected,
+      SELECT s.session_id, s.target_id as connector_id, s.started_at, s.protected,
         (SELECT COUNT(*) FROM events WHERE session_id = s.session_id) as event_count
       FROM sessions s
       WHERE s.protected = 0
     `;
         const params = [];
-        if (connectorId) {
-            sql += ` AND s.connector_id = ?`;
-            params.push(connectorId);
+        if (filterId) {
+            sql += ` AND s.target_id = ?`;
+            params.push(filterId);
         }
         if (before) {
             sql += ` AND s.started_at < ?`;
@@ -429,15 +478,15 @@ export class EventsStore {
         });
     }
     /**
-     * Get latest session (optionally for a specific connector)
+     * Get latest session (optionally for a specific target)
      * Used by RefResolver
      */
-    getLatestSession(connectorId) {
-        let sql = `SELECT session_id, connector_id FROM sessions`;
+    getLatestSession(targetId) {
+        let sql = `SELECT session_id, target_id FROM sessions`;
         const params = [];
-        if (connectorId) {
-            sql += ` WHERE connector_id = ?`;
-            params.push(connectorId);
+        if (targetId) {
+            sql += ` WHERE target_id = ?`;
+            params.push(targetId);
         }
         sql += ` ORDER BY started_at DESC LIMIT 1`;
         const stmt = this.db.prepare(sql);
@@ -474,23 +523,23 @@ export class EventsStore {
      * Get session by ID or prefix
      * Used by RefResolver
      */
-    getSessionByPrefix(prefix, connectorId) {
+    getSessionByPrefix(prefix, targetId) {
         // Try exact match first
-        let stmt = this.db.prepare(`SELECT session_id, connector_id FROM sessions WHERE session_id = ?`);
+        let stmt = this.db.prepare(`SELECT session_id, target_id FROM sessions WHERE session_id = ?`);
         let result = stmt.get(prefix);
         if (result) {
-            if (connectorId && result.connector_id !== connectorId) {
+            if (targetId && result.target_id !== targetId) {
                 return null; // Wrong connector
             }
             return result;
         }
         // Try prefix match (escape SQL wildcards in user input)
         const escapedPrefix = prefix.replace(/[%_]/g, '\\$&');
-        let sql = `SELECT session_id, connector_id FROM sessions WHERE session_id LIKE ? ESCAPE '\\'`;
+        let sql = `SELECT session_id, target_id FROM sessions WHERE session_id LIKE ? ESCAPE '\\'`;
         const params = [escapedPrefix + '%'];
-        if (connectorId) {
-            sql += ` AND connector_id = ?`;
-            params.push(connectorId);
+        if (targetId) {
+            sql += ` AND target_id = ?`;
+            params.push(targetId);
         }
         sql += ` ORDER BY started_at DESC LIMIT 1`;
         stmt = this.db.prepare(sql);
@@ -536,5 +585,550 @@ export class EventsStore {
             response: response || undefined,
         };
     }
+    // ==================== A2A Sessions (Phase 7.0) ====================
+    /**
+     * Get A2A sessions for a target
+     *
+     * A2A sessions are sessions with actor_kind = 'agent'
+     *
+     * @param targetId - Target ID (agent ID)
+     * @param limit - Maximum number of sessions to return
+     * @returns Array of sessions with message count and last activity
+     */
+    getA2ASessions(targetId, limit = 50) {
+        const sql = `
+      SELECT
+        s.session_id,
+        (SELECT COUNT(*) FROM events WHERE session_id = s.session_id AND (normalized_json LIKE '%"actor":"user"%' OR normalized_json LIKE '%"actor":"assistant"%')) as message_count,
+        COALESCE(
+          (SELECT ts FROM events WHERE session_id = s.session_id ORDER BY ts DESC LIMIT 1),
+          s.started_at
+        ) as last_activity
+      FROM sessions s
+      WHERE s.target_id = ? AND s.actor_kind = 'agent'
+      ORDER BY last_activity DESC
+      LIMIT ?
+    `;
+        const stmt = this.db.prepare(sql);
+        return stmt.all(targetId, limit);
+    }
+    /**
+     * Get A2A messages for a session
+     *
+     * Returns messages with role, content, and timestamp from normalized_json
+     *
+     * @param sessionId - Session ID
+     * @param limit - Maximum number of messages to return
+     * @returns Array of A2A messages
+     */
+    getA2AMessages(sessionId, limit = 100) {
+        const sql = `
+      SELECT
+        e.event_id,
+        e.normalized_json,
+        e.raw_json,
+        e.ts
+      FROM events e
+      WHERE e.session_id = ?
+        AND e.normalized_json IS NOT NULL
+        AND (e.normalized_json LIKE '%"actor":"user"%' OR e.normalized_json LIKE '%"actor":"assistant"%')
+      ORDER BY e.ts ASC
+      LIMIT ?
+    `;
+        const stmt = this.db.prepare(sql);
+        const events = stmt.all(sessionId, limit);
+        const messages = [];
+        for (let i = 0; i < events.length; i++) {
+            const event = events[i];
+            let role = 'user';
+            let content = '';
+            if (event.normalized_json) {
+                try {
+                    const normalized = JSON.parse(event.normalized_json);
+                    if (normalized.actor === 'assistant') {
+                        role = 'assistant';
+                    }
+                    if (normalized.content && normalized.content.type === 'text') {
+                        content = normalized.content.text || '';
+                    }
+                }
+                catch {
+                    // If parsing fails, try raw_json
+                    if (event.raw_json) {
+                        try {
+                            const raw = JSON.parse(event.raw_json);
+                            // Raw format: { jsonrpc: '2.0', id: '...', result: { role: '...', parts: [...] } }
+                            const result = raw.result || raw;
+                            if (result.role === 'assistant') {
+                                role = 'assistant';
+                            }
+                            if (result.parts && Array.isArray(result.parts)) {
+                                content = result.parts
+                                    .filter((p) => p && typeof p === 'object' && 'text' in p)
+                                    .map((p) => p.text)
+                                    .join('');
+                            }
+                        }
+                        catch {
+                            // Parsing failed, use summary or empty
+                            content = '';
+                        }
+                    }
+                }
+            }
+            messages.push({
+                id: i + 1,
+                role,
+                content,
+                timestamp: event.ts,
+                rawJson: event.raw_json,
+            });
+        }
+        return messages;
+    }
+    /**
+     * Get A2A message detail by index
+     *
+     * @param sessionId - Session ID
+     * @param index - Message index (1-based)
+     * @returns Message detail or null if not found
+     */
+    getA2AMessageByIndex(sessionId, index) {
+        const messages = this.getA2AMessages(sessionId, index);
+        return messages[index - 1] || null;
+    }
+    /**
+     * Get A2A session by session ID (with metadata)
+     *
+     * @param sessionId - Session ID (or prefix)
+     * @param targetId - Optional target ID for filtering
+     * @returns Session or null
+     */
+    getA2ASessionById(sessionId, targetId) {
+        let sql = `
+      SELECT
+        s.session_id,
+        s.target_id,
+        s.started_at,
+        (SELECT COUNT(*) FROM events WHERE session_id = s.session_id AND (normalized_json LIKE '%"actor":"user"%' OR normalized_json LIKE '%"actor":"assistant"%')) as message_count,
+        COALESCE(
+          (SELECT ts FROM events WHERE session_id = s.session_id ORDER BY ts DESC LIMIT 1),
+          s.started_at
+        ) as last_activity
+      FROM sessions s
+      WHERE s.session_id LIKE ? AND s.actor_kind = 'agent'
+    `;
+        const params = [sessionId + '%'];
+        if (targetId) {
+            sql += ` AND s.target_id = ?`;
+            params.push(targetId);
+        }
+        sql += ` ORDER BY s.started_at DESC LIMIT 1`;
+        const stmt = this.db.prepare(sql);
+        return stmt.get(...params);
+    }
+    /**
+     * Get A2A messages across all sessions for a target (agent)
+     *
+     * Phase 2.3.1: Cross-session history search
+     *
+     * Returns messages in descending timestamp order (newest first)
+     *
+     * @param targetId - Target ID (agent ID)
+     * @param limit - Maximum number of messages to return
+     * @returns Array of A2A messages with session ID
+     */
+    getA2AMessagesForTarget(targetId, limit) {
+        const sql = `
+      SELECT
+        e.session_id,
+        e.ts,
+        json_extract(e.normalized_json, '$.actor') as role,
+        json_extract(e.normalized_json, '$.content.text') as content
+      FROM events e
+      JOIN sessions s ON e.session_id = s.session_id
+      WHERE s.target_id = ?
+        AND e.normalized_json IS NOT NULL
+        AND (json_extract(e.normalized_json, '$.actor') = 'user'
+             OR json_extract(e.normalized_json, '$.actor') = 'assistant')
+      ORDER BY e.ts DESC
+      LIMIT ?
+    `;
+        const stmt = this.db.prepare(sql);
+        const rows = stmt.all(targetId, limit);
+        const messages = [];
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            messages.push({
+                id: i + 1,
+                sessionId: row.session_id,
+                role: (row.role === 'assistant' ? 'assistant' : 'user'),
+                content: row.content || '',
+                timestamp: row.ts,
+            });
+        }
+        // Return in descending order (newest first)
+        return messages;
+    }
+    // ==================== Task Events (Phase 2.4) ====================
+    /**
+     * Normalize task status string to TaskStatus
+     * @private
+     */
+    normalizeTaskStatus(status) {
+        if (typeof status !== 'string')
+            return 'pending';
+        const validStatuses = [
+            'pending',
+            'working',
+            'input_required',
+            'completed',
+            'failed',
+            'canceled',
+            'rejected',
+        ];
+        if (validStatuses.includes(status)) {
+            return status;
+        }
+        return 'pending';
+    }
+    /**
+     * Save a task event
+     *
+     * @param sessionId - Session ID
+     * @param taskEventKind - Task event kind
+     * @param payload - Task event payload
+     * @returns Task event record
+     */
+    saveTaskEvent(sessionId, taskEventKind, payload) {
+        const event = {
+            event_id: randomUUID(),
+            session_id: sessionId,
+            task_id: payload.taskId,
+            event_kind: taskEventKind,
+            ts: new Date().toISOString(),
+            payload_json: JSON.stringify(payload),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO task_events (event_id, session_id, task_id, event_kind, ts, payload_json)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(event.event_id, event.session_id, event.task_id, event.event_kind, event.ts, event.payload_json);
+        return event;
+    }
+    /**
+     * Get task events for a session
+     *
+     * @param sessionId - Session ID
+     * @param limit - Maximum number of events to return
+     * @returns Task events in chronological order
+     */
+    getTaskEventsBySession(sessionId, limit) {
+        let sql = `SELECT * FROM task_events WHERE session_id = ? ORDER BY ts ASC`;
+        if (limit) {
+            sql += ` LIMIT ${limit}`;
+        }
+        const stmt = this.db.prepare(sql);
+        return stmt.all(sessionId);
+    }
+    /**
+     * Get task events for a specific task
+     *
+     * @param taskId - Task ID
+     * @returns Task events for the task in chronological order
+     */
+    getTaskEventsByTaskId(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM task_events WHERE task_id = ? ORDER BY ts ASC
+    `);
+        return stmt.all(taskId);
+    }
+    /**
+     * Get recent task events across all sessions
+     *
+     * @param limit - Maximum number of events to return
+     * @returns Task events in descending order (newest first)
+     */
+    getRecentTaskEvents(limit = 20) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM task_events ORDER BY ts DESC LIMIT ?
+    `);
+        const events = stmt.all(limit);
+        return events.reverse(); // Return in chronological order (oldest first)
+    }
+    /**
+     * Get all task events for a target (agent)
+     *
+     * @param targetId - Target ID (agent ID)
+     * @param limit - Maximum number of events to return
+     * @returns Task events in chronological order
+     */
+    getTaskEventsByTarget(targetId, limit = 100) {
+        const stmt = this.db.prepare(`
+      SELECT te.* FROM task_events te
+      JOIN sessions s ON te.session_id = s.session_id
+      WHERE s.target_id = ?
+      ORDER BY te.ts ASC
+      LIMIT ?
+    `);
+        return stmt.all(targetId, limit);
+    }
+    /**
+     * Get the last recorded status for a task
+     *
+     * @param taskId - Task ID
+     * @returns Last task event or null if not found
+     */
+    getLastTaskEvent(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM task_events
+      WHERE task_id = ?
+      ORDER BY ts DESC
+      LIMIT 1
+    `);
+        return stmt.get(taskId);
+    }
+    /**
+     * Record task creation event
+     *
+     * @param sessionId - Session ID
+     * @param taskId - Task ID
+     * @param rawStatus - Raw status string from response
+     */
+    recordTaskCreated(sessionId, taskId, rawStatus) {
+        const status = this.normalizeTaskStatus(rawStatus);
+        this.saveTaskEvent(sessionId, 'a2a:task:created', {
+            taskId,
+            rawStatus,
+            status,
+        });
+    }
+    /**
+     * Record task status update event
+     *
+     * Only records if status actually changed (no duplicate status events)
+     *
+     * @param sessionId - Session ID
+     * @param taskId - Task ID
+     * @param rawStatus - New raw status string
+     * @returns True if event was recorded, false if status unchanged
+     */
+    recordTaskUpdated(sessionId, taskId, rawStatus) {
+        const status = this.normalizeTaskStatus(rawStatus);
+        // Check last recorded status to avoid duplicate events
+        const lastEvent = this.getLastTaskEvent(taskId);
+        if (lastEvent) {
+            const lastPayload = JSON.parse(lastEvent.payload_json);
+            if (lastPayload.status === status) {
+                // Status unchanged, don't record
+                return false;
+            }
+        }
+        this.saveTaskEvent(sessionId, 'a2a:task:updated', {
+            taskId,
+            rawStatus,
+            status,
+            previousStatus: lastEvent
+                ? JSON.parse(lastEvent.payload_json).status
+                : undefined,
+        });
+        return true;
+    }
+    /**
+     * Record task completion event
+     *
+     * @param sessionId - Session ID
+     * @param taskId - Task ID
+     * @param rawStatus - Raw status string
+     * @param messages - Messages (optional)
+     * @param artifacts - Artifacts (optional)
+     */
+    recordTaskCompleted(sessionId, taskId, rawStatus, messages, artifacts) {
+        this.saveTaskEvent(sessionId, 'a2a:task:completed', {
+            taskId,
+            rawStatus,
+            status: 'completed',
+            messages,
+            artifacts,
+        });
+    }
+    /**
+     * Record task failure event
+     *
+     * @param sessionId - Session ID
+     * @param taskId - Task ID
+     * @param rawStatus - Raw status string
+     * @param error - Error message
+     */
+    recordTaskFailed(sessionId, taskId, rawStatus, error) {
+        this.saveTaskEvent(sessionId, 'a2a:task:failed', {
+            taskId,
+            rawStatus,
+            status: 'failed',
+            error,
+        });
+    }
+    /**
+     * Record task cancellation event
+     *
+     * @param sessionId - Session ID
+     * @param taskId - Task ID
+     * @param rawStatus - Raw status string
+     */
+    recordTaskCanceled(sessionId, taskId, rawStatus) {
+        this.saveTaskEvent(sessionId, 'a2a:task:canceled', {
+            taskId,
+            rawStatus,
+            status: 'canceled',
+        });
+    }
+    /**
+     * Record task wait timeout event
+     *
+     * @param sessionId - Session ID
+     * @param taskId - Task ID
+     * @param error - Error message
+     */
+    recordTaskWaitTimeout(sessionId, taskId, error) {
+        this.saveTaskEvent(sessionId, 'a2a:task:wait_timeout', {
+            taskId,
+            rawStatus: 'timeout',
+            status: 'failed',
+            error: error || 'Task wait timeout',
+        });
+    }
+    /**
+     * Record task poll error event
+     *
+     * @param sessionId - Session ID
+     * @param taskId - Task ID
+     * @param error - Error message
+     */
+    recordTaskPollError(sessionId, taskId, error) {
+        this.saveTaskEvent(sessionId, 'a2a:task:poll_error', {
+            taskId,
+            rawStatus: 'poll_error',
+            status: 'failed',
+            error: error || 'Task poll error',
+        });
+    }
+    // ==================== UI Events (Phase 6.2) ====================
+    /**
+     * Save a UI tool request event
+     *
+     * @param uiSessionId - UI session ID (derived from sessionToken)
+     * @param uiRpcId - UI RPC ID
+     * @param correlationId - Correlation ID
+     * @param toolCallFingerprint - Tool call fingerprint
+     * @param toolName - Tool name
+     * @param payload - Event payload (arguments, sessionToken, etc.)
+     * @returns UI event record
+     */
+    saveUiToolRequestEvent(uiSessionId, uiRpcId, correlationId, toolCallFingerprint, toolName, payload) {
+        const event = {
+            event_id: randomUUID(),
+            ui_session_id: uiSessionId,
+            ui_rpc_id: uiRpcId,
+            correlation_id: correlationId,
+            tool_call_fingerprint: toolCallFingerprint,
+            event_type: 'ui_tool_request',
+            tool_name: toolName,
+            ts: Date.now(),
+            payload_json: JSON.stringify(payload),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO ui_events (event_id, ui_session_id, ui_rpc_id, correlation_id, tool_call_fingerprint, event_type, tool_name, ts, payload_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(event.event_id, event.ui_session_id, event.ui_rpc_id, event.correlation_id, event.tool_call_fingerprint, event.event_type, event.tool_name, event.ts, event.payload_json);
+        return { event_id: event.event_id, ts: event.ts };
+    }
+    /**
+     * Save a UI tool result event
+     *
+     * @param uiSessionId - UI session ID
+     * @param uiRpcId - UI RPC ID
+     * @param correlationId - Correlation ID
+     * @param toolCallFingerprint - Tool call fingerprint
+     * @param payload - Event payload (result, duration_ms, etc.)
+     * @returns UI event record
+     */
+    saveUiToolResultEvent(uiSessionId, uiRpcId, correlationId, toolCallFingerprint, payload) {
+        const event = {
+            event_id: randomUUID(),
+            ui_session_id: uiSessionId,
+            ui_rpc_id: uiRpcId,
+            correlation_id: correlationId,
+            tool_call_fingerprint: toolCallFingerprint,
+            event_type: 'ui_tool_result',
+            tool_name: null,
+            ts: Date.now(),
+            payload_json: JSON.stringify(payload),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO ui_events (event_id, ui_session_id, ui_rpc_id, correlation_id, tool_call_fingerprint, event_type, tool_name, ts, payload_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(event.event_id, event.ui_session_id, event.ui_rpc_id, event.correlation_id, event.tool_call_fingerprint, event.event_type, event.tool_name, event.ts, event.payload_json);
+        return { event_id: event.event_id, ts: event.ts };
+    }
+    /**
+     * Save a UI tool delivered event (sent to UI)
+     *
+     * @param uiSessionId - UI session ID
+     * @param uiRpcId - UI RPC ID
+     * @param correlationId - Correlation ID
+     * @param toolCallFingerprint - Tool call fingerprint
+     * @param payload - Event payload (result)
+     * @returns UI event record
+     */
+    saveUiToolDeliveredEvent(uiSessionId, uiRpcId, correlationId, toolCallFingerprint, payload) {
+        const event = {
+            event_id: randomUUID(),
+            ui_session_id: uiSessionId,
+            ui_rpc_id: uiRpcId,
+            correlation_id: correlationId,
+            tool_call_fingerprint: toolCallFingerprint,
+            event_type: 'ui_tool_delivered',
+            tool_name: null,
+            ts: Date.now(),
+            payload_json: JSON.stringify(payload),
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO ui_events (event_id, ui_session_id, ui_rpc_id, correlation_id, tool_call_fingerprint, event_type, tool_name, ts, payload_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(event.event_id, event.ui_session_id, event.ui_rpc_id, event.correlation_id, event.tool_call_fingerprint, event.event_type, event.tool_name, event.ts, event.payload_json);
+        return { event_id: event.event_id, ts: event.ts };
+    }
+    /**
+     * Get UI events by correlation ID
+     *
+     * @param correlationId - Correlation ID
+     * @returns UI events with matching correlation ID
+     */
+    getUiEventsByCorrelationId(correlationId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM ui_events WHERE correlation_id = ? ORDER BY ts ASC
+    `);
+        return stmt.all(correlationId);
+    }
+    /**
+     * Get UI events by session ID
+     *
+     * @param uiSessionId - UI session ID
+     * @param limit - Maximum number of events to return
+     * @returns UI events for the session
+     */
+    getUiEventsBySession(uiSessionId, limit = 100) {
+        const sql = `
+      SELECT * FROM ui_events
+      WHERE ui_session_id = ?
+      ORDER BY ts DESC
+      LIMIT ?
+    `;
+        const stmt = this.db.prepare(sql);
+        return stmt.all(uiSessionId, limit);
+    }
 }
 //# sourceMappingURL=events-store.js.map