@gotza02/seq-thinking 1.1.5 → 1.1.7

package/src/__tests__/types.test.ts

@@ -1,839 +0,0 @@
-/**
- * Types Test Suite
- * Tests for type definitions, enums, and interfaces
- */
-import { test, describe } from 'node:test';
-import assert from 'node:assert';
-import {
-  ThoughtType,
-  AgentType,
-  ReasoningStrategy,
-  CriticType,
-  SynthesizerType,
-  MessageType,
-  ConsensusAlgorithm,
-  ConflictResolutionStrategy,
-  AssignmentStrategy,
-  BranchStatus,
-  SessionStatus,
-  TaskStatus,
-  ConflictStatus,
-  AgentStatus,
-  type ConfidenceScore,
-  type Thought,
-  type ThoughtBranch,
-  type MetaNote,
-  type SessionContext,
-  type SessionSettings,
-  type ThinkingSession,
-  type AgentConfig,
-  type AgentCapability,
-  type Agent,
-  type SwarmMessage,
-  type Task,
-  type TaskResult,
-  type ConsensusVote,
-  type ConsensusResult,
-  type Conflict,
-} from '../types/index.js';
-
-describe('ThoughtType Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(ThoughtType.HYPOTHESIS, 'hypothesis');
-    assert.strictEqual(ThoughtType.ANALYSIS, 'analysis');
-    assert.strictEqual(ThoughtType.SYNTHESIS, 'synthesis');
-    assert.strictEqual(ThoughtType.CONCLUSION, 'conclusion');
-    assert.strictEqual(ThoughtType.META_REASONING, 'meta_reasoning');
-    assert.strictEqual(ThoughtType.SELF_CORRECTION, 'self_correction');
-    assert.strictEqual(ThoughtType.UNCERTAINTY, 'uncertainty');
-    assert.strictEqual(ThoughtType.QUESTION, 'question');
-    assert.strictEqual(ThoughtType.EVIDENCE, 'evidence');
-    assert.strictEqual(ThoughtType.COUNTERARGUMENT, 'counterargument');
-    assert.strictEqual(ThoughtType.ASSUMPTION, 'assumption');
-    assert.strictEqual(ThoughtType.BRANCH_POINT, 'branch_point');
-    assert.strictEqual(ThoughtType.MERGE_POINT, 'merge_point');
-    assert.strictEqual(ThoughtType.REVISION, 'revision');
-  });
-
-  test('should have exactly 14 values', () => {
-    const values = Object.values(ThoughtType);
-    assert.strictEqual(values.length, 14);
-  });
-
-  test('all values should be strings', () => {
-    const values = Object.values(ThoughtType);
-    values.forEach(value => {
-      assert.strictEqual(typeof value, 'string');
-    });
-  });
-});
-
-describe('AgentType Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(AgentType.REASONER, 'reasoner');
-    assert.strictEqual(AgentType.CRITIC, 'critic');
-    assert.strictEqual(AgentType.SYNTHESIZER, 'synthesizer');
-    assert.strictEqual(AgentType.SPECIALIST, 'specialist');
-    assert.strictEqual(AgentType.META_REASONING, 'meta_reasoning');
-    assert.strictEqual(AgentType.UTILITY, 'utility');
-  });
-
-  test('should have exactly 6 values', () => {
-    const values = Object.values(AgentType);
-    assert.strictEqual(values.length, 6);
-  });
-});
-
-describe('ReasoningStrategy Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(ReasoningStrategy.CHAIN_OF_THOUGHT, 'chain_of_thought');
-    assert.strictEqual(ReasoningStrategy.TREE_OF_THOUGHT, 'tree_of_thought');
-    assert.strictEqual(ReasoningStrategy.ANALOGICAL, 'analogical');
-    assert.strictEqual(ReasoningStrategy.ABDUCTIVE, 'abductive');
-  });
-
-  test('should have exactly 4 values', () => {
-    const values = Object.values(ReasoningStrategy);
-    assert.strictEqual(values.length, 4);
-  });
-});
-
-describe('CriticType Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(CriticType.LOGICAL, 'logical');
-    assert.strictEqual(CriticType.FACTUAL, 'factual');
-    assert.strictEqual(CriticType.BIAS, 'bias');
-    assert.strictEqual(CriticType.SAFETY, 'safety');
-  });
-
-  test('should have exactly 4 values', () => {
-    const values = Object.values(CriticType);
-    assert.strictEqual(values.length, 4);
-  });
-});
-
-describe('SynthesizerType Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(SynthesizerType.CONSENSUS, 'consensus');
-    assert.strictEqual(SynthesizerType.CREATIVE, 'creative');
-    assert.strictEqual(SynthesizerType.CONFLICT_RESOLUTION, 'conflict_resolution');
-  });
-
-  test('should have exactly 3 values', () => {
-    const values = Object.values(SynthesizerType);
-    assert.strictEqual(values.length, 3);
-  });
-});
-
-describe('MessageType Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(MessageType.TASK_ASSIGNMENT, 'task_assignment');
-    assert.strictEqual(MessageType.TASK_RESULT, 'task_result');
-    assert.strictEqual(MessageType.BROADCAST, 'broadcast');
-    assert.strictEqual(MessageType.DIRECT, 'direct');
-    assert.strictEqual(MessageType.CONSENSUS_REQUEST, 'consensus_request');
-    assert.strictEqual(MessageType.CONSENSUS_VOTE, 'consensus_vote');
-    assert.strictEqual(MessageType.CONFLICT_NOTIFICATION, 'conflict_notification');
-    assert.strictEqual(MessageType.HEARTBEAT, 'heartbeat');
-  });
-
-  test('should have exactly 8 values', () => {
-    const values = Object.values(MessageType);
-    assert.strictEqual(values.length, 8);
-  });
-});
-
-describe('ConsensusAlgorithm Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(ConsensusAlgorithm.MAJORITY_VOTE, 'majority_vote');
-    assert.strictEqual(ConsensusAlgorithm.WEIGHTED_VOTE, 'weighted_vote');
-    assert.strictEqual(ConsensusAlgorithm.BORDA_COUNT, 'borda_count');
-    assert.strictEqual(ConsensusAlgorithm.CONDORCET, 'condorcet');
-    assert.strictEqual(ConsensusAlgorithm.DELPHI_METHOD, 'delphi_method');
-    assert.strictEqual(ConsensusAlgorithm.PREDICTION_MARKET, 'prediction_market');
-  });
-
-  test('should have exactly 6 values', () => {
-    const values = Object.values(ConsensusAlgorithm);
-    assert.strictEqual(values.length, 6);
-  });
-});
-
-describe('ConflictResolutionStrategy Enum', () => {
-  test('should have all expected values', () => {
-    assert.strictEqual(ConflictResolutionStrategy.MEDIATION, 'mediation');
-    assert.strictEqual(ConflictResolutionStrategy.ARBITRATION, 'arbitration');
-    assert.strictEqual(ConflictResolutionStrategy.VOTING, 'voting');
-    assert.strictEqual(ConflictResolutionStrategy.EXPERT_ESCALATION, 'expert_escalation');
-    assert.strictEqual(ConflictResolutionStrategy.COMPROMISE, 'compromise');
-    assert.strictEqual(ConflictResolutionStrategy.EVIDENCE_BASED, 'evidence_based');
-  });
-
-  test('should have exactly 6 values', () => {
-    const values = Object.values(ConflictResolutionStrategy);
-    assert.strictEqual(values.length, 6);
-  });
-});
-
-describe('AssignmentStrategy Type', () => {
-  test('should accept valid assignment strategies', () => {
-    const strategies: AssignmentStrategy[] = [
-      'round_robin',
-      'capability_based',
-      'load_balanced',
-      'performance_based',
-      'adaptive',
-      'cost_based',
-      'fastest_first',
-    ];
-    assert.strictEqual(strategies.length, 7);
-    strategies.forEach(strategy => {
-      assert.strictEqual(typeof strategy, 'string');
-    });
-  });
-});
-
-describe('ConfidenceScore Interface', () => {
-  test('should create valid ConfidenceScore object', () => {
-    const score: ConfidenceScore = {
-      overall: 0.85,
-      components: {
-        logicalConsistency: 0.9,
-        factualAccuracy: 0.8,
-        reasoningQuality: 0.85,
-        evidenceStrength: 0.85,
-      },
-      uncertaintyBounds: [0.7, 0.95],
-      calibrationHistory: [
-        {
-          timestamp: new Date(),
-          priorConfidence: 0.7,
-          outcome: true,
-          adjustedConfidence: 0.75,
-          reason: 'Correct prediction',
-          adjustment: 0.05,
-        },
-      ],
-    };
-
-    assert.strictEqual(typeof score.overall, 'number');
-    assert.strictEqual(score.overall, 0.85);
-    assert.ok(score.uncertaintyBounds[0] <= score.uncertaintyBounds[1]);
-    assert.ok(score.overall >= 0 && score.overall <= 1);
-  });
-
-  test('should validate confidence bounds', () => {
-    const score: ConfidenceScore = {
-      overall: 0.5,
-      components: {
-        logicalConsistency: 0.5,
-        factualAccuracy: 0.5,
-        reasoningQuality: 0.5,
-        evidenceStrength: 0.5,
-      },
-      uncertaintyBounds: [0, 1],
-      calibrationHistory: [],
-    };
-
-    // Overall should be within bounds
-    assert.ok(score.overall >= score.uncertaintyBounds[0]);
-    assert.ok(score.overall <= score.uncertaintyBounds[1]);
-  });
-});
-
-describe('Thought Interface', () => {
-  test('should create valid Thought object', () => {
-    const thought: Thought = {
-      id: 'thought-001',
-      sessionId: 'session-001',
-      content: 'This is a test thought',
-      stepNumber: 1,
-      thoughtType: ThoughtType.HYPOTHESIS,
-      confidence: {
-        overall: 0.8,
-        components: {
-          logicalConsistency: 0.85,
-          factualAccuracy: 0.75,
-          reasoningQuality: 0.8,
-          evidenceStrength: 0.8,
-        },
-        uncertaintyBounds: [0.6, 0.9],
-        calibrationHistory: [],
-      },
-      parentThoughtId: null,
-      childThoughtIds: [],
-      branchId: 'branch-001',
-      revisionOf: null,
-      revisionHistory: [],
-      metadata: {
-        createdAt: new Date(),
-        modifiedAt: new Date(),
-        agentId: 'agent-001',
-        processingTimeMs: 100,
-        tokensUsed: 50,
-      },
-      tags: ['test', 'hypothesis'],
-      assumptions: ['assumption-1'],
-      dependencies: [],
-    };
-
-    assert.strictEqual(thought.id, 'thought-001');
-    assert.strictEqual(thought.stepNumber, 1);
-    assert.ok(thought.metadata.createdAt instanceof Date);
-  });
-
-  test('should handle revision history', () => {
-    const thought: Thought = {
-      id: 'thought-002',
-      sessionId: 'session-001',
-      content: 'Revised content',
-      stepNumber: 2,
-      thoughtType: ThoughtType.REVISION,
-      confidence: {
-        overall: 0.9,
-        components: {
-          logicalConsistency: 0.9,
-          factualAccuracy: 0.9,
-          reasoningQuality: 0.9,
-          evidenceStrength: 0.9,
-        },
-        uncertaintyBounds: [0.8, 1.0],
-        calibrationHistory: [],
-      },
-      parentThoughtId: 'thought-001',
-      childThoughtIds: [],
-      branchId: 'branch-001',
-      revisionOf: 'thought-001',
-      revisionHistory: [
-        {
-          previousContent: 'Original content',
-          revisedAt: new Date(),
-          revisionReason: 'Improved clarity',
-        },
-      ],
-      metadata: {
-        createdAt: new Date(),
-        modifiedAt: new Date(),
-        processingTimeMs: 150,
-        tokensUsed: 75,
-      },
-      tags: [],
-      assumptions: [],
-      dependencies: ['thought-001'],
-    };
-
-    assert.strictEqual(thought.revisionOf, 'thought-001');
-    assert.strictEqual(thought.revisionHistory.length, 1);
-  });
-});
-
-describe('ThoughtBranch Interface', () => {
-  test('should create valid ThoughtBranch object', () => {
-    const branch: ThoughtBranch = {
-      id: 'branch-001',
-      sessionId: 'session-001',
-      name: 'Main Branch',
-      description: 'Primary reasoning path',
-      rootThoughtId: 'thought-001',
-      thoughtIds: ['thought-001', 'thought-002'],
-      parentBranchId: null,
-      childBranchIds: [],
-      status: BranchStatus.ACTIVE,
-      confidence: 0.85,
-      metadata: {
-        createdAt: new Date(),
-      },
-    };
-
-    assert.strictEqual(branch.status, 'active');
-    assert.ok(['active', 'pruned', 'merged', 'completed'].includes(branch.status));
-  });
-
-  test('should handle pruned branch', () => {
-    const branch: ThoughtBranch = {
-      id: 'branch-002',
-      sessionId: 'session-001',
-      name: 'Alternative Path',
-      description: 'Discarded branch',
-      rootThoughtId: 'thought-003',
-      thoughtIds: ['thought-003'],
-      parentBranchId: 'branch-001',
-      childBranchIds: [],
-      status: BranchStatus.PRUNED,
-      confidence: 0.3,
-      metadata: {
-        createdAt: new Date(),
-        prunedAt: new Date(),
-        pruneReason: 'Low confidence',
-      },
-    };
-
-    assert.strictEqual(branch.status, 'pruned');
-    assert.ok(branch.metadata.prunedAt instanceof Date);
-    assert.strictEqual(branch.metadata.pruneReason, 'Low confidence');
-  });
-});
-
-describe('MetaNote Interface', () => {
-  test('should create valid MetaNote object', () => {
-    const metaNote: MetaNote = {
-      id: 'meta-001',
-      thoughtId: 'thought-001',
-      content: 'Pattern detected in reasoning',
-      observationType: 'pattern',
-      timestamp: new Date(),
-      triggeredActions: ['review', 'validate'],
-    };
-
-    assert.ok(['pattern', 'concern', 'strategy', 'bias', 'confidence', 'process'].includes(metaNote.observationType));
-    assert.strictEqual(metaNote.triggeredActions.length, 2);
-  });
-});
-
-describe('SessionContext Interface', () => {
-  test('should create valid SessionContext object', () => {
-    const context: SessionContext = {
-      originalProblem: 'Solve this complex problem',
-      constraints: ['time < 1 hour', 'budget < $100'],
-      relevantInformation: ['info-1', 'info-2'],
-      workingMemory: new Map([['key', 'value']]),
-      longTermReferences: ['ref-1', 'ref-2'],
-    };
-
-    assert.strictEqual(context.originalProblem, 'Solve this complex problem');
-    assert.strictEqual(context.constraints.length, 2);
-    assert.ok(context.workingMemory instanceof Map);
-  });
-
-  test('should handle empty context', () => {
-    const context: SessionContext = {
-      originalProblem: '',
-      constraints: [],
-      relevantInformation: [],
-      workingMemory: new Map(),
-      longTermReferences: [],
-    };
-
-    assert.strictEqual(context.constraints.length, 0);
-    assert.strictEqual(context.workingMemory.size, 0);
-  });
-});
-
-describe('SessionSettings Interface', () => {
-  test('should create valid SessionSettings object', () => {
-    const settings: SessionSettings = {
-      maxBranches: 5,
-      maxDepth: 10,
-      confidenceThreshold: 0.7,
-      enableSelfCorrection: true,
-      enableMetaReasoning: true,
-      enableParallelHypotheses: true,
-      adaptiveGranularity: true,
-      granularitySettings: {
-        minStepDetail: 1,
-        maxStepDetail: 10,
-        complexityThreshold: 0.5,
-      },
-    };
-
-    assert.strictEqual(settings.maxBranches, 5);
-    assert.ok(settings.enableSelfCorrection);
-    assert.ok(settings.granularitySettings.minStepDetail < settings.granularitySettings.maxStepDetail);
-  });
-
-  test('should validate confidence threshold range', () => {
-    const settings: SessionSettings = {
-      maxBranches: 3,
-      maxDepth: 5,
-      confidenceThreshold: 0.5,
-      enableSelfCorrection: false,
-      enableMetaReasoning: false,
-      enableParallelHypotheses: false,
-      adaptiveGranularity: false,
-      granularitySettings: {
-        minStepDetail: 1,
-        maxStepDetail: 5,
-        complexityThreshold: 0.3,
-      },
-    };
-
-    assert.ok(settings.confidenceThreshold >= 0 && settings.confidenceThreshold <= 1);
-  });
-});
-
-describe('ThinkingSession Interface', () => {
-  test('should create valid ThinkingSession object', () => {
-    const session: ThinkingSession = {
-      id: 'session-001',
-      topic: 'Test Topic',
-      status: SessionStatus.INITIALIZING,
-      currentBranchId: 'branch-001',
-      branches: new Map(),
-      thoughts: new Map(),
-      metaNotes: new Map(),
-      context: {
-        originalProblem: 'Test problem',
-        constraints: [],
-        relevantInformation: [],
-        workingMemory: new Map(),
-        longTermReferences: [],
-      },
-      settings: {
-        maxBranches: 3,
-        maxDepth: 5,
-        confidenceThreshold: 0.7,
-        enableSelfCorrection: true,
-        enableMetaReasoning: true,
-        enableParallelHypotheses: false,
-        adaptiveGranularity: true,
-        granularitySettings: {
-          minStepDetail: 1,
-          maxStepDetail: 5,
-          complexityThreshold: 0.5,
-        },
-      },
-      metadata: {
-        createdAt: new Date(),
-        lastActivityAt: new Date(),
-        totalThoughts: 0,
-        totalBranches: 1,
-      },
-    };
-
-    assert.ok(Object.values(SessionStatus).includes(session.status));
-  });
-});
-
-describe('AgentCapability Interface', () => {
-  test('should create valid AgentCapability object', () => {
-    const capability: AgentCapability = {
-      name: 'logical-reasoning',
-      description: 'Ability to perform logical reasoning',
-      confidence: 0.9,
-      performanceMetrics: {
-        tasksCompleted: 100,
-        averageQuality: 0.85,
-        averageTimeMs: 500,
-      },
-    };
-
-    assert.strictEqual(capability.name, 'logical-reasoning');
-    assert.ok(capability.confidence >= 0 && capability.confidence <= 1);
-    assert.ok(capability.performanceMetrics.averageQuality >= 0 && capability.performanceMetrics.averageQuality <= 1);
-  });
-});
-
-describe('AgentConfig Interface', () => {
-  test('should create valid AgentConfig object', () => {
-    const config: AgentConfig = {
-      id: 'agent-001',
-      name: 'Test Agent',
-      type: AgentType.REASONER,
-      subtype: 'chain-of-thought',
-      capabilities: [
-        {
-          name: 'reasoning',
-          description: 'Logical reasoning',
-          confidence: 0.9,
-          performanceMetrics: {
-            tasksCompleted: 50,
-            averageQuality: 0.85,
-            averageTimeMs: 300,
-          },
-        },
-      ],
-      maxConcurrentTasks: 3,
-      confidenceThreshold: 0.7,
-      metadata: {
-        createdAt: new Date(),
-        version: '1.0.0',
-        config: {},
-      },
-    };
-
-    assert.strictEqual(config.type, AgentType.REASONER);
-    assert.ok(config.maxConcurrentTasks > 0);
-  });
-});
-
-describe('Agent Interface', () => {
-  test('should create valid Agent object', () => {
-    const agent: Agent = {
-      config: {
-        id: 'agent-001',
-        name: 'Test Agent',
-        type: AgentType.REASONER,
-        capabilities: [],
-        maxConcurrentTasks: 1,
-        confidenceThreshold: 0.5,
-        metadata: {
-          createdAt: new Date(),
-          version: '1.0.0',
-          config: {},
-        },
-      },
-      status: AgentStatus.IDLE,
-      currentTasks: [],
-      performanceHistory: [],
-    };
-
-    assert.ok(['idle', 'busy', 'offline'].includes(agent.status));
-    assert.strictEqual(agent.currentTasks.length, 0);
-  });
-});
-
-describe('SwarmMessage Interface', () => {
-  test('should create valid SwarmMessage object', () => {
-    const message: SwarmMessage = {
-      id: 'msg-001',
-      type: MessageType.TASK_ASSIGNMENT,
-      senderId: 'agent-001',
-      recipientId: 'agent-002',
-      timestamp: new Date(),
-      payload: { taskId: 'task-001' },
-      context: {
-        sessionId: 'session-001',
-        taskId: 'task-001',
-        correlationId: 'corr-001',
-      },
-      metadata: {
-        priority: 1,
-        ttl: 30000,
-        retryCount: 0,
-      },
-    };
-
-    assert.strictEqual(message.type, MessageType.TASK_ASSIGNMENT);
-    assert.ok(message.metadata.priority >= 0);
-    assert.ok(message.metadata.ttl > 0);
-  });
-
-  test('should handle broadcast message', () => {
-    const message: SwarmMessage = {
-      id: 'msg-002',
-      type: MessageType.BROADCAST,
-      senderId: 'agent-001',
-      recipientId: null,
-      timestamp: new Date(),
-      payload: { announcement: 'Hello all' },
-      context: {},
-      metadata: {
-        priority: 0,
-        ttl: 60000,
-        retryCount: 0,
-      },
-    };
-
-    assert.strictEqual(message.recipientId, null);
-  });
-});
-
-describe('Task Interface', () => {
-  test('should create valid Task object', () => {
-    const task: Task = {
-      id: 'task-001',
-      type: 'reasoning',
-      description: 'Perform reasoning task',
-      input: { problem: 'Solve X' },
-      context: {
-        sessionId: 'session-001',
-        dependencies: [],
-      },
-      requirements: {
-        requiredCapabilities: ['reasoning'],
-        minConfidence: 0.7,
-        maxTimeMs: 5000,
-      },
-      assignedAgentId: null,
-      status: TaskStatus.PENDING,
-      result: null,
-      metadata: {
-        createdAt: new Date(),
-      },
-    };
-
-    assert.ok(['pending', 'assigned', 'in_progress', 'completed', 'failed'].includes(task.status));
-    assert.ok(task.requirements.maxTimeMs > 0);
-  });
-
-  test('should handle completed task', () => {
-    const task: Task = {
-      id: 'task-002',
-      type: 'analysis',
-      description: 'Analyze data',
-      input: { data: [1, 2, 3] },
-      context: {
-        sessionId: 'session-001',
-        parentTaskId: 'task-001',
-        dependencies: ['task-001'],
-      },
-      requirements: {
-        requiredCapabilities: ['analysis'],
-        minConfidence: 0.8,
-        maxTimeMs: 10000,
-      },
-      assignedAgentId: 'agent-001',
-      status: TaskStatus.COMPLETED,
-      result: {
-        taskId: 'task-001',
-        agentId: 'agent-001',
-        success: true,
-        output: 'Analysis complete',
-        confidence: 0.9,
-        processingTimeMs: 1500,
-        metadata: {
-          tokensUsed: 500,
-          reasoningSteps: 5,
-          intermediateResults: [],
-        },
-      },
-      metadata: {
-        createdAt: new Date(),
-        assignedAt: new Date(),
-        startedAt: new Date(),
-        completedAt: new Date(),
-      },
-    };
-
-    assert.strictEqual(task.status, 'completed');
-    assert.ok(task.metadata.completedAt instanceof Date);
-  });
-});
-
-describe('TaskResult Interface', () => {
-  test('should create valid TaskResult object', () => {
-    const result: TaskResult = {
-      taskId: 'task-001',
-      agentId: 'agent-001',
-      success: true,
-      output: { answer: 42 },
-      confidence: 0.9,
-      processingTimeMs: 500,
-      metadata: {
-        tokensUsed: 100,
-        reasoningSteps: 5,
-        intermediateResults: [],
-      },
-    };
-
-    assert.strictEqual(result.success, true);
-    assert.ok(result.confidence >= 0 && result.confidence <= 1);
-    assert.ok(result.processingTimeMs >= 0);
-  });
-
-  test('should handle failed result', () => {
-    const result: TaskResult = {
-      taskId: 'task-002',
-      agentId: 'agent-001',
-      success: false,
-      output: null,
-      confidence: 0,
-      processingTimeMs: 100,
-      metadata: {
-        tokensUsed: 50,
-        reasoningSteps: 1,
-        intermediateResults: [],
-        error: 'Task failed due to timeout',
-      },
-    };
-
-    assert.strictEqual(result.success, false);
-    assert.ok(result.metadata.error);
-  });
-});
-
-describe('ConsensusVote Interface', () => {
-  test('should create valid ConsensusVote object', () => {
-    const vote: ConsensusVote = {
-      agentId: 'agent-001',
-      proposalId: 'proposal-001',
-      vote: 'option-a',
-      confidence: 0.8,
-      reasoning: 'This option is optimal',
-      timestamp: new Date(),
-    };
-
-    assert.strictEqual(vote.agentId, 'agent-001');
-    assert.ok(vote.confidence >= 0 && vote.confidence <= 1);
-  });
-});
-
-describe('ConsensusResult Interface', () => {
-  test('should create valid ConsensusResult object', () => {
-    const result: ConsensusResult = {
-      proposalId: 'proposal-001',
-      algorithm: ConsensusAlgorithm.MAJORITY_VOTE,
-      winningOption: 'option-a',
-      confidence: 0.75,
-      votes: [],
-      agreementRatio: 0.8,
-      dissentingOpinions: [],
-      metadata: {
-        rounds: 1,
-        totalVotingTimeMs: 1000,
-        convergenceRate: 0.9,
-      },
-    };
-
-    assert.ok(result.agreementRatio >= 0 && result.agreementRatio <= 1);
-    assert.ok(result.metadata.rounds > 0);
-  });
-});
-
-describe('Conflict Interface', () => {
-  test('should create valid Conflict object', () => {
-    const conflict: Conflict = {
-      id: 'conflict-001',
-      type: 'disagreement',
-      description: 'Agents disagree on approach',
-      involvedAgents: ['agent-001', 'agent-002'],
-      conflictingPositions: [
-        {
-          agentId: 'agent-001',
-          position: 'approach-a',
-          evidence: ['evidence-1'],
-          confidence: 0.8,
-        },
-        {
-          agentId: 'agent-002',
-          position: 'approach-b',
-          evidence: ['evidence-2'],
-          confidence: 0.75,
-        },
-      ],
-      status: ConflictStatus.DETECTED,
-      resolution: null,
-      metadata: {
-        createdAt: new Date(),
-      },
-    };
-
-    assert.ok(Object.values(ConflictStatus).includes(conflict.status));
-    assert.strictEqual(conflict.involvedAgents.length, 2);
-  });
-
-  test('should handle resolved conflict', () => {
-    const conflict: Conflict = {
-      id: 'conflict-002',
-      type: 'resource-contention',
-      description: 'Resource allocation dispute',
-      involvedAgents: ['agent-001', 'agent-002'],
-      conflictingPositions: [],
-      status: ConflictStatus.RESOLVED,
-      resolution: {
-        strategy: ConflictResolutionStrategy.COMPROMISE,
-        result: 'compromise',
-        confidence: 0.8,
-        reasoning: 'Balanced approach',
-      },
-      metadata: {
-        createdAt: new Date(),
-        resolvedAt: new Date(),
-        resolutionStrategy: ConflictResolutionStrategy.COMPROMISE,
-      },
-    };
-
-    assert.strictEqual(conflict.status, 'resolved');
-    assert.ok(conflict.metadata.resolvedAt instanceof Date);
-  });
-});