macro-agent 0.2.4 → 0.2.6

package/dist/store/event-store.js

@@ -0,0 +1,1751 @@
+/**
+ * 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().
+        // Disabled for secondary instances (e.g., MCP subprocesses) to prevent
+        // cross-process data corruption from concurrent TinyBase save operations.
+        if (!config.disableAutoSave) {
+            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 });
+        }
+        if (updates.team_instance !== undefined) {
+            partial.team_instance = updates.team_instance;
+        }
+        if (updates.cwd !== undefined) {
+            partial.cwd = updates.cwd;
+        }
+        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', 'cwd', 'team_instance'];
+    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 ?? '',
+        team_instance: payload.team_instance ?? '',
+        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,
+        team_instance: row.team_instance || 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