cognitive-core 0.1.0 → 0.2.0

package/tests/workspace/templates/team-playbook-extraction.test.ts

@@ -0,0 +1,341 @@
+import { describe, it, expect } from 'vitest';
+import { teamPlaybookExtractionTemplate } from '../../../src/workspace/templates/team-playbook-extraction.js';
+import type { TeamPlaybookExtractionInput } from '../../../src/workspace/templates/team-playbook-extraction.js';
+import { buildTeamTrajectory } from '../../../src/types/team-trajectory.js';
+import type {
+  TeamTrajectory,
+  TeamTrajectoryInput,
+  InteractionTag,
+} from '../../../src/types/team-trajectory.js';
+import type { TeamAnalysisResult } from '../../../src/memory/team-experience.js';
+import { createTask, createStep, successOutcome, createTrajectory } from '../../../src/types/index.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 to executor', 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 delegation', observation: 'received from planner', metadata: { interactionTag: { interactionId: 'int-1', interactionType: 'delegation', counterpartAgentId: 'planner-1', stepRole: 'target' } as InteractionTag } }),
+            createStep({ action: 'implement auth module', 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 makeSampleAnalysis(trajectoryId: string, overrides?: Partial<TeamAnalysisResult>): TeamAnalysisResult {
+  return {
+    teamTrajectoryId: trajectoryId,
+    agentCredits: [
+      { agentId: 'planner-1', role: 'planner', contributionScore: 1, assessment: 'Excellent', roleAssessment: 'essential' },
+      { agentId: 'executor-1', role: 'executor', contributionScore: 1, assessment: 'Good', roleAssessment: 'essential' },
+    ],
+    interactionCredits: [
+      { interactionId: 'i-0', fromRole: 'planner', toRole: 'executor', value: 'helpful', creditScore: 0.5, reasoning: 'Delegation', necessity: 'useful' },
+    ],
+    coordinationAssessment: {
+      quality: 'good',
+      observedPatterns: [],
+      observedAntiPatterns: [],
+      narrative: 'Team coordinated well',
+    },
+    roleLessons: [
+      { role: 'planner', strengths: ['Completed assigned tasks'], improvements: [] },
+      { role: 'executor', strengths: ['Completed assigned tasks'], improvements: [] },
+    ],
+    teamLessons: [],
+    metaObservation: {
+      formationEffective: true,
+      teamSizeAssessment: 'right-sized',
+      topologyAssessment: 'effective',
+      formationSuggestions: [],
+      coordinationSuggestions: [],
+    },
+    analysisMetrics: { analysisTokens: 0, analysisTimeMs: 0, analysisToolCalls: 0 },
+    ...overrides,
+  };
+}
+
+describe('teamPlaybookExtractionTemplate', () => {
+  describe('assessComplexity', () => {
+    it('should return heuristic for small batches', () => {
+      const input: TeamPlaybookExtractionInput = {
+        analyses: [
+          { teamTrajectory: makeSampleTrajectory(), analysis: makeSampleAnalysis('a') },
+        ],
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      expect(teamPlaybookExtractionTemplate.assessComplexity(input)).toBe('heuristic');
+    });
+
+    it('should return standard for medium batches', () => {
+      const analyses = Array.from({ length: 5 }, () => {
+        const t = makeSampleTrajectory();
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+      const input: TeamPlaybookExtractionInput = {
+        analyses,
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      expect(teamPlaybookExtractionTemplate.assessComplexity(input)).toBe('standard');
+    });
+
+    it('should return thorough for large batches', () => {
+      const analyses = Array.from({ length: 12 }, () => {
+        const t = makeSampleTrajectory();
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+      const input: TeamPlaybookExtractionInput = {
+        analyses,
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      expect(teamPlaybookExtractionTemplate.assessComplexity(input)).toBe('thorough');
+    });
+  });
+
+  describe('heuristicFallback', () => {
+    it('should extract team playbook from multiple successful same-topology runs', async () => {
+      const analyses = Array.from({ length: 3 }, () => {
+        const t = makeSampleTrajectory();
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+      const input: TeamPlaybookExtractionInput = {
+        analyses,
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+
+      expect(result.newTeamPlaybooks).toHaveLength(1);
+      expect(result.newTeamPlaybooks[0].composition.topology).toBe('wave');
+      expect(result.newTeamPlaybooks[0].applicability.domains).toContain('web');
+    });
+
+    it('should not create team playbook without enough successful runs', async () => {
+      const t1 = makeSampleTrajectory({
+        outcome: { success: false, partialScore: 0.2, quality: 'poor', totalLlmCalls: 25, totalTokens: 50000, totalWallTimeSeconds: 120 },
+      });
+      const t2 = makeSampleTrajectory();
+
+      const input: TeamPlaybookExtractionInput = {
+        analyses: [
+          { teamTrajectory: t1, analysis: makeSampleAnalysis(t1.id) },
+          { teamTrajectory: t2, analysis: makeSampleAnalysis(t2.id) },
+        ],
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+      // Only 1 successful, need 2+
+      expect(result.newTeamPlaybooks).toHaveLength(0);
+    });
+
+    it('should extract role playbooks from repeated successful role lessons', async () => {
+      const analyses = Array.from({ length: 3 }, () => {
+        const t = makeSampleTrajectory();
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+      const input: TeamPlaybookExtractionInput = {
+        analyses,
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+
+      // Both planner and executor appear 3 times each → role playbooks
+      expect(result.newRolePlaybooks.length).toBeGreaterThanOrEqual(2);
+      const roles = result.newRolePlaybooks.map((p) => p.role);
+      expect(roles).toContain('planner');
+      expect(roles).toContain('executor');
+    });
+
+    it('should not duplicate existing team playbooks', async () => {
+      const analyses = Array.from({ length: 3 }, () => {
+        const t = makeSampleTrajectory();
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+
+      // Create existing playbook with same topology and domain
+      const { createTeamPlaybook } = await import('../../../src/types/team-playbook.js');
+      const existing = createTeamPlaybook({
+        name: 'existing-wave-web',
+        applicability: {
+          taskTypes: ['moderate'],
+          teamSizeRange: { min: 2, max: 4 },
+          complexityLevels: ['moderate'],
+          domains: ['web'],
+          antiPatterns: [],
+        },
+        composition: {
+          topology: 'wave',
+          roles: [],
+          spawnRules: {},
+          enforcement: 'permissive',
+        },
+        coordination: {
+          executionModel: 'wave-parallel',
+          channels: [],
+          interactionPatterns: [],
+          delegationStrategy: 'auto',
+        },
+        confidence: 0.7,
+      });
+
+      const input: TeamPlaybookExtractionInput = {
+        analyses,
+        existingTeamPlaybooks: [existing],
+        existingRolePlaybooks: [],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+
+      // Should not create a duplicate team playbook (same topology + overlapping domain)
+      expect(result.newTeamPlaybooks).toHaveLength(0);
+    });
+
+    it('should not duplicate existing role playbooks', async () => {
+      const analyses = Array.from({ length: 3 }, () => {
+        const t = makeSampleTrajectory();
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+
+      const { createRolePlaybook } = await import('../../../src/types/team-playbook.js');
+      const existingRole = createRolePlaybook({
+        name: 'existing-planner',
+        role: 'planner',
+        teamContext: { topologies: ['wave'], teamSizeRange: { min: 2, max: 10 }, taskTypes: [], domains: [] },
+        guidance: { responsibilities: [], interactionGuidance: [], decisionFrameworks: [], antiPatterns: [] },
+        confidence: 0.7,
+      });
+
+      const input: TeamPlaybookExtractionInput = {
+        analyses,
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [existingRole],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+
+      const plannerPlaybooks = result.newRolePlaybooks.filter((p) => p.role === 'planner');
+      expect(plannerPlaybooks).toHaveLength(0);
+      // executor should still be created
+      const executorPlaybooks = result.newRolePlaybooks.filter((p) => p.role === 'executor');
+      expect(executorPlaybooks).toHaveLength(1);
+    });
+
+    it('should return empty meta-strategies and updates from heuristic', async () => {
+      const analyses = Array.from({ length: 3 }, () => {
+        const t = makeSampleTrajectory();
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+      const input: TeamPlaybookExtractionInput = {
+        analyses,
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+
+      expect(result.newMetaStrategies).toHaveLength(0);
+      expect(result.teamPlaybookUpdates).toHaveLength(0);
+      expect(result.rolePlaybookUpdates).toHaveLength(0);
+    });
+
+    it('should handle mixed topologies', async () => {
+      const waveTrajectories = Array.from({ length: 2 }, () => {
+        const t = makeSampleTrajectory({ topologyType: 'wave' as const });
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+      const flatTrajectories = Array.from({ length: 2 }, () => {
+        const t = makeSampleTrajectory({ topologyType: 'flat' as const });
+        return { teamTrajectory: t, analysis: makeSampleAnalysis(t.id) };
+      });
+
+      const input: TeamPlaybookExtractionInput = {
+        analyses: [...waveTrajectories, ...flatTrajectories],
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+
+      // Should create playbooks for both topologies
+      expect(result.newTeamPlaybooks).toHaveLength(2);
+      const topologies = result.newTeamPlaybooks.map((p) => p.composition.topology);
+      expect(topologies).toContain('wave');
+      expect(topologies).toContain('flat');
+    });
+
+    it('should handle empty analyses', async () => {
+      const input: TeamPlaybookExtractionInput = {
+        analyses: [],
+        existingTeamPlaybooks: [],
+        existingRolePlaybooks: [],
+      };
+
+      const result = await teamPlaybookExtractionTemplate.heuristicFallback!(input);
+
+      expect(result.newTeamPlaybooks).toHaveLength(0);
+      expect(result.newRolePlaybooks).toHaveLength(0);
+    });
+  });
+
+  describe('template metadata', () => {
+    it('should have correct task type and domain', () => {
+      expect(teamPlaybookExtractionTemplate.taskType).toBe('team-playbook-extraction');
+      expect(teamPlaybookExtractionTemplate.domain).toBe('team-playbook-extraction');
+    });
+
+    it('should require extraction.json output', () => {
+      expect(teamPlaybookExtractionTemplate.outputConfig.files).toHaveLength(1);
+      expect(teamPlaybookExtractionTemplate.outputConfig.files[0].path).toBe('extraction.json');
+      expect(teamPlaybookExtractionTemplate.outputConfig.files[0].required).toBe(true);
+    });
+  });
+});