claude-flow 3.62.0 → 3.63.1

package/v3/@claude-flow/cli/dist/src/services/managed-workflows.d.ts

@@ -0,0 +1,101 @@
+/** Provider event semantics for ADR-115 / dynamic workflows. No model calls. */
+export interface ManagedEvent {
+    id: string;
+    type: string;
+    processed_at?: string | null;
+    content?: Array<{
+        type: string;
+        text?: string;
+    }>;
+    name?: string;
+    input?: unknown;
+    stop_reason?: {
+        type: string;
+    };
+    workflow_run_id?: string | null;
+    session_thread_id?: string;
+    result?: {
+        type: string;
+    } | string;
+    [key: string]: unknown;
+}
+export interface EventPage {
+    data: ManagedEvent[];
+    next_page?: string | null;
+}
+/** Validate untrusted pages before deriving lifecycle claims. */
+export declare function eventPage(value: unknown): EventPage;
+/** Reads complete history, bounded and deduplicated. Cursor is opaque, never a URL. */
+export declare function readManagedEvents(read: (query: string) => Promise<unknown>, since?: string): Promise<ManagedEvent[]>;
+/** Incremental reducer. Provider completion is always unverified. */
+export declare class ManagedProgress {
+    private seen;
+    private text;
+    private tools;
+    private runs;
+    private failures;
+    private status;
+    private stopReason;
+    private cost;
+    private since;
+    private bytes;
+    private finished;
+    private interrupted;
+    accept(events: ManagedEvent[]): void;
+    watermark(): string | undefined;
+    snapshot(): {
+        assistantText: string;
+        toolUses: {
+            name: string;
+            input: unknown;
+        }[];
+        status: string;
+        stopReason: string | null;
+        eventCount: number;
+        workflowRuns: {
+            id: string;
+            status: string;
+            result?: string;
+        }[];
+        openRuns: number;
+        finished: boolean;
+        interrupted: boolean;
+        blocked: boolean;
+        observedFailures: number;
+        listCost: unknown;
+        verification: "unverified";
+        needsThreadInspection: boolean;
+    };
+}
+/** Build only the supported configuration; do not pass arbitrary multiagent JSON. */
+export declare function dynamicConfig(input: Record<string, unknown>): {
+    enabled: boolean;
+    budget: {
+        type: string;
+        max_list_cost: {
+            amount: string;
+            currency: string;
+        };
+    } | undefined;
+    multiagent: {
+        type: string;
+        subagents: {
+            type: string;
+        };
+        workflows: {
+            inline_agents?: {
+                type: string;
+            } | undefined;
+            predefined_agents?: any[] | undefined;
+            type: string;
+        };
+    } | undefined;
+    networking: {
+        type: string;
+        allowed_hosts: any[];
+    } | {
+        type: {};
+        allowed_hosts?: undefined;
+    };
+};
+//# sourceMappingURL=managed-workflows.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/managed-workflows.js

@@ -0,0 +1,183 @@
+/** Validate untrusted pages before deriving lifecycle claims. */
+export function eventPage(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Invalid Managed Agents event page');
+    const page = value;
+    if (!Array.isArray(page.data) || page.data.some(e => !e || typeof e.id !== 'string' || !e.id || typeof e.type !== 'string')) {
+        throw new Error('Invalid Managed Agents events');
+    }
+    for (const e of page.data) {
+        if (e.processed_at != null && (typeof e.processed_at !== 'string' || !Number.isFinite(Date.parse(e.processed_at))))
+            throw new Error('Invalid event timestamp');
+        if (e.type === 'agent.message' && e.content !== undefined && (!Array.isArray(e.content) || e.content.some(b => !b || typeof b.type !== 'string' || (b.text !== undefined && typeof b.text !== 'string'))))
+            throw new Error('Invalid event content');
+        if (e.stop_reason != null && typeof e.stop_reason.type !== 'string')
+            throw new Error('Invalid event stop reason');
+        if (e.type === 'workflow_run.status_ended' && (!e.result || typeof e.result !== 'object' || typeof e.result.type !== 'string'))
+            throw new Error('Invalid workflow result');
+        if (e.type.startsWith('workflow_run.') && e.type !== 'workflow_run.error' && (typeof e.workflow_run_id !== 'string' || !e.workflow_run_id))
+            throw new Error('Invalid workflow ID');
+        if (e.workflow_run_id != null && typeof e.workflow_run_id !== 'string')
+            throw new Error('Invalid workflow ID');
+    }
+    if (page.next_page != null && (typeof page.next_page !== 'string' || !page.next_page || page.next_page.length > 4096)) {
+        throw new Error('Invalid Managed Agents cursor');
+    }
+    return page;
+}
+/** Reads complete history, bounded and deduplicated. Cursor is opaque, never a URL. */
+export async function readManagedEvents(read, since) {
+    const events = new Map();
+    const cursors = new Set();
+    let bytes = 0;
+    let cursor;
+    for (let count = 0; count < 100; count++) {
+        const query = new URLSearchParams({ order: 'asc', limit: '100' });
+        if (cursor)
+            query.set('page', cursor);
+        if (since)
+            query.set('created_at[gte]', since);
+        const page = eventPage(await read(query.toString()));
+        bytes += Buffer.byteLength(JSON.stringify(page), 'utf8');
+        if (bytes > 16_000_000)
+            throw new Error('Managed Agents transcript limit exceeded');
+        for (const e of page.data)
+            events.set(e.id, e);
+        if (events.size > 10_000)
+            throw new Error('Managed Agents event limit exceeded');
+        if (!page.next_page)
+            return [...events.values()];
+        if (cursors.has(page.next_page))
+            throw new Error('Repeated Managed Agents cursor');
+        cursors.add(page.next_page);
+        cursor = page.next_page;
+    }
+    throw new Error('Managed Agents page limit exceeded');
+}
+/** Incremental reducer. Provider completion is always unverified. */
+export class ManagedProgress {
+    seen = new Set();
+    text = [];
+    tools = [];
+    runs = new Map();
+    failures = 0;
+    status = 'unknown';
+    stopReason = null;
+    cost = null;
+    since;
+    bytes = 0;
+    finished = false;
+    interrupted = false;
+    accept(events) {
+        for (const e of events) {
+            // Queued user messages may be returned again after processing.
+            if (!e.processed_at)
+                continue;
+            if (this.seen.has(e.id))
+                continue;
+            if (this.seen.size >= 10_000)
+                throw new Error('Managed Agents event limit exceeded');
+            this.bytes += Buffer.byteLength(JSON.stringify(e), 'utf8');
+            if (this.bytes > 16_000_000)
+                throw new Error('Managed Agents transcript limit exceeded');
+            this.seen.add(e.id);
+            if (!this.since || e.processed_at > this.since)
+                this.since = e.processed_at;
+            if (e.type === 'user.message') {
+                this.finished = false;
+                this.interrupted = false;
+            }
+            else if (e.type === 'user.interrupt') {
+                this.finished = false;
+                this.interrupted = true;
+            }
+            else if (e.type === 'agent.message' && Array.isArray(e.content)) {
+                this.text.push(e.content.filter(b => b?.type === 'text' && typeof b.text === 'string').map(b => b.text).join(''));
+            }
+            else if (e.type === 'agent.tool_use' || e.type === 'agent.mcp_tool_use') {
+                this.tools.push({ name: e.name ?? '?', input: e.input });
+            }
+            else if (e.type === 'session.status_running') {
+                this.status = 'running';
+                this.stopReason = null;
+                this.finished = false;
+            }
+            else if (e.type === 'session.status_idle') {
+                this.status = 'idle';
+                this.stopReason = e.stop_reason?.type ?? null;
+                this.finished = this.stopReason === 'end_turn' && !this.interrupted && [...this.runs.values()].every(r => r.status === 'ended');
+            }
+            else if (e.type === 'session.status_terminated') {
+                this.status = 'terminated';
+                this.finished = false;
+            }
+            else if (e.type === 'session.error' || e.type === 'session.status_error' || e.type === 'session.status_failed') {
+                this.failures++;
+            }
+            else if (e.type === 'session.usage') {
+                this.cost = e.usage && typeof e.usage === 'object' ? e.usage.list_cost ?? null : null;
+            }
+            if (e.type === 'workflow_run.error')
+                this.failures++;
+            if (e.workflow_run_id && e.type.startsWith('workflow_run.')) {
+                this.finished = false;
+                const run = this.runs.get(e.workflow_run_id) ?? { id: e.workflow_run_id, status: 'running' };
+                if (e.type === 'workflow_run.status_ended') {
+                    run.status = 'ended';
+                    run.result = typeof e.result === 'object' ? e.result.type : 'unknown';
+                    if (run.result !== 'completed')
+                        this.failures++;
+                }
+                else if (e.type === 'workflow_run.status_idle' && run.status !== 'ended')
+                    run.status = 'idle';
+                else if (e.type === 'workflow_run.status_running' && run.status !== 'ended')
+                    run.status = 'running';
+                this.runs.set(run.id, run);
+            }
+        }
+    }
+    watermark() { return this.since; }
+    snapshot() {
+        const workflowRuns = [...this.runs.values()].map(r => ({ ...r }));
+        const openRuns = workflowRuns.filter(r => r.status !== 'ended').length;
+        const blocked = this.status === 'idle' && ['budget_reached', 'requires_action'].includes(this.stopReason ?? '');
+        return {
+            assistantText: this.text.join(''), toolUses: [...this.tools], status: this.status,
+            stopReason: this.stopReason, eventCount: this.seen.size, workflowRuns, openRuns,
+            finished: this.finished, interrupted: this.interrupted, blocked, observedFailures: this.failures, listCost: this.cost,
+            verification: 'unverified',
+            needsThreadInspection: workflowRuns.length > 0,
+        };
+    }
+}
+/** Build only the supported configuration; do not pass arbitrary multiagent JSON. */
+export function dynamicConfig(input) {
+    if (input.dynamicWorkflows !== undefined && typeof input.dynamicWorkflows !== 'boolean')
+        throw new Error('dynamicWorkflows must be boolean');
+    const enabled = input.dynamicWorkflows === true;
+    if (input.budgetCents !== undefined || enabled) {
+        if (typeof input.budgetCents !== 'string' || !/^[1-9][0-9]{0,8}$/.test(input.budgetCents)) {
+            throw new Error('budgetCents must be a positive integer cents string (maximum 999999999)');
+        }
+    }
+    if (enabled && input.networking !== undefined && input.networking !== 'limited')
+        throw new Error('Dynamic workflows require limited networking');
+    const hosts = input.allowedHosts ?? [];
+    if (!Array.isArray(hosts) || hosts.length > 100 || hosts.some(h => typeof h !== 'string' || h.length > 253 || !/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/i.test(h))) {
+        throw new Error('allowedHosts must contain at most 100 exact hostnames');
+    }
+    const agents = input.predefinedAgents;
+    if (agents !== undefined && (!Array.isArray(agents) || agents.length < 1 || agents.length > 20 || agents.some(a => typeof a !== 'string' || !/^agent_[A-Za-z0-9]+$/.test(a)))) {
+        throw new Error('predefinedAgents must contain 1 to 20 agent IDs');
+    }
+    return {
+        enabled,
+        budget: input.budgetCents === undefined ? undefined : { type: 'limit', max_list_cost: { amount: input.budgetCents, currency: 'USD' } },
+        multiagent: enabled ? {
+            type: 'multiagent_20261001', subagents: { type: 'disabled' },
+            workflows: { type: 'enabled', ...(agents ? { inline_agents: { type: 'disabled' }, predefined_agents: agents } : {}) },
+        } : undefined,
+        networking: enabled || input.networking === 'limited' ? { type: 'limited', allowed_hosts: hosts } : { type: input.networking ?? 'unrestricted' },
+    };
+}
+//# sourceMappingURL=managed-workflows.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.62.0",
+  "version": "3.63.1",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",

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

@@ -0,0 +1,8 @@
+/**
+ * Event Store Tests
+ *
+ * Comprehensive tests for the event sourcing implementation.
+ * Tests event storage, retrieval, filtering, snapshots, and projections.
+ */
+export {};
+//# sourceMappingURL=event-store.test.d.ts.map

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/hooks/hooks.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * V3 Hooks System - Tests
+ *
+ * Comprehensive tests for hook registry and executor.
+ *
+ * @module v3/shared/hooks/hooks.test
+ */
+export {};
+//# sourceMappingURL=hooks.test.d.ts.map