cognitive-core 0.2.0 → 0.2.2

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

@@ -0,0 +1,794 @@
+/**
+ * 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);
+    });
+  });
+});