cognitive-core 0.2.5 → 0.3.1

package/tests/integration/e2e.test.ts

@@ -1,1337 +0,0 @@
-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',
-    ];
-
-    let lastResult: any;
-    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',
-      });
-
-      lastResult = await atlas.processTrajectory(trajectory);
-    }
-
-    // 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 () => {
-    // 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({
-      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);
-  });
-});