@gotza02/seq-thinking 1.1.4 → 1.1.6

package/src/__tests__/agents.test.ts

@@ -1,858 +0,0 @@
-/**
- * Agents Test Suite
- * Tests for BaseAgent, ReasonerAgent, CriticAgent, SynthesizerAgent, and MetaReasoningAgent
- */
-import { test, describe, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import {
-  BaseAgent,
-  ReasonerAgent,
-  CriticAgent,
-  SynthesizerAgent,
-  MetaReasoningAgent,
-} from '../agents/index.js';
-import {
-  AgentType,
-  ThoughtType,
-  ReasoningStrategy,
-  CriticType,
-  SynthesizerType,
-  AgentStatus,
-  TaskStatus,
-  type AgentConfig,
-  type AgentCapability,
-  type Task,
-  type TaskResult,
-  type SwarmMessage,
-  MessageType,
-} from '../types/index.js';
-
-// Concrete implementation of BaseAgent for testing
-class TestAgent extends BaseAgent {
-  getType(): AgentType {
-    return AgentType.UTILITY;
-  }
-
-  getCapabilities(): AgentCapability[] {
-    return [
-      {
-        name: 'test-capability',
-        description: 'For testing purposes',
-        confidence: 0.9,
-        performanceMetrics: {
-          tasksCompleted: 10,
-          averageQuality: 0.85,
-          averageTimeMs: 100,
-        },
-      },
-    ];
-  }
-
-  public createTaskResult(
-    taskId: string,
-    output: any,
-    confidence: number,
-    processingTimeMs: number,
-    metadata: any = {}
-  ): TaskResult {
-    return super.createTaskResult(taskId, output, confidence, processingTimeMs, metadata);
-  }
-
-  async process(task: Task): Promise<TaskResult> {
-    return this.createTaskResult(
-      task.id,
-      { processed: true, input: task.input },
-      0.9,
-      100
-    );
-  }
-}
-
-describe('BaseAgent', () => {
-  let agent: TestAgent;
-
-  beforeEach(() => {
-    agent = new TestAgent({
-      name: 'Test Agent',
-      capabilities: [
-        {
-          name: 'test-capability',
-          description: 'For testing purposes',
-          confidence: 0.9,
-          performanceMetrics: {
-            tasksCompleted: 10,
-            averageQuality: 0.85,
-            averageTimeMs: 100,
-          },
-        }
-      ],
-      maxConcurrentTasks: 3,
-      confidenceThreshold: 0.7,
-    });
-  });
-
-  test('should have unique id', () => {
-    const agent2 = new TestAgent({ name: 'Test Agent 2', capabilities: [], maxConcurrentTasks: 1, confidenceThreshold: 0.5 });
-    assert.notStrictEqual(agent.id, agent2.id);
-  });
-
-  test('should return correct type', () => {
-    assert.strictEqual(agent.getType(), AgentType.UTILITY);
-  });
-
-  test('should return capabilities', () => {
-    const capabilities = agent.getCapabilities();
-    assert.ok(Array.isArray(capabilities));
-    assert.ok(capabilities.length > 0);
-    assert.ok(capabilities[0].name);
-  });
-
-  test('should execute task', async () => {
-    const task = createMockTask();
-    const result = await agent.execute(task);
-
-    assert.ok(result);
-    assert.strictEqual(result.taskId, task.id);
-    assert.strictEqual(result.agentId, agent.id);
-    assert.strictEqual(result.success, true);
-    assert.ok(result.output);
-    assert.ok(typeof result.confidence === 'number');
-    assert.ok(typeof result.processingTimeMs === 'number');
-  });
-
-  test('should set status to busy during execution', async () => {
-    const task = createMockTask();
-    
-    // Status should be idle before execution
-    assert.strictEqual(agent.getStatus(), 'idle');
-    
-    const executionPromise = agent.execute(task);
-    
-    // Status might be busy during execution (implementation dependent)
-    const result = await executionPromise;
-    
-    assert.ok(result);
-  });
-
-  test('should track current tasks', async () => {
-    const task = createMockTask();
-    
-    assert.deepStrictEqual(agent.getCurrentTasks(), []);
-    
-    await agent.execute(task);
-    
-    // After execution, task should be removed from current tasks
-    assert.deepStrictEqual(agent.getCurrentTasks(), []);
-  });
-
-  test('should handle message subscription', () => {
-    const messages: SwarmMessage[] = [];
-    
-    const unsubscribe = agent.onMessage((msg) => {
-      messages.push(msg);
-    });
-
-    assert.ok(typeof unsubscribe === 'function');
-
-    const testMessage = createMockMessage();
-    agent.receiveMessage(testMessage);
-
-    assert.strictEqual(messages.length, 1);
-    assert.strictEqual(messages[0].id, testMessage.id);
-
-    unsubscribe();
-  });
-
-  test('should unsubscribe from messages', () => {
-    const messages: SwarmMessage[] = [];
-    
-    const unsubscribe = agent.onMessage((msg) => {
-      messages.push(msg);
-    });
-
-    unsubscribe();
-
-    const testMessage = createMockMessage();
-    agent.receiveMessage(testMessage);
-
-    // After unsubscribe, should not receive messages
-    assert.strictEqual(messages.length, 0);
-  });
-
-  test('should get performance metrics', async () => {
-    const task = createMockTask();
-    await agent.execute(task);
-
-    const metrics = agent.getPerformanceMetrics();
-
-    assert.ok(typeof metrics.tasksCompleted === 'number');
-    assert.ok(typeof metrics.averageQuality === 'number');
-    assert.ok(typeof metrics.averageTimeMs === 'number');
-    assert.ok(typeof metrics.successRate === 'number');
-    
-    assert.strictEqual(metrics.tasksCompleted, 1);
-    assert.ok(metrics.successRate >= 0 && metrics.successRate <= 1);
-  });
-
-  test('should check capability', () => {
-    assert.strictEqual(agent.hasCapability('test-capability'), true);
-    assert.strictEqual(agent.hasCapability('non-existent'), false);
-  });
-
-  test('should get capability confidence', () => {
-    assert.strictEqual(agent.getCapabilityConfidence('test-capability'), 0.9);
-    assert.strictEqual(agent.getCapabilityConfidence('non-existent'), 0);
-  });
-
-  test('should check if can handle task', () => {
-    const taskWithCapability = createMockTask({
-      requirements: {
-        requiredCapabilities: ['test-capability'],
-        minConfidence: 0.5,
-        maxTimeMs: 5000
-      }
-    });
-    const taskWithoutCapability = createMockTask({
-      requirements: {
-        requiredCapabilities: ['unknown-capability'],
-        minConfidence: 0.5,
-        maxTimeMs: 5000
-      }
-    });
-
-    assert.strictEqual(agent.canHandleTask(taskWithCapability), true);
-    assert.strictEqual(agent.canHandleTask(taskWithoutCapability), false);
-  });
-
-  test('should create task result', () => {
-    const result = (agent as TestAgent).createTaskResult(
-      'task-001',
-      { answer: 42 },
-      0.95,
-      500,
-      { tokensUsed: 100 }
-    );
-
-    assert.strictEqual(result.taskId, 'task-001');
-    assert.strictEqual(result.agentId, agent.id);
-    assert.strictEqual(result.success, true);
-    assert.deepStrictEqual(result.output, { answer: 42 });
-    assert.strictEqual(result.confidence, 0.95);
-    assert.strictEqual(result.processingTimeMs, 500);
-    assert.strictEqual(result.metadata.tokensUsed, 100);
-  });
-
-  test('should set and get status', () => {
-    agent.setStatus(AgentStatus.OFFLINE);
-    assert.strictEqual(agent.getStatus(), AgentStatus.OFFLINE);
-  });
-
-  test('should track multiple executions', async () => {
-    for (let i = 0; i < 5; i++) {
-      await agent.execute(createMockTask());
-    }
-
-    const metrics = agent.getPerformanceMetrics();
-    assert.strictEqual(metrics.tasksCompleted, 5);
-  });
-});
-
-describe('ReasonerAgent', () => {
-  let agent: ReasonerAgent;
-
-  beforeEach(() => {
-    agent = new ReasonerAgent({
-      name: 'Test Reasoner',
-      strategy: ReasoningStrategy.CHAIN_OF_THOUGHT,
-      maxIterations: 5,
-      confidenceThreshold: 0.7,
-    });
-  });
-
-  test('should return correct type', () => {
-    assert.strictEqual(agent.getType(), AgentType.REASONER);
-  });
-
-  test('should return reasoning capabilities', () => {
-    const capabilities = agent.getCapabilities();
-    assert.ok(capabilities.length > 0);
-    assert.ok(capabilities.some(c => c.name.includes('reasoning') || c.name.includes('chain')));
-  });
-
-  test('should process reasoning task', async () => {
-    const task = createMockTask({
-      type: 'reasoning',
-      input: { problem: 'What is 2 + 2?' },
-    });
-
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    assert.strictEqual(result.success, true);
-    assert.ok(result.output);
-  });
-
-  test('should handle chain of thought reasoning', async () => {
-    const cotAgent = new ReasonerAgent({
-      name: 'CoT Reasoner',
-      strategy: ReasoningStrategy.CHAIN_OF_THOUGHT,
-    });
-
-    const task = createMockTask({ input: { problem: 'Complex problem' } });
-    const result = await cotAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should handle tree of thought reasoning', async () => {
-    const totAgent = new ReasonerAgent({
-      name: 'ToT Reasoner',
-      strategy: ReasoningStrategy.TREE_OF_THOUGHT,
-    });
-
-    const task = createMockTask({ input: { problem: 'Multi-path problem' } });
-    const result = await totAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should handle analogical reasoning', async () => {
-    const analogicalAgent = new ReasonerAgent({
-      name: 'Analogical Reasoner',
-      strategy: ReasoningStrategy.ANALOGICAL,
-    });
-
-    const task = createMockTask({ input: { problem: 'Find analogy' } });
-    const result = await analogicalAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should handle abductive reasoning', async () => {
-    const abductiveAgent = new ReasonerAgent({
-      name: 'Abductive Reasoner',
-      strategy: ReasoningStrategy.ABDUCTIVE,
-    });
-
-    const task = createMockTask({ input: { problem: 'Find best explanation' } });
-    const result = await abductiveAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should respect max iterations', async () => {
-    const limitedAgent = new ReasonerAgent({
-      name: 'Limited Reasoner',
-      maxIterations: 2,
-    });
-
-    const task = createMockTask({ input: { problem: 'Iterative problem' } });
-    const result = await limitedAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should respect confidence threshold', async () => {
-    const highThresholdAgent = new ReasonerAgent({
-      name: 'High Threshold Reasoner',
-      confidenceThreshold: 0.95,
-    });
-
-    const task = createMockTask({ input: { problem: 'Difficult problem' } });
-    const result = await highThresholdAgent.process(task);
-
-    assert.ok(result);
-    // Result confidence should be below threshold if not confident enough
-    assert.ok(result.confidence <= 1);
-  });
-});
-
-describe('CriticAgent', () => {
-  let agent: CriticAgent;
-
-  beforeEach(() => {
-    agent = new CriticAgent({
-      name: 'Test Critic',
-      criticType: CriticType.LOGICAL,
-      severityThreshold: 0.5,
-    });
-  });
-
-  test('should return correct type', () => {
-    assert.strictEqual(agent.getType(), AgentType.CRITIC);
-  });
-
-  test('should return critic capabilities', () => {
-    const capabilities = agent.getCapabilities();
-    assert.ok(capabilities.length > 0);
-    assert.ok(capabilities.some(c => c.name.includes('critique') || c.name.includes('evaluation')));
-  });
-
-  test('should process evaluation task', async () => {
-    const task = createMockTask({
-      type: 'evaluation',
-      input: { content: 'This is a statement to evaluate' },
-    });
-
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    assert.strictEqual(result.success, true);
-    assert.ok(result.output);
-  });
-
-  test('should evaluate logical consistency', async () => {
-    const logicalCritic = new CriticAgent({
-      name: 'Logical Critic',
-      criticType: CriticType.LOGICAL,
-    });
-
-    const task = createMockTask({
-      input: { content: 'If A then B. A is true. Therefore B is true.' },
-    });
-    const result = await logicalCritic.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should check factual accuracy', async () => {
-    const factualCritic = new CriticAgent({
-      name: 'Factual Critic',
-      criticType: CriticType.FACTUAL,
-    });
-
-    const task = createMockTask({
-      input: { content: 'The Earth is flat.' },
-    });
-    const result = await factualCritic.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should check for bias', async () => {
-    const biasCritic = new CriticAgent({
-      name: 'Bias Critic',
-      criticType: CriticType.BIAS,
-    });
-
-    const task = createMockTask({
-      input: { content: 'All people from group X are Y.' },
-    });
-    const result = await biasCritic.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should check safety', async () => {
-    const safetyCritic = new CriticAgent({
-      name: 'Safety Critic',
-      criticType: CriticType.SAFETY,
-    });
-
-    const task = createMockTask({
-      input: { content: 'How to build a dangerous device' },
-    });
-    const result = await safetyCritic.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should respect severity threshold', async () => {
-    const strictCritic = new CriticAgent({
-      name: 'Strict Critic',
-      criticType: CriticType.LOGICAL,
-      severityThreshold: 0.2,
-    });
-
-    const task = createMockTask({ input: { content: 'Somewhat problematic content' } });
-    const result = await strictCritic.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should provide evaluation results', async () => {
-    const task = createMockTask({ input: { content: 'Content to evaluate' } });
-    const result = await agent.process(task);
-
-    assert.ok(result.output);
-    const output = result.output as { passed?: boolean; score?: number; issues?: unknown[] };
-    assert.ok(typeof output.passed === 'boolean' || output.passed === undefined);
-    assert.ok(typeof output.score === 'number' || output.score === undefined);
-  });
-});
-
-describe('SynthesizerAgent', () => {
-  let agent: SynthesizerAgent;
-
-  beforeEach(() => {
-    agent = new SynthesizerAgent({
-      name: 'Test Synthesizer',
-      synthesizerType: SynthesizerType.CONSENSUS,
-    });
-  });
-
-  test('should return correct type', () => {
-    assert.strictEqual(agent.getType(), AgentType.SYNTHESIZER);
-  });
-
-  test('should return synthesis capabilities', () => {
-    const capabilities = agent.getCapabilities();
-    assert.ok(capabilities.length > 0);
-    assert.ok(capabilities.some(c => c.name.includes('synthesis') || c.name.includes('consensus')));
-  });
-
-  test('should process synthesis task', async () => {
-    const task = createMockTask({
-      type: 'synthesis',
-      input: {
-        outputs: [
-          { agentId: 'agent-1', output: 'Result A is long enough to be a key point.', confidence: 0.8 },
-          { agentId: 'agent-2', output: 'Result B is also long enough to be a key point.', confidence: 0.7 },
-        ],
-        goal: 'Combine results',
-      },
-    });
-
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    assert.strictEqual(result.success, true);
-    assert.ok(result.output);
-  });
-
-  test('should build consensus', async () => {
-    const consensusAgent = new SynthesizerAgent({
-      name: 'Consensus Synthesizer',
-      synthesizerType: SynthesizerType.CONSENSUS,
-    });
-
-    const task = createMockTask({
-      input: {
-        outputs: [
-          { agentId: 'a1', output: 'Agree', confidence: 0.9 },
-          { agentId: 'a2', output: 'Agree', confidence: 0.85 },
-          { agentId: 'a3', output: 'Agree', confidence: 0.8 },
-        ],
-        goal: 'Find consensus',
-      },
-    });
-    const result = await consensusAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should perform creative synthesis', async () => {
-    const creativeAgent = new SynthesizerAgent({
-      name: 'Creative Synthesizer',
-      synthesizerType: SynthesizerType.CREATIVE,
-    });
-
-    const task = createMockTask({
-      input: {
-        outputs: [
-          { agentId: 'a1', output: 'Idea 1', confidence: 0.7 },
-          { agentId: 'a2', output: 'Idea 2', confidence: 0.6 },
-        ],
-        goal: 'Generate creative combination',
-      },
-    });
-    const result = await creativeAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should resolve conflicts', async () => {
-    const conflictAgent = new SynthesizerAgent({
-      name: 'Conflict Resolver',
-      synthesizerType: SynthesizerType.CONFLICT_RESOLUTION,
-    });
-
-    const task = createMockTask({
-      input: {
-        outputs: [
-          { agentId: 'a1', output: 'Option A', confidence: 0.8 },
-          { agentId: 'a2', output: 'Option B', confidence: 0.75 },
-        ],
-        goal: 'Resolve disagreement',
-      },
-    });
-    const result = await conflictAgent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should handle dissenting views', async () => {
-    const task = createMockTask({
-      input: {
-        outputs: [
-          { agentId: 'a1', output: 'Majority view', confidence: 0.8, reasoning: 'Because X' },
-          { agentId: 'a2', output: 'Majority view', confidence: 0.75 },
-          { agentId: 'a3', output: 'Minority view', confidence: 0.6, reasoning: 'Because Y' },
-        ],
-        goal: 'Synthesize with dissent',
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    const output = result.output as { dissentingViews?: unknown[] };
-    // May or may not have dissenting views depending on implementation
-    assert.ok(output);
-  });
-
-  test('should handle empty inputs', async () => {
-    const task = createMockTask({
-      input: {
-        outputs: [],
-        goal: 'Synthesize nothing',
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should handle single input', async () => {
-    const task = createMockTask({
-      input: {
-        outputs: [{ agentId: 'a1', output: 'Only result', confidence: 0.9 }],
-        goal: 'Synthesize single input',
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-  });
-});
-
-describe('MetaReasoningAgent', () => {
-  let agent: MetaReasoningAgent;
-
-  beforeEach(() => {
-    agent = new MetaReasoningAgent({
-      name: 'Test Meta Reasoner',
-    });
-  });
-
-  test('should return correct type', () => {
-    assert.strictEqual(agent.getType(), AgentType.META_REASONING);
-  });
-
-  test('should return meta-reasoning capabilities', () => {
-    const capabilities = agent.getCapabilities();
-    assert.ok(capabilities.length > 0);
-    assert.ok(capabilities.some(c => c.name.includes('meta') || c.name.includes('reflection')));
-  });
-
-  test('should process meta-reasoning task', async () => {
-    const task = createMockTask({
-      type: 'meta-reasoning',
-      input: {
-        thoughts: [
-          { id: 't1', content: 'First thought', type: ThoughtType.HYPOTHESIS },
-          { id: 't2', content: 'Second thought', type: ThoughtType.ANALYSIS },
-        ],
-        sessionContext: { topic: 'Test topic' },
-      },
-    });
-
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    assert.strictEqual(result.success, true);
-    assert.ok(result.output);
-  });
-
-  test('should identify patterns', async () => {
-    const task = createMockTask({
-      input: {
-        thoughts: Array(5).fill(0).map((_, i) => ({
-          id: `t${i}`,
-          content: `Thought ${i}`,
-          type: i % 2 === 0 ? ThoughtType.HYPOTHESIS : ThoughtType.ANALYSIS,
-        })),
-        sessionContext: { topic: 'Pattern detection test' },
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    const output = result.output as { observations?: Array<{ type: string }> };
-    // May identify patterns
-    assert.ok(output);
-  });
-
-  test('should detect concerns', async () => {
-    const task = createMockTask({
-      input: {
-        thoughts: [
-          { id: 't1', content: 'Low confidence thought', confidence: 0.3 },
-          { id: 't2', content: 'Contradictory statement' },
-        ],
-        sessionContext: { topic: 'Concern detection test' },
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should provide recommendations', async () => {
-    const task = createMockTask({
-      input: {
-        thoughts: [{ id: 't1', content: 'Single thought' }],
-        sessionContext: { topic: 'Recommendation test' },
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    const output = result.output as { recommendations?: string[] };
-    // Should provide some recommendations
-    assert.ok(output);
-  });
-
-  test('should handle empty thoughts', async () => {
-    const task = createMockTask({
-      input: {
-        thoughts: [],
-        sessionContext: { topic: 'Empty test' },
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-  });
-
-  test('should track meta-observations', async () => {
-    const task = createMockTask({
-      input: {
-        thoughts: Array(10).fill(0).map((_, i) => ({
-          id: `t${i}`,
-          content: `Thought ${i}`,
-        })),
-        sessionContext: { topic: 'Tracking test' },
-      },
-    });
-    const result = await agent.process(task);
-
-    assert.ok(result);
-    const output = result.output as { observations?: unknown[] };
-    // May have multiple observations
-    assert.ok(output);
-  });
-});
-
-describe('Agent Interactions', () => {
-  test('reasoner and critic should work together', async () => {
-    const reasoner = new ReasonerAgent({ name: 'Reasoner' });
-    const critic = new CriticAgent({ name: 'Critic', criticType: CriticType.LOGICAL });
-
-    const reasoningTask = createMockTask({ input: { problem: 'Solve X' } });
-    const reasoningResult = await reasoner.process(reasoningTask);
-
-    const evaluationTask = createMockTask({
-      input: { content: reasoningResult.output },
-    });
-    const evaluationResult = await critic.process(evaluationTask);
-
-    assert.ok(reasoningResult.success);
-    assert.ok(evaluationResult.success);
-  });
-
-  test('multiple agents can process same task type', async () => {
-    const reasoner1 = new ReasonerAgent({
-      name: 'Reasoner 1',
-      strategy: ReasoningStrategy.CHAIN_OF_THOUGHT,
-    });
-    const reasoner2 = new ReasonerAgent({
-      name: 'Reasoner 2',
-      strategy: ReasoningStrategy.TREE_OF_THOUGHT,
-    });
-
-    const task = createMockTask({ input: { problem: 'Compare strategies' } });
-
-    const result1 = await reasoner1.process(task);
-    const result2 = await reasoner2.process(task);
-
-    assert.ok(result1.success);
-    assert.ok(result2.success);
-  });
-
-  test('synthesizer can combine multiple agent outputs', async () => {
-    const synthesizer = new SynthesizerAgent({
-      name: 'Synthesizer',
-      synthesizerType: SynthesizerType.CONSENSUS,
-    });
-
-    const task = createMockTask({
-      input: {
-        outputs: [
-          { agentId: 'reasoner', output: 'Reasoning result', confidence: 0.8 },
-          { agentId: 'critic', output: 'Evaluation result', confidence: 0.75 },
-        ],
-        goal: 'Combine agent outputs',
-      },
-    });
-
-    const result = await synthesizer.process(task);
-    assert.ok(result.success);
-  });
-
-  test('meta-reasoner can observe other agents', async () => {
-    const metaReasoner = new MetaReasoningAgent({ name: 'Meta' });
-    const reasoner = new ReasonerAgent({ name: 'Reasoner' });
-
-    const reasoningTask = createMockTask({ input: { problem: 'Problem' } });
-    const reasoningResult = await reasoner.process(reasoningTask);
-
-    const metaTask = createMockTask({
-      input: {
-        thoughts: [{ id: '1', content: JSON.stringify(reasoningResult.output) }],
-        sessionContext: { topic: 'Observe reasoning' },
-      },
-    });
-    const metaResult = await metaReasoner.process(metaTask);
-
-    assert.ok(metaResult.success);
-  });
-});
-
-// Helper functions
-function createMockTask(overrides: Partial<Task> = {}): Task {
-  return {
-    id: `task-${Math.random().toString(36).substr(2, 9)}`,
-    type: 'test',
-    description: 'Test task',
-    input: {},
-    context: { dependencies: [] },
-    requirements: {
-      requiredCapabilities: [],
-      minConfidence: 0.5,
-      maxTimeMs: 5000,
-    },
-    assignedAgentId: null,
-    status: TaskStatus.PENDING,
-    result: null,
-    metadata: { createdAt: new Date() },
-    ...overrides,
-  };
-}
-
-function createMockMessage(overrides: Partial<SwarmMessage> = {}): SwarmMessage {
-  return {
-    id: `msg-${Math.random().toString(36).substr(2, 9)}`,
-    type: MessageType.BROADCAST,
-    senderId: 'agent-test',
-    recipientId: null,
-    timestamp: new Date(),
-    payload: {},
-    context: {},
-    metadata: {
-      priority: 0,
-      ttl: 30000,
-      retryCount: 0,
-    },
-    ...overrides,
-  };
-}