cognitive-core 0.1.0 → 0.2.0

package/tests/integration/phase-e2e.test.ts

@@ -0,0 +1,1143 @@
+/**
+ * End-to-end integration tests for Phase 0-5 modules.
+ *
+ * Exercises the full data flow:
+ *   Trajectory → UnifiedLearningPipeline (instant + batch + maintenance)
+ *   → TemporalCompressor → ReasoningBank clustering
+ *   + CausalStore edges, ReflexionMemory episodes, CoherenceChecker,
+ *     MoEGate routing, InvertedIndex narrowing, PartitionedStore
+ *
+ * These tests use real (non-mocked) components wired together to catch
+ * integration bugs that unit tests miss.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import {
+  createTrajectory,
+  createStep,
+  createTask,
+  successOutcome,
+  failureOutcome,
+  type Trajectory,
+} from '../../src/types/index.js';
+
+import { MemorySystem } from '../../src/memory/system.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
+import { UnifiedLearningPipeline, createUnifiedPipeline } from '../../src/learning/unified-pipeline.js';
+import { InstantLoop, createInstantLoop } from '../../src/learning/instant-loop.js';
+import { ReflexionGenerator, createReflexionGenerator } from '../../src/learning/reflexion-generator.js';
+import { ReasoningBank, createReasoningBank } from '../../src/memory/reasoning-bank.js';
+import { TemporalCompressor, createTemporalCompressor } from '../../src/memory/temporal-compressor.js';
+import { CausalStore, createCausalStore } from '../../src/memory/causal-store.js';
+import { CoherenceChecker, createCoherenceChecker } from '../../src/memory/coherence.js';
+import { InvertedIndex } from '../../src/embeddings/inverted-index.js';
+import { PartitionedStore } from '../../src/utils/partitioned-store.js';
+import {
+  MoEGate,
+  createMoEGate,
+  extractTaskFeatures,
+  MOE_FEATURE_SIZE,
+  MOE_STRATEGIES,
+} from '../../src/search/moe-gate.js';
+import { createObservation, type KnowledgeNote } from '../../src/types/knowledge.js';
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+let testDir: string;
+
+function makeTrajectory(
+  description: string,
+  success: boolean,
+  domain = 'code',
+  opts?: {
+    steps?: ReturnType<typeof createStep>[];
+    errorInfo?: string;
+    solution?: unknown;
+  }
+): Trajectory {
+  const defaultSteps = [
+    createStep({
+      thought: 'Analyzing the task requirements',
+      action: 'Read src/main.ts',
+      observation: 'file contents: export function main() {}',
+      attributionScore: 0.6,
+    }),
+    createStep({
+      thought: 'Implementing the solution',
+      action: 'Edit src/main.ts',
+      observation: success ? 'file updated successfully' : 'error: syntax error in file',
+      attributionScore: success ? 0.9 : 0.2,
+    }),
+    createStep({
+      thought: 'Verifying the result',
+      action: 'Bash npm test',
+      observation: success
+        ? 'All tests passed'
+        : `error: test failed - ${opts?.errorInfo ?? 'assertion error'}`,
+      attributionScore: success ? 0.8 : 0.1,
+    }),
+  ];
+
+  return createTrajectory({
+    task: createTask({ domain, description }),
+    steps: opts?.steps ?? defaultSteps,
+    outcome: success
+      ? successOutcome({ result: opts?.solution ?? 'completed' })
+      : failureOutcome(opts?.errorInfo ?? 'Task failed'),
+    agentId: 'test-agent',
+  });
+}
+
+function makeVariedTrajectories(count: number, successRate: number, domain = 'code'): Trajectory[] {
+  const trajectories: Trajectory[] = [];
+  const successCount = Math.round(count * successRate);
+  const topics = [
+    'Fix authentication bug in login form',
+    'Implement user registration endpoint',
+    'Add pagination to user list API',
+    'Fix database connection timeout error',
+    'Implement rate limiting middleware',
+    'Add input validation to payment form',
+    'Fix memory leak in event handler',
+    'Implement caching layer for API responses',
+    'Add error handling to file upload',
+    'Fix CSS layout issue in dashboard',
+    'Implement search functionality with filters',
+    'Add unit tests for authentication module',
+    'Fix type error in configuration parser',
+    'Implement webhook notification system',
+    'Add logging middleware for request tracing',
+  ];
+
+  for (let i = 0; i < count; i++) {
+    const isSuccess = i < successCount;
+    const desc = topics[i % topics.length] + ` (variant ${Math.floor(i / topics.length)})`;
+    trajectories.push(
+      makeTrajectory(desc, isSuccess, domain, {
+        errorInfo: isSuccess ? undefined : 'TypeError: Cannot read property of undefined',
+      })
+    );
+  }
+  return trajectories;
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('Phase 0-5 End-to-End Integration', () => {
+  let memory: MemorySystem;
+  let persistence: any;
+
+  beforeEach(async () => {
+    testDir = path.join(process.cwd(), `.test-e2e-phase-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`);
+    await fs.mkdir(testDir, { recursive: true });
+    persistence = createSqlitePersistence({ baseDir: testDir });
+    await persistence.init();
+    memory = new MemorySystem(persistence, testDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    persistence.close();
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  // --------------------------------------------------------------------------
+  // 1. InvertedIndex — standalone candidate narrowing
+  // --------------------------------------------------------------------------
+  describe('InvertedIndex', () => {
+    it('should index documents and return ranked candidates', () => {
+      const idx = new InvertedIndex();
+      idx.add('a', 'fix authentication bug in login form');
+      idx.add('b', 'implement user registration endpoint');
+      idx.add('c', 'fix database connection timeout bug');
+      idx.add('d', 'add pagination to user list API');
+
+      const candidates = idx.getCandidates('authentication bug fix');
+      expect(candidates.length).toBeGreaterThan(0);
+      // "a" has the most token overlap with the query
+      expect(candidates[0]).toBe('a');
+    });
+
+    it('should handle remove and size', () => {
+      const idx = new InvertedIndex();
+      idx.add('x', 'hello world');
+      idx.add('y', 'goodbye world');
+      expect(idx.size()).toBe(2);
+
+      idx.remove('x');
+      expect(idx.size()).toBe(1);
+      expect(idx.has('x')).toBe(false);
+      expect(idx.has('y')).toBe(true);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 2. PartitionedStore — domain-partitioned persistence
+  // --------------------------------------------------------------------------
+  describe('PartitionedStore', () => {
+    it('should partition data by key and retrieve per-partition', async () => {
+      const store = new PartitionedStore<{ name: string; domain: string }>(
+        testDir,
+        'items',
+        (item) => item.domain,
+      );
+      await store.init();
+
+      store.set('a', { name: 'alpha', domain: 'code' });
+      store.set('b', { name: 'beta', domain: 'ops' });
+      store.set('c', { name: 'gamma', domain: 'code' });
+
+      expect(store.size()).toBe(3);
+      expect(store.valuesInPartition('code').length).toBe(2);
+      expect(store.valuesInPartition('ops').length).toBe(1);
+      expect(store.getPartitionNames()).toContain('code');
+      expect(store.getPartitionNames()).toContain('ops');
+
+      // Delete and verify
+      store.delete('a');
+      expect(store.size()).toBe(2);
+      expect(store.valuesInPartition('code').length).toBe(1);
+
+      await store.close();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 3. ReflexionGenerator — standalone episode creation
+  // --------------------------------------------------------------------------
+  describe('ReflexionGenerator', () => {
+    it('should generate a reflexion episode from a successful trajectory', async () => {
+      const gen = createReflexionGenerator({ maxInsights: 3 });
+      const traj = makeTrajectory('Fix authentication bug in login form', true);
+      const episode = await gen.generate(traj);
+
+      expect(episode.trajectoryId).toBe(traj.id);
+      expect(episode.outcome).toBe('success');
+      expect(episode.taskSummary).toContain('authentication');
+      expect(episode.selfCritique.length).toBeGreaterThan(0);
+      expect(episode.keyInsights.length).toBeGreaterThanOrEqual(0);
+      expect(episode.strategyAssessment).toContain('without playbook guidance');
+      expect(episode.suggestedPlaybookUpdates.length).toBeGreaterThan(0);
+    });
+
+    it('should generate a reflexion episode from a failed trajectory', async () => {
+      const gen = createReflexionGenerator();
+      const traj = makeTrajectory('Implement search functionality', false, 'code', {
+        errorInfo: 'TypeError: Cannot read property of undefined',
+      });
+      const episode = await gen.generate(traj);
+
+      expect(episode.outcome).toBe('failure');
+      expect(episode.selfCritique).toContain('TypeError');
+      expect(episode.keyInsights.some((i) => i.includes('Error pattern'))).toBe(true);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 4. CausalStore — edge storage, merging, and chain traversal
+  // --------------------------------------------------------------------------
+  describe('CausalStore', () => {
+    it('should store edges and retrieve by domain', async () => {
+      const now = new Date();
+      await memory.causal.add({
+        id: 'e1',
+        cause: 'Missing input validation on payment form',
+        effect: 'SQL injection vulnerability in production',
+        confidence: 0.6,
+        domain: 'security',
+        sourceTrajectoryIds: ['t1'],
+        observedCount: 1,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      await memory.causal.add({
+        id: 'e2',
+        cause: 'Uncached database query in hot path',
+        effect: 'API latency spike under load',
+        confidence: 0.7,
+        domain: 'performance',
+        sourceTrajectoryIds: ['t2'],
+        observedCount: 1,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      const securityEdges = await memory.causal.getByDomain('security');
+      expect(securityEdges.length).toBe(1);
+      expect(securityEdges[0].cause).toContain('validation');
+
+      const allEdges = await memory.causal.getAll();
+      expect(allEdges.length).toBe(2);
+    });
+
+    it('should merge similar edges and boost confidence', async () => {
+      const now = new Date();
+      const baseEdge = {
+        cause: 'Missing null check on user input',
+        effect: 'Runtime TypeError crash in production',
+        confidence: 0.4,
+        domain: 'code',
+        observedCount: 1,
+        createdAt: now,
+        updatedAt: now,
+      };
+
+      await memory.causal.add({ ...baseEdge, id: 'e1', sourceTrajectoryIds: ['t1'] });
+      await memory.causal.add({
+        ...baseEdge,
+        id: 'e2',
+        cause: 'Missing null check on user input field',
+        effect: 'Runtime TypeError crash in production server',
+        sourceTrajectoryIds: ['t2'],
+      });
+
+      const edges = await memory.causal.getAll();
+      // Should have merged into one edge with boosted confidence
+      expect(edges.length).toBe(1);
+      expect(edges[0].observedCount).toBe(2);
+      expect(edges[0].confidence).toBeGreaterThan(0.4);
+      expect(edges[0].sourceTrajectoryIds).toContain('t1');
+      expect(edges[0].sourceTrajectoryIds).toContain('t2');
+    });
+
+    it('should find similar edges by query', async () => {
+      const now = new Date();
+      await memory.causal.add({
+        id: 'e1',
+        cause: 'Authentication token expired',
+        effect: 'User session terminated unexpectedly',
+        confidence: 0.8,
+        domain: 'auth',
+        sourceTrajectoryIds: ['t1'],
+        observedCount: 3,
+        createdAt: now,
+        updatedAt: now,
+      });
+
+      const results = await memory.causal.findSimilar('token expiration problem');
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].cause).toContain('token');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 5. CoherenceChecker — contradiction detection
+  // --------------------------------------------------------------------------
+  describe('CoherenceChecker', () => {
+    it('should detect contradictions between knowledge notes', async () => {
+      const checker = createCoherenceChecker({ contradictionThreshold: 0.3 });
+
+      const noteA: KnowledgeNote = {
+        frontmatter: {
+          id: 'n1',
+          type: 'observation',
+          domain: ['code'],
+          entities: ['authentication'],
+          tags: [],
+          confidence: 0.7,
+          source: { origin: 'extracted', trajectories: ['t1'] },
+          links: [],
+          created: new Date().toISOString(),
+          updated: new Date().toISOString(),
+        },
+        body: 'Always use JWT tokens for authentication in production APIs',
+        filePath: '/notes/n1.md',
+      };
+
+      const noteB: KnowledgeNote = {
+        frontmatter: {
+          id: 'n2',
+          type: 'observation',
+          domain: ['code'],
+          entities: ['authentication'],
+          tags: [],
+          confidence: 0.6,
+          source: { origin: 'extracted', trajectories: ['t2'] },
+          links: [],
+          created: new Date().toISOString(),
+          updated: new Date().toISOString(),
+        },
+        body: 'Never use JWT tokens for authentication in production APIs',
+        filePath: '/notes/n2.md',
+      };
+
+      const result = await checker.check(noteB, [noteA]);
+      expect(result.isCoherent).toBe(false);
+      expect(result.contradictions.length).toBeGreaterThan(0);
+      expect(result.contradictions[0].residualEnergy).toBeGreaterThan(0);
+    });
+
+    it('should return coherent for non-contradictory notes', async () => {
+      const checker = createCoherenceChecker();
+
+      const noteA: KnowledgeNote = {
+        frontmatter: {
+          id: 'n1',
+          type: 'observation',
+          domain: ['code'],
+          entities: ['caching'],
+          tags: [],
+          confidence: 0.7,
+          source: { origin: 'extracted', trajectories: ['t1'] },
+          links: [],
+          created: new Date().toISOString(),
+          updated: new Date().toISOString(),
+        },
+        body: 'Use Redis for caching API responses',
+        filePath: '/notes/n1.md',
+      };
+
+      const noteB: KnowledgeNote = {
+        frontmatter: {
+          id: 'n2',
+          type: 'observation',
+          domain: ['code'],
+          entities: ['caching'],
+          tags: [],
+          confidence: 0.6,
+          source: { origin: 'extracted', trajectories: ['t2'] },
+          links: [],
+          created: new Date().toISOString(),
+          updated: new Date().toISOString(),
+        },
+        body: 'Use Redis for caching database query results',
+        filePath: '/notes/n2.md',
+      };
+
+      const result = await checker.check(noteB, [noteA]);
+      expect(result.isCoherent).toBe(true);
+      expect(result.contradictions.length).toBe(0);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 6. ReasoningBank — K-means++ clustering and retrieval
+  // --------------------------------------------------------------------------
+  describe('ReasoningBank', () => {
+    it('should cluster experiences and enable cluster-based retrieval', () => {
+      const bank = createReasoningBank({ minClusterSize: 2, maxClusters: 5 });
+
+      // Generate enough experiences to form clusters (need diverse topics)
+      const experiences = [
+        // Auth cluster
+        ...['Fix login authentication', 'Debug login session issue', 'Authentication token refresh', 'Fix OAuth login flow'].map(
+          (desc, i) => ({
+            id: `auth-${i}`,
+            taskInput: desc,
+            solutionOutput: 'Fixed auth issue',
+            feedback: 'Success',
+            success: true,
+            domain: 'code',
+            createdAt: new Date(),
+            metadata: {},
+            trajectoryId: `t-auth-${i}`,
+            accessScore: 0.5,
+          })
+        ),
+        // Database cluster
+        ...['Fix database query timeout', 'Optimize slow database query', 'Database connection pooling fix', 'Repair database index'].map(
+          (desc, i) => ({
+            id: `db-${i}`,
+            taskInput: desc,
+            solutionOutput: 'Fixed DB issue',
+            feedback: 'Success',
+            success: true,
+            domain: 'code',
+            createdAt: new Date(),
+            metadata: {},
+            trajectoryId: `t-db-${i}`,
+            accessScore: 0.5,
+          })
+        ),
+      ];
+
+      bank.buildClusters(experiences);
+
+      expect(bank.clusterCount).toBeGreaterThan(0);
+      const clusters = bank.getClusters();
+      expect(clusters.length).toBeGreaterThan(0);
+
+      // Cluster stats should reflect cluster sizes
+      const stats = bank.getClusterStats();
+      for (const stat of stats) {
+        expect(stat.size).toBeGreaterThanOrEqual(2);
+        expect(stat.successRate).toBe(1); // All successful
+      }
+
+      // Retrieval: query related to auth should find auth experiences
+      const results = bank.findInCluster('login authentication problem');
+      expect(results.length).toBeGreaterThan(0);
+      // At least one auth-related experience in the results
+      expect(results.some((r) => r.experience.taskInput.includes('login') || r.experience.taskInput.includes('auth'))).toBe(true);
+    });
+
+    it('should only cluster successful experiences', () => {
+      const bank = createReasoningBank({ minClusterSize: 2 });
+
+      const experiences = [
+        { id: 's1', taskInput: 'Fix bug A', solutionOutput: 'done', feedback: 'ok', success: true, domain: 'code', createdAt: new Date(), metadata: {}, trajectoryId: 't1', accessScore: 0.5 },
+        { id: 's2', taskInput: 'Fix bug B', solutionOutput: 'done', feedback: 'ok', success: true, domain: 'code', createdAt: new Date(), metadata: {}, trajectoryId: 't2', accessScore: 0.5 },
+        { id: 'f1', taskInput: 'Fix bug C', solutionOutput: 'failed', feedback: 'error', success: false, domain: 'code', createdAt: new Date(), metadata: {}, trajectoryId: 't3', accessScore: 0.5 },
+      ];
+
+      bank.buildClusters(experiences);
+
+      // Failed experience should not appear in any cluster
+      const clusters = bank.getClusters();
+      for (const cluster of clusters) {
+        expect(cluster.experienceIds).not.toContain('f1');
+      }
+    });
+
+    it('should track recluster intervals', () => {
+      const bank = createReasoningBank({ reclusterInterval: 3 });
+
+      expect(bank.shouldRecluster()).toBe(false);
+      bank.notifyNewExperience();
+      bank.notifyNewExperience();
+      expect(bank.shouldRecluster()).toBe(false);
+      bank.notifyNewExperience();
+      expect(bank.shouldRecluster()).toBe(true);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 7. TemporalCompressor — tier transitions with hysteresis
+  // --------------------------------------------------------------------------
+  describe('TemporalCompressor', () => {
+    it('should classify experiences into tiers by accessScore', async () => {
+      const compressor = createTemporalCompressor({
+        hotThreshold: 0.5,
+        warmThreshold: 0.2,
+        evictionThreshold: 0.05,
+      });
+
+      const experiences = [
+        { id: 'hot1', taskInput: 'hot task', solutionOutput: 'result', feedback: 'ok', success: true, domain: 'code', createdAt: new Date(), metadata: {}, trajectoryId: 't1', tier: 'hot' as const, accessScore: 0.8 },
+        { id: 'warm1', taskInput: 'warm task', solutionOutput: 'result', feedback: 'ok', success: true, domain: 'code', createdAt: new Date(), metadata: {}, trajectoryId: 't2', tier: 'hot' as const, accessScore: 0.3 },
+        { id: 'cold1', taskInput: 'cold task', solutionOutput: 'result', feedback: 'ok', success: true, domain: 'code', createdAt: new Date(), metadata: {}, trajectoryId: 't3', tier: 'hot' as const, accessScore: 0.1 },
+      ];
+
+      // First pass — marks pending demotion (hysteresis)
+      const pass1 = await compressor.compress(experiences);
+      // warm1 and cold1 should be marked pending, not yet demoted
+      expect(pass1.demoted.length).toBe(0);
+      expect(pass1.unchanged).toContain('warm1');
+      expect(pass1.unchanged).toContain('cold1');
+
+      // Second pass — should actually demote
+      const pass2 = await compressor.compress(experiences);
+      expect(pass2.demoted).toContain('warm1');
+      expect(pass2.demoted).toContain('cold1');
+    });
+
+    it('should compress data when demoting to warm', () => {
+      const compressor = createTemporalCompressor();
+      const exp = {
+        id: 'e1',
+        taskInput: 'Fix authentication bug',
+        solutionOutput: 'Applied fix to auth module\nUpdated token refresh\nAll tests passed',
+        feedback: 'Success',
+        success: true,
+        domain: 'code',
+        createdAt: new Date(),
+        metadata: { steps: [{ action: 'Read auth.ts', observation: 'found bug' }] },
+        trajectoryId: 't1',
+        tier: 'hot' as const,
+        accessScore: 0.3,
+      };
+
+      const warm = compressor.compressToWarm(exp);
+      expect(warm.tier).toBe('warm');
+      expect(warm.compressed).toBeDefined();
+      expect(warm.compressed!.keySteps.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should generate summary when demoting to cold', () => {
+      const compressor = createTemporalCompressor();
+      const exp = {
+        id: 'e1',
+        taskInput: 'Fix authentication bug in login form',
+        solutionOutput: 'Applied fix to auth module',
+        feedback: 'Success',
+        success: true,
+        domain: 'code',
+        createdAt: new Date(),
+        metadata: {},
+        trajectoryId: 't1',
+        tier: 'warm' as const,
+        accessScore: 0.1,
+        compressed: { keySteps: ['Read auth module', 'Applied fix'], summary: '', originalStepCount: 3 },
+      };
+
+      const cold = compressor.compressToCold(exp);
+      expect(cold.tier).toBe('cold');
+      expect(cold.compressed!.summary.length).toBeGreaterThan(0);
+      expect(cold.compressed!.summary).toContain('code');
+    });
+
+    it('should require hysteresis gap for promotion', async () => {
+      const compressor = createTemporalCompressor({
+        hotThreshold: 0.5,
+        warmThreshold: 0.2,
+        hysteresis: 0.05,
+      });
+
+      // Experience at warm tier with score just above warm threshold but below warm+hysteresis
+      const exp = {
+        id: 'e1',
+        taskInput: 'task',
+        solutionOutput: 'result',
+        feedback: 'ok',
+        success: true,
+        domain: 'code',
+        createdAt: new Date(),
+        metadata: {},
+        trajectoryId: 't1',
+        tier: 'cold' as const,
+        accessScore: 0.22, // Above warm threshold (0.2) but below warm+hysteresis (0.25)
+      };
+
+      const result = await compressor.compress([exp]);
+      // Should NOT be promoted because accessScore < warmThreshold + hysteresis
+      expect(result.promoted.length).toBe(0);
+      expect(result.unchanged).toContain('e1');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 8. MoEGate — learned routing with online gradient
+  // --------------------------------------------------------------------------
+  describe('MoEGate', () => {
+    it('should produce uniform probabilities before training', () => {
+      const gate = createMoEGate();
+      expect(gate.isTrained).toBe(false);
+
+      const features = [0.5, 0.3, 0.4, 0.6, 0.5, 0, 1, 0.2];
+      const probs = gate.gate(features);
+
+      // Should be roughly uniform with small random weights
+      const values = [...probs.values()];
+      const maxDiff = Math.max(...values) - Math.min(...values);
+      // Small random weights = near-uniform, but not exact
+      expect(maxDiff).toBeLessThan(0.3);
+      // All 4 strategies present
+      expect(probs.size).toBe(4);
+    });
+
+    it('should shift probabilities after training with reward signal', () => {
+      const gate = new MoEGate([...MOE_STRATEGIES], MOE_FEATURE_SIZE);
+      const features = [0.5, 0.8, 0.7, 0.9, 0.8, 1, 0, 0.3];
+
+      // Train: reward "adapt" strategy heavily
+      for (let i = 0; i < 50; i++) {
+        gate.update(features, 'adapt', 1.0, 0.1);
+      }
+
+      expect(gate.isTrained).toBe(true);
+      expect(gate.totalUpdates).toBe(50);
+
+      const strategy = gate.selectStrategy(features);
+      expect(strategy).toBe('adapt');
+    });
+
+    it('should learn domain-specific weights', () => {
+      const gate = new MoEGate([...MOE_STRATEGIES], MOE_FEATURE_SIZE);
+      const features = [0.5, 0.5, 0.5, 0.5, 0.5, 0, 0, 0.5];
+
+      // Train 'direct' for domain A
+      for (let i = 0; i < 30; i++) {
+        gate.update(features, 'direct', 1.0, 0.1, 'domainA');
+      }
+
+      // Train 'explore' for domain B
+      for (let i = 0; i < 30; i++) {
+        gate.update(features, 'explore', 1.0, 0.1, 'domainB');
+      }
+
+      expect(gate.selectStrategy(features, 'domainA')).toBe('direct');
+      expect(gate.selectStrategy(features, 'domainB')).toBe('explore');
+    });
+
+    it('should serialize and restore state', () => {
+      const gate = new MoEGate([...MOE_STRATEGIES], MOE_FEATURE_SIZE);
+      const features = [0.5, 0.5, 0.5, 0.5, 0.5, 1, 0, 0.5];
+
+      gate.update(features, 'fallback', 1.0, 0.1, 'test-domain');
+      gate.update(features, 'fallback', 1.0, 0.1, 'test-domain');
+
+      const state = gate.toJSON();
+      const restored = MoEGate.fromJSON(state);
+
+      expect(restored.totalUpdates).toBe(2);
+      expect(restored.isTrained).toBe(true);
+      expect(restored.selectStrategy(features, 'test-domain')).toBe(
+        gate.selectStrategy(features, 'test-domain')
+      );
+    });
+
+    it('should extract task features correctly', () => {
+      const features = extractTaskFeatures(
+        'Fix the authentication bug in the login form',
+        {
+          experiences: [{ score: 0.8 }, { score: 0.5 }],
+          playbooks: [{ score: 0.7, playbook: { confidence: 0.9 } }],
+        },
+        15
+      );
+
+      expect(features.length).toBe(MOE_FEATURE_SIZE);
+      expect(features[2]).toBe(0.8); // best experience match score
+      expect(features[3]).toBe(0.7); // best playbook match score
+      expect(features[4]).toBe(0.9); // best playbook confidence
+      expect(features[5]).toBe(1);   // is bug fix ("fix" keyword)
+      expect(features[6]).toBe(0);   // not a new feature
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 9. InstantLoop — per-trajectory hot-path learning
+  // --------------------------------------------------------------------------
+  describe('InstantLoop', () => {
+    it('should store experience and generate reflexion on successful trajectory', async () => {
+      const loop = createInstantLoop(memory, {
+        enableReflexion: true,
+        maxPlaybookMatches: 3,
+      });
+
+      const traj = makeTrajectory(
+        'Fix authentication bug in login form',
+        true,
+        'code',
+        { solution: 'applied fix to auth module' },
+      );
+
+      const result = await loop.process(traj);
+
+      expect(result.experienceId).toBeDefined();
+      expect(result.durationMs).toBeGreaterThanOrEqual(0);
+
+      // Should have generated a reflexion episode
+      expect(result.reflexionEpisodeId).toBeDefined();
+      const episode = await memory.reflexion.getByTrajectory(traj.id);
+      expect(episode).toBeDefined();
+      expect(episode!.outcome).toBe('success');
+
+      // Should have extracted at least one causal edge
+      expect(result.causalEdgesExtracted).toBeGreaterThan(0);
+      const edges = await memory.causal.getAll();
+      expect(edges.length).toBeGreaterThan(0);
+
+      // Experience should be stored
+      const expCount = await memory.experiences.count();
+      expect(expCount).toBe(1);
+    });
+
+    it('should extract error causal edge from failed trajectory', async () => {
+      const loop = createInstantLoop(memory);
+
+      const traj = makeTrajectory(
+        'Implement payment processing',
+        false,
+        'code',
+        { errorInfo: 'TypeError: Cannot read property amount of undefined' },
+      );
+
+      const result = await loop.process(traj);
+
+      expect(result.causalEdgesExtracted).toBeGreaterThan(0);
+      const edges = await memory.causal.getAll();
+      const errorEdge = edges.find((e) => e.effect.includes('TypeError'));
+      expect(errorEdge).toBeDefined();
+      expect(errorEdge!.confidence).toBe(0.4); // Lower confidence for errors
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 10. UnifiedLearningPipeline — instant + batch + latency
+  // --------------------------------------------------------------------------
+  describe('UnifiedLearningPipeline orchestration', () => {
+    it('should track accumulated count and process trajectories', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: { learning: { minTrajectories: 3 }, energy: { countThreshold: 100 } },
+      }, persistence);
+      await pipeline.init();
+
+      expect(pipeline.getAccumulatedCount()).toBe(0);
+
+      for (let i = 0; i < 3; i++) {
+        const traj = makeTrajectory(`Task ${i}`, true);
+        await pipeline.processTrajectory(traj);
+      }
+
+      expect(pipeline.getAccumulatedCount()).toBe(3);
+    });
+
+    it('should invoke latency warning callback when budget exceeded', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        maxInstantLatencyMs: -1,
+        batch: { learning: {}, energy: { countThreshold: 100 } },
+      }, persistence);
+      await pipeline.init();
+
+      let warningMs = -1;
+      pipeline.onLatencyWarning((ms) => {
+        warningMs = ms;
+      });
+
+      const traj = makeTrajectory('Task', true);
+      await pipeline.processTrajectory(traj);
+
+      expect(warningMs).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 11. Full pipeline: InstantLoop → batch → compression → clustering
+  // --------------------------------------------------------------------------
+  describe('Full Learning Pipeline Integration', () => {
+    it('should process trajectories through unified pipeline (instant + batch)', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 3, minSuccessRate: 0.3, maxExperiences: 100 },
+          energy: { countThreshold: 100 }, // Don't auto-trigger batch
+        },
+      }, persistence);
+      await pipeline.init();
+
+      const trajectories = makeVariedTrajectories(4, 0.75); // 3 success, 1 failure
+
+      // Process all trajectories through unified pipeline (instant + accumulate)
+      for (const traj of trajectories) {
+        await pipeline.processTrajectory(traj);
+      }
+
+      // Verify instant loop stored experiences
+      const expCount = await memory.experiences.count();
+      expect(expCount).toBe(4);
+
+      // Verify reflexion episodes generated
+      const reflexionCount = await memory.reflexion.count();
+      expect(reflexionCount).toBe(4);
+
+      // Verify causal edges extracted
+      const causalCount = await memory.causal.count();
+      expect(causalCount).toBeGreaterThan(0);
+
+      // Force batch learning
+      const batchResult = await pipeline.runBatch();
+
+      expect(batchResult.trajectoriesProcessed).toBe(4);
+      expect(batchResult.successRate).toBeCloseTo(0.75, 1);
+      expect(batchResult.experiencesClustered).toBeGreaterThanOrEqual(0);
+      expect(batchResult.experiencesCompressed).toBeDefined();
+
+      expect(pipeline.getAccumulatedCount()).toBe(0);
+    });
+
+    it('should populate ReasoningBank clusters during batch learning', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 1, maxExperiences: 100 },
+          energy: { countThreshold: 100 },
+        },
+      }, persistence);
+      await pipeline.init();
+
+      const trajectories = makeVariedTrajectories(8, 1.0);
+
+      for (const traj of trajectories) {
+        await pipeline.processTrajectory(traj);
+      }
+
+      const batchResult = await pipeline.runBatch();
+
+      expect(batchResult.experiencesClustered).toBeGreaterThan(0);
+      expect(batchResult.trajectoriesProcessed).toBe(8);
+    });
+
+    it('should include compression results in batch output', async () => {
+      const pipeline = createUnifiedPipeline(memory, {
+        batch: {
+          learning: { minTrajectories: 1, maxExperiences: 100 },
+          energy: { countThreshold: 100 },
+        },
+      }, persistence);
+      await pipeline.init();
+
+      const trajectories = makeVariedTrajectories(5, 0.8);
+
+      for (const traj of trajectories) {
+        await pipeline.processTrajectory(traj);
+      }
+
+      const result = await pipeline.runBatch();
+
+      expect(result.experiencesCompressed).toHaveProperty('promoted');
+      expect(result.experiencesCompressed).toHaveProperty('demoted');
+      expect(result.experiencesCompressed).toHaveProperty('evicted');
+      expect(result.experiencesCompressed.demoted).toBe(0);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 12. Cross-module: CausalStore + ReflexionMemory populated by InstantLoop
+  // --------------------------------------------------------------------------
+  describe('Cross-module: CausalStore + ReflexionMemory via InstantLoop', () => {
+    it('should build causal edges from multiple trajectories and query them', async () => {
+      const loop = createInstantLoop(memory);
+
+      // Process several trajectories with related themes
+      const authTraj1 = makeTrajectory('Fix OAuth token refresh logic', true, 'auth');
+      const authTraj2 = makeTrajectory('Fix OAuth token validation bug', false, 'auth', {
+        errorInfo: 'Token validation failed: expired token not rejected',
+      });
+      const dbTraj = makeTrajectory('Optimize database query performance', true, 'database');
+
+      await loop.process(authTraj1);
+      await loop.process(authTraj2);
+      await loop.process(dbTraj);
+
+      // Query causal store for auth-related edges
+      const authEdges = await memory.causal.getByDomain('auth');
+      expect(authEdges.length).toBeGreaterThan(0);
+
+      // Query by similarity
+      const tokenEdges = await memory.causal.findSimilar('token authentication issue');
+      expect(tokenEdges.length).toBeGreaterThan(0);
+
+      // Reflexion episodes should exist for all trajectories
+      const authEp1 = await memory.reflexion.getByTrajectory(authTraj1.id);
+      const authEp2 = await memory.reflexion.getByTrajectory(authTraj2.id);
+      expect(authEp1).toBeDefined();
+      expect(authEp2).toBeDefined();
+      expect(authEp1!.outcome).toBe('success');
+      expect(authEp2!.outcome).toBe('failure');
+    });
+
+    it('should retrieve recent reflexion episodes by domain and outcome', async () => {
+      const loop = createInstantLoop(memory);
+
+      // Process mixed trajectories
+      await loop.process(makeTrajectory('Fix login form', true, 'frontend'));
+      await loop.process(makeTrajectory('Fix signup page', false, 'frontend', { errorInfo: 'test failure' }));
+      await loop.process(makeTrajectory('Optimize API query', true, 'backend'));
+
+      // Get recent episodes for frontend domain
+      const frontendEpisodes = await memory.reflexion.getRecent({
+        domain: 'frontend',
+      });
+      expect(frontendEpisodes.length).toBe(2);
+
+      // Get only failed episodes
+      const failedEpisodes = await memory.reflexion.getRecent({
+        outcome: 'failure',
+      });
+      expect(failedEpisodes.length).toBe(1);
+      expect(failedEpisodes[0].outcome).toBe('failure');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 13. MoEGate + extractTaskFeatures + MemorySystem query integration
+  // --------------------------------------------------------------------------
+  describe('MoEGate + Memory Query Integration', () => {
+    it('should extract features from memory context and route tasks', async () => {
+      const gate = createMoEGate();
+
+      // Store some experiences so memory queries return results
+      const loop = createInstantLoop(memory);
+      await loop.process(makeTrajectory('Fix authentication bug', true, 'code'));
+      await loop.process(makeTrajectory('Implement new API endpoint', true, 'code'));
+
+      // Query memory for a new task
+      const queryResult = await memory.queryV2('Fix login authentication error');
+
+      // Extract features from the memory context
+      const features = extractTaskFeatures(
+        'Fix login authentication error',
+        {
+          experiences: queryResult.experiences.map((e) => ({ score: e.score })),
+          playbooks: queryResult.playbooks.map((p) => ({
+            score: p.score,
+            playbook: { confidence: p.playbook.confidence },
+          })),
+        },
+        queryResult.experiences.length,
+      );
+
+      expect(features.length).toBe(MOE_FEATURE_SIZE);
+      expect(features[5]).toBe(1); // "fix" → isBugFix
+
+      // Gate should return a valid strategy
+      const strategy = gate.selectStrategy(features);
+      expect(MOE_STRATEGIES).toContain(strategy);
+
+      // After some training, gate should specialize
+      gate.update(features, 'adapt', 1.0, 0.1, 'code');
+      gate.update(features, 'adapt', 1.0, 0.1, 'code');
+      expect(gate.isTrained).toBe(true);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 14. MemorySystem.storeTrajectory + queryV2 round-trip
+  // --------------------------------------------------------------------------
+  describe('MemorySystem round-trip', () => {
+    it('should store and retrieve experiences via queryV2', async () => {
+      const traj = makeTrajectory('Fix CSS layout bug in dashboard component', true, 'frontend');
+      const exp = await memory.storeTrajectory(traj);
+
+      expect(exp.id).toBeDefined();
+      expect(exp.domain).toBe('frontend');
+      expect(exp.success).toBe(true);
+
+      // Query should return the stored experience
+      const result = await memory.queryV2('CSS layout dashboard');
+      expect(result.experiences.length).toBeGreaterThan(0);
+      expect(result.experiences[0].experience.id).toBe(exp.id);
+    });
+
+    it('should track experience count in stats', async () => {
+      await memory.storeTrajectory(makeTrajectory('Task A', true));
+      await memory.storeTrajectory(makeTrajectory('Task B', false));
+
+      const stats = await memory.getStats();
+      expect(stats.experienceCount).toBe(2);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 15. ReflexionMemory persistence
+  // --------------------------------------------------------------------------
+  describe('ReflexionMemory persistence', () => {
+    it('should persist episodes and retrieve by ID', async () => {
+      const gen = createReflexionGenerator();
+      const traj = makeTrajectory('Implement search feature', true, 'code');
+      const episode = await gen.generate(traj);
+
+      await memory.reflexion.add(episode);
+
+      const retrieved = await memory.reflexion.get(episode.id);
+      expect(retrieved).toBeDefined();
+      expect(retrieved!.trajectoryId).toBe(traj.id);
+      expect(retrieved!.outcome).toBe('success');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // 16. Full data flow: trajectory → all subsystems
+  // --------------------------------------------------------------------------
+  describe('Full data flow smoke test', () => {
+    it('should exercise every Phase 0-5 subsystem in sequence', async () => {
+      // Phase 0: PartitionedStore and InvertedIndex (standalone)
+      const idx = new InvertedIndex();
+      idx.add('doc1', 'authentication token refresh');
+      expect(idx.getCandidates('auth token').length).toBeGreaterThan(0);
+
+      // Phase 1+2: UnifiedLearningPipeline processes trajectories (instant + accumulate)
+      const pipeline = createUnifiedPipeline(memory, {
+        features: { reflexion: true },
+        batch: {
+          learning: { minTrajectories: 2, maxExperiences: 100 },
+          energy: { countThreshold: 100 }, // Don't auto-trigger batch
+        },
+      }, persistence);
+      await pipeline.init();
+
+      const traj1 = makeTrajectory('Fix authentication token refresh bug', true, 'auth');
+      const traj2 = makeTrajectory('Implement user profile endpoint', true, 'api');
+      const traj3 = makeTrajectory('Fix database connection pool leak', false, 'database', {
+        errorInfo: 'Connection pool exhausted: max connections reached',
+      });
+
+      const r1 = await pipeline.processTrajectory(traj1);
+      const r2 = await pipeline.processTrajectory(traj2);
+      const r3 = await pipeline.processTrajectory(traj3);
+
+      // Verify InstantLoop results
+      expect(r1.instantLoop.experienceId).toBeDefined();
+      expect(r1.instantLoop.reflexionEpisodeId).toBeDefined();
+      expect(r2.instantLoop.causalEdgesExtracted).toBeGreaterThan(0);
+      expect(r3.instantLoop.causalEdgesExtracted).toBeGreaterThan(0);
+
+      // Force batch
+      const batchResult = await pipeline.runBatch();
+
+      expect(batchResult.trajectoriesProcessed).toBe(3);
+      expect(batchResult.experiencesClustered).toBeGreaterThanOrEqual(0);
+      expect(typeof batchResult.experiencesCompressed.promoted).toBe('number');
+      expect(typeof batchResult.experiencesCompressed.demoted).toBe('number');
+      expect(typeof batchResult.experiencesCompressed.evicted).toBe('number');
+
+      // Phase 3: CoherenceChecker (standalone)
+      const checker = createCoherenceChecker();
+      const noteA = createObservation({
+        title: 'connection-pool',
+        body: 'Always use connection pooling for database access',
+        domain: ['database'],
+        entities: ['connection-pool'],
+        confidence: 0.7,
+        source: { origin: 'extracted', trajectories: [traj3.id] },
+      });
+      const noteB = createObservation({
+        title: 'connection-pool',
+        body: 'Avoid connection pooling for database access',
+        domain: ['database'],
+        entities: ['connection-pool'],
+        confidence: 0.5,
+        source: { origin: 'extracted', trajectories: ['other'] },
+      });
+      const coherenceResult = await checker.check(noteB, [noteA]);
+      // "Always" vs "Avoid" should flag contradiction
+      expect(coherenceResult.isCoherent).toBe(false);
+
+      // Phase 4: MoEGate routing
+      const gate = createMoEGate();
+      const queryResult = await memory.queryV2('Fix database connection issue');
+      const features = extractTaskFeatures(
+        'Fix database connection issue',
+        {
+          experiences: queryResult.experiences.map((e) => ({ score: e.score })),
+          playbooks: queryResult.playbooks.map((p) => ({
+            score: p.score,
+            playbook: { confidence: p.playbook.confidence },
+          })),
+        },
+        queryResult.experiences.length,
+      );
+      const strategy = gate.selectStrategy(features);
+      expect(MOE_STRATEGIES).toContain(strategy);
+
+      // Phase 5: TemporalCompressor (standalone verification)
+      const compressor = createTemporalCompressor();
+      const allExperiences = await memory.experiences.getAll();
+      const compressionResult = await compressor.compress(allExperiences);
+      expect(compressionResult).toHaveProperty('promoted');
+      expect(compressionResult).toHaveProperty('demoted');
+      expect(compressionResult).toHaveProperty('evicted');
+      expect(compressionResult).toHaveProperty('unchanged');
+
+      // Phase 4 (CausalStore): query causal edges
+      const edges = await memory.causal.findSimilar('database connection error');
+      expect(edges.length).toBeGreaterThan(0);
+
+      // ReflexionMemory: verify all episodes stored
+      const totalReflexions = await memory.reflexion.count();
+      expect(totalReflexions).toBe(3);
+
+      // Final stats
+      const stats = await memory.getStats();
+      expect(stats.experienceCount).toBeGreaterThanOrEqual(3);
+    });
+  });
+});