cognitive-core 0.2.5 → 0.3.1

package/tests/memory/knowledge-evolution.test.ts

@@ -1,563 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { KnowledgeBank } from '../../src/memory/knowledge-bank.js';
-import type { KnowledgeBankConfig } from '../../src/types/config.js';
-import {
-  createObservation,
-  createEntityNote,
-} from '../../src/types/knowledge.js';
-import type { Contradiction } from '../../src/types/knowledge.js';
-
-function defaultConfig(): KnowledgeBankConfig {
-  return {
-    enabled: true,
-    memoryDir: 'memory',
-    extraction: {
-      enabled: true,
-      useLlmExtraction: false,
-      minAttributionScore: 0.3,
-    },
-    defrag: {
-      minInboxItems: 5,
-      autoConsolidate: true,
-      consolidationThreshold: 3,
-      autoRegenerateSummaries: true,
-      llmSummaryGeneration: false,
-      autoResolveContradictions: false,
-    },
-    confidence: {
-      extractedInitial: 0.3,
-      agentAuthoredInitial: 0.5,
-      reinforcementAlpha: 0.1,
-      contradictionPenalty: 0.3,
-      dailyDecayRate: 0.001,
-      staleThreshold: 0.2,
-      decayGracePeriodDays: 90,
-    },
-    graph: {
-      enabledLayers: ['semantic', 'entity', 'temporal', 'causal'],
-      inferTemporalEdges: true,
-      inferCausalEdges: true,
-      inferEntityEdges: true,
-      domainSplitThreshold: 500,
-      sqlitePromotionThreshold: 10000,
-    },
-    surfacing: {
-      includeDomainSummaries: true,
-      includeEntityNotes: true,
-      maxNotesPerTask: 5,
-      maxTokensForKnowledge: 2000,
-      includeEvidence: true,
-      includeLinks: false,
-    },
-    minimemAware: false,
-  };
-}
-
-describe('KnowledgeBank Evolution', () => {
-  let tmpDir: string;
-  let bank: KnowledgeBank;
-
-  beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'kb-evolution-test-'));
-    bank = new KnowledgeBank(tmpDir, defaultConfig());
-    await bank.init();
-  });
-
-  afterEach(async () => {
-    try {
-      await bank.close();
-    } catch {
-      // ignore
-    }
-    await rm(tmpDir, { recursive: true, force: true });
-  });
-
-  // =========================================================================
-  // Reinforcement
-  // =========================================================================
-
-  describe('reinforce', () => {
-    it('should update confidence using EMA formula', async () => {
-      const obs = createObservation({
-        id: 'k-reinforce-1',
-        title: 'Obs',
-        body: 'Test.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.3,
-        source: { origin: 'extracted', trajectories: ['t-1'] },
-      });
-      await bank.addObservation(obs);
-
-      await bank.reinforce('k-reinforce-1', 't-2');
-
-      const note = await bank.getNote('k-reinforce-1');
-      // EMA: (1 - 0.1) * 0.3 + 0.1 * 1.0 = 0.27 + 0.1 = 0.37
-      expect(note!.frontmatter.confidence).toBeCloseTo(0.37, 5);
-    });
-
-    it('should add trajectory to source without duplicates', async () => {
-      const obs = createObservation({
-        id: 'k-reinforce-2',
-        title: 'Obs',
-        body: 'Test.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        source: { origin: 'extracted', trajectories: ['t-1'] },
-      });
-      await bank.addObservation(obs);
-
-      await bank.reinforce('k-reinforce-2', 't-2');
-      await bank.reinforce('k-reinforce-2', 't-2'); // duplicate
-
-      const note = await bank.getNote('k-reinforce-2');
-      expect(note!.frontmatter.source.trajectories).toContain('t-1');
-      expect(note!.frontmatter.source.trajectories).toContain('t-2');
-      expect(note!.frontmatter.source.trajectories).toHaveLength(2);
-    });
-
-    it('should update the timestamp', async () => {
-      const obs = createObservation({
-        id: 'k-reinforce-3',
-        title: 'Obs',
-        body: 'Test.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs);
-
-      const before = obs.frontmatter.updated;
-      // Small delay to ensure different timestamp
-      await new Promise((r) => setTimeout(r, 10));
-      await bank.reinforce('k-reinforce-3', 't-1');
-
-      const note = await bank.getNote('k-reinforce-3');
-      expect(note!.frontmatter.updated).not.toBe(before);
-    });
-
-    it('should persist to disk', async () => {
-      const obs = createObservation({
-        id: 'k-reinforce-4',
-        title: 'Obs',
-        body: 'Test.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.5,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs);
-      await bank.reinforce('k-reinforce-4', 't-1');
-      await bank.close();
-
-      // Re-open
-      const bank2 = new KnowledgeBank(tmpDir, defaultConfig());
-      await bank2.init();
-
-      const note = await bank2.getNote('k-reinforce-4');
-      expect(note!.frontmatter.confidence).toBeCloseTo(0.55, 5);
-      await bank2.close();
-    });
-
-    it('should update graph node', async () => {
-      const obs = createObservation({
-        id: 'k-reinforce-5',
-        title: 'Obs',
-        body: 'Test.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.3,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs);
-      await bank.reinforce('k-reinforce-5', 't-1');
-
-      const graphNode = bank.graph.getNode('k-reinforce-5');
-      expect(graphNode!.confidence).toBeCloseTo(0.37, 5);
-    });
-
-    it('should throw for missing note', async () => {
-      await expect(
-        bank.reinforce('nonexistent', 't-1')
-      ).rejects.toThrow('Cannot reinforce');
-    });
-
-    it('should converge toward 1.0 with repeated reinforcement', async () => {
-      const obs = createObservation({
-        id: 'k-reinforce-converge',
-        title: 'Obs',
-        body: 'Test.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.3,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs);
-
-      // Reinforce many times
-      for (let i = 0; i < 50; i++) {
-        await bank.reinforce('k-reinforce-converge', `t-${i}`);
-      }
-
-      const note = await bank.getNote('k-reinforce-converge');
-      expect(note!.frontmatter.confidence).toBeGreaterThan(0.95);
-    });
-  });
-
-  // =========================================================================
-  // Enhanced Contradiction
-  // =========================================================================
-
-  describe('recordContradiction (enhanced)', () => {
-    it('should lower old note confidence on supersede', async () => {
-      const oldObs = createObservation({
-        id: 'k-old-super',
-        title: 'Old',
-        body: 'Old fact.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.7,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(oldObs);
-
-      const newObs = createObservation({
-        id: 'k-new-super',
-        title: 'New',
-        body: 'New fact.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        source: { origin: 'extracted' },
-      });
-
-      await bank.recordContradiction({
-        existingNoteId: 'k-old-super',
-        newObservation: newObs,
-        conflictDescription: 'Updated info',
-        resolution: 'supersede',
-      });
-
-      const old = await bank.getNote('k-old-super');
-      // 0.7 - 0.3 = 0.4
-      expect(old!.frontmatter.confidence).toBeCloseTo(0.4, 5);
-    });
-
-    it('should add temporal supersedes edge on supersede', async () => {
-      const oldObs = createObservation({
-        id: 'k-old-temporal',
-        title: 'Old',
-        body: 'Old.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(oldObs);
-
-      const newObs = createObservation({
-        id: 'k-new-temporal',
-        title: 'New',
-        body: 'New.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        source: { origin: 'extracted' },
-      });
-
-      await bank.recordContradiction({
-        existingNoteId: 'k-old-temporal',
-        newObservation: newObs,
-        conflictDescription: 'Updated',
-        resolution: 'supersede',
-      });
-
-      const temporalLayer = bank.graph.getLayer('temporal');
-      expect(temporalLayer).not.toBeNull();
-      const edges = temporalLayer!.getEdges('k-new-temporal', 'outgoing');
-      const supersedesEdge = edges.find((e) => e.relation === 'supersedes');
-      expect(supersedesEdge).toBeDefined();
-      expect(supersedesEdge!.to).toBe('k-old-temporal');
-    });
-
-    it('should lower both notes by half penalty on coexist', async () => {
-      const obs1 = createObservation({
-        id: 'k-coexist-1',
-        title: 'A',
-        body: 'Fact A.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.6,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs1);
-
-      const obs2 = createObservation({
-        id: 'k-coexist-2',
-        title: 'B',
-        body: 'Fact B.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.5,
-        source: { origin: 'extracted' },
-      });
-
-      await bank.recordContradiction({
-        existingNoteId: 'k-coexist-1',
-        newObservation: obs2,
-        conflictDescription: 'Different view',
-        resolution: 'coexist',
-      });
-
-      const note1 = await bank.getNote('k-coexist-1');
-      const note2 = await bank.getNote('k-coexist-2');
-      // 0.6 - 0.15 = 0.45, 0.5 - 0.15 = 0.35
-      expect(note1!.frontmatter.confidence).toBeCloseTo(0.45, 5);
-      expect(note2!.frontmatter.confidence).toBeCloseTo(0.35, 5);
-    });
-
-    it('should tag both notes for review on review resolution', async () => {
-      const obs1 = createObservation({
-        id: 'k-review-1',
-        title: 'A',
-        body: 'Fact A.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.6,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs1);
-
-      const obs2 = createObservation({
-        id: 'k-review-2',
-        title: 'B',
-        body: 'Fact B.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.5,
-        source: { origin: 'extracted' },
-      });
-
-      await bank.recordContradiction({
-        existingNoteId: 'k-review-1',
-        newObservation: obs2,
-        conflictDescription: 'Needs human review',
-        resolution: 'review',
-      });
-
-      const note1 = await bank.getNote('k-review-1');
-      const note2 = await bank.getNote('k-review-2');
-      expect(note1!.frontmatter.tags).toContain('needs-review');
-      expect(note2!.frontmatter.tags).toContain('needs-review');
-      // No confidence change
-      expect(note1!.frontmatter.confidence).toBeCloseTo(0.6, 5);
-    });
-
-    it('should clamp confidence at 0', async () => {
-      const obs = createObservation({
-        id: 'k-clamp-old',
-        title: 'Old',
-        body: 'Old.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.1, // Less than penalty (0.3)
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs);
-
-      const newObs = createObservation({
-        id: 'k-clamp-new',
-        title: 'New',
-        body: 'New.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        source: { origin: 'extracted' },
-      });
-
-      await bank.recordContradiction({
-        existingNoteId: 'k-clamp-old',
-        newObservation: newObs,
-        conflictDescription: 'Supersede',
-        resolution: 'supersede',
-      });
-
-      const old = await bank.getNote('k-clamp-old');
-      expect(old!.frontmatter.confidence).toBe(0);
-    });
-  });
-
-  // =========================================================================
-  // Decay
-  // =========================================================================
-
-  describe('applyDecay', () => {
-    it('should skip notes within grace period', async () => {
-      const obs = createObservation({
-        id: 'k-decay-grace',
-        title: 'Fresh',
-        body: 'Recent note.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.5,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs);
-
-      const result = await bank.applyDecay();
-      expect(result.decayed).toBe(0);
-    });
-
-    it('should apply decay after grace period', async () => {
-      const obs = createObservation({
-        id: 'k-decay-old',
-        title: 'Old',
-        body: 'Old note.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.5,
-        source: { origin: 'extracted' },
-      });
-      // Set updated to 100 days ago (past 90-day grace)
-      const oldDate = new Date(Date.now() - 100 * 24 * 60 * 60 * 1000);
-      obs.frontmatter.updated = oldDate.toISOString();
-      await bank.addObservation(obs);
-
-      const result = await bank.applyDecay();
-      expect(result.decayed).toBe(1);
-
-      const note = await bank.getNote('k-decay-old');
-      expect(note!.frontmatter.confidence).toBeLessThan(0.5);
-    });
-
-    it('should apply correct decay formula', async () => {
-      const obs = createObservation({
-        id: 'k-decay-formula',
-        title: 'Old',
-        body: 'Old note.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.5,
-        source: { origin: 'extracted' },
-      });
-      // Set updated to exactly 100 days ago (10 days past grace)
-      const daysAgo = 100;
-      const oldDate = new Date(Date.now() - daysAgo * 24 * 60 * 60 * 1000);
-      obs.frontmatter.updated = oldDate.toISOString();
-      await bank.addObservation(obs);
-
-      await bank.applyDecay();
-
-      const note = await bank.getNote('k-decay-formula');
-      // Expected: 0.5 * (1 - 0.001)^(100 - 90) = 0.5 * 0.999^10
-      const expected = 0.5 * Math.pow(0.999, 10);
-      expect(note!.frontmatter.confidence).toBeCloseTo(expected, 4);
-    });
-
-    it('should add stale tag when below threshold', async () => {
-      const obs = createObservation({
-        id: 'k-decay-stale',
-        title: 'Old',
-        body: 'Old note.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.2, // Just at threshold
-        source: { origin: 'extracted' },
-      });
-      // Set updated to 200 days ago (110 days past grace) → decay enough to go below 0.2
-      const oldDate = new Date(Date.now() - 200 * 24 * 60 * 60 * 1000);
-      obs.frontmatter.updated = oldDate.toISOString();
-      await bank.addObservation(obs);
-
-      const result = await bank.applyDecay();
-      expect(result.newlyStale).toBeGreaterThanOrEqual(1);
-
-      const note = await bank.getNote('k-decay-stale');
-      expect(note!.frontmatter.tags).toContain('stale');
-    });
-
-    it('should count already-stale notes', async () => {
-      const obs = createObservation({
-        id: 'k-already-stale',
-        title: 'Already stale',
-        body: 'Stale note.',
-        domain: ['code'],
-        entities: [],
-        tags: ['stale'],
-        confidence: 0.1,
-        source: { origin: 'extracted' },
-      });
-      await bank.addObservation(obs);
-
-      const result = await bank.applyDecay();
-      expect(result.alreadyStale).toBe(1);
-      expect(result.decayed).toBe(0);
-    });
-
-    it('should skip domain summaries', async () => {
-      // Domain summaries should not decay
-      const { createDomainSummary } = await import(
-        '../../src/types/knowledge.js'
-      );
-      const summary = createDomainSummary({
-        domainName: 'code',
-        body: 'Domain summary.',
-        source: { origin: 'extracted' },
-      });
-      // Set old date
-      summary.frontmatter.updated = new Date(
-        Date.now() - 200 * 24 * 60 * 60 * 1000
-      ).toISOString();
-      await bank.addObservation(summary);
-
-      const result = await bank.applyDecay();
-      // Domain summaries are in the domains dir, which is not scanned by applyDecay
-      expect(result.decayed).toBe(0);
-    });
-
-    it('should persist decayed values to disk', async () => {
-      const obs = createObservation({
-        id: 'k-decay-persist',
-        title: 'Old',
-        body: 'Old.',
-        domain: ['code'],
-        entities: [],
-        tags: [],
-        confidence: 0.5,
-        source: { origin: 'extracted' },
-      });
-      obs.frontmatter.updated = new Date(
-        Date.now() - 100 * 24 * 60 * 60 * 1000
-      ).toISOString();
-      await bank.addObservation(obs);
-      await bank.applyDecay();
-      await bank.close();
-
-      // Re-open
-      const bank2 = new KnowledgeBank(tmpDir, defaultConfig());
-      await bank2.init();
-      const note = await bank2.getNote('k-decay-persist');
-      expect(note!.frontmatter.confidence).toBeLessThan(0.5);
-      await bank2.close();
-    });
-  });
-});