cognitive-core 0.2.4 → 0.3.1

package/tests/types/team-trajectory.test.ts

@@ -1,557 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  createTeamTrajectory,
-  isTeamSuccessful,
-  buildInteractionGraph,
-  buildTeamTrajectory,
-  type TeamTrajectory,
-  type TeamEvent,
-  type InteractionEdge,
-  type CoordinationMetrics,
-  type MemberOutcome,
-  type TeamOutcome,
-  type MemberTrajectoryInput,
-  type TeamTrajectoryInput,
-  type InteractionTag,
-} from '../../src/types/team-trajectory.js';
-import { createTask, createStep, successOutcome, failureOutcome, createTrajectory } from '../../src/types/index.js';
-
-describe('TeamTrajectory', () => {
-  const sampleMetrics: CoordinationMetrics = {
-    totalWallTimeSeconds: 120,
-    timeToFirstOutputSeconds: 30,
-    coordinationOverheadRatio: 0.25,
-    bottleneckAgent: 'planner-1',
-    communicationCycles: 4,
-    maxDependencyDepth: 2,
-    reDelegationCount: 0,
-    parallelismRatio: 0.65,
-  };
-
-  const sampleOutcome: TeamOutcome = {
-    success: true,
-    partialScore: 0.9,
-    quality: 'good',
-    totalLlmCalls: 25,
-    totalTokens: 50000,
-    totalWallTimeSeconds: 120,
-  };
-
-  const sampleEvents: TeamEvent[] = [
-    {
-      timestamp: new Date('2026-01-01T00:00:00Z'),
-      type: 'agent_spawned',
-      agentId: 'planner-1',
-      role: 'planner',
-      payload: {},
-    },
-    {
-      timestamp: new Date('2026-01-01T00:00:01Z'),
-      type: 'task_delegated',
-      agentId: 'planner-1',
-      role: 'planner',
-      payload: { targetAgent: 'executor-1', task: 'implement auth' },
-    },
-    {
-      timestamp: new Date('2026-01-01T00:01:00Z'),
-      type: 'task_completed',
-      agentId: 'executor-1',
-      role: 'executor',
-      payload: { task: 'implement auth' },
-    },
-  ];
-
-  const sampleInteractions: InteractionEdge[] = [
-    {
-      from: 'planner',
-      to: 'executor',
-      count: 3,
-      types: ['task_delegated', 'message_sent'],
-      avgResponseLatencyMs: 500,
-    },
-    {
-      from: 'executor',
-      to: 'verifier',
-      count: 2,
-      types: ['signal_emitted'],
-    },
-  ];
-
-  const sampleMemberOutcomes: MemberOutcome[] = [
-    {
-      agentId: 'planner-1',
-      role: 'planner',
-      tasksAssigned: 1,
-      tasksCompleted: 1,
-      tasksFailed: 0,
-      llmCalls: 5,
-      totalTokens: 10000,
-    },
-    {
-      agentId: 'executor-1',
-      role: 'executor',
-      tasksAssigned: 2,
-      tasksCompleted: 2,
-      tasksFailed: 0,
-      llmCalls: 15,
-      totalTokens: 30000,
-      trajectoryId: 'traj-exec-1',
-    },
-  ];
-
-  it('should create a team trajectory with all fields', () => {
-    const trajectory = createTeamTrajectory({
-      teamName: 'feature-team',
-      templateName: 'wave-parallel',
-      topologyType: 'wave',
-      roles: ['planner', 'executor', 'verifier'],
-      teamSize: 3,
-      enforcement: 'permissive',
-      objective: 'Implement OAuth2 authentication',
-      domain: 'web',
-      complexity: 'complex',
-      events: sampleEvents,
-      interactionGraph: sampleInteractions,
-      metrics: sampleMetrics,
-      memberOutcomes: sampleMemberOutcomes,
-      outcome: sampleOutcome,
-      members: [
-        { agentId: 'planner-1', role: 'planner', trajectory: createTrajectory({
-          task: createTask({ domain: 'web', description: 'plan' }),
-          steps: [createStep({ action: 'plan', observation: 'done' })],
-          outcome: successOutcome('ok'),
-          agentId: 'planner-1',
-        }) },
-      ],
-      interactions: [],
-      graphMetrics: {
-        teamSize: 3,
-        totalSteps: 1,
-        totalInteractions: 0,
-        interactionDensity: 0,
-        maxInDegree: { agentId: '', count: 0 },
-        maxOutDegree: { agentId: '', count: 0 },
-        parallelismRatio: 0.65,
-        totalWallTimeSeconds: 120,
-        totalTokens: 50000,
-      },
-    });
-
-    expect(trajectory.id).toBeDefined();
-    expect(trajectory.teamName).toBe('feature-team');
-    expect(trajectory.templateName).toBe('wave-parallel');
-    expect(trajectory.topologyType).toBe('wave');
-    expect(trajectory.roles).toEqual(['planner', 'executor', 'verifier']);
-    expect(trajectory.teamSize).toBe(3);
-    expect(trajectory.enforcement).toBe('permissive');
-    expect(trajectory.objective).toBe('Implement OAuth2 authentication');
-    expect(trajectory.domain).toBe('web');
-    expect(trajectory.complexity).toBe('complex');
-    expect(trajectory.events).toHaveLength(3);
-    expect(trajectory.interactionGraph).toHaveLength(2);
-    expect(trajectory.metrics.parallelismRatio).toBe(0.65);
-    expect(trajectory.memberOutcomes).toHaveLength(2);
-    expect(trajectory.outcome.success).toBe(true);
-    expect(trajectory.timestamp).toBeInstanceOf(Date);
-    expect(trajectory.metadata).toEqual({});
-    expect(trajectory.members).toHaveLength(1);
-    expect(trajectory.members[0].agentId).toBe('planner-1');
-    expect(trajectory.graphMetrics.teamSize).toBe(3);
-    expect(trajectory.graphMetrics.parallelismRatio).toBe(0.65);
-    expect(trajectory.graphMetrics.totalWallTimeSeconds).toBe(120);
-    expect(trajectory.graphMetrics.totalTokens).toBe(50000);
-  });
-
-  it('should create with custom id and metadata', () => {
-    const trajectory = createTeamTrajectory({
-      id: 'team-traj-001',
-      teamName: 'test-team',
-      templateName: 'flat',
-      topologyType: 'flat',
-      roles: ['worker'],
-      teamSize: 1,
-      enforcement: 'strict',
-      objective: 'Simple task',
-      domain: 'testing',
-      complexity: 'simple',
-      events: [],
-      interactionGraph: [],
-      metrics: { ...sampleMetrics, bottleneckAgent: undefined },
-      memberOutcomes: [],
-      outcome: { ...sampleOutcome, success: false, quality: 'poor' },
-      metadata: { experiment: 'test-run-1' },
-      members: [],
-      interactions: [],
-      graphMetrics: {
-        teamSize: 1,
-        totalSteps: 0,
-        totalInteractions: 0,
-        interactionDensity: 0,
-        maxInDegree: { agentId: '', count: 0 },
-        maxOutDegree: { agentId: '', count: 0 },
-        parallelismRatio: 0,
-        totalWallTimeSeconds: 0,
-        totalTokens: 0,
-      },
-    });
-
-    expect(trajectory.id).toBe('team-traj-001');
-    expect(trajectory.metadata).toEqual({ experiment: 'test-run-1' });
-  });
-
-  it('isTeamSuccessful should return true for successful trajectory', () => {
-    const trajectory = createTeamTrajectory({
-      teamName: 't',
-      templateName: 't',
-      topologyType: 'flat',
-      roles: [],
-      teamSize: 1,
-      enforcement: 'permissive',
-      objective: 'test',
-      domain: 'test',
-      complexity: 'simple',
-      events: [],
-      interactionGraph: [],
-      metrics: sampleMetrics,
-      memberOutcomes: [],
-      outcome: sampleOutcome,
-      members: [],
-      interactions: [],
-      graphMetrics: {
-        teamSize: 1,
-        totalSteps: 0,
-        totalInteractions: 0,
-        interactionDensity: 0,
-        maxInDegree: { agentId: '', count: 0 },
-        maxOutDegree: { agentId: '', count: 0 },
-        parallelismRatio: 0,
-        totalWallTimeSeconds: 0,
-        totalTokens: 0,
-      },
-    });
-
-    expect(isTeamSuccessful(trajectory)).toBe(true);
-  });
-
-  it('isTeamSuccessful should return false for failed trajectory', () => {
-    const trajectory = createTeamTrajectory({
-      teamName: 't',
-      templateName: 't',
-      topologyType: 'flat',
-      roles: [],
-      teamSize: 1,
-      enforcement: 'permissive',
-      objective: 'test',
-      domain: 'test',
-      complexity: 'simple',
-      events: [],
-      interactionGraph: [],
-      metrics: sampleMetrics,
-      memberOutcomes: [],
-      outcome: { ...sampleOutcome, success: false },
-      members: [],
-      interactions: [],
-      graphMetrics: {
-        teamSize: 1,
-        totalSteps: 0,
-        totalInteractions: 0,
-        interactionDensity: 0,
-        maxInDegree: { agentId: '', count: 0 },
-        maxOutDegree: { agentId: '', count: 0 },
-        parallelismRatio: 0,
-        totalWallTimeSeconds: 0,
-        totalTokens: 0,
-      },
-    });
-
-    expect(isTeamSuccessful(trajectory)).toBe(false);
-  });
-
-  it('should store graph data fields', () => {
-    const trajectory = createTeamTrajectory({
-      teamName: 'graph-team',
-      templateName: 'wave',
-      topologyType: 'wave',
-      roles: ['planner', 'executor'],
-      teamSize: 2,
-      enforcement: 'permissive',
-      objective: 'test',
-      domain: 'web',
-      complexity: 'moderate',
-      events: sampleEvents,
-      interactionGraph: sampleInteractions,
-      metrics: sampleMetrics,
-      memberOutcomes: sampleMemberOutcomes,
-      outcome: sampleOutcome,
-      members: [
-        { agentId: 'planner-1', role: 'planner', trajectory: createTrajectory({
-          task: createTask({ domain: 'web', description: 'plan' }),
-          steps: [createStep({ action: 'plan', observation: 'done' })],
-          outcome: successOutcome('ok'),
-          agentId: 'planner-1',
-        }) },
-      ],
-      interactions: [{
-        id: 'int-1',
-        type: 'delegation',
-        from: { agentId: 'planner-1', role: 'planner', stepIndex: 0 },
-        to: { agentId: 'executor-1', role: 'executor', stepIndex: 0 },
-        content: 'implement auth',
-        timestamp: new Date(),
-        wasExpected: true,
-      }],
-      graphMetrics: {
-        teamSize: 2,
-        totalSteps: 5,
-        totalInteractions: 1,
-        interactionDensity: 0.2,
-        maxInDegree: { agentId: 'executor-1', count: 1 },
-        maxOutDegree: { agentId: 'planner-1', count: 1 },
-        parallelismRatio: 0.5,
-        totalWallTimeSeconds: 120,
-        totalTokens: 50000,
-      },
-    });
-
-    expect(trajectory.members).toHaveLength(1);
-    expect(trajectory.interactions).toHaveLength(1);
-    expect(trajectory.graphMetrics.totalSteps).toBe(5);
-    expect(trajectory.interactions[0].wasExpected).toBe(true);
-  });
-});
-
-// ============================================================
-// Graph Model Tests
-// ============================================================
-
-describe('buildInteractionGraph', () => {
-  function makeMemberInputs(): MemberTrajectoryInput[] {
-    const plannerSteps = [
-      createStep({
-        action: 'delegate task',
-        observation: 'delegated to executor',
-        metadata: {
-          interactionTag: {
-            interactionId: 'int-1',
-            interactionType: 'delegation',
-            counterpartAgentId: 'executor-1',
-            stepRole: 'source',
-          } satisfies InteractionTag,
-        },
-      }),
-    ];
-    const executorSteps = [
-      createStep({
-        action: 'receive task',
-        observation: 'started work',
-        metadata: {
-          interactionTag: {
-            interactionId: 'int-1',
-            interactionType: 'delegation',
-            counterpartAgentId: 'planner-1',
-            stepRole: 'target',
-          } satisfies InteractionTag,
-        },
-      }),
-      createStep({ action: 'implement', observation: 'completed' }),
-    ];
-
-    return [
-      {
-        agentId: 'planner-1',
-        role: 'planner',
-        trajectory: createTrajectory({
-          task: createTask({ domain: 'web', description: 'plan' }),
-          steps: plannerSteps,
-          outcome: successOutcome('ok'),
-          agentId: 'planner-1',
-          totalTokens: 5000,
-        }),
-      },
-      {
-        agentId: 'executor-1',
-        role: 'executor',
-        trajectory: createTrajectory({
-          task: createTask({ domain: 'web', description: 'execute' }),
-          steps: executorSteps,
-          outcome: successOutcome('implemented'),
-          agentId: 'executor-1',
-          totalTokens: 15000,
-        }),
-      },
-    ];
-  }
-
-  it('should build interaction graph from InteractionTags', () => {
-    const members = makeMemberInputs();
-    const graph = buildInteractionGraph(members);
-
-    expect(graph).toHaveLength(1);
-    expect(graph[0].from).toBe('planner');
-    expect(graph[0].to).toBe('executor');
-    expect(graph[0].count).toBe(1);
-    expect(graph[0].types).toContain('task_delegated');
-  });
-
-  it('should return empty graph when no interaction tags', () => {
-    const members: MemberTrajectoryInput[] = [{
-      agentId: 'solo-1',
-      role: 'worker',
-      trajectory: createTrajectory({
-        task: createTask({ domain: 'test', description: 'work' }),
-        steps: [createStep({ action: 'do', observation: 'done' })],
-        outcome: successOutcome('ok'),
-        agentId: 'solo-1',
-      }),
-    }];
-
-    const graph = buildInteractionGraph(members);
-    expect(graph).toHaveLength(0);
-  });
-});
-
-describe('buildTeamTrajectory', () => {
-  function makeTeamInput(): TeamTrajectoryInput {
-    const plannerSteps = [
-      createStep({
-        action: 'delegate task to executor',
-        observation: 'delegated',
-        metadata: {
-          interactionTag: {
-            interactionId: 'int-1',
-            interactionType: 'delegation',
-            counterpartAgentId: 'executor-1',
-            stepRole: 'source',
-          } satisfies InteractionTag,
-        },
-      }),
-    ];
-    const executorSteps = [
-      createStep({
-        action: 'receive delegation',
-        observation: 'received',
-        metadata: {
-          interactionTag: {
-            interactionId: 'int-1',
-            interactionType: 'delegation',
-            counterpartAgentId: 'planner-1',
-            stepRole: 'target',
-          } satisfies InteractionTag,
-        },
-      }),
-      createStep({ action: 'implement feature', observation: 'success: implemented' }),
-    ];
-
-    return {
-      objective: 'Build auth',
-      domain: 'web',
-      complexity: 'moderate',
-      teamName: 'auth-team',
-      templateName: 'hierarchical',
-      topologyType: 'hierarchical',
-      enforcement: 'permissive',
-      memberTrajectories: [
-        {
-          agentId: 'planner-1',
-          role: 'planner',
-          trajectory: createTrajectory({
-            task: createTask({ domain: 'web', description: 'plan auth' }),
-            steps: plannerSteps,
-            outcome: successOutcome('planned'),
-            agentId: 'planner-1',
-            totalTokens: 5000,
-          }),
-        },
-        {
-          agentId: 'executor-1',
-          role: 'executor',
-          trajectory: createTrajectory({
-            task: createTask({ domain: 'web', description: 'implement auth' }),
-            steps: executorSteps,
-            outcome: successOutcome('implemented'),
-            agentId: 'executor-1',
-            totalTokens: 15000,
-          }),
-        },
-      ],
-      outcome: {
-        success: true,
-        partialScore: 1.0,
-        quality: 'good' as const,
-        totalLlmCalls: 10,
-        totalTokens: 20000,
-        totalWallTimeSeconds: 60,
-      },
-    };
-  }
-
-  it('should build a TeamTrajectory with both graph and flat data', () => {
-    const input = makeTeamInput();
-    const trajectory = buildTeamTrajectory(input);
-
-    // Graph data present
-    expect(trajectory.members).toHaveLength(2);
-    expect(trajectory.members[0].agentId).toBe('planner-1');
-    expect(trajectory.members[1].agentId).toBe('executor-1');
-    expect(trajectory.interactions).toBeDefined();
-    expect(trajectory.graphMetrics).toBeDefined();
-    expect(trajectory.graphMetrics.teamSize).toBe(2);
-    expect(trajectory.graphMetrics.totalSteps).toBe(3); // 1 + 2
-  });
-
-  it('should build AgentInteractions from InteractionTags', () => {
-    const input = makeTeamInput();
-    const trajectory = buildTeamTrajectory(input);
-
-    expect(trajectory.interactions).toHaveLength(1);
-    const interaction = trajectory.interactions[0];
-    expect(interaction.type).toBe('delegation');
-    expect(interaction.from.agentId).toBe('planner-1');
-    expect(interaction.from.stepIndex).toBe(0);
-    expect(interaction.to.agentId).toBe('executor-1');
-    expect(interaction.to.stepIndex).toBe(0);
-  });
-
-  it('should mark wasExpected when expectedPatterns match', () => {
-    const input = makeTeamInput();
-    input.expectedPatterns = [{
-      name: 'plan-delegate',
-      fromRole: 'planner',
-      toRole: 'executor',
-      type: 'delegation',
-      frequency: 'once',
-    }];
-
-    const trajectory = buildTeamTrajectory(input);
-    expect(trajectory.interactions[0].wasExpected).toBe(true);
-  });
-
-  it('should mark wasExpected false when no pattern matches', () => {
-    const input = makeTeamInput();
-    input.expectedPatterns = [{
-      name: 'different-pattern',
-      fromRole: 'verifier',
-      toRole: 'executor',
-      type: 'message',
-      frequency: 'per-task',
-    }];
-
-    const trajectory = buildTeamTrajectory(input);
-    expect(trajectory.interactions[0].wasExpected).toBe(false);
-  });
-
-  it('should compute graph metrics correctly', () => {
-    const input = makeTeamInput();
-    const trajectory = buildTeamTrajectory(input);
-    const gm = trajectory.graphMetrics;
-
-    expect(gm.teamSize).toBe(2);
-    expect(gm.totalSteps).toBe(3);
-    expect(gm.totalInteractions).toBe(1);
-    expect(gm.interactionDensity).toBeCloseTo(1 / 3);
-    expect(gm.maxOutDegree.agentId).toBe('planner-1');
-    expect(gm.maxOutDegree.count).toBe(1);
-    expect(gm.maxInDegree.agentId).toBe('executor-1');
-    expect(gm.maxInDegree.count).toBe(1);
-  });
-});