cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,741 @@
+/**
+ * End-to-end integration tests for SQLite persistence flows.
+ *
+ * Covers the gaps identified in persistence coverage:
+ * 1. System state persistence surviving restart (MoEGate, ReasoningBank,
+ *    TemporalCompressor)
+ * 2. Playbook recordSuccess/recordFailure with version snapshots
+ * 3. MetaMemory via MetaLearner driving observations/strategies into SQLite
+ * 4. Atlas close/reopen with full subsystem state restoration
+ * 5. EmbeddingManager with shared DB connection
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+
+import {
+  createTrajectory,
+  createStep,
+  createTask,
+  successOutcome,
+  failureOutcome,
+  createPlaybook,
+  type Trajectory,
+  type Experience,
+} from '../../src/types/index.js';
+import { MemorySystem, createMemorySystem } from '../../src/memory/system.js';
+import {
+  createSqlitePersistence,
+  type SqlitePersistence,
+} from '../../src/persistence/index.js';
+import { TaskRouter, createRouter } from '../../src/search/router.js';
+import { extractTaskFeatures } from '../../src/search/moe-gate.js';
+import { ReasoningBank, createReasoningBank } from '../../src/memory/reasoning-bank.js';
+import { InstantLoop, createInstantLoop } from '../../src/learning/instant-loop.js';
+import { TemporalCompressor, createTemporalCompressor } from '../../src/memory/temporal-compressor.js';
+import { MetaLearner, createMetaLearner } from '../../src/learning/meta-learner.js';
+import { MetaMemory, createMetaMemory } from '../../src/memory/meta.js';
+import { EmbeddingManager } from '../../src/embeddings/manager.js';
+import { Atlas, createAtlas } from '../../src/atlas.js';
+
+let testDir: string;
+
+async function makeTempDir(): Promise<string> {
+  const dir = path.join(
+    process.cwd(),
+    `.test-persistence-e2e-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`
+  );
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+// Helper trajectories
+function makeTrajectory(id: string, domain = 'code', success = true): Trajectory {
+  return createTrajectory({
+    id,
+    task: createTask({ domain, description: `Task ${id}: fix ${domain} issue` }),
+    steps: [
+      createStep({ thought: 'Analyzing', action: 'read file', observation: 'found issue' }),
+      createStep({ thought: 'Fixing', action: 'edit file', observation: 'applied fix' }),
+    ],
+    outcome: success
+      ? successOutcome({ result: 'done' })
+      : failureOutcome('failed to fix'),
+    agentId: 'test-agent',
+    wallTimeSeconds: 10,
+    llmCalls: 2,
+  });
+}
+
+function makeExperience(id: string, domain = 'code', success = true): Experience {
+  return {
+    id,
+    taskInput: `Task ${id}: fix ${domain} issue`,
+    solutionOutput: success ? 'Fixed the issue' : 'Failed to fix',
+    feedback: success ? 'Good' : 'Bad',
+    success,
+    domain,
+    trajectoryId: `traj-${id}`,
+    usageCount: 0,
+    accessScore: success ? 0.8 : 0.1,
+    createdAt: new Date(),
+    metadata: {},
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// 1. System state persistence surviving restart
+// ──────────────────────────────────────────────────────────────────────
+
+describe('System state persistence across restart', () => {
+  beforeEach(async () => {
+    testDir = await makeTempDir();
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('MoEGate state survives close/reopen', async () => {
+    // --- Session 1: Train the gate ---
+    const persistence1 = createSqlitePersistence({ baseDir: testDir });
+    await persistence1.init();
+    const memory1 = createMemorySystem(persistence1, testDir);
+    await memory1.init();
+
+    const router1 = createRouter(memory1, undefined, undefined, persistence1);
+
+    // Train the gate with several updates
+    const task = createTask({ domain: 'code', description: 'Fix typescript error' });
+    const memoryContext = await memory1.queryV2('fix typescript error');
+    for (let i = 0; i < 15; i++) {
+      router1.updateGate(task, memoryContext, 'direct', 1.0);
+    }
+
+    // Gate should be trained
+    expect(router1.getMoEGate().isTrained).toBe(true);
+    const updateCountBefore = router1.getMoEGate().totalUpdates;
+
+    // Flush state and close
+    router1.persistGateState();
+    await memory1.close();
+    persistence1.close();
+
+    // --- Session 2: Reopen and verify ---
+    const persistence2 = createSqlitePersistence({ baseDir: testDir });
+    await persistence2.init();
+    const memory2 = createMemorySystem(persistence2, testDir);
+    await memory2.init();
+
+    const router2 = createRouter(memory2, undefined, undefined, persistence2);
+    router2.loadPersistedState();
+
+    expect(router2.getMoEGate().isTrained).toBe(true);
+    expect(router2.getMoEGate().totalUpdates).toBe(updateCountBefore);
+
+    await memory2.close();
+    persistence2.close();
+  });
+
+  it('ReasoningBank clusters survive close/reopen', async () => {
+    // --- Session 1: Build clusters ---
+    const persistence1 = createSqlitePersistence({ baseDir: testDir });
+    await persistence1.init();
+
+    const bank1 = createReasoningBank({ minClusterSize: 2, maxClusters: 5 }, persistence1);
+
+    // Create enough experiences to form clusters
+    const experiences: Experience[] = [];
+    for (let i = 0; i < 6; i++) {
+      experiences.push(makeExperience(`exp-${i}`, i < 3 ? 'code' : 'testing', true));
+    }
+
+    bank1.buildClusters(experiences);
+    const clusterCountBefore = bank1.getClusters().length;
+    expect(clusterCountBefore).toBeGreaterThan(0);
+
+    const clusterIdsBefore = bank1.getClusters().map((c) => c.id).sort();
+    persistence1.close();
+
+    // --- Session 2: Reopen and verify ---
+    const persistence2 = createSqlitePersistence({ baseDir: testDir });
+    await persistence2.init();
+
+    const bank2 = createReasoningBank({ minClusterSize: 2, maxClusters: 5 }, persistence2);
+    // Clusters should be restored from system_state
+    const clusterCountAfter = bank2.getClusters().length;
+    expect(clusterCountAfter).toBe(clusterCountBefore);
+
+    const clusterIdsAfter = bank2.getClusters().map((c) => c.id).sort();
+    expect(clusterIdsAfter).toEqual(clusterIdsBefore);
+
+    persistence2.close();
+  });
+
+  it('TemporalCompressor pendingDemotion set survives close/reopen', async () => {
+    // --- Session 1: Create pending demotions ---
+    const persistence1 = createSqlitePersistence({ baseDir: testDir });
+    await persistence1.init();
+
+    const compressor1 = createTemporalCompressor(
+      { hotThreshold: 0.5, warmThreshold: 0.2, evictionThreshold: 0.05, hysteresis: 0.05 },
+      persistence1
+    );
+
+    // Create experiences that should trigger pending demotion
+    // (accessScore below warmThreshold for hot-tier experiences)
+    const experiences: Experience[] = [
+      { ...makeExperience('exp-low-1'), accessScore: 0.1, tier: 'hot' as const },
+      { ...makeExperience('exp-low-2'), accessScore: 0.1, tier: 'hot' as const },
+      { ...makeExperience('exp-high'), accessScore: 0.9, tier: 'hot' as const },
+    ];
+
+    const result1 = await compressor1.compress(experiences);
+    // Low-access experiences should be pending demotion for next pass
+    // High-access experience should be unchanged
+    expect(result1.unchanged.length + result1.demoted.length + result1.promoted.length + result1.evicted.length)
+      .toBe(experiences.length);
+
+    persistence1.close();
+
+    // --- Session 2: Reopen and verify pendingDemotion is restored ---
+    const persistence2 = createSqlitePersistence({ baseDir: testDir });
+    await persistence2.init();
+
+    const compressor2 = createTemporalCompressor(
+      { hotThreshold: 0.5, warmThreshold: 0.2, evictionThreshold: 0.05, hysteresis: 0.05 },
+      persistence2
+    );
+    compressor2.loadPersistedState();
+
+    // Second compress pass: items that were pending should now demote
+    const result2 = await compressor2.compress(experiences);
+    // The low-access items were in pendingDemotion from pass 1,
+    // so they should be demoted on this second pass
+    const totalDemoted = result2.demoted.length;
+    expect(totalDemoted).toBeGreaterThan(0);
+
+    persistence2.close();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 2. Playbook recordSuccess/recordFailure with version snapshots
+// ──────────────────────────────────────────────────────────────────────
+
+describe('Playbook version snapshots via recordSuccess/recordFailure', () => {
+  let persistence: SqlitePersistence;
+  let memory: MemorySystem;
+
+  beforeEach(async () => {
+    testDir = await makeTempDir();
+    persistence = createSqlitePersistence({ baseDir: testDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, testDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    persistence.close();
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('recordSuccess creates a version snapshot', async () => {
+    const playbook = createPlaybook({
+      id: 'pb-snap-success',
+      name: 'Test Playbook',
+      confidence: 0.5,
+      applicability: {
+        situations: ['testing'],
+        triggers: ['test'],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Test strategy',
+        tactics: ['Write tests first'],
+      },
+      verification: {
+        successIndicators: ['tests pass'],
+        failureIndicators: [],
+        commands: [],
+      },
+    });
+
+    await memory.playbooks.add(playbook);
+    const confidenceBefore = playbook.confidence;
+
+    // Record success — should snapshot version before mutation
+    await memory.playbooks.recordSuccess('pb-snap-success', 'traj-1', 'code');
+
+    // Verify version history exists
+    const versions = persistence.getPlaybookVersions('pb-snap-success');
+    expect(versions.length).toBeGreaterThanOrEqual(1);
+    expect(versions[0].changelog).toContain('Success recorded');
+
+    // Verify the snapshot captured pre-mutation state
+    const snapshot = JSON.parse(versions[0].playbook_snapshot);
+    expect(snapshot.confidence).toBe(confidenceBefore);
+
+    // Verify post-mutation playbook has updated confidence
+    const updated = await memory.playbooks.get('pb-snap-success');
+    expect(updated!.confidence).toBeGreaterThan(confidenceBefore);
+  });
+
+  it('recordFailure creates a version snapshot with failure mode', async () => {
+    const playbook = createPlaybook({
+      id: 'pb-snap-fail',
+      name: 'Failing Playbook',
+      confidence: 0.7,
+      applicability: {
+        situations: ['testing'],
+        triggers: ['test'],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Do things',
+        tactics: ['Step 1'],
+      },
+      verification: {
+        successIndicators: [],
+        failureIndicators: [],
+        commands: [],
+      },
+    });
+
+    await memory.playbooks.add(playbook);
+    const confidenceBefore = playbook.confidence;
+
+    await memory.playbooks.recordFailure(
+      'pb-snap-fail',
+      'traj-fail-1',
+      'timeout after 30s',
+      'timeout'
+    );
+
+    const versions = persistence.getPlaybookVersions('pb-snap-fail');
+    expect(versions.length).toBeGreaterThanOrEqual(1);
+    expect(versions[0].changelog).toContain('Failure recorded: timeout');
+
+    // Snapshot should have pre-mutation confidence
+    const snapshot = JSON.parse(versions[0].playbook_snapshot);
+    expect(snapshot.confidence).toBe(confidenceBefore);
+
+    // Post-mutation confidence should be lower
+    const updated = await memory.playbooks.get('pb-snap-fail');
+    expect(updated!.confidence).toBeLessThan(confidenceBefore);
+  });
+
+  it('recordSuccess and recordFailure both create snapshots at same version', async () => {
+    const playbook = createPlaybook({
+      id: 'pb-multi',
+      name: 'Multi-version Playbook',
+      confidence: 0.5,
+      applicability: {
+        situations: ['testing'],
+        triggers: ['test'],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Iterative approach',
+        tactics: ['Try stuff'],
+      },
+      verification: {
+        successIndicators: [],
+        failureIndicators: [],
+        commands: [],
+      },
+    });
+
+    await memory.playbooks.add(playbook);
+
+    // recordSuccess snapshots the version before mutation
+    await memory.playbooks.recordSuccess('pb-multi', 'traj-1', 'code');
+
+    const versions = persistence.getPlaybookVersions('pb-multi');
+    // One snapshot per unique version string (INSERT OR IGNORE on playbook_id + version PK)
+    expect(versions.length).toBe(1);
+    expect(versions[0].changelog).toContain('Success recorded');
+
+    // Multiple recordSuccess calls at the same version won't create duplicate snapshots
+    // (this is by design — version snapshots capture state per version, not per update)
+    await memory.playbooks.recordSuccess('pb-multi', 'traj-2', 'code');
+    const versions2 = persistence.getPlaybookVersions('pb-multi');
+    expect(versions2.length).toBe(1); // Still 1, same version
+
+    // recordFailure at the same version also won't duplicate
+    await memory.playbooks.recordFailure('pb-multi', 'traj-3', 'context', 'mode');
+    const versions3 = persistence.getPlaybookVersions('pb-multi');
+    expect(versions3.length).toBe(1); // Still 1, same version
+
+    // But the playbook's confidence should reflect all 3 mutations
+    const updated = await memory.playbooks.get('pb-multi');
+    expect(updated!.evolution.successCount).toBe(2);
+    expect(updated!.evolution.failureCount).toBe(1);
+  });
+
+  it('playbooks survive close/reopen and are queryable', async () => {
+    const playbook = createPlaybook({
+      id: 'pb-persist',
+      name: 'Persistent Playbook',
+      confidence: 0.8,
+      applicability: {
+        situations: ['coding errors'],
+        triggers: ['typescript', 'error'],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Check compiler errors',
+        tactics: ['Read error output', 'Fix types'],
+      },
+      verification: {
+        successIndicators: ['compiles'],
+        failureIndicators: [],
+        commands: [],
+      },
+    });
+
+    await memory.playbooks.add(playbook);
+    await memory.playbooks.recordSuccess('pb-persist', 'traj-1', 'code');
+
+    // Close everything
+    await memory.close();
+    persistence.close();
+
+    // Reopen
+    const persistence2 = createSqlitePersistence({ baseDir: testDir });
+    await persistence2.init();
+    const memory2 = createMemorySystem(persistence2, testDir);
+    await memory2.init();
+
+    // Playbook should be queryable
+    const found = await memory2.playbooks.get('pb-persist');
+    expect(found).toBeDefined();
+    expect(found!.name).toBe('Persistent Playbook');
+    expect(found!.evolution.successCount).toBe(1);
+    expect(found!.confidence).toBeGreaterThan(0.8); // boosted by success
+
+    // Should also be findable via search
+    const matches = await memory2.playbooks.findMatching('typescript error');
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches.some((m) => m.playbook.id === 'pb-persist')).toBe(true);
+
+    await memory2.close();
+    persistence2.close();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 3. MetaMemory via MetaLearner
+// ──────────────────────────────────────────────────────────────────────
+
+describe('MetaMemory driven by MetaLearner into SQLite', () => {
+  let persistence: SqlitePersistence;
+  let memory: MemorySystem;
+
+  beforeEach(async () => {
+    testDir = await makeTempDir();
+    persistence = createSqlitePersistence({ baseDir: testDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, testDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    persistence.close();
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('MetaLearner.generateReflection stores observation in SQLite', async () => {
+    const metaLearner = createMetaLearner(memory.meta);
+
+    const trajectory = makeTrajectory('meta-traj-1', 'code', true);
+    const routing = {
+      strategy: 'direct' as const,
+      confidence: 0.8,
+      estimatedBudget: 2,
+      reasoning: 'High confidence playbook found',
+    };
+
+    const observation = await metaLearner.generateReflection(trajectory, routing, []);
+
+    // Observation should be stored in SQLite via MetaMemory
+    expect(observation.id).toBeDefined();
+    expect(observation.trajectoryId).toBe('meta-traj-1');
+
+    // Verify it's persisted
+    const stats = await memory.getStats();
+    expect(stats.metaObservationCount).toBe(1);
+
+    // Query observations back
+    const observations = await memory.meta.getObservations({ limit: 10 });
+    expect(observations.length).toBe(1);
+    expect(observations[0].routing.decision).toBe('direct');
+    expect(observations[0].outcome.success).toBe(true);
+  });
+
+  it('MetaLearner generates strategies after enough observations', async () => {
+    const metaLearner = createMetaLearner(memory.meta, {
+      minObservationsForStrategies: 5,
+      strategyGenerationInterval: 5,
+      helpfulRetrievalThreshold: 0.7,
+      tacticOverlapThreshold: 2,
+    });
+
+    // Generate enough observations to trigger strategy generation
+    for (let i = 0; i < 5; i++) {
+      const traj = makeTrajectory(`meta-traj-${i}`, 'code', i % 2 === 0);
+      const routing = {
+        strategy: (i % 2 === 0 ? 'direct' : 'explore') as 'direct' | 'explore',
+        confidence: 0.5 + i * 0.1,
+        estimatedBudget: 3,
+        reasoning: 'test',
+      };
+      await metaLearner.generateReflection(traj, routing, []);
+    }
+
+    // Should have observations
+    const stats = await memory.getStats();
+    expect(stats.metaObservationCount).toBe(5);
+
+    // Strategies may have been generated (depends on pattern detection)
+    const strategies = await memory.meta.getAllStrategies();
+    // At minimum, observations should be persisted; strategies are optional
+    // based on routing effectiveness data
+    expect(stats.metaObservationCount).toBeGreaterThanOrEqual(5);
+  });
+
+  it('MetaMemory observations survive close/reopen', async () => {
+    const metaLearner = createMetaLearner(memory.meta);
+
+    const trajectory = makeTrajectory('meta-persist-1', 'code', true);
+    await metaLearner.generateReflection(trajectory, {
+      strategy: 'direct' as const,
+      confidence: 0.9,
+      estimatedBudget: 1,
+      reasoning: 'test',
+    }, []);
+
+    await memory.close();
+    persistence.close();
+
+    // Reopen
+    const persistence2 = createSqlitePersistence({ baseDir: testDir });
+    await persistence2.init();
+    const memory2 = createMemorySystem(persistence2, testDir);
+    await memory2.init();
+
+    const observations = await memory2.meta.getObservations({ limit: 10 });
+    expect(observations.length).toBe(1);
+    expect(observations[0].trajectoryId).toBe('meta-persist-1');
+
+    await memory2.close();
+    persistence2.close();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 4. Atlas close/reopen with full subsystem state restoration
+// ──────────────────────────────────────────────────────────────────────
+
+describe('Atlas full-lifecycle persistence', () => {
+  beforeEach(async () => {
+    testDir = await makeTempDir();
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('experiences, playbooks, and reflexion episodes survive Atlas restart', async () => {
+    // --- Session 1 ---
+    const atlas1 = createAtlas({
+      storage: { baseDir: testDir },
+      learning: { batchSize: 100 }, // high threshold so batch doesn't trigger
+    });
+    await atlas1.init();
+
+    // Add experience
+    const mem1 = atlas1.getMemory();
+    await mem1.experiences.add(makeExperience('exp-atlas-1', 'code', true));
+
+    // Add playbook
+    await mem1.playbooks.add(createPlaybook({
+      id: 'pb-atlas-1',
+      name: 'Atlas Playbook',
+      confidence: 0.7,
+      applicability: {
+        situations: ['testing'],
+        triggers: ['test'],
+        antiPatterns: [],
+        domains: ['code'],
+      },
+      guidance: {
+        strategy: 'Test strategy',
+        tactics: ['Write tests'],
+      },
+      verification: {
+        successIndicators: ['tests pass'],
+        failureIndicators: [],
+        commands: [],
+      },
+    }));
+
+    // Add reflexion episode
+    await mem1.reflexion.add({
+      id: 'ref-atlas-1',
+      trajectoryId: 'traj-1',
+      taskSummary: 'Fix a bug',
+      outcome: 'success',
+      selfCritique: 'Could have been faster',
+      keyInsights: ['Read errors carefully'],
+      strategyAssessment: 'Effective',
+      suggestedPlaybookUpdates: [],
+      domain: 'code',
+      createdAt: new Date(),
+    });
+
+    await atlas1.close();
+
+    // --- Session 2 ---
+    const atlas2 = createAtlas({
+      storage: { baseDir: testDir },
+      learning: { batchSize: 100 },
+    });
+    await atlas2.init();
+    const mem2 = atlas2.getMemory();
+
+    // Verify experience
+    const exp = await mem2.experiences.get('exp-atlas-1');
+    expect(exp).toBeDefined();
+    expect(exp!.domain).toBe('code');
+
+    // Verify playbook
+    const pb = await mem2.playbooks.get('pb-atlas-1');
+    expect(pb).toBeDefined();
+    expect(pb!.name).toBe('Atlas Playbook');
+
+    // Verify reflexion episode
+    const ref = await mem2.reflexion.get('ref-atlas-1');
+    expect(ref).toBeDefined();
+    expect(ref!.taskSummary).toBe('Fix a bug');
+
+    const stats = await atlas2.getStats();
+    expect(stats.memory.experienceCount).toBe(1);
+    expect(stats.memory.playbookCount).toBe(1);
+
+    await atlas2.close();
+  });
+
+  it('Atlas processTrajectory data persists across restarts', async () => {
+    // --- Session 1: Process trajectories ---
+    const atlas1 = createAtlas({
+      storage: { baseDir: testDir },
+      learning: { batchSize: 100 },
+    });
+    await atlas1.init();
+
+    await atlas1.processTrajectory(makeTrajectory('atlas-traj-1', 'code', true));
+    await atlas1.processTrajectory(makeTrajectory('atlas-traj-2', 'testing', true));
+
+    const stats1 = await atlas1.getStats();
+    expect(stats1.memory.experienceCount).toBeGreaterThanOrEqual(2);
+
+    await atlas1.close();
+
+    // --- Session 2: Data should persist ---
+    const atlas2 = createAtlas({
+      storage: { baseDir: testDir },
+      learning: { batchSize: 100 },
+    });
+    await atlas2.init();
+
+    const stats2 = await atlas2.getStats();
+    expect(stats2.memory.experienceCount).toBeGreaterThanOrEqual(2);
+
+    // Can query memory and find experiences
+    const results = await atlas2.queryMemory('fix code issue');
+    expect(results.experiences.length).toBeGreaterThan(0);
+
+    await atlas2.close();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 5. EmbeddingManager with shared DB connection
+// ──────────────────────────────────────────────────────────────────────
+
+describe('EmbeddingManager with shared DB connection', () => {
+  beforeEach(async () => {
+    testDir = await makeTempDir();
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('creates EmbeddingManager using shared DB handle from SqlitePersistence', async () => {
+    const persistence = createSqlitePersistence({ baseDir: testDir });
+    await persistence.init();
+
+    const db = persistence.getDatabase();
+
+    // BM25-only mode with shared DB (no provider → no vector search, but exercises the wiring)
+    const manager = new EmbeddingManager({ db });
+
+    // Should work for store/search via BM25 fallback
+    await manager.store('item-1', 'Fix typescript compilation errors', 'experience');
+    await manager.store('item-2', 'Write unit tests for react components', 'experience');
+
+    const results = await manager.search('typescript errors');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].id).toBe('item-1');
+
+    manager.close();
+    persistence.close();
+  });
+
+  it('SqliteVectorStore tables live in same DB as other persistence tables', async () => {
+    const persistence = createSqlitePersistence({ baseDir: testDir });
+    await persistence.init();
+
+    const db = persistence.getDatabase();
+
+    // Verify the DB already has our persistence tables
+    const tables = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+      .all() as Array<{ name: string }>;
+    const tableNames = tables.map((t) => t.name);
+    expect(tableNames).toContain('experiences');
+    expect(tableNames).toContain('playbooks');
+
+    // Insert a test experience via persistence (uses Experience interface, camelCase)
+    persistence.insertExperience({
+      id: 'shared-db-test',
+      taskInput: 'Test task',
+      solutionOutput: 'Solution',
+      feedback: 'ok',
+      success: true,
+      domain: 'code',
+      trajectoryId: 'traj-1',
+      usageCount: 0,
+      accessScore: 0.5,
+      createdAt: new Date(),
+      metadata: {},
+    });
+
+    // Verify via the same DB handle
+    const row = db.prepare('SELECT id FROM experiences WHERE id = ?').get('shared-db-test') as { id: string } | undefined;
+    expect(row).toBeDefined();
+    expect(row!.id).toBe('shared-db-test');
+
+    persistence.close();
+  });
+});