escribano 0.1.0

package/dist/services/subject-grouping.js

@@ -0,0 +1,342 @@
+/**
+ * Escribano - Subject Grouping Service
+ *
+ * Groups TopicBlocks into coherent subjects using LLM-based clustering.
+ * This is the foundation for the new artifact architecture.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const PERSONAL_APPS = new Set([
+    'WhatsApp',
+    'Instagram',
+    'TikTok',
+    'Telegram',
+    'Facebook',
+    'Twitter',
+    'Snapchat',
+    'Discord',
+    'Messenger',
+    'Signal',
+    'FaceTime',
+    'iMessage',
+    'Messages',
+]);
+const PERSONAL_APP_THRESHOLD = 0.5;
+const SUBJECT_GROUPING_MODEL = process.env.ESCRIBANO_SUBJECT_GROUPING_MODEL || 'qwen3.5:27b';
+export async function groupTopicBlocksIntoSubjects(topicBlocks, intelligence, recordingId) {
+    if (topicBlocks.length === 0) {
+        return {
+            subjects: [],
+            personalDuration: 0,
+            workDuration: 0,
+        };
+    }
+    const blocksForGrouping = topicBlocks.map(extractBlockForGrouping);
+    const prompt = buildGroupingPrompt(blocksForGrouping);
+    console.log(`[subject-grouping] Grouping ${topicBlocks.length} blocks into subjects (model: ${SUBJECT_GROUPING_MODEL})`);
+    try {
+        const response = await intelligence.generateText(prompt, {
+            expectJson: false,
+            model: SUBJECT_GROUPING_MODEL,
+            numPredict: 2000,
+            think: false,
+        });
+        console.log(`[subject-grouping] LLM response (${response.length} chars):\n${response.slice(0, 500)}${response.length > 500 ? '...' : ''}`);
+        const grouping = parseGroupingResponse(response, topicBlocks);
+        console.log(`[subject-grouping] Parsed ${grouping.groups.length} groups: ${grouping.groups.map((g) => g.label).join(', ')}`);
+        const subjects = grouping.groups.map((group, index) => {
+            const subjectId = `subject-${recordingId}-${index}`;
+            const blocks = group.blockIds
+                .map((id) => topicBlocks.find((b) => b.id === id))
+                .filter((b) => b !== undefined);
+            const totalDuration = blocks.reduce((sum, b) => {
+                const classification = parseClassification(b);
+                return sum + (classification?.duration ?? 0);
+            }, 0);
+            const activityBreakdown = {};
+            const appsSet = new Set();
+            for (const block of blocks) {
+                const classification = parseClassification(block);
+                if (classification) {
+                    const activity = classification.activity_type || 'other';
+                    activityBreakdown[activity] =
+                        (activityBreakdown[activity] || 0) + (classification.duration ?? 0);
+                    if (classification.apps) {
+                        for (const app of classification.apps) {
+                            appsSet.add(app);
+                        }
+                    }
+                }
+            }
+            const isPersonal = detectPersonalSubject(appsSet, activityBreakdown);
+            return {
+                id: subjectId,
+                recordingId,
+                label: group.label,
+                topicBlockIds: group.blockIds,
+                totalDuration,
+                activityBreakdown,
+                apps: [...appsSet],
+                isPersonal,
+            };
+        });
+        const personalDuration = subjects
+            .filter((s) => s.isPersonal)
+            .reduce((sum, s) => sum + s.totalDuration, 0);
+        const workDuration = subjects
+            .filter((s) => !s.isPersonal)
+            .reduce((sum, s) => sum + s.totalDuration, 0);
+        return {
+            subjects,
+            personalDuration,
+            workDuration,
+        };
+    }
+    catch (error) {
+        const err = error;
+        const errorType = err.name || 'Error';
+        const errorMessage = err.message || String(err);
+        console.error(`[subject-grouping] LLM grouping failed (${errorType}): ${errorMessage}`);
+        if (err.stack) {
+            console.error(`[subject-grouping] Stack trace:`, err.stack.split('\n').slice(0, 3).join('\n'));
+        }
+        return createFallbackGrouping(topicBlocks, recordingId);
+    }
+}
+function extractBlockForGrouping(block) {
+    const classification = parseClassification(block);
+    return {
+        id: block.id,
+        startTime: classification?.start_time ?? 0,
+        endTime: classification?.end_time ?? 0,
+        duration: classification?.duration ?? 0,
+        activityType: classification?.activity_type || 'other',
+        keyDescription: classification?.key_description ?? '',
+        apps: classification?.apps ?? [],
+        topics: classification?.topics ?? [],
+    };
+}
+function parseClassification(block) {
+    if (!block.classification)
+        return null;
+    try {
+        return JSON.parse(block.classification);
+    }
+    catch {
+        return null;
+    }
+}
+function buildGroupingPrompt(blocks) {
+    const blockDescriptions = blocks
+        .map((b, i) => {
+        return `BLOCK ${i + 1}:
+Time: ${formatTime(b.startTime)} - ${formatTime(b.endTime)} (${formatDuration(b.duration)})
+Activity: ${b.activityType}
+Description: ${b.keyDescription}
+Apps: ${b.apps.join(', ') || 'none'}
+Topics: ${b.topics.join(', ') || 'none'}
+ID: ${b.id}`;
+    })
+        .join('\n\n');
+    const blockIdList = blocks.map((b) => b.id);
+    const exampleBlockIds = blockIdList.length >= 2
+        ? `"${blockIdList[0]}", "${blockIdList[1]}"`
+        : `"${blockIdList[0]}"`;
+    let template;
+    try {
+        const promptPath = join(process.cwd(), 'prompts', 'subject-grouping.md');
+        template = readFileSync(promptPath, 'utf-8');
+    }
+    catch {
+        // Fallback inline prompt if file not found
+        template = `You are analyzing a work session that has been divided into {{BLOCK_COUNT}} segments (TopicBlocks).
+
+Your task is to group these segments into 1-6 coherent SUBJECTS. A subject represents a distinct thread of work (e.g., "Escribano pipeline optimization", "Personal time", "Email and admin", "Research on competitors").
+
+GROUPING RULES:
+1. Group segments that belong to the same work thread, even if they're not consecutive in time
+2. Personal activities (WhatsApp, Instagram, social media, personal calls) should be grouped into a "Personal" subject
+3. Email/calendar/admin is only its own group when email IS the primary activity — not just because an email app was open in the background
+4. Deep work on the same project/codebase should be grouped together
+5. Research sessions should be grouped separately from coding sessions unless clearly related
+
+RULE PRIORITY (when in doubt):
+- Classify by primary ACTIVITY TYPE and project context, not by which apps happened to be open
+- If all segments are about the same project, one group is correct — do not invent artificial splits
+
+SEGMENTS TO GROUP:
+{{BLOCK_DESCRIPTIONS}}
+
+For each group, output ONE line in this EXACT format:
+Group 1: label: [Descriptive subject name] | blockIds: [uuid1, uuid2, uuid3]
+
+Example output:
+Group 1: label: Escribano VLM Integration | blockIds: [{{EXAMPLE_BLOCK_IDS}}]
+
+CRITICAL REQUIREMENTS:
+- Each group MUST have "label" and "blockIds"
+- Block IDs are the UUIDs shown in each BLOCK above (copy them exactly)
+- Include ALL {{BLOCK_COUNT}} block IDs across all groups (every block must be assigned exactly once)
+- Create 1-6 groups (one group is fine if all work is the same project)
+- Use clear, descriptive labels for each subject
+- Output ONLY the group lines — no explanation, no preamble, no markdown`;
+    }
+    // Replace template variables
+    return template
+        .replaceAll('{{BLOCK_COUNT}}', String(blocks.length))
+        .replace('{{BLOCK_DESCRIPTIONS}}', blockDescriptions)
+        .replace('{{EXAMPLE_BLOCK_IDS}}', exampleBlockIds);
+}
+function parseGroupingResponse(response, topicBlocks) {
+    const validBlockIds = new Set(topicBlocks.map((b) => b.id));
+    const groups = [];
+    const lines = response.split('\n').filter((line) => line.trim());
+    const groupRegex = /^Group\s+\d+:\s*label:\s*(.+?)\s*\|\s*blockIds:\s*\[(.+?)\]$/i;
+    let matchedLines = 0;
+    for (const line of lines) {
+        const match = line.match(groupRegex);
+        if (!match)
+            continue;
+        matchedLines++;
+        const label = match[1].trim();
+        const blockIdsStr = match[2].trim();
+        const blockIds = blockIdsStr
+            .split(',')
+            .map((id) => id.trim().replace(/^["']|["']$/g, ''))
+            .filter((id) => validBlockIds.has(id));
+        console.log(`[subject-grouping] Parsed group "${label}": ${blockIds.length}/${blockIdsStr.split(',').length} valid block IDs`);
+        if (blockIds.length > 0 && label) {
+            groups.push({ label, blockIds });
+        }
+    }
+    if (groups.length === 0) {
+        console.error(`[subject-grouping] Failed to parse any groups from ${lines.length} lines (${matchedLines} matched regex)`);
+        throw new Error(`No valid groups found in response. Matched ${matchedLines}/${lines.length} lines.`);
+    }
+    return { groups };
+}
+function detectPersonalSubject(apps, activityBreakdown) {
+    let personalAppCount = 0;
+    let totalAppCount = 0;
+    for (const app of apps) {
+        totalAppCount++;
+        if (PERSONAL_APPS.has(app)) {
+            personalAppCount++;
+        }
+    }
+    if (totalAppCount === 0)
+        return false;
+    return personalAppCount / totalAppCount >= PERSONAL_APP_THRESHOLD;
+}
+function createFallbackGrouping(topicBlocks, recordingId) {
+    if (topicBlocks.length === 0) {
+        return {
+            subjects: [],
+            personalDuration: 0,
+            workDuration: 0,
+        };
+    }
+    const subjects = [];
+    let currentSubject = null;
+    const sortedBlocks = [...topicBlocks].sort((a, b) => {
+        const aClass = parseClassification(a);
+        const bClass = parseClassification(b);
+        return (aClass?.start_time ?? 0) - (bClass?.start_time ?? 0);
+    });
+    for (const block of sortedBlocks) {
+        const classification = parseClassification(block);
+        if (!classification)
+            continue;
+        const apps = classification.apps || [];
+        const isPersonal = apps.some((app) => PERSONAL_APPS.has(app));
+        if (!currentSubject) {
+            currentSubject = {
+                label: isPersonal ? 'Personal' : 'Work Session',
+                blocks: [],
+                apps: new Set(),
+                activities: {},
+            };
+        }
+        const shouldStartNewSubject = (isPersonal && currentSubject.label !== 'Personal') ||
+            (!isPersonal && currentSubject.label === 'Personal');
+        if (shouldStartNewSubject) {
+            subjects.push(finalizeSubject(currentSubject, recordingId, subjects.length));
+            currentSubject = {
+                label: isPersonal ? 'Personal' : 'Work Session',
+                blocks: [],
+                apps: new Set(),
+                activities: {},
+            };
+        }
+        currentSubject.blocks.push(block);
+        for (const app of apps) {
+            currentSubject.apps.add(app);
+        }
+        const activity = classification.activity_type || 'other';
+        currentSubject.activities[activity] =
+            (currentSubject.activities[activity] || 0) +
+                (classification.duration ?? 0);
+    }
+    if (currentSubject && currentSubject.blocks.length > 0) {
+        subjects.push(finalizeSubject(currentSubject, recordingId, subjects.length));
+    }
+    const personalDuration = subjects
+        .filter((s) => s.isPersonal)
+        .reduce((sum, s) => sum + s.totalDuration, 0);
+    const workDuration = subjects
+        .filter((s) => !s.isPersonal)
+        .reduce((sum, s) => sum + s.totalDuration, 0);
+    return { subjects, personalDuration, workDuration };
+}
+function finalizeSubject(subject, recordingId, index) {
+    const totalDuration = subject.blocks.reduce((sum, b) => {
+        const classification = parseClassification(b);
+        return sum + (classification?.duration ?? 0);
+    }, 0);
+    return {
+        id: `subject-${recordingId}-${index}`,
+        recordingId,
+        label: subject.label,
+        topicBlockIds: subject.blocks.map((b) => b.id),
+        totalDuration,
+        activityBreakdown: subject.activities,
+        apps: [...subject.apps],
+        isPersonal: subject.label === 'Personal',
+    };
+}
+function formatTime(seconds) {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, '0')}`;
+}
+function formatDuration(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    if (hours > 0) {
+        return `${hours}h ${mins}m`;
+    }
+    if (mins > 0) {
+        return `${mins}m`;
+    }
+    return `${Math.floor(seconds)}s`;
+}
+export function saveSubjectsToDatabase(subjects, recordingId, repos) {
+    const subjectInserts = [];
+    const links = [];
+    for (const subject of subjects) {
+        subjectInserts.push({
+            id: subject.id,
+            recording_id: subject.recordingId,
+            label: subject.label,
+            is_personal: subject.isPersonal ? 1 : 0,
+            duration: subject.totalDuration,
+            activity_breakdown: JSON.stringify(subject.activityBreakdown),
+            metadata: JSON.stringify({ apps: subject.apps }),
+        });
+        for (const blockId of subject.topicBlockIds) {
+            links.push({ subjectId: subject.id, topicBlockId: blockId });
+        }
+    }
+    repos.subjects.saveBatch(subjectInserts);
+    repos.subjects.linkTopicBlocksBatch(links);
+}

package/dist/services/temporal-alignment.js

@@ -0,0 +1,99 @@
+/**
+ * Escribano - Temporal Audio Alignment Service
+ *
+ * Attaches audio transcripts to visual segments based on timestamp overlap.
+ * Replaces semantic similarity-based merge with deterministic temporal alignment.
+ */
+const DEFAULT_CONFIG = {
+    minOverlapSeconds: 1,
+    preferredSource: 'mic',
+};
+/**
+ * Check if two time ranges overlap.
+ *
+ * @param start1 - Start of range 1
+ * @param end1 - End of range 1
+ * @param start2 - Start of range 2
+ * @param end2 - End of range 2
+ * @returns True if ranges overlap
+ */
+function rangesOverlap(start1, end1, start2, end2) {
+    return start1 < end2 && start2 < end1;
+}
+/**
+ * Calculate overlap duration between two time ranges.
+ *
+ * @param start1 - Start of range 1
+ * @param end1 - End of range 1
+ * @param start2 - Start of range 2
+ * @param end2 - End of range 2
+ * @returns Overlap duration in seconds (0 if no overlap)
+ */
+function calculateOverlap(start1, end1, start2, end2) {
+    if (!rangesOverlap(start1, end1, start2, end2)) {
+        return 0;
+    }
+    const overlapStart = Math.max(start1, start2);
+    const overlapEnd = Math.min(end1, end2);
+    return Math.max(0, overlapEnd - overlapStart);
+}
+/**
+ * Align audio transcripts to visual segments based on temporal overlap.
+ *
+ * @param segments - Visual segments from activity segmentation
+ * @param audioObservations - Audio observations with transcripts
+ * @param config - Alignment configuration
+ * @returns Segments enriched with aligned transcripts
+ */
+export function alignAudioToSegments(segments, audioObservations, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    // Filter to audio observations with transcripts
+    const audioTranscripts = audioObservations
+        .filter((o) => o.type === 'audio' && o.text && o.text.trim().length > 0)
+        .map((o) => ({
+        source: o.audio_source,
+        text: o.text,
+        startTime: o.timestamp,
+        endTime: o.end_timestamp ?? o.timestamp + 5, // Default 5s if no end time
+    }))
+        .sort((a, b) => a.startTime - b.startTime);
+    // Enrich each segment with overlapping transcripts
+    return segments.map((segment) => {
+        const overlappingTranscripts = [];
+        for (const transcript of audioTranscripts) {
+            const overlap = calculateOverlap(segment.startTime, segment.endTime, transcript.startTime, transcript.endTime);
+            if (overlap >= cfg.minOverlapSeconds) {
+                overlappingTranscripts.push(transcript);
+            }
+        }
+        // Combine transcripts in chronological order
+        const combinedTranscript = overlappingTranscripts
+            .sort((a, b) => a.startTime - b.startTime)
+            .map((t) => `[${t.source.toUpperCase()}] ${t.text}`)
+            .join('\n');
+        return {
+            ...segment,
+            transcripts: overlappingTranscripts,
+            combinedTranscript,
+        };
+    });
+}
+/**
+ * Get statistics about audio alignment.
+ */
+export function getAlignmentStats(enrichedSegments) {
+    const segmentsWithAudio = enrichedSegments.filter((s) => s.transcripts.length > 0).length;
+    const totalTranscriptSegments = enrichedSegments.reduce((sum, s) => sum + s.transcripts.length, 0);
+    const micTranscriptCount = enrichedSegments.reduce((sum, s) => sum + s.transcripts.filter((t) => t.source === 'mic').length, 0);
+    const systemTranscriptCount = enrichedSegments.reduce((sum, s) => sum + s.transcripts.filter((t) => t.source === 'system').length, 0);
+    return {
+        totalSegments: enrichedSegments.length,
+        segmentsWithAudio,
+        totalTranscriptSegments,
+        micTranscriptCount,
+        systemTranscriptCount,
+        avgTranscriptsPerSegment: enrichedSegments.length > 0
+            ? totalTranscriptSegments / enrichedSegments.length
+            : 0,
+    };
+}

package/dist/services/vlm-enrichment.js

@@ -0,0 +1,84 @@
+/**
+ * Escribano - VLM Enrichment Service
+ * @deprecated V2 pipeline - uses old clustering approach. Use V3 pipeline instead.
+ *
+ * Selects representative frames from clusters and describes them with a vision model.
+ */
+const DEFAULT_CONFIG = {
+    maxFramesPerCluster: 5,
+    minOcrLength: 100,
+    visionModel: 'qwen3-vl-8b',
+};
+/**
+ * Select representative frames for VLM description.
+ *
+ * Strategy:
+ * 1. Always include first and last frame (boundaries)
+ * 2. Include frames with low OCR quality (< minOcrLength chars)
+ * 3. Sample at regular intervals based on cluster duration
+ * 4. Cap at maxFramesPerCluster
+ */
+export function selectFramesForVLM(observations, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    if (observations.length === 0)
+        return [];
+    const visualObs = observations
+        .filter((o) => o.type === 'visual' && o.image_path)
+        .sort((a, b) => a.timestamp - b.timestamp);
+    if (visualObs.length === 0)
+        return [];
+    const selected = [];
+    const selectedIds = new Set();
+    const addFrame = (obs, reason) => {
+        if (!selectedIds.has(obs.id)) {
+            selectedIds.add(obs.id);
+            selected.push({ observation: obs, reason });
+        }
+    };
+    // 1. Boundaries
+    addFrame(visualObs[0], 'boundary');
+    if (visualObs.length > 1) {
+        addFrame(visualObs[visualObs.length - 1], 'boundary');
+    }
+    // 2. Low OCR quality frames
+    const lowOcrFrames = visualObs.filter((o) => (o.ocr_text?.length ?? 0) < cfg.minOcrLength && !selectedIds.has(o.id));
+    for (const frame of lowOcrFrames.slice(0, 3)) {
+        addFrame(frame, 'low_ocr');
+    }
+    // 3. Interval sampling (if still below max)
+    if (selected.length < cfg.maxFramesPerCluster && visualObs.length > 2) {
+        const duration = visualObs[visualObs.length - 1].timestamp - visualObs[0].timestamp;
+        const intervalSeconds = duration / (cfg.maxFramesPerCluster - selected.length + 1);
+        let nextTarget = visualObs[0].timestamp + intervalSeconds;
+        for (const obs of visualObs) {
+            if (selected.length >= cfg.maxFramesPerCluster)
+                break;
+            if (obs.timestamp >= nextTarget && !selectedIds.has(obs.id)) {
+                addFrame(obs, 'interval');
+                nextTarget += intervalSeconds;
+            }
+        }
+    }
+    return selected.slice(0, cfg.maxFramesPerCluster);
+}
+/**
+ * Describe selected frames using VLM.
+ */
+export async function describeFrames(frames, intelligence) {
+    const results = new Map();
+    if (frames.length === 0)
+        return results;
+    const images = frames.map((f) => ({
+        imagePath: f.observation.image_path,
+        clusterId: 0, // Not used in our case
+        timestamp: f.observation.timestamp,
+    }));
+    const descriptions = await intelligence.describeImages(images);
+    for (const [index, frame] of frames.entries()) {
+        const desc = descriptions[index];
+        if (desc?.description) {
+            results.set(frame.observation.id, desc.description);
+        }
+    }
+    return results;
+}

package/dist/services/vlm-service.js

@@ -0,0 +1,130 @@
+/**
+ * Escribano - VLM Service
+ *
+ * Orchestrates sequential VLM inference for frame descriptions.
+ * Each frame is processed individually for accurate image-description mapping.
+ */
+const DEFAULT_CONFIG = {
+    model: process.env.ESCRIBANO_VLM_MODEL || 'qwen3-vl:4b',
+};
+/**
+ * Process sampled frames through VLM sequentially (one image at a time).
+ *
+ * @param frames - Sampled frames from adaptiveSample()
+ * @param intelligence - Intelligence service with describeImages
+ * @param config - Processing configuration
+ * @returns Array of frame descriptions with VLM analysis
+ */
+export async function describeFrames(frames, intelligence, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    if (frames.length === 0) {
+        console.log('[VLM] No frames to process');
+        return [];
+    }
+    const total = frames.length;
+    console.log(`[VLM] Processing ${total} frames sequentially...`);
+    console.log(`[VLM] Model: ${cfg.model}`);
+    // Prepare input for intelligence service
+    const images = frames.map((f) => ({
+        imagePath: f.imagePath,
+        timestamp: f.timestamp,
+    }));
+    // Call the sequential VLM API with per-image callback
+    const results = await intelligence.describeImages(images, {
+        model: cfg.model,
+        recordingId: cfg.recordingId,
+        onImageProcessed: cfg.onImageProcessed,
+    });
+    console.log(`\n[VLM] Completed ${results.length}/${total} frames`);
+    return results;
+}
+/** @deprecated Use describeFrames instead */
+export const batchDescribeFrames = describeFrames;
+/**
+ * Normalize activity labels to canonical forms.
+ * Allows VLM flexibility while maintaining consistency.
+ */
+export function normalizeActivity(rawActivity) {
+    const lower = rawActivity.toLowerCase().trim();
+    const synonyms = {
+        // Debugging
+        debugging: 'debugging',
+        'fixing bug': 'debugging',
+        'investigating error': 'debugging',
+        troubleshooting: 'debugging',
+        'reading error': 'debugging',
+        'stack trace': 'debugging',
+        // Coding
+        coding: 'coding',
+        'writing code': 'coding',
+        implementing: 'coding',
+        developing: 'coding',
+        programming: 'coding',
+        // Reading
+        reading: 'reading',
+        'reading docs': 'reading',
+        documentation: 'reading',
+        'reading documentation': 'reading',
+        // Research
+        research: 'research',
+        browsing: 'research',
+        searching: 'research',
+        watching: 'research',
+        'stack overflow': 'research',
+        googling: 'research',
+        // Meeting
+        meeting: 'meeting',
+        'video call': 'meeting',
+        zoom: 'meeting',
+        'google meet': 'meeting',
+        'screen share': 'meeting',
+        // Terminal
+        terminal: 'terminal',
+        'command line': 'terminal',
+        cli: 'terminal',
+        shell: 'terminal',
+        // Code Review
+        review: 'review',
+        reviewing: 'review',
+        'code review': 'review',
+        'reviewing pr': 'review',
+        'pull request': 'review',
+    };
+    // Check exact match
+    if (synonyms[lower]) {
+        return synonyms[lower];
+    }
+    // Check partial match
+    for (const [pattern, normalized] of Object.entries(synonyms)) {
+        if (lower.includes(pattern)) {
+            return normalized;
+        }
+    }
+    // Return as-is if no match (allows new activities to emerge)
+    return lower.replace(/\s+/g, '_');
+}
+/**
+ * Get statistics about VLM processing results.
+ */
+export function getVLMStats(descriptions) {
+    const activityCounts = {};
+    const apps = new Set();
+    const topics = new Set();
+    for (const desc of descriptions) {
+        const normalized = normalizeActivity(desc.activity);
+        activityCounts[normalized] = (activityCounts[normalized] || 0) + 1;
+        desc.apps.forEach((app) => {
+            apps.add(app);
+        });
+        desc.topics.forEach((topic) => {
+            topics.add(topic);
+        });
+    }
+    return {
+        totalFrames: descriptions.length,
+        uniqueActivities: Object.keys(activityCounts),
+        activityCounts,
+        uniqueApps: Array.from(apps),
+        uniqueTopics: Array.from(topics),
+    };
+}

package/dist/stats/index.js

@@ -0,0 +1,3 @@
+export { cancelCurrentRun, getCurrentRunId, setupStatsObserver, } from './observer.js';
+export { createStatsRepository } from './repository.js';
+export { ResourceTracker } from './resource-tracker.js';