cognitive-core 0.1.0 → 0.2.0

package/tests/integration/e2e.test.ts

@@ -8,6 +8,8 @@ import { createTask } from '../../src/types/task.js';
 import { createTrajectory } from '../../src/types/trajectory.js';
 import { createStep } from '../../src/types/step.js';
 import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
+import { buildTeamTrajectory } from '../../src/types/team-trajectory.js';
+import type { InteractionTag, TeamTrajectoryInput } from '../../src/types/team-trajectory.js';
 import { MockBackend, createMockBackend } from '../../src/runtime/backends/mock.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -292,6 +294,7 @@ describe('Integration: Learning Pipeline Batch Extraction', () => {
       'Fix authentication login flow',
     ];
 
+    let lastResult: any;
     for (let i = 0; i < similarTasks.length; i++) {
       const trajectory = createTrajectory({
         id: `auth-traj-${i}`,
@@ -320,12 +323,12 @@ describe('Integration: Learning Pipeline Batch Extraction', () => {
         agentId: 'test-agent',
       });
 
-      await atlas.processTrajectory(trajectory);
+      lastResult = await atlas.processTrajectory(trajectory);
     }
 
-    // Force batch learning
-    const batchResult = await atlas.runBatchLearning();
-    expect(batchResult.trajectoriesProcessed).toBe(3);
+    // With unified pipeline, batch is auto-triggered when count threshold (3) is reached
+    expect(lastResult.batchTriggered).toBe(true);
+    expect(lastResult.batchResult.trajectoriesProcessed).toBe(3);
   });
 
   it('should run batch learning explicitly', async () => {
@@ -927,3 +930,408 @@ describe('Integration: Playbook Usage Inference', () => {
     expect(result.injectedPlaybooks).toBeDefined();
   });
 });
+
+// ============================================================
+// E2E: Graph-based Team Trajectory Learning
+// ============================================================
+
+describe('Integration: Graph-based Team Trajectory Learning', () => {
+  let tempDir: string;
+  let atlas: Atlas;
+  let mockBackend: MockBackend;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-team-graph-e2e-'));
+    mockBackend = createMockBackend({
+      success: true,
+      result: 'Done',
+      durationMs: 30,
+    });
+
+    atlas = createAtlasWithAgents([mockBackend], {
+      storage: { baseDir: tempDir },
+      teamLearning: {
+        enabled: true,
+        minTeamTrajectories: 2, // Low threshold for testing
+      },
+    });
+
+    await atlas.init();
+  });
+
+  afterEach(async () => {
+    await atlas.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Build a graph-based TeamTrajectory from per-agent trajectories
+   * with InteractionTag metadata on steps.
+   */
+  function makeGraphTeamTrajectory(params: {
+    objective: string;
+    domain: string;
+    success: boolean;
+    topologyType?: string;
+  }): ReturnType<typeof buildTeamTrajectory> {
+    const plannerSteps = [
+      createStep({
+        thought: 'Analyzing the task and planning delegation',
+        action: 'delegate subtask to executor',
+        observation: 'Delegated successfully',
+        metadata: {
+          interactionTag: {
+            interactionId: `int-${params.objective}`,
+            interactionType: 'delegation',
+            counterpartAgentId: 'executor-1',
+            stepRole: 'source',
+          } satisfies InteractionTag,
+        },
+      }),
+      createStep({
+        action: 'read executor result',
+        observation: params.success
+          ? 'success: executor completed all subtasks'
+          : 'error: executor encountered failures',
+      }),
+    ];
+
+    const executorSteps = [
+      createStep({
+        action: 'receive delegation from planner',
+        observation: 'Received task assignment',
+        metadata: {
+          interactionTag: {
+            interactionId: `int-${params.objective}`,
+            interactionType: 'delegation',
+            counterpartAgentId: 'planner-1',
+            stepRole: 'target',
+          } satisfies InteractionTag,
+        },
+      }),
+      createStep({
+        thought: 'Deciding implementation approach',
+        action: 'decided to implement feature',
+        observation: 'Implementation started',
+      }),
+      createStep({
+        action: 'complete implementation',
+        observation: params.success ? 'completed successfully' : 'failed with error',
+      }),
+    ];
+
+    const input: TeamTrajectoryInput = {
+      objective: params.objective,
+      domain: params.domain,
+      complexity: 'moderate',
+      teamName: 'test-team',
+      templateName: params.topologyType ?? 'hierarchical',
+      topologyType: params.topologyType ?? 'hierarchical',
+      enforcement: 'permissive',
+      memberTrajectories: [
+        {
+          agentId: 'planner-1',
+          role: 'planner',
+          trajectory: createTrajectory({
+            task: createTask({ domain: params.domain, description: `Plan: ${params.objective}` }),
+            steps: plannerSteps,
+            outcome: params.success ? successOutcome('planned') : failureOutcome('planning failed', 0.3),
+            agentId: 'planner-1',
+            totalTokens: 5000,
+            llmCalls: 3,
+          }),
+        },
+        {
+          agentId: 'executor-1',
+          role: 'executor',
+          trajectory: createTrajectory({
+            task: createTask({ domain: params.domain, description: `Execute: ${params.objective}` }),
+            steps: executorSteps,
+            outcome: params.success ? successOutcome('done') : failureOutcome('execution failed', 0.2),
+            agentId: 'executor-1',
+            totalTokens: 15000,
+            llmCalls: 8,
+          }),
+        },
+      ],
+      outcome: {
+        success: params.success,
+        partialScore: params.success ? 1.0 : 0.3,
+        quality: params.success ? 'good' : 'poor',
+        totalLlmCalls: 11,
+        totalTokens: 20000,
+        totalWallTimeSeconds: 60,
+      },
+      expectedPatterns: [{
+        name: 'planner-delegates',
+        fromRole: 'planner',
+        toRole: 'executor',
+        type: 'delegation',
+        frequency: 'once',
+      }],
+    };
+
+    return buildTeamTrajectory(input);
+  }
+
+  it('should process a graph-based team trajectory end-to-end', async () => {
+    const trajectory = makeGraphTeamTrajectory({
+      objective: 'Build authentication module',
+      domain: 'web',
+      success: true,
+    });
+
+    // Verify graph data is present before processing
+    expect(trajectory.members).toHaveLength(2);
+    expect(trajectory.interactions).toBeDefined();
+    expect(trajectory.interactions!.length).toBeGreaterThan(0);
+    expect(trajectory.graphMetrics).toBeDefined();
+
+    // Process through Atlas
+    const result = await atlas.processTeamTrajectory(trajectory);
+
+    expect(result.teamTrajectoryId).toBe(trajectory.id);
+    expect(result.stored).toBe(true);
+    expect(result.analyzed).toBe(true);
+    expect(result.analysis).toBeDefined();
+
+    // Verify analysis used graph data
+    expect(result.analysis!.agentCredits).toHaveLength(2);
+    expect(result.analysis!.interactionCredits.length).toBeGreaterThan(0);
+
+    // Planner should have graph-enriched credit assessment
+    const plannerCredit = result.analysis!.agentCredits.find(c => c.role === 'planner');
+    expect(plannerCredit).toBeDefined();
+    expect(plannerCredit!.contributionScore).toBe(1.0); // Success
+    expect(plannerCredit!.assessment).toContain('steps'); // Graph-based: "completed N steps"
+
+    // Verify team stats updated
+    const stats = await atlas.getStats();
+    expect(stats.learning.teamTrajectoriesProcessed).toBe(1);
+    expect(stats.teamMemory).toBeDefined();
+    expect(stats.teamMemory!.teamExperienceCount).toBe(1);
+    expect(stats.teamMemory!.teamMetaObservationCount).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should accumulate graph trajectories and run batch learning', async () => {
+    // Process enough trajectories to trigger batch (minTeamTrajectories: 2)
+    // The batch auto-triggers during processTeamTrajectory when threshold is reached
+    const trajectories = [
+      makeGraphTeamTrajectory({
+        objective: 'Build user registration',
+        domain: 'web',
+        success: true,
+      }),
+      makeGraphTeamTrajectory({
+        objective: 'Build password reset',
+        domain: 'web',
+        success: true,
+      }),
+    ];
+
+    for (const t of trajectories) {
+      await atlas.processTeamTrajectory(t);
+    }
+
+    // Verify all processed
+    const stats = await atlas.getStats();
+    expect(stats.learning.teamTrajectoriesProcessed).toBe(2);
+    expect(stats.teamMemory!.teamExperienceCount).toBe(2);
+
+    // Batch was auto-triggered at threshold. Check team memory for results.
+    const teamMemory = atlas.getMemory().teamExperiences;
+    const teamPlaybooks = await teamMemory.getTeamPlaybooks();
+    const rolePlaybooks = await teamMemory.getRolePlaybooks();
+
+    // With 2 successful hierarchical/web trajectories, should extract patterns
+    expect(teamPlaybooks.length + rolePlaybooks.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should handle mixed success/failure graph trajectories', async () => {
+    const success = makeGraphTeamTrajectory({
+      objective: 'Implement feature A',
+      domain: 'backend',
+      success: true,
+    });
+    const failure = makeGraphTeamTrajectory({
+      objective: 'Implement feature B',
+      domain: 'backend',
+      success: false,
+    });
+
+    const successResult = await atlas.processTeamTrajectory(success);
+    const failureResult = await atlas.processTeamTrajectory(failure);
+
+    // Both should be processed
+    expect(successResult.analyzed).toBe(true);
+    expect(failureResult.analyzed).toBe(true);
+
+    // Failure analysis should reflect the failure
+    const failedCredits = failureResult.analysis!.agentCredits;
+    expect(failedCredits.some(c => c.contributionScore < 1.0)).toBe(true);
+
+    // Team memory should have both
+    const stats = await atlas.getStats();
+    expect(stats.teamMemory!.teamExperienceCount).toBe(2);
+  });
+
+  it('should use graph interactions for richer analysis', async () => {
+    const trajectory = makeGraphTeamTrajectory({
+      objective: 'Build API endpoint',
+      domain: 'backend',
+      success: true,
+    });
+
+    const result = await atlas.processTeamTrajectory(trajectory);
+
+    // Interaction credits should reference the step-level delegation
+    const interactionCredits = result.analysis!.interactionCredits;
+    expect(interactionCredits.length).toBeGreaterThan(0);
+
+    // With graph data, interaction credits should have type info
+    const delegationCredit = interactionCredits.find(
+      ic => ic.reasoning.includes('delegation')
+    );
+    expect(delegationCredit).toBeDefined();
+    expect(delegationCredit!.fromRole).toBe('planner');
+    expect(delegationCredit!.toRole).toBe('executor');
+  });
+
+  it('should generate meta-observations with graph metrics', async () => {
+    const trajectory = makeGraphTeamTrajectory({
+      objective: 'Build dashboard',
+      domain: 'frontend',
+      success: true,
+    });
+
+    await atlas.processTeamTrajectory(trajectory);
+
+    // Check meta-observations were recorded
+    const teamMemory = atlas.getMemory().teamExperiences;
+    const metaObs = await teamMemory.getMetaObservations();
+    expect(metaObs.length).toBeGreaterThanOrEqual(1);
+
+    // The pipeline-generated meta-observation should exist
+    const obs = metaObs[0];
+    expect(obs.formation.wasEffective).toBe(true);
+    expect(obs.formation.topologyUsed).toBe('hierarchical');
+    expect(obs.formation.domain).toBe('frontend');
+  });
+
+  it('should recommend teams after accumulating graph experience', async () => {
+    // Process trajectories to build team memory
+    const trajectories = [
+      makeGraphTeamTrajectory({
+        objective: 'Build auth module',
+        domain: 'web',
+        success: true,
+        topologyType: 'hierarchical',
+      }),
+      makeGraphTeamTrajectory({
+        objective: 'Build user profile',
+        domain: 'web',
+        success: true,
+        topologyType: 'hierarchical',
+      }),
+    ];
+
+    for (const t of trajectories) {
+      await atlas.processTeamTrajectory(t);
+    }
+
+    // Force batch learning to extract playbooks
+    await atlas.runTeamBatchLearning();
+
+    // Now try to recommend a team
+    const recommendation = await atlas.recommendTeam({
+      description: 'Build payment integration',
+      domain: 'web',
+      complexity: 'moderate',
+    });
+
+    expect(recommendation).toBeDefined();
+    expect(recommendation.confidence).toBeGreaterThanOrEqual(0);
+    expect(recommendation.composition).toBeDefined();
+    expect(recommendation.composition.topology).toBeDefined();
+    expect(recommendation.composition.roles.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should process graph trajectory through full pipeline to team playbook extraction', async () => {
+    // Close existing atlas and create new one with higher batch threshold
+    await atlas.close();
+    await rm(tempDir, { recursive: true, force: true });
+
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-team-graph-e2e-'));
+    atlas = createAtlasWithAgents([mockBackend], {
+      storage: { baseDir: tempDir },
+      teamLearning: {
+        enabled: true,
+        minTeamTrajectories: 10, // High threshold so batch doesn't auto-trigger
+      },
+    });
+    await atlas.init();
+
+    // Need enough similar trajectories for playbook extraction
+    const objectives = [
+      'Implement login page',
+      'Implement signup page',
+      'Implement password reset page',
+    ];
+
+    for (const objective of objectives) {
+      const t = makeGraphTeamTrajectory({
+        objective,
+        domain: 'web',
+        success: true,
+        topologyType: 'hierarchical',
+      });
+      await atlas.processTeamTrajectory(t);
+    }
+
+    // Verify all processed
+    const stats = await atlas.getStats();
+    expect(stats.learning.teamTrajectoriesProcessed).toBe(3);
+
+    // Run batch extraction explicitly (threshold not reached, but we force it)
+    const batchResult = await atlas.runTeamBatchLearning();
+    expect(batchResult).toBeDefined();
+    expect(batchResult!.ready).toBe(true);
+    expect(batchResult!.trajectoriesProcessed).toBe(3);
+
+    // Check team memory for results
+    const teamMemory = atlas.getMemory().teamExperiences;
+    const teamPlaybooks = await teamMemory.getTeamPlaybooks();
+    const rolePlaybooks = await teamMemory.getRolePlaybooks();
+
+    // With 3 successful hierarchical/web trajectories with the same topology,
+    // the heuristic should extract at least 1 team playbook
+    expect(teamPlaybooks.length).toBeGreaterThanOrEqual(1);
+
+    // Verify team playbook has graph-enriched interaction patterns
+    if (teamPlaybooks.length > 0) {
+      const tp = teamPlaybooks[0];
+      expect(tp.composition.topology).toBe('hierarchical');
+      expect(tp.applicability.domains).toContain('web');
+      expect(tp.composition.roles.length).toBeGreaterThanOrEqual(1);
+
+      // Should have interaction patterns extracted from graph data
+      expect(tp.coordination.interactionPatterns.length).toBeGreaterThanOrEqual(0);
+    }
+
+    // With 3 trajectories both roles appear consistently
+    // Role playbooks should be extracted for at least one role
+    if (rolePlaybooks.length > 0) {
+      const roles = rolePlaybooks.map(rp => rp.role);
+      // Either 'planner' or 'executor' should be present
+      expect(roles.some(r => ['planner', 'executor'].includes(r))).toBe(true);
+    }
+
+    // Query team memory to verify searchability
+    const queryResult = await atlas.queryTeamMemory('authentication', {
+      domain: 'web',
+      includeExperiences: true,
+      includePlaybooks: true,
+    });
+    expect(queryResult.experiences.length + queryResult.playbooks.length).toBeGreaterThanOrEqual(0);
+  });
+});