cognitive-core 0.2.4 → 0.3.1

package/tests/learning/team-meta-learner.test.ts

@@ -1,618 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  TeamMetaLearner,
-  createTeamMetaLearner,
-} from '../../src/learning/team-meta-learner.js';
-import type { TeamExperienceMemory } from '../../src/memory/team-experience.js';
-import { buildTeamTrajectory } from '../../src/types/team-trajectory.js';
-import { createTeamMetaObservation, createTeamMetaStrategy } from '../../src/types/team-meta.js';
-import type {
-  TeamTrajectory,
-  TeamOutcome,
-  TeamMetaObservation,
-  TeamMetaStrategy,
-  TeamTrajectoryInput,
-  InteractionTag,
-} from '../../src/types/index.js';
-import { createTask, createStep, successOutcome, failureOutcome, createTrajectory } from '../../src/types/index.js';
-import type { TeamRecommendation, TeamRecommendationInput } from '../../src/search/team-router.js';
-
-function makeSampleTrajectory(
-  overrides?: Partial<TeamTrajectoryInput>
-): TeamTrajectory {
-  return buildTeamTrajectory({
-    objective: 'Implement authentication',
-    domain: 'web',
-    complexity: 'moderate',
-    teamName: 'test-team',
-    templateName: 'wave',
-    topologyType: 'wave',
-    enforcement: 'permissive',
-    memberTrajectories: [
-      {
-        agentId: 'planner-1',
-        role: 'planner',
-        trajectory: createTrajectory({
-          task: createTask({ domain: 'web', description: 'plan auth' }),
-          steps: [
-            createStep({ action: 'delegate task', observation: 'delegated', metadata: { interactionTag: { interactionId: 'int-1', interactionType: 'delegation', counterpartAgentId: 'executor-1', stepRole: 'source' } as InteractionTag } }),
-          ],
-          outcome: successOutcome('planned'),
-          agentId: 'planner-1',
-          totalTokens: 10000,
-        }),
-      },
-      {
-        agentId: 'executor-1',
-        role: 'executor',
-        trajectory: createTrajectory({
-          task: createTask({ domain: 'web', description: 'implement auth' }),
-          steps: [
-            createStep({ action: 'receive task', observation: 'received', metadata: { interactionTag: { interactionId: 'int-1', interactionType: 'delegation', counterpartAgentId: 'planner-1', stepRole: 'target' } as InteractionTag } }),
-            createStep({ action: 'implement auth', observation: 'done' }),
-          ],
-          outcome: successOutcome('implemented'),
-          agentId: 'executor-1',
-          totalTokens: 30000,
-        }),
-      },
-    ],
-    outcome: {
-      success: true,
-      partialScore: 0.9,
-      quality: 'good',
-      totalLlmCalls: 25,
-      totalTokens: 50000,
-      totalWallTimeSeconds: 120,
-    },
-    ...overrides,
-  });
-}
-
-function createMockMemory(): TeamExperienceMemory {
-  return {
-    recordMetaObservation: vi.fn().mockResolvedValue(undefined),
-    getMetaObservations: vi.fn().mockResolvedValue([]),
-    storeMetaStrategy: vi.fn().mockResolvedValue(undefined),
-    getMetaStrategies: vi.fn().mockResolvedValue([]),
-    getMatchingMetaStrategies: vi.fn().mockResolvedValue([]),
-  } as unknown as TeamExperienceMemory;
-}
-
-describe('TeamMetaLearner', () => {
-  let mockMemory: TeamExperienceMemory;
-
-  beforeEach(() => {
-    mockMemory = createMockMemory();
-  });
-
-  it('should create via factory function', () => {
-    const learner = createTeamMetaLearner(mockMemory);
-    expect(learner).toBeInstanceOf(TeamMetaLearner);
-  });
-
-  describe('generateReflection', () => {
-    it('should produce meta-observation from successful trajectory', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      const trajectory = makeSampleTrajectory();
-
-      const obs = await learner.generateReflection(trajectory);
-
-      expect(obs.teamTrajectoryId).toBe(trajectory.id);
-      expect(obs.outcome.success).toBe(true);
-      expect(obs.outcome.quality).toBe('good');
-      expect(obs.compositionEffectiveness.teamSizeAssessment).toBe('right-sized');
-      expect(obs.compositionEffectiveness.redundantRoles).toHaveLength(0);
-    });
-
-    it('should store meta-observation in memory', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      await learner.generateReflection(makeSampleTrajectory());
-
-      expect(mockMemory.recordMetaObservation).toHaveBeenCalledTimes(1);
-    });
-
-    it('should detect redundant roles', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      const trajectory = buildTeamTrajectory({
-        objective: 'Implement authentication',
-        domain: 'web',
-        complexity: 'moderate',
-        teamName: 'test-team',
-        templateName: 'wave',
-        topologyType: 'wave',
-        enforcement: 'permissive',
-        memberTrajectories: [
-          {
-            agentId: 'planner-1',
-            role: 'planner',
-            trajectory: createTrajectory({
-              task: createTask({ domain: 'web', description: 'plan' }),
-              steps: [createStep({ action: 'plan', observation: 'done' })],
-              outcome: successOutcome('planned'),
-              agentId: 'planner-1',
-              totalTokens: 10000,
-            }),
-          },
-          {
-            agentId: 'executor-1',
-            role: 'executor',
-            trajectory: createTrajectory({
-              task: createTask({ domain: 'web', description: 'execute' }),
-              steps: [createStep({ action: 'execute', observation: 'done' })],
-              outcome: successOutcome('executed'),
-              agentId: 'executor-1',
-              totalTokens: 30000,
-            }),
-          },
-          {
-            agentId: 'reviewer-1',
-            role: 'reviewer',
-            trajectory: createTrajectory({
-              task: createTask({ domain: 'web', description: 'review' }),
-              steps: [],
-              outcome: successOutcome('nothing'),
-              agentId: 'reviewer-1',
-              totalTokens: 200,
-            }),
-          },
-        ],
-        outcome: {
-          success: true,
-          partialScore: 0.9,
-          quality: 'good',
-          totalLlmCalls: 25,
-          totalTokens: 50000,
-          totalWallTimeSeconds: 120,
-        },
-      });
-
-      const obs = await learner.generateReflection(trajectory);
-
-      expect(obs.compositionEffectiveness.redundantRoles).toContain('reviewer');
-      expect(obs.compositionEffectiveness.teamSizeAssessment).toBe('too-large');
-    });
-
-    it('should detect team too small from re-delegation', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      const trajectory = makeSampleTrajectory({
-        outcome: { success: false, partialScore: 0.3, quality: 'poor', totalLlmCalls: 25, totalTokens: 50000, totalWallTimeSeconds: 120 },
-      });
-      // Manually set re-delegation count (derived flat metric)
-      (trajectory as any).metrics.reDelegationCount = 3;
-
-      const obs = await learner.generateReflection(trajectory);
-
-      expect(obs.compositionEffectiveness.teamSizeAssessment).toBe('too-small');
-      expect(obs.lessons.whatFailed.length).toBeGreaterThan(0);
-    });
-
-    it('should detect high coordination overhead', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      const trajectory = makeSampleTrajectory();
-      // Manually set high coordination overhead (derived flat metric)
-      (trajectory as any).metrics.coordinationOverheadRatio = 0.55;
-
-      const obs = await learner.generateReflection(trajectory);
-
-      expect(obs.coordinationEffectiveness.enforcementAssessment).toBe('too-strict');
-      expect(obs.lessons.coordinationSuggestions.length).toBeGreaterThan(0);
-    });
-
-    it('should record formation reasoning when recommendation provided', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      const trajectory = makeSampleTrajectory();
-
-      const recommendation = {
-        playbook: { id: 'pb-1' },
-        confidence: 0.8,
-        reasoning: 'Matched wave-web-team',
-      } as unknown as import('../../src/search/team-router.js').TeamRecommendation;
-
-      const obs = await learner.generateReflection(trajectory, recommendation);
-
-      expect(obs.formation.playbookUsed).toBe('pb-1');
-      expect(obs.formation.formationMethod).toBe('playbook');
-      expect(obs.formation.confidence).toBe(0.8);
-    });
-
-    it('should identify hindering topology for failed teams', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      const trajectory = makeSampleTrajectory({
-        outcome: { success: false, partialScore: 0.2, quality: 'poor', totalLlmCalls: 25, totalTokens: 50000, totalWallTimeSeconds: 120 },
-      });
-
-      const obs = await learner.generateReflection(trajectory);
-
-      expect(obs.compositionEffectiveness.topologyAssessment).toBe('hindering');
-    });
-
-    it('should record bottleneck agents', async () => {
-      const learner = createTeamMetaLearner(mockMemory);
-      const trajectory = makeSampleTrajectory();
-
-      const obs = await learner.generateReflection(trajectory);
-
-      expect(obs.coordinationEffectiveness.bottlenecks).toContain('executor-1');
-    });
-  });
-
-  describe('learn', () => {
-    it('should return empty when not enough observations', async () => {
-      const learner = createTeamMetaLearner(mockMemory, {
-        minObservationsForStrategies: 5,
-      });
-
-      const strategies = await learner.learn();
-      expect(strategies).toHaveLength(0);
-    });
-
-    it('should generate strategies from successful topology patterns', async () => {
-      // Create observations where "wave" topology has high success
-      const observations: TeamMetaObservation[] = Array.from({ length: 6 }, (_, i) =>
-        createTeamMetaObservation({
-          teamTrajectoryId: `t-${i}`,
-          formation: {
-            formationMethod: 'manual',
-            confidence: 0.5,
-            reasoning: 'topology: wave, domain: web',
-          },
-          compositionEffectiveness: {
-            roleUtilization: { planner: 0.9, executor: 0.9 },
-            missingRoles: [],
-            redundantRoles: [],
-            teamSizeAssessment: 'right-sized',
-            topologyAssessment: 'effective',
-          },
-          coordinationEffectiveness: {
-            enforcementAssessment: 'appropriate',
-            channelEffectiveness: 'helpful',
-            bottlenecks: [],
-            coordinationOverhead: 0.2,
-          },
-          outcome: {
-            success: true,
-            quality: 'good',
-            speedupEstimate: 1.5,
-            costEfficiency: 0.5,
-          },
-          lessons: { whatWorked: ['wave worked'], whatFailed: [], formationSuggestions: [], coordinationSuggestions: [] },
-        })
-      );
-
-      vi.mocked(mockMemory.getMetaObservations).mockResolvedValue(observations);
-      vi.mocked(mockMemory.getMetaStrategies).mockResolvedValue([]);
-
-      const learner = createTeamMetaLearner(mockMemory, {
-        minObservationsForStrategies: 3,
-      });
-
-      const strategies = await learner.learn();
-
-      // Should generate a prefer-wave strategy
-      const waveStrategy = strategies.find((s) => s.name.includes('wave'));
-      expect(waveStrategy).toBeDefined();
-      expect(waveStrategy!.adjustment.topologyBias).toBeDefined();
-      expect(waveStrategy!.adjustment.topologyBias!['wave']).toBeGreaterThan(0);
-    });
-
-    it('should generate avoid-strategy for low-success topologies', async () => {
-      const observations: TeamMetaObservation[] = Array.from({ length: 4 }, (_, i) =>
-        createTeamMetaObservation({
-          teamTrajectoryId: `t-${i}`,
-          formation: { formationMethod: 'manual', confidence: 0.5, reasoning: 'topology: hierarchical' },
-          compositionEffectiveness: {
-            roleUtilization: { planner: 0.5 },
-            missingRoles: [],
-            redundantRoles: [],
-            teamSizeAssessment: 'right-sized',
-            topologyAssessment: 'hindering',
-          },
-          coordinationEffectiveness: {
-            enforcementAssessment: 'appropriate',
-            channelEffectiveness: 'neutral',
-            bottlenecks: [],
-            coordinationOverhead: 0.3,
-          },
-          outcome: {
-            success: i === 0, // Only 1/4 successful → 25% success
-            quality: i === 0 ? 'good' : 'poor',
-            speedupEstimate: 1,
-            costEfficiency: 0.3,
-          },
-          lessons: { whatWorked: [], whatFailed: ['hierarchical failed'], formationSuggestions: [], coordinationSuggestions: [] },
-        })
-      );
-
-      vi.mocked(mockMemory.getMetaObservations).mockResolvedValue(observations);
-      vi.mocked(mockMemory.getMetaStrategies).mockResolvedValue([]);
-
-      const learner = createTeamMetaLearner(mockMemory, {
-        minObservationsForStrategies: 3,
-      });
-
-      const strategies = await learner.learn();
-
-      const avoidStrategy = strategies.find((s) => s.name.includes('avoid'));
-      expect(avoidStrategy).toBeDefined();
-      expect(avoidStrategy!.adjustment.topologyBias!['hierarchical']).toBeLessThan(0);
-    });
-
-    it('should generate reduce-team-size strategy when frequently too large', async () => {
-      const observations: TeamMetaObservation[] = Array.from({ length: 6 }, (_, i) =>
-        createTeamMetaObservation({
-          teamTrajectoryId: `t-${i}`,
-          formation: { formationMethod: 'manual', confidence: 0.5, reasoning: 'no topology specified' },
-          compositionEffectiveness: {
-            roleUtilization: { planner: 0.9 },
-            missingRoles: [],
-            redundantRoles: i < 4 ? ['reviewer'] : [],
-            teamSizeAssessment: i < 4 ? 'too-large' : 'right-sized',
-            topologyAssessment: 'neutral',
-          },
-          coordinationEffectiveness: {
-            enforcementAssessment: 'appropriate',
-            channelEffectiveness: 'neutral',
-            bottlenecks: [],
-            coordinationOverhead: 0.2,
-          },
-          outcome: { success: true, quality: 'good', speedupEstimate: 1.5, costEfficiency: 0.5 },
-          lessons: { whatWorked: [], whatFailed: [], formationSuggestions: [], coordinationSuggestions: [] },
-        })
-      );
-
-      vi.mocked(mockMemory.getMetaObservations).mockResolvedValue(observations);
-      vi.mocked(mockMemory.getMetaStrategies).mockResolvedValue([]);
-
-      const learner = createTeamMetaLearner(mockMemory, {
-        minObservationsForStrategies: 3,
-      });
-
-      const strategies = await learner.learn();
-
-      const sizeStrategy = strategies.find((s) => s.name.includes('reduce-team-size'));
-      expect(sizeStrategy).toBeDefined();
-      expect(sizeStrategy!.adjustment.teamSizeAdjustment).toBe('decrease');
-    });
-
-    it('should generate reduce-overhead strategy when coordination overhead is high', async () => {
-      const observations: TeamMetaObservation[] = Array.from({ length: 6 }, (_, i) =>
-        createTeamMetaObservation({
-          teamTrajectoryId: `t-${i}`,
-          formation: { formationMethod: 'manual', confidence: 0.5, reasoning: 'no topology' },
-          compositionEffectiveness: {
-            roleUtilization: {},
-            missingRoles: [],
-            redundantRoles: [],
-            teamSizeAssessment: 'right-sized',
-            topologyAssessment: 'neutral',
-          },
-          coordinationEffectiveness: {
-            enforcementAssessment: 'too-strict',
-            channelEffectiveness: 'noisy',
-            bottlenecks: [],
-            coordinationOverhead: 0.6, // High
-          },
-          outcome: { success: true, quality: 'acceptable', speedupEstimate: 1, costEfficiency: 0.3 },
-          lessons: { whatWorked: [], whatFailed: [], formationSuggestions: [], coordinationSuggestions: [] },
-        })
-      );
-
-      vi.mocked(mockMemory.getMetaObservations).mockResolvedValue(observations);
-      vi.mocked(mockMemory.getMetaStrategies).mockResolvedValue([]);
-
-      const learner = createTeamMetaLearner(mockMemory, {
-        minObservationsForStrategies: 3,
-      });
-
-      const strategies = await learner.learn();
-
-      const overheadStrategy = strategies.find((s) => s.name.includes('overhead'));
-      expect(overheadStrategy).toBeDefined();
-      expect(overheadStrategy!.adjustment.enforcementBias).toBe('permissive');
-    });
-
-    it('should not duplicate existing strategies', async () => {
-      const observations: TeamMetaObservation[] = Array.from({ length: 6 }, (_, i) =>
-        createTeamMetaObservation({
-          teamTrajectoryId: `t-${i}`,
-          formation: { formationMethod: 'manual', confidence: 0.5, reasoning: 'topology: wave' },
-          compositionEffectiveness: {
-            roleUtilization: {},
-            missingRoles: [],
-            redundantRoles: [],
-            teamSizeAssessment: 'right-sized',
-            topologyAssessment: 'effective',
-          },
-          coordinationEffectiveness: {
-            enforcementAssessment: 'appropriate',
-            channelEffectiveness: 'helpful',
-            bottlenecks: [],
-            coordinationOverhead: 0.2,
-          },
-          outcome: { success: true, quality: 'good', speedupEstimate: 1.5, costEfficiency: 0.5 },
-          lessons: { whatWorked: [], whatFailed: [], formationSuggestions: [], coordinationSuggestions: [] },
-        })
-      );
-
-      vi.mocked(mockMemory.getMetaObservations).mockResolvedValue(observations);
-      vi.mocked(mockMemory.getMetaStrategies).mockResolvedValue([
-        createTeamMetaStrategy({
-          name: 'prefer-wave-high-success',
-          condition: { taskCharacteristics: [], resourceConstraints: [], domains: [] },
-          adjustment: { teamSizeAdjustment: 'maintain', roleAdjustments: [], coordinationHints: [] },
-        }),
-      ]);
-
-      const learner = createTeamMetaLearner(mockMemory, {
-        minObservationsForStrategies: 3,
-      });
-
-      await learner.learn();
-
-      // Should not store a duplicate prefer-wave-high-success
-      const storeCalls = vi.mocked(mockMemory.storeMetaStrategy).mock.calls;
-      const waveStrategies = storeCalls.filter(
-        ([s]) => s.name === 'prefer-wave-high-success'
-      );
-      expect(waveStrategies).toHaveLength(0);
-    });
-  });
-
-  describe('adjustRecommendation', () => {
-    it('should return unchanged recommendation when no strategies match', async () => {
-      vi.mocked(mockMemory.getMatchingMetaStrategies).mockResolvedValue([]);
-
-      const learner = createTeamMetaLearner(mockMemory);
-
-      const rec = {
-        composition: { topology: 'wave' as const, roles: [], spawnRules: {}, enforcement: 'permissive' as const },
-        coordination: { executionModel: 'wave-parallel' as const, channels: [], interactionPatterns: [], delegationStrategy: 'auto' },
-        rolePlaybooks: [],
-        confidence: 0.5,
-        reasoning: 'Base reasoning',
-        appliedMetaStrategies: [],
-        asTeamYaml: () => '',
-      } as TeamRecommendation;
-
-      const input: TeamRecommendationInput = {
-        description: 'Implement feature',
-        domain: 'web',
-        complexity: 'moderate',
-      };
-
-      const adjusted = await learner.adjustRecommendation(rec, input);
-      expect(adjusted.reasoning).toBe('Base reasoning');
-      expect(adjusted.appliedMetaStrategies).toHaveLength(0);
-    });
-
-    it('should apply enforcement bias from strategy', async () => {
-      const strategy = createTeamMetaStrategy({
-        name: 'reduce-overhead',
-        condition: { taskCharacteristics: [], resourceConstraints: [], domains: ['web'] },
-        adjustment: {
-          teamSizeAdjustment: 'maintain',
-          enforcementBias: 'permissive',
-          roleAdjustments: [],
-          coordinationHints: ['Use permissive enforcement'],
-        },
-      });
-
-      vi.mocked(mockMemory.getMatchingMetaStrategies).mockResolvedValue([strategy]);
-
-      const learner = createTeamMetaLearner(mockMemory);
-
-      const rec = {
-        composition: { topology: 'wave' as const, roles: [], spawnRules: {}, enforcement: 'strict' as const },
-        coordination: { executionModel: 'wave-parallel' as const, channels: [], interactionPatterns: [], delegationStrategy: 'auto' },
-        rolePlaybooks: [],
-        confidence: 0.5,
-        reasoning: 'Base',
-        appliedMetaStrategies: [],
-        asTeamYaml: () => '',
-      } as TeamRecommendation;
-
-      const adjusted = await learner.adjustRecommendation(rec, {
-        description: 'Implement feature',
-        domain: 'web',
-        complexity: 'moderate',
-      });
-
-      expect(adjusted.composition.enforcement).toBe('permissive');
-      expect(adjusted.appliedMetaStrategies).toContain('reduce-overhead');
-    });
-
-    it('should apply topology bias and potentially switch topology', async () => {
-      const strategy = createTeamMetaStrategy({
-        name: 'prefer-flat',
-        condition: { taskCharacteristics: [], resourceConstraints: [], domains: ['web'] },
-        adjustment: {
-          topologyBias: { flat: 0.5, wave: -0.2 },
-          teamSizeAdjustment: 'maintain',
-          roleAdjustments: [],
-          coordinationHints: [],
-        },
-      });
-
-      vi.mocked(mockMemory.getMatchingMetaStrategies).mockResolvedValue([strategy]);
-
-      const learner = createTeamMetaLearner(mockMemory);
-
-      const rec = {
-        composition: { topology: 'wave' as const, roles: [], spawnRules: {}, enforcement: 'permissive' as const },
-        coordination: { executionModel: 'wave-parallel' as const, channels: [], interactionPatterns: [], delegationStrategy: 'auto' },
-        rolePlaybooks: [],
-        confidence: 0.4, // Low enough that topology switch can occur
-        reasoning: 'Base',
-        appliedMetaStrategies: [],
-        asTeamYaml: () => '',
-      } as TeamRecommendation;
-
-      const adjusted = await learner.adjustRecommendation(rec, {
-        description: 'Implement feature',
-        domain: 'web',
-        complexity: 'moderate',
-      });
-
-      expect(adjusted.composition.topology).toBe('flat');
-      expect(adjusted.reasoning).toContain('flat topology');
-    });
-
-    it('should clamp confidence to valid range', async () => {
-      const strategy = createTeamMetaStrategy({
-        name: 'extreme-boost',
-        condition: { taskCharacteristics: [], resourceConstraints: [], domains: ['web'] },
-        adjustment: {
-          topologyBias: { wave: 5.0 }, // Very high bias
-          teamSizeAdjustment: 'maintain',
-          roleAdjustments: [],
-          coordinationHints: [],
-        },
-      });
-
-      vi.mocked(mockMemory.getMatchingMetaStrategies).mockResolvedValue([strategy]);
-
-      const learner = createTeamMetaLearner(mockMemory);
-
-      const rec = {
-        composition: { topology: 'wave' as const, roles: [], spawnRules: {}, enforcement: 'permissive' as const },
-        coordination: { executionModel: 'wave-parallel' as const, channels: [], interactionPatterns: [], delegationStrategy: 'auto' },
-        rolePlaybooks: [],
-        confidence: 0.9,
-        reasoning: 'Base',
-        appliedMetaStrategies: [],
-        asTeamYaml: () => '',
-      } as TeamRecommendation;
-
-      const adjusted = await learner.adjustRecommendation(rec, {
-        description: 'Implement feature',
-        domain: 'web',
-        complexity: 'moderate',
-      });
-
-      expect(adjusted.confidence).toBeLessThanOrEqual(0.95);
-      expect(adjusted.confidence).toBeGreaterThanOrEqual(0.1);
-    });
-  });
-
-  describe('periodic strategy generation', () => {
-    it('should trigger learn() at strategyGenerationInterval', async () => {
-      vi.mocked(mockMemory.getMetaObservations).mockResolvedValue([]);
-
-      const learner = createTeamMetaLearner(mockMemory, {
-        strategyGenerationInterval: 3,
-      });
-
-      // Process 3 trajectories → should trigger learn on the 3rd
-      const t1 = makeSampleTrajectory(); (t1 as any).id = 't1';
-      const t2 = makeSampleTrajectory(); (t2 as any).id = 't2';
-      const t3 = makeSampleTrajectory(); (t3 as any).id = 't3';
-      await learner.generateReflection(t1);
-      await learner.generateReflection(t2);
-      await learner.generateReflection(t3);
-
-      // getMetaObservations is called by learn()
-      expect(mockMemory.getMetaObservations).toHaveBeenCalled();
-    });
-  });
-});