cognitive-core 0.0.2 → 0.1.2

package/tests/integration/e2e.test.ts

@@ -0,0 +1,1336 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  Atlas,
+  createAtlas,
+  createAtlasWithAgents,
+} from '../../src/atlas.js';
+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';
+import { tmpdir } from 'node:os';
+
+describe('Integration: End-to-End Solve Flow', () => {
+  let tempDir: string;
+  let atlas: Atlas;
+  let mockBackend: MockBackend;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-e2e-test-'));
+    mockBackend = createMockBackend({
+      success: true,
+      result: 'Task completed successfully',
+      durationMs: 50,
+      toolCalls: [
+        { name: 'read_file', input: { path: 'src/main.ts' }, output: 'code content' },
+        { name: 'write_file', input: { path: 'src/main.ts', content: 'updated' }, output: 'written' },
+      ],
+    });
+
+    atlas = createAtlasWithAgents([mockBackend], {
+      storage: { baseDir: tempDir },
+      learning: {
+        minTrajectories: 2,
+        deduplicationThreshold: 0.8,
+      },
+      execution: {
+        defaultAgentType: 'mock',
+        maxExecutionTime: 60,
+        captureToolCalls: true,
+      },
+    });
+
+    await atlas.init();
+  });
+
+  afterEach(async () => {
+    await atlas.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('solve() with AgentManager', () => {
+    it('should solve a task and return trajectory', async () => {
+      const task = createTask({
+        domain: 'code',
+        description: 'Fix the bug in authentication module',
+      });
+
+      const result = await atlas.solve(task);
+
+      expect(result.trajectory).toBeDefined();
+      expect(result.trajectory.outcome.success).toBe(true);
+      expect(result.usedAgentManager).toBe(true);
+      expect(result.routing).toBeDefined();
+      expect(result.routing?.strategy).toBeDefined();
+    });
+
+    it('should inject playbooks when available', async () => {
+      // Add a playbook that should be injected
+      const memory = atlas.getMemory();
+      await memory.playbooks.add({
+        id: 'auth-playbook',
+        name: 'Authentication Bug Fix',
+        applicability: {
+          situations: ['Fix authentication bug', 'Auth module issue'],
+          triggers: ['authentication', 'auth', 'login'],
+          antiPatterns: [],
+          domains: ['code', 'auth'],
+        },
+        guidance: {
+          strategy: 'Check token validation and session management',
+          tactics: ['Verify token expiry', 'Check session storage'],
+          steps: ['Read auth code', 'Find issue', 'Apply fix', 'Test'],
+        },
+        verification: {
+          successIndicators: ['Tests pass', 'No auth errors'],
+          failureIndicators: ['Auth still fails'],
+        },
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 5,
+          failureCount: 0,
+        },
+        confidence: 0.85,
+        complexity: 'moderate',
+        estimatedEffort: 2,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      // Refresh skill library tiers
+      const skillLibrary = atlas.getSkillLibrary();
+      await skillLibrary?.refreshTiers();
+
+      const task = createTask({
+        domain: 'code',
+        description: 'Fix the authentication bug in login flow',
+      });
+
+      const result = await atlas.solve(task);
+
+      expect(result.trajectory).toBeDefined();
+      // Playbooks should be tracked (may or may not be injected depending on scoring)
+      expect(result.injectedPlaybooks).toBeDefined();
+    });
+
+    it('should track memory context from router', async () => {
+      const task = createTask({
+        domain: 'code',
+        description: 'Implement new feature',
+      });
+
+      const result = await atlas.solve(task);
+
+      expect(result.routing).toBeDefined();
+      expect(result.routing?.memoryContext).toBeDefined();
+      expect(result.routing?.confidence).toBeDefined();
+      expect(result.routing?.estimatedBudget).toBeDefined();
+    });
+
+    it('should process trajectory for learning after solve', async () => {
+      const task = createTask({
+        domain: 'code',
+        description: 'Test learning integration',
+      });
+
+      await atlas.solve(task);
+
+      const stats = await atlas.getStats();
+      expect(stats.learning.trajectoriesProcessed).toBe(1);
+    });
+
+    it('should handle failed agent execution', async () => {
+      mockBackend.setDefaultBehavior({
+        success: false,
+        error: 'Agent execution failed',
+        result: 'Partial result before failure',  // Provide result for experience creation
+        durationMs: 50,
+      });
+
+      const task = createTask({
+        domain: 'code',
+        description: 'Failing task',
+      });
+
+      const result = await atlas.solve(task);
+
+      expect(result.trajectory.outcome.success).toBe(false);
+      expect(result.usedAgentManager).toBe(true);
+    });
+  });
+
+  describe('solve() with multiple tasks', () => {
+    it('should solve batch of tasks', async () => {
+      const tasks = [
+        createTask({ domain: 'code', description: 'Task 1' }),
+        createTask({ domain: 'code', description: 'Task 2' }),
+        createTask({ domain: 'code', description: 'Task 3' }),
+      ];
+
+      const results = await atlas.solveBatch(tasks);
+
+      expect(results.length).toBe(3);
+      results.forEach(result => {
+        expect(result.trajectory).toBeDefined();
+        expect(result.usedAgentManager).toBe(true);
+      });
+
+      const stats = await atlas.getStats();
+      expect(stats.learning.trajectoriesProcessed).toBe(3);
+    });
+
+    it('should accumulate learning across tasks', async () => {
+      // Solve multiple similar tasks
+      for (let i = 0; i < 3; i++) {
+        await atlas.solve(createTask({
+          domain: 'code',
+          description: `Fix TypeScript error ${i}`,
+        }));
+      }
+
+      const stats = await atlas.getStats();
+      expect(stats.learning.trajectoriesProcessed).toBe(3);
+    });
+  });
+});
+
+describe('Integration: Learning Pipeline Batch Extraction', () => {
+  let tempDir: string;
+  let atlas: Atlas;
+  let mockBackend: MockBackend;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-learning-test-'));
+    mockBackend = createMockBackend({
+      success: true,
+      result: 'Completed',
+      durationMs: 30,
+    });
+
+    atlas = createAtlasWithAgents([mockBackend], {
+      storage: { baseDir: tempDir },
+      learning: {
+        minTrajectories: 3, // Low threshold for testing
+        deduplicationThreshold: 0.7,
+      },
+    });
+
+    await atlas.init();
+  });
+
+  afterEach(async () => {
+    await atlas.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should accumulate trajectories until batch threshold', async () => {
+    // Process trajectories below threshold
+    for (let i = 0; i < 2; i++) {
+      const trajectory = createTrajectory({
+        id: `traj-${i}`,
+        task: createTask({ domain: 'code', description: `Task ${i}` }),
+        steps: [
+          createStep({ action: 'read', observation: 'content' }),
+          createStep({ action: 'write', observation: 'done' }),
+        ],
+        outcome: successOutcome('Done'),
+        agentId: 'test-agent',
+      });
+
+      await atlas.processTrajectory(trajectory);
+    }
+
+    const stats = await atlas.getStats();
+    expect(stats.learning.trajectoriesProcessed).toBe(2);
+    expect(stats.learning.pendingTrajectories).toBe(2);
+  });
+
+  it('should trigger batch learning when threshold reached', async () => {
+    // Process trajectories to trigger batch
+    for (let i = 0; i < 4; i++) {
+      const trajectory = createTrajectory({
+        id: `batch-traj-${i}`,
+        task: createTask({
+          domain: 'code',
+          description: `Fix TypeScript error in module ${i}`,
+        }),
+        steps: [
+          createStep({
+            thought: 'Need to fix the type error',
+            action: 'Read the file with error',
+            observation: 'Found type mismatch',
+          }),
+          createStep({
+            thought: 'Applying the fix',
+            action: 'Update type annotation',
+            observation: 'Type error resolved',
+          }),
+        ],
+        outcome: successOutcome('Fixed type error'),
+        agentId: 'test-agent',
+      });
+
+      await atlas.processTrajectory(trajectory);
+    }
+
+    // After threshold, batch learning should have been triggered
+    const stats = await atlas.getStats();
+    expect(stats.learning.trajectoriesProcessed).toBe(4);
+  });
+
+  it('should extract playbooks from similar trajectories', async () => {
+    // Create similar successful trajectories
+    const similarTasks = [
+      'Fix authentication token validation',
+      'Fix authentication session expiry',
+      'Fix authentication login flow',
+    ];
+
+    for (let i = 0; i < similarTasks.length; i++) {
+      const trajectory = createTrajectory({
+        id: `auth-traj-${i}`,
+        task: createTask({
+          domain: 'auth',
+          description: similarTasks[i],
+        }),
+        steps: [
+          createStep({
+            thought: 'Check authentication code',
+            action: 'Read auth module',
+            observation: 'Found the issue',
+          }),
+          createStep({
+            thought: 'Apply fix',
+            action: 'Update auth logic',
+            observation: 'Fixed',
+          }),
+          createStep({
+            thought: 'Verify fix',
+            action: 'Run auth tests',
+            observation: 'All tests pass',
+          }),
+        ],
+        outcome: successOutcome('Auth issue fixed'),
+        agentId: 'test-agent',
+      });
+
+      await atlas.processTrajectory(trajectory);
+    }
+
+    // Force batch learning
+    const batchResult = await atlas.runBatchLearning();
+    expect(batchResult.trajectoriesProcessed).toBe(3);
+  });
+
+  it('should run batch learning explicitly', async () => {
+    // Add a trajectory
+    const trajectory = createTrajectory({
+      task: createTask({ domain: 'test', description: 'Explicit batch test' }),
+      steps: [createStep({ action: 'test', observation: 'result' })],
+      outcome: successOutcome('Done'),
+      agentId: 'test',
+    });
+
+    await atlas.processTrajectory(trajectory);
+
+    // Explicitly run batch learning
+    const result = await atlas.runBatchLearning();
+
+    expect(result).toBeDefined();
+    expect(result.trajectoriesProcessed).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('Integration: Skill Tier Promotion/Demotion', () => {
+  let tempDir: string;
+  let atlas: Atlas;
+  let mockBackend: MockBackend;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-tier-test-'));
+    mockBackend = createMockBackend({ success: true, durationMs: 30 });
+
+    atlas = createAtlasWithAgents([mockBackend], {
+      storage: { baseDir: tempDir },
+      skillLibrary: {
+        promotion: {
+          minConfidence: 0.8,
+          minSuccessCount: 3,
+          minSuccessRate: 0.7,
+        },
+        demotion: {
+          failureThreshold: 2,
+          minConfidenceToRetain: 0.5,
+        },
+        limits: {
+          maxCoreSkills: 5,
+          maxDomainSkills: 3,
+          maxContextualPlaybooks: 2,
+        },
+      },
+    });
+
+    await atlas.init();
+  });
+
+  afterEach(async () => {
+    await atlas.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should promote high-performing playbooks to core skills', async () => {
+    const memory = atlas.getMemory();
+    const skillLibrary = atlas.getSkillLibrary();
+
+    // Add a high-confidence, high-success playbook
+    await memory.playbooks.add({
+      id: 'promote-playbook',
+      name: 'High Performance Playbook',
+      applicability: {
+        situations: ['Common coding task'],
+        triggers: ['code', 'fix'],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Proven approach',
+        tactics: ['Step 1', 'Step 2'],
+      },
+      verification: {
+        successIndicators: ['Works'],
+        failureIndicators: ['Fails'],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 10,
+        failureCount: 1,
+      },
+      confidence: 0.9,
+      complexity: 'simple',
+      estimatedEffort: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    // Refresh tiers
+    const tierResult = await skillLibrary?.refreshTiers();
+
+    expect(tierResult?.promoted).toBeDefined();
+    expect(tierResult?.coreCount).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should demote failing playbooks', async () => {
+    const memory = atlas.getMemory();
+    const skillLibrary = atlas.getSkillLibrary();
+
+    // Add a playbook that will be demoted
+    await memory.playbooks.add({
+      id: 'demote-playbook',
+      name: 'Failing Playbook',
+      applicability: {
+        situations: ['Edge case'],
+        triggers: ['rare'],
+        antiPatterns: [],
+        domains: ['test'],
+      },
+      guidance: {
+        strategy: 'Risky approach',
+        tactics: [],
+      },
+      verification: {
+        successIndicators: [],
+        failureIndicators: [],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 1,
+        failureCount: 5,
+      },
+      confidence: 0.3,
+      complexity: 'complex',
+      estimatedEffort: 5,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await skillLibrary?.refreshTiers();
+
+    // Playbook with low success should not be in core
+    const coreSkills = skillLibrary?.getCoreSkills();
+    const isInCore = coreSkills?.some(s => s.id === 'demote-playbook');
+    expect(isInCore).toBe(false);
+  });
+
+  it('should track consecutive failures for demotion', async () => {
+    const memory = atlas.getMemory();
+    const skillLibrary = atlas.getSkillLibrary();
+
+    // Add playbook and record failures
+    await memory.playbooks.add({
+      id: 'failure-track-playbook',
+      name: 'Track Failures',
+      applicability: {
+        situations: ['Test'],
+        triggers: ['test'],
+        antiPatterns: [],
+        domains: ['test'],
+      },
+      guidance: {
+        strategy: 'Test strategy',
+        tactics: [],
+      },
+      verification: {
+        successIndicators: [],
+        failureIndicators: [],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 5,
+        failureCount: 0,
+      },
+      confidence: 0.85,
+      complexity: 'simple',
+      estimatedEffort: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await skillLibrary?.refreshTiers();
+
+    // Record consecutive failures
+    await skillLibrary?.recordOutcome('failure-track-playbook', 'traj-1', false, 'First failure');
+    await skillLibrary?.recordOutcome('failure-track-playbook', 'traj-2', false, 'Second failure');
+
+    const failures = skillLibrary?.getConsecutiveFailures('failure-track-playbook');
+    expect(failures).toBe(2);
+
+    // Check at-risk playbooks
+    const atRisk = skillLibrary?.getAtRiskPlaybooks();
+    expect(atRisk).toBeDefined();
+  });
+
+  it('should reset failure count on success', async () => {
+    const memory = atlas.getMemory();
+    const skillLibrary = atlas.getSkillLibrary();
+
+    await memory.playbooks.add({
+      id: 'reset-playbook',
+      name: 'Reset Test',
+      applicability: {
+        situations: ['Test'],
+        triggers: ['test'],
+        antiPatterns: [],
+        domains: ['test'],
+      },
+      guidance: {
+        strategy: 'Test',
+        tactics: [],
+      },
+      verification: {
+        successIndicators: [],
+        failureIndicators: [],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 5,
+        failureCount: 0,
+      },
+      confidence: 0.85,
+      complexity: 'simple',
+      estimatedEffort: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await skillLibrary?.refreshTiers();
+
+    // Record failures then success
+    await skillLibrary?.recordOutcome('reset-playbook', 'traj-1', false);
+    await skillLibrary?.recordOutcome('reset-playbook', 'traj-2', false);
+
+    let failures = skillLibrary?.getConsecutiveFailures('reset-playbook');
+    expect(failures).toBe(2);
+
+    // Success should reset
+    await skillLibrary?.recordOutcome('reset-playbook', 'traj-3', true);
+
+    failures = skillLibrary?.getConsecutiveFailures('reset-playbook');
+    expect(failures).toBe(0);
+  });
+
+  it('should organize skills by domain', async () => {
+    const memory = atlas.getMemory();
+    const skillLibrary = atlas.getSkillLibrary();
+
+    // Add playbooks in different domains
+    const domains = ['frontend', 'backend', 'database'];
+    for (const domain of domains) {
+      await memory.playbooks.add({
+        id: `${domain}-playbook`,
+        name: `${domain} Playbook`,
+        applicability: {
+          situations: [`${domain} task`],
+          triggers: [domain],
+          antiPatterns: [],
+          domains: [domain],
+        },
+        guidance: {
+          strategy: `${domain} strategy`,
+          tactics: [],
+        },
+        verification: {
+          successIndicators: [],
+          failureIndicators: [],
+        },
+        evolution: {
+          version: '1.0.0',
+          createdFrom: [],
+          failures: [],
+          refinements: [],
+          successCount: 3,
+          failureCount: 1,
+        },
+        confidence: 0.7,
+        complexity: 'moderate',
+        estimatedEffort: 2,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+    }
+
+    await skillLibrary?.refreshTiers();
+
+    const allDomains = skillLibrary?.getDomains();
+    expect(allDomains?.length).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('Integration: Memory Persistence', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-persist-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should persist and restore memory across sessions', async () => {
+    // First session - add data
+    const atlas1 = createAtlasWithAgents([createMockBackend()], {
+      storage: { baseDir: tempDir },
+    });
+    await atlas1.init();
+
+    const memory1 = atlas1.getMemory();
+    await memory1.experiences.add({
+      id: 'persist-exp-1',
+      taskInput: 'Persistent experience',
+      solutionOutput: 'Solution persisted',
+      feedback: 'Good',
+      success: true,
+      domain: 'test',
+      trajectoryId: 'persist-traj-1',
+      usageCount: 0,
+      createdAt: new Date(),
+      metadata: {},
+    });
+
+    await memory1.playbooks.add({
+      id: 'persist-playbook-1',
+      name: 'Persistent Playbook',
+      applicability: {
+        situations: ['Test persistence'],
+        triggers: ['persist'],
+        antiPatterns: [],
+        domains: ['test'],
+      },
+      guidance: {
+        strategy: 'Persist this',
+        tactics: [],
+      },
+      verification: {
+        successIndicators: [],
+        failureIndicators: [],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 0,
+        failureCount: 0,
+      },
+      confidence: 0.7,
+      complexity: 'simple',
+      estimatedEffort: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await atlas1.close();
+
+    // Second session - verify data persisted
+    const atlas2 = createAtlasWithAgents([createMockBackend()], {
+      storage: { baseDir: tempDir },
+    });
+    await atlas2.init();
+
+    const stats = await atlas2.getStats();
+    expect(stats.memory.experienceCount).toBe(1);
+    expect(stats.memory.playbookCount).toBe(1);
+
+    const memory2 = atlas2.getMemory();
+    const exp = await memory2.experiences.get('persist-exp-1');
+    expect(exp?.taskInput).toBe('Persistent experience');
+
+    const playbook = await memory2.playbooks.get('persist-playbook-1');
+    expect(playbook?.name).toBe('Persistent Playbook');
+
+    await atlas2.close();
+  });
+
+  it('should persist skill library state', async () => {
+    // First session
+    const atlas1 = createAtlasWithAgents([createMockBackend()], {
+      storage: { baseDir: tempDir },
+    });
+    await atlas1.init();
+
+    const memory1 = atlas1.getMemory();
+    const skillLibrary1 = atlas1.getSkillLibrary();
+
+    // Add playbook and record outcomes
+    await memory1.playbooks.add({
+      id: 'skill-persist',
+      name: 'Skill Persist Test',
+      applicability: {
+        situations: ['Test'],
+        triggers: ['test'],
+        antiPatterns: [],
+        domains: ['test'],
+      },
+      guidance: {
+        strategy: 'Test',
+        tactics: [],
+      },
+      verification: {
+        successIndicators: [],
+        failureIndicators: [],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 5,
+        failureCount: 0,
+      },
+      confidence: 0.85,
+      complexity: 'simple',
+      estimatedEffort: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await skillLibrary1?.refreshTiers();
+
+    // Record failures
+    await skillLibrary1?.recordOutcome('skill-persist', 'traj-1', false);
+    await skillLibrary1?.recordOutcome('skill-persist', 'traj-2', false);
+
+    // Export failure state for verification
+    const failureState = skillLibrary1?.exportFailureState();
+    expect(failureState?.['skill-persist']).toBe(2);
+
+    await atlas1.close();
+
+    // Note: Failure state is in-memory only, but playbook state persists
+    const atlas2 = createAtlasWithAgents([createMockBackend()], {
+      storage: { baseDir: tempDir },
+    });
+    await atlas2.init();
+
+    const memory2 = atlas2.getMemory();
+    const playbook = await memory2.playbooks.get('skill-persist');
+    expect(playbook).toBeDefined();
+
+    await atlas2.close();
+  });
+});
+
+describe('Integration: Playbook Usage Inference', () => {
+  let tempDir: string;
+  let atlas: Atlas;
+  let mockBackend: MockBackend;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-usage-test-'));
+    mockBackend = createMockBackend({
+      success: true,
+      result: 'Done',
+      durationMs: 30,
+      messages: [
+        { role: 'assistant', content: 'Following the authentication fix playbook...' },
+        { role: 'assistant', content: 'Checking token validation as suggested...' },
+      ],
+    });
+
+    atlas = createAtlasWithAgents([mockBackend], {
+      storage: { baseDir: tempDir },
+      execution: {
+        defaultAgentType: 'mock',
+      },
+    });
+    await atlas.init();
+  });
+
+  afterEach(async () => {
+    await atlas.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should infer playbook usage from trajectory', async () => {
+    const memory = atlas.getMemory();
+
+    // Add playbook
+    await memory.playbooks.add({
+      id: 'auth-fix-playbook',
+      name: 'Authentication Fix',
+      applicability: {
+        situations: ['Fix auth issue'],
+        triggers: ['authentication', 'token', 'auth'],
+        antiPatterns: [],
+        domains: ['auth'],
+      },
+      guidance: {
+        strategy: 'Check token validation and fix',
+        tactics: ['Validate tokens', 'Check expiry'],
+      },
+      verification: {
+        successIndicators: ['Auth works'],
+        failureIndicators: ['Auth fails'],
+      },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 5,
+        failureCount: 0,
+      },
+      confidence: 0.8,
+      complexity: 'moderate',
+      estimatedEffort: 2,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await atlas.getSkillLibrary()?.refreshTiers();
+
+    const task = createTask({
+      domain: 'auth',
+      description: 'Fix authentication token validation issue',
+    });
+
+    const result = await atlas.solve(task);
+
+    // Usage inference should have run
+    expect(result.injectedPlaybooks).toBeDefined();
+  });
+
+  it('should track all injected playbooks', async () => {
+    const memory = atlas.getMemory();
+
+    // Add multiple playbooks
+    await memory.playbooks.add({
+      id: 'playbook-a',
+      name: 'Playbook A',
+      applicability: {
+        situations: ['Test situation A'],
+        triggers: ['test-a'],
+        antiPatterns: [],
+        domains: ['test'],
+      },
+      guidance: { strategy: 'Strategy A', tactics: [] },
+      verification: { successIndicators: [], failureIndicators: [] },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 3,
+        failureCount: 0,
+      },
+      confidence: 0.75,
+      complexity: 'simple',
+      estimatedEffort: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await memory.playbooks.add({
+      id: 'playbook-b',
+      name: 'Playbook B',
+      applicability: {
+        situations: ['Test situation B'],
+        triggers: ['test-b'],
+        antiPatterns: [],
+        domains: ['test'],
+      },
+      guidance: { strategy: 'Strategy B', tactics: [] },
+      verification: { successIndicators: [], failureIndicators: [] },
+      evolution: {
+        version: '1.0.0',
+        createdFrom: [],
+        failures: [],
+        refinements: [],
+        successCount: 3,
+        failureCount: 0,
+      },
+      confidence: 0.75,
+      complexity: 'simple',
+      estimatedEffort: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await atlas.getSkillLibrary()?.refreshTiers();
+
+    const task = createTask({
+      domain: 'test',
+      description: 'Test task for tracking',
+    });
+
+    const result = await atlas.solve(task);
+
+    // Should have tracked injected playbooks (may include playbooks from router context)
+    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);
+  });
+});