cognitive-core 0.0.2 → 0.1.2

package/tests/workspace/templates/team-trajectory-analysis.test.ts

@@ -0,0 +1,417 @@
+import { describe, it, expect } from 'vitest';
+import { teamTrajectoryAnalysisTemplate } from '../../../src/workspace/templates/team-trajectory-analysis.js';
+import { createTeamTrajectoryIngester } from '../../../src/learning/team-ingester.js';
+import { buildTeamTrajectory } from '../../../src/types/team-trajectory.js';
+import type {
+  TeamTrajectory,
+  TeamOutcome,
+  TeamTrajectoryInput,
+  InteractionTag,
+} from '../../../src/types/team-trajectory.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: 'auth module complete' }),
+          ],
+          outcome: successOutcome('implemented'),
+          agentId: 'executor-1',
+          totalTokens: 30000,
+        }),
+      },
+    ],
+    outcome: {
+      success: true,
+      partialScore: 0.9,
+      quality: 'good',
+      totalLlmCalls: 25,
+      totalTokens: 50000,
+      totalWallTimeSeconds: 120,
+    },
+    ...overrides,
+  });
+}
+
+describe('teamTrajectoryAnalysisTemplate', () => {
+  describe('assessComplexity', () => {
+    it('should return heuristic for small successful teams', () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const complexity = teamTrajectoryAnalysisTemplate.assessComplexity({ ingestion });
+      expect(complexity).toBe('heuristic');
+    });
+
+    it('should return standard for failed teams with enough events', () => {
+      const manySteps = Array.from({ length: 15 }, (_, i) =>
+        createStep({ action: `step ${i}`, observation: `result ${i}` })
+      );
+      const trajectory = buildTeamTrajectory({
+        objective: 'Implement auth',
+        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: manySteps.slice(0, 8),
+              outcome: successOutcome('planned'),
+              agentId: 'planner-1',
+              totalTokens: 10000,
+            }),
+          },
+          {
+            agentId: 'executor-1',
+            role: 'executor',
+            trajectory: createTrajectory({
+              task: createTask({ domain: 'web', description: 'execute' }),
+              steps: manySteps.slice(8),
+              outcome: successOutcome('executed'),
+              agentId: 'executor-1',
+              totalTokens: 30000,
+            }),
+          },
+        ],
+        outcome: {
+          success: false,
+          partialScore: 0.2,
+          quality: 'poor',
+          totalLlmCalls: 25,
+          totalTokens: 50000,
+          totalWallTimeSeconds: 120,
+        },
+      });
+      const ingester = createTeamTrajectoryIngester();
+      const ingestion = ingester.ingest(trajectory);
+
+      const complexity = teamTrajectoryAnalysisTemplate.assessComplexity({ ingestion });
+      expect(complexity).toBe('standard');
+    });
+
+    it('should return standard for large teams', () => {
+      const members = Array.from({ length: 6 }, (_, i) => ({
+        agentId: `agent-${i}`,
+        role: `role-${i}`,
+        trajectory: createTrajectory({
+          task: createTask({ domain: 'web', description: `task ${i}` }),
+          steps: Array.from({ length: 10 }, (_, j) =>
+            createStep({ action: `step ${j}`, observation: `result ${j}` })
+          ),
+          outcome: successOutcome('done'),
+          agentId: `agent-${i}`,
+          totalTokens: 5000,
+        }),
+      }));
+
+      const trajectory = buildTeamTrajectory({
+        objective: 'Complex task',
+        domain: 'web',
+        complexity: 'complex',
+        teamName: 'large-team',
+        templateName: 'wave',
+        topologyType: 'wave',
+        enforcement: 'permissive',
+        memberTrajectories: members,
+        outcome: {
+          success: true,
+          partialScore: 0.9,
+          quality: 'good',
+          totalLlmCalls: 25,
+          totalTokens: 50000,
+          totalWallTimeSeconds: 120,
+        },
+      });
+      const ingester = createTeamTrajectoryIngester();
+      const ingestion = ingester.ingest(trajectory);
+
+      const complexity = teamTrajectoryAnalysisTemplate.assessComplexity({ ingestion });
+      expect(complexity).toBe('standard');
+    });
+
+    it('should return lightweight for small step counts on 3-member teams', () => {
+      const trajectory = buildTeamTrajectory({
+        objective: 'Simple task',
+        domain: 'web',
+        complexity: 'simple',
+        teamName: 'small-team',
+        templateName: 'flat',
+        topologyType: 'flat',
+        enforcement: 'permissive',
+        memberTrajectories: [
+          { agentId: 'a', role: 'r', trajectory: createTrajectory({ task: createTask({ domain: 'web', description: 'a' }), steps: [createStep({ action: 'do', observation: 'done' })], outcome: successOutcome('ok'), agentId: 'a' }) },
+          { agentId: 'b', role: 's', trajectory: createTrajectory({ task: createTask({ domain: 'web', description: 'b' }), steps: [createStep({ action: 'do', observation: 'done' })], outcome: successOutcome('ok'), agentId: 'b' }) },
+          { agentId: 'c', role: 't', trajectory: createTrajectory({ task: createTask({ domain: 'web', description: 'c' }), steps: [createStep({ action: 'do', observation: 'done' })], outcome: successOutcome('ok'), agentId: 'c' }) },
+        ],
+        outcome: {
+          success: true,
+          partialScore: 0.9,
+          quality: 'good',
+          totalLlmCalls: 5,
+          totalTokens: 5000,
+          totalWallTimeSeconds: 30,
+        },
+      });
+      const ingester = createTeamTrajectoryIngester();
+      const ingestion = ingester.ingest(trajectory);
+
+      const complexity = teamTrajectoryAnalysisTemplate.assessComplexity({ ingestion });
+      expect(complexity).toBe('lightweight');
+    });
+  });
+
+  describe('heuristicFallback', () => {
+    it('should produce analysis result with agent credits', async () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      expect(result.agentCredits).toHaveLength(2);
+      // Both agents completed all steps successfully → essential
+      expect(result.agentCredits[0].roleAssessment).toBe('essential');
+      expect(result.agentCredits[1].roleAssessment).toBe('essential');
+      expect(result.agentCredits[0].contributionScore).toBe(1);
+    });
+
+    it('should mark low-performing agents as non-essential', async () => {
+      const trajectory = buildTeamTrajectory({
+        objective: 'Implement auth',
+        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: 'attempt plan', observation: 'failed to plan' })],
+              outcome: { success: false, partialScore: 0.33, errorInfo: 'could not plan', verificationDetails: {} },
+              agentId: 'planner-1',
+              totalTokens: 10000,
+            }),
+          },
+          {
+            agentId: 'executor-1',
+            role: 'executor',
+            trajectory: createTrajectory({
+              task: createTask({ domain: 'web', description: 'implement auth' }),
+              steps: [createStep({ action: 'execute', observation: 'done' })],
+              outcome: successOutcome('implemented'),
+              agentId: 'executor-1',
+              totalTokens: 30000,
+            }),
+          },
+        ],
+        outcome: {
+          success: false,
+          partialScore: 0.5,
+          quality: 'acceptable',
+          totalLlmCalls: 10,
+          totalTokens: 40000,
+          totalWallTimeSeconds: 60,
+        },
+      });
+      const ingester = createTeamTrajectoryIngester();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      const plannerCredit = result.agentCredits.find((c) => c.role === 'planner')!;
+      expect(plannerCredit.roleAssessment).toBe('helpful'); // has steps and tokens but not successful
+      expect(plannerCredit.contributionScore).toBeCloseTo(0.33);
+    });
+
+    it('should produce interaction credits from graph', async () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      expect(result.interactionCredits).toHaveLength(1);
+      expect(result.interactionCredits[0].fromRole).toBe('planner');
+      expect(result.interactionCredits[0].toRole).toBe('executor');
+      expect(result.interactionCredits[0].value).toBe('helpful');
+      expect(result.interactionCredits[0].necessity).toBe('useful');
+    });
+
+    it('should produce good coordination assessment for successful teams', async () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      expect(result.coordinationAssessment.quality).toBe('good');
+      expect(result.coordinationAssessment.narrative).toContain('completed objective successfully');
+    });
+
+    it('should produce acceptable coordination for failed teams', async () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory({
+        outcome: {
+          success: false,
+          partialScore: 0.2,
+          quality: 'poor',
+          totalLlmCalls: 25,
+          totalTokens: 50000,
+          totalWallTimeSeconds: 120,
+        },
+      });
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      expect(result.coordinationAssessment.quality).toBe('acceptable');
+      expect(result.coordinationAssessment.narrative).toContain('failed');
+    });
+
+    it('should detect high coordination overhead', async () => {
+      const trajectory = makeSampleTrajectory();
+      (trajectory as any).metrics.coordinationOverheadRatio = 0.5;
+      const ingester = createTeamTrajectoryIngester();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      const coordLesson = result.teamLessons.find((l) => l.category === 'coordination');
+      expect(coordLesson).toBeDefined();
+      expect(coordLesson!.lesson).toContain('High coordination overhead');
+    });
+
+    it('should detect re-delegation', async () => {
+      const trajectory = makeSampleTrajectory();
+      (trajectory as any).metrics.reDelegationCount = 2;
+      const ingester = createTeamTrajectoryIngester();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      const delegationLesson = result.teamLessons.find((l) => l.category === 'delegation');
+      expect(delegationLesson).toBeDefined();
+      expect(delegationLesson!.lesson).toContain('re-delegated');
+    });
+
+    it('should produce meta-observation', async () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      expect(result.metaObservation.formationEffective).toBe(true);
+      expect(result.metaObservation.teamSizeAssessment).toBe('right-sized');
+      expect(result.metaObservation.topologyAssessment).toBe('effective');
+    });
+
+    it('should produce role lessons for each member', async () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      expect(result.roleLessons).toHaveLength(2);
+      expect(result.roleLessons[0].role).toBe('planner');
+      expect(result.roleLessons[0].strengths[0]).toContain('steps successfully');
+    });
+
+    it('should report zero analysis metrics for heuristic path', async () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const result = await teamTrajectoryAnalysisTemplate.heuristicFallback!({ ingestion });
+
+      expect(result.analysisMetrics.analysisTokens).toBe(0);
+      expect(result.analysisMetrics.analysisTimeMs).toBe(0);
+      expect(result.analysisMetrics.analysisToolCalls).toBe(0);
+    });
+  });
+
+  describe('buildTaskPrompt', () => {
+    it('should include team info in prompt', () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory();
+      const ingestion = ingester.ingest(trajectory);
+
+      const prompt = teamTrajectoryAnalysisTemplate.buildTaskPrompt({ ingestion });
+
+      expect(prompt).toContain('SUCCESSFUL');
+      expect(prompt).toContain('2 agents');
+      expect(prompt).toContain('wave');
+      expect(prompt).toContain('analysis.json');
+    });
+
+    it('should indicate FAILED for unsuccessful teams', () => {
+      const ingester = createTeamTrajectoryIngester();
+      const trajectory = makeSampleTrajectory({
+        outcome: {
+          success: false,
+          partialScore: 0.2,
+          quality: 'poor',
+          totalLlmCalls: 25,
+          totalTokens: 50000,
+          totalWallTimeSeconds: 120,
+        },
+      });
+      const ingestion = ingester.ingest(trajectory);
+
+      const prompt = teamTrajectoryAnalysisTemplate.buildTaskPrompt({ ingestion });
+      expect(prompt).toContain('FAILED');
+    });
+  });
+
+  describe('template metadata', () => {
+    it('should have correct task type and domain', () => {
+      expect(teamTrajectoryAnalysisTemplate.taskType).toBe('team-trajectory-analysis');
+      expect(teamTrajectoryAnalysisTemplate.domain).toBe('team-analysis');
+    });
+
+    it('should require analysis.json output', () => {
+      expect(teamTrajectoryAnalysisTemplate.outputConfig.files).toHaveLength(1);
+      expect(teamTrajectoryAnalysisTemplate.outputConfig.files[0].path).toBe('analysis.json');
+      expect(teamTrajectoryAnalysisTemplate.outputConfig.files[0].required).toBe(true);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "reference"]
+}

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    watch: false,
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      include: ["src/**/*.ts"],
+      exclude: ["src/**/*.d.ts", "src/index.ts"],
+    },
+    testTimeout: 10000,
+  },
+  resolve: {
+    alias: {
+      "@": "/home/user/cognitive-core/src",
+    },
+  },
+});