cognitive-core 0.0.1 → 0.1.0

package/tests/integration/e2e.test.ts

@@ -0,0 +1,929 @@
+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 { 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();
+  });
+});