cognitive-core 0.1.2 → 0.2.1

package/tests/persistence/sqlite-persistence.test.ts

@@ -0,0 +1,635 @@
+/**
+ * Tests for SqlitePersistence — unified SQLite database.
+ *
+ * Uses :memory: databases (via tmp directories) for isolation.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { SqlitePersistence, createSqlitePersistence } from '../../src/persistence/sqlite-persistence.js';
+import type { Experience } from '../../src/types/memory.js';
+import type { Playbook } from '../../src/types/playbook.js';
+import type { ReflexionEpisode } from '../../src/types/memory.js';
+import type { MetaObservation, MetaStrategy } from '../../src/types/meta.js';
+
+// ============================================================================
+// Test data factories
+// ============================================================================
+
+function createTestExperience(overrides: Partial<Experience> = {}): Experience {
+  return {
+    id: 'exp-1',
+    taskInput: 'Fix the login bug',
+    solutionOutput: 'Updated auth middleware',
+    feedback: 'Works well',
+    success: true,
+    domain: 'code',
+    trajectoryId: 'traj-1',
+    usageCount: 0,
+    accessScore: 0,
+    retrievalCount: 0,
+    tier: 'hot',
+    metadata: {},
+    createdAt: new Date('2024-01-01'),
+    ...overrides,
+  };
+}
+
+function createTestPlaybook(overrides: Partial<Playbook> = {}): Playbook {
+  return {
+    id: 'pb-1',
+    name: 'Error Handling Strategy',
+    applicability: {
+      situations: ['error handling'],
+      triggers: ['try-catch needed'],
+      antiPatterns: ['silent catch'],
+      domains: ['code'],
+    },
+    guidance: {
+      strategy: 'Use structured error handling',
+      tactics: ['validate inputs', 'log errors'],
+    },
+    verification: {
+      successIndicators: ['no unhandled errors'],
+      failureIndicators: ['silent failures'],
+    },
+    evolution: {
+      version: '1.0.0',
+      createdFrom: ['traj-1'],
+      failures: [],
+      refinements: [],
+      successCount: 3,
+      failureCount: 1,
+    },
+    confidence: 0.75,
+    complexity: 'moderate',
+    estimatedEffort: 3,
+    createdAt: new Date('2024-01-01'),
+    updatedAt: new Date('2024-01-02'),
+    ...overrides,
+  };
+}
+
+function createTestReflexion(overrides: Partial<ReflexionEpisode> = {}): ReflexionEpisode {
+  return {
+    id: 'ref-1',
+    trajectoryId: 'traj-1',
+    taskSummary: 'Fixed auth bug',
+    outcome: 'success',
+    selfCritique: 'Could have been faster',
+    keyInsights: ['check middleware first'],
+    strategyAssessment: 'good approach',
+    suggestedPlaybookUpdates: [],
+    domain: 'code',
+    createdAt: new Date('2024-01-01'),
+    ...overrides,
+  };
+}
+
+function createTestMetaObservation(overrides: Partial<MetaObservation> = {}): MetaObservation {
+  return {
+    id: 'obs-1',
+    trajectoryId: 'traj-1',
+    routing: { decision: 'adapt', confidence: 0.8, reasoning: 'similar past experience' },
+    memoryUsage: { experiencesRetrieved: 3, playbooksApplied: ['pb-1'], retrievalQuality: 'helpful' },
+    execution: { decompositionUsed: false, refinementIterations: 1, backtrackingOccurred: false, toolsUsed: ['grep'] },
+    outcome: { success: true, quality: 'good', effortActual: 5, effortEstimate: 8 },
+    lessons: { whatWorked: ['experience retrieval'], whatFailed: [], suggestions: [] },
+    timestamp: new Date('2024-01-01'),
+    ...overrides,
+  };
+}
+
+function createTestMetaStrategy(overrides: Partial<MetaStrategy> = {}): MetaStrategy {
+  return {
+    id: 'strat-1',
+    name: 'Experience-heavy retrieval',
+    condition: { taskCharacteristics: ['familiar domain'], memoryState: ['many experiences'] },
+    adjustment: {
+      routingBias: { adapt: 0.2 },
+      retrievalModification: 'expand query',
+      executionHint: 'prefer decomposition',
+    },
+    applicationCount: 5,
+    successRate: 0.8,
+    createdAt: new Date('2024-01-01'),
+    updatedAt: new Date('2024-01-02'),
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('SqlitePersistence', () => {
+  let persistence: SqlitePersistence;
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'atlas-test-'));
+    persistence = createSqlitePersistence({ baseDir: tmpDir });
+    await persistence.init();
+  });
+
+  afterEach(() => {
+    persistence.close();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // --------------------------------------------------------------------------
+  // Init & lifecycle
+  // --------------------------------------------------------------------------
+
+  describe('initialization', () => {
+    it('should create the database file', () => {
+      expect(persistence.isInitialized).toBe(true);
+    });
+
+    it('should be idempotent (calling init twice is safe)', async () => {
+      await persistence.init();
+      expect(persistence.isInitialized).toBe(true);
+    });
+
+    it('should report dbPath', () => {
+      expect(persistence.dbPath).toContain('cognitive-core.db');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Schema version
+  // --------------------------------------------------------------------------
+
+  describe('schema version', () => {
+    it('should default to 0 when no version set', () => {
+      expect(persistence.getSchemaVersion()).toBe(0);
+    });
+
+    it('should track schema versions', () => {
+      persistence.setSchemaVersion(1);
+      expect(persistence.getSchemaVersion()).toBe(1);
+
+      persistence.setSchemaVersion(2);
+      expect(persistence.getSchemaVersion()).toBe(2);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Experiences CRUD
+  // --------------------------------------------------------------------------
+
+  describe('experiences', () => {
+    it('should insert and retrieve an experience', () => {
+      const exp = createTestExperience();
+      persistence.insertExperience(exp);
+
+      const row = persistence.getExperience('exp-1');
+      expect(row).toBeDefined();
+      expect(row!.id).toBe('exp-1');
+      expect(row!.task_input).toBe('Fix the login bug');
+      expect(row!.success).toBe(1); // boolean → integer
+      expect(row!.domain).toBe('code');
+      expect(row!.tier).toBe('hot');
+    });
+
+    it('should return undefined for missing experience', () => {
+      expect(persistence.getExperience('nonexistent')).toBeUndefined();
+    });
+
+    it('should get all experiences', () => {
+      persistence.insertExperience(createTestExperience({ id: 'exp-1' }));
+      persistence.insertExperience(createTestExperience({ id: 'exp-2', domain: 'data' }));
+
+      const all = persistence.getAllExperiences();
+      expect(all).toHaveLength(2);
+    });
+
+    it('should filter by domain', () => {
+      persistence.insertExperience(createTestExperience({ id: 'exp-1', domain: 'code' }));
+      persistence.insertExperience(createTestExperience({ id: 'exp-2', domain: 'data' }));
+
+      const codeExps = persistence.getExperiencesByDomain('code');
+      expect(codeExps).toHaveLength(1);
+      expect(codeExps[0].id).toBe('exp-1');
+    });
+
+    it('should filter by trajectory', () => {
+      persistence.insertExperience(createTestExperience({ id: 'exp-1', trajectoryId: 'traj-1' }));
+      persistence.insertExperience(createTestExperience({ id: 'exp-2', trajectoryId: 'traj-2' }));
+
+      const results = persistence.getExperiencesByTrajectory('traj-1');
+      expect(results).toHaveLength(1);
+    });
+
+    it('should get experience IDs for inverted index', () => {
+      persistence.insertExperience(createTestExperience({ id: 'exp-1' }));
+      persistence.insertExperience(createTestExperience({ id: 'exp-2' }));
+
+      const ids = persistence.getExperienceIds();
+      expect(ids).toHaveLength(2);
+      expect(ids[0]).toHaveProperty('id');
+      expect(ids[0]).toHaveProperty('task_input');
+    });
+
+    it('should update an experience', () => {
+      persistence.insertExperience(createTestExperience());
+
+      persistence.updateExperience('exp-1', { usageCount: 5, tier: 'warm' });
+
+      const row = persistence.getExperience('exp-1');
+      expect(row!.usage_count).toBe(5);
+      expect(row!.tier).toBe('warm');
+    });
+
+    it('should delete an experience', () => {
+      persistence.insertExperience(createTestExperience());
+      expect(persistence.deleteExperience('exp-1')).toBe(true);
+      expect(persistence.getExperience('exp-1')).toBeUndefined();
+    });
+
+    it('should return false when deleting nonexistent', () => {
+      expect(persistence.deleteExperience('nonexistent')).toBe(false);
+    });
+
+    it('should count experiences', () => {
+      expect(persistence.getExperienceCount()).toBe(0);
+      persistence.insertExperience(createTestExperience());
+      expect(persistence.getExperienceCount()).toBe(1);
+    });
+
+    it('should handle embedding round-trip', () => {
+      const embedding = [0.1, 0.2, 0.3, 0.4];
+      persistence.insertExperience(createTestExperience({ embedding }));
+
+      const row = persistence.getExperience('exp-1');
+      expect(row!.embedding).toBeDefined();
+      expect(row!.embedding).toBeInstanceOf(Buffer);
+    });
+
+    it('should bulk delete with WHERE clause', () => {
+      persistence.insertExperience(createTestExperience({ id: 'exp-1', tier: 'cold' as 'hot' | 'warm' | 'cold' }));
+      persistence.insertExperience(createTestExperience({ id: 'exp-2', tier: 'hot' }));
+
+      const deleted = persistence.deleteExperiencesWhere('tier = ?', ['cold']);
+      expect(deleted).toBe(1);
+      expect(persistence.getExperienceCount()).toBe(1);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Playbooks CRUD
+  // --------------------------------------------------------------------------
+
+  describe('playbooks', () => {
+    it('should insert and retrieve a playbook', () => {
+      const pb = createTestPlaybook();
+      persistence.insertPlaybook(pb);
+
+      const row = persistence.getPlaybook('pb-1');
+      expect(row).toBeDefined();
+      expect(row!.name).toBe('Error Handling Strategy');
+      expect(row!.confidence).toBe(0.75);
+      expect(row!.primary_domain).toBe('code');
+    });
+
+    it('should get all playbooks', () => {
+      persistence.insertPlaybook(createTestPlaybook({ id: 'pb-1' }));
+      persistence.insertPlaybook(createTestPlaybook({ id: 'pb-2', name: 'Another' }));
+
+      expect(persistence.getAllPlaybooks()).toHaveLength(2);
+    });
+
+    it('should filter by domain', () => {
+      persistence.insertPlaybook(createTestPlaybook({ id: 'pb-1' }));
+      persistence.insertPlaybook(createTestPlaybook({
+        id: 'pb-2',
+        applicability: { situations: [], triggers: [], antiPatterns: [], domains: ['data'] },
+      }));
+
+      const codePlaybooks = persistence.getPlaybooksByDomain('code');
+      expect(codePlaybooks).toHaveLength(1);
+    });
+
+    it('should update a playbook', () => {
+      persistence.insertPlaybook(createTestPlaybook());
+
+      persistence.updatePlaybook('pb-1', { confidence: 0.9, complexity: 'simple' });
+
+      const row = persistence.getPlaybook('pb-1');
+      expect(row!.confidence).toBe(0.9);
+      expect(row!.complexity).toBe('simple');
+    });
+
+    it('should delete a playbook', () => {
+      persistence.insertPlaybook(createTestPlaybook());
+      expect(persistence.deletePlaybook('pb-1')).toBe(true);
+      expect(persistence.getPlaybook('pb-1')).toBeUndefined();
+    });
+
+    it('should count playbooks', () => {
+      expect(persistence.getPlaybookCount()).toBe(0);
+      persistence.insertPlaybook(createTestPlaybook());
+      expect(persistence.getPlaybookCount()).toBe(1);
+    });
+
+    it('should snapshot playbook versions', () => {
+      persistence.insertPlaybook(createTestPlaybook());
+      persistence.snapshotPlaybookVersion('pb-1', '1.0.0', 'Initial version');
+
+      const versions = persistence.getPlaybookVersions('pb-1');
+      expect(versions).toHaveLength(1);
+      expect(versions[0].version).toBe('1.0.0');
+      expect(versions[0].changelog).toBe('Initial version');
+
+      // Snapshot should contain valid JSON of the playbook
+      const snapshot = JSON.parse(versions[0].playbook_snapshot);
+      expect(snapshot.name).toBe('Error Handling Strategy');
+    });
+
+    it('should store JSON fields correctly', () => {
+      persistence.insertPlaybook(createTestPlaybook());
+      const row = persistence.getPlaybook('pb-1');
+
+      const applicability = JSON.parse(row!.applicability);
+      expect(applicability.situations).toContain('error handling');
+
+      const guidance = JSON.parse(row!.guidance);
+      expect(guidance.strategy).toBe('Use structured error handling');
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Reflexion Episodes CRUD
+  // --------------------------------------------------------------------------
+
+  describe('reflexion episodes', () => {
+    it('should insert and retrieve a reflexion episode', () => {
+      persistence.insertReflexionEpisode(createTestReflexion());
+
+      const row = persistence.getReflexionEpisode('ref-1');
+      expect(row).toBeDefined();
+      expect(row!.outcome).toBe('success');
+      expect(row!.domain).toBe('code');
+    });
+
+    it('should filter by domain and outcome', () => {
+      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-1', domain: 'code', outcome: 'success' }));
+      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-2', domain: 'code', outcome: 'failure' }));
+      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-3', domain: 'data', outcome: 'success' }));
+
+      const codeSuccess = persistence.getReflexionEpisodes({ domain: 'code', outcome: 'success' });
+      expect(codeSuccess).toHaveLength(1);
+      expect(codeSuccess[0].id).toBe('ref-1');
+    });
+
+    it('should respect limit', () => {
+      for (let i = 0; i < 5; i++) {
+        persistence.insertReflexionEpisode(createTestReflexion({
+          id: `ref-${i}`,
+          createdAt: new Date(2024, 0, i + 1),
+        }));
+      }
+
+      const limited = persistence.getReflexionEpisodes({ limit: 3 });
+      expect(limited).toHaveLength(3);
+    });
+
+    it('should get by trajectory', () => {
+      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-1', trajectoryId: 'traj-1' }));
+      persistence.insertReflexionEpisode(createTestReflexion({ id: 'ref-2', trajectoryId: 'traj-2' }));
+
+      const results = persistence.getReflexionByTrajectory('traj-1');
+      expect(results).toHaveLength(1);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Causal Edges CRUD
+  // --------------------------------------------------------------------------
+
+  describe('causal edges', () => {
+    it('should insert and retrieve a causal edge', () => {
+      persistence.insertCausalEdge({
+        id: 'edge-1',
+        cause: 'missing validation',
+        effect: 'runtime error',
+        confidence: 0.9,
+        domain: 'code',
+        sourceTrajectoryIds: ['traj-1'],
+        observedCount: 3,
+        createdAt: new Date('2024-01-01'),
+        updatedAt: new Date('2024-01-02'),
+      });
+
+      const row = persistence.getCausalEdge('edge-1');
+      expect(row).toBeDefined();
+      expect(row!.cause).toBe('missing validation');
+      expect(row!.confidence).toBe(0.9);
+      expect(JSON.parse(row!.source_trajectory_ids)).toEqual(['traj-1']);
+    });
+
+    it('should get all and filter by domain', () => {
+      persistence.insertCausalEdge({
+        id: 'edge-1', cause: 'a', effect: 'b', confidence: 0.5,
+        domain: 'code', sourceTrajectoryIds: [], observedCount: 1,
+        createdAt: new Date(), updatedAt: new Date(),
+      });
+      persistence.insertCausalEdge({
+        id: 'edge-2', cause: 'c', effect: 'd', confidence: 0.5,
+        domain: 'data', sourceTrajectoryIds: [], observedCount: 1,
+        createdAt: new Date(), updatedAt: new Date(),
+      });
+
+      expect(persistence.getAllCausalEdges()).toHaveLength(2);
+      expect(persistence.getCausalEdgesByDomain('code')).toHaveLength(1);
+    });
+
+    it('should update a causal edge', () => {
+      persistence.insertCausalEdge({
+        id: 'edge-1', cause: 'a', effect: 'b', confidence: 0.5,
+        domain: 'code', sourceTrajectoryIds: [], observedCount: 1,
+        createdAt: new Date(), updatedAt: new Date(),
+      });
+
+      persistence.updateCausalEdge('edge-1', { confidence: 0.9, observedCount: 5 });
+
+      const row = persistence.getCausalEdge('edge-1');
+      expect(row!.confidence).toBe(0.9);
+      expect(row!.observed_count).toBe(5);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Meta Observations CRUD
+  // --------------------------------------------------------------------------
+
+  describe('meta observations', () => {
+    it('should insert and retrieve a meta observation', () => {
+      persistence.insertMetaObservation(createTestMetaObservation());
+
+      const row = persistence.getMetaObservation('obs-1');
+      expect(row).toBeDefined();
+      expect(row!.routing_decision).toBe('adapt');
+      expect(row!.outcome_success).toBe(1);
+    });
+
+    it('should filter by routing decision', () => {
+      persistence.insertMetaObservation(createTestMetaObservation({ id: 'obs-1' }));
+      persistence.insertMetaObservation(createTestMetaObservation({
+        id: 'obs-2',
+        routing: { decision: 'direct', confidence: 0.5, reasoning: 'test' },
+      }));
+
+      const adaptObs = persistence.getMetaObservationsByRouting('adapt');
+      expect(adaptObs).toHaveLength(1);
+    });
+
+    it('should aggregate routing effectiveness', () => {
+      persistence.insertMetaObservation(createTestMetaObservation({
+        id: 'obs-1',
+        routing: { decision: 'adapt', confidence: 0.8, reasoning: '' },
+        outcome: { success: true, quality: 'good', effortActual: 5, effortEstimate: 5 },
+      }));
+      persistence.insertMetaObservation(createTestMetaObservation({
+        id: 'obs-2',
+        routing: { decision: 'adapt', confidence: 0.7, reasoning: '' },
+        outcome: { success: false, quality: 'poor', effortActual: 10, effortEstimate: 5 },
+      }));
+      persistence.insertMetaObservation(createTestMetaObservation({
+        id: 'obs-3',
+        routing: { decision: 'direct', confidence: 0.9, reasoning: '' },
+        outcome: { success: true, quality: 'excellent', effortActual: 2, effortEstimate: 3 },
+      }));
+
+      const agg = persistence.aggregateRoutingEffectiveness();
+      expect(agg['adapt']).toEqual({ total: 2, successful: 1 });
+      expect(agg['direct']).toEqual({ total: 1, successful: 1 });
+    });
+
+    it('should delete observations before cutoff', () => {
+      persistence.insertMetaObservation(createTestMetaObservation({
+        id: 'obs-old',
+        timestamp: new Date('2023-01-01'),
+      }));
+      persistence.insertMetaObservation(createTestMetaObservation({
+        id: 'obs-new',
+        timestamp: new Date('2024-06-01'),
+      }));
+
+      const deleted = persistence.deleteMetaObservationsBefore(new Date('2024-01-01'));
+      expect(deleted).toBe(1);
+      expect(persistence.getMetaObservationCount()).toBe(1);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Meta Strategies CRUD
+  // --------------------------------------------------------------------------
+
+  describe('meta strategies', () => {
+    it('should insert and retrieve a meta strategy', () => {
+      persistence.insertMetaStrategy(createTestMetaStrategy());
+
+      const row = persistence.getMetaStrategy('strat-1');
+      expect(row).toBeDefined();
+      expect(row!.name).toBe('Experience-heavy retrieval');
+      expect(row!.success_rate).toBe(0.8);
+    });
+
+    it('should get by name', () => {
+      persistence.insertMetaStrategy(createTestMetaStrategy());
+
+      const row = persistence.getMetaStrategyByName('Experience-heavy retrieval');
+      expect(row).toBeDefined();
+    });
+
+    it('should update a meta strategy', () => {
+      persistence.insertMetaStrategy(createTestMetaStrategy());
+
+      persistence.updateMetaStrategy('strat-1', { applicationCount: 10, successRate: 0.9 });
+
+      const row = persistence.getMetaStrategy('strat-1');
+      expect(row!.application_count).toBe(10);
+      expect(row!.success_rate).toBe(0.9);
+    });
+
+    it('should delete a meta strategy', () => {
+      persistence.insertMetaStrategy(createTestMetaStrategy());
+      expect(persistence.deleteMetaStrategy('strat-1')).toBe(true);
+      expect(persistence.getMetaStrategy('strat-1')).toBeUndefined();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // System State (key-value)
+  // --------------------------------------------------------------------------
+
+  describe('system state', () => {
+    it('should store and retrieve typed state', () => {
+      persistence.setSystemState('moe_gate', { weights: [0.1, 0.2, 0.7] });
+
+      const state = persistence.getSystemState<{ weights: number[] }>('moe_gate');
+      expect(state).toBeDefined();
+      expect(state!.weights).toEqual([0.1, 0.2, 0.7]);
+    });
+
+    it('should return undefined for missing key', () => {
+      expect(persistence.getSystemState('nonexistent')).toBeUndefined();
+    });
+
+    it('should overwrite existing state', () => {
+      persistence.setSystemState('counter', 1);
+      persistence.setSystemState('counter', 2);
+
+      expect(persistence.getSystemState<number>('counter')).toBe(2);
+    });
+
+    it('should delete state', () => {
+      persistence.setSystemState('temp', 'value');
+      expect(persistence.deleteSystemState('temp')).toBe(true);
+      expect(persistence.getSystemState('temp')).toBeUndefined();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Transactions
+  // --------------------------------------------------------------------------
+
+  describe('transactions', () => {
+    it('should commit batch inserts atomically', () => {
+      persistence.transaction(() => {
+        for (let i = 0; i < 10; i++) {
+          persistence.insertExperience(createTestExperience({ id: `exp-${i}` }));
+        }
+      });
+
+      expect(persistence.getExperienceCount()).toBe(10);
+    });
+
+    it('should roll back on error', () => {
+      try {
+        persistence.transaction(() => {
+          persistence.insertExperience(createTestExperience({ id: 'exp-1' }));
+          throw new Error('Simulated failure');
+        });
+      } catch {
+        // Expected
+      }
+
+      expect(persistence.getExperienceCount()).toBe(0);
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Factory
+  // --------------------------------------------------------------------------
+
+  describe('factory', () => {
+    it('should create persistence with default config', () => {
+      const p = createSqlitePersistence({ baseDir: tmpDir });
+      expect(p).toBeInstanceOf(SqlitePersistence);
+    });
+  });
+});

package/tests/runtime/agent-manager.test.ts

@@ -8,16 +8,20 @@ import type { AgentSession, ToolCall, AgentMessage } from '../../src/runtime/typ
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 
 describe('AgentManager', () => {
   let tempDir: string;
   let memory: MemorySystem;
   let manager: AgentManager;
   let mockBackend: MockBackend;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'agent-manager-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     await memory.init();
 
     manager = createAgentManager(memory);
@@ -31,6 +35,7 @@ describe('AgentManager', () => {
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 

package/tests/runtime/delegate.test.ts

@@ -15,15 +15,19 @@ import type { MemorySystem } from '../../src/memory/system.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 
 describe('AgentDelegate', () => {
   let tempDir: string;
   let memory: MemorySystem;
   let mockBackend: MockBackend;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'delegate-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     mockBackend = createMockBackend({
       success: true,
       result: 'Mock result',
@@ -33,6 +37,7 @@ describe('AgentDelegate', () => {
   });
 
   afterEach(async () => {
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });