@symerian/symi 3.0.17 → 3.0.19

package/extensions/learning-loop/src/test/fixes.test.ts

@@ -1,1286 +0,0 @@
-/**
- * Comprehensive tests for the four follow-up fixes:
- *   A. Shared reconstructCompletedRun utility
- *   B. Pruning preserves learnings (sentinel __pruned__ row) + pruneStaleLearnings
- *   C. Lazy bridge available() state tracking
- *   D. Tool pattern matching with Jaccard similarity
- *   E. Feedback rescoring updates DB (explicit + implicit paths)
- *   F. Embeddings populated when bridge available + backfill DB methods
- */
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { reconstructCompletedRun, normalizeCompletedRun } from "../capture/serializer.js";
-import { createDatabaseManager } from "../db.js";
-import { createExplicitFeedbackHandler } from "../feedback/explicit-feedback.js";
-import { createEmbeddingBridge, type EmbeddingBridge } from "../learning/embedding-bridge.js";
-import { createLearningExtractor } from "../learning/learning-extractor.js";
-import { createLearningStore } from "../learning/learning-store.js";
-import { createQualityEngine } from "../scoring/quality-engine.js";
-import type { CompletedRun, LearningLoopConfig, RunRow, ToolCallRow } from "../types.js";
-
-const TEST_CONFIG: LearningLoopConfig = {
-  capture: { embedPrompts: false, maxRuns: 1000 },
-  scoring: {
-    weights: {
-      taskCompletion: 0.35,
-      toolEfficiency: 0.25,
-      responseAppropriateLength: 0.1,
-      latencyRelative: 0.1,
-      userFeedback: 0.2,
-    },
-  },
-  injection: { maxLearnings: 5, minRelevance: 0.1, maxTokens: 500, cacheTtlMs: 60000 },
-  decay: { halfLifeDays: 30 },
-};
-
-const logger = {
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  debug: () => {},
-};
-
-function makeRun(overrides: Partial<CompletedRun> = {}): CompletedRun {
-  return {
-    runId: `run_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-    sessionId: "sess-1",
-    sessionKey: "sk-1",
-    agentId: "agent-1",
-    provider: "openai",
-    model: "gpt-4",
-    promptHash: "hash-default",
-    promptLength: 100,
-    responseLength: 200,
-    responseToolCallCount: 2,
-    usage: { input: 50, output: 100, cacheRead: 0, cacheWrite: 0, total: 150 },
-    toolCalls: [],
-    success: true,
-    error: null,
-    durationMs: 1000,
-    startedAt: Date.now() - 1000,
-    completedAt: Date.now(),
-    ...overrides,
-  };
-}
-
-const testScore = { score: 0.85, signals: [], algorithmVersion: 1 } as const;
-
-// ---------------------------------------------------------------------------
-// A. reconstructCompletedRun shared utility
-// ---------------------------------------------------------------------------
-describe("reconstructCompletedRun", () => {
-  let tmpDir: string;
-  let db: ReturnType<typeof createDatabaseManager>;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ll-fixes-reconstruct-"));
-    db = createDatabaseManager({ stateDir: tmpDir, config: TEST_CONFIG, logger });
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("should roundtrip a run through DB and reconstruct identically", () => {
-    const original = makeRun({
-      runId: "roundtrip-1",
-      provider: "claude",
-      model: "claude-3-opus",
-      promptHash: "abc123",
-      promptLength: 500,
-      responseLength: 1200,
-      responseToolCallCount: 3,
-      usage: { input: 200, output: 400, cacheRead: 50, cacheWrite: 10, total: 660 },
-      toolCalls: [
-        { toolName: "Read", durationMs: 15, success: true, error: null, paramHash: "ph1" },
-        {
-          toolName: "Edit",
-          durationMs: 42,
-          success: false,
-          error: "file not found",
-          paramHash: "ph2",
-        },
-        { toolName: "Bash", durationMs: 100, success: true, error: null, paramHash: "ph3" },
-      ],
-      success: true,
-      error: null,
-      durationMs: 2500,
-      startedAt: 1700000000000,
-      completedAt: 1700000002500,
-    });
-
-    db.insertRun(original, { score: 0.8, signals: [], algorithmVersion: 1 });
-    const row = db.getRun("roundtrip-1")!;
-    const toolCalls = db.getToolCalls("roundtrip-1");
-    const reconstructed = reconstructCompletedRun(row, toolCalls);
-
-    expect(reconstructed.runId).toBe(original.runId);
-    expect(reconstructed.provider).toBe(original.provider);
-    expect(reconstructed.model).toBe(original.model);
-    expect(reconstructed.promptHash).toBe(original.promptHash);
-    expect(reconstructed.promptLength).toBe(original.promptLength);
-    expect(reconstructed.responseLength).toBe(original.responseLength);
-    expect(reconstructed.responseToolCallCount).toBe(original.responseToolCallCount);
-    expect(reconstructed.usage).toEqual(original.usage);
-    expect(reconstructed.success).toBe(original.success);
-    expect(reconstructed.error).toBe(original.error);
-    expect(reconstructed.durationMs).toBe(original.durationMs);
-    expect(reconstructed.startedAt).toBe(original.startedAt);
-    expect(reconstructed.completedAt).toBe(original.completedAt);
-
-    expect(reconstructed.toolCalls).toHaveLength(3);
-    expect(reconstructed.toolCalls[0]!.toolName).toBe("Read");
-    expect(reconstructed.toolCalls[1]!.success).toBe(false);
-    expect(reconstructed.toolCalls[1]!.error).toBe("file not found");
-    expect(reconstructed.toolCalls[2]!.durationMs).toBe(100);
-  });
-
-  it("should handle a run with no tool calls", () => {
-    const original = makeRun({ runId: "no-tools", toolCalls: [], responseToolCallCount: 0 });
-    db.insertRun(original, testScore);
-
-    const row = db.getRun("no-tools")!;
-    const toolCalls = db.getToolCalls("no-tools");
-    const reconstructed = reconstructCompletedRun(row, toolCalls);
-
-    expect(reconstructed.toolCalls).toHaveLength(0);
-  });
-
-  it("should reconstruct error run with null error field correctly", () => {
-    const original = makeRun({ runId: "failed-run", success: false, error: "timeout" });
-    db.insertRun(original, testScore);
-
-    const row = db.getRun("failed-run")!;
-    const reconstructed = reconstructCompletedRun(row, []);
-
-    expect(reconstructed.success).toBe(false);
-    expect(reconstructed.error).toBe("timeout");
-  });
-
-  it("should convert success from integer to boolean", () => {
-    // DB stores success as 0/1 integer; reconstructCompletedRun must return boolean
-    const run = makeRun({ runId: "bool-check", success: true });
-    db.insertRun(run, testScore);
-
-    const row = db.getRun("bool-check")!;
-    // DB row has integer
-    expect(typeof row.success).toBe("number");
-
-    const reconstructed = reconstructCompletedRun(row, []);
-    expect(typeof reconstructed.success).toBe("boolean");
-    expect(reconstructed.success).toBe(true);
-  });
-
-  it("should be usable from explicit-feedback path (integration)", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({
-      runId: "fb-reconstruct",
-      toolCalls: [{ toolName: "Glob", durationMs: 5, success: true, error: null, paramHash: "g1" }],
-      responseToolCallCount: 1,
-    });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    // The explicit feedback handler internally uses reconstructCompletedRun
-    const handler = createExplicitFeedbackHandler({ db, qualityEngine });
-    const fb = handler.submitFeedback("fb-reconstruct", 4);
-
-    expect(fb).not.toBeNull();
-    expect(fb!.score).toBe(4);
-
-    // Score should have been updated via the reconstructed run
-    const updatedRow = db.getRun("fb-reconstruct")!;
-    expect(updatedRow.quality_score).not.toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// B. Pruning preserves learnings (sentinel row)
-// ---------------------------------------------------------------------------
-describe("Pruning preserves learnings", () => {
-  let tmpDir: string;
-  let db: ReturnType<typeof createDatabaseManager>;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ll-fixes-prune-"));
-    db = createDatabaseManager({ stateDir: tmpDir, config: TEST_CONFIG, logger });
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("should set run_id to '__pruned__' on learnings when their run is pruned", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-
-    const run = makeRun({ runId: "run-to-prune" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    const learningId = learningStore.addLearning({
-      runId: "run-to-prune",
-      category: "tool_pattern",
-      content: "This learning should survive pruning",
-      embedding: null,
-      confidence: 0.8,
-    });
-    expect(learningId).not.toBeNull();
-
-    const pruned = db.pruneOldRuns(0);
-    expect(pruned).toBe(1);
-    expect(db.getRunCount()).toBe(0);
-
-    const row = db.getLearning(learningId!);
-    expect(row).toBeDefined();
-    expect(row!.run_id).toBe("__pruned__");
-  });
-
-  it("should preserve multiple learnings across multiple pruned runs", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-
-    // Insert 3 runs with learnings
-    const learningIds: string[] = [];
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `multi-prune-${i}`,
-        completedAt: Date.now() - (3 - i) * 1000,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      const id = learningStore.addLearning({
-        runId: `multi-prune-${i}`,
-        category: "tool_pattern",
-        content: `Learning from run ${i} unique content`,
-        embedding: null,
-        confidence: 0.8,
-      });
-      if (id) learningIds.push(id);
-    }
-    expect(learningIds).toHaveLength(3);
-
-    // Prune down to 1 run (keeps the newest)
-    const pruned = db.pruneOldRuns(1);
-    expect(pruned).toBe(2);
-    expect(db.getRunCount()).toBe(1);
-
-    // All 3 learnings should still exist; 2 with __pruned__, 1 with original run_id
-    for (const id of learningIds) {
-      const row = db.getLearning(id);
-      expect(row).toBeDefined();
-    }
-
-    const prunedLearnings = learningIds
-      .map((id) => db.getLearning(id)!)
-      .filter((r) => r.run_id === "__pruned__");
-    expect(prunedLearnings).toHaveLength(2);
-  });
-
-  it("should not create sentinel if no learnings exist for pruned runs", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-
-    // Insert runs without learnings
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `no-learning-${i}`,
-        completedAt: Date.now() - (3 - i) * 1000,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-    }
-
-    // Pruning should still work (sentinel is created but has no learnings referencing it)
-    const pruned = db.pruneOldRuns(1);
-    expect(pruned).toBe(2);
-    expect(db.getRunCount()).toBe(1);
-  });
-
-  it("should handle pruning idempotently (sentinel already exists)", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-
-    // First round: insert 2 runs with learnings, prune to 1
-    for (let i = 0; i < 2; i++) {
-      const run = makeRun({
-        runId: `idem-round1-${i}`,
-        completedAt: Date.now() - (2 - i) * 1000,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      learningStore.addLearning({
-        runId: `idem-round1-${i}`,
-        category: "tool_pattern",
-        content: `Idempotent learning round 1 run ${i}`,
-        embedding: null,
-        confidence: 0.8,
-      });
-    }
-    db.pruneOldRuns(1);
-    expect(db.getRunCount()).toBe(1);
-
-    // Second round: insert 2 more runs, prune to 1 again
-    for (let i = 0; i < 2; i++) {
-      const run = makeRun({
-        runId: `idem-round2-${i}`,
-        completedAt: Date.now() + (i + 1) * 1000,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      learningStore.addLearning({
-        runId: `idem-round2-${i}`,
-        category: "error_recovery",
-        content: `Idempotent learning round 2 run ${i}`,
-        embedding: null,
-        confidence: 0.7,
-      });
-    }
-    const pruned = db.pruneOldRuns(1);
-    expect(pruned).toBe(2);
-    expect(db.getRunCount()).toBe(1);
-
-    // All 4 learnings should exist
-    const allLearnings = db.getAllLearnings(100);
-    expect(allLearnings).toHaveLength(4);
-  });
-
-  it("should return 0 when nothing to prune", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: "keep-me" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    const pruned = db.pruneOldRuns(10);
-    expect(pruned).toBe(0);
-    expect(db.getRunCount()).toBe(1);
-  });
-
-  it("should exclude sentinel from getRunCount", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-
-    const run = makeRun({ runId: "count-test" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-    learningStore.addLearning({
-      runId: "count-test",
-      category: "tool_pattern",
-      content: "count test learning",
-      embedding: null,
-      confidence: 0.8,
-    });
-
-    expect(db.getRunCount()).toBe(1);
-
-    db.pruneOldRuns(0);
-    // Sentinel exists in DB but getRunCount should return 0
-    expect(db.getRunCount()).toBe(0);
-  });
-
-  it("should remove stale learnings (old, unapplied, low-confidence)", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const longAgo = Date.now() - 120 * 24 * 60 * 60 * 1000;
-
-    const run = makeRun({ runId: "r1" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    db.insertLearning({
-      id: "stale-1",
-      runId: "r1",
-      category: "tool_pattern",
-      content: "stale learning",
-      embedding: null,
-      confidence: 0.3,
-      appliedCount: 0,
-      createdAt: longAgo,
-      updatedAt: longAgo,
-    });
-
-    const pruned = db.pruneStaleLearnings(90 * 24 * 60 * 60 * 1000);
-    expect(pruned).toBe(1);
-    expect(db.getLearning("stale-1")).toBeUndefined();
-  });
-
-  it("should preserve active learnings (applied or high-confidence)", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const longAgo = Date.now() - 120 * 24 * 60 * 60 * 1000;
-
-    const run1 = makeRun({ runId: "r1" });
-    db.insertRun(run1, qualityEngine.scoreRun(run1));
-    const run2 = makeRun({ runId: "r2" });
-    db.insertRun(run2, qualityEngine.scoreRun(run2));
-
-    db.insertLearning({
-      id: "active-hc",
-      runId: "r1",
-      category: "tool_pattern",
-      content: "high confidence learning",
-      embedding: null,
-      confidence: 0.9,
-      appliedCount: 0,
-      createdAt: longAgo,
-      updatedAt: longAgo,
-    });
-
-    db.insertLearning({
-      id: "active-applied",
-      runId: "r2",
-      category: "error_recovery",
-      content: "applied learning",
-      embedding: null,
-      confidence: 0.3,
-      appliedCount: 5,
-      createdAt: longAgo,
-      updatedAt: longAgo,
-    });
-
-    const pruned = db.pruneStaleLearnings(90 * 24 * 60 * 60 * 1000);
-    expect(pruned).toBe(0);
-    expect(db.getLearning("active-hc")).toBeDefined();
-    expect(db.getLearning("active-applied")).toBeDefined();
-  });
-
-  it("should not prune learnings that are old but recently updated", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const longAgo = Date.now() - 120 * 24 * 60 * 60 * 1000;
-
-    const run = makeRun({ runId: "r-recent" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    db.insertLearning({
-      id: "recently-updated",
-      runId: "r-recent",
-      category: "tool_pattern",
-      content: "old but recently updated",
-      embedding: null,
-      confidence: 0.3,
-      appliedCount: 0,
-      createdAt: longAgo,
-      updatedAt: Date.now(), // recently updated
-    });
-
-    const pruned = db.pruneStaleLearnings(90 * 24 * 60 * 60 * 1000);
-    expect(pruned).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// C. Lazy bridge available() state tracking
-// ---------------------------------------------------------------------------
-describe("Lazy bridge available() state tracking", () => {
-  it("should return true (optimistic) before bridge resolves", () => {
-    // Simulate the lazy bridge pattern from index.ts
-    let bridgeResolved = false;
-    let bridgeHasProvider = false;
-
-    const lazyAvailable = () => (bridgeResolved ? bridgeHasProvider : true);
-
-    // Before any embed call, available() is optimistic
-    expect(lazyAvailable()).toBe(true);
-  });
-
-  it("should return true after resolving with a real provider", async () => {
-    let bridgeResolved = false;
-    let bridgeHasProvider = false;
-    let bridgePromise: Promise<EmbeddingBridge> | null = null;
-
-    const realBridge: EmbeddingBridge = {
-      embed: async () => [0.1, 0.2],
-      embedBatch: async (texts) => texts.map(() => [0.1, 0.2]),
-      available: () => true,
-    };
-
-    async function initAndTrack(): Promise<EmbeddingBridge> {
-      bridgeResolved = true;
-      bridgeHasProvider = realBridge.available();
-      return realBridge;
-    }
-
-    const lazyBridge: EmbeddingBridge = {
-      async embed(text) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embed(text);
-      },
-      async embedBatch(texts) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embedBatch(texts);
-      },
-      available: () => (bridgeResolved ? bridgeHasProvider : true),
-    };
-
-    // Before use: optimistic
-    expect(lazyBridge.available()).toBe(true);
-
-    // Trigger initialization
-    const result = await lazyBridge.embed("test");
-    expect(result).toEqual([0.1, 0.2]);
-
-    // After resolve: accurately true
-    expect(lazyBridge.available()).toBe(true);
-  });
-
-  it("should return false after resolving with no provider", async () => {
-    let bridgeResolved = false;
-    let bridgeHasProvider = false;
-    let bridgePromise: Promise<EmbeddingBridge> | null = null;
-
-    const nullBridge: EmbeddingBridge = {
-      embed: async () => null,
-      embedBatch: async (texts) => texts.map(() => null),
-      available: () => false,
-    };
-
-    async function initAndTrack(): Promise<EmbeddingBridge> {
-      bridgeResolved = true;
-      bridgeHasProvider = nullBridge.available();
-      return nullBridge;
-    }
-
-    const lazyBridge: EmbeddingBridge = {
-      async embed(text) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embed(text);
-      },
-      async embedBatch(texts) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embedBatch(texts);
-      },
-      available: () => (bridgeResolved ? bridgeHasProvider : true),
-    };
-
-    // Before use: optimistic
-    expect(lazyBridge.available()).toBe(true);
-
-    // Trigger initialization
-    const result = await lazyBridge.embed("test");
-    expect(result).toBeNull();
-
-    // After resolve: accurately false
-    expect(lazyBridge.available()).toBe(false);
-  });
-
-  it("should only initialize once even with concurrent calls", async () => {
-    let initCount = 0;
-    let bridgeResolved = false;
-    let bridgeHasProvider = false;
-    let bridgePromise: Promise<EmbeddingBridge> | null = null;
-
-    const realBridge: EmbeddingBridge = {
-      embed: async () => [1.0],
-      embedBatch: async (texts) => texts.map(() => [1.0]),
-      available: () => true,
-    };
-
-    async function initAndTrack(): Promise<EmbeddingBridge> {
-      initCount++;
-      bridgeResolved = true;
-      bridgeHasProvider = realBridge.available();
-      return realBridge;
-    }
-
-    const lazyBridge: EmbeddingBridge = {
-      async embed(text) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embed(text);
-      },
-      async embedBatch(texts) {
-        if (!bridgePromise) bridgePromise = initAndTrack();
-        return (await bridgePromise).embedBatch(texts);
-      },
-      available: () => (bridgeResolved ? bridgeHasProvider : true),
-    };
-
-    // Fire multiple concurrent calls
-    const results = await Promise.all([
-      lazyBridge.embed("a"),
-      lazyBridge.embed("b"),
-      lazyBridge.embedBatch(["c", "d"]),
-    ]);
-
-    expect(initCount).toBe(1);
-    expect(results[0]).toEqual([1.0]);
-    expect(results[1]).toEqual([1.0]);
-    expect(results[2]).toEqual([[1.0], [1.0]]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// D. createEmbeddingBridge unit tests
-// ---------------------------------------------------------------------------
-describe("createEmbeddingBridge", () => {
-  it("should return available=true with a real provider", () => {
-    const mockProvider = {
-      embedQuery: async (text: string) => [0.1, 0.2, 0.3],
-      embedBatch: async (texts: string[]) => texts.map(() => [0.1, 0.2, 0.3]),
-    };
-    const bridge = createEmbeddingBridge({ provider: mockProvider, logger });
-    expect(bridge.available()).toBe(true);
-  });
-
-  it("should return available=false with null provider", () => {
-    const bridge = createEmbeddingBridge({ provider: null, logger });
-    expect(bridge.available()).toBe(false);
-  });
-
-  it("should return null from embed when provider is null", async () => {
-    const bridge = createEmbeddingBridge({ provider: null, logger });
-    const result = await bridge.embed("test");
-    expect(result).toBeNull();
-  });
-
-  it("should return all nulls from embedBatch when provider is null", async () => {
-    const bridge = createEmbeddingBridge({ provider: null, logger });
-    const results = await bridge.embedBatch(["a", "b", "c"]);
-    expect(results).toEqual([null, null, null]);
-  });
-
-  it("should return vector from embed when provider exists", async () => {
-    const mockProvider = {
-      embedQuery: async (text: string) => [0.5, 0.6],
-      embedBatch: async (texts: string[]) => texts.map(() => [0.5, 0.6]),
-    };
-    const bridge = createEmbeddingBridge({ provider: mockProvider, logger });
-    const result = await bridge.embed("test");
-    expect(result).toEqual([0.5, 0.6]);
-  });
-
-  it("should gracefully return null on embed error", async () => {
-    const mockProvider = {
-      embedQuery: async () => {
-        throw new Error("API timeout");
-      },
-      embedBatch: async (texts: string[]) => texts.map(() => [0.1]),
-    };
-    const bridge = createEmbeddingBridge({ provider: mockProvider, logger });
-    const result = await bridge.embed("test");
-    expect(result).toBeNull();
-  });
-
-  it("should gracefully return nulls on embedBatch error", async () => {
-    const mockProvider = {
-      embedQuery: async () => [0.1],
-      embedBatch: async () => {
-        throw new Error("batch limit exceeded");
-      },
-    };
-    const bridge = createEmbeddingBridge({ provider: mockProvider, logger });
-    const results = await bridge.embedBatch(["a", "b"]);
-    expect(results).toEqual([null, null]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// E. Tool pattern matching with Jaccard similarity
-// ---------------------------------------------------------------------------
-describe("Tool pattern matching with Jaccard", () => {
-  let tmpDir: string;
-  let db: ReturnType<typeof createDatabaseManager>;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ll-fixes-jaccard-"));
-    db = createDatabaseManager({ stateDir: tmpDir, config: TEST_CONFIG, logger });
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("should extract a tool pattern when same tools appear in different order", async () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-    const extractor = createLearningExtractor({ db, learningStore, config: TEST_CONFIG });
-
-    const toolsA = [
-      { toolName: "Read", durationMs: 10, success: true, error: null, paramHash: "a" },
-      { toolName: "Edit", durationMs: 20, success: true, error: null, paramHash: "b" },
-      { toolName: "Bash", durationMs: 30, success: true, error: null, paramHash: "c" },
-    ];
-    const toolsB = [
-      { toolName: "Bash", durationMs: 15, success: true, error: null, paramHash: "d" },
-      { toolName: "Read", durationMs: 25, success: true, error: null, paramHash: "e" },
-      { toolName: "Edit", durationMs: 35, success: true, error: null, paramHash: "f" },
-    ];
-
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `jaccard-run-${i}`,
-        toolCalls: i % 2 === 0 ? toolsA : toolsB,
-        responseToolCallCount: 3,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      db.updateRunScore(run.runId, 0.9);
-    }
-
-    const currentRun = makeRun({
-      runId: "jaccard-current",
-      toolCalls: [
-        { toolName: "Edit", durationMs: 12, success: true, error: null, paramHash: "g" },
-        { toolName: "Bash", durationMs: 22, success: true, error: null, paramHash: "h" },
-        { toolName: "Read", durationMs: 32, success: true, error: null, paramHash: "i" },
-      ],
-      responseToolCallCount: 3,
-    });
-    db.insertRun(currentRun, qualityEngine.scoreRun(currentRun));
-    db.updateRunScore(currentRun.runId, 0.9);
-
-    await extractor.extract(currentRun, { score: 0.9, signals: [], algorithmVersion: 1 });
-
-    const learnings = learningStore.listLearnings({ category: "tool_pattern" });
-    expect(learnings.length).toBeGreaterThanOrEqual(1);
-    expect(learnings[0]!.content).toContain("Read");
-    expect(learnings[0]!.content).toContain("Edit");
-    expect(learnings[0]!.content).toContain("Bash");
-  });
-
-  it("should NOT extract a pattern when tool sets differ significantly (low Jaccard)", async () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-    const extractor = createLearningExtractor({ db, learningStore, config: TEST_CONFIG });
-
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `low-jaccard-${i}`,
-        toolCalls: [
-          { toolName: `UniqueA${i}`, durationMs: 10, success: true, error: null, paramHash: "x" },
-          { toolName: `UniqueB${i}`, durationMs: 20, success: true, error: null, paramHash: "y" },
-        ],
-        responseToolCallCount: 2,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      db.updateRunScore(run.runId, 0.9);
-    }
-
-    const currentRun = makeRun({
-      runId: "low-jaccard-current",
-      toolCalls: [
-        { toolName: "Diff1", durationMs: 10, success: true, error: null, paramHash: "z" },
-        { toolName: "Diff2", durationMs: 20, success: true, error: null, paramHash: "w" },
-      ],
-      responseToolCallCount: 2,
-    });
-    db.insertRun(currentRun, qualityEngine.scoreRun(currentRun));
-    db.updateRunScore(currentRun.runId, 0.9);
-
-    await extractor.extract(currentRun, { score: 0.9, signals: [], algorithmVersion: 1 });
-
-    const learnings = learningStore.listLearnings({ category: "tool_pattern" });
-    expect(learnings.length).toBe(0);
-  });
-
-  it("should match with high overlap (4/5 shared tools = Jaccard 0.8)", async () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-    const extractor = createLearningExtractor({ db, learningStore, config: TEST_CONFIG });
-
-    // Base tool set: A, B, C, D, E
-    const baseTools = ["ToolA", "ToolB", "ToolC", "ToolD", "ToolE"];
-    // Current: A, B, C, D, F => intersection=4, union=6, Jaccard=4/6=0.667 < 0.8
-    // But if current is A, B, C, D, E too => Jaccard=1.0
-    // Let's test the exact boundary: 4 shared out of 5 each = 4/6 = 0.667 < 0.8
-
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `overlap-${i}`,
-        toolCalls: baseTools.map((t) => ({
-          toolName: t,
-          durationMs: 10,
-          success: true,
-          error: null,
-          paramHash: `h${i}`,
-        })),
-        responseToolCallCount: 5,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      db.updateRunScore(run.runId, 0.9);
-    }
-
-    // Current run shares 4 of 5 tools + 1 different => Jaccard = 4/6 = 0.667
-    const currentRun = makeRun({
-      runId: "overlap-current",
-      toolCalls: ["ToolA", "ToolB", "ToolC", "ToolD", "ToolX"].map((t) => ({
-        toolName: t,
-        durationMs: 10,
-        success: true,
-        error: null,
-        paramHash: "hc",
-      })),
-      responseToolCallCount: 5,
-    });
-    db.insertRun(currentRun, qualityEngine.scoreRun(currentRun));
-    db.updateRunScore(currentRun.runId, 0.9);
-
-    await extractor.extract(currentRun, { score: 0.9, signals: [], algorithmVersion: 1 });
-
-    // 4/6 = 0.667 < 0.8, so should NOT match
-    const learnings = learningStore.listLearnings({ category: "tool_pattern" });
-    expect(learnings.length).toBe(0);
-  });
-
-  it("should not extract patterns for low-score runs", async () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-    const extractor = createLearningExtractor({ db, learningStore, config: TEST_CONFIG });
-
-    const tools = [
-      { toolName: "Read", durationMs: 10, success: true, error: null, paramHash: "a" },
-      { toolName: "Edit", durationMs: 20, success: true, error: null, paramHash: "b" },
-    ];
-
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `lowscore-${i}`,
-        toolCalls: tools,
-        responseToolCallCount: 2,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      db.updateRunScore(run.runId, 0.9);
-    }
-
-    const currentRun = makeRun({
-      runId: "lowscore-current",
-      toolCalls: tools,
-      responseToolCallCount: 2,
-    });
-    db.insertRun(currentRun, qualityEngine.scoreRun(currentRun));
-
-    // Extract with a score below 0.7 threshold
-    await extractor.extract(currentRun, { score: 0.5, signals: [], algorithmVersion: 1 });
-
-    const learnings = learningStore.listLearnings({ category: "tool_pattern" });
-    expect(learnings.length).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// F. Feedback rescoring updates DB
-// ---------------------------------------------------------------------------
-describe("Feedback rescoring updates DB", () => {
-  let tmpDir: string;
-  let db: ReturnType<typeof createDatabaseManager>;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ll-fixes-feedback-"));
-    db = createDatabaseManager({ stateDir: tmpDir, config: TEST_CONFIG, logger });
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("should update quality_score via updateRunScore", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: "rescore-1" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    db.updateRunScore("rescore-1", 0.99);
-    const row = db.getRun("rescore-1");
-    expect(row).toBeDefined();
-    expect(row!.quality_score).toBeCloseTo(0.99, 5);
-  });
-
-  it("should rescore via explicit feedback handler with qualityEngine", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: "fb-rescore-1" });
-    const initialScore = qualityEngine.scoreRun(run);
-    db.insertRun(run, initialScore);
-
-    const handler = createExplicitFeedbackHandler({ db, qualityEngine });
-    const fb = handler.submitFeedback("fb-rescore-1", 5);
-    expect(fb).not.toBeNull();
-
-    const row = db.getRun("fb-rescore-1");
-    expect(row).toBeDefined();
-    expect(row!.quality_score).not.toBeCloseTo(initialScore.score, 5);
-  });
-
-  it("should clamp feedback scores to 1-5 range", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: "clamp-test" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    const handler = createExplicitFeedbackHandler({ db });
-
-    const fb1 = handler.submitFeedback("clamp-test", -10);
-    expect(fb1!.score).toBe(1);
-
-    const fb2 = handler.submitFeedback("clamp-test", 100);
-    expect(fb2!.score).toBe(5);
-  });
-
-  it("should return null when submitting feedback for nonexistent run", () => {
-    const handler = createExplicitFeedbackHandler({ db });
-    const fb = handler.submitFeedback("nonexistent-run", 3);
-    expect(fb).toBeNull();
-  });
-
-  it("should persist feedback record in DB", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: "persist-fb" });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-
-    const handler = createExplicitFeedbackHandler({ db });
-    handler.submitFeedback("persist-fb", 4);
-
-    const feedbacks = db.getFeedback("persist-fb");
-    expect(feedbacks).toHaveLength(1);
-    expect(feedbacks[0]!.source).toBe("explicit");
-    expect(feedbacks[0]!.score).toBe(4);
-  });
-
-  it("should handle feedback without qualityEngine (no rescore)", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: "no-qe" });
-    const score = qualityEngine.scoreRun(run);
-    db.insertRun(run, score);
-
-    // Handler without qualityEngine
-    const handler = createExplicitFeedbackHandler({ db });
-    const fb = handler.submitFeedback("no-qe", 2);
-    expect(fb).not.toBeNull();
-
-    // Score should not have changed
-    const row = db.getRun("no-qe")!;
-    expect(row.quality_score).toBeCloseTo(score.score, 5);
-  });
-
-  it("should rescore lower with bad feedback (score 1)", () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: "bad-fb" });
-    const initialScore = qualityEngine.scoreRun(run);
-    db.insertRun(run, initialScore);
-
-    const handler = createExplicitFeedbackHandler({ db, qualityEngine });
-    handler.submitFeedback("bad-fb", 1);
-
-    const row = db.getRun("bad-fb")!;
-    // With feedback of 1 (worst), score should decrease
-    expect(row.quality_score).toBeLessThan(initialScore.score);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// G. Embeddings populated when bridge available + backfill
-// ---------------------------------------------------------------------------
-describe("Embeddings populated when bridge available", () => {
-  let tmpDir: string;
-  let db: ReturnType<typeof createDatabaseManager>;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ll-fixes-embed-"));
-    db = createDatabaseManager({ stateDir: tmpDir, config: TEST_CONFIG, logger });
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("should store embeddings when bridge returns vectors", async () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-
-    const mockBridge: EmbeddingBridge = {
-      embed: async () => [0.1, 0.2, 0.3],
-      embedBatch: async (texts) => texts.map(() => [0.1, 0.2, 0.3]),
-      available: () => true,
-    };
-
-    const extractor = createLearningExtractor({
-      db,
-      learningStore,
-      config: TEST_CONFIG,
-      embeddingBridge: mockBridge,
-    });
-
-    const tools = [
-      { toolName: "Read", durationMs: 10, success: true, error: null, paramHash: "a" },
-      { toolName: "Edit", durationMs: 20, success: true, error: null, paramHash: "b" },
-    ];
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `embed-prior-${i}`,
-        toolCalls: tools,
-        responseToolCallCount: 2,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      db.updateRunScore(run.runId, 0.9);
-    }
-
-    const currentRun = makeRun({
-      runId: "embed-current",
-      toolCalls: tools,
-      responseToolCallCount: 2,
-    });
-    db.insertRun(currentRun, qualityEngine.scoreRun(currentRun));
-    db.updateRunScore(currentRun.runId, 0.9);
-
-    const ids = await extractor.extract(currentRun, {
-      score: 0.9,
-      signals: [],
-      algorithmVersion: 1,
-    });
-
-    expect(ids.length).toBeGreaterThan(0);
-    const row = db.getLearning(ids[0]!);
-    expect(row).toBeDefined();
-    expect(row!.embedding).not.toBeNull();
-    const parsed = JSON.parse(row!.embedding!) as number[];
-    expect(parsed).toEqual([0.1, 0.2, 0.3]);
-  });
-
-  it("should leave embeddings null when no bridge is provided", async () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-
-    const extractor = createLearningExtractor({
-      db,
-      learningStore,
-      config: TEST_CONFIG,
-    });
-
-    const tools = [
-      { toolName: "Read", durationMs: 10, success: true, error: null, paramHash: "a" },
-      { toolName: "Edit", durationMs: 20, success: true, error: null, paramHash: "b" },
-    ];
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `no-embed-prior-${i}`,
-        toolCalls: tools,
-        responseToolCallCount: 2,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      db.updateRunScore(run.runId, 0.9);
-    }
-
-    const currentRun = makeRun({
-      runId: "no-embed-current",
-      toolCalls: tools,
-      responseToolCallCount: 2,
-    });
-    db.insertRun(currentRun, qualityEngine.scoreRun(currentRun));
-    db.updateRunScore(currentRun.runId, 0.9);
-
-    const ids = await extractor.extract(currentRun, {
-      score: 0.9,
-      signals: [],
-      algorithmVersion: 1,
-    });
-
-    expect(ids.length).toBeGreaterThan(0);
-    const row = db.getLearning(ids[0]!);
-    expect(row).toBeDefined();
-    expect(row!.embedding).toBeNull();
-  });
-
-  it("should leave embeddings null when bridge returns null (no provider)", async () => {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const learningStore = createLearningStore({ db });
-
-    const nullBridge: EmbeddingBridge = {
-      embed: async () => null,
-      embedBatch: async (texts) => texts.map(() => null),
-      available: () => false,
-    };
-
-    const extractor = createLearningExtractor({
-      db,
-      learningStore,
-      config: TEST_CONFIG,
-      embeddingBridge: nullBridge,
-    });
-
-    const tools = [
-      { toolName: "Read", durationMs: 10, success: true, error: null, paramHash: "a" },
-      { toolName: "Edit", durationMs: 20, success: true, error: null, paramHash: "b" },
-    ];
-    for (let i = 0; i < 3; i++) {
-      const run = makeRun({
-        runId: `null-bridge-${i}`,
-        toolCalls: tools,
-        responseToolCallCount: 2,
-      });
-      db.insertRun(run, qualityEngine.scoreRun(run));
-      db.updateRunScore(run.runId, 0.9);
-    }
-
-    const currentRun = makeRun({
-      runId: "null-bridge-current",
-      toolCalls: tools,
-      responseToolCallCount: 2,
-    });
-    db.insertRun(currentRun, qualityEngine.scoreRun(currentRun));
-    db.updateRunScore(currentRun.runId, 0.9);
-
-    const ids = await extractor.extract(currentRun, {
-      score: 0.9,
-      signals: [],
-      algorithmVersion: 1,
-    });
-
-    expect(ids.length).toBeGreaterThan(0);
-    const row = db.getLearning(ids[0]!);
-    expect(row).toBeDefined();
-    expect(row!.embedding).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// H. Backfill DB methods and flow
-// ---------------------------------------------------------------------------
-describe("Embedding backfill", () => {
-  let tmpDir: string;
-  let db: ReturnType<typeof createDatabaseManager>;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ll-fixes-backfill-"));
-    db = createDatabaseManager({ stateDir: tmpDir, config: TEST_CONFIG, logger });
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  function insertLearningWithRun(id: string, embedding: number[] | null) {
-    const qualityEngine = createQualityEngine({ config: TEST_CONFIG, db });
-    const run = makeRun({ runId: `run-for-${id}` });
-    db.insertRun(run, qualityEngine.scoreRun(run));
-    db.insertLearning({
-      id,
-      runId: `run-for-${id}`,
-      category: "tool_pattern",
-      content: `Learning ${id}`,
-      embedding,
-      confidence: 0.8,
-      appliedCount: 0,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    });
-  }
-
-  it("should find learnings without embeddings", () => {
-    insertLearningWithRun("bf-1", null);
-    insertLearningWithRun("bf-2", null);
-    insertLearningWithRun("bf-3", [0.1, 0.2]);
-
-    const rows = db.getLearningsWithoutEmbeddings(100);
-    expect(rows).toHaveLength(2);
-    expect(rows.map((r) => r.id).sort()).toEqual(["bf-1", "bf-2"]);
-  });
-
-  it("should respect the limit parameter", () => {
-    insertLearningWithRun("lim-1", null);
-    insertLearningWithRun("lim-2", null);
-    insertLearningWithRun("lim-3", null);
-
-    const rows = db.getLearningsWithoutEmbeddings(2);
-    expect(rows).toHaveLength(2);
-  });
-
-  it("should update a learning embedding", () => {
-    insertLearningWithRun("upd-1", null);
-
-    db.updateLearningEmbedding("upd-1", [0.5, 0.6, 0.7]);
-
-    const row = db.getLearning("upd-1");
-    expect(row).toBeDefined();
-    expect(row!.embedding).not.toBeNull();
-    expect(JSON.parse(row!.embedding!)).toEqual([0.5, 0.6, 0.7]);
-  });
-
-  it("should not return learnings that already have embeddings", () => {
-    insertLearningWithRun("has-embed", [1.0, 2.0, 3.0]);
-
-    const rows = db.getLearningsWithoutEmbeddings(100);
-    expect(rows).toHaveLength(0);
-  });
-
-  it("should return empty array when all learnings have embeddings", () => {
-    insertLearningWithRun("all-1", [0.1]);
-    insertLearningWithRun("all-2", [0.2]);
-
-    const rows = db.getLearningsWithoutEmbeddings(100);
-    expect(rows).toHaveLength(0);
-  });
-
-  it("should simulate full backfill loop with batching", async () => {
-    // Insert 5 learnings without embeddings
-    for (let i = 0; i < 5; i++) {
-      insertLearningWithRun(`batch-${i}`, null);
-    }
-
-    const mockBridge: EmbeddingBridge = {
-      embed: async () => [0.1],
-      embedBatch: async (texts) => texts.map((_, idx) => [idx * 0.1]),
-      available: () => true,
-    };
-
-    // Simulate the backfill loop from index.ts
-    const BATCH_SIZE = 2;
-    let totalBackfilled = 0;
-
-    while (true) {
-      const rows = db.getLearningsWithoutEmbeddings(BATCH_SIZE);
-      if (rows.length === 0) break;
-
-      const texts = rows.map((r) => r.content);
-      const embeddings = await mockBridge.embedBatch(texts);
-
-      for (let i = 0; i < rows.length; i++) {
-        const emb = embeddings[i];
-        if (emb) {
-          db.updateLearningEmbedding(rows[i]!.id, emb);
-          totalBackfilled++;
-        }
-      }
-    }
-
-    expect(totalBackfilled).toBe(5);
-    expect(db.getLearningsWithoutEmbeddings(100)).toHaveLength(0);
-
-    // Verify all have embeddings now
-    for (let i = 0; i < 5; i++) {
-      const row = db.getLearning(`batch-${i}`);
-      expect(row!.embedding).not.toBeNull();
-    }
-  });
-
-  it("should handle partial failures in backfill (some null embeddings)", async () => {
-    insertLearningWithRun("partial-0", null);
-    insertLearningWithRun("partial-1", null);
-    insertLearningWithRun("partial-2", null);
-
-    const mockBridge: EmbeddingBridge = {
-      embed: async () => [0.1],
-      embedBatch: async (texts) =>
-        // Return null for the middle one
-        texts.map((_, i) => (i === 1 ? null : [0.1 * i])),
-      available: () => true,
-    };
-
-    const rows = db.getLearningsWithoutEmbeddings(100);
-    const embeddings = await mockBridge.embedBatch(rows.map((r) => r.content));
-
-    let backfilled = 0;
-    for (let i = 0; i < rows.length; i++) {
-      const emb = embeddings[i];
-      if (emb) {
-        db.updateLearningEmbedding(rows[i]!.id, emb);
-        backfilled++;
-      }
-    }
-
-    expect(backfilled).toBe(2);
-    // One learning still has no embedding
-    const remaining = db.getLearningsWithoutEmbeddings(100);
-    expect(remaining).toHaveLength(1);
-  });
-
-  it("should overwrite existing embedding via updateLearningEmbedding", () => {
-    insertLearningWithRun("overwrite", [0.1, 0.2]);
-
-    db.updateLearningEmbedding("overwrite", [0.9, 0.8]);
-
-    const row = db.getLearning("overwrite");
-    expect(JSON.parse(row!.embedding!)).toEqual([0.9, 0.8]);
-  });
-});