@ai-studio-3d/vyasa 0.1.0

package/dist/core/search/index.d.ts

@@ -0,0 +1,44 @@
+import Database from 'better-sqlite3';
+import type { FoundationData, WasteData, SearchData, SessionDetailData, SessionsListData, LiveData, AnalyticsRange, AnalyticsData } from '../schema/index.js';
+export interface SearchFilters {
+    q?: string;
+    project?: string;
+    model?: string;
+    platform?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    outcome?: 'any' | 'completed' | 'abandoned';
+    limit?: number;
+    offset?: number;
+}
+export interface SessionsFilters {
+    project?: string;
+    model?: string;
+    platform?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    outcome?: 'any' | 'completed' | 'abandoned';
+    sort?: 'date' | 'cost' | 'duration';
+    tag?: string;
+    /** Include zero-value "empty" sessions (no tokens, no cost). Default false — they're noise. */
+    includeEmpty?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export declare function search(db: Database.Database, filters: SearchFilters): SearchData;
+export declare function getFoundation(db: Database.Database): FoundationData;
+type WasteRange = '7d' | '30d' | '90d' | 'all';
+export declare function getWaste(db: Database.Database, range: WasteRange): WasteData;
+export declare function getSessionDetail(db: Database.Database, sessionId: string): SessionDetailData | null;
+export declare function getSessions(db: Database.Database, filters: SessionsFilters): SessionsListData;
+/**
+ * Sessions whose last message (`endedAt`) landed inside the live window — the
+ * sessions an agent is actively writing right now. Reuses getSessions (so name
+ * resolution, tags, errorCount all come for free), then filters by recency and
+ * re-sorts by most-recent activity. The SSE `session-updated` stream + a short
+ * client poll keep this fresh, so a running session climbs in near-real-time.
+ */
+export declare function getLiveSessions(db: Database.Database, nowMs: number, windowMinutes?: number): LiveData;
+export declare function getAnalytics(db: Database.Database, range: AnalyticsRange): AnalyticsData;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/core/search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/search/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAA;AACrC,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EAGT,UAAU,EAKV,iBAAiB,EAGjB,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,aAAa,EAEd,MAAM,oBAAoB,CAAA;AAG3B,MAAM,WAAW,aAAa;IAC5B,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,WAAW,CAAA;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,WAAW,CAAA;IAC3C,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,CAAA;IACnC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,+FAA+F;IAC/F,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AA2GD,wBAAgB,MAAM,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,aAAa,GAAG,UAAU,CAuKhF;AAID,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,GAAG,cAAc,CAyCnE;AAID,KAAK,UAAU,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;AAU9C,wBAAgB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,CAmD5E;AAgCD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,SAAS,EAAE,MAAM,GAChB,iBAAiB,GAAG,IAAI,CA2F1B;AAID,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,eAAe,GAAG,gBAAgB,CAsI7F;AAID;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,SAAK,GAAG,QAAQ,CAOlG;AAID,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,GAAG,aAAa,CAqLxF"}

package/dist/core/search/index.js

@@ -0,0 +1,641 @@
+import { normalizeTag, resolveName, getSessionMeta } from '../tags/index.js';
+/** A session that produced no measurable work: no tokens and no cost. Pure noise in the list
+ *  (e.g. Cursor globalStorage rows, instantly-abandoned sessions). Hidden by default. */
+const EMPTY_SESSION_SQL = '(total_input_tokens + total_output_tokens + total_cache_read + total_cache_creation = 0 AND total_cost_cents = 0)';
+function loadPricingMap(db) {
+    // ASC order so later entries (most recent period_start) overwrite earlier ones
+    const rows = db
+        .prepare(`SELECT model, input_per_mtok, output_per_mtok, cache_write_per_mtok, cache_read_per_mtok
+       FROM pricing ORDER BY period_start ASC`)
+        .all();
+    const map = new Map();
+    for (const row of rows)
+        map.set(row.model, row);
+    return map;
+}
+function costCents(pricing, inputTokens, outputTokens, cacheCreation, cacheRead) {
+    // Grouped arithmetic matches the ingest formula to avoid floating-point divergence
+    return (((inputTokens * pricing.input_per_mtok +
+        outputTokens * pricing.output_per_mtok +
+        cacheCreation * pricing.cache_write_per_mtok +
+        cacheRead * pricing.cache_read_per_mtok) /
+        1_000_000) *
+        100);
+}
+// ─── sanitise FTS5 query ─────────────────────────────────────────────────────
+function sanitiseFts(q) {
+    const escaped = q.replace(/"/g, '""');
+    return `"${escaped}"`;
+}
+// Escape HTML in FTS5 snippet output, then restore only our intentional <mark> delimiters.
+// FTS5 snippet() does not escape source text, so user JSONL may contain HTML/script tags.
+function escapeSnippet(raw) {
+    return raw
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/&lt;mark&gt;/g, '<mark>')
+        .replace(/&lt;\/mark&gt;/g, '</mark>');
+}
+// ─── search() ────────────────────────────────────────────────────────────────
+// FTS column layout (migration 0011): 0 session_id, 1 message_id, 2 content,
+// 3 tool_inputs, 4 tool_outputs, 5 errors. snippet() takes the absolute column index.
+const FTS_COL_CONTENT = 2;
+const FTS_COL_TOOL_INPUT = 3;
+const FTS_COL_TOOL_OUTPUT = 4;
+// Max hits surfaced per session in the grouped view (the rest roll up into hitCount).
+const HITS_PER_SESSION = 4;
+/** Pick which FTS column actually matched (so we can chip the hit's kind) and return the
+ *  best snippet for display. A snippet contains a real hit only if it carries a <mark>.
+ *  Precedence when several columns matched: prose first, then tool input, then tool output. */
+function pickHit(row) {
+    const hasMark = (s) => s.includes('<mark>');
+    if (hasMark(row.snip_content))
+        return { kind: 'text', snippet: escapeSnippet(row.snip_content) };
+    if (hasMark(row.snip_input))
+        return { kind: 'tool_input', snippet: escapeSnippet(row.snip_input) };
+    if (hasMark(row.snip_output))
+        return { kind: 'tool_output', snippet: escapeSnippet(row.snip_output) };
+    // No mark anywhere (rare — e.g. prefix/column-scoped quirks). Fall back to prose text.
+    return { kind: 'text', snippet: row.snip_content ? escapeSnippet(row.snip_content) : '' };
+}
+export function search(db, filters) {
+    const rawLimit = filters.limit ?? 20;
+    const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 100) : 20;
+    const rawOffset = filters.offset ?? 0;
+    const offset = Number.isFinite(rawOffset) && rawOffset >= 0 ? rawOffset : 0;
+    const q = filters.q?.trim() ?? '';
+    // Build filter clauses (applied after the base query)
+    const extraWhere = [];
+    const extraParams = [];
+    if (filters.project) {
+        extraWhere.push('s.project = ?');
+        extraParams.push(filters.project);
+    }
+    if (filters.model) {
+        extraWhere.push('first_msg.model = ?');
+        extraParams.push(filters.model);
+    }
+    if (filters.platform) {
+        extraWhere.push('s.platform = ?');
+        extraParams.push(filters.platform);
+    }
+    if (filters.dateFrom) {
+        extraWhere.push('s.started_at >= ?');
+        extraParams.push(filters.dateFrom);
+    }
+    if (filters.dateTo) {
+        extraWhere.push('s.started_at <= ?');
+        extraParams.push(filters.dateTo);
+    }
+    if (filters.outcome && filters.outcome !== 'any') {
+        extraWhere.push('s.last_outcome = ?');
+        extraParams.push(filters.outcome);
+    }
+    const whereClause = extraWhere.length > 0 ? ' AND ' + extraWhere.join(' AND ') : '';
+    // Shared session columns + name-resolution joins (session_meta drives the display name).
+    const sessionCols = `s.project, s.platform, s.started_at, s.last_outcome,
+             sm.custom_name, sm.claude_custom_title, sm.claude_ai_title`;
+    const sessionJoins = `LEFT JOIN session_meta sm ON sm.session_id = s.id`;
+    let baseQuery;
+    let countQuery;
+    let baseParams;
+    if (q) {
+        const ftsQuery = sanitiseFts(q);
+        // One snippet() per indexed text column so we can tag the hit's kind by which one marked.
+        baseQuery = `
+      SELECT fts.session_id, fts.message_id,
+             snippet(messages_fts, ${FTS_COL_CONTENT}, '<mark>', '</mark>', '...', 10) AS snip_content,
+             snippet(messages_fts, ${FTS_COL_TOOL_INPUT}, '<mark>', '</mark>', '...', 10) AS snip_input,
+             snippet(messages_fts, ${FTS_COL_TOOL_OUTPUT}, '<mark>', '</mark>', '...', 10) AS snip_output,
+             m.idx, first_msg.model, ${sessionCols}
+      FROM messages_fts fts
+      JOIN messages m ON m.id = fts.message_id
+      JOIN sessions s ON s.id = fts.session_id
+      ${sessionJoins}
+      LEFT JOIN messages first_msg ON first_msg.session_id = s.id AND first_msg.idx = 0
+      WHERE messages_fts MATCH ?${whereClause}
+      ORDER BY rank
+    `;
+        countQuery = `
+      SELECT COUNT(*) as n
+      FROM messages_fts fts
+      JOIN messages m ON m.id = fts.message_id
+      JOIN sessions s ON s.id = fts.session_id
+      LEFT JOIN messages first_msg ON first_msg.session_id = s.id AND first_msg.idx = 0
+      WHERE messages_fts MATCH ?${whereClause}
+    `;
+        baseParams = [ftsQuery, ...extraParams];
+    }
+    else {
+        // No query: list the most recent sessions (one row each, via their first message).
+        baseQuery = `
+      SELECT s.id AS session_id, m.id AS message_id,
+             '' AS snip_content, '' AS snip_input, '' AS snip_output,
+             m.idx, m.model, ${sessionCols}
+      FROM sessions s
+      JOIN messages m ON m.session_id = s.id AND m.idx = 0
+      ${sessionJoins}
+      WHERE 1=1${whereClause}
+      ORDER BY s.started_at DESC
+    `;
+        countQuery = `
+      SELECT COUNT(*) as n
+      FROM sessions s
+      JOIN messages m ON m.session_id = s.id AND m.idx = 0
+      WHERE 1=1${whereClause}
+    `;
+        baseParams = extraParams;
+    }
+    const total = db.prepare(countQuery).get(...baseParams).n;
+    const paginatedQuery = baseQuery + ' LIMIT ? OFFSET ?';
+    const rows = db.prepare(paginatedQuery).all(...baseParams, limit, offset);
+    const enriched = rows.map((r) => ({ row: r, ...pickHit(r) }));
+    // Flat list — kept for back-compat with callers/tests that read results/total.
+    const results = enriched.map(({ row, snippet }) => ({
+        sessionId: row.session_id,
+        messageId: row.message_id,
+        msgIdx: row.idx,
+        snippet,
+        session: {
+            project: row.project,
+            startedAt: row.started_at,
+            model: row.model,
+        },
+    }));
+    // Grouped view — collapse this page's hits by session, preserving rank order of first
+    // appearance. Each group caps its surfaced hits (ordered by msgIdx) but counts them all.
+    const groupMap = new Map();
+    const order = [];
+    for (const { row, kind, snippet } of enriched) {
+        let group = groupMap.get(row.session_id);
+        if (!group) {
+            group = {
+                sessionId: row.session_id,
+                project: row.project,
+                name: resolveName({
+                    id: row.session_id,
+                    project: row.project,
+                    custom_name: row.custom_name,
+                    claude_custom_title: row.claude_custom_title,
+                    claude_ai_title: row.claude_ai_title,
+                }),
+                platform: row.platform,
+                startedAt: row.started_at,
+                model: row.model,
+                lastOutcome: row.last_outcome,
+                hitCount: 0,
+                hits: [],
+            };
+            groupMap.set(row.session_id, group);
+            order.push(row.session_id);
+        }
+        group.hitCount += 1;
+        group.hits.push({ msgIdx: row.idx, snippet, kind });
+    }
+    const groups = order.map((id) => {
+        const g = groupMap.get(id);
+        const hits = [...g.hits].sort((a, b) => a.msgIdx - b.msgIdx).slice(0, HITS_PER_SESSION);
+        return { ...g, hits };
+    });
+    // Distinct sessions across the WHOLE result set (not just this page), so the UI can show
+    // "N sessions" even while paginating hits.
+    const sessionTotal = q
+        ? db
+            .prepare(`SELECT COUNT(DISTINCT fts.session_id) AS n
+           FROM messages_fts fts
+           JOIN messages m ON m.id = fts.message_id
+           JOIN sessions s ON s.id = fts.session_id
+           LEFT JOIN messages first_msg ON first_msg.session_id = s.id AND first_msg.idx = 0
+           WHERE messages_fts MATCH ?${whereClause}`)
+            .get(...baseParams).n
+        : total;
+    return { total, results, sessionTotal, groups };
+}
+// ─── getFoundation() ─────────────────────────────────────────────────────────
+export function getFoundation(db) {
+    const { totalCostCents } = db
+        .prepare(`SELECT COALESCE(SUM(total_cost_cents), 0) AS totalCostCents
+       FROM sessions
+       WHERE started_at >= datetime('now', '-7 days')`)
+        .get();
+    const { sumRead, sumDenom } = db
+        .prepare(`SELECT COALESCE(SUM(total_cache_read), 0) AS sumRead,
+              COALESCE(SUM(total_input_tokens + total_cache_read), 0) AS sumDenom
+       FROM sessions
+       WHERE started_at >= datetime('now', '-30 days')`)
+        .get();
+    const cacheHitRateLast30Days = sumDenom === 0 ? 0 : sumRead / sumDenom;
+    const modelRows = db
+        .prepare(`SELECT m.model, SUM(u.output_tokens) AS total_output
+       FROM messages m JOIN usage u ON u.message_id = m.id
+       WHERE m.model IS NOT NULL
+       GROUP BY m.model
+       ORDER BY total_output DESC`)
+        .all();
+    const grandTotal = modelRows.reduce((acc, r) => acc + r.total_output, 0);
+    const modelMix = modelRows.map((r) => ({
+        model: r.model,
+        pct: grandTotal === 0 ? 0 : (r.total_output / grandTotal) * 100,
+    }));
+    return {
+        totalCostCentsThisWeek: totalCostCents,
+        cacheHitRateLast30Days,
+        modelMix,
+    };
+}
+function rangeToCutoff(range) {
+    if (range === 'all')
+        return null;
+    const days = range === '7d' ? 7 : range === '30d' ? 30 : 90;
+    const d = new Date();
+    d.setDate(d.getDate() - days);
+    return d.toISOString();
+}
+export function getWaste(db, range) {
+    const cutoff = rangeToCutoff(range);
+    const rows = db
+        .prepare(`SELECT wa.session_id, wa.category, wa.amount_cents, wa.anchor_msg_idx, wa.evidence_json,
+              s.project, s.started_at
+       FROM waste_attributions wa
+       JOIN sessions s ON s.id = wa.session_id
+       WHERE (? IS NULL OR s.started_at >= ?)
+       ORDER BY wa.category, wa.amount_cents DESC`)
+        .all(cutoff, cutoff);
+    // Group by category
+    const categoryMap = new Map();
+    for (const row of rows) {
+        if (!categoryMap.has(row.category))
+            categoryMap.set(row.category, []);
+        categoryMap.get(row.category).push({
+            sessionId: row.session_id,
+            project: row.project,
+            startedAt: row.started_at,
+            amountCents: row.amount_cents,
+            anchorMsgIdx: row.anchor_msg_idx,
+            evidenceJson: row.evidence_json,
+        });
+    }
+    const categories = [];
+    let totalCents = 0;
+    for (const [category, sessions] of categoryMap) {
+        const catTotal = sessions.reduce((acc, s) => acc + s.amountCents, 0);
+        totalCents += catTotal;
+        categories.push({
+            category,
+            totalCents: catTotal,
+            sessionCount: sessions.length,
+            sessions,
+        });
+    }
+    return { totalCents, categories };
+}
+export function getSessionDetail(db, sessionId) {
+    const sessionRow = db
+        .prepare(`SELECT id, project, platform, started_at, ended_at, message_count,
+              total_input_tokens, total_output_tokens, total_cache_creation,
+              total_cache_read, total_cost_cents, last_outcome
+       FROM sessions WHERE id = ?`)
+        .get(sessionId);
+    if (!sessionRow)
+        return null;
+    const msgRows = db
+        .prepare(`SELECT m.id, m.idx, m.ts, m.role, m.model, m.content_json,
+              u.input_tokens, u.output_tokens, u.cache_creation_tokens, u.cache_read_tokens
+       FROM messages m
+       LEFT JOIN usage u ON u.message_id = m.id
+       WHERE m.session_id = ?
+       ORDER BY m.idx ASC`)
+        .all(sessionId);
+    const pricingMap = loadPricingMap(db);
+    const messages = [];
+    const timeline = [];
+    let cumulativeCostCents = 0;
+    for (const row of msgRows) {
+        const detail = {
+            id: row.id,
+            idx: row.idx,
+            role: row.role,
+            ts: row.ts,
+            model: row.model,
+            contentJson: row.content_json,
+        };
+        if (row.input_tokens != null)
+            detail.inputTokens = row.input_tokens;
+        if (row.output_tokens != null)
+            detail.outputTokens = row.output_tokens;
+        if (row.cache_creation_tokens != null)
+            detail.cacheCreationTokens = row.cache_creation_tokens;
+        if (row.cache_read_tokens != null)
+            detail.cacheReadTokens = row.cache_read_tokens;
+        messages.push(detail);
+        // Accumulate cost for assistant messages with usage
+        if (row.role === 'assistant' && row.model && row.input_tokens != null) {
+            const pricing = pricingMap.get(row.model);
+            if (pricing) {
+                cumulativeCostCents += costCents(pricing, row.input_tokens ?? 0, row.output_tokens ?? 0, row.cache_creation_tokens ?? 0, row.cache_read_tokens ?? 0);
+            }
+        }
+        timeline.push({
+            msgIdx: row.idx,
+            ts: row.ts,
+            cumulativeCostCents,
+        });
+    }
+    const meta = getSessionMeta(db, sessionRow.id);
+    return {
+        session: {
+            id: sessionRow.id,
+            project: sessionRow.project,
+            platform: sessionRow.platform,
+            startedAt: sessionRow.started_at,
+            endedAt: sessionRow.ended_at,
+            messageCount: sessionRow.message_count,
+            totalInputTokens: sessionRow.total_input_tokens,
+            totalOutputTokens: sessionRow.total_output_tokens,
+            totalCacheCreation: sessionRow.total_cache_creation,
+            totalCacheRead: sessionRow.total_cache_read,
+            totalCostCents: sessionRow.total_cost_cents,
+            lastOutcome: sessionRow.last_outcome,
+            name: meta.name,
+            customName: meta.customName,
+            tags: meta.tags,
+        },
+        messages,
+        timeline,
+        // Default empty; the session-detail route overrides this with getDecisions() (F3).
+        decisions: [],
+    };
+}
+// ─── getSessions() ────────────────────────────────────────────────────────────
+export function getSessions(db, filters) {
+    const rawLimit = filters.limit ?? 50;
+    const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 200) : 50;
+    const rawOffset = filters.offset ?? 0;
+    const offset = Number.isFinite(rawOffset) && rawOffset >= 0 ? rawOffset : 0;
+    const validSorts = {
+        date: 'started_at DESC',
+        cost: 'total_cost_cents DESC',
+        duration: '(CASE WHEN started_at IS NOT NULL AND ended_at IS NOT NULL THEN (julianday(ended_at) - julianday(started_at)) * 86400000 ELSE NULL END) DESC NULLS LAST',
+    };
+    const sortKey = filters.sort && Object.hasOwn(validSorts, filters.sort) ? filters.sort : 'date';
+    const orderClause = validSorts[sortKey];
+    const where = [];
+    const params = [];
+    if (filters.project) {
+        where.push('project = ?');
+        params.push(filters.project);
+    }
+    if (filters.model) {
+        where.push('EXISTS (SELECT 1 FROM messages WHERE session_id = sessions.id AND model = ?)');
+        params.push(filters.model);
+    }
+    if (filters.platform) {
+        where.push('platform = ?');
+        params.push(filters.platform);
+    }
+    if (filters.dateFrom) {
+        where.push('started_at >= ?');
+        params.push(filters.dateFrom);
+    }
+    if (filters.dateTo) {
+        where.push('started_at <= ?');
+        params.push(filters.dateTo);
+    }
+    if (filters.outcome && filters.outcome !== 'any') {
+        where.push('last_outcome = ?');
+        params.push(filters.outcome);
+    }
+    if (filters.tag) {
+        where.push('EXISTS (SELECT 1 FROM session_tags st WHERE st.session_id = sessions.id AND st.tag = ?)');
+        params.push(normalizeTag(filters.tag));
+    }
+    // How many sessions (under the OTHER filters) are zero-value "empty" — surfaced so the UI can
+    // say "N hidden" with a toggle. Computed before the empty-exclusion is added to the where.
+    const hiddenEmptyCount = filters.includeEmpty
+        ? 0
+        : db.prepare(`SELECT COUNT(*) as n FROM sessions ${where.length ? 'WHERE ' + where.join(' AND ') + ' AND ' : 'WHERE '}${EMPTY_SESSION_SQL}`).get(...params).n;
+    // Hide zero-value sessions by default.
+    if (!filters.includeEmpty)
+        where.push(`NOT ${EMPTY_SESSION_SQL}`);
+    const whereClause = where.length > 0 ? 'WHERE ' + where.join(' AND ') : '';
+    const total = db.prepare(`SELECT COUNT(*) as n FROM sessions ${whereClause}`).get(...params).n;
+    const rows = db
+        .prepare(`SELECT sessions.id, project, platform, started_at, ended_at, message_count,
+              total_cost_cents, total_input_tokens, total_output_tokens,
+              total_cache_read, last_outcome,
+              m.custom_name AS custom_name,
+              m.claude_custom_title AS claude_custom_title,
+              m.claude_ai_title AS claude_ai_title,
+              CASE WHEN started_at IS NOT NULL AND ended_at IS NOT NULL
+                   THEN CAST((julianday(ended_at) - julianday(started_at)) * 86400000 AS INTEGER)
+                   ELSE NULL END AS duration_ms,
+              (SELECT COUNT(*) FROM tool_calls tc
+                 JOIN messages msg ON msg.id = tc.message_id
+                 WHERE msg.session_id = sessions.id AND tc.error IS NOT NULL) AS error_count
+       FROM sessions LEFT JOIN session_meta m ON m.session_id = sessions.id ${whereClause}
+       ORDER BY ${orderClause}
+       LIMIT ? OFFSET ?`)
+        .all(...params, limit, offset);
+    // Batch-fetch tags for this page (no N+1)
+    const tagsBySession = new Map();
+    if (rows.length > 0) {
+        const placeholders = rows.map(() => '?').join(',');
+        const tagRows = db
+            .prepare(`SELECT session_id, tag FROM session_tags WHERE session_id IN (${placeholders}) ORDER BY tag`)
+            .all(...rows.map((r) => r.id));
+        for (const tr of tagRows) {
+            const list = tagsBySession.get(tr.session_id) ?? [];
+            list.push(tr.tag);
+            tagsBySession.set(tr.session_id, list);
+        }
+    }
+    return {
+        total,
+        hiddenEmptyCount,
+        sessions: rows.map((r) => ({
+            id: r.id,
+            project: r.project,
+            platform: r.platform,
+            startedAt: r.started_at,
+            endedAt: r.ended_at,
+            messageCount: r.message_count,
+            totalCostCents: r.total_cost_cents,
+            totalInputTokens: r.total_input_tokens,
+            totalOutputTokens: r.total_output_tokens,
+            totalCacheRead: r.total_cache_read,
+            lastOutcome: r.last_outcome,
+            durationMs: r.duration_ms,
+            errorCount: r.error_count,
+            name: resolveName(r),
+            tags: tagsBySession.get(r.id) ?? [],
+        })),
+    };
+}
+// ─── getLiveSessions() ────────────────────────────────────────────────────────
+/**
+ * Sessions whose last message (`endedAt`) landed inside the live window — the
+ * sessions an agent is actively writing right now. Reuses getSessions (so name
+ * resolution, tags, errorCount all come for free), then filters by recency and
+ * re-sorts by most-recent activity. The SSE `session-updated` stream + a short
+ * client poll keep this fresh, so a running session climbs in near-real-time.
+ */
+export function getLiveSessions(db, nowMs, windowMinutes = 15) {
+    const cutoffIso = new Date(nowMs - windowMinutes * 60_000).toISOString();
+    const { sessions } = getSessions(db, { sort: 'date', limit: 200 });
+    const live = sessions
+        .filter((s) => s.endedAt != null && s.endedAt >= cutoffIso)
+        .sort((a, b) => (b.endedAt ?? '').localeCompare(a.endedAt ?? ''));
+    return { now: nowMs, windowMinutes, sessions: live };
+}
+// ─── getAnalytics() ───────────────────────────────────────────────────────────
+export function getAnalytics(db, range) {
+    const cutoff = range === 'all'
+        ? null
+        : (() => {
+            const days = range === '7d' ? 7 : range === '30d' ? 30 : 90;
+            const d = new Date();
+            d.setDate(d.getDate() - days);
+            return d.toISOString();
+        })();
+    const cutoffClause = cutoff ? 'WHERE started_at >= ?' : '';
+    const cutoffParam = cutoff ? [cutoff] : [];
+    const dailyCutoffClause = cutoff
+        ? 'WHERE started_at IS NOT NULL AND started_at >= ?'
+        : 'WHERE started_at IS NOT NULL';
+    const dailyRows = db
+        .prepare(`SELECT strftime('%Y-%m-%d', started_at) AS date,
+              SUM(total_cost_cents) AS costCents,
+              COUNT(*) AS sessionCount
+       FROM sessions ${dailyCutoffClause}
+       GROUP BY strftime('%Y-%m-%d', started_at)
+       ORDER BY date ASC`)
+        .all(...cutoffParam);
+    const projectRows = db
+        .prepare(`SELECT project,
+              SUM(total_cost_cents) AS costCents,
+              COUNT(*) AS sessionCount
+       FROM sessions ${cutoffClause}
+       GROUP BY project
+       ORDER BY costCents DESC
+       LIMIT 10`)
+        .all(...cutoffParam);
+    // modelCost: join messages + usage, filter by session start date
+    const sessionJoin = cutoff
+        ? 'JOIN sessions s ON s.id = m.session_id WHERE s.started_at >= ? AND m.model IS NOT NULL'
+        : 'JOIN sessions s ON s.id = m.session_id WHERE m.model IS NOT NULL';
+    const modelRows = db
+        .prepare(`SELECT m.model,
+              SUM(u.output_tokens) AS outputTokens,
+              SUM(u.input_tokens) AS inputTokens,
+              SUM(u.cache_creation_tokens) AS cacheCreation,
+              SUM(u.cache_read_tokens) AS cacheRead
+       FROM messages m
+       JOIN usage u ON u.message_id = m.id
+       ${sessionJoin}
+       GROUP BY m.model
+       ORDER BY outputTokens DESC
+       LIMIT 10`)
+        .all(...cutoffParam);
+    const pricingMap = loadPricingMap(db);
+    const modelCost = modelRows.map((r) => {
+        const pricing = pricingMap.get(r.model);
+        const cost = pricing
+            ? costCents(pricing, r.inputTokens, r.outputTokens, r.cacheCreation, r.cacheRead)
+            : 0;
+        return { model: r.model, costCents: cost, outputTokens: r.outputTokens };
+    });
+    // dailyTokens: tokens (in+out) per calendar day — tokens are the truer effort signal
+    // than dollars, which read $0 on most sessions.
+    const dailyTokenRows = db
+        .prepare(`SELECT strftime('%Y-%m-%d', started_at) AS date,
+              SUM(total_input_tokens + total_output_tokens) AS tokens
+       FROM sessions ${dailyCutoffClause}
+       GROUP BY strftime('%Y-%m-%d', started_at)
+       ORDER BY date ASC`)
+        .all(...cutoffParam);
+    // summary: headline stats across the range.
+    const summaryRow = db
+        .prepare(`SELECT COUNT(*) AS totalSessions,
+              SUM(total_input_tokens + total_output_tokens) AS totalTokens,
+              COUNT(DISTINCT strftime('%Y-%m-%d', started_at)) AS activeDays
+       FROM sessions ${dailyCutoffClause}`)
+        .get(...cutoffParam);
+    // activityClock: day-of-week (%w → 0=Sun..6=Sat) × hour (%H), in LOCAL time, so the
+    // grid reflects when the user actually worked. Error counts come from tool_calls.
+    const clockRows = db
+        .prepare(`SELECT CAST(strftime('%w', started_at, 'localtime') AS INTEGER) AS dayOfWeek,
+              CAST(strftime('%H', started_at, 'localtime') AS INTEGER) AS hour,
+              COUNT(*) AS sessionCount,
+              SUM(total_input_tokens + total_output_tokens) AS tokens
+       FROM sessions ${dailyCutoffClause}
+       GROUP BY dayOfWeek, hour`)
+        .all(...cutoffParam);
+    // Error tool-calls per bucket — joined through messages→sessions, anchored on the
+    // session's local start hour/day so the tint aligns with the same grid cell.
+    const errorRows = db
+        .prepare(`SELECT CAST(strftime('%w', s.started_at, 'localtime') AS INTEGER) AS dayOfWeek,
+              CAST(strftime('%H', s.started_at, 'localtime') AS INTEGER) AS hour,
+              COUNT(*) AS errorCount
+       FROM tool_calls tc
+       JOIN messages m ON m.id = tc.message_id
+       JOIN sessions s ON s.id = m.session_id
+       WHERE tc.error IS NOT NULL AND s.started_at IS NOT NULL
+       ${cutoff ? 'AND s.started_at >= ?' : ''}
+       GROUP BY dayOfWeek, hour`)
+        .all(...cutoffParam);
+    const errorByCell = new Map();
+    for (const e of errorRows)
+        errorByCell.set(e.dayOfWeek * 24 + e.hour, e.errorCount);
+    let maxSessions = 0;
+    let maxTokens = 0;
+    let busiestHour = null;
+    let busiestHourCount = -1;
+    const hourTotals = new Array(24).fill(0);
+    const cells = clockRows.map((r) => {
+        const tokens = r.tokens ?? 0;
+        if (r.sessionCount > maxSessions)
+            maxSessions = r.sessionCount;
+        if (tokens > maxTokens)
+            maxTokens = tokens;
+        hourTotals[r.hour] += r.sessionCount;
+        return {
+            dayOfWeek: r.dayOfWeek,
+            hour: r.hour,
+            sessionCount: r.sessionCount,
+            tokens,
+            errorCount: errorByCell.get(r.dayOfWeek * 24 + r.hour) ?? 0,
+        };
+    });
+    for (let h = 0; h < 24; h++) {
+        if (hourTotals[h] > busiestHourCount) {
+            busiestHourCount = hourTotals[h];
+            busiestHour = hourTotals[h] > 0 ? h : busiestHour;
+        }
+    }
+    if (busiestHourCount <= 0)
+        busiestHour = null;
+    return {
+        range,
+        dailyCost: dailyRows.map((r) => ({
+            date: r.date,
+            costCents: r.costCents,
+            sessionCount: r.sessionCount,
+        })),
+        projectCost: projectRows.map((r) => ({
+            project: r.project,
+            costCents: r.costCents,
+            sessionCount: r.sessionCount,
+        })),
+        modelCost,
+        dailyTokens: dailyTokenRows.map((r) => ({ date: r.date, tokens: r.tokens ?? 0 })),
+        summary: {
+            totalSessions: summaryRow.totalSessions,
+            totalTokens: summaryRow.totalTokens ?? 0,
+            activeDays: summaryRow.activeDays,
+            busiestHour,
+        },
+        activityClock: { cells, maxSessions, maxTokens },
+    };
+}
+//# sourceMappingURL=index.js.map