cognitive-core 0.2.5 → 0.3.1

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

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