cognitive-core 0.2.5 → 0.3.1

package/tests/integration/pipeline-data-correctness.test.ts

@@ -1,794 +0,0 @@
-/**
- * Pipeline Data-Correctness Integration Tests
- *
- * Validates that the learning pipeline properly:
- * 1. Identifies improvement points from trajectories (analysis)
- * 2. Writes through to memory stores (experience, playbook, causal, reflexion)
- * 3. Makes stored data retrievable via the correct query paths
- * 4. Handles batch extraction → playbook library indexing
- * 5. Coordinates hot + cold paths correctly
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { InstantLoop } from '../../src/learning/instant-loop.js';
-import { LearningPipeline, createLearningPipeline } from '../../src/learning/pipeline.js';
-import { LoopCoordinator } from '../../src/learning/loop-coordinator.js';
-import { MemorySystem } from '../../src/memory/system.js';
-import { createPlaybook } from '../../src/types/playbook.js';
-import { createTrajectory, type Trajectory } from '../../src/types/trajectory.js';
-import { createTask } from '../../src/types/task.js';
-import { createStep } from '../../src/types/step.js';
-import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
-import { createSqlitePersistence, type SqlitePersistence } from '../../src/persistence/index.js';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeSuccessTrajectory(opts?: {
-  domain?: string;
-  description?: string;
-  id?: string;
-}): Trajectory {
-  return createTrajectory({
-    id: opts?.id,
-    task: createTask({
-      description: opts?.description ?? 'Fix the broken authentication module',
-      domain: opts?.domain ?? 'typescript',
-    }),
-    steps: [
-      createStep({
-        thought: 'Need to read the auth module',
-        action: 'ReadFile src/auth.ts',
-        observation: 'File content: export function login() { /* ... */ }',
-      }),
-      createStep({
-        thought: 'Found the bug — missing null check',
-        action: 'EditFile src/auth.ts',
-        observation: 'File updated: added null check for user token',
-        metadata: { attributionScore: 0.9 },
-      }),
-      createStep({
-        action: 'RunTests npm test',
-        observation: 'All 42 tests passed',
-      }),
-    ],
-    outcome: successOutcome('Added null check in login() to prevent crash on undefined token'),
-    agentId: 'test-agent',
-  });
-}
-
-function makeFailureTrajectory(opts?: {
-  domain?: string;
-  description?: string;
-  errorInfo?: string;
-}): Trajectory {
-  return createTrajectory({
-    task: createTask({
-      description: opts?.description ?? 'Fix the database connection timeout',
-      domain: opts?.domain ?? 'typescript',
-    }),
-    steps: [
-      createStep({
-        thought: 'Check db config',
-        action: 'ReadFile src/db.ts',
-        observation: 'File content: const pool = createPool({ timeout: 5000 })',
-      }),
-      createStep({
-        thought: 'Try increasing timeout',
-        action: 'EditFile src/db.ts',
-        observation: 'File updated: timeout: 30000',
-      }),
-    ],
-    outcome: failureOutcome(opts?.errorInfo ?? 'ECONNREFUSED 127.0.0.1:5432 - database server not running'),
-    agentId: 'test-agent',
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Test suite
-// ---------------------------------------------------------------------------
-
-describe('Pipeline Data Correctness', () => {
-  let tempDir: string;
-  let persistence: SqlitePersistence;
-  let memory: MemorySystem;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'atlas-data-correctness-'));
-    persistence = createSqlitePersistence({ baseDir: tempDir });
-    await persistence.init();
-    memory = new MemorySystem(persistence, tempDir);
-    await memory.init();
-  });
-
-  afterEach(async () => {
-    await memory.close();
-    persistence.close();
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  // =========================================================================
-  // 1. InstantLoop → Memory store write-through
-  // =========================================================================
-  describe('InstantLoop write-through to memory stores', () => {
-    let loop: InstantLoop;
-
-    beforeEach(() => {
-      loop = new InstantLoop(memory);
-    });
-
-    it('should store experience that is retrievable by ID and by similarity', async () => {
-      const trajectory = makeSuccessTrajectory();
-      const result = await loop.process(trajectory);
-
-      // Verify retrievable by ID
-      const exp = await memory.experiences.get(result.experienceId);
-      expect(exp).toBeDefined();
-      expect(exp!.taskInput).toBe(trajectory.task.description);
-      expect(exp!.success).toBe(true);
-
-      // Verify retrievable by similarity search
-      const similar = await memory.experiences.findSimilar(
-        'authentication module bug fix',
-        { k: 5 }
-      );
-      expect(similar.length).toBeGreaterThanOrEqual(1);
-      expect(similar.some(s => s.experience.id === result.experienceId)).toBe(true);
-    });
-
-    it('should store causal edge for failed trajectory that is queryable', async () => {
-      const trajectory = makeFailureTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.causalEdgesExtracted).toBeGreaterThanOrEqual(1);
-
-      // Verify edge stored in CausalStore and queryable
-      const edges = await memory.causal.getByDomain('typescript');
-      expect(edges.length).toBeGreaterThanOrEqual(1);
-
-      const failureEdge = edges.find(e => e.id === `ce-fail-${trajectory.id}`);
-      expect(failureEdge).toBeDefined();
-      expect(failureEdge!.cause).toContain('database connection timeout');
-      expect(failureEdge!.effect).toContain('ECONNREFUSED');
-      expect(failureEdge!.confidence).toBe(0.4);
-    });
-
-    it('should store causal edge for successful trajectory with approach→outcome', async () => {
-      const trajectory = makeSuccessTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.causalEdgesExtracted).toBeGreaterThanOrEqual(1);
-
-      const edges = await memory.causal.getByDomain('typescript');
-      const successEdge = edges.find(e => e.id === `ce-succ-${trajectory.id}`);
-      expect(successEdge).toBeDefined();
-      expect(successEdge!.cause).toContain('authentication');
-      expect(successEdge!.effect).toContain('null check');
-      expect(successEdge!.confidence).toBe(0.7);
-    });
-
-    it('should generate and store reflexion episode that is queryable by trajectory', async () => {
-      const trajectory = makeFailureTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.reflexionEpisodeId).toBeDefined();
-
-      // Verify reflexion stored and retrievable
-      const episode = await memory.reflexion.getByTrajectory(trajectory.id);
-      expect(episode).toBeDefined();
-      expect(episode!.id).toBe(result.reflexionEpisodeId);
-      expect(episode!.trajectoryId).toBe(trajectory.id);
-      expect(episode!.outcome).toBe('failure');
-      expect(episode!.selfCritique).toBeTruthy();
-    });
-
-    it('should generate reflexion episode for successful trajectory too', async () => {
-      const trajectory = makeSuccessTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.reflexionEpisodeId).toBeDefined();
-
-      const episode = await memory.reflexion.getByTrajectory(trajectory.id);
-      expect(episode).toBeDefined();
-      expect(episode!.outcome).toBe('success');
-    });
-
-    it('should bump playbook confidence on success and persist the change', async () => {
-      const playbook = createPlaybook({
-        name: 'fix-auth-bugs',
-        confidence: 0.5,
-        applicability: {
-          situations: ['authentication bug', 'auth module error'],
-          triggers: ['authentication', 'auth module'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: {
-          strategy: 'Check null references in auth flow',
-          tactics: ['add null checks', 'verify token handling'],
-          steps: [],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      const trajectory = makeSuccessTrajectory({
-        description: 'Fix the authentication module crash',
-      });
-      const result = await loop.process(trajectory);
-
-      // Verify confidence was bumped
-      const match = result.matchedPlaybooks.find(m => m.id === playbook.id);
-      expect(match).toBeDefined();
-      expect(match!.confidenceDelta).toBeGreaterThan(0);
-
-      // Verify persisted value reflects the bump
-      const updated = await memory.playbooks.get(playbook.id);
-      expect(updated).toBeDefined();
-      expect(updated!.confidence).toBeGreaterThan(0.5);
-      expect(updated!.evolution.successCount).toBeGreaterThan(0);
-    });
-
-    it('should decrease playbook confidence on failure and record failure context', async () => {
-      const playbook = createPlaybook({
-        name: 'fix-db-timeout',
-        confidence: 0.7,
-        applicability: {
-          situations: ['database connection timeout'],
-          triggers: ['database timeout', 'connection timeout'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: {
-          strategy: 'Increase pool timeout',
-          tactics: [],
-          steps: [],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      const trajectory = makeFailureTrajectory({
-        description: 'Fix the database connection timeout issue',
-      });
-      const result = await loop.process(trajectory);
-
-      const match = result.matchedPlaybooks.find(m => m.id === playbook.id);
-      if (match) {
-        expect(match.confidenceDelta).toBeLessThan(0);
-      }
-
-      // Verify failure recorded in evolution
-      const updated = await memory.playbooks.get(playbook.id);
-      expect(updated).toBeDefined();
-      expect(updated!.confidence).toBeLessThan(0.7);
-      expect(updated!.evolution.failureCount).toBeGreaterThan(0);
-    });
-
-    it('should process multiple trajectories and each writes independently', async () => {
-      const t1 = makeSuccessTrajectory({ description: 'Fix auth bug', domain: 'auth' });
-      const t2 = makeFailureTrajectory({ description: 'Fix DB issue', domain: 'database' });
-      const t3 = makeSuccessTrajectory({ description: 'Fix CSS layout', domain: 'frontend' });
-
-      const r1 = await loop.process(t1);
-      const r2 = await loop.process(t2);
-      const r3 = await loop.process(t3);
-
-      // All three experiences should exist
-      const e1 = await memory.experiences.get(r1.experienceId);
-      const e2 = await memory.experiences.get(r2.experienceId);
-      const e3 = await memory.experiences.get(r3.experienceId);
-      expect(e1).toBeDefined();
-      expect(e2).toBeDefined();
-      expect(e3).toBeDefined();
-
-      // Total experience count should be 3
-      const allExperiences = await memory.experiences.getAll();
-      expect(allExperiences.length).toBe(3);
-
-      // Causal edges should exist for all trajectories
-      const authEdges = await memory.causal.getByDomain('auth');
-      const dbEdges = await memory.causal.getByDomain('database');
-      const feEdges = await memory.causal.getByDomain('frontend');
-      expect(authEdges.length).toBeGreaterThanOrEqual(1);
-      expect(dbEdges.length).toBeGreaterThanOrEqual(1);
-      expect(feEdges.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  // =========================================================================
-  // 2. Batch pipeline → playbook extraction → library indexing
-  // =========================================================================
-  describe('Batch pipeline playbook extraction and indexing', () => {
-    let pipeline: LearningPipeline;
-
-    beforeEach(() => {
-      pipeline = createLearningPipeline(
-        memory,
-        {
-          minTrajectories: 2,
-          deduplicationThreshold: 0.95, // High threshold so similar tasks create new playbooks
-          minSuccessRate: 0.5,
-          maxExperiences: 1000,
-        },
-        { enableTemporalCompression: false, enableReasoningBank: false },
-      );
-    });
-
-    it('should extract playbooks from successful trajectories and make them findable', async () => {
-      // Feed enough similar successful trajectories to trigger extraction
-      for (let i = 0; i < 4; i++) {
-        const t = makeSuccessTrajectory({
-          description: `Fix authentication null pointer in module ${i}`,
-          domain: 'typescript',
-        });
-        await pipeline.processTrajectory(t);
-      }
-
-      const batchResult = await pipeline.runBatchLearning();
-      expect(batchResult.trajectoriesProcessed).toBe(4);
-
-      if (batchResult.playbooksExtracted > 0) {
-        // Verify extracted playbooks are findable via findMatching
-        const matches = await memory.playbooks.findMatching(
-          'Fix authentication null pointer bug',
-          { k: 5, domains: ['typescript'] }
-        );
-        expect(matches.length).toBeGreaterThanOrEqual(1);
-      }
-
-      // Regardless of extraction, all 4 experiences should be stored
-      const allExperiences = await memory.experiences.getAll();
-      expect(allExperiences.length).toBe(4);
-    });
-
-    it('should accumulate analyses with correct credit assignment', async () => {
-      const trajectory = makeSuccessTrajectory();
-      const result = await pipeline.processTrajectory(trajectory);
-
-      expect(result.analysis).toBeDefined();
-      expect(result.analysis.success).toBe(true);
-      expect(result.analysis.stepAttribution.length).toBe(trajectory.steps.length);
-
-      // Key steps should be identified (steps with highest attribution)
-      expect(result.analysis.keySteps.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should identify error patterns from failed trajectories', async () => {
-      const trajectory = makeFailureTrajectory({
-        errorInfo: 'TypeError: Cannot read properties of undefined (reading "token")',
-      });
-      const result = await pipeline.processTrajectory(trajectory);
-
-      expect(result.analysis.success).toBe(false);
-      expect(result.analysis.errorPatterns).toBeDefined();
-      expect(result.analysis.errorPatterns!.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should run temporal compression on batch and update experiences', async () => {
-      const pipelineWithCompression = createLearningPipeline(
-        memory,
-        { minTrajectories: 2, maxExperiences: 1000 },
-        { enableTemporalCompression: true, enableReasoningBank: false },
-      );
-
-      // Process trajectories
-      for (let i = 0; i < 3; i++) {
-        await pipelineWithCompression.processTrajectory(
-          makeSuccessTrajectory({ description: `Task ${i}` })
-        );
-      }
-
-      const batchResult = await pipelineWithCompression.runBatchLearning();
-      expect(batchResult.trajectoriesProcessed).toBe(3);
-
-      // After compression, experiences should still be queryable
-      const all = await memory.experiences.getAll();
-      expect(all.length).toBeGreaterThan(0);
-    });
-
-    it('should build reasoning clusters in batch and persist them', async () => {
-      const pipelineWithClustering = createLearningPipeline(
-        memory,
-        { minTrajectories: 2, maxExperiences: 1000 },
-        { enableTemporalCompression: false, enableReasoningBank: true },
-        persistence,
-      );
-
-      // Process enough trajectories for clustering
-      for (let i = 0; i < 5; i++) {
-        await pipelineWithClustering.processTrajectory(
-          makeSuccessTrajectory({ description: `Fix module issue #${i}` })
-        );
-      }
-
-      const batchResult = await pipelineWithClustering.runBatchLearning();
-      expect(batchResult.experiencesClustered).toBeGreaterThanOrEqual(5);
-    });
-  });
-
-  // =========================================================================
-  // 3. LoopCoordinator → hot + cold path coordination
-  // =========================================================================
-  describe('LoopCoordinator hot+cold path coordination', () => {
-    let loop: InstantLoop;
-    let coordinator: LoopCoordinator;
-
-    beforeEach(() => {
-      loop = new InstantLoop(memory);
-      coordinator = new LoopCoordinator(loop, { batchThreshold: 3 }, persistence);
-    });
-
-    it('should process via instant loop and track pending count', async () => {
-      const t1 = makeSuccessTrajectory({ description: 'Task A' });
-      const t2 = makeFailureTrajectory({ description: 'Task B' });
-
-      await coordinator.onTrajectoryComplete(t1);
-      expect(coordinator.getPendingCount()).toBe(1);
-      expect(coordinator.shouldRunBatch()).toBe(false);
-
-      await coordinator.onTrajectoryComplete(t2);
-      expect(coordinator.getPendingCount()).toBe(2);
-      expect(coordinator.shouldRunBatch()).toBe(false);
-    });
-
-    it('should signal batch at threshold', async () => {
-      for (let i = 0; i < 3; i++) {
-        await coordinator.onTrajectoryComplete(
-          makeSuccessTrajectory({ description: `Task ${i}` })
-        );
-      }
-      expect(coordinator.shouldRunBatch()).toBe(true);
-      expect(coordinator.getPendingCount()).toBe(3);
-    });
-
-    it('should reset pending count after batch acknowledged', async () => {
-      for (let i = 0; i < 3; i++) {
-        await coordinator.onTrajectoryComplete(
-          makeSuccessTrajectory({ description: `Task ${i}` })
-        );
-      }
-      expect(coordinator.shouldRunBatch()).toBe(true);
-
-      coordinator.resetPendingCount();
-      expect(coordinator.getPendingCount()).toBe(0);
-      expect(coordinator.shouldRunBatch()).toBe(false);
-    });
-
-    it('should persist pending count and restore on new coordinator', async () => {
-      // Process 2 trajectories
-      await coordinator.onTrajectoryComplete(makeSuccessTrajectory({ description: 'T1' }));
-      await coordinator.onTrajectoryComplete(makeSuccessTrajectory({ description: 'T2' }));
-      expect(coordinator.getPendingCount()).toBe(2);
-
-      // Create a new coordinator with same persistence — should restore count
-      const loop2 = new InstantLoop(memory);
-      const coordinator2 = new LoopCoordinator(loop2, { batchThreshold: 3 }, persistence);
-      expect(coordinator2.getPendingCount()).toBe(2);
-    });
-
-    it('should persist reset and restore zero', async () => {
-      await coordinator.onTrajectoryComplete(makeSuccessTrajectory({ description: 'T1' }));
-      coordinator.resetPendingCount();
-
-      const loop2 = new InstantLoop(memory);
-      const coordinator2 = new LoopCoordinator(loop2, { batchThreshold: 3 }, persistence);
-      expect(coordinator2.getPendingCount()).toBe(0);
-    });
-
-    it('should store all experiences in memory during hot path', async () => {
-      const trajectories: Trajectory[] = [];
-      for (let i = 0; i < 4; i++) {
-        const t = makeSuccessTrajectory({ description: `Coordinator task ${i}` });
-        trajectories.push(t);
-        await coordinator.onTrajectoryComplete(t);
-      }
-
-      // All 4 should be in memory
-      const all = await memory.experiences.getAll();
-      expect(all.length).toBe(4);
-
-      // Each should have reflexion
-      for (const t of trajectories) {
-        const episode = await memory.reflexion.getByTrajectory(t.id);
-        expect(episode).toBeDefined();
-      }
-    });
-  });
-
-  // =========================================================================
-  // 4. End-to-end: hot path → batch → verify all stores
-  // =========================================================================
-  describe('End-to-end hot path → batch → store verification', () => {
-    it('should properly flow trajectory through instant loop then batch', async () => {
-      const loop = new InstantLoop(memory);
-      const coordinator = new LoopCoordinator(loop, { batchThreshold: 3 }, persistence);
-      const pipeline = createLearningPipeline(
-        memory,
-        { minTrajectories: 3, maxExperiences: 1000 },
-        { enableTemporalCompression: true, enableReasoningBank: true },
-        persistence,
-      );
-
-      // Hot path: process 4 trajectories
-      const trajectories: Trajectory[] = [];
-      for (let i = 0; i < 4; i++) {
-        const t = i < 3
-          ? makeSuccessTrajectory({ description: `Fix auth issue variant ${i}`, domain: 'auth' })
-          : makeFailureTrajectory({ description: 'Fix auth timeout', domain: 'auth' });
-        trajectories.push(t);
-        await coordinator.onTrajectoryComplete(t);
-        // Also feed into pipeline (skipStore since instant loop already stored)
-        await pipeline.processTrajectory(t, { skipStore: true });
-      }
-
-      // Verify hot-path wrote everything
-      expect(coordinator.shouldRunBatch()).toBe(true);
-      const allExperiences = await memory.experiences.getAll();
-      expect(allExperiences.length).toBe(4);
-
-      // Verify reflexion episodes exist for all
-      for (const t of trajectories) {
-        const episode = await memory.reflexion.getByTrajectory(t.id);
-        expect(episode).toBeDefined();
-      }
-
-      // Verify causal edges exist (similar edges may be merged by CausalStore)
-      const causalEdges = await memory.causal.getByDomain('auth');
-      expect(causalEdges.length).toBeGreaterThanOrEqual(2); // At least success + failure patterns
-
-      // Cold path: run batch
-      const batchResult = await pipeline.runBatchLearning();
-      expect(batchResult.trajectoriesProcessed).toBe(4);
-      expect(batchResult.successRate).toBeCloseTo(0.75, 2);
-
-      // After batch, experiences should still be queryable
-      const postBatchExperiences = await memory.experiences.getAll();
-      expect(postBatchExperiences.length).toBeGreaterThan(0);
-
-      // Reset coordinator
-      coordinator.resetPendingCount();
-      expect(coordinator.getPendingCount()).toBe(0);
-    });
-
-    it('should not double-store experiences when skipStore is used', async () => {
-      const loop = new InstantLoop(memory);
-      const pipeline = createLearningPipeline(memory, { minTrajectories: 1 });
-
-      const trajectory = makeSuccessTrajectory();
-
-      // Hot path stores it
-      await loop.process(trajectory);
-
-      // Cold path with skipStore
-      await pipeline.processTrajectory(trajectory, { skipStore: true });
-
-      // Should only have 1 experience, not 2
-      const byTrajectory = await memory.experiences.getByTrajectory(trajectory.id);
-      expect(byTrajectory.length).toBe(1);
-    });
-
-    it('should double-store when skipStore is not used (documents expected behavior)', async () => {
-      const loop = new InstantLoop(memory);
-      const pipeline = createLearningPipeline(memory, { minTrajectories: 1 });
-
-      const trajectory = makeSuccessTrajectory();
-
-      // Hot path stores it
-      await loop.process(trajectory);
-
-      // Cold path without skipStore — stores again
-      await pipeline.processTrajectory(trajectory);
-
-      // Two experiences from the same trajectory
-      const byTrajectory = await memory.experiences.getByTrajectory(trajectory.id);
-      expect(byTrajectory.length).toBe(2);
-    });
-  });
-
-  // =========================================================================
-  // 5. Analysis quality — credit assignment and error patterns
-  // =========================================================================
-  describe('Analysis quality and improvement identification', () => {
-    let pipeline: LearningPipeline;
-
-    beforeEach(() => {
-      pipeline = createLearningPipeline(memory, { minTrajectories: 1 });
-    });
-
-    it('should correctly identify key steps with high attribution', async () => {
-      const trajectory = createTrajectory({
-        task: createTask({
-          description: 'Fix the rendering bug',
-          domain: 'frontend',
-        }),
-        steps: [
-          createStep({ action: 'ReadFile src/component.tsx', observation: 'JSX code' }),
-          createStep({ action: 'ReadFile src/styles.css', observation: 'CSS code' }),
-          createStep({
-            thought: 'Found the bug — z-index conflict',
-            action: 'EditFile src/styles.css',
-            observation: 'Fixed z-index from 1 to 10',
-          }),
-          createStep({ action: 'RunTests npm test', observation: 'All tests pass' }),
-        ],
-        outcome: successOutcome('Fixed z-index conflict in styles.css'),
-        agentId: 'test-agent',
-      });
-
-      const result = await pipeline.processTrajectory(trajectory);
-
-      // The edit step (index 2) should have high attribution
-      expect(result.analysis.stepAttribution.length).toBe(4);
-      expect(result.analysis.keySteps.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should mark trajectory with many steps as abstractable', async () => {
-      const trajectory = createTrajectory({
-        task: createTask({
-          description: 'Fix the flaky test',
-          domain: 'testing',
-        }),
-        steps: [
-          createStep({ action: 'RunTests npm test', observation: 'Test failed: timeout' }),
-          createStep({ action: 'EditFile src/test.ts', observation: 'Updated timeout' }),
-          createStep({ action: 'RunTests npm test', observation: 'Test failed: timeout' }),
-          createStep({ action: 'EditFile src/test.ts', observation: 'Increased timeout more' }),
-          createStep({ action: 'RunTests npm test', observation: 'Test passed' }),
-        ],
-        outcome: successOutcome('Increased test timeout'),
-        agentId: 'test-agent',
-      });
-
-      const result = await pipeline.processTrajectory(trajectory);
-
-      // A successful trajectory with multiple steps should be abstractable
-      expect(result.analysis.success).toBe(true);
-      expect(result.analysis.stepAttribution.length).toBe(5);
-    });
-
-    it('should classify error patterns in failed trajectories', async () => {
-      const trajectory = createTrajectory({
-        task: createTask({
-          description: 'Deploy the application',
-          domain: 'devops',
-        }),
-        steps: [
-          createStep({ action: 'RunCommand docker build .', observation: 'Build complete' }),
-          createStep({
-            action: 'RunCommand docker push registry/app:latest',
-            observation: 'Error: denied: access forbidden',
-          }),
-        ],
-        outcome: failureOutcome('Permission denied: docker push requires authentication'),
-        agentId: 'test-agent',
-      });
-
-      const result = await pipeline.processTrajectory(trajectory);
-
-      expect(result.analysis.success).toBe(false);
-      expect(result.analysis.errorPatterns).toBeDefined();
-      expect(result.analysis.errorPatterns!.length).toBeGreaterThanOrEqual(1);
-      // The error should be classified (from our error-classifier)
-      expect(result.analysis.errorPatterns![0].type).toBeDefined();
-    });
-  });
-
-  // =========================================================================
-  // 6. Playbook evolution — success/failure tracking updates playbook state
-  // =========================================================================
-  describe('Playbook evolution through learning', () => {
-    it('should track success count and version through multiple trajectories', async () => {
-      const playbook = createPlaybook({
-        name: 'fix-broken-authentication-module',
-        confidence: 0.5,
-        applicability: {
-          situations: ['Fix the broken authentication module', 'authentication module is broken'],
-          triggers: ['broken authentication module', 'authentication module'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: {
-          strategy: 'Add null checks in authentication flow',
-          tactics: ['check token', 'verify user object'],
-          steps: [],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      const loop = new InstantLoop(memory);
-
-      // Process 3 successful trajectories that match this playbook's triggers
-      for (let i = 0; i < 3; i++) {
-        await loop.process(
-          makeSuccessTrajectory({
-            description: 'Fix the broken authentication module',
-            domain: 'typescript',
-          })
-        );
-      }
-
-      const updated = await memory.playbooks.get(playbook.id);
-      expect(updated).toBeDefined();
-      expect(updated!.confidence).toBeGreaterThan(0.5);
-      expect(updated!.evolution.successCount).toBeGreaterThanOrEqual(3);
-    });
-
-    it('should track failure context for later analysis', async () => {
-      const playbook = createPlaybook({
-        name: 'increase-timeout',
-        confidence: 0.6,
-        applicability: {
-          situations: ['connection timeout', 'request timeout'],
-          triggers: ['timeout'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: {
-          strategy: 'Increase timeout values',
-          tactics: [],
-          steps: [],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      const loop = new InstantLoop(memory);
-
-      // Process 2 failures
-      for (let i = 0; i < 2; i++) {
-        await loop.process(
-          makeFailureTrajectory({
-            description: `Fix connection timeout in service ${i}`,
-            errorInfo: `ECONNREFUSED: service ${i} unreachable`,
-          })
-        );
-      }
-
-      const updated = await memory.playbooks.get(playbook.id);
-      expect(updated).toBeDefined();
-      expect(updated!.confidence).toBeLessThan(0.6);
-      expect(updated!.evolution.failureCount).toBeGreaterThanOrEqual(2);
-      expect(updated!.evolution.failures.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  // =========================================================================
-  // 7. Cross-store consistency — domain partitioning
-  // =========================================================================
-  describe('Cross-store domain consistency', () => {
-    it('should partition data by domain across all stores', async () => {
-      const loop = new InstantLoop(memory);
-
-      // Process trajectories from different domains
-      await loop.process(makeSuccessTrajectory({ description: 'Fix auth bug', domain: 'auth' }));
-      await loop.process(makeSuccessTrajectory({ description: 'Fix UI layout', domain: 'frontend' }));
-      await loop.process(makeFailureTrajectory({ description: 'Fix DB query', domain: 'database' }));
-
-      // Experiences should be queryable by domain
-      const authExperiences = await memory.experiences.findSimilar(
-        'authentication',
-        { k: 10, domain: 'auth' }
-      );
-      const feExperiences = await memory.experiences.findSimilar(
-        'UI layout',
-        { k: 10, domain: 'frontend' }
-      );
-
-      // Each domain query should return results from that domain
-      for (const { experience } of authExperiences) {
-        expect(experience.domain).toBe('auth');
-      }
-      for (const { experience } of feExperiences) {
-        expect(experience.domain).toBe('frontend');
-      }
-
-      // Causal edges should be domain-partitioned
-      const authEdges = await memory.causal.getByDomain('auth');
-      const dbEdges = await memory.causal.getByDomain('database');
-      expect(authEdges.every(e => e.domain === 'auth')).toBe(true);
-      expect(dbEdges.every(e => e.domain === 'database')).toBe(true);
-    });
-  });
-});