@gotza02/seq-thinking 1.1.4 → 1.1.6

package/src/__tests__/swarm-coordinator.test.ts

@@ -1,903 +0,0 @@
-/**
- * Swarm Coordinator Test Suite
- * Tests for AgentRegistry, MessageBroker, TaskQueueManager, TaskAssigner,
- * ConsensusEngine, ConflictResolver, and SwarmCoordinator
- */
-import { test, describe, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import {
-  AgentRegistry,
-  MessageBroker,
-  TaskQueueManager,
-  TaskAssigner,
-  ConsensusEngine,
-  ConflictResolver,
-  SwarmCoordinator,
-} from '../swarm-coordinator.js';
-import {
-  AgentType,
-  MessageType,
-  ConsensusAlgorithm,
-  ConflictResolutionStrategy,
-  AgentStatus,
-  TaskStatus,
-  ConflictStatus,
-  type AgentConfig,
-  type AgentCapability,
-  type Task,
-  type TaskResult,
-} from '../types/index.js';
-import { BaseAgent } from '../agents/base-agent.js';
-
-class MockAgent extends BaseAgent {
-  async process(task: Task): Promise<TaskResult> {
-    return this.createTaskResult(task.id, { processed: true }, 0.9, 100);
-  }
-  
-  getType(): string {
-    return this.config.type;
-  }
-  
-  getCapabilities(): AgentCapability[] {
-    return this.config.capabilities;
-  }
-}
-
-describe('AgentRegistry', () => {
-  let registry: AgentRegistry;
-
-  beforeEach(() => {
-    registry = new AgentRegistry();
-  });
-
-  test('should register an agent', async () => {
-    const config = createMockAgentConfig();
-    const agent = await registry.registerAgent(config);
-
-    assert.ok(agent);
-    assert.ok(agent.config.id);
-    assert.strictEqual(agent.config.name, config.name);
-    assert.strictEqual(agent.config.type, config.type);
-    assert.strictEqual(agent.status, AgentStatus.IDLE);
-  });
-
-  test('should unregister an agent', async () => {
-    const config = createMockAgentConfig();
-    const agent = await registry.registerAgent(config);
-
-    const result = await registry.unregisterAgent(agent.config.id);
-
-    assert.strictEqual(result, true);
-    assert.strictEqual(registry.getAgent(agent.config.id), undefined);
-  });
-
-  test('should return false when unregistering non-existent agent', async () => {
-    const result = await registry.unregisterAgent('non-existent-id');
-    assert.strictEqual(result, false);
-  });
-
-  test('should get agent by id', async () => {
-    const config = createMockAgentConfig();
-    const registered = await registry.registerAgent(config);
-
-    const retrieved = registry.getAgent(registered.config.id);
-
-    assert.ok(retrieved);
-    assert.strictEqual(retrieved!.config.id, registered.config.id);
-  });
-
-  test('should get agents by type', async () => {
-    const reasonerConfig1 = createMockAgentConfig({ type: AgentType.REASONER });
-    const reasonerConfig2 = createMockAgentConfig({ type: AgentType.REASONER });
-    const criticConfig = createMockAgentConfig({ type: AgentType.CRITIC });
-
-    await registry.registerAgent(reasonerConfig1);
-    await registry.registerAgent(criticConfig);
-    await registry.registerAgent(reasonerConfig2);
-
-    const reasoners = registry.getAgentsByType(AgentType.REASONER);
-    const critics = registry.getAgentsByType(AgentType.CRITIC);
-
-    assert.strictEqual(reasoners.length, 2);
-    assert.strictEqual(critics.length, 1);
-  });
-
-  test('should get agents by capability', async () => {
-    const config1 = createMockAgentConfig({
-      capabilities: [createMockCapability('reasoning')],
-    });
-    const config2 = createMockAgentConfig({
-      capabilities: [createMockCapability('analysis')],
-    });
-
-    const agent1 = await registry.registerAgent(config1);
-    await registry.registerAgent(config2);
-
-    const reasoningAgents = registry.getAgentsByCapability('reasoning');
-
-    assert.strictEqual(reasoningAgents.length, 1);
-    assert.strictEqual(reasoningAgents[0].config.id, agent1.config.id);
-  });
-
-  test('should get all agents', async () => {
-    await registry.registerAgent(createMockAgentConfig());
-    await registry.registerAgent(createMockAgentConfig());
-    await registry.registerAgent(createMockAgentConfig());
-
-    const allAgents = registry.getAllAgents();
-
-    assert.strictEqual(allAgents.length, 3);
-  });
-
-  test('should get available agents', async () => {
-    const config1 = createMockAgentConfig();
-    const config2 = createMockAgentConfig();
-
-    const agent1 = await registry.registerAgent(config1);
-    const agent2 = await registry.registerAgent(config2);
-
-    registry.updateAgentStatus(agent1.config.id, AgentStatus.BUSY);
-
-    const available = registry.getAvailableAgents();
-
-    assert.strictEqual(available.length, 1);
-    assert.strictEqual(available[0].config.id, agent2.config.id);
-  });
-
-  test('should update agent status', async () => {
-    const config = createMockAgentConfig();
-    const agent = await registry.registerAgent(config);
-
-    registry.updateAgentStatus(agent.config.id, AgentStatus.BUSY);
-
-    const updated = registry.getAgent(agent.config.id);
-    assert.strictEqual(updated!.status, 'busy');
-  });
-
-  test('should record agent performance', async () => {
-    const config = createMockAgentConfig();
-    const agent = await registry.registerAgent(config);
-
-    registry.recordPerformance(agent.config.id, 'task-001', 0.9, 1000);
-
-    const updated = registry.getAgent(agent.config.id);
-    assert.strictEqual(updated!.performanceHistory.length, 1);
-    assert.strictEqual(updated!.performanceHistory[0].taskId, 'task-001');
-    assert.strictEqual(updated!.performanceHistory[0].quality, 0.9);
-    assert.strictEqual(updated!.performanceHistory[0].timeMs, 1000);
-  });
-
-  test('should handle multiple performance records', async () => {
-    const config = createMockAgentConfig();
-    const agent = await registry.registerAgent(config);
-
-    registry.recordPerformance(agent.config.id, 'task-001', 0.8, 500);
-    registry.recordPerformance(agent.config.id, 'task-002', 0.9, 600);
-    registry.recordPerformance(agent.config.id, 'task-003', 0.85, 550);
-
-    const updated = registry.getAgent(agent.config.id);
-    assert.strictEqual(updated!.performanceHistory.length, 3);
-  });
-});
-
-describe('MessageBroker', () => {
-  let broker: MessageBroker;
-
-  beforeEach(() => {
-    broker = new MessageBroker();
-  });
-
-  test('should send message', () => {
-    const message = broker.sendMessage({
-      type: MessageType.TASK_ASSIGNMENT,
-      senderId: 'agent-001',
-      recipientId: 'agent-002',
-      payload: { taskId: 'task-001' },
-      context: {},
-      metadata: {
-        priority: 1,
-        ttl: 30000,
-        retryCount: 0,
-      },
-    });
-
-    assert.ok(message.id);
-    assert.ok(message.timestamp);
-    assert.strictEqual(message.type, MessageType.TASK_ASSIGNMENT);
-  });
-
-  test('should broadcast message', () => {
-    const message = broker.sendMessage({
-      type: MessageType.BROADCAST,
-      senderId: 'agent-001',
-      recipientId: null,
-      payload: { announcement: 'Hello' },
-      context: {},
-      metadata: {
-        priority: 0,
-        ttl: 60000,
-        retryCount: 0,
-      },
-    });
-
-    // Should not throw
-    broker.broadcast(message);
-    assert.ok(message);
-  });
-
-  test('should deliver to recipient', () => {
-    const message = broker.sendMessage({
-      type: MessageType.DIRECT,
-      senderId: 'agent-001',
-      recipientId: 'agent-002',
-      payload: { data: 'test' },
-      context: {},
-      metadata: {
-        priority: 1,
-        ttl: 30000,
-        retryCount: 0,
-      },
-    });
-
-    // Should not throw
-    broker.deliverToRecipient(message);
-    assert.ok(message);
-  });
-
-  test('should subscribe to messages', () => {
-    const messages: unknown[] = [];
-    const unsubscribe = broker.subscribe('agent-001', (msg) => {
-      messages.push(msg);
-    });
-
-    assert.ok(typeof unsubscribe === 'function');
-
-    broker.sendMessage({
-      type: MessageType.BROADCAST,
-      senderId: 'agent-002',
-      recipientId: null,
-      payload: {},
-      context: {},
-      metadata: { priority: 0, ttl: 30000, retryCount: 0 },
-    });
-
-    // Cleanup
-    unsubscribe();
-  });
-
-  test('should unsubscribe from messages', () => {
-    const messages: unknown[] = [];
-    const unsubscribe = broker.subscribe('agent-001', (msg) => {
-      messages.push(msg);
-    });
-
-    unsubscribe();
-
-    // After unsubscribe, should not receive messages
-    // This is implementation-dependent, but unsubscribe should work
-    assert.ok(true);
-  });
-});
-
-describe('TaskQueueManager', () => {
-  let manager: TaskQueueManager;
-
-  beforeEach(() => {
-    manager = new TaskQueueManager();
-  });
-
-  test('should create task', () => {
-    const task = manager.createTask(
-      'reasoning',
-      'Perform reasoning',
-      { problem: 'Solve X' },
-      { requiredCapabilities: ['reasoning'], minConfidence: 0.7, maxTimeMs: 5000 }
-    );
-
-    assert.ok(task.id);
-    assert.strictEqual(task.type, 'reasoning');
-    assert.strictEqual(task.status, TaskStatus.PENDING);
-    assert.strictEqual(task.assignedAgentId, null);
-  });
-
-  test('should assign task to agent', () => {
-    const task = manager.createTask(
-      'analysis',
-      'Analyze data',
-      { data: [] },
-      { requiredCapabilities: ['analysis'], minConfidence: 0.8, maxTimeMs: 10000 }
-    );
-
-    const assigned = manager.assignTask(task.id, 'agent-001');
-
-    assert.ok(assigned);
-    assert.strictEqual(assigned!.assignedAgentId, 'agent-001');
-    assert.strictEqual(assigned!.status, TaskStatus.ASSIGNED);
-  });
-
-  test('should return null when assigning non-existent task', () => {
-    const result = manager.assignTask('non-existent-id', 'agent-001');
-    assert.strictEqual(result, null);
-  });
-
-  test('should start task', () => {
-    const task = manager.createTask(
-      'processing',
-      'Process data',
-      {},
-      { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 }
-    );
-    manager.assignTask(task.id, 'agent-001');
-
-    const started = manager.startTask(task.id);
-
-    assert.ok(started);
-    assert.strictEqual(started!.status, TaskStatus.IN_PROGRESS);
-  });
-
-  test('should complete task', () => {
-    const task = manager.createTask(
-      'computation',
-      'Compute result',
-      {},
-      { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 }
-    );
-    manager.assignTask(task.id, 'agent-001');
-    manager.startTask(task.id);
-
-    const result: TaskResult = {
-      taskId: task.id,
-      agentId: 'agent-001',
-      success: true,
-      output: { result: 42 },
-      confidence: 0.9,
-      processingTimeMs: 1000,
-      metadata: {
-        tokensUsed: 50,
-        reasoningSteps: 5,
-        intermediateResults: [],
-      },
-    };
-
-    manager.completeTask(task.id, result);
-
-    const completed = manager.getTask(task.id);
-    assert.strictEqual(completed!.status, 'completed');
-    assert.strictEqual(completed!.result, result);
-  });
-
-  test('should fail task', () => {
-    const task = manager.createTask(
-      'risky-task',
-      'Task that might fail',
-      {},
-      { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 }
-    );
-    manager.assignTask(task.id, 'agent-001');
-    manager.startTask(task.id);
-
-    manager.failTask(task.id, 'Timeout error');
-
-    const failed = manager.getTask(task.id);
-    assert.strictEqual(failed!.status, 'failed');
-  });
-
-  test('should get tasks by status', () => {
-    const task1 = manager.createTask('type1', 'Task 1', {}, { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 });
-    const task2 = manager.createTask('type2', 'Task 2', {}, { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 });
-    const task3 = manager.createTask('type3', 'Task 3', {}, { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 });
-
-    manager.assignTask(task2.id, 'agent-001');
-    manager.assignTask(task3.id, 'agent-002');
-    manager.startTask(task3.id);
-
-    const pending = manager.getTasksByStatus(TaskStatus.PENDING);
-    const assigned = manager.getTasksByStatus(TaskStatus.ASSIGNED);
-    const inProgress = manager.getTasksByStatus(TaskStatus.IN_PROGRESS);
-
-    assert.strictEqual(pending.length, 1);
-    assert.strictEqual(assigned.length, 1);
-    assert.strictEqual(inProgress.length, 1);
-  });
-
-  test('should get pending tasks', () => {
-    manager.createTask('type1', 'Task 1', {}, { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 });
-    manager.createTask('type2', 'Task 2', {}, { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 });
-
-    const pending = manager.getPendingTasks();
-    assert.strictEqual(pending.length, 2);
-  });
-
-  test('should get in progress tasks', () => {
-    const task = manager.createTask('type', 'Task', {}, { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 });
-    manager.assignTask(task.id, 'agent-001');
-    manager.startTask(task.id);
-
-    const inProgress = manager.getInProgressTasks();
-    assert.strictEqual(inProgress.length, 1);
-  });
-
-  test('should get completed tasks', () => {
-    const task = manager.createTask('type', 'Task', {}, { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 });
-    manager.assignTask(task.id, 'agent-001');
-    manager.startTask(task.id);
-    manager.completeTask(task.id, createMockTaskResult(task.id, 'agent-001'));
-
-    const completed = manager.getCompletedTasks();
-    assert.strictEqual(completed.length, 1);
-  });
-});
-
-describe('TaskAssigner', () => {
-  let registry: AgentRegistry;
-  let assigner: TaskAssigner;
-
-  beforeEach(() => {
-    registry = new AgentRegistry();
-    assigner = new TaskAssigner(registry);
-  });
-
-  test('should assign task using round robin', async () => {
-    await registry.registerAgent(createMockAgentConfig());
-    await registry.registerAgent(createMockAgentConfig());
-
-    const task = createMockTask();
-
-    const agent1 = assigner.assignTask(task, 'round_robin');
-    const agent2 = assigner.assignTask(task, 'round_robin');
-
-    assert.ok(agent1);
-    assert.ok(agent2);
-    assert.notStrictEqual(agent1!.config.id, agent2!.config.id);
-  });
-
-  test('should assign task using capability based strategy', async () => {
-    await registry.registerAgent(createMockAgentConfig({
-      capabilities: [createMockCapability('required-skill')],
-    }));
-    await registry.registerAgent(createMockAgentConfig({
-      capabilities: [createMockCapability('other-skill')],
-    }));
-
-    const task = createMockTask({ requiredCapabilities: ['required-skill'] });
-
-    const agent = assigner.assignTask(task, 'capability_based');
-
-    assert.ok(agent);
-    assert.ok(agent!.config.capabilities.some((c: AgentCapability) => c.name === 'required-skill'));
-  });
-
-  test('should assign task using load balanced strategy', async () => {
-    const agent1 = await registry.registerAgent(createMockAgentConfig());
-    const agent2 = await registry.registerAgent(createMockAgentConfig());
-
-    registry.updateAgentStatus(agent1.config.id, AgentStatus.BUSY);
-
-    const task = createMockTask();
-    const assigned = assigner.assignTask(task, 'load_balanced');
-
-    assert.ok(assigned);
-    assert.strictEqual(assigned!.config.id, agent2.config.id);
-  });
-
-  test('should return null when no suitable agent', () => {
-    const task = createMockTask({ requiredCapabilities: ['non-existent-capability'] });
-
-    const agent = assigner.assignTask(task, 'capability_based');
-
-    assert.strictEqual(agent, null);
-  });
-
-  test('should handle empty registry', () => {
-    const task = createMockTask();
-    const agent = assigner.assignTask(task, 'round_robin');
-    assert.strictEqual(agent, null);
-  });
-});
-
-describe('ConsensusEngine', () => {
-  let engine: ConsensusEngine;
-
-  beforeEach(() => {
-    engine = new ConsensusEngine();
-  });
-
-  test('should reach consensus with majority vote', async () => {
-    const result = await engine.reachConsensus(
-      'prop-001',
-      ConsensusAlgorithm.MAJORITY_VOTE,
-      [
-        { agentId: 'a1', proposalId: 'p1', vote: 'yes', confidence: 1.0, reasoning: '', timestamp: new Date() },
-        { agentId: 'a2', proposalId: 'p1', vote: 'yes', confidence: 1.0, reasoning: '', timestamp: new Date() },
-        { agentId: 'a3', proposalId: 'p1', vote: 'no', confidence: 1.0, reasoning: '', timestamp: new Date() }
-      ],
-      0.5,
-      1
-    );
-
-    assert.ok(result);
-    assert.ok(result.proposalId);
-    assert.ok(result.winningOption);
-    assert.ok(typeof result.confidence === 'number');
-    assert.ok(Array.isArray(result.votes));
-    assert.ok(typeof result.agreementRatio === 'number');
-  });
-
-  test('should reach consensus with weighted vote', async () => {
-    const result = await engine.reachConsensus(
-      'prop-002',
-      ConsensusAlgorithm.WEIGHTED_VOTE,
-      [
-        { agentId: 'a1', proposalId: 'p2', vote: 'yes', confidence: 0.9, reasoning: '', timestamp: new Date() },
-        { agentId: 'a2', proposalId: 'p2', vote: 'no', confidence: 0.4, reasoning: '', timestamp: new Date() }
-      ],
-      0.6,
-      1
-    );
-
-    assert.ok(result);
-    assert.strictEqual(result.algorithm, ConsensusAlgorithm.WEIGHTED_VOTE);
-  });
-
-  test('should handle empty agent list', async () => {
-    const result = await engine.reachConsensus(
-      'prop-003',
-      ConsensusAlgorithm.MAJORITY_VOTE,
-      [],
-      0.5,
-      1
-    );
-
-    assert.ok(result);
-  });
-
-  test('should handle single agent', async () => {
-    const result = await engine.reachConsensus(
-      'prop-004',
-      ConsensusAlgorithm.MAJORITY_VOTE,
-      [{ agentId: 'a1', proposalId: 'p4', vote: 'a', confidence: 1.0, reasoning: '', timestamp: new Date() }],
-      0.5,
-      1
-    );
-
-    assert.ok(result);
-    assert.strictEqual(result.agreementRatio, 1);
-  });
-
-  test('should include dissenting opinions', async () => {
-    const result = await engine.reachConsensus(
-      'prop-005',
-      ConsensusAlgorithm.MAJORITY_VOTE,
-      [
-        { agentId: 'a1', proposalId: 'p5', vote: 'a', confidence: 1.0, reasoning: '', timestamp: new Date() },
-        { agentId: 'a2', proposalId: 'p5', vote: 'b', confidence: 1.0, reasoning: 'disagree', timestamp: new Date() }
-      ],
-      0.5,
-      1
-    );
-
-    assert.ok(Array.isArray(result.dissentingOpinions));
-  });
-});
-
-describe('ConflictResolver', () => {
-  let resolver: ConflictResolver;
-
-  beforeEach(() => {
-    resolver = new ConflictResolver();
-  });
-
-  test('should identify conflict', () => {
-    const conflict = resolver.identifyConflict(
-      'disagreement',
-      'Agents disagree on approach',
-      [
-        { agentId: 'agent-001', position: 'approach-a', evidence: ['evidence-1'], confidence: 0.8 },
-        { agentId: 'agent-002', position: 'approach-b', evidence: ['evidence-2'], confidence: 0.75 },
-      ]
-    );
-
-    assert.ok(conflict.id);
-    assert.strictEqual(conflict.type, 'disagreement');
-    assert.strictEqual(conflict.status, ConflictStatus.DETECTED);
-    assert.strictEqual(conflict.involvedAgents.length, 2);
-  });
-
-  test('should resolve conflict with voting', () => {
-    const conflict = resolver.identifyConflict(
-      'resource-contention',
-      'Resource dispute',
-      [
-        { agentId: 'agent-001', position: 'claim-a', evidence: [], confidence: 0.7 },
-        { agentId: 'agent-002', position: 'claim-b', evidence: [], confidence: 0.6 },
-      ]
-    );
-
-    const { conflict: resolved, resolution } = resolver.resolveConflict(
-      conflict.id,
-      ConflictResolutionStrategy.VOTING,
-      'test-resolver'
-    );
-
-    assert.strictEqual(resolved.status, ConflictStatus.RESOLVED);
-    assert.ok(resolution);
-    assert.ok(resolved.metadata.resolvedAt);
-    assert.strictEqual(resolved.metadata.resolutionStrategy, ConflictResolutionStrategy.VOTING);
-  });
-
-  test('should resolve conflict with compromise', () => {
-    const conflict = resolver.identifyConflict(
-      'priority-dispute',
-      'Task priority disagreement',
-      [
-        { agentId: 'agent-001', position: 'high-priority', evidence: [], confidence: 0.9 },
-        { agentId: 'agent-002', position: 'low-priority', evidence: [], confidence: 0.8 },
-      ]
-    );
-
-    const { conflict: resolved } = resolver.resolveConflict(
-      conflict.id,
-      ConflictResolutionStrategy.COMPROMISE,
-      'test-resolver'
-    );
-
-    assert.strictEqual(resolved.status, ConflictStatus.RESOLVED);
-  });
-
-  test('should get conflict by id', () => {
-    const conflict = resolver.identifyConflict('test', 'Test conflict', []);
-
-    const retrieved = resolver.getConflict(conflict.id);
-
-    assert.ok(retrieved);
-    assert.strictEqual(retrieved!.id, conflict.id);
-  });
-
-  test('should get all conflicts', () => {
-    resolver.identifyConflict('type1', 'Conflict 1', []);
-    resolver.identifyConflict('type2', 'Conflict 2', []);
-    resolver.identifyConflict('type3', 'Conflict 3', []);
-
-    const allConflicts = resolver.getAllConflicts();
-
-    assert.strictEqual(allConflicts.length, 3);
-  });
-
-  test('should handle resolving non-existent conflict', () => {
-    assert.throws(() => {
-      resolver.resolveConflict('non-existent-id', ConflictResolutionStrategy.VOTING, 'test-resolver');
-    });
-  });
-});
-
-describe('SwarmCoordinator', () => {
-  let coordinator: SwarmCoordinator;
-
-  beforeEach(() => {
-    coordinator = new SwarmCoordinator();
-  });
-
-  test('should register agent', async () => {
-    const config = createMockAgentConfig();
-    const agent = await coordinator.registerAgent(config);
-
-    assert.ok(agent);
-    assert.strictEqual(agent.config.name, config.name);
-  });
-
-  test('should get all agents', async () => {
-    await coordinator.registerAgent(createMockAgentConfig());
-    await coordinator.registerAgent(createMockAgentConfig());
-
-    const agents = coordinator.getAllAgents();
-
-    assert.strictEqual(agents.length, 2);
-  });
-
-  test('should unregister agent', async () => {
-    const agent = await coordinator.registerAgent(createMockAgentConfig());
-
-    const result = await coordinator.unregisterAgent(agent.config.id);
-
-    assert.strictEqual(result, true);
-    assert.strictEqual(coordinator.getAllAgents().length, 0);
-  });
-
-  test('should submit task', async () => {
-    await coordinator.registerAgent(createMockAgentConfig());
-
-    const { task, assignedAgent } = coordinator.submitTask(
-      'reasoning',
-      'Perform reasoning',
-      { problem: 'Solve X' },
-      { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 }
-    );
-
-    assert.ok(task);
-    assert.ok(task.id);
-  });
-
-  test('should execute task', async () => {
-    const config = createMockAgentConfig();
-    const agent = new MockAgent(config);
-    await coordinator.registerAgent(agent);
-
-    const { task } = coordinator.submitTask(
-      'computation',
-      'Compute something',
-      { input: 5 },
-      { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 }
-    );
-
-    const result = await coordinator.executeTask(task.id);
-
-    assert.ok(result);
-    assert.strictEqual(result.taskId, task.id);
-    assert.strictEqual(result.success, true);
-  });
-
-  test('should reach consensus', async () => {
-    const config1 = createMockAgentConfig();
-    const config2 = createMockAgentConfig();
-    await coordinator.registerAgent(new MockAgent(config1));
-    await coordinator.registerAgent(new MockAgent(config2));
-
-    const result = await coordinator.reachConsensus(
-      'Decision?',
-      ['option-a', 'option-b'],
-      ConsensusAlgorithm.MAJORITY_VOTE
-    );
-
-    assert.ok(result);
-    assert.ok(result.winningOption);
-  });
-
-  test('should identify conflict', () => {
-    const conflict = coordinator.identifyConflict(
-      'disagreement',
-      'Test conflict',
-      [
-        { agentId: 'agent-001', position: 'a', evidence: [], confidence: 0.8 },
-        { agentId: 'agent-002', position: 'b', evidence: [], confidence: 0.7 },
-      ]
-    );
-
-    assert.ok(conflict);
-    assert.strictEqual(conflict.type, 'disagreement');
-  });
-
-  test('should resolve conflict', () => {
-    const conflict = coordinator.identifyConflict(
-      'test-conflict',
-      'Test',
-      [{ agentId: 'agent-001', position: 'x', evidence: [], confidence: 0.5 }]
-    );
-
-    const { conflict: resolved, resolution } = coordinator.resolveConflict(
-      conflict.id,
-      ConflictResolutionStrategy.VOTING,
-      'test-resolver'
-    );
-
-    assert.strictEqual(resolved.status, ConflictStatus.RESOLVED);
-  });
-
-  test('should broadcast message', () => {
-    const message = coordinator.broadcastMessage('agent-001', { announcement: 'Hello' });
-
-    assert.ok(message);
-    assert.strictEqual(message.type, MessageType.BROADCAST);
-  });
-
-  test('should send direct message', () => {
-    const message = coordinator.sendDirectMessage('agent-001', 'agent-002', { data: 'test' });
-
-    assert.ok(message);
-    assert.strictEqual(message.type, MessageType.DIRECT);
-    assert.strictEqual(message.recipientId, 'agent-002');
-  });
-
-  test('should get swarm stats', async () => {
-    await coordinator.registerAgent(createMockAgentConfig());
-    await coordinator.registerAgent(createMockAgentConfig());
-
-    const stats = coordinator.getSwarmStats();
-
-    assert.ok(typeof stats.totalAgents === 'number');
-    assert.ok(typeof stats.availableAgents === 'number');
-    assert.ok(typeof stats.busyAgents === 'number');
-    assert.ok(typeof stats.pendingTasks === 'number');
-    assert.ok(typeof stats.inProgressTasks === 'number');
-    assert.ok(typeof stats.completedTasks === 'number');
-    assert.ok(typeof stats.activeConflicts === 'number');
-
-    assert.strictEqual(stats.totalAgents, 2);
-  });
-
-  test('should track task lifecycle', async () => {
-    const config = createMockAgentConfig();
-    await coordinator.registerAgent(new MockAgent(config));
-
-    const { task } = coordinator.submitTask(
-      'test-task',
-      'Test task',
-      {},
-      { requiredCapabilities: [], minConfidence: 0.5, maxTimeMs: 5000 }
-    );
-
-    const initialStats = coordinator.getSwarmStats();
-
-    await coordinator.executeTask(task.id);
-
-    const finalStats = coordinator.getSwarmStats();
-
-    assert.ok(finalStats.completedTasks > initialStats.completedTasks || finalStats.completedTasks === 1);
-  });
-});
-
-// Helper functions
-function createMockAgentConfig(overrides: Partial<AgentConfig> = {}): AgentConfig {
-  return {
-    id: `agent-${Math.random().toString(36).substring(2, 9)}`,
-    name: 'Test Agent',
-    type: AgentType.REASONER,
-    capabilities: [],
-    maxConcurrentTasks: 3,
-    confidenceThreshold: 0.7,
-    metadata: {
-      createdAt: new Date(),
-      version: '1.0.0',
-      config: {},
-    },
-    ...overrides,
-  };
-}
-
-function createMockCapability(name: string): AgentCapability {
-  return {
-    name,
-    description: `Capability: ${name}`,
-    confidence: 0.8,
-    performanceMetrics: {
-      tasksCompleted: 10,
-      averageQuality: 0.85,
-      averageTimeMs: 1000,
-    },
-  };
-}
-
-function createMockTask(overrides: Partial<Task['requirements']> = {}): Task {
-  return {
-    id: `task-${Math.random().toString(36).substring(2, 9)}`,
-    type: 'test',
-    description: 'Test task',
-    input: {},
-    context: { dependencies: [] },
-    requirements: {
-      requiredCapabilities: [],
-      minConfidence: 0.5,
-      maxTimeMs: 5000,
-      ...overrides,
-    },
-    assignedAgentId: null,
-    status: TaskStatus.PENDING,
-    result: null,
-    metadata: { createdAt: new Date() },
-  };
-}
-
-function createMockTaskResult(taskId: string, agentId: string): TaskResult {
-  return {
-    taskId,
-    agentId,
-    success: true,
-    output: {},
-    confidence: 0.9,
-    processingTimeMs: 1000,
-    metadata: {
-      tokensUsed: 50,
-      reasoningSteps: 5,
-      intermediateResults: [],
-    },
-  };
-}