@agentlensai/server 0.10.0 → 0.13.0

package/dist/db/sqlite-store.js

@@ -1,992 +1,125 @@
 /**
- * SQLite implementation of IEventStore.
+ * SQLite implementation of IEventStore — thin facade.
  *
- * Write operations (Story 3.4):
- * - insertEvents() — batch insert in single transaction
- * - Auto-create/update session records on event insert
- * - Auto-create agent records on first event
- * - Session status management
- *
- * Read operations (Story 3.5):
- * - queryEvents(), getEvent(), getSessionTimeline(), countEvents()
- * - querySessions(), getSession()
- * - listAgents(), getAgent()
- * - getAnalytics(), getStats()
- */
-import { eq, and, gte, lte, inArray, desc, asc, sql, count as drizzleCount } from 'drizzle-orm';
-import { computeEventHash } from '@agentlensai/core';
-import { events, sessions, agents, alertRules, alertHistory } from './schema.sqlite.js';
-import { HashChainError, NotFoundError } from './errors.js';
-// ─── Helpers ───────────────────────────────────────────────
-/**
- * Safe JSON.parse that returns a fallback on any error instead of throwing.
+ * Delegates to focused repository classes (Story S-7.5):
+ * - EventRepository — event CRUD
+ * - SessionRepository — session CRUD
+ * - AgentRepository — agent CRUD
+ * - AlertRepository — alert rules + history
+ * - AnalyticsRepository — analytics and stats
+ * - RetentionService — data retention/cleanup
  */
-export function safeJsonParse(raw, fallback) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return fallback;
-    }
-}
+import { EventRepository } from './repositories/event-repository.js';
+import { SessionRepository } from './repositories/session-repository.js';
+import { AgentRepository } from './repositories/agent-repository.js';
+import { AlertRepository } from './repositories/alert-repository.js';
+import { AnalyticsRepository } from './repositories/analytics-repository.js';
+import { RetentionService } from './services/retention-service.js';
+// Re-export for backward compatibility
+export { safeJsonParse } from './shared/query-helpers.js';
 export class SqliteEventStore {
     db;
+    eventRepo;
+    sessionRepo;
+    agentRepo;
+    alertRepo;
+    analyticsRepo;
+    retentionService;
     constructor(db) {
         this.db = db;
-    }
-    /**
-     * Defense-in-depth: warn when a query method is called without tenantId.
-     * This helps catch missing tenant scoping in call chains.
-     */
-    warnIfNoTenant(method, tenantId) {
-        if (tenantId === undefined) {
-            console.warn(`[SqliteEventStore] ${method}() called without tenantId — query is unscoped. ` +
-                `Ensure tenant isolation is applied upstream (via TenantScopedStore).`);
-        }
-    }
-    // ─── Events — Write ────────────────────────────────────────
+        this.eventRepo = new EventRepository(db);
+        this.sessionRepo = new SessionRepository(db);
+        this.agentRepo = new AgentRepository(db);
+        this.alertRepo = new AlertRepository(db);
+        this.analyticsRepo = new AnalyticsRepository(db);
+        this.retentionService = new RetentionService(db);
+    }
+    // ─── Events ────────────────────────────────────────────────
     async insertEvents(eventList) {
-        if (eventList.length === 0)
-            return;
-        // Batch insert in a single transaction for atomicity and performance
-        this.db.transaction((tx) => {
-            // CRITICAL 3: Validate hash chain before inserting
-            const firstEvent = eventList[0];
-            const tenantId = firstEvent.tenantId ?? 'default';
-            // Check if the first event already exists (idempotent re-insert)
-            const existingFirst = tx
-                .select({ id: events.id })
-                .from(events)
-                .where(eq(events.id, firstEvent.id))
-                .get();
-            if (!existingFirst) {
-                // Fresh insert — validate chain continuity against stored events
-                const lastStoredEvent = tx
-                    .select({ hash: events.hash })
-                    .from(events)
-                    .where(and(eq(events.sessionId, firstEvent.sessionId), eq(events.tenantId, tenantId)))
-                    .orderBy(desc(events.timestamp), desc(events.id))
-                    .limit(1)
-                    .get();
-                const lastStoredHash = lastStoredEvent?.hash ?? null;
-                // Validate that the first event's prevHash matches the latest stored hash
-                if (firstEvent.prevHash !== lastStoredHash) {
-                    throw new HashChainError(`Chain continuity broken: event ${firstEvent.id} has prevHash=${firstEvent.prevHash} but last stored hash is ${lastStoredHash}`);
-                }
-            }
-            // Validate each event's hash and intra-batch chain links
-            for (let i = 0; i < eventList.length; i++) {
-                const event = eventList[i];
-                // Verify intra-batch chain continuity (for events after the first)
-                if (i > 0) {
-                    const prevEvent = eventList[i - 1];
-                    if (event.prevHash !== prevEvent.hash) {
-                        throw new HashChainError(`Chain continuity broken within batch: event ${event.id} has prevHash=${event.prevHash} but previous event hash is ${prevEvent.hash}`);
-                    }
-                }
-                // Recompute hash server-side and verify
-                const recomputedHash = computeEventHash({
-                    id: event.id,
-                    timestamp: event.timestamp,
-                    sessionId: event.sessionId,
-                    agentId: event.agentId,
-                    eventType: event.eventType,
-                    severity: event.severity,
-                    payload: event.payload,
-                    metadata: event.metadata,
-                    prevHash: event.prevHash,
-                });
-                if (event.hash !== recomputedHash) {
-                    throw new HashChainError(`Hash mismatch for event ${event.id}: supplied=${event.hash}, computed=${recomputedHash}`);
-                }
-            }
-            for (const event of eventList) {
-                // CRITICAL 4: Idempotent event insertion — ON CONFLICT DO NOTHING
-                tx.insert(events)
-                    .values({
-                    id: event.id,
-                    timestamp: event.timestamp,
-                    sessionId: event.sessionId,
-                    agentId: event.agentId,
-                    eventType: event.eventType,
-                    severity: event.severity,
-                    payload: JSON.stringify(event.payload),
-                    metadata: JSON.stringify(event.metadata),
-                    prevHash: event.prevHash,
-                    hash: event.hash,
-                    tenantId,
-                })
-                    .onConflictDoNothing({ target: events.id })
-                    .run();
-                // Handle session management
-                this._handleSessionUpdate(tx, event, tenantId);
-                // Handle agent auto-creation
-                this._handleAgentUpsert(tx, event, tenantId);
-            }
-        });
-    }
-    _handleSessionUpdate(tx, event, tenantId) {
-        if (event.eventType === 'session_started') {
-            // Create new session
-            const payload = event.payload;
-            const tags = payload.tags ?? [];
-            const agentName = payload.agentName ?? undefined;
-            // CRITICAL 4: Use INSERT ... ON CONFLICT DO UPDATE for sessions
-            tx.insert(sessions)
-                .values({
-                id: event.sessionId,
-                agentId: event.agentId,
-                agentName: agentName,
-                startedAt: event.timestamp,
-                status: 'active',
-                eventCount: 1,
-                toolCallCount: 0,
-                errorCount: 0,
-                totalCostUsd: 0,
-                tags: JSON.stringify(tags),
-                tenantId,
-            })
-                .onConflictDoUpdate({
-                target: [sessions.id, sessions.tenantId],
-                set: {
-                    agentName: agentName ?? sql `coalesce(${sessions.agentName}, NULL)`,
-                    status: 'active',
-                    eventCount: sql `${sessions.eventCount} + 1`,
-                    tags: tags.length > 0 ? JSON.stringify(tags) : sql `${sessions.tags}`,
-                },
-            })
-                .run();
-            return;
-        }
-        // For non-session_started events, ensure a session exists first (upsert)
-        tx.insert(sessions)
-            .values({
-            id: event.sessionId,
-            agentId: event.agentId,
-            startedAt: event.timestamp,
-            status: 'active',
-            eventCount: 0,
-            toolCallCount: 0,
-            errorCount: 0,
-            totalCostUsd: 0,
-            tags: '[]',
-            tenantId,
-        })
-            .onConflictDoNothing({ target: [sessions.id, sessions.tenantId] })
-            .run();
-        // Build incremental updates
-        const isToolCall = event.eventType === 'tool_call';
-        const isError = event.severity === 'error' ||
-            event.severity === 'critical' ||
-            event.eventType === 'tool_error';
-        const isCost = event.eventType === 'cost_tracked';
-        const isLlmResponse = event.eventType === 'llm_response';
-        const costPayload = event.payload;
-        const costUsd = isCost ? (Number(costPayload.costUsd) || 0) : 0;
-        const llmCostUsd = isLlmResponse ? (Number(costPayload.costUsd) || 0) : 0;
-        const llmUsage = isLlmResponse ? costPayload.usage : undefined;
-        const llmInputTokens = llmUsage ? (Number(llmUsage.inputTokens) || 0) : 0;
-        const llmOutputTokens = llmUsage ? (Number(llmUsage.outputTokens) || 0) : 0;
-        if (event.eventType === 'session_ended') {
-            const payload = event.payload;
-            const reason = payload.reason;
-            const status = reason === 'error' ? 'error' : 'completed';
-            tx.update(sessions)
-                .set({
-                endedAt: event.timestamp,
-                status: status,
-                eventCount: sql `${sessions.eventCount} + 1`,
-                errorCount: isError
-                    ? sql `${sessions.errorCount} + 1`
-                    : sessions.errorCount,
-            })
-                .where(and(eq(sessions.id, event.sessionId), eq(sessions.tenantId, tenantId)))
-                .run();
-            return;
-        }
-        // Regular event — increment counters
-        tx.update(sessions)
-            .set({
-            eventCount: sql `${sessions.eventCount} + 1`,
-            toolCallCount: isToolCall
-                ? sql `${sessions.toolCallCount} + 1`
-                : sessions.toolCallCount,
-            errorCount: isError
-                ? sql `${sessions.errorCount} + 1`
-                : sessions.errorCount,
-            totalCostUsd: isCost
-                ? sql `${sessions.totalCostUsd} + ${costUsd}`
-                : isLlmResponse
-                    ? sql `${sessions.totalCostUsd} + ${llmCostUsd}`
-                    : sessions.totalCostUsd,
-            llmCallCount: isLlmResponse
-                ? sql `${sessions.llmCallCount} + 1`
-                : sessions.llmCallCount,
-            totalInputTokens: isLlmResponse
-                ? sql `${sessions.totalInputTokens} + ${llmInputTokens}`
-                : sessions.totalInputTokens,
-            totalOutputTokens: isLlmResponse
-                ? sql `${sessions.totalOutputTokens} + ${llmOutputTokens}`
-                : sessions.totalOutputTokens,
-        })
-            .where(and(eq(sessions.id, event.sessionId), eq(sessions.tenantId, tenantId)))
-            .run();
-    }
-    _handleAgentUpsert(tx, event, tenantId) {
-        // CRITICAL 4: Use INSERT ... ON CONFLICT DO UPDATE for agents
-        // Agents are scoped per tenant — use composite key (id + tenant_id)
-        const payload = event.payload;
-        const agentName = payload.agentName ?? event.agentId;
-        tx.insert(agents)
-            .values({
-            id: event.agentId,
-            name: agentName,
-            firstSeenAt: event.timestamp,
-            lastSeenAt: event.timestamp,
-            sessionCount: event.eventType === 'session_started' ? 1 : 0,
-            tenantId,
-        })
-            .onConflictDoUpdate({
-            target: [agents.id, agents.tenantId],
-            set: {
-                lastSeenAt: event.timestamp,
-                sessionCount: event.eventType === 'session_started'
-                    ? sql `${agents.sessionCount} + 1`
-                    : agents.sessionCount,
-            },
-        })
-            .run();
-    }
-    // ─── Sessions — Write ──────────────────────────────────────
-    async upsertSession(session) {
-        const tenantId = session.tenantId ?? 'default';
-        const existing = this.db
-            .select()
-            .from(sessions)
-            .where(and(eq(sessions.id, session.id), eq(sessions.tenantId, tenantId)))
-            .get();
-        if (existing) {
-            const updates = {};
-            if (session.agentId !== undefined)
-                updates.agentId = session.agentId;
-            if (session.agentName !== undefined)
-                updates.agentName = session.agentName;
-            if (session.startedAt !== undefined)
-                updates.startedAt = session.startedAt;
-            if (session.endedAt !== undefined)
-                updates.endedAt = session.endedAt;
-            if (session.status !== undefined)
-                updates.status = session.status;
-            if (session.eventCount !== undefined)
-                updates.eventCount = session.eventCount;
-            if (session.toolCallCount !== undefined)
-                updates.toolCallCount = session.toolCallCount;
-            if (session.errorCount !== undefined)
-                updates.errorCount = session.errorCount;
-            if (session.totalCostUsd !== undefined)
-                updates.totalCostUsd = session.totalCostUsd;
-            if (session.llmCallCount !== undefined)
-                updates.llmCallCount = session.llmCallCount;
-            if (session.totalInputTokens !== undefined)
-                updates.totalInputTokens = session.totalInputTokens;
-            if (session.totalOutputTokens !== undefined)
-                updates.totalOutputTokens = session.totalOutputTokens;
-            if (session.tags !== undefined)
-                updates.tags = JSON.stringify(session.tags);
-            if (Object.keys(updates).length > 0) {
-                this.db
-                    .update(sessions)
-                    .set(updates)
-                    .where(and(eq(sessions.id, session.id), eq(sessions.tenantId, tenantId)))
-                    .run();
-            }
-        }
-        else {
-            this.db
-                .insert(sessions)
-                .values({
-                id: session.id,
-                agentId: session.agentId ?? '',
-                startedAt: session.startedAt ?? new Date().toISOString(),
-                status: session.status ?? 'active',
-                agentName: session.agentName,
-                endedAt: session.endedAt,
-                eventCount: session.eventCount ?? 0,
-                toolCallCount: session.toolCallCount ?? 0,
-                errorCount: session.errorCount ?? 0,
-                totalCostUsd: session.totalCostUsd ?? 0,
-                llmCallCount: session.llmCallCount ?? 0,
-                totalInputTokens: session.totalInputTokens ?? 0,
-                totalOutputTokens: session.totalOutputTokens ?? 0,
-                tags: JSON.stringify(session.tags ?? []),
-                tenantId,
-            })
-                .run();
-        }
-    }
-    // ─── Agents — Write ────────────────────────────────────────
-    async upsertAgent(agent) {
-        const tenantId = agent.tenantId ?? 'default';
-        const existing = this.db
-            .select()
-            .from(agents)
-            .where(and(eq(agents.id, agent.id), eq(agents.tenantId, tenantId)))
-            .get();
-        if (existing) {
-            const updates = {};
-            if (agent.name !== undefined)
-                updates.name = agent.name;
-            if (agent.description !== undefined)
-                updates.description = agent.description;
-            if (agent.lastSeenAt !== undefined)
-                updates.lastSeenAt = agent.lastSeenAt;
-            if (agent.sessionCount !== undefined)
-                updates.sessionCount = agent.sessionCount;
-            if (Object.keys(updates).length > 0) {
-                this.db
-                    .update(agents)
-                    .set(updates)
-                    .where(and(eq(agents.id, agent.id), eq(agents.tenantId, tenantId)))
-                    .run();
-            }
-        }
-        else {
-            const now = new Date().toISOString();
-            this.db
-                .insert(agents)
-                .values({
-                id: agent.id,
-                name: agent.name ?? agent.id,
-                description: agent.description,
-                firstSeenAt: agent.firstSeenAt ?? now,
-                lastSeenAt: agent.lastSeenAt ?? now,
-                sessionCount: agent.sessionCount ?? 0,
-                tenantId,
-            })
-                .run();
-        }
+        this.eventRepo.insertEvents(eventList, (tx, event, tenantId) => this.sessionRepo.handleSessionUpdate(tx, event, tenantId), (tx, event, tenantId) => this.agentRepo.handleAgentUpsert(tx, event, tenantId));
     }
-    // ─── Agents — Pause/Override (B1 — Story 1.2) ──────────────
-    /**
-     * Pause an agent: set paused_at and pause_reason.
-     */
-    async pauseAgent(tenantId, agentId, reason) {
-        const result = this.db
-            .update(agents)
-            .set({
-            pausedAt: new Date().toISOString(),
-            pauseReason: reason,
-        })
-            .where(and(eq(agents.id, agentId), eq(agents.tenantId, tenantId)))
-            .run();
-        return result.changes > 0;
-    }
-    /**
-     * Unpause an agent: clear paused_at, pause_reason, and optionally model_override.
-     */
-    async unpauseAgent(tenantId, agentId, clearModelOverride) {
-        const updates = {
-            pausedAt: null,
-            pauseReason: null,
-        };
-        if (clearModelOverride) {
-            updates.modelOverride = null;
-        }
-        const result = this.db
-            .update(agents)
-            .set(updates)
-            .where(and(eq(agents.id, agentId), eq(agents.tenantId, tenantId)))
-            .run();
-        return result.changes > 0;
-    }
-    /**
-     * Set model override on an agent.
-     */
-    async setModelOverride(tenantId, agentId, model) {
-        const result = this.db
-            .update(agents)
-            .set({ modelOverride: model })
-            .where(and(eq(agents.id, agentId), eq(agents.tenantId, tenantId)))
-            .run();
-        return result.changes > 0;
-    }
-    // ─── Events — Read (Story 3.5 stubs, implemented later) ────
     async queryEvents(query) {
-        const limit = Math.min(query.limit ?? 50, 500);
-        const offset = query.offset ?? 0;
-        const orderDir = query.order === 'asc' ? asc : desc;
-        const conditions = this._buildEventConditions(query);
-        const rows = this.db
-            .select()
-            .from(events)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .orderBy(orderDir(events.timestamp))
-            .limit(limit)
-            .offset(offset)
-            .all();
-        const total = await this.countEvents(query);
-        return {
-            events: rows.map(this._mapEventRow),
-            total,
-            hasMore: offset + rows.length < total,
-        };
+        return this.eventRepo.queryEvents(query);
     }
     async getEvent(id, tenantId) {
-        this.warnIfNoTenant('getEvent', tenantId);
-        const conditions = [eq(events.id, id)];
-        if (tenantId)
-            conditions.push(eq(events.tenantId, tenantId));
-        const row = this.db
-            .select()
-            .from(events)
-            .where(and(...conditions))
-            .get();
-        return row ? this._mapEventRow(row) : null;
+        return this.eventRepo.getEvent(id, tenantId);
     }
     async getSessionTimeline(sessionId, tenantId) {
-        const conditions = [eq(events.sessionId, sessionId)];
-        if (tenantId)
-            conditions.push(eq(events.tenantId, tenantId));
-        const rows = this.db
-            .select()
-            .from(events)
-            .where(and(...conditions))
-            .orderBy(asc(events.timestamp))
-            .all();
-        return rows.map(this._mapEventRow);
+        return this.eventRepo.getSessionTimeline(sessionId, tenantId);
     }
     async getLastEventHash(sessionId, tenantId) {
-        const conditions = [eq(events.sessionId, sessionId)];
-        if (tenantId)
-            conditions.push(eq(events.tenantId, tenantId));
-        const row = this.db
-            .select({ hash: events.hash })
-            .from(events)
-            .where(and(...conditions))
-            .orderBy(desc(events.timestamp), desc(events.id))
-            .limit(1)
-            .get();
-        return row?.hash ?? null;
+        return this.eventRepo.getLastEventHash(sessionId, tenantId);
     }
     async countEvents(query) {
-        const conditions = this._buildEventConditions(query);
-        const result = this.db
-            .select({ count: drizzleCount() })
-            .from(events)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .get();
-        return result?.count ?? 0;
+        return this.eventRepo.countEvents(query);
+    }
+    async countEventsBatch(query) {
+        return this.eventRepo.countEventsBatch(query);
+    }
+    // ─── Sessions ──────────────────────────────────────────────
+    async upsertSession(session) {
+        return this.sessionRepo.upsertSession(session);
     }
-    // ─── Sessions — Read ───────────────────────────────────────
     async querySessions(query) {
-        this.warnIfNoTenant('querySessions', query.tenantId);
-        const limit = Math.min(query.limit ?? 50, 500);
-        const offset = query.offset ?? 0;
-        const conditions = this._buildSessionConditions(query);
-        const rows = this.db
-            .select()
-            .from(sessions)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .orderBy(desc(sessions.startedAt))
-            .limit(limit)
-            .offset(offset)
-            .all();
-        const totalResult = this.db
-            .select({ count: drizzleCount() })
-            .from(sessions)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .get();
-        return {
-            sessions: rows.map(this._mapSessionRow),
-            total: totalResult?.count ?? 0,
-        };
+        return this.sessionRepo.querySessions(query);
     }
     async getSession(id, tenantId) {
-        const conditions = [eq(sessions.id, id)];
-        if (tenantId)
-            conditions.push(eq(sessions.tenantId, tenantId));
-        const row = this.db
-            .select()
-            .from(sessions)
-            .where(and(...conditions))
-            .get();
-        return row ? this._mapSessionRow(row) : null;
+        return this.sessionRepo.getSession(id, tenantId);
+    }
+    async sumSessionCost(query) {
+        return this.sessionRepo.sumSessionCost(query);
+    }
+    // ─── Agents ────────────────────────────────────────────────
+    async upsertAgent(agent) {
+        return this.agentRepo.upsertAgent(agent);
+    }
+    async pauseAgent(tenantId, agentId, reason) {
+        return this.agentRepo.pauseAgent(tenantId, agentId, reason);
+    }
+    async unpauseAgent(tenantId, agentId, clearModelOverride) {
+        return this.agentRepo.unpauseAgent(tenantId, agentId, clearModelOverride);
+    }
+    async setModelOverride(tenantId, agentId, model) {
+        return this.agentRepo.setModelOverride(tenantId, agentId, model);
     }
-    // ─── Agents — Read ─────────────────────────────────────────
     async listAgents(tenantId) {
-        this.warnIfNoTenant('listAgents', tenantId);
-        const conditions = tenantId ? [eq(agents.tenantId, tenantId)] : [];
-        const rows = this.db
-            .select()
-            .from(agents)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .orderBy(desc(agents.lastSeenAt))
-            .all();
-        return rows.map(this._mapAgentRow);
+        return this.agentRepo.listAgents(tenantId);
     }
     async getAgent(id, tenantId) {
-        const conditions = [eq(agents.id, id)];
-        if (tenantId)
-            conditions.push(eq(agents.tenantId, tenantId));
-        const row = this.db
-            .select()
-            .from(agents)
-            .where(and(...conditions))
-            .get();
-        return row ? this._mapAgentRow(row) : null;
-    }
-    // ─── Analytics ─────────────────────────────────────────────
-    async getAnalytics(params) {
-        this.warnIfNoTenant('getAnalytics', params.tenantId);
-        // HIGH 5: Build the time-bucket format string for SQLite strftime
-        const formatStr = params.granularity === 'hour'
-            ? '%Y-%m-%dT%H:00:00Z'
-            : params.granularity === 'day'
-                ? '%Y-%m-%dT00:00:00Z'
-                : '%Y-%W'; // week — true ISO week bucketing
-        const conditions = [
-            gte(events.timestamp, params.from),
-            lte(events.timestamp, params.to),
-        ];
-        if (params.agentId) {
-            conditions.push(eq(events.agentId, params.agentId));
-        }
-        // HIGH 6: Compute avgLatencyMs and totalCostUsd from payload JSON
-        // Bucketed query
-        const bucketRows = this.db
-            .all(sql `
-          SELECT
-            strftime(${formatStr}, timestamp) as bucket,
-            COUNT(*) as eventCount,
-            SUM(CASE WHEN event_type = 'tool_call' THEN 1 ELSE 0 END) as toolCallCount,
-            SUM(CASE WHEN severity IN ('error', 'critical') OR event_type = 'tool_error' THEN 1 ELSE 0 END) as errorCount,
-            COUNT(DISTINCT session_id) as uniqueSessions,
-            COALESCE(AVG(CASE WHEN event_type = 'tool_response' THEN json_extract(payload, '$.durationMs') ELSE NULL END), 0) as avgLatencyMs,
-            COALESCE(SUM(CASE WHEN event_type = 'cost_tracked' THEN json_extract(payload, '$.costUsd') ELSE 0 END), 0) as totalCostUsd
-          FROM events
-          WHERE timestamp >= ${params.from}
-            AND timestamp <= ${params.to}
-            ${params.agentId ? sql `AND agent_id = ${params.agentId}` : sql ``}
-            ${params.tenantId ? sql `AND tenant_id = ${params.tenantId}` : sql ``}
-          GROUP BY bucket
-          ORDER BY bucket ASC
-        `);
-        // Totals query
-        const totalsRow = this.db.get(sql `
-        SELECT
-          COUNT(*) as eventCount,
-          SUM(CASE WHEN event_type = 'tool_call' THEN 1 ELSE 0 END) as toolCallCount,
-          SUM(CASE WHEN severity IN ('error', 'critical') OR event_type = 'tool_error' THEN 1 ELSE 0 END) as errorCount,
-          COUNT(DISTINCT session_id) as uniqueSessions,
-          COUNT(DISTINCT agent_id) as uniqueAgents,
-          COALESCE(AVG(CASE WHEN event_type = 'tool_response' THEN json_extract(payload, '$.durationMs') ELSE NULL END), 0) as avgLatencyMs,
-          COALESCE(SUM(CASE WHEN event_type = 'cost_tracked' THEN json_extract(payload, '$.costUsd') ELSE 0 END), 0) as totalCostUsd
-        FROM events
-        WHERE timestamp >= ${params.from}
-          AND timestamp <= ${params.to}
-          ${params.agentId ? sql `AND agent_id = ${params.agentId}` : sql ``}
-          ${params.tenantId ? sql `AND tenant_id = ${params.tenantId}` : sql ``}
-      `);
-        return {
-            buckets: bucketRows.map((row) => ({
-                timestamp: row.bucket,
-                eventCount: Number(row.eventCount),
-                toolCallCount: Number(row.toolCallCount),
-                errorCount: Number(row.errorCount),
-                avgLatencyMs: Number(row.avgLatencyMs),
-                totalCostUsd: Number(row.totalCostUsd),
-                uniqueSessions: Number(row.uniqueSessions),
-            })),
-            totals: {
-                eventCount: Number(totalsRow?.eventCount ?? 0),
-                toolCallCount: Number(totalsRow?.toolCallCount ?? 0),
-                errorCount: Number(totalsRow?.errorCount ?? 0),
-                avgLatencyMs: Number(totalsRow?.avgLatencyMs ?? 0),
-                totalCostUsd: Number(totalsRow?.totalCostUsd ?? 0),
-                uniqueSessions: Number(totalsRow?.uniqueSessions ?? 0),
-                uniqueAgents: Number(totalsRow?.uniqueAgents ?? 0),
-            },
-        };
+        return this.agentRepo.getAgent(id, tenantId);
     }
-    // ─── Alert Rules ───────────────────────────────────────────
+    // ─── Alerts ────────────────────────────────────────────────
     async createAlertRule(rule) {
-        this.db
-            .insert(alertRules)
-            .values({
-            id: rule.id,
-            name: rule.name,
-            enabled: rule.enabled,
-            condition: rule.condition,
-            threshold: rule.threshold,
-            windowMinutes: rule.windowMinutes,
-            scope: JSON.stringify(rule.scope),
-            notifyChannels: JSON.stringify(rule.notifyChannels),
-            createdAt: rule.createdAt,
-            updatedAt: rule.updatedAt,
-            tenantId: rule.tenantId ?? 'default',
-        })
-            .run();
+        return this.alertRepo.createAlertRule(rule);
     }
-    // HIGH 8: Check affected row count and throw NotFoundError when zero
     async updateAlertRule(id, updates, tenantId) {
-        const setValues = {};
-        if (updates.name !== undefined)
-            setValues.name = updates.name;
-        if (updates.enabled !== undefined)
-            setValues.enabled = updates.enabled;
-        if (updates.condition !== undefined)
-            setValues.condition = updates.condition;
-        if (updates.threshold !== undefined)
-            setValues.threshold = updates.threshold;
-        if (updates.windowMinutes !== undefined)
-            setValues.windowMinutes = updates.windowMinutes;
-        if (updates.scope !== undefined)
-            setValues.scope = JSON.stringify(updates.scope);
-        if (updates.notifyChannels !== undefined)
-            setValues.notifyChannels = JSON.stringify(updates.notifyChannels);
-        if (updates.updatedAt !== undefined)
-            setValues.updatedAt = updates.updatedAt;
-        const whereConditions = [eq(alertRules.id, id)];
-        if (tenantId)
-            whereConditions.push(eq(alertRules.tenantId, tenantId));
-        if (Object.keys(setValues).length === 0) {
-            // Even with no actual updates, verify the rule exists
-            const existing = this.db
-                .select({ id: alertRules.id })
-                .from(alertRules)
-                .where(and(...whereConditions))
-                .get();
-            if (!existing) {
-                throw new NotFoundError(`Alert rule not found: ${id}`);
-            }
-            return;
-        }
-        const result = this.db
-            .update(alertRules)
-            .set(setValues)
-            .where(and(...whereConditions))
-            .run();
-        if (result.changes === 0) {
-            throw new NotFoundError(`Alert rule not found: ${id}`);
-        }
+        return this.alertRepo.updateAlertRule(id, updates, tenantId);
     }
     async deleteAlertRule(id, tenantId) {
-        const whereConditions = [eq(alertRules.id, id)];
-        if (tenantId)
-            whereConditions.push(eq(alertRules.tenantId, tenantId));
-        const result = this.db.delete(alertRules).where(and(...whereConditions)).run();
-        if (result.changes === 0) {
-            throw new NotFoundError(`Alert rule not found: ${id}`);
-        }
+        return this.alertRepo.deleteAlertRule(id, tenantId);
     }
     async listAlertRules(tenantId) {
-        this.warnIfNoTenant('listAlertRules', tenantId);
-        const conditions = tenantId ? [eq(alertRules.tenantId, tenantId)] : [];
-        const rows = this.db
-            .select()
-            .from(alertRules)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .all();
-        return rows.map(this._mapAlertRuleRow);
+        return this.alertRepo.listAlertRules(tenantId);
     }
     async getAlertRule(id, tenantId) {
-        const conditions = [eq(alertRules.id, id)];
-        if (tenantId)
-            conditions.push(eq(alertRules.tenantId, tenantId));
-        const row = this.db
-            .select()
-            .from(alertRules)
-            .where(and(...conditions))
-            .get();
-        return row ? this._mapAlertRuleRow(row) : null;
+        return this.alertRepo.getAlertRule(id, tenantId);
     }
-    // ─── Alert History ─────────────────────────────────────────
     async insertAlertHistory(entry) {
-        this.db
-            .insert(alertHistory)
-            .values({
-            id: entry.id,
-            ruleId: entry.ruleId,
-            triggeredAt: entry.triggeredAt,
-            resolvedAt: entry.resolvedAt ?? null,
-            currentValue: entry.currentValue,
-            threshold: entry.threshold,
-            message: entry.message,
-            tenantId: entry.tenantId ?? 'default',
-        })
-            .run();
+        return this.alertRepo.insertAlertHistory(entry);
     }
     async listAlertHistory(opts) {
-        const limit = Math.min(opts?.limit ?? 50, 500);
-        const offset = opts?.offset ?? 0;
-        const conditions = [];
-        if (opts?.ruleId) {
-            conditions.push(eq(alertHistory.ruleId, opts.ruleId));
-        }
-        if (opts?.tenantId) {
-            conditions.push(eq(alertHistory.tenantId, opts.tenantId));
-        }
-        const rows = this.db
-            .select()
-            .from(alertHistory)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .orderBy(desc(alertHistory.triggeredAt))
-            .limit(limit)
-            .offset(offset)
-            .all();
-        const totalResult = this.db
-            .select({ count: drizzleCount() })
-            .from(alertHistory)
-            .where(conditions.length > 0 ? and(...conditions) : undefined)
-            .get();
-        return {
-            entries: rows.map((row) => ({
-                id: row.id,
-                ruleId: row.ruleId,
-                triggeredAt: row.triggeredAt,
-                resolvedAt: row.resolvedAt ?? undefined,
-                currentValue: row.currentValue,
-                threshold: row.threshold,
-                message: row.message,
-                tenantId: row.tenantId,
-            })),
-            total: totalResult?.count ?? 0,
-        };
+        return this.alertRepo.listAlertHistory(opts);
     }
-    // ─── Maintenance ───────────────────────────────────────────
-    async applyRetention(olderThan, tenantId) {
-        // Build conditions — always filter by timestamp, optionally by tenant
-        const countConditions = [lte(events.timestamp, olderThan)];
-        if (tenantId)
-            countConditions.push(eq(events.tenantId, tenantId));
-        // Count events to be deleted
-        const countResult = this.db
-            .select({ count: drizzleCount() })
-            .from(events)
-            .where(and(...countConditions))
-            .get();
-        const deletedCount = countResult?.count ?? 0;
-        if (deletedCount === 0)
-            return { deletedCount: 0 };
-        this.db.transaction((tx) => {
-            if (tenantId) {
-                // Tenant-scoped retention: only delete this tenant's old events
-                tx.delete(events)
-                    .where(and(lte(events.timestamp, olderThan), eq(events.tenantId, tenantId)))
-                    .run();
-                // Clean up this tenant's sessions that have no remaining events
-                tx.run(sql `
-          DELETE FROM sessions
-          WHERE tenant_id = ${tenantId}
-            AND id NOT IN (
-              SELECT DISTINCT session_id FROM events WHERE tenant_id = ${tenantId}
-            )
-        `);
-            }
-            else {
-                // Global retention (system-level, not exposed through TenantScopedStore)
-                tx.delete(events).where(lte(events.timestamp, olderThan)).run();
-                tx.run(sql `
-          DELETE FROM sessions
-          WHERE id NOT IN (SELECT DISTINCT session_id FROM events)
-        `);
-            }
-        });
-        return { deletedCount };
+    // ─── Analytics & Stats ─────────────────────────────────────
+    async getAnalytics(params) {
+        return this.analyticsRepo.getAnalytics(params);
     }
     async getStats(tenantId) {
-        const eventConditions = tenantId ? [eq(events.tenantId, tenantId)] : [];
-        const sessionConditions = tenantId ? [eq(sessions.tenantId, tenantId)] : [];
-        const agentConditions = tenantId ? [eq(agents.tenantId, tenantId)] : [];
-        const eventCount = this.db
-            .select({ count: drizzleCount() })
-            .from(events)
-            .where(eventConditions.length > 0 ? and(...eventConditions) : undefined)
-            .get()?.count ?? 0;
-        const sessionCount = this.db
-            .select({ count: drizzleCount() })
-            .from(sessions)
-            .where(sessionConditions.length > 0 ? and(...sessionConditions) : undefined)
-            .get()?.count ?? 0;
-        const agentCount = this.db
-            .select({ count: drizzleCount() })
-            .from(agents)
-            .where(agentConditions.length > 0 ? and(...agentConditions) : undefined)
-            .get()?.count ?? 0;
-        const oldest = this.db
-            .select({ timestamp: events.timestamp })
-            .from(events)
-            .where(eventConditions.length > 0 ? and(...eventConditions) : undefined)
-            .orderBy(asc(events.timestamp))
-            .limit(1)
-            .get();
-        const newest = this.db
-            .select({ timestamp: events.timestamp })
-            .from(events)
-            .where(eventConditions.length > 0 ? and(...eventConditions) : undefined)
-            .orderBy(desc(events.timestamp))
-            .limit(1)
-            .get();
-        // SQLite page_count * page_size for storage size
-        const pageCount = this.db.get(sql `PRAGMA page_count`)
-            ?.page_count ?? 0;
-        const pageSize = this.db.get(sql `PRAGMA page_size`)
-            ?.page_size ?? 0;
-        return {
-            totalEvents: eventCount,
-            totalSessions: sessionCount,
-            totalAgents: agentCount,
-            oldestEvent: oldest?.timestamp,
-            newestEvent: newest?.timestamp,
-            storageSizeBytes: pageCount * pageSize,
-        };
-    }
-    // ─── Private Helpers ───────────────────────────────────────
-    _buildEventConditions(query) {
-        const conditions = [];
-        if (query.tenantId) {
-            conditions.push(eq(events.tenantId, query.tenantId));
-        }
-        if (query.sessionId) {
-            conditions.push(eq(events.sessionId, query.sessionId));
-        }
-        if (query.agentId) {
-            conditions.push(eq(events.agentId, query.agentId));
-        }
-        if (query.eventType) {
-            if (Array.isArray(query.eventType)) {
-                conditions.push(inArray(events.eventType, query.eventType));
-            }
-            else {
-                conditions.push(eq(events.eventType, query.eventType));
-            }
-        }
-        if (query.severity) {
-            if (Array.isArray(query.severity)) {
-                conditions.push(inArray(events.severity, query.severity));
-            }
-            else {
-                conditions.push(eq(events.severity, query.severity));
-            }
-        }
-        if (query.from) {
-            conditions.push(gte(events.timestamp, query.from));
-        }
-        if (query.to) {
-            conditions.push(lte(events.timestamp, query.to));
-        }
-        if (query.search) {
-            // H1 fix: Escape LIKE wildcards to prevent wildcard abuse
-            const escaped = query.search
-                .replace(/\\/g, '\\\\')
-                .replace(/%/g, '\\%')
-                .replace(/_/g, '\\_');
-            conditions.push(sql `${events.payload} LIKE ${'%' + escaped + '%'} ESCAPE '\\'`);
-        }
-        return conditions;
-    }
-    // HIGH 4: Use json_each() for exact tag matching with OR semantics
-    _buildSessionConditions(query) {
-        const conditions = [];
-        if (query.tenantId) {
-            conditions.push(eq(sessions.tenantId, query.tenantId));
-        }
-        if (query.agentId) {
-            conditions.push(eq(sessions.agentId, query.agentId));
-        }
-        if (query.status) {
-            if (Array.isArray(query.status)) {
-                if (query.status.length === 1) {
-                    conditions.push(eq(sessions.status, query.status[0]));
-                }
-                else if (query.status.length > 1) {
-                    conditions.push(inArray(sessions.status, query.status));
-                }
-            }
-            else {
-                conditions.push(eq(sessions.status, query.status));
-            }
-        }
-        if (query.from) {
-            conditions.push(gte(sessions.startedAt, query.from));
-        }
-        if (query.to) {
-            conditions.push(lte(sessions.startedAt, query.to));
-        }
-        if (query.tags && query.tags.length > 0) {
-            // Use json_each for exact tag matching with OR semantics
-            // A session matches if it contains ANY of the specified tags
-            const tagPlaceholders = query.tags.map((tag) => sql `${tag}`);
-            conditions.push(sql `EXISTS (
-          SELECT 1 FROM json_each(${sessions.tags}) AS je
-          WHERE je.value IN (${sql.join(tagPlaceholders, sql `, `)})
-        )`);
-        }
-        return conditions;
+        return this.analyticsRepo.getStats(tenantId);
     }
-    // HIGH 7: Use safeJsonParse everywhere
-    _mapEventRow(row) {
-        return {
-            id: row.id,
-            timestamp: row.timestamp,
-            sessionId: row.sessionId,
-            agentId: row.agentId,
-            eventType: row.eventType,
-            severity: row.severity,
-            payload: safeJsonParse(row.payload, {}),
-            metadata: safeJsonParse(row.metadata, {}),
-            prevHash: row.prevHash,
-            hash: row.hash,
-            tenantId: row.tenantId,
-        };
-    }
-    _mapSessionRow(row) {
-        return {
-            id: row.id,
-            agentId: row.agentId,
-            agentName: row.agentName ?? undefined,
-            startedAt: row.startedAt,
-            endedAt: row.endedAt ?? undefined,
-            status: row.status,
-            eventCount: row.eventCount,
-            toolCallCount: row.toolCallCount,
-            errorCount: row.errorCount,
-            totalCostUsd: row.totalCostUsd,
-            llmCallCount: row.llmCallCount,
-            totalInputTokens: row.totalInputTokens,
-            totalOutputTokens: row.totalOutputTokens,
-            tags: safeJsonParse(row.tags, []),
-            tenantId: row.tenantId,
-        };
-    }
-    _mapAgentRow(row) {
-        return {
-            id: row.id,
-            name: row.name,
-            description: row.description ?? undefined,
-            firstSeenAt: row.firstSeenAt,
-            lastSeenAt: row.lastSeenAt,
-            sessionCount: row.sessionCount,
-            tenantId: row.tenantId,
-            modelOverride: row.modelOverride ?? undefined,
-            pausedAt: row.pausedAt ?? undefined,
-            pauseReason: row.pauseReason ?? undefined,
-        };
-    }
-    _mapAlertRuleRow(row) {
-        return {
-            id: row.id,
-            name: row.name,
-            enabled: row.enabled,
-            condition: row.condition,
-            threshold: row.threshold,
-            windowMinutes: row.windowMinutes,
-            scope: safeJsonParse(row.scope, {}),
-            notifyChannels: safeJsonParse(row.notifyChannels, []),
-            createdAt: row.createdAt,
-            updatedAt: row.updatedAt,
-            tenantId: row.tenantId,
-        };
+    // ─── Maintenance ───────────────────────────────────────────
+    async applyRetention(olderThan, tenantId) {
+        return this.retentionService.applyRetention(olderThan, tenantId);
     }
 }
 //# sourceMappingURL=sqlite-store.js.map