cognitive-core 0.2.4 → 0.3.1

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

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