cognitive-core 0.1.0 → 0.1.2

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';
@@ -927,3 +929,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({
+      taskDescription: '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);
+  });
+});

package/tests/integration/entire-e2e.test.ts

@@ -0,0 +1,187 @@
+/**
+ * End-to-end integration test: SessionBank + EntireTrajectorySource
+ * against REAL Entire CLI checkpoint data on the orphan branch.
+ *
+ * This test reads data captured by the actual Entire CLI v0.4.6
+ * (not fixtures) from the `entire/checkpoints/v1` orphan branch.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { SessionBank } from '../../src/session-bank/session-bank';
+import { EntireTrajectorySource } from '../../src/learning/trajectory-sources/entire';
+
+describe('Entire CLI E2E Integration', () => {
+  let bank: SessionBank;
+  let source: EntireTrajectorySource;
+
+  beforeAll(async () => {
+    bank = new SessionBank({
+      repoPath: process.cwd(),
+      branch: 'entire/checkpoints/v1',
+      stateDir: '/tmp/atlas-e2e-test-state',
+      cache: true,
+    });
+
+    await bank.init();
+    source = new EntireTrajectorySource(bank);
+  });
+
+  afterAll(async () => {
+    if (bank) {
+      await bank.close();
+    }
+  });
+
+  describe('SessionBank against real Entire data', () => {
+    it('should detect the orphan branch exists', () => {
+      expect(bank.isAvailable()).toBe(true);
+    });
+
+    it('should list checkpoints from real data', async () => {
+      const checkpoints = await bank.listCheckpoints();
+      expect(checkpoints.length).toBeGreaterThanOrEqual(1);
+
+      const checkpoint = checkpoints[0];
+      expect(checkpoint.checkpointId).toBeTruthy();
+      expect(checkpoint.path).toBeTruthy();
+      expect(checkpoint.sessionCount).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should discover sessions with metadata', async () => {
+      const sessions = await bank.discover();
+      expect(sessions.length).toBeGreaterThanOrEqual(1);
+
+      const session = sessions[0];
+      expect(session.sessionId).toBe('test-session-e2e');
+      expect(session.metadata.agent).toBe('Claude Code');
+      expect(session.metadata.strategy).toBe('manual-commit');
+      expect(session.metadata.filesTouched).toContain('src/e2e-test-marker.ts');
+      expect(session.metadata.branch).toBe('claude/session-bank-design-41pv3');
+    });
+
+    it('should query sessions and load transcripts', async () => {
+      const result = await bank.query();
+      expect(result.sessions.length).toBeGreaterThanOrEqual(1);
+      expect(result.total).toBeGreaterThanOrEqual(1);
+
+      const session = result.sessions[0];
+      // Transcript should be loaded with actual messages
+      expect(session.transcript).toBeDefined();
+      expect(session.transcript.length).toBeGreaterThan(0);
+
+      // Check we have user messages (from "human" type in Entire JSONL)
+      const userMessages = session.transcript.filter(
+        (m) => m.role === 'user'
+      );
+      expect(userMessages.length).toBeGreaterThan(0);
+
+      // Check we have assistant messages
+      const assistantMessages = session.transcript.filter(
+        (m) => m.role === 'assistant'
+      );
+      expect(assistantMessages.length).toBeGreaterThan(0);
+    });
+
+    it('should filter sessions by branch', async () => {
+      const result = await bank.query({
+        branch: 'claude/session-bank-design-41pv3',
+      });
+      expect(result.sessions.length).toBeGreaterThanOrEqual(1);
+
+      const noResults = await bank.query({
+        branch: 'nonexistent-branch',
+      });
+      expect(noResults.sessions.length).toBe(0);
+    });
+
+    it('should search across transcript content', async () => {
+      const result = await bank.query({
+        search: 'hello world',
+      });
+      expect(result.sessions.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should count sessions', async () => {
+      const count = await bank.count();
+      expect(count).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should find session by ID', async () => {
+      const session = await bank.getBySessionId('test-session-e2e');
+      expect(session).toBeDefined();
+      expect(session!.sessionId).toBe('test-session-e2e');
+    });
+  });
+
+  describe('EntireTrajectorySource against real data', () => {
+    it('should count available trajectories', async () => {
+      const count = await source.count();
+      expect(count).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should load and synthesize trajectories from real data', async () => {
+      const items = await source.load();
+      expect(items.length).toBeGreaterThanOrEqual(1);
+
+      // load() returns TrajectoryWithAnalysis[]
+      const { trajectory } = items[0];
+      expect(trajectory.id).toContain('entire-');
+      expect(trajectory.task).toBeDefined();
+      expect(trajectory.task.description).toBeTruthy();
+      expect(trajectory.steps).toBeDefined();
+      expect(trajectory.outcome).toBeDefined();
+      expect(trajectory.metadata).toBeDefined();
+
+      // Metadata should have Entire provenance
+      expect(trajectory.metadata?.source).toBe('entire');
+      expect(trajectory.metadata?.checkpointId).toBeTruthy();
+      expect(trajectory.metadata?.sessionId).toBe('test-session-e2e');
+    });
+
+    it('should extract steps from real tool_use blocks', async () => {
+      const items = await source.load();
+      const { trajectory } = items[0];
+
+      // Our transcript had a Write tool_use
+      const writeStep = trajectory.steps.find(
+        (s) => s.action && s.action.includes('Write')
+      );
+      expect(writeStep).toBeDefined();
+      expect(writeStep!.action).toContain('Write');
+    });
+
+    it('should infer domain from files touched', async () => {
+      const items = await source.load();
+      const { trajectory } = items[0];
+
+      // Files touched include .ts files, so domain should be typescript
+      expect(trajectory.task.domain).toBe('typescript');
+    });
+
+    it('should determine outcome from real data', async () => {
+      const items = await source.load();
+      const { trajectory } = items[0];
+
+      expect(trajectory.outcome.success).toBeDefined();
+      expect(typeof trajectory.outcome.success).toBe('boolean');
+    });
+
+    it('should produce valid Trajectory shape', async () => {
+      const items = await source.load();
+      const { trajectory } = items[0];
+
+      expect(trajectory).toMatchObject({
+        id: expect.stringContaining('entire-'),
+        task: expect.objectContaining({
+          domain: expect.any(String),
+          description: expect.any(String),
+        }),
+        outcome: expect.objectContaining({
+          success: expect.any(Boolean),
+        }),
+        metadata: expect.objectContaining({
+          source: 'entire',
+        }),
+      });
+    });
+  });
+});