┌─────────────────────────────────────────────────────────────┐
│                      Event Store                            │
│  ┌───────────────────────────────────────────────────────┐  │
│  │  SQLite Database (sql.js for cross-platform)          │  │
│  │  - events table (append-only log)                     │  │
│  │  - snapshots table (performance optimization)         │  │
│  └───────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘
           │                    │                    │
           ▼                    ▼                    ▼
    ┌──────────────┐   ┌──────────────┐   ┌──────────────┐
    │   Agent      │   │    Task      │   │   Memory     │
    │ Projection   │   │  Projection  │   │ Projection   │
    └──────────────┘   └──────────────┘   └──────────────┘

import { EventStore, createAgentSpawnedEvent } from '@claude-flow/shared/events';

// Initialize
const eventStore = new EventStore({
  databasePath: './events.db',
  verbose: true,
});
await eventStore.initialize();

// Record events
const event = createAgentSpawnedEvent(
  'agent-1',
  'coder',
  'core',
  ['coding', 'testing']
);
await eventStore.append(event);

// Query events
const agentEvents = await eventStore.getEvents('agent-1');
const allTaskEvents = await eventStore.query({
  aggregateTypes: ['task']
});

// Cleanup
await eventStore.shutdown();

import {
  EventStore,
  AgentStateProjection,
  TaskHistoryProjection
} from '@claude-flow/shared/events';

const eventStore = new EventStore({ databasePath: './events.db' });
await eventStore.initialize();

// Build agent state projection
const agentProjection = new AgentStateProjection(eventStore);
await agentProjection.initialize();

// Query agent state
const activeAgents = agentProjection.getAgentsByStatus('active');
const agent1 = agentProjection.getAgent('agent-1');

console.log(`Active agents: ${activeAgents.length}`);
console.log(`Agent 1 completed ${agent1.completedTasks.length} tasks`);

// Build task history projection
const taskProjection = new TaskHistoryProjection(eventStore);
await taskProjection.initialize();

// Query task history
const completedTasks = taskProjection.getTasksByStatus('completed');
const avgDuration = taskProjection.getAverageTaskDuration();

console.log(`Completed: ${completedTasks.length} tasks`);
console.log(`Average duration: ${avgDuration}ms`);

// Replay all events
for await (const event of eventStore.replay()) {
  console.log(`${event.type} at ${new Date(event.timestamp)}`);
}

// Replay from specific version
for await (const event of eventStore.replay(100)) {
  // Process events starting from version 100
}

// Save snapshot for performance
await eventStore.saveSnapshot({
  aggregateId: 'agent-1',
  aggregateType: 'agent',
  version: 500,
  state: { status: 'active', tasks: ['task-1', 'task-2'] },
  timestamp: Date.now(),
});

// Load snapshot
const snapshot = await eventStore.getSnapshot('agent-1');
if (snapshot) {
  // Resume from snapshot version
  const events = await eventStore.getEvents('agent-1', snapshot.version);
}

const eventStore = new EventStore({
  // Database path (:memory: for in-memory only)
  databasePath: './v3-events.db',

  // Enable verbose logging
  verbose: true,

  // Auto-persist interval (0 = manual only)
  autoPersistInterval: 5000, // 5 seconds

  // Recommend snapshots every N events
  snapshotThreshold: 100,

  // Custom sql.js WASM path (optional)
  wasmPath: './sql-wasm.wasm',
});

# Run all event store tests
npm test -- event-store.test.ts

# Run specific test suite
npm test -- event-store.test.ts -t "Event Appending"

npx tsx v3/@claude-flow/shared/src/events/example-usage.ts

// Queen coordinator spawns agents
await eventStore.append(
  createAgentSpawnedEvent('agent-2', 'security-architect', 'security', ['auditing'])
);

// Track agent execution
await eventStore.append(createAgentStartedEvent('agent-2'));
await eventStore.append(createAgentTaskAssignedEvent('agent-2', 'task-1', Date.now()));

// Create task
await eventStore.append(
  createTaskCreatedEvent('task-1', 'security-audit', 'CVE-1 Fix', 'Fix injection', 'critical', [])
);

// Track progress
await eventStore.append(createTaskStartedEvent('task-1', 'agent-2'));
await eventStore.append(createTaskCompletedEvent('task-1', { fixed: true }, 5000));

// Track memory usage
await eventStore.append(
  createMemoryStoredEvent('mem-1', 'agent-context', 'agent-2-state', 'episodic', 2048)
);

await eventStore.append(
  createMemoryRetrievedEvent('mem-1', 'agent-context', 'agent-2-state', 1)
);