cognitive-core 0.2.5 → 0.3.1

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

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