escribano 0.1.0

package/dist/db/repositories/cluster.sqlite.js

@@ -0,0 +1,92 @@
+/**
+ * Cluster Repository - SQLite Implementation
+ */
+import { nowISO } from '../helpers.js';
+export function createSqliteClusterRepository(db) {
+    const stmts = {
+        findById: db.prepare('SELECT * FROM clusters WHERE id = ?'),
+        findByRecording: db.prepare('SELECT * FROM clusters WHERE recording_id = ? ORDER BY start_timestamp ASC'),
+        findByRecordingAndType: db.prepare('SELECT * FROM clusters WHERE recording_id = ? AND type = ? ORDER BY start_timestamp ASC'),
+        insert: db.prepare(`
+      INSERT INTO clusters (id, recording_id, type, start_timestamp, end_timestamp, observation_count, centroid, classification, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `),
+        linkObservation: db.prepare(`
+      INSERT OR REPLACE INTO observation_clusters (observation_id, cluster_id, distance)
+      VALUES (?, ?, ?)
+    `),
+        getObservations: db.prepare(`
+      SELECT o.* FROM observations o
+      JOIN observation_clusters oc ON o.id = oc.observation_id
+      WHERE oc.cluster_id = ?
+      ORDER BY o.timestamp ASC
+    `),
+        updateClassification: db.prepare('UPDATE clusters SET classification = ? WHERE id = ?'),
+        updateCentroid: db.prepare('UPDATE clusters SET centroid = ? WHERE id = ?'),
+        saveMerge: db.prepare(`
+      INSERT OR REPLACE INTO cluster_merges (visual_cluster_id, audio_cluster_id, similarity_score, merge_reason)
+      VALUES (?, ?, ?, ?)
+    `),
+        getMergedAudioClusters: db.prepare(`
+      SELECT c.* FROM clusters c
+      JOIN cluster_merges cm ON c.id = cm.audio_cluster_id
+      WHERE cm.visual_cluster_id = ?
+    `),
+        delete: db.prepare('DELETE FROM clusters WHERE id = ?'),
+        deleteByRecording: db.prepare('DELETE FROM clusters WHERE recording_id = ?'),
+    };
+    const insertBatch = db.transaction((clusters) => {
+        for (const c of clusters) {
+            stmts.insert.run(c.id, c.recording_id, c.type, c.start_timestamp, c.end_timestamp, c.observation_count, c.centroid, c.classification, c.metadata, nowISO());
+        }
+    });
+    const linkBatch = db.transaction((links) => {
+        for (const link of links) {
+            stmts.linkObservation.run(link.observationId, link.clusterId, link.distance ?? null);
+        }
+    });
+    return {
+        findById(id) {
+            return stmts.findById.get(id) ?? null;
+        },
+        findByRecording(recordingId) {
+            return stmts.findByRecording.all(recordingId);
+        },
+        findByRecordingAndType(recordingId, type) {
+            return stmts.findByRecordingAndType.all(recordingId, type);
+        },
+        save(cluster) {
+            stmts.insert.run(cluster.id, cluster.recording_id, cluster.type, cluster.start_timestamp, cluster.end_timestamp, cluster.observation_count, cluster.centroid, cluster.classification, cluster.metadata, nowISO());
+        },
+        saveBatch(clusters) {
+            insertBatch(clusters);
+        },
+        linkObservation(obsId, clusterId, distance) {
+            stmts.linkObservation.run(obsId, clusterId, distance ?? null);
+        },
+        linkObservationsBatch(links) {
+            linkBatch(links);
+        },
+        getObservations(clusterId) {
+            return stmts.getObservations.all(clusterId);
+        },
+        updateClassification(id, classification) {
+            stmts.updateClassification.run(classification, id);
+        },
+        updateCentroid(id, centroid) {
+            stmts.updateCentroid.run(Buffer.from(new Float32Array(centroid).buffer), id);
+        },
+        saveMerge(visualId, audioId, similarity, reason) {
+            stmts.saveMerge.run(visualId, audioId, similarity, reason);
+        },
+        getMergedAudioClusters(visualId) {
+            return stmts.getMergedAudioClusters.all(visualId);
+        },
+        delete(id) {
+            stmts.delete.run(id);
+        },
+        deleteByRecording(recordingId) {
+            stmts.deleteByRecording.run(recordingId);
+        },
+    };
+}

package/dist/db/repositories/context.sqlite.js

@@ -0,0 +1,75 @@
+/**
+ * Context Repository - SQLite Implementation
+ */
+import { nowISO } from '../helpers.js';
+export function createSqliteContextRepository(db) {
+    const stmts = {
+        findById: db.prepare('SELECT * FROM contexts WHERE id = ?'),
+        findByTypeAndName: db.prepare('SELECT * FROM contexts WHERE type = ? AND name = ?'),
+        findAll: db.prepare('SELECT * FROM contexts ORDER BY created_at DESC'),
+        insert: db.prepare(`
+      INSERT INTO contexts (id, type, name, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `),
+        insertOrIgnore: db.prepare(`
+      INSERT OR IGNORE INTO contexts (id, type, name, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `),
+        linkObservation: db.prepare(`
+      INSERT OR REPLACE INTO observation_contexts (observation_id, context_id, confidence)
+      VALUES (?, ?, ?)
+    `),
+        unlinkObservation: db.prepare(`
+      DELETE FROM observation_contexts WHERE observation_id = ? AND context_id = ?
+    `),
+        getObservationLinks: db.prepare(`
+      SELECT * FROM observation_contexts WHERE context_id = ?
+    `),
+        getObservationLinksByObservation: db.prepare(`
+      SELECT * FROM observation_contexts WHERE observation_id = ?
+    `),
+        getLinksByRecording: db.prepare(`
+      SELECT oc.* FROM observation_contexts oc
+      JOIN observations o ON oc.observation_id = o.id
+      WHERE o.recording_id = ?
+    `),
+        delete: db.prepare('DELETE FROM contexts WHERE id = ?'),
+    };
+    return {
+        findById(id) {
+            const row = stmts.findById.get(id);
+            return row ?? null;
+        },
+        findByTypeAndName(type, name) {
+            const row = stmts.findByTypeAndName.get(type, name);
+            return row ?? null;
+        },
+        findAll() {
+            return stmts.findAll.all();
+        },
+        save(context) {
+            stmts.insert.run(context.id, context.type, context.name, context.metadata, nowISO());
+        },
+        saveOrIgnore(context) {
+            stmts.insertOrIgnore.run(context.id, context.type, context.name, context.metadata, nowISO());
+        },
+        linkObservation(observationId, contextId, confidence = 1.0) {
+            stmts.linkObservation.run(observationId, contextId, confidence);
+        },
+        unlinkObservation(observationId, contextId) {
+            stmts.unlinkObservation.run(observationId, contextId);
+        },
+        getObservationLinks(contextId) {
+            return stmts.getObservationLinks.all(contextId);
+        },
+        getObservationLinksByObservation(observationId) {
+            return stmts.getObservationLinksByObservation.all(observationId);
+        },
+        getLinksByRecording(recordingId) {
+            return stmts.getLinksByRecording.all(recordingId);
+        },
+        delete(id) {
+            stmts.delete.run(id);
+        },
+    };
+}

package/dist/db/repositories/index.js

@@ -0,0 +1,10 @@
+/**
+ * Repository exports
+ */
+export { createSqliteArtifactRepository } from './artifact.sqlite.js';
+export { createSqliteClusterRepository } from './cluster.sqlite.js';
+export { createSqliteContextRepository } from './context.sqlite.js';
+export { createSqliteObservationRepository } from './observation.sqlite.js';
+export { createSqliteRecordingRepository } from './recording.sqlite.js';
+export { createSqliteSubjectRepository } from './subject.sqlite.js';
+export { createSqliteTopicBlockRepository } from './topic-block.sqlite.js';

package/dist/db/repositories/observation.sqlite.js

@@ -0,0 +1,70 @@
+/**
+ * Observation Repository - SQLite Implementation
+ */
+import { nowISO } from '../helpers.js';
+export function createSqliteObservationRepository(db) {
+    const stmts = {
+        findById: db.prepare('SELECT * FROM observations WHERE id = ?'),
+        findByRecording: db.prepare('SELECT * FROM observations WHERE recording_id = ? ORDER BY timestamp ASC'),
+        findByRecordingAndType: db.prepare('SELECT * FROM observations WHERE recording_id = ? AND type = ? ORDER BY timestamp ASC'),
+        findByContext: db.prepare(`
+      SELECT o.* FROM observations o
+      JOIN observation_contexts oc ON o.id = oc.observation_id
+      WHERE oc.context_id = ?
+      ORDER BY o.created_at DESC
+    `),
+        insert: db.prepare(`
+      INSERT INTO observations (
+        id, recording_id, type, timestamp, end_timestamp,
+        image_path, ocr_text, vlm_description, vlm_raw_response, activity_type, apps, topics,
+        text, audio_source, audio_type, embedding, created_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `),
+        delete: db.prepare('DELETE FROM observations WHERE id = ?'),
+        deleteByRecording: db.prepare('DELETE FROM observations WHERE recording_id = ?'),
+    };
+    return {
+        findById(id) {
+            const row = stmts.findById.get(id);
+            return row ?? null;
+        },
+        findByRecording(recordingId) {
+            return stmts.findByRecording.all(recordingId);
+        },
+        findByRecordingAndType(recordingId, type) {
+            return stmts.findByRecordingAndType.all(recordingId, type);
+        },
+        findByContext(contextId) {
+            return stmts.findByContext.all(contextId);
+        },
+        save(observation) {
+            const now = nowISO();
+            stmts.insert.run(observation.id, observation.recording_id, observation.type, observation.timestamp, observation.end_timestamp, observation.image_path, observation.ocr_text, observation.vlm_description, observation.vlm_raw_response ?? null, observation.activity_type ?? null, observation.apps ?? null, observation.topics ?? null, observation.text, observation.audio_source, observation.audio_type, observation.embedding, now);
+        },
+        saveBatch(observations) {
+            const now = nowISO();
+            const insertMany = db.transaction((obsList) => {
+                for (const obs of obsList) {
+                    stmts.insert.run(obs.id, obs.recording_id, obs.type, obs.timestamp, obs.end_timestamp, obs.image_path, obs.ocr_text, obs.vlm_description, obs.vlm_raw_response ?? null, obs.activity_type ?? null, obs.apps ?? null, obs.topics ?? null, obs.text, obs.audio_source, obs.audio_type, obs.embedding, now);
+                }
+            });
+            insertMany(observations);
+        },
+        updateEmbedding(id, embedding) {
+            const stmt = db.prepare('UPDATE observations SET embedding = ? WHERE id = ?');
+            const buffer = Buffer.from(new Float32Array(embedding).buffer);
+            stmt.run(buffer, id);
+        },
+        updateVLMDescription(id, description) {
+            const stmt = db.prepare('UPDATE observations SET vlm_description = ? WHERE id = ?');
+            stmt.run(description, id);
+        },
+        delete(id) {
+            stmts.delete.run(id);
+        },
+        deleteByRecording(recordingId) {
+            stmts.deleteByRecording.run(recordingId);
+        },
+    };
+}

package/dist/db/repositories/recording.sqlite.js

@@ -0,0 +1,56 @@
+/**
+ * Recording Repository - SQLite Implementation
+ */
+import { nowISO } from '../helpers.js';
+export function createSqliteRecordingRepository(db) {
+    // Prepare statements once
+    const stmts = {
+        findById: db.prepare('SELECT * FROM recordings WHERE id = ?'),
+        findByStatus: db.prepare('SELECT * FROM recordings WHERE status = ? ORDER BY captured_at DESC'),
+        findPending: db.prepare("SELECT * FROM recordings WHERE status IN ('raw', 'processing') ORDER BY captured_at ASC"),
+        insert: db.prepare(`
+      INSERT INTO recordings (
+        id, video_path, audio_mic_path, audio_system_path, duration, 
+        captured_at, status, processing_step, source_type, 
+        source_metadata, error_message, created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `),
+        updateStatus: db.prepare(`
+      UPDATE recordings 
+      SET status = ?, processing_step = ?, error_message = ?, updated_at = ? 
+      WHERE id = ?
+    `),
+        updateMetadata: db.prepare(`
+      UPDATE recordings 
+      SET source_metadata = ?, updated_at = ? 
+      WHERE id = ?
+    `),
+        delete: db.prepare('DELETE FROM recordings WHERE id = ?'),
+    };
+    return {
+        findById(id) {
+            const row = stmts.findById.get(id);
+            return row ?? null;
+        },
+        findByStatus(status) {
+            return stmts.findByStatus.all(status);
+        },
+        findPending() {
+            return stmts.findPending.all();
+        },
+        save(recording) {
+            const now = nowISO();
+            stmts.insert.run(recording.id, recording.video_path, recording.audio_mic_path, recording.audio_system_path, recording.duration, recording.captured_at, recording.status, recording.processing_step, recording.source_type, recording.source_metadata, recording.error_message, now, now);
+        },
+        updateStatus(id, status, step, error) {
+            stmts.updateStatus.run(status, step ?? null, error ?? null, nowISO(), id);
+        },
+        updateMetadata(id, metadata) {
+            stmts.updateMetadata.run(metadata, nowISO(), id);
+        },
+        delete(id) {
+            stmts.delete.run(id);
+        },
+    };
+}

package/dist/db/repositories/subject.sqlite.js

@@ -0,0 +1,64 @@
+/**
+ * Subject Repository - SQLite Implementation
+ */
+import { nowISO } from '../helpers.js';
+export function createSqliteSubjectRepository(db) {
+    const stmts = {
+        findById: db.prepare('SELECT * FROM subjects WHERE id = ?'),
+        findByRecording: db.prepare('SELECT * FROM subjects WHERE recording_id = ? ORDER BY created_at ASC'),
+        insert: db.prepare(`
+      INSERT INTO subjects (id, recording_id, label, is_personal, duration, activity_breakdown, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `),
+        insertLink: db.prepare(`
+      INSERT OR IGNORE INTO subject_topic_blocks (subject_id, topic_block_id)
+      VALUES (?, ?)
+    `),
+        getTopicBlocks: db.prepare(`
+      SELECT tb.* FROM topic_blocks tb
+      INNER JOIN subject_topic_blocks stb ON tb.id = stb.topic_block_id
+      WHERE stb.subject_id = ?
+      ORDER BY tb.created_at ASC
+    `),
+        deleteByRecording: db.prepare('DELETE FROM subjects WHERE recording_id = ?'),
+        deleteLinksByRecording: db.prepare(`
+      DELETE FROM subject_topic_blocks 
+      WHERE subject_id IN (SELECT id FROM subjects WHERE recording_id = ?)
+    `),
+    };
+    const insertMany = db.transaction((subjects) => {
+        for (const subject of subjects) {
+            stmts.insert.run(subject.id, subject.recording_id, subject.label, subject.is_personal ? 1 : 0, subject.duration ?? 0, subject.activity_breakdown ?? null, subject.metadata ?? null, nowISO());
+        }
+    });
+    const linkMany = db.transaction((links) => {
+        for (const link of links) {
+            stmts.insertLink.run(link.subjectId, link.topicBlockId);
+        }
+    });
+    return {
+        findById(id) {
+            const row = stmts.findById.get(id);
+            return row ?? null;
+        },
+        findByRecording(recordingId) {
+            return stmts.findByRecording.all(recordingId);
+        },
+        save(subject) {
+            stmts.insert.run(subject.id, subject.recording_id, subject.label, subject.is_personal ? 1 : 0, subject.duration ?? 0, subject.activity_breakdown ?? null, subject.metadata ?? null, nowISO());
+        },
+        saveBatch(subjects) {
+            insertMany(subjects);
+        },
+        linkTopicBlocksBatch(links) {
+            linkMany(links);
+        },
+        getTopicBlocks(subjectId) {
+            return stmts.getTopicBlocks.all(subjectId);
+        },
+        deleteByRecording(recordingId) {
+            stmts.deleteLinksByRecording.run(recordingId);
+            stmts.deleteByRecording.run(recordingId);
+        },
+    };
+}

package/dist/db/repositories/topic-block.sqlite.js

@@ -0,0 +1,45 @@
+/**
+ * Topic Block Repository - SQLite Implementation
+ */
+import { nowISO } from '../helpers.js';
+export function createSqliteTopicBlockRepository(db) {
+    const stmts = {
+        findById: db.prepare('SELECT * FROM topic_blocks WHERE id = ?'),
+        findByRecording: db.prepare('SELECT * FROM topic_blocks WHERE recording_id = ? ORDER BY created_at ASC'),
+        findByContext: db.prepare(`
+      SELECT * FROM topic_blocks 
+      WHERE context_ids LIKE ?
+      ORDER BY created_at DESC
+    `),
+        insert: db.prepare(`
+      INSERT INTO topic_blocks (id, recording_id, context_ids, classification, duration, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `),
+        delete: db.prepare('DELETE FROM topic_blocks WHERE id = ?'),
+        deleteByRecording: db.prepare('DELETE FROM topic_blocks WHERE recording_id = ?'),
+    };
+    return {
+        findById(id) {
+            const row = stmts.findById.get(id);
+            return row ?? null;
+        },
+        findByRecording(recordingId) {
+            return stmts.findByRecording.all(recordingId);
+        },
+        findByContext(contextId) {
+            // Simple LIKE search for the context ID in the JSON array string
+            // NOTE: For more robust JSON searching, we could use SQLite's json_each if available.
+            // Current implementation matches substrings, which is acceptable for UUIDv7 but not ideal.
+            return stmts.findByContext.all(`%${contextId}%`);
+        },
+        save(block) {
+            stmts.insert.run(block.id, block.recording_id, block.context_ids, block.classification, block.duration, nowISO());
+        },
+        delete(id) {
+            stmts.delete.run(id);
+        },
+        deleteByRecording(recordingId) {
+            stmts.deleteByRecording.run(recordingId);
+        },
+    };
+}

package/dist/db/types.js

@@ -0,0 +1,4 @@
+/**
+ * Manual Database Types for SQLite
+ */
+export {};

package/dist/domain/classification.js

@@ -0,0 +1,60 @@
+/**
+ * Escribano - Classification Value Object
+ */
+export const Classification = {
+    /**
+     * Get the primary session type based on scores.
+     * Returns the type with the highest score if it's above the threshold.
+     */
+    getPrimary: (c, threshold = 25) => {
+        const sorted = Object.entries(c).sort(([, a], [, b]) => b - a);
+        const [type, score] = sorted[0];
+        return score >= threshold ? type : null;
+    },
+    /**
+     * Check if a specific type is present with a score above threshold
+     */
+    hasType: (c, type, threshold = 50) => {
+        return (c[type] || 0) >= threshold;
+    },
+    /**
+     * Get all types that meet a significance threshold
+     */
+    getSignificantTypes: (c, threshold = 25) => {
+        return Object.entries(c)
+            .filter(([, score]) => score >= threshold)
+            .map(([type]) => type);
+    },
+    /**
+     * Aggregate multiple classifications (e.g., from segments to session)
+     * Uses time-weighted average or simple average.
+     */
+    aggregate: (classifications) => {
+        const result = {
+            meeting: 0,
+            debugging: 0,
+            tutorial: 0,
+            learning: 0,
+            working: 0,
+        };
+        if (classifications.length === 0)
+            return result;
+        let totalWeight = 0;
+        for (const { classification, weight } of classifications) {
+            totalWeight += weight;
+            result.meeting += (classification.meeting || 0) * weight;
+            result.debugging += (classification.debugging || 0) * weight;
+            result.tutorial += (classification.tutorial || 0) * weight;
+            result.learning += (classification.learning || 0) * weight;
+            result.working += (classification.working || 0) * weight;
+        }
+        if (totalWeight > 0) {
+            result.meeting = Math.round(result.meeting / totalWeight);
+            result.debugging = Math.round(result.debugging / totalWeight);
+            result.tutorial = Math.round(result.tutorial / totalWeight);
+            result.learning = Math.round(result.learning / totalWeight);
+            result.working = Math.round(result.working / totalWeight);
+        }
+        return result;
+    },
+};

package/dist/domain/context.js

@@ -0,0 +1,97 @@
+/**
+ * Escribano - Context Extraction Domain Module
+ */
+export const Context = {
+    /**
+     * Extract semantic contexts from raw OCR text using regex patterns.
+     * This is a fast-path optimization for common applications and URLs.
+     */
+    extractFromOCR: (ocrText) => {
+        const contexts = [];
+        const text = ocrText.trim();
+        if (!text)
+            return contexts;
+        // 1. App Detection
+        const apps = [
+            { name: 'Ghostty', pattern: /Ghostty/i },
+            { name: 'VS Code', pattern: /Visual Studio Code|VS Code/i },
+            { name: 'Chrome', pattern: /Google Chrome/i },
+            { name: 'Arc', pattern: /Arc/i },
+            { name: 'Cursor', pattern: /Cursor/i },
+            { name: 'TablePlus', pattern: /TablePlus/i },
+            { name: 'Slack', pattern: /Slack/i },
+            { name: 'Spotify', pattern: /Spotify/i },
+            { name: 'YouTube Music', pattern: /YouTube Music/i },
+        ];
+        for (const app of apps) {
+            if (app.pattern.test(text)) {
+                contexts.push({
+                    type: 'app',
+                    value: app.name,
+                    confidence: 0.9,
+                });
+            }
+        }
+        // 2. URL Detection
+        const urlPattern = /https?:\/\/[^\s]+/g;
+        const urls = text.match(urlPattern);
+        if (urls) {
+            for (const url of urls) {
+                contexts.push({
+                    type: 'url',
+                    value: url.replace(/[,.)}>]$/, ''), // Clean trailing punctuation
+                    confidence: 1.0,
+                });
+            }
+        }
+        // 3. Domain Detection (Specific known domains)
+        const domains = [
+            { name: 'github.com', pattern: /github\.com/i },
+            { name: 'linkedin.com', pattern: /linkedin\.com/i },
+            { name: 'stackoverflow.com', pattern: /stackoverflow\.com/i },
+            { name: 'docs.rs', pattern: /docs\.rs/i },
+            { name: 'ollama.com', pattern: /ollama\.com/i },
+        ];
+        for (const domain of domains) {
+            if (domain.pattern.test(text)) {
+                // Only add if not already covered by a full URL
+                if (!contexts.some((c) => c.type === 'url' && c.value.includes(domain.name))) {
+                    contexts.push({
+                        type: 'url',
+                        value: domain.name,
+                        confidence: 0.8,
+                    });
+                }
+            }
+        }
+        // 4. File Path Detection
+        const pathPattern = /(?:~\/|\/Users\/)[^\s]+\.(?:ts|js|py|rs|md|go|json|yml|yaml)/g;
+        const paths = text.match(pathPattern);
+        if (paths) {
+            for (const path of paths) {
+                contexts.push({
+                    type: 'file',
+                    value: path,
+                    confidence: 0.9,
+                });
+            }
+        }
+        // TODO: Implement Step 2 - Embedding clustering for topic grouping
+        // This will be used when regex patterns don't yield high-confidence results
+        // or when we want to group related segments together.
+        return contexts;
+    },
+    /**
+     * Aggregate multiple contexts and remove duplicates
+     */
+    unique: (contexts) => {
+        const seen = new Set();
+        return contexts.filter((c) => {
+            const key = `${c.type}:${c.value}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    },
+};

package/dist/domain/index.js

@@ -0,0 +1,2 @@
+export * from './observation.js';
+export * from './recording.js';

package/dist/domain/observation.js

@@ -0,0 +1,17 @@
+import { generateId } from '../db/helpers.js';
+/**
+ * Factory for audio observations
+ */
+export function createAudioObservation(params) {
+    return {
+        id: generateId(),
+        recordingId: params.recordingId,
+        type: 'audio',
+        timestamp: params.timestamp,
+        endTimestamp: params.endTimestamp,
+        text: params.text,
+        audioSource: params.audioSource,
+        audioType: 'speech',
+        confidence: params.confidence ?? null,
+    };
+}

package/dist/domain/recording.js

@@ -0,0 +1,41 @@
+/**
+ * Transition recording to processing state
+ */
+export function startProcessing(recording) {
+    return {
+        ...recording,
+        status: 'processing',
+        processingStep: 'vad',
+        errorMessage: null,
+    };
+}
+/**
+ * Advance to next processing step
+ */
+export function advanceStep(recording, step) {
+    return {
+        ...recording,
+        processingStep: step,
+    };
+}
+/**
+ * Mark recording as successfully processed
+ */
+export function completeProcessing(recording) {
+    return {
+        ...recording,
+        status: 'processed',
+        processingStep: null,
+    };
+}
+/**
+ * Mark recording as failed
+ */
+export function failProcessing(recording, error) {
+    return {
+        ...recording,
+        status: 'error',
+        errorMessage: error,
+        // Keep processingStep to know where we failed for resume
+    };
+}