cognitive-core 0.2.4 → 0.3.1

package/tests/learning/pipeline-memory-updates.test.ts

@@ -1,721 +0,0 @@
-/**
- * Behavioral tests for the learning pipeline's memory updates.
- *
- * These tests verify *what the system learns* from given experiences,
- * not implementation mechanics. Assertions use the same retrieval APIs
- * that the router/solver would use at task-time.
- *
- * Pattern: Given/When/Then (Gherkin-inspired, no BDD framework).
- * Plumbing: Real SqlitePersistence + MemorySystem + UnifiedLearningPipeline.
- * No mocks, no LLM calls — heuristic-only extractors throughout.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { createSqlitePersistence, type SqlitePersistence } from '../../src/persistence/index.js';
-import { MemorySystem } from '../../src/memory/system.js';
-import {
-  UnifiedLearningPipeline,
-  createUnifiedPipeline,
-} from '../../src/learning/unified-pipeline.js';
-import { createPlaybook } from '../../src/types/playbook.js';
-import { KnowledgeBankConfigSchema } from '../../src/types/config.js';
-
-import {
-  makeTypescriptImportFix,
-  makePythonTypeFix,
-  makeFailedAuthFix,
-  makeKubernetesDeploy,
-  makeInefficient,
-  makeSuccessfulWithSolution,
-} from '../fixtures/behavioral-trajectories.js';
-
-// ============================================================================
-// Shared setup
-// ============================================================================
-
-/** Pipeline config with low thresholds for testability and all features on. */
-function pipelineConfig(overrides?: {
-  batchThreshold?: number;
-  healing?: boolean;
-  knowledgeExtraction?: boolean;
-}) {
-  const threshold = overrides?.batchThreshold ?? 100;
-  return {
-    batch: {
-      learning: { minTrajectories: threshold, minSuccessRate: 0.0 },
-      energy: { countThreshold: threshold, minIntervalMs: 0 },
-    },
-    features: {
-      temporalCompression: true,
-      reasoningBank: true,
-      reflexion: true,
-      causalExtraction: true,
-      knowledgeExtraction: overrides?.knowledgeExtraction ?? true,
-      healing: overrides?.healing ?? false,
-      metaLearning: false,
-      effectivenessTracking: false,
-    },
-  };
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('Pipeline Memory Updates — Behavioral Tests', () => {
-  let tempDir: string;
-  let persistence: SqlitePersistence;
-  let memory: MemorySystem;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'behavioral-test-'));
-    persistence = createSqlitePersistence({ baseDir: tempDir });
-    await persistence.init();
-    const kbConfig = KnowledgeBankConfigSchema.parse({ enabled: true });
-    memory = new MemorySystem(persistence, tempDir, undefined, kbConfig);
-    await memory.init();
-  });
-
-  afterEach(async () => {
-    await memory.close();
-    persistence.close();
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  // --------------------------------------------------------------------------
-  // 1. Experience Storage
-  // --------------------------------------------------------------------------
-  describe('experience storage — the system remembers what happened', () => {
-    it('given a successful trajectory, when processed, then an experience is stored and retrievable', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-      const trajectory = makeTypescriptImportFix(0);
-
-      // When
-      const result = await pipeline.processTrajectory(trajectory);
-
-      // Then — experience exists with correct fields
-      const exp = await memory.experiences.get(result.instantLoop.experienceId);
-      expect(exp).toBeDefined();
-      expect(exp!.success).toBe(true);
-      expect(exp!.domain).toBe('typescript');
-      expect(exp!.taskInput).toContain('Fix broken TypeScript import');
-
-      // Then — experience is retrievable via similarity search
-      const similar = await memory.experiences.findSimilar('Fix broken import', {
-        domain: 'typescript',
-      });
-      expect(similar.length).toBeGreaterThanOrEqual(1);
-      expect(similar[0].experience.id).toBe(exp!.id);
-    });
-
-    it('given a successful trajectory, when processed, then experience metadata preserves step information', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-      const trajectory = makeTypescriptImportFix(0);
-
-      // When
-      await pipeline.processTrajectory(trajectory);
-
-      // Then — metadata has steps
-      const all = await memory.experiences.getAll();
-      expect(all.length).toBe(1);
-      const meta = all[0].metadata as Record<string, unknown>;
-      expect(meta.steps).toBeDefined();
-      const steps = meta.steps as Array<Record<string, unknown>>;
-      expect(steps.length).toBe(trajectory.steps.length);
-      expect(steps[0].action).toContain('ReadFile');
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 2. Playbook Confidence Evolution
-  // --------------------------------------------------------------------------
-  describe('playbook confidence evolution — success reinforces, failure weakens', () => {
-    it('given a seeded playbook, when matching trajectories succeed, then confidence increases', async () => {
-      // Given — seed a playbook that matches "Fix TypeScript import" tasks
-      const playbook = createPlaybook({
-        name: 'fix-typescript-imports',
-        confidence: 0.5,
-        applicability: {
-          situations: ['Fix broken TypeScript import', 'Resolve TS2307 module not found'],
-          triggers: ['import error', 'cannot find module', 'TS2307'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: {
-          strategy: 'Add .js extension to ESM imports',
-          tactics: ['Check import paths', 'Add .js extension', 'Run tsc'],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      // When — two matching successes
-      await pipeline.processTrajectory(makeTypescriptImportFix(0));
-      await pipeline.processTrajectory(makeTypescriptImportFix(1));
-
-      // Then — confidence increased
-      const updated = await memory.playbooks.get(playbook.id);
-      expect(updated).toBeDefined();
-      expect(updated!.confidence).toBeGreaterThan(0.5);
-      expect(updated!.evolution.successCount).toBe(2);
-    });
-
-    it('given a playbook with successes, when a matching trajectory fails, then confidence decreases', async () => {
-      // Given — seed playbook with higher confidence
-      const playbook = createPlaybook({
-        name: 'fix-auth-middleware',
-        confidence: 0.7,
-        applicability: {
-          situations: ['Fix authentication bypass', 'Fix auth middleware'],
-          triggers: ['auth bypass', 'token validation', 'JWT'],
-          antiPatterns: [],
-          domains: ['security'],
-        },
-        guidance: {
-          strategy: 'Validate all token fields including expiry',
-          tactics: ['Check expiry', 'Validate signature', 'Run security tests'],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      // When — a matching failure
-      await pipeline.processTrajectory(
-        makeFailedAuthFix('token validation still bypassed for admin tokens'),
-      );
-
-      // Then — confidence decreased and failure recorded
-      const updated = await memory.playbooks.get(playbook.id);
-      expect(updated).toBeDefined();
-      expect(updated!.confidence).toBeLessThan(0.7);
-      expect(updated!.evolution.failureCount).toBe(1);
-      expect(updated!.confidence).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 3. Knowledge Extraction
-  // --------------------------------------------------------------------------
-  describe('knowledge extraction — errors become learnable observations', () => {
-    it('given a failed trajectory with error info, when processed, then a knowledge observation is stored', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      // When
-      const result = await pipeline.processTrajectory(
-        makeFailedAuthFix('TypeError: Cannot read properties of undefined (reading "expiry")'),
-      );
-
-      // Then — knowledge notes were extracted
-      expect(result.instantLoop.knowledgeNotesExtracted).toBeGreaterThan(0);
-
-      // Then — knowledge is retrievable for similar tasks
-      if (memory.knowledgeBank) {
-        const knowledge = await memory.knowledgeBank.getRelevantKnowledge({
-          description: 'Fix auth token error',
-          domain: 'security',
-        });
-        // At minimum, the error observation should be findable
-        expect(knowledge.length).toBeGreaterThanOrEqual(0);
-        // Note: text-similarity matching may not always surface heuristically-extracted
-        // notes for different descriptions, so we also verify via direct listing
-        const stats = await memory.knowledgeBank.getStats();
-        expect(stats.observationCount).toBeGreaterThan(0);
-      }
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 4. Causal Edge Extraction
-  // --------------------------------------------------------------------------
-  describe('causal edge extraction — the system links causes to effects', () => {
-    it('given a failed trajectory, when processed, then a causal edge linking task to error is stored', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      // When
-      const result = await pipeline.processTrajectory(
-        makeFailedAuthFix('token validation failed: signature mismatch'),
-      );
-
-      // Then — at least one causal edge extracted
-      expect(result.instantLoop.causalEdgesExtracted).toBeGreaterThanOrEqual(1);
-
-      // Then — edge is retrievable
-      const edges = await memory.causal.findSimilar('auth token validation');
-      expect(edges.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('given a successful trajectory, when processed, then a causal edge linking approach to outcome is stored', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      // When
-      const result = await pipeline.processTrajectory(
-        makeSuccessfulWithSolution(
-          'typescript',
-          'Fix login flow token refresh',
-          'Added automatic token refresh before API calls',
-        ),
-      );
-
-      // Then — approach→outcome edge extracted
-      expect(result.instantLoop.causalEdgesExtracted).toBeGreaterThanOrEqual(1);
-
-      const edges = await memory.causal.findSimilar('token refresh');
-      expect(edges.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 5. Reflexion Generation
-  // --------------------------------------------------------------------------
-  describe('reflexion generation — the system critiques its own failures', () => {
-    it('given a failed trajectory with repeated actions, when processed, then a reflexion episode with critique is stored', async () => {
-      // Given — an inefficient trajectory with 5 repeated ReadFile steps
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-      const trajectory = makeInefficient(5);
-
-      // When
-      const result = await pipeline.processTrajectory(trajectory);
-
-      // Then — reflexion episode created
-      expect(result.instantLoop.reflexionEpisodeId).toBeDefined();
-
-      // Then — episode has meaningful content
-      const episodes = await memory.reflexion.getRecent({ limit: 1 });
-      expect(episodes.length).toBe(1);
-      const episode = episodes[0];
-      expect(episode.outcome).toBe('failure');
-      expect(episode.selfCritique).toBeTruthy();
-      expect(episode.selfCritique.length).toBeGreaterThan(0);
-      expect(episode.keyInsights.length).toBeGreaterThan(0);
-    });
-
-    it('given a successful trajectory, when processed, then a reflexion episode with success outcome is stored', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      // When
-      await pipeline.processTrajectory(makeTypescriptImportFix(0));
-
-      // Then
-      const episodes = await memory.reflexion.getRecent({ limit: 1 });
-      expect(episodes.length).toBe(1);
-      expect(episodes[0].outcome).toBe('success');
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 6. Batch Playbook Extraction
-  // --------------------------------------------------------------------------
-  describe('batch playbook extraction — repeated patterns become reusable playbooks', () => {
-    it('given 5 similar successful trajectories, when batch runs, then a new playbook is extracted', async () => {
-      // Given — 5 similar TypeScript import fix trajectories
-      const pipeline = createUnifiedPipeline(
-        memory,
-        pipelineConfig({ batchThreshold: 5 }),
-        persistence,
-      );
-      await pipeline.init();
-
-      // When — process 5 similar trajectories (batch triggers on 5th)
-      for (let i = 0; i < 4; i++) {
-        await pipeline.processTrajectory(makeTypescriptImportFix(i));
-      }
-      const result = await pipeline.processTrajectory(makeTypescriptImportFix(4));
-
-      // Then — batch ran
-      expect(result.batchTriggered).toBe(true);
-      expect(result.batchResult!.trajectoriesProcessed).toBe(5);
-      expect(result.batchResult!.successRate).toBe(1.0);
-
-      // Then — playbook(s) may have been extracted
-      // Note: PlaybookExtractor requires minTrajectories (default 2) and
-      // minSuccessRate (0.6). With 5 similar successes, extraction should attempt.
-      const allPlaybooks = await memory.playbooks.getAll();
-      // The extractor's heuristic may or may not produce a playbook from these
-      // trajectories depending on internal similarity thresholds, but the batch
-      // pipeline should have run without error and experiences should be stored.
-      expect(await memory.experiences.count()).toBe(5);
-
-      // If playbooks were extracted, they should be retrievable for similar tasks
-      if (allPlaybooks.length > 0) {
-        const matches = await memory.playbooks.findMatching(
-          'Fix TypeScript import error in utils.ts',
-        );
-        expect(matches.length).toBeGreaterThanOrEqual(1);
-      }
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 7. Playbook Retrieval Relevance
-  // --------------------------------------------------------------------------
-  describe('playbook retrieval relevance — learned playbooks surface for similar tasks, not dissimilar ones', () => {
-    it('given a TypeScript import playbook, when queried with similar vs dissimilar tasks, then only the similar task matches', async () => {
-      // Given — seed a playbook
-      const playbook = createPlaybook({
-        name: 'fix-esm-imports',
-        confidence: 0.8,
-        applicability: {
-          situations: ['Fix broken TypeScript ESM import path'],
-          triggers: ['import error', 'TS2307', 'cannot find module'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: {
-          strategy: 'Add .js extension to relative imports',
-          tactics: ['Find import statement', 'Add .js extension', 'Run tsc --noEmit'],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      // When — query with similar task
-      const similarMatches = await memory.playbooks.findMatching(
-        'Fix import error in handler.ts',
-        { minScore: 0.2 },
-      );
-
-      // When — query with dissimilar task
-      const dissimilarMatches = await memory.playbooks.findMatching(
-        'Deploy Kubernetes cluster to production',
-        { domains: ['devops'], minScore: 0.3 },
-      );
-
-      // Then — similar task finds the playbook
-      expect(similarMatches.length).toBeGreaterThanOrEqual(1);
-      expect(similarMatches[0].playbook.id).toBe(playbook.id);
-
-      // Then — dissimilar task does not
-      const devopsIds = dissimilarMatches.map(m => m.playbook.id);
-      expect(devopsIds).not.toContain(playbook.id);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 8. Mixed Success/Failure Batch
-  // --------------------------------------------------------------------------
-  describe('mixed success/failure batch — the system tracks honest success rates', () => {
-    it('given 3 successes and 2 failures, when batch runs, then success rate is 0.6 and reflexions exist for failures', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(
-        memory,
-        pipelineConfig({ batchThreshold: 5 }),
-        persistence,
-      );
-      await pipeline.init();
-
-      // When — 3 successes + 2 failures
-      await pipeline.processTrajectory(makeTypescriptImportFix(0));
-      await pipeline.processTrajectory(
-        makeFailedAuthFix('Validation error: missing claims'),
-      );
-      await pipeline.processTrajectory(makeTypescriptImportFix(1));
-      await pipeline.processTrajectory(
-        makeFailedAuthFix('JWT signature verification failed'),
-      );
-      const result = await pipeline.processTrajectory(makeTypescriptImportFix(2));
-
-      // Then — batch ran with correct success rate
-      expect(result.batchTriggered).toBe(true);
-      expect(result.batchResult!.successRate).toBe(0.6);
-
-      // Then — all 5 experiences stored
-      const allExp = await memory.experiences.getAll();
-      expect(allExp.length).toBe(5);
-      expect(allExp.filter(e => e.success).length).toBe(3);
-      expect(allExp.filter(e => !e.success).length).toBe(2);
-
-      // Then — reflexion episodes exist for failures (and successes, since reflexion is on)
-      const reflexionCount = await memory.reflexion.count();
-      expect(reflexionCount).toBe(5); // one per trajectory when reflexion enabled
-
-      // Then — failure reflexions have failure outcome
-      const failureEpisodes = await memory.reflexion.getRecent({
-        outcome: 'failure',
-        limit: 10,
-      });
-      expect(failureEpisodes.length).toBe(2);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 9. Domain Isolation
-  // --------------------------------------------------------------------------
-  describe('domain isolation — learning in one domain does not pollute another', () => {
-    it('given trajectories in different domains, when queried with domain filter, then only matching domain results appear', async () => {
-      // Given — process TypeScript and Python trajectories
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      for (let i = 0; i < 3; i++) {
-        await pipeline.processTrajectory(makeTypescriptImportFix(i));
-      }
-      for (let i = 0; i < 3; i++) {
-        await pipeline.processTrajectory(makePythonTypeFix(i));
-      }
-
-      // When — query experiences with domain filter
-      const tsResults = await memory.experiences.findSimilar('Fix code error', {
-        domain: 'typescript',
-      });
-      const pyResults = await memory.experiences.findSimilar('Fix code error', {
-        domain: 'python',
-      });
-
-      // Then — TypeScript query returns only TypeScript experiences
-      for (const r of tsResults) {
-        expect(r.experience.domain).toBe('typescript');
-      }
-
-      // Then — Python query returns only Python experiences
-      for (const r of pyResults) {
-        expect(r.experience.domain).toBe('python');
-      }
-
-      // Then — both domains have results
-      expect(tsResults.length).toBeGreaterThanOrEqual(1);
-      expect(pyResults.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('given playbooks in different domains, when queried with domain filter, then only matching domain playbooks appear', async () => {
-      // Given — seed playbooks for different domains
-      await memory.playbooks.add(createPlaybook({
-        name: 'fix-ts-imports',
-        applicability: {
-          situations: ['Fix TypeScript import'],
-          triggers: ['import error'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: { strategy: 'Add .js extension', tactics: [] },
-      }));
-      await memory.playbooks.add(createPlaybook({
-        name: 'fix-python-types',
-        applicability: {
-          situations: ['Fix Python type annotation'],
-          triggers: ['type error'],
-          antiPatterns: [],
-          domains: ['python'],
-        },
-        guidance: { strategy: 'Add proper type hints', tactics: [] },
-      }));
-
-      // When
-      const tsPlaybooks = await memory.playbooks.findMatching('Fix error in code', {
-        domains: ['typescript'],
-      });
-      const pyPlaybooks = await memory.playbooks.findMatching('Fix error in code', {
-        domains: ['python'],
-      });
-
-      // Then — each domain only sees its own playbooks
-      for (const m of tsPlaybooks) {
-        expect(m.playbook.applicability.domains).toContain('typescript');
-      }
-      for (const m of pyPlaybooks) {
-        expect(m.playbook.applicability.domains).toContain('python');
-      }
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 10. Playbook Refinement
-  // --------------------------------------------------------------------------
-  describe('playbook refinement — existing playbooks evolve from new evidence', () => {
-    it('given a seeded playbook, when batch runs with matching trajectories, then playbook may gain refinements', async () => {
-      // Given — seed a playbook
-      const playbook = createPlaybook({
-        name: 'fix-import-paths',
-        confidence: 0.5,
-        applicability: {
-          situations: ['Fix broken import path in TypeScript'],
-          triggers: ['import error', 'module not found'],
-          antiPatterns: [],
-          domains: ['typescript'],
-        },
-        guidance: {
-          strategy: 'Check and fix import paths for ESM compatibility',
-          tactics: ['Read the file', 'Fix import extensions', 'Verify with tsc'],
-        },
-      });
-      await memory.playbooks.add(playbook);
-
-      const pipeline = createUnifiedPipeline(
-        memory,
-        pipelineConfig({ batchThreshold: 5 }),
-        persistence,
-      );
-      await pipeline.init();
-
-      // When — process 5 matching trajectories through batch
-      for (let i = 0; i < 5; i++) {
-        await pipeline.processTrajectory(makeTypescriptImportFix(i));
-      }
-
-      // Then — playbook still exists (not overwritten or deleted)
-      const updated = await memory.playbooks.get(playbook.id);
-      expect(updated).toBeDefined();
-
-      // Then — original guidance preserved
-      expect(updated!.guidance.strategy).toContain('ESM');
-
-      // Then — confidence bumped from successful matches (instant loop)
-      expect(updated!.confidence).toBeGreaterThan(0.5);
-      expect(updated!.evolution.successCount).toBeGreaterThan(0);
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 11. Full Lifecycle
-  // --------------------------------------------------------------------------
-  describe('full lifecycle — trajectory to experience to playbook to retrieval', () => {
-    it('given 10 trajectories processed through all phases, then all memory stores are populated and queryable', async () => {
-      // Given — pipeline with low batch threshold, maintenance after 2 batches
-      const pipeline = createUnifiedPipeline(memory, {
-        batch: {
-          learning: { minTrajectories: 5, minSuccessRate: 0.0 },
-          energy: { countThreshold: 5, minIntervalMs: 0 },
-        },
-        maintenance: { mode: 'afterNBatches', batchInterval: 2 },
-        features: {
-          temporalCompression: true,
-          reasoningBank: true,
-          reflexion: true,
-          causalExtraction: true,
-          knowledgeExtraction: true,
-          healing: false,
-          metaLearning: false,
-          effectivenessTracking: false,
-        },
-      }, persistence);
-      await pipeline.init();
-
-      // When — process 10 trajectories (2 batches of 5)
-      // Batch 1: 4 TypeScript successes + 1 auth failure
-      for (let i = 0; i < 4; i++) {
-        await pipeline.processTrajectory(makeTypescriptImportFix(i));
-      }
-      await pipeline.processTrajectory(
-        makeFailedAuthFix('Token expired'),
-      );
-
-      // Batch 2: 3 Python successes + 1 Kubernetes + 1 inefficient failure
-      for (let i = 0; i < 3; i++) {
-        await pipeline.processTrajectory(makePythonTypeFix(i));
-      }
-      await pipeline.processTrajectory(makeKubernetesDeploy());
-      await pipeline.processTrajectory(makeInefficient(3));
-
-      // Then — stats reflect full lifecycle
-      const stats = pipeline.getStats();
-      expect(stats.totalProcessed).toBe(10);
-      expect(stats.batchCyclesRun).toBe(2);
-      expect(stats.maintenanceCyclesRun).toBe(1);
-
-      // Then — experiences are stored and queryable
-      const expCount = await memory.experiences.count();
-      expect(expCount).toBe(10);
-
-      const tsExperiences = await memory.experiences.findSimilar('TypeScript import fix', {
-        domain: 'typescript',
-      });
-      expect(tsExperiences.length).toBeGreaterThanOrEqual(1);
-
-      // Then — reflexion episodes exist (one per trajectory)
-      const reflexionCount = await memory.reflexion.count();
-      expect(reflexionCount).toBe(10);
-
-      // Then — causal edges exist
-      const causalEdges = await memory.causal.findSimilar('import error');
-      expect(causalEdges.length).toBeGreaterThanOrEqual(1);
-
-      // Then — knowledge notes were extracted
-      if (memory.knowledgeBank) {
-        const knowledgeStats = await memory.knowledgeBank.getStats();
-        expect(knowledgeStats.observationCount).toBeGreaterThan(0);
-      }
-    });
-  });
-
-  // --------------------------------------------------------------------------
-  // 12. Temporal Stability
-  // --------------------------------------------------------------------------
-  describe('temporal stability — recent experiences are accessible', () => {
-    it('given trajectories processed at different times, when queried, then all remain accessible', async () => {
-      // Given — process trajectories in two waves
-      const pipeline = createUnifiedPipeline(memory, pipelineConfig(), persistence);
-      await pipeline.init();
-
-      // Wave 1
-      for (let i = 0; i < 3; i++) {
-        await pipeline.processTrajectory(makeTypescriptImportFix(i));
-      }
-
-      // Wave 2 (same domain, slightly different)
-      for (let i = 3; i < 6; i++) {
-        await pipeline.processTrajectory(makeTypescriptImportFix(i));
-      }
-
-      // Then — all 6 experiences still accessible
-      const allExp = await memory.experiences.getAll();
-      expect(allExp.length).toBe(6);
-
-      // Then — similarity search returns results from both waves
-      const results = await memory.experiences.findSimilar('Fix broken TypeScript import', {
-        k: 10,
-      });
-      expect(results.length).toBe(6);
-    });
-
-    it('given a batch with compression enabled, when batch runs, then no experiences are prematurely evicted', async () => {
-      // Given
-      const pipeline = createUnifiedPipeline(memory, {
-        batch: {
-          learning: { minTrajectories: 3, minSuccessRate: 0.0 },
-          energy: { countThreshold: 3, minIntervalMs: 0 },
-        },
-        features: {
-          temporalCompression: true,
-          reasoningBank: true,
-          reflexion: false,
-          causalExtraction: false,
-          knowledgeExtraction: false,
-          healing: false,
-        },
-      }, persistence);
-      await pipeline.init();
-
-      // When — process enough to trigger batch
-      for (let i = 0; i < 3; i++) {
-        await pipeline.processTrajectory(makeTypescriptImportFix(i));
-      }
-
-      // Then — all experiences survive (fresh experiences shouldn't be evicted)
-      const count = await memory.experiences.count();
-      expect(count).toBe(3);
-
-      // Then — batch ran successfully
-      const stats = pipeline.getStats();
-      expect(stats.batchCyclesRun).toBe(1);
-    });
-  });
-});