cognitive-core 0.1.2 → 0.2.1

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

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