claude-flow 3.28.0 → 3.30.0

package/v3/@claude-flow/shared/dist/events/event-store.test.js

@@ -0,0 +1,293 @@
+/**
+ * Event Store Tests
+ *
+ * Comprehensive tests for the event sourcing implementation.
+ * Tests event storage, retrieval, filtering, snapshots, and projections.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { EventStore } from './event-store.js';
+import { AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection } from './projections.js';
+import { createAgentSpawnedEvent, createAgentStartedEvent, createAgentTaskAssignedEvent, createAgentTaskCompletedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, } from './domain-events.js';
+describe('EventStore', () => {
+    let eventStore;
+    beforeEach(async () => {
+        eventStore = new EventStore({ databasePath: ':memory:', verbose: false });
+        await eventStore.initialize();
+    });
+    afterEach(async () => {
+        await eventStore.shutdown();
+    });
+    describe('Event Appending', () => {
+        it('should append events to the store', async () => {
+            const event = createAgentSpawnedEvent('agent-1', 'coder', 'core', ['coding', 'testing']);
+            await eventStore.append(event);
+            const events = await eventStore.getEvents('agent-1');
+            expect(events).toHaveLength(1);
+            expect(events[0].type).toBe('agent:spawned');
+            expect(events[0].version).toBe(1);
+        });
+        it('should increment version for each event', async () => {
+            const event1 = createAgentSpawnedEvent('agent-1', 'coder', 'core', []);
+            const event2 = createAgentStartedEvent('agent-1');
+            await eventStore.append(event1);
+            await eventStore.append(event2);
+            const events = await eventStore.getEvents('agent-1');
+            expect(events[0].version).toBe(1);
+            expect(events[1].version).toBe(2);
+        });
+        it('should maintain version per aggregate', async () => {
+            const agent1Event = createAgentSpawnedEvent('agent-1', 'coder', 'core', []);
+            const agent2Event = createAgentSpawnedEvent('agent-2', 'tester', 'quality', []);
+            await eventStore.append(agent1Event);
+            await eventStore.append(agent2Event);
+            const agent1Events = await eventStore.getEvents('agent-1');
+            const agent2Events = await eventStore.getEvents('agent-2');
+            expect(agent1Events[0].version).toBe(1);
+            expect(agent2Events[0].version).toBe(1);
+        });
+    });
+    describe('Event Retrieval', () => {
+        beforeEach(async () => {
+            // Setup: Create multiple events
+            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+            await eventStore.append(createAgentStartedEvent('agent-1'));
+            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Build feature', 'Description', 'high', []));
+            await eventStore.append(createTaskStartedEvent('task-1', 'agent-1'));
+        });
+        it('should retrieve events by aggregate ID', async () => {
+            const events = await eventStore.getEvents('agent-1');
+            expect(events).toHaveLength(2);
+            expect(events[0].type).toBe('agent:spawned');
+            expect(events[1].type).toBe('agent:started');
+        });
+        it('should retrieve events from specific version', async () => {
+            const events = await eventStore.getEvents('agent-1', 2);
+            expect(events).toHaveLength(1);
+            expect(events[0].type).toBe('agent:started');
+        });
+        it('should retrieve events by type', async () => {
+            const events = await eventStore.getEventsByType('task:created');
+            expect(events).toHaveLength(1);
+            expect(events[0].aggregateId).toBe('task-1');
+        });
+    });
+    describe('Event Filtering', () => {
+        beforeEach(async () => {
+            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+            await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
+            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task 1', 'Desc', 'high', []));
+            await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
+        });
+        it('should filter by aggregate types', async () => {
+            const events = await eventStore.query({ aggregateTypes: ['agent'] });
+            expect(events).toHaveLength(2);
+            expect(events.every((e) => e.aggregateType === 'agent')).toBe(true);
+        });
+        it('should filter by event types', async () => {
+            const events = await eventStore.query({ eventTypes: ['agent:spawned'] });
+            expect(events).toHaveLength(2);
+            expect(events.every((e) => e.type === 'agent:spawned')).toBe(true);
+        });
+        it('should filter by aggregate IDs', async () => {
+            const events = await eventStore.query({ aggregateIds: ['agent-1', 'task-1'] });
+            expect(events).toHaveLength(2);
+        });
+        it('should support pagination', async () => {
+            const page1 = await eventStore.query({ limit: 2, offset: 0 });
+            const page2 = await eventStore.query({ limit: 2, offset: 2 });
+            expect(page1).toHaveLength(2);
+            expect(page2).toHaveLength(2);
+            expect(page1[0].id).not.toBe(page2[0].id);
+        });
+    });
+    describe('Event Replay', () => {
+        it('should replay all events', async () => {
+            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+            await eventStore.append(createAgentStartedEvent('agent-1'));
+            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
+            const events = [];
+            for await (const event of eventStore.replay()) {
+                events.push(event);
+            }
+            expect(events).toHaveLength(3);
+        });
+        it('should replay from specific version', async () => {
+            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+            await eventStore.append(createAgentStartedEvent('agent-1'));
+            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
+            const events = [];
+            for await (const event of eventStore.replay(2)) {
+                events.push(event);
+            }
+            expect(events.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe('Snapshots', () => {
+        it('should save snapshots', async () => {
+            const snapshot = {
+                aggregateId: 'agent-1',
+                aggregateType: 'agent',
+                version: 5,
+                state: { status: 'active', tasks: ['task-1'] },
+                timestamp: Date.now(),
+            };
+            await eventStore.saveSnapshot(snapshot);
+            const retrieved = await eventStore.getSnapshot('agent-1');
+            expect(retrieved).not.toBeNull();
+            expect(retrieved?.version).toBe(5);
+            expect(retrieved?.state).toEqual({ status: 'active', tasks: ['task-1'] });
+        });
+        it('should return latest snapshot', async () => {
+            const snapshot1 = {
+                aggregateId: 'agent-1',
+                aggregateType: 'agent',
+                version: 5,
+                state: { status: 'active' },
+                timestamp: Date.now(),
+            };
+            const snapshot2 = {
+                aggregateId: 'agent-1',
+                aggregateType: 'agent',
+                version: 10,
+                state: { status: 'completed' },
+                timestamp: Date.now(),
+            };
+            await eventStore.saveSnapshot(snapshot1);
+            await eventStore.saveSnapshot(snapshot2);
+            const retrieved = await eventStore.getSnapshot('agent-1');
+            expect(retrieved?.version).toBe(10);
+        });
+    });
+    describe('Statistics', () => {
+        it('should provide event store statistics', async () => {
+            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+            await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
+            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
+            const stats = await eventStore.getStats();
+            expect(stats.totalEvents).toBe(3);
+            expect(stats.eventsByType['agent:spawned']).toBe(2);
+            expect(stats.eventsByType['task:created']).toBe(1);
+            expect(stats.eventsByAggregate['agent-1']).toBe(1);
+            expect(stats.eventsByAggregate['agent-2']).toBe(1);
+        });
+    });
+});
+describe('AgentStateProjection', () => {
+    let eventStore;
+    let projection;
+    beforeEach(async () => {
+        eventStore = new EventStore({ databasePath: ':memory:' });
+        await eventStore.initialize();
+        projection = new AgentStateProjection(eventStore);
+    });
+    afterEach(async () => {
+        await eventStore.shutdown();
+    });
+    it('should build agent state from events', async () => {
+        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', ['coding']));
+        await eventStore.append(createAgentStartedEvent('agent-1'));
+        await projection.initialize();
+        const agent = projection.getAgent('agent-1');
+        expect(agent).not.toBeNull();
+        expect(agent?.role).toBe('coder');
+        expect(agent?.status).toBe('active');
+    });
+    it('should track task assignments', async () => {
+        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+        await eventStore.append(createAgentTaskAssignedEvent('agent-1', 'task-1', Date.now()));
+        await projection.initialize();
+        const agent = projection.getAgent('agent-1');
+        expect(agent?.currentTask).toBe('task-1');
+    });
+    it('should track completed tasks', async () => {
+        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+        await eventStore.append(createAgentTaskCompletedEvent('agent-1', 'task-1', { success: true }, Date.now(), 5000));
+        await projection.initialize();
+        const agent = projection.getAgent('agent-1');
+        expect(agent?.completedTasks).toContain('task-1');
+        expect(agent?.taskCount).toBe(1);
+    });
+    it('should filter agents by status', async () => {
+        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
+        await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
+        await eventStore.append(createAgentStartedEvent('agent-1'));
+        await projection.initialize();
+        const activeAgents = projection.getAgentsByStatus('active');
+        const idleAgents = projection.getAgentsByStatus('idle');
+        expect(activeAgents).toHaveLength(1);
+        expect(idleAgents).toHaveLength(1);
+    });
+});
+describe('TaskHistoryProjection', () => {
+    let eventStore;
+    let projection;
+    beforeEach(async () => {
+        eventStore = new EventStore({ databasePath: ':memory:' });
+        await eventStore.initialize();
+        projection = new TaskHistoryProjection(eventStore);
+    });
+    afterEach(async () => {
+        await eventStore.shutdown();
+    });
+    it('should build task history from events', async () => {
+        await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Build Feature', 'Description', 'high', []));
+        await eventStore.append(createTaskStartedEvent('task-1', 'agent-1'));
+        await eventStore.append(createTaskCompletedEvent('task-1', { success: true }, 5000));
+        await projection.initialize();
+        const task = projection.getTask('task-1');
+        expect(task).not.toBeNull();
+        expect(task?.title).toBe('Build Feature');
+        expect(task?.status).toBe('completed');
+        expect(task?.assignedAgent).toBe('agent-1');
+    });
+    it('should calculate average task duration', async () => {
+        await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task 1', 'Desc', 'high', []));
+        await eventStore.append(createTaskCompletedEvent('task-1', { success: true }, 5000));
+        await eventStore.append(createTaskCreatedEvent('task-2', 'implementation', 'Task 2', 'Desc', 'high', []));
+        await eventStore.append(createTaskCompletedEvent('task-2', { success: true }, 3000));
+        await projection.initialize();
+        const avgDuration = projection.getAverageTaskDuration();
+        expect(avgDuration).toBe(4000);
+    });
+});
+describe('MemoryIndexProjection', () => {
+    let eventStore;
+    let projection;
+    beforeEach(async () => {
+        eventStore = new EventStore({ databasePath: ':memory:' });
+        await eventStore.initialize();
+        projection = new MemoryIndexProjection(eventStore);
+    });
+    afterEach(async () => {
+        await eventStore.shutdown();
+    });
+    it('should build memory index from events', async () => {
+        await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
+        await eventStore.append(createMemoryRetrievedEvent('mem-1', 'default', 'key1', 1));
+        await projection.initialize();
+        const memory = projection.getMemory('mem-1');
+        expect(memory).not.toBeNull();
+        expect(memory?.namespace).toBe('default');
+        expect(memory?.accessCount).toBe(1);
+    });
+    it('should track memory deletions', async () => {
+        await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
+        await eventStore.append(createMemoryDeletedEvent('mem-1', 'default', 'key1'));
+        await projection.initialize();
+        const memory = projection.getMemory('mem-1');
+        expect(memory?.isDeleted).toBe(true);
+        const activeMemories = projection.getActiveMemories();
+        expect(activeMemories).toHaveLength(0);
+    });
+    it('should calculate total size by namespace', async () => {
+        await eventStore.append(createMemoryStoredEvent('mem-1', 'ns1', 'key1', 'semantic', 1024));
+        await eventStore.append(createMemoryStoredEvent('mem-2', 'ns1', 'key2', 'semantic', 2048));
+        await eventStore.append(createMemoryStoredEvent('mem-3', 'ns2', 'key3', 'semantic', 512));
+        await projection.initialize();
+        const ns1Size = projection.getTotalSizeByNamespace('ns1');
+        const ns2Size = projection.getTotalSizeByNamespace('ns2');
+        expect(ns1Size).toBe(3072);
+        expect(ns2Size).toBe(512);
+    });
+});
+//# sourceMappingURL=event-store.test.js.map

package/v3/@claude-flow/shared/dist/events/example-usage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Event Store Usage Example
+ *
+ * Demonstrates how to use the Event Sourcing system in V3 Claude Flow.
+ *
+ * Usage:
+ *   npx tsx v3/@claude-flow/shared/src/events/example-usage.ts
+ */
+export {};
+//# sourceMappingURL=example-usage.d.ts.map

package/v3/@claude-flow/shared/dist/events/example-usage.js

@@ -0,0 +1,193 @@
+/**
+ * Event Store Usage Example
+ *
+ * Demonstrates how to use the Event Sourcing system in V3 Claude Flow.
+ *
+ * Usage:
+ *   npx tsx v3/@claude-flow/shared/src/events/example-usage.ts
+ */
+import { EventStore } from './event-store.js';
+import { AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection } from './projections.js';
+import { createAgentSpawnedEvent, createAgentStartedEvent, createAgentTaskAssignedEvent, createAgentTaskCompletedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createSwarmInitializedEvent, createSwarmScaledEvent, } from './domain-events.js';
+async function main() {
+    console.log('Event Sourcing Example - V3 Claude Flow\n');
+    // =========================================================================
+    // 1. Initialize Event Store
+    // =========================================================================
+    console.log('1. Initializing Event Store...');
+    const eventStore = new EventStore({
+        databasePath: './event-store-example.db',
+        verbose: true,
+        autoPersistInterval: 0, // Manual persist for demo
+    });
+    await eventStore.initialize();
+    console.log('   Event Store initialized\n');
+    // =========================================================================
+    // 2. Record Swarm Initialization Events
+    // =========================================================================
+    console.log('2. Recording Swarm Events...');
+    await eventStore.append(createSwarmInitializedEvent('hierarchical-mesh', 15, {
+        security: { strict: true },
+        memory: { backend: 'agentdb' },
+    }));
+    await eventStore.append(createSwarmScaledEvent(0, 5, 'Initial agent spawn'));
+    console.log('   Swarm events recorded\n');
+    // =========================================================================
+    // 3. Record Agent Lifecycle Events
+    // =========================================================================
+    console.log('3. Recording Agent Lifecycle Events...');
+    // Agent 1: Queen Coordinator
+    await eventStore.append(createAgentSpawnedEvent('agent-1', 'queen-coordinator', 'coordination', [
+        'orchestration',
+        'task-assignment',
+    ]));
+    await eventStore.append(createAgentStartedEvent('agent-1'));
+    // Agent 2: Security Architect
+    await eventStore.append(createAgentSpawnedEvent('agent-2', 'security-architect', 'security', [
+        'threat-modeling',
+        'security-design',
+    ]));
+    await eventStore.append(createAgentStartedEvent('agent-2'));
+    // Agent 3: Core Architect
+    await eventStore.append(createAgentSpawnedEvent('agent-3', 'core-architect', 'core', ['ddd-design', 'architecture']));
+    await eventStore.append(createAgentStartedEvent('agent-3'));
+    console.log('   Agent events recorded\n');
+    // =========================================================================
+    // 4. Record Task Execution Events
+    // =========================================================================
+    console.log('4. Recording Task Execution Events...');
+    // Task 1: Security Audit
+    await eventStore.append(createTaskCreatedEvent('task-1', 'security-audit', 'Audit CVE-1 (Command Injection)', 'Review and fix command injection vulnerability', 'critical', []));
+    await eventStore.append(createTaskStartedEvent('task-1', 'agent-2'));
+    await eventStore.append(createAgentTaskAssignedEvent('agent-2', 'task-1', Date.now()));
+    // Example: Async work gap between task start and completion
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    await eventStore.append(createTaskCompletedEvent('task-1', { vulnerabilitiesFixed: 3, severity: 'high' }, 5234));
+    await eventStore.append(createAgentTaskCompletedEvent('agent-2', 'task-1', { success: true }, Date.now(), 5234));
+    // Task 2: DDD Architecture Design
+    await eventStore.append(createTaskCreatedEvent('task-2', 'architecture-design', 'Design V3 Domain Structure', 'Implement bounded contexts for V3', 'high', []));
+    await eventStore.append(createTaskStartedEvent('task-2', 'agent-3'));
+    await eventStore.append(createAgentTaskAssignedEvent('agent-3', 'task-2', Date.now()));
+    console.log('   Task events recorded\n');
+    // =========================================================================
+    // 5. Record Memory Operations Events
+    // =========================================================================
+    console.log('5. Recording Memory Operations Events...');
+    await eventStore.append(createMemoryStoredEvent('mem-1', 'agent-context', 'agent-2-state', 'episodic', 2048));
+    await eventStore.append(createMemoryStoredEvent('mem-2', 'task-results', 'task-1-result', 'semantic', 1024));
+    await eventStore.append(createMemoryRetrievedEvent('mem-1', 'agent-context', 'agent-2-state', 1));
+    await eventStore.append(createMemoryRetrievedEvent('mem-1', 'agent-context', 'agent-2-state', 2));
+    console.log('   Memory events recorded\n');
+    // =========================================================================
+    // 6. Query Events
+    // =========================================================================
+    console.log('6. Querying Events...\n');
+    const allAgentEvents = await eventStore.query({ aggregateTypes: ['agent'] });
+    console.log(`   Total agent events: ${allAgentEvents.length}`);
+    const allTaskEvents = await eventStore.query({ aggregateTypes: ['task'] });
+    console.log(`   Total task events: ${allTaskEvents.length}`);
+    const completedTaskEvents = await eventStore.getEventsByType('task:completed');
+    console.log(`   Completed task events: ${completedTaskEvents.length}`);
+    console.log();
+    // =========================================================================
+    // 7. Build Projections
+    // =========================================================================
+    console.log('7. Building Projections...\n');
+    // Agent State Projection
+    const agentProjection = new AgentStateProjection(eventStore);
+    await agentProjection.initialize();
+    console.log('   Agent State Projection:');
+    const allAgents = agentProjection.getAllAgents();
+    for (const agent of allAgents) {
+        console.log(`     - ${agent.id}: ${agent.role} (${agent.status})`);
+        console.log(`       Tasks completed: ${agent.completedTasks.length}`);
+        console.log(`       Avg duration: ${agent.taskCount > 0 ? agent.totalTaskDuration / agent.taskCount : 0}ms`);
+    }
+    const activeAgents = agentProjection.getActiveAgentCount();
+    console.log(`\n   Active agents: ${activeAgents}`);
+    // Task History Projection
+    const taskProjection = new TaskHistoryProjection(eventStore);
+    await taskProjection.initialize();
+    console.log('\n   Task History Projection:');
+    const allTasks = taskProjection.getAllTasks();
+    for (const task of allTasks) {
+        console.log(`     - ${task.id}: ${task.title} (${task.status})`);
+        console.log(`       Assigned to: ${task.assignedAgent || 'unassigned'}`);
+        console.log(`       Duration: ${task.duration || 'N/A'}ms`);
+    }
+    const avgTaskDuration = taskProjection.getAverageTaskDuration();
+    console.log(`\n   Average task duration: ${avgTaskDuration.toFixed(2)}ms`);
+    // Memory Index Projection
+    const memoryProjection = new MemoryIndexProjection(eventStore);
+    await memoryProjection.initialize();
+    console.log('\n   Memory Index Projection:');
+    const activeMemories = memoryProjection.getActiveMemories();
+    for (const memory of activeMemories) {
+        console.log(`     - ${memory.id}: ${memory.namespace}/${memory.key}`);
+        console.log(`       Size: ${memory.size} bytes, Accessed: ${memory.accessCount} times`);
+    }
+    const totalSize = activeMemories.reduce((sum, m) => sum + m.size, 0);
+    console.log(`\n   Total memory used: ${totalSize} bytes`);
+    // =========================================================================
+    // 8. Event Replay
+    // =========================================================================
+    console.log('\n8. Event Replay Example...\n');
+    let replayCount = 0;
+    for await (const event of eventStore.replay(0)) {
+        replayCount++;
+        if (replayCount <= 3) {
+            console.log(`   Replaying: ${event.type} (v${event.version})`);
+        }
+    }
+    console.log(`   Total events replayed: ${replayCount}`);
+    // =========================================================================
+    // 9. Snapshots
+    // =========================================================================
+    console.log('\n9. Snapshot Example...\n');
+    const agent2State = agentProjection.getAgent('agent-2');
+    if (agent2State) {
+        await eventStore.saveSnapshot({
+            aggregateId: 'agent-2',
+            aggregateType: 'agent',
+            version: 5,
+            state: agent2State,
+            timestamp: Date.now(),
+        });
+        console.log('   Snapshot saved for agent-2');
+        const snapshot = await eventStore.getSnapshot('agent-2');
+        console.log(`   Snapshot retrieved: version ${snapshot?.version}`);
+    }
+    // =========================================================================
+    // 10. Statistics
+    // =========================================================================
+    console.log('\n10. Event Store Statistics...\n');
+    const stats = await eventStore.getStats();
+    console.log(`   Total events: ${stats.totalEvents}`);
+    console.log(`   Events by type:`);
+    for (const [type, count] of Object.entries(stats.eventsByType)) {
+        console.log(`     - ${type}: ${count}`);
+    }
+    console.log(`\n   Events by aggregate:`);
+    const topAggregates = Object.entries(stats.eventsByAggregate)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 5);
+    for (const [aggregate, count] of topAggregates) {
+        console.log(`     - ${aggregate}: ${count}`);
+    }
+    console.log(`\n   Snapshots: ${stats.snapshotCount}`);
+    // =========================================================================
+    // Cleanup
+    // =========================================================================
+    console.log('\n11. Persisting and Shutting Down...\n');
+    await eventStore.persist();
+    await eventStore.shutdown();
+    console.log('   Event Store shutdown complete');
+    console.log('\nExample completed successfully!');
+    console.log('Database saved to: ./event-store-example.db');
+}
+// Run the example
+main().catch((error) => {
+    console.error('Error running example:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=example-usage.js.map

package/v3/@claude-flow/shared/dist/events/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Event Sourcing System (ADR-007)
+ *
+ * Complete event sourcing implementation for V3 Claude Flow:
+ * - Domain events for all aggregates (agent, task, memory, swarm)
+ * - Persistent event store with SQLite backend
+ * - Projections for building read models
+ * - Event replay and snapshots
+ *
+ * @module v3/shared/events
+ */
+export type { DomainEvent, AllDomainEvents, AgentSpawnedEvent, AgentStartedEvent, AgentStoppedEvent, AgentFailedEvent, AgentStatusChangedEvent, AgentTaskAssignedEvent, AgentTaskCompletedEvent, TaskCreatedEvent, TaskStartedEvent, TaskCompletedEvent, TaskFailedEvent, TaskBlockedEvent, TaskQueuedEvent, MemoryStoredEvent, MemoryRetrievedEvent, MemoryDeletedEvent, MemoryExpiredEvent, SwarmInitializedEvent, SwarmScaledEvent, SwarmTerminatedEvent, SwarmPhaseChangedEvent, SwarmMilestoneReachedEvent, SwarmErrorEvent, } from './domain-events.js';
+export { createAgentSpawnedEvent, createAgentStartedEvent, createAgentStoppedEvent, createAgentFailedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createTaskFailedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, createSwarmInitializedEvent, createSwarmScaledEvent, createSwarmTerminatedEvent, } from './domain-events.js';
+export { EventStore } from './event-store.js';
+export type { EventStoreConfig, EventFilter, EventSnapshot, EventStoreStats, } from './event-store.js';
+export { Projection, AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection, } from './projections.js';
+export type { AgentProjectionState, TaskProjectionState, MemoryProjectionState, } from './projections.js';
+export { RvfEventLog } from './rvf-event-log.js';
+export type { RvfEventLogConfig } from './rvf-event-log.js';
+export { StateReconstructor, createStateReconstructor, AgentAggregate, TaskAggregate, type AggregateRoot, type ReconstructorOptions, } from './state-reconstructor.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/shared/dist/events/index.js

@@ -0,0 +1,22 @@
+/**
+ * Event Sourcing System (ADR-007)
+ *
+ * Complete event sourcing implementation for V3 Claude Flow:
+ * - Domain events for all aggregates (agent, task, memory, swarm)
+ * - Persistent event store with SQLite backend
+ * - Projections for building read models
+ * - Event replay and snapshots
+ *
+ * @module v3/shared/events
+ */
+// Domain Event Factory Functions
+export { createAgentSpawnedEvent, createAgentStartedEvent, createAgentStoppedEvent, createAgentFailedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createTaskFailedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, createSwarmInitializedEvent, createSwarmScaledEvent, createSwarmTerminatedEvent, } from './domain-events.js';
+// Event Store
+export { EventStore } from './event-store.js';
+// Projections
+export { Projection, AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection, } from './projections.js';
+// RVF Event Log (ADR-057 — zero-dependency alternative to EventStore)
+export { RvfEventLog } from './rvf-event-log.js';
+// State Reconstruction (ADR-007)
+export { StateReconstructor, createStateReconstructor, AgentAggregate, TaskAggregate, } from './state-reconstructor.js';
+//# sourceMappingURL=index.js.map