cognitive-core 0.0.2 → 0.1.2

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

@@ -0,0 +1,557 @@
+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);
+  });
+});