macro-agent 0.1.1 → 0.1.3

package/dist/store/event-store.js

@@ -1,1739 +0,0 @@
-/**
- * Event Store implementation using TinyBase
- *
- * Provides an append-only event log with materialized views for:
- * - Agents
- * - Tasks
- * - Messages (per-agent queues)
- * - Subscriptions
- */
-import { createStore } from 'tinybase';
-import { createCustomPersister, createCustomSqlitePersister } from 'tinybase/persisters';
-import Database from 'better-sqlite3';
-import { nanoid } from 'nanoid';
-import * as path from 'path';
-import * as os from 'os';
-import * as fs from 'fs';
-import { CURRENT_EVENT_VERSION } from './types/events.js';
-import { migrateEvent } from './migrations.js';
-import { resolveInstancePath, ensureInstanceDir, createInstanceMeta, writeInstanceMeta, touchInstance, registerInstance, DEFAULT_PEER_VISIBILITY, filterEventsForPeer, } from './instance.js';
-import { createTinyBaseBackend } from './backends/tinybase-backend.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// Tabular better-sqlite3 Persister
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Build tabular config for the 10 TinyBase tables.
- * Identity mapping: TinyBase table name === SQLite table name.
- */
-function getTabularConfig() {
-    const tableNames = [
-        'events', 'agents', 'tasks', 'messages',
-        'sessions', 'conversations', 'turns',
-        'threads', 'subscriptions', 'participants',
-    ];
-    const load = {};
-    const save = {};
-    for (const t of tableNames) {
-        load[t] = t; // SQLite table -> TinyBase table (same name)
-        save[t] = t; // TinyBase table -> SQLite table (same name)
-    }
-    return {
-        mode: 'tabular',
-        tables: { load, save },
-        autoLoadIntervalSeconds: 1,
-    };
-}
-/**
- * Creates a tabular TinyBase persister backed by better-sqlite3.
- *
- * Unlike the old JSON blob approach (entire store as one JSON string in a
- * single row), tabular mode maps each TinyBase table to a real SQLite table
- * and only writes changed rows on autoSave — making persistence O(delta)
- * instead of O(total).
- */
-function createTabularBetterSqlite3Persister(store, db) {
-    // Wrap better-sqlite3's sync API as the async DatabaseExecuteCommand.
-    // TinyBase generates SQL with $1, $2, ... placeholders (PostgreSQL-style),
-    // but better-sqlite3 uses ? for positional array binding. Convert them.
-    const executeCommand = async (sql, params) => {
-        const convertedSql = sql.replace(/\$\d+/g, '?');
-        const trimmed = convertedSql.trimStart().toUpperCase();
-        const stmt = db.prepare(convertedSql);
-        if (trimmed.startsWith('SELECT') || trimmed.startsWith('PRAGMA')) {
-            return (params ? stmt.all(...params) : stmt.all());
-        }
-        params ? stmt.run(...params) : stmt.run();
-        return [];
-    };
-    return createCustomSqlitePersister(store, getTabularConfig(), executeCommand, 
-    // addChangeListener — better-sqlite3 has no native change events
-    (_listener) => null, 
-    // delChangeListener — no-op
-    (_handle) => { }, 
-    // onSqlCommand
-    undefined, 
-    // onIgnoredError
-    (error) => console.warn('[EventStore] Persister error:', error), 
-    // destroy — do NOT close DB here; close() handles it after the persister drains
-    () => { }, 
-    // persist mode (1 = StoreOnly)
-    1, 
-    // thing (the db instance)
-    db, 
-    // getThing accessor name
-    'getDb');
-}
-/**
- * Parse a duration string (e.g., "30d", "7d") to milliseconds
- */
-export function parseDuration(duration) {
-    const match = duration.match(/^(\d+)([dhms])$/);
-    if (!match) {
-        throw new Error(`Invalid duration format: "${duration}". Use format like "30d", "7d", "24h", "60m", "30s".`);
-    }
-    const value = parseInt(match[1], 10);
-    const unit = match[2];
-    const multipliers = {
-        s: 1000,
-        m: 60 * 1000,
-        h: 60 * 60 * 1000,
-        d: 24 * 60 * 60 * 1000,
-    };
-    return value * multipliers[unit];
-}
-/**
- * Create an Event Store instance
- */
-export async function createEventStore(config = {}) {
-    // Resolve instance configuration
-    const resolved = resolveInstancePath(config);
-    const { instanceId, instancePath, namespace, isNew, backendType } = resolved;
-    // Reject deprecated legacy path option
-    if (config.path) {
-        throw new Error('[macro-agent] The `path` option has been removed. ' +
-            'Use `instanceId` and `baseDir` instead for per-instance isolation.');
-    }
-    // Track baseDir for MCP subprocess communication
-    const baseDir = config.baseDir ?? path.join(os.homedir(), '.multiagent');
-    // Get peer visibility config (default is restrictive)
-    const peerVisibility = config.peerVisibility ?? DEFAULT_PEER_VISIBILITY;
-    // Emit warning for in-memory mode (only in non-test environments)
-    if (config.inMemory && process.env.NODE_ENV !== 'test') {
-        console.warn('[macro-agent] WARNING: Using in-memory EventStore. MCP tools (done, spawn_agent, etc.) will not work ' +
-            'because MCP servers run as separate subprocesses that cannot access in-memory data. ' +
-            'Use file-based storage (remove inMemory option) for real agent workflows.');
-    }
-    const store = createStore();
-    // Set up persister based on backend type
-    let persister = null;
-    let db = null;
-    if (!config.inMemory) {
-        ensureInstanceDir(instancePath);
-        const dbPath = path.join(instancePath, 'store.sqlite');
-        db = new Database(dbPath);
-        db.pragma('journal_mode = WAL');
-        db.pragma('busy_timeout = 5000');
-        // Migration: if old JSON blob table exists, load data from it first
-        const oldTableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tinybase_store'").get();
-        if (oldTableExists) {
-            const oldPersister = createCustomPersister(store, async () => {
-                const row = db.prepare("SELECT store FROM tinybase_store WHERE _id = '_'").get();
-                return row ? JSON.parse(row.store) : undefined;
-            }, async () => { }, (listener) => setInterval(listener, 1000), (interval) => clearInterval(interval));
-            await oldPersister.load();
-            oldPersister.destroy();
-        }
-        persister = createTabularBetterSqlite3Persister(store, db);
-        if (oldTableExists) {
-            // Save migrated data to new tabular format, then drop old table
-            await persister.save();
-            db.exec('DROP TABLE IF EXISTS tinybase_store');
-        }
-        await persister.load();
-        // Auto-save: persist to disk whenever the in-memory store changes.
-        // Without this, emit() only writes to TinyBase's in-memory store and
-        // data is lost if the server is killed before an explicit persist().
-        await persister.startAutoSave();
-    }
-    // Initialize/update instance metadata
-    if (!config.inMemory) {
-        if (isNew) {
-            const meta = createInstanceMeta(resolved, config);
-            writeInstanceMeta(instancePath, meta);
-        }
-        else {
-            touchInstance(instancePath);
-        }
-        // Register in namespace for discovery
-        registerInstance(config.baseDir ?? path.join(os.homedir(), '.multiagent'), namespace, instanceId, { label: config.label });
-    }
-    // Initialize tables if they don't exist
-    initializeTables(store);
-    // Rebuild materialized views from events
-    rebuildViews(store);
-    // Listener registries
-    const agentListeners = new Set();
-    const agentIdListeners = new Map();
-    const taskListeners = new Set();
-    const sessionListeners = new Set();
-    const messageListeners = new Map();
-    const conversationListeners = new Set();
-    const turnListeners = new Set();
-    /**
-     * Emit a new event to the store
-     */
-    function emit(input) {
-        const event = {
-            ...input,
-            id: `evt_${nanoid(12)}`,
-            version: CURRENT_EVENT_VERSION,
-            timestamp: Date.now(),
-        };
-        // Store the event
-        // Note: Use empty object for undefined source to avoid JSON.parse errors in query
-        store.setRow('events', event.id, {
-            id: event.id,
-            version: event.version,
-            timestamp: event.timestamp,
-            type: event.type,
-            source: JSON.stringify(event.source ?? {}),
-            target: event.target ? JSON.stringify(event.target) : '',
-            payload: JSON.stringify(event.payload),
-            metadata: event.metadata ? JSON.stringify(event.metadata) : '',
-        });
-        // Update materialized views
-        applyEventToViews(store, event, notifyAgentChange, notifyTaskChange, notifyMessageChange, notifySessionChange, notifyConversationChange, notifyTurnChange);
-        return event;
-    }
-    /**
-     * Query events with filters
-     */
-    function query(filter) {
-        const events = [];
-        const rowIds = store.getRowIds('events');
-        for (const rowId of rowIds) {
-            const row = store.getRow('events', rowId);
-            if (!row.id)
-                continue;
-            // Parse raw event data
-            // Handle legacy data where source might be stored as "undefined" string
-            const sourceStr = row.source;
-            const parsedSource = sourceStr && sourceStr !== 'undefined'
-                ? JSON.parse(sourceStr)
-                : {};
-            const rawEvent = {
-                id: row.id,
-                version: row.version,
-                timestamp: row.timestamp,
-                type: row.type,
-                source: parsedSource,
-                target: row.target ? JSON.parse(row.target) : undefined,
-                payload: JSON.parse(row.payload),
-                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-            };
-            // Migrate event to current version if needed
-            const event = migrateEvent(rawEvent);
-            // Apply filters
-            if (filter) {
-                if (filter.type && event.type !== filter.type)
-                    continue;
-                if (filter.source_agent_id && event.source.agent_id !== filter.source_agent_id)
-                    continue;
-                if (filter.target_agent_id && event.target?.agent_id !== filter.target_agent_id)
-                    continue;
-                if (filter.after && event.timestamp <= filter.after)
-                    continue;
-                if (filter.before && event.timestamp >= filter.before)
-                    continue;
-            }
-            events.push(event);
-        }
-        // Sort by timestamp
-        events.sort((a, b) => a.timestamp - b.timestamp);
-        // Apply limit
-        if (filter?.limit) {
-            return events.slice(0, filter.limit);
-        }
-        return events;
-    }
-    /**
-     * Get agent by ID
-     */
-    function getAgent(agentId) {
-        const row = store.getRow('agents', agentId);
-        if (!row.id)
-            return null;
-        return rowToAgent(row);
-    }
-    /**
-     * List agents with optional filter
-     */
-    function listAgents(filter) {
-        const agents = [];
-        const rowIds = store.getRowIds('agents');
-        for (const rowId of rowIds) {
-            const row = store.getRow('agents', rowId);
-            if (!row.id)
-                continue;
-            const agent = rowToAgent(row);
-            if (filter) {
-                if (filter.state && agent.state !== filter.state)
-                    continue;
-                if (filter.parent !== undefined && agent.parent !== filter.parent)
-                    continue;
-            }
-            agents.push(agent);
-        }
-        return agents;
-    }
-    /**
-     * Update agent metadata fields (name, plan, metadata).
-     * Only provided fields are updated. Metadata is shallow-merged with existing.
-     */
-    function updateAgentMetadata(agentId, updates) {
-        const row = store.getRow('agents', agentId);
-        if (!row.id)
-            return;
-        const partial = {
-            last_activity_at: Date.now(),
-        };
-        if (updates.name !== undefined) {
-            partial.name = updates.name;
-        }
-        if (updates.plan !== undefined) {
-            partial.plan = JSON.stringify(updates.plan);
-        }
-        if (updates.metadata !== undefined) {
-            // Shallow merge with existing metadata
-            const existing = row.metadata ? JSON.parse(row.metadata) : {};
-            partial.metadata = JSON.stringify({ ...existing, ...updates.metadata });
-        }
-        store.setPartialRow('agents', agentId, partial);
-        const agent = rowToAgent(store.getRow('agents', agentId));
-        notifyAgentChange(agentId, agent);
-    }
-    /**
-     * Update an agent's plan entries (persisted to SQLite via TinyBase).
-     * Convenience wrapper around updateAgentMetadata.
-     */
-    function updateAgentPlan(agentId, plan) {
-        updateAgentMetadata(agentId, { plan });
-    }
-    /**
-     * Get task by ID
-     */
-    function getTask(taskId) {
-        const row = store.getRow('tasks', taskId);
-        if (!row.id)
-            return null;
-        return rowToTask(row);
-    }
-    /**
-     * List tasks with optional filter
-     */
-    function listTasks(filter) {
-        const tasks = [];
-        const rowIds = store.getRowIds('tasks');
-        for (const rowId of rowIds) {
-            const row = store.getRow('tasks', rowId);
-            if (!row.id)
-                continue;
-            const task = rowToTask(row);
-            if (filter) {
-                if (filter.status && task.status !== filter.status)
-                    continue;
-                if (filter.assigned_agent && task.assigned_agent !== filter.assigned_agent)
-                    continue;
-            }
-            tasks.push(task);
-        }
-        return tasks;
-    }
-    /**
-     * Get pending messages for an agent
-     */
-    function getMessages(agentId, limit) {
-        const messages = [];
-        const rowIds = store.getRowIds('messages');
-        for (const rowId of rowIds) {
-            const row = store.getRow('messages', rowId);
-            if (!row.id || row.recipient !== agentId)
-                continue;
-            messages.push({
-                id: row.id,
-                from: JSON.parse(row.from),
-                content: row.content,
-                timestamp: row.timestamp,
-                truncated: row.truncated,
-                correlation_id: row.correlation_id,
-            });
-        }
-        // Sort by timestamp
-        messages.sort((a, b) => a.timestamp - b.timestamp);
-        if (limit) {
-            return messages.slice(0, limit);
-        }
-        return messages;
-    }
-    /**
-     * Get full message content by ID
-     */
-    function getFullMessage(messageId) {
-        // Look up the original event
-        const row = store.getRow('events', messageId);
-        if (!row.id || row.type !== 'message')
-            return null;
-        const payload = JSON.parse(row.payload);
-        return payload.content ?? null;
-    }
-    /**
-     * Add a subscription for an agent
-     */
-    function addSubscription(agentId, subscription) {
-        const subId = `${agentId}:${subscription.type}:${subscription.target}`;
-        store.setRow('subscriptions', subId, {
-            id: subId,
-            agent_id: agentId,
-            type: subscription.type,
-            target: subscription.target,
-        });
-    }
-    /**
-     * Remove a subscription for an agent
-     */
-    function removeSubscription(agentId, subscription) {
-        const subId = `${agentId}:${subscription.type}:${subscription.target}`;
-        store.delRow('subscriptions', subId);
-    }
-    /**
-     * Get all subscriptions for an agent
-     */
-    function getSubscriptions(agentId) {
-        const subscriptions = [];
-        const rowIds = store.getRowIds('subscriptions');
-        for (const rowId of rowIds) {
-            const row = store.getRow('subscriptions', rowId);
-            if (row.agent_id !== agentId)
-                continue;
-            subscriptions.push({
-                type: row.type,
-                target: row.target,
-            });
-        }
-        return subscriptions;
-    }
-    /**
-     * Get all agents subscribed to a given subscription
-     */
-    function getSubscribers(subscription) {
-        const subscribers = [];
-        const rowIds = store.getRowIds('subscriptions');
-        for (const rowId of rowIds) {
-            const row = store.getRow('subscriptions', rowId);
-            if (row.type !== subscription.type || row.target !== subscription.target)
-                continue;
-            subscribers.push(row.agent_id);
-        }
-        return subscribers;
-    }
-    /**
-     * Notify agent change listeners
-     */
-    function notifyAgentChange(agentId, agent) {
-        // Global listeners
-        for (const callback of agentListeners) {
-            callback(agentId, agent);
-        }
-        // Specific agent listeners
-        const specificListeners = agentIdListeners.get(agentId);
-        if (specificListeners) {
-            for (const callback of specificListeners) {
-                callback(agentId, agent);
-            }
-        }
-    }
-    /**
-     * Notify task change listeners
-     */
-    function notifyTaskChange(taskId, task) {
-        for (const callback of taskListeners) {
-            callback(taskId, task);
-        }
-    }
-    /**
-     * Notify message change listeners
-     */
-    function notifyMessageChange(agentId) {
-        const listeners = messageListeners.get(agentId);
-        if (listeners) {
-            const messages = getMessages(agentId);
-            for (const callback of listeners) {
-                callback(agentId, messages);
-            }
-        }
-    }
-    /**
-     * Subscribe to agent changes (all agents or specific agent)
-     */
-    function onAgentChange(callbackOrId, callback) {
-        if (typeof callbackOrId === 'function') {
-            // Global subscription
-            agentListeners.add(callbackOrId);
-            return () => agentListeners.delete(callbackOrId);
-        }
-        else {
-            // Specific agent subscription
-            const agentId = callbackOrId;
-            const cb = callback;
-            if (!agentIdListeners.has(agentId)) {
-                agentIdListeners.set(agentId, new Set());
-            }
-            agentIdListeners.get(agentId).add(cb);
-            return () => agentIdListeners.get(agentId)?.delete(cb);
-        }
-    }
-    /**
-     * Subscribe to task changes
-     */
-    function onTaskChange(callback) {
-        taskListeners.add(callback);
-        return () => taskListeners.delete(callback);
-    }
-    /**
-     * Subscribe to message changes for an agent
-     */
-    function onMessageChange(agentId, callback) {
-        if (!messageListeners.has(agentId)) {
-            messageListeners.set(agentId, new Set());
-        }
-        messageListeners.get(agentId).add(callback);
-        return () => messageListeners.get(agentId)?.delete(callback);
-    }
-    /**
-     * Notify conversation change listeners
-     */
-    function notifyConversationChange(conversationId, conversation) {
-        for (const callback of conversationListeners) {
-            callback(conversationId, conversation);
-        }
-    }
-    /**
-     * Notify turn change listeners
-     */
-    function notifyTurnChange(conversationId, turn) {
-        for (const callback of turnListeners) {
-            callback(conversationId, turn);
-        }
-    }
-    /**
-     * Subscribe to conversation changes
-     */
-    function onConversationChange(callback) {
-        conversationListeners.add(callback);
-        return () => conversationListeners.delete(callback);
-    }
-    /**
-     * Subscribe to turn changes
-     */
-    function onTurnChange(callback) {
-        turnListeners.add(callback);
-        return () => turnListeners.delete(callback);
-    }
-    // ─── Session View Queries ───
-    function getSession(sessionId) {
-        const row = store.getRow('sessions', sessionId);
-        if (!row.id)
-            return null;
-        return rowToSession(row);
-    }
-    function listSessions(filter) {
-        const sessions = [];
-        const rowIds = store.getRowIds('sessions');
-        for (const rowId of rowIds) {
-            const row = store.getRow('sessions', rowId);
-            if (!row.id)
-                continue;
-            const session = rowToSession(row);
-            if (filter) {
-                if (filter.state && session.state !== filter.state)
-                    continue;
-                if (filter.agent_id && session.current_agent_id !== filter.agent_id && session.head_manager_id !== filter.agent_id)
-                    continue;
-            }
-            sessions.push(session);
-        }
-        return sessions;
-    }
-    /**
-     * Notify session change listeners
-     */
-    function notifySessionChange(sessionId, session) {
-        for (const callback of sessionListeners) {
-            callback(sessionId, session);
-        }
-    }
-    /**
-     * Subscribe to session changes
-     */
-    function onSessionChange(callback) {
-        sessionListeners.add(callback);
-        return () => sessionListeners.delete(callback);
-    }
-    // ─── Conversation View Queries ───
-    function getConversation(conversationId) {
-        const row = store.getRow('conversations', conversationId);
-        if (!row.id)
-            return null;
-        return rowToConversation(row);
-    }
-    function listConversations(filter) {
-        const conversations = [];
-        const rowIds = store.getRowIds('conversations');
-        for (const rowId of rowIds) {
-            const row = store.getRow('conversations', rowId);
-            if (!row.id)
-                continue;
-            const conversation = rowToConversation(row);
-            if (filter) {
-                if (filter.type && conversation.type !== filter.type)
-                    continue;
-                if (filter.status && conversation.status !== filter.status)
-                    continue;
-                if (filter.parentConversationId && conversation.parentConversationId !== filter.parentConversationId)
-                    continue;
-                if (filter.participantId) {
-                    // Check participants table for membership
-                    const partRow = store.getRow('participants', `${conversation.id}:${filter.participantId}`);
-                    if (!partRow.id)
-                        continue;
-                    // Skip if participant has left
-                    if (partRow.left_at && partRow.left_at > 0)
-                        continue;
-                }
-            }
-            conversations.push(conversation);
-        }
-        return conversations;
-    }
-    function listTurns(filter) {
-        const turns = [];
-        const rowIds = store.getRowIds('turns');
-        for (const rowId of rowIds) {
-            const row = store.getRow('turns', rowId);
-            if (!row.id)
-                continue;
-            const turn = rowToTurn(row);
-            // Filter by conversation (required)
-            if (turn.conversationId !== filter.conversationId)
-                continue;
-            // Optional filters
-            if (filter.threadId && turn.threadId !== filter.threadId)
-                continue;
-            if (filter.contentType && turn.contentType !== filter.contentType)
-                continue;
-            if (filter.participantId && turn.participant !== filter.participantId)
-                continue;
-            turns.push(turn);
-        }
-        // Sort
-        const order = filter.order ?? 'asc';
-        turns.sort((a, b) => order === 'asc' ? a.timestamp - b.timestamp : b.timestamp - a.timestamp);
-        // Limit
-        if (filter.limit) {
-            return turns.slice(0, filter.limit);
-        }
-        return turns;
-    }
-    function listParticipants(conversationId, active) {
-        const participants = [];
-        const rowIds = store.getRowIds('participants');
-        for (const rowId of rowIds) {
-            const row = store.getRow('participants', rowId);
-            if (!row.id)
-                continue;
-            if (row.conversation_id !== conversationId)
-                continue;
-            const participant = rowToParticipant(row);
-            if (active && participant.leftAt)
-                continue;
-            participants.push(participant);
-        }
-        return participants;
-    }
-    /**
-     * Persist store to disk
-     */
-    async function persist() {
-        if (persister) {
-            await persister.save();
-        }
-    }
-    /**
-     * Reload store from disk (refresh data from SQLite)
-     */
-    async function reload() {
-        if (persister) {
-            await persister.load();
-            // Rebuild materialized views from freshly loaded events
-            rebuildViews(store);
-        }
-    }
-    /**
-     * Close the store
-     */
-    async function close() {
-        if (persister) {
-            // Stop auto-save first to prevent race conditions between
-            // auto-save callbacks and the explicit save/destroy sequence.
-            await persister.stopAutoSave();
-            await persister.save();
-            // Destroy the persister (removes store listeners) BEFORE closing the DB.
-            // The destroy callback is a no-op — we close the DB ourselves below
-            // after giving TinyBase's internal async queues time to drain.
-            persister.destroy();
-            // Allow any in-flight TinyBase microtasks to settle before closing
-            // the database connection. Without this, pending writes from store
-            // change listeners can race against db.close().
-            await new Promise(resolve => setTimeout(resolve, 50));
-        }
-        if (db) {
-            db.close();
-        }
-    }
-    /**
-     * Get archives directory path
-     */
-    function getArchivesDir() {
-        return path.join(instancePath, 'archives');
-    }
-    /**
-     * Get manifest file path
-     */
-    function getManifestPath() {
-        return path.join(getArchivesDir(), 'manifest.json');
-    }
-    /**
-     * Read archive manifest
-     */
-    function readManifest() {
-        const manifestPath = getManifestPath();
-        if (fs.existsSync(manifestPath)) {
-            return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-        }
-        return { version: 1, archives: [] };
-    }
-    /**
-     * Write archive manifest
-     */
-    function writeManifest(manifest) {
-        const manifestPath = getManifestPath();
-        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-    }
-    /**
-     * Archive old events to prevent unbounded store growth
-     */
-    async function archive(options = {}) {
-        // Calculate cutoff timestamp
-        let cutoff;
-        if (options.before !== undefined) {
-            cutoff = options.before;
-        }
-        else if (options.olderThan) {
-            cutoff = Date.now() - parseDuration(options.olderThan);
-        }
-        else {
-            // Default to 30 days
-            cutoff = Date.now() - parseDuration('30d');
-        }
-        // Query events older than cutoff
-        const allEvents = query();
-        const eventsToArchive = allEvents.filter((e) => e.timestamp < cutoff);
-        const eventsToRetain = allEvents.filter((e) => e.timestamp >= cutoff);
-        if (eventsToArchive.length === 0) {
-            return {
-                archivedCount: 0,
-                archivePath: '',
-                oldestRetained: eventsToRetain.length > 0 ? eventsToRetain[0].timestamp : Date.now(),
-            };
-        }
-        // Ensure archives directory exists
-        const archivesDir = getArchivesDir();
-        if (!fs.existsSync(archivesDir)) {
-            fs.mkdirSync(archivesDir, { recursive: true });
-        }
-        // Group events by month
-        const eventsByMonth = new Map();
-        for (const event of eventsToArchive) {
-            const date = new Date(event.timestamp);
-            const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
-            if (!eventsByMonth.has(monthKey)) {
-                eventsByMonth.set(monthKey, []);
-            }
-            eventsByMonth.get(monthKey).push(event);
-        }
-        // Read existing manifest
-        const manifest = readManifest();
-        // Write archive files and update manifest
-        let lastArchivePath = '';
-        for (const [monthKey, monthEvents] of eventsByMonth) {
-            const archivePath = path.join(archivesDir, `${monthKey}.json`);
-            lastArchivePath = archivePath;
-            // Read existing archive if it exists and merge
-            let existingEvents = [];
-            if (fs.existsSync(archivePath)) {
-                existingEvents = JSON.parse(fs.readFileSync(archivePath, 'utf-8'));
-            }
-            // Merge and deduplicate by event ID
-            const mergedEvents = [...existingEvents, ...monthEvents];
-            const uniqueEvents = Array.from(new Map(mergedEvents.map((e) => [e.id, e])).values());
-            uniqueEvents.sort((a, b) => a.timestamp - b.timestamp);
-            // Write archive file
-            fs.writeFileSync(archivePath, JSON.stringify(uniqueEvents, null, 2));
-            // Update manifest entry
-            const existingIndex = manifest.archives.findIndex((a) => a.path === archivePath);
-            const archiveEntry = {
-                path: archivePath,
-                from: uniqueEvents[0].timestamp,
-                to: uniqueEvents[uniqueEvents.length - 1].timestamp,
-                eventCount: uniqueEvents.length,
-            };
-            if (existingIndex >= 0) {
-                manifest.archives[existingIndex] = archiveEntry;
-            }
-            else {
-                manifest.archives.push(archiveEntry);
-            }
-        }
-        // Sort manifest archives by date
-        manifest.archives.sort((a, b) => a.from - b.from);
-        // Write updated manifest
-        writeManifest(manifest);
-        // Remove archived events from active store
-        for (const event of eventsToArchive) {
-            store.delRow('events', event.id);
-        }
-        // Persist the updated store
-        await persist();
-        return {
-            archivedCount: eventsToArchive.length,
-            archivePath: lastArchivePath,
-            oldestRetained: eventsToRetain.length > 0 ? eventsToRetain[0].timestamp : Date.now(),
-        };
-    }
-    /**
-     * Load archived events by date range
-     */
-    async function loadArchive(options = {}) {
-        const manifest = readManifest();
-        const events = [];
-        for (const archive of manifest.archives) {
-            // Skip archives outside the requested range
-            if (options.from !== undefined && archive.to < options.from)
-                continue;
-            if (options.to !== undefined && archive.from > options.to)
-                continue;
-            // Read archive file
-            if (!fs.existsSync(archive.path))
-                continue;
-            const archiveEvents = JSON.parse(fs.readFileSync(archive.path, 'utf-8'));
-            // Filter by date range
-            for (const event of archiveEvents) {
-                if (options.from !== undefined && event.timestamp < options.from)
-                    continue;
-                if (options.to !== undefined && event.timestamp > options.to)
-                    continue;
-                events.push(event);
-            }
-        }
-        // Sort by timestamp
-        events.sort((a, b) => a.timestamp - b.timestamp);
-        return events;
-    }
-    /**
-     * Get information about available archives
-     */
-    async function getArchiveInfo() {
-        const manifest = readManifest();
-        const totalArchivedEvents = manifest.archives.reduce((sum, a) => sum + a.eventCount, 0);
-        return {
-            archives: manifest.archives,
-            totalArchivedEvents,
-        };
-    }
-    /**
-     * Export events for peer sync
-     * @param filter Optional event filter
-     * @param options Export options
-     * @param options.forPeer If true, filter by peerVisibility config
-     */
-    function exportEvents(filter, options) {
-        let events = query(filter);
-        // If exporting for peer, apply visibility filter
-        if (options?.forPeer) {
-            events = filterEventsForPeer(events, peerVisibility);
-        }
-        return events.map((event) => ({
-            ...event,
-            sourceInstance: instanceId,
-        }));
-    }
-    /**
-     * Import events from peer
-     */
-    function importEvents(events) {
-        for (const event of events) {
-            // Skip if event already exists
-            const existing = store.getRow('events', event.id);
-            if (existing.id)
-                continue;
-            // Store the event
-            store.setRow('events', event.id, {
-                id: event.id,
-                version: event.version,
-                timestamp: event.timestamp,
-                type: event.type,
-                source: JSON.stringify(event.source),
-                target: event.target ? JSON.stringify(event.target) : '',
-                payload: JSON.stringify(event.payload),
-                metadata: event.metadata ? JSON.stringify(event.metadata) : '',
-            });
-            // Update materialized views
-            applyEventToViews(store, event, notifyAgentChange, notifyTaskChange, notifyMessageChange, notifySessionChange, notifyConversationChange, notifyTurnChange);
-        }
-    }
-    /**
-     * Get underlying storage backend (for advanced use)
-     */
-    function getBackend() {
-        return createTinyBaseBackend(store, {
-            onFlush: async () => {
-                if (persister) {
-                    await persister.save();
-                }
-            },
-            onClose: async () => {
-                if (persister) {
-                    await persister.save();
-                    persister.destroy();
-                }
-                if (db) {
-                    db.close();
-                }
-            },
-        });
-    }
-    return {
-        // Instance info
-        instanceId,
-        namespace,
-        instancePath,
-        baseDir,
-        backendType,
-        peerVisibility,
-        // Event operations
-        emit,
-        query,
-        // Views
-        getAgent,
-        listAgents,
-        updateAgentPlan,
-        updateAgentMetadata,
-        getTask,
-        listTasks,
-        getMessages,
-        getFullMessage,
-        getSession,
-        listSessions,
-        getConversation,
-        listConversations,
-        listTurns,
-        listParticipants,
-        // Subscriptions
-        addSubscription,
-        removeSubscription,
-        getSubscriptions,
-        getSubscribers,
-        // Reactive updates
-        onAgentChange,
-        onTaskChange,
-        onMessageChange,
-        onSessionChange,
-        onConversationChange,
-        onTurnChange,
-        // Lifecycle
-        persist,
-        reload,
-        close,
-        // Archival
-        archive,
-        loadArchive,
-        getArchiveInfo,
-        // Export/Import
-        exportEvents,
-        importEvents,
-        // Advanced
-        getBackend,
-    };
-}
-/**
- * Initialize empty tables in the store
- */
-function initializeTables(store) {
-    // Events table is created implicitly when rows are added
-    // We just ensure the tables exist by checking row IDs
-    store.getRowIds('events');
-    store.getRowIds('agents');
-    store.getRowIds('tasks');
-    store.getRowIds('messages');
-    store.getRowIds('subscriptions');
-    store.getRowIds('sessions');
-    store.getRowIds('conversations');
-    store.getRowIds('turns');
-    store.getRowIds('threads');
-    store.getRowIds('participants');
-}
-/**
- * Rebuild materialized views from the event log
- */
-function rebuildViews(store) {
-    // Preserve out-of-band agent fields that aren't derived from events.
-    // These fields are written directly (not through events),
-    // so they would be lost when we clear and replay.
-    const OUT_OF_BAND_FIELDS = ['plan', 'name', 'metadata'];
-    const savedOutOfBand = new Map();
-    for (const rowId of store.getRowIds('agents')) {
-        const row = store.getRow('agents', rowId);
-        const saved = {};
-        for (const field of OUT_OF_BAND_FIELDS) {
-            const val = row[field];
-            if (val && val !== '' && val !== '[]') {
-                saved[field] = val;
-            }
-        }
-        if (Object.keys(saved).length > 0) {
-            savedOutOfBand.set(rowId, saved);
-        }
-    }
-    // Clear existing views
-    for (const rowId of store.getRowIds('agents')) {
-        store.delRow('agents', rowId);
-    }
-    for (const rowId of store.getRowIds('tasks')) {
-        store.delRow('tasks', rowId);
-    }
-    for (const rowId of store.getRowIds('messages')) {
-        store.delRow('messages', rowId);
-    }
-    for (const rowId of store.getRowIds('sessions')) {
-        store.delRow('sessions', rowId);
-    }
-    for (const rowId of store.getRowIds('conversations')) {
-        store.delRow('conversations', rowId);
-    }
-    for (const rowId of store.getRowIds('turns')) {
-        store.delRow('turns', rowId);
-    }
-    for (const rowId of store.getRowIds('threads')) {
-        store.delRow('threads', rowId);
-    }
-    for (const rowId of store.getRowIds('participants')) {
-        store.delRow('participants', rowId);
-    }
-    // Replay all events to rebuild views
-    const events = [];
-    for (const rowId of store.getRowIds('events')) {
-        const row = store.getRow('events', rowId);
-        if (!row.id)
-            continue;
-        // Parse raw event and migrate to current version
-        const rawEvent = {
-            id: row.id,
-            version: row.version,
-            timestamp: row.timestamp,
-            type: row.type,
-            source: JSON.parse(row.source),
-            target: row.target ? JSON.parse(row.target) : undefined,
-            payload: JSON.parse(row.payload),
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-        };
-        events.push(migrateEvent(rawEvent));
-    }
-    // Sort by timestamp
-    events.sort((a, b) => a.timestamp - b.timestamp);
-    // Apply each event (no-op callbacks since we're rebuilding)
-    const noop = () => { };
-    for (const event of events) {
-        applyEventToViews(store, event, noop, noop, noop, noop, noop, noop);
-    }
-    // Restore out-of-band agent fields preserved before the wipe
-    for (const [agentId, fields] of savedOutOfBand) {
-        const row = store.getRow('agents', agentId);
-        if (row.id) {
-            store.setPartialRow('agents', agentId, fields);
-        }
-    }
-}
-/**
- * Apply a single event to materialized views
- */
-function applyEventToViews(store, event, notifyAgentChange, notifyTaskChange, notifyMessageChange, notifySessionChange, notifyConversationChange, notifyTurnChange) {
-    switch (event.type) {
-        case 'spawn':
-            applySpawnEvent(store, event, notifyAgentChange);
-            break;
-        case 'stop':
-            applyStopEvent(store, event, notifyAgentChange);
-            break;
-        case 'status':
-            applyStatusEvent(store, event, notifyAgentChange);
-            break;
-        case 'message':
-            applyMessageEvent(store, event, notifyMessageChange);
-            break;
-        case 'task':
-            applyTaskEvent(store, event, notifyTaskChange);
-            break;
-        case 'session':
-            applySessionEvent(store, event, notifySessionChange);
-            break;
-        case 'conversation':
-            applyConversationEvent(store, event, notifyConversationChange);
-            break;
-        case 'turn':
-            applyTurnEvent(store, event, notifyTurnChange);
-            break;
-        case 'thread':
-            applyThreadEvent(store, event);
-            break;
-        case 'peer_message':
-        case 'peer_request':
-            // Peer events are stored in the event log for audit trail
-            // but not materialized into views since PeerManager handles
-            // in-memory queues. Events can be queried via eventStore.query().
-            break;
-    }
-}
-/**
- * Apply spawn event to agents view
- */
-function applySpawnEvent(store, event, notify) {
-    const payload = event.payload;
-    const agentId = payload.agent_id;
-    const parent = payload.parent ?? null;
-    // Compute lineage
-    let lineage = [];
-    if (parent) {
-        const parentRow = store.getRow('agents', parent);
-        if (parentRow.lineage) {
-            lineage = [...JSON.parse(parentRow.lineage), parent];
-        }
-        else {
-            lineage = [parent];
-        }
-    }
-    store.setRow('agents', agentId, {
-        id: agentId,
-        name: '',
-        session_id: payload.session_id,
-        provider_session_id: '',
-        parent: parent ?? '',
-        lineage: JSON.stringify(lineage),
-        state: 'spawning',
-        stop_reason: '',
-        task: payload.task,
-        task_id: payload.task_id ?? '',
-        role: payload.role ?? '',
-        config: JSON.stringify(payload.config ?? {}),
-        cwd: payload.cwd ?? process.cwd(),
-        plan: '[]',
-        metadata: '',
-        created_at: event.timestamp,
-        started_at: 0,
-        stopped_at: 0,
-        last_activity_at: event.timestamp,
-    });
-    const agent = rowToAgent(store.getRow('agents', agentId));
-    notify(agentId, agent);
-}
-/**
- * Apply stop event to agents view
- */
-function applyStopEvent(store, event, notify) {
-    const agentId = event.source.agent_id;
-    if (!agentId)
-        return;
-    const payload = event.payload;
-    store.setPartialRow('agents', agentId, {
-        state: 'stopped',
-        stop_reason: payload.reason,
-        stopped_at: event.timestamp,
-        last_activity_at: event.timestamp,
-    });
-    const agent = rowToAgent(store.getRow('agents', agentId));
-    notify(agentId, agent);
-}
-/**
- * Apply status event to agents view
- */
-function applyStatusEvent(store, event, notify) {
-    const agentId = event.source.agent_id;
-    if (!agentId)
-        return;
-    const payload = event.payload;
-    // Handle specific status types
-    if (payload.status_type === 'started') {
-        const updates = {
-            state: 'running',
-            started_at: event.timestamp,
-            last_activity_at: event.timestamp,
-        };
-        // Store the provider's session ID (e.g., Claude Code UUID for --resume)
-        if (payload.provider_session_id) {
-            updates.provider_session_id = payload.provider_session_id;
-        }
-        store.setPartialRow('agents', agentId, updates);
-    }
-    else {
-        // Always update last_activity_at on any status event
-        store.setPartialRow('agents', agentId, {
-            last_activity_at: event.timestamp,
-        });
-    }
-    const agent = rowToAgent(store.getRow('agents', agentId));
-    notify(agentId, agent);
-}
-/**
- * Apply message event to messages view
- */
-function applyMessageEvent(store, event, notify) {
-    const target = event.target;
-    if (!target)
-        return;
-    const payload = event.payload;
-    // Handle various payload formats - content may be a string, object, or missing
-    const rawContent = payload.content;
-    const content = typeof rawContent === 'string'
-        ? rawContent
-        : rawContent != null
-            ? JSON.stringify(rawContent)
-            : '[no content]';
-    // Truncate if needed (1000 chars limit)
-    const MAX_CONTENT_LENGTH = 1000;
-    const truncated = content.length > MAX_CONTENT_LENGTH;
-    const displayContent = truncated ? content.slice(0, MAX_CONTENT_LENGTH) + '...' : content;
-    // Route to direct agent target
-    if (target.agent_id) {
-        const messageId = `${event.id}:${target.agent_id}`;
-        store.setRow('messages', messageId, {
-            id: event.id,
-            recipient: target.agent_id,
-            from: JSON.stringify(event.source),
-            content: displayContent,
-            timestamp: event.timestamp,
-            truncated,
-            correlation_id: payload.correlation_id ?? '',
-        });
-        notify(target.agent_id);
-    }
-    // Route to topic subscribers
-    if (target.topic) {
-        const rowIds = store.getRowIds('subscriptions');
-        for (const rowId of rowIds) {
-            const row = store.getRow('subscriptions', rowId);
-            if (row.type === 'topic' && row.target === target.topic) {
-                const recipientId = row.agent_id;
-                const messageId = `${event.id}:${recipientId}`;
-                store.setRow('messages', messageId, {
-                    id: event.id,
-                    recipient: recipientId,
-                    from: JSON.stringify(event.source),
-                    content: displayContent,
-                    timestamp: event.timestamp,
-                    truncated,
-                    correlation_id: payload.correlation_id ?? '',
-                });
-                notify(recipientId);
-            }
-        }
-    }
-}
-/**
- * Apply task event to tasks view
- */
-function applyTaskEvent(store, event, notify) {
-    const payload = event.payload;
-    const taskId = payload.task_id;
-    switch (payload.action) {
-        case 'created': {
-            const details = payload.details;
-            store.setRow('tasks', taskId, {
-                id: taskId,
-                description: details.description,
-                status: 'pending',
-                assigned_agent: '',
-                parent_task: details.parent_task ?? '',
-                subtasks: JSON.stringify([]),
-                blockers: JSON.stringify([]),
-                tags: details.tags ? JSON.stringify(details.tags) : '',
-                created_at: event.timestamp,
-                started_at: 0,
-                completed_at: 0,
-                created_by: event.source.agent_id ?? '',
-                inputs: JSON.stringify(details.inputs ?? {}),
-                outputs: JSON.stringify({}),
-                artifacts: JSON.stringify([]),
-                agent_history: JSON.stringify([]),
-                retry_policy: details.retryPolicy
-                    ? JSON.stringify(details.retryPolicy)
-                    : '',
-                retry_state: '',
-            });
-            break;
-        }
-        case 'assigned': {
-            const details = payload.details;
-            const existing = store.getRow('tasks', taskId);
-            const history = existing.agent_history
-                ? JSON.parse(existing.agent_history)
-                : [];
-            history.push({
-                agent_id: details.agent_id,
-                role: details.role,
-                assigned_at: event.timestamp,
-            });
-            store.setPartialRow('tasks', taskId, {
-                status: 'assigned',
-                assigned_agent: details.agent_id,
-                agent_history: JSON.stringify(history),
-            });
-            break;
-        }
-        case 'unassigned': {
-            const details = payload.details;
-            const existing = store.getRow('tasks', taskId);
-            const history = existing.agent_history
-                ? JSON.parse(existing.agent_history)
-                : [];
-            // Update the last entry for this agent with ended_at
-            for (let i = history.length - 1; i >= 0; i--) {
-                if (history[i].agent_id === details.agent_id && !history[i].ended_at) {
-                    history[i].ended_at = event.timestamp;
-                    break;
-                }
-            }
-            const updates = {
-                assigned_agent: '',
-                agent_history: JSON.stringify(history),
-            };
-            // Reset to pending if task was only assigned (not yet started)
-            if (existing.status === 'assigned') {
-                updates.status = 'pending';
-            }
-            store.setPartialRow('tasks', taskId, updates);
-            break;
-        }
-        case 'status_change': {
-            const details = payload.details;
-            const updates = {};
-            if (details.status) {
-                updates.status = details.status;
-                if (details.status === 'in_progress') {
-                    const existing = store.getRow('tasks', taskId);
-                    if (!existing.started_at) {
-                        updates.started_at = event.timestamp;
-                    }
-                }
-            }
-            if (details.outputs !== undefined) {
-                updates.outputs = JSON.stringify(details.outputs);
-            }
-            if (details.artifacts !== undefined) {
-                const existing = store.getRow('tasks', taskId);
-                const currentArtifacts = existing.artifacts
-                    ? JSON.parse(existing.artifacts)
-                    : [];
-                updates.artifacts = JSON.stringify([
-                    ...currentArtifacts,
-                    ...details.artifacts,
-                ]);
-            }
-            if (details.description !== undefined) {
-                updates.description = details.description;
-            }
-            if (details.subtask_added) {
-                const existing = store.getRow('tasks', taskId);
-                const subtasks = existing.subtasks
-                    ? JSON.parse(existing.subtasks)
-                    : [];
-                subtasks.push(details.subtask_added);
-                updates.subtasks = JSON.stringify(subtasks);
-            }
-            if (details.retryState !== undefined) {
-                updates.retry_state = JSON.stringify(details.retryState);
-            }
-            // Allow clearing the assigned agent (for retry)
-            if (details.agent_id === null) {
-                updates.assigned_agent = '';
-            }
-            if (Object.keys(updates).length > 0) {
-                store.setPartialRow('tasks', taskId, updates);
-            }
-            break;
-        }
-        case 'completed': {
-            store.setPartialRow('tasks', taskId, {
-                status: 'completed',
-                completed_at: event.timestamp,
-            });
-            break;
-        }
-        case 'failed': {
-            store.setPartialRow('tasks', taskId, {
-                status: 'failed',
-                completed_at: event.timestamp,
-            });
-            break;
-        }
-        case 'blocker_added': {
-            const details = payload.details;
-            const existing = store.getRow('tasks', taskId);
-            const blockers = existing.blockers
-                ? JSON.parse(existing.blockers)
-                : [];
-            if (!blockers.includes(details.blocker_id)) {
-                blockers.push(details.blocker_id);
-                store.setPartialRow('tasks', taskId, {
-                    blockers: JSON.stringify(blockers),
-                });
-            }
-            break;
-        }
-        case 'blocker_removed': {
-            const details = payload.details;
-            const existing = store.getRow('tasks', taskId);
-            const blockers = existing.blockers
-                ? JSON.parse(existing.blockers)
-                : [];
-            const idx = blockers.indexOf(details.blocker_id);
-            if (idx >= 0) {
-                blockers.splice(idx, 1);
-                store.setPartialRow('tasks', taskId, {
-                    blockers: JSON.stringify(blockers),
-                });
-            }
-            break;
-        }
-    }
-    const task = rowToTask(store.getRow('tasks', taskId));
-    notify(taskId, task);
-}
-/**
- * Convert a TinyBase row to an Agent object
- */
-function rowToAgent(row) {
-    const stopReason = row.stop_reason;
-    return {
-        id: row.id,
-        name: row.name || undefined,
-        session_id: row.session_id,
-        provider_session_id: row.provider_session_id || undefined,
-        parent: row.parent || null,
-        lineage: row.lineage ? JSON.parse(row.lineage) : [],
-        state: row.state,
-        stop_reason: stopReason ? stopReason : undefined,
-        task: row.task,
-        task_id: row.task_id || undefined,
-        role: row.role || undefined,
-        config: row.config ? JSON.parse(row.config) : {},
-        cwd: row.cwd || process.cwd(),
-        plan: row.plan ? JSON.parse(row.plan) : [],
-        metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-        created_at: row.created_at,
-        started_at: row.started_at || undefined,
-        stopped_at: row.stopped_at || undefined,
-        last_activity_at: row.last_activity_at || undefined,
-    };
-}
-/**
- * Convert a TinyBase row to a Task object
- */
-function rowToTask(row) {
-    return {
-        id: row.id,
-        description: row.description,
-        status: row.status,
-        assigned_agent: row.assigned_agent || undefined,
-        parent_task: row.parent_task || undefined,
-        subtasks: row.subtasks ? JSON.parse(row.subtasks) : undefined,
-        blockers: row.blockers ? JSON.parse(row.blockers) : undefined,
-        created_at: row.created_at,
-        started_at: row.started_at || undefined,
-        completed_at: row.completed_at || undefined,
-        created_by: row.created_by,
-        inputs: row.inputs ? JSON.parse(row.inputs) : undefined,
-        outputs: row.outputs ? JSON.parse(row.outputs) : undefined,
-        artifacts: row.artifacts ? JSON.parse(row.artifacts) : undefined,
-        agent_history: row.agent_history ? JSON.parse(row.agent_history) : undefined,
-        tags: row.tags ? JSON.parse(row.tags) : undefined,
-        retryPolicy: row.retry_policy ? JSON.parse(row.retry_policy) : undefined,
-        retryState: row.retry_state ? JSON.parse(row.retry_state) : undefined,
-    };
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Session Event Handlers
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Apply session event to sessions view
- */
-function applySessionEvent(store, event, notify) {
-    const payload = event.payload;
-    const sessionId = payload.session_id;
-    switch (payload.action) {
-        case 'created': {
-            store.setRow('sessions', sessionId, {
-                id: sessionId,
-                head_manager_id: payload.head_manager_id ?? '',
-                current_agent_id: payload.head_manager_id ?? '',
-                state: 'active',
-                created_at: event.timestamp,
-                updated_at: event.timestamp,
-                closed_at: 0,
-            });
-            break;
-        }
-        case 'mounted': {
-            store.setPartialRow('sessions', sessionId, {
-                current_agent_id: payload.target_agent_id ?? '',
-                state: 'mounted',
-                updated_at: event.timestamp,
-            });
-            break;
-        }
-        case 'unmounted': {
-            const existing = store.getRow('sessions', sessionId);
-            store.setPartialRow('sessions', sessionId, {
-                current_agent_id: existing.head_manager_id,
-                state: 'active',
-                updated_at: event.timestamp,
-            });
-            break;
-        }
-        case 'closed': {
-            store.setPartialRow('sessions', sessionId, {
-                state: 'closed',
-                updated_at: event.timestamp,
-                closed_at: event.timestamp,
-            });
-            break;
-        }
-    }
-    const session = rowToSession(store.getRow('sessions', sessionId));
-    notify(sessionId, session);
-}
-/**
- * Convert a TinyBase row to a Session object
- */
-function rowToSession(row) {
-    return {
-        id: row.id,
-        head_manager_id: row.head_manager_id,
-        current_agent_id: row.current_agent_id,
-        state: row.state,
-        created_at: row.created_at,
-        updated_at: row.updated_at,
-        closed_at: row.closed_at || undefined,
-    };
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Conversation Event Handlers
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Apply conversation event to conversations view
- */
-function applyConversationEvent(store, event, notify) {
-    const payload = event.payload;
-    const conversationId = payload.conversation_id;
-    switch (payload.action) {
-        case 'created': {
-            store.setRow('conversations', conversationId, {
-                id: conversationId,
-                type: payload.conversation_type,
-                status: 'active',
-                subject: payload.subject ?? '',
-                parent_conversation_id: payload.parent_conversation_id ?? '',
-                created_by: event.source.agent_id ?? 'unknown',
-                created_at: event.timestamp,
-                updated_at: event.timestamp,
-                closed_at: 0,
-                closed_by: '',
-                close_reason: '',
-                participant_count: 0,
-                metadata: payload.metadata ? JSON.stringify(payload.metadata) : '',
-            });
-            break;
-        }
-        case 'closed': {
-            const closeReason = payload.close_reason ?? '';
-            // Map close_reason to valid ConversationStatus
-            const validStatuses = new Set(['completed', 'failed', 'archived']);
-            const closedStatus = validStatuses.has(closeReason) ? closeReason : 'completed';
-            store.setPartialRow('conversations', conversationId, {
-                status: closedStatus,
-                closed_at: event.timestamp,
-                updated_at: event.timestamp,
-                closed_by: payload.closed_by ?? event.source.agent_id ?? '',
-                close_reason: closeReason,
-            });
-            break;
-        }
-        case 'participant_joined': {
-            const participantId = payload.participant_id;
-            const partId = `${conversationId}:${participantId}`;
-            store.setRow('participants', partId, {
-                id: participantId,
-                conversation_id: conversationId,
-                type: payload.participant_type ?? 'agent',
-                role: payload.participant_role ?? 'worker',
-                joined_at: event.timestamp,
-                left_at: 0,
-                agent_id: payload.agent_id ?? '',
-            });
-            // Increment participant count
-            const existing = store.getRow('conversations', conversationId);
-            if (existing.id) {
-                const count = existing.participant_count || 0;
-                store.setPartialRow('conversations', conversationId, {
-                    participant_count: count + 1,
-                    updated_at: event.timestamp,
-                });
-            }
-            break;
-        }
-        case 'participant_left': {
-            const leftParticipantId = payload.participant_id;
-            const partId = `${conversationId}:${leftParticipantId}`;
-            store.setPartialRow('participants', partId, {
-                left_at: event.timestamp,
-            });
-            // Decrement participant count
-            const existing = store.getRow('conversations', conversationId);
-            if (existing.id) {
-                const count = existing.participant_count || 0;
-                store.setPartialRow('conversations', conversationId, {
-                    participant_count: Math.max(0, count - 1),
-                    updated_at: event.timestamp,
-                });
-            }
-            break;
-        }
-    }
-    const conversation = rowToConversation(store.getRow('conversations', conversationId));
-    notify(conversationId, conversation);
-}
-/**
- * Apply turn event to turns view
- */
-function applyTurnEvent(store, event, notify) {
-    const payload = event.payload;
-    if (payload.action !== 'recorded')
-        return;
-    const turnId = payload.turn_id;
-    const conversationId = payload.conversation_id;
-    const content = payload.content;
-    store.setRow('turns', turnId, {
-        id: turnId,
-        conversation_id: conversationId,
-        participant: payload.participant ?? event.source.agent_id ?? '',
-        timestamp: event.timestamp,
-        content_type: payload.content_type ?? 'text',
-        content: typeof content === 'string' ? content : JSON.stringify(content),
-        thread_id: payload.thread_id ?? '',
-        in_reply_to: payload.in_reply_to ?? '',
-        source_type: payload.source_type ?? 'explicit',
-        source_message_id: payload.source_message_id ?? '',
-        metadata: payload.metadata ? JSON.stringify(payload.metadata) : '',
-    });
-    // Update conversation's updatedAt
-    const convRow = store.getRow('conversations', conversationId);
-    if (convRow.id) {
-        store.setPartialRow('conversations', conversationId, {
-            updated_at: event.timestamp,
-        });
-    }
-    const turn = rowToTurn(store.getRow('turns', turnId));
-    notify(conversationId, turn);
-}
-/**
- * Apply thread event to threads view
- */
-function applyThreadEvent(store, event) {
-    const payload = event.payload;
-    if (payload.action !== 'created')
-        return;
-    const threadId = payload.thread_id;
-    store.setRow('threads', threadId, {
-        id: threadId,
-        conversation_id: payload.conversation_id ?? '',
-        root_turn_id: payload.root_turn_id ?? '',
-        subject: payload.subject ?? '',
-        parent_thread_id: payload.parent_thread_id ?? '',
-        created_by: event.source.agent_id ?? 'unknown',
-        created_at: event.timestamp,
-        turn_count: 0,
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Conversation Row Conversion Functions
-// ─────────────────────────────────────────────────────────────────────────────
-function rowToConversation(row) {
-    return {
-        id: row.id,
-        type: row.type,
-        status: row.status,
-        subject: row.subject || undefined,
-        parentConversationId: row.parent_conversation_id || undefined,
-        createdBy: row.created_by,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-        closedAt: row.closed_at || undefined,
-        closedBy: row.closed_by || undefined,
-        closeReason: row.close_reason || undefined,
-        participantCount: row.participant_count || 0,
-        metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-    };
-}
-function rowToTurn(row) {
-    const rawContent = row.content;
-    let content;
-    try {
-        content = JSON.parse(rawContent);
-    }
-    catch {
-        content = rawContent;
-    }
-    return {
-        id: row.id,
-        conversationId: row.conversation_id,
-        participant: row.participant,
-        timestamp: row.timestamp,
-        contentType: row.content_type,
-        content,
-        threadId: row.thread_id || undefined,
-        inReplyTo: row.in_reply_to || undefined,
-        sourceType: row.source_type,
-        sourceMessageId: row.source_message_id || undefined,
-        metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-    };
-}
-function rowToParticipant(row) {
-    return {
-        id: row.id,
-        conversationId: row.conversation_id,
-        type: row.type,
-        role: row.role,
-        joinedAt: row.joined_at,
-        leftAt: row.left_at || undefined,
-        agentId: row.agent_id || undefined,
-    };
-}
-//# sourceMappingURL=event-store.js.map