@symerian/symi 3.0.18 → 3.0.19

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

@@ -1,711 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { createDatabaseManager } from "../db.js";
-import { createEdgeInference } from "../graph/edge-inference.js";
-import { createGraphRetrieval } from "../graph/graph-retrieval.js";
-import { createGraphStore } from "../graph/graph-store.js";
-import { createLearningStore } from "../learning/learning-store.js";
-import type { RetrievalResult } from "../learning/retrieval.js";
-import type { LearningLoopConfig, CompletedRun, QualityScore, LearningRecord } 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.3, maxTokens: 500, cacheTtlMs: 60000 },
-  decay: { halfLifeDays: 30 },
-};
-
-const logger = {
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-};
-
-function makeRun(id: string): CompletedRun {
-  return {
-    runId: id,
-    sessionId: "sess-1",
-    sessionKey: "sk-1",
-    agentId: "agent-1",
-    provider: "openai",
-    model: "gpt-4",
-    promptHash: "hash-" + id,
-    promptLength: 100,
-    responseLength: 200,
-    responseToolCallCount: 0,
-    usage: { input: 50, output: 100, total: 150 },
-    toolCalls: [],
-    success: true,
-    error: null,
-    durationMs: 1000,
-    startedAt: Date.now() - 1000,
-    completedAt: Date.now(),
-  };
-}
-
-const testScore: QualityScore = {
-  score: 0.85,
-  signals: [],
-  algorithmVersion: 1,
-};
-
-// Generate a simple normalized embedding of specified dimension
-function makeEmbedding(seed: number, dim: number = 8): number[] {
-  const emb: number[] = [];
-  for (let i = 0; i < dim; i++) {
-    emb.push(Math.sin(seed + i * 0.7));
-  }
-  // Normalize
-  const norm = Math.sqrt(emb.reduce((s, v) => s + v * v, 0));
-  return emb.map((v) => v / norm);
-}
-
-/**
- * Create an embedding with a target cosine similarity to the base.
- * Uses deterministic rotation: result = cos(angle)*base + sin(angle)*orthogonal
- * where angle = arccos(targetSimilarity).
- */
-function makeEmbeddingWithSimilarity(base: number[], targetSimilarity: number): number[] {
-  const angle = Math.acos(Math.min(1, Math.max(-1, targetSimilarity)));
-  // Create an orthogonal vector by shifting and normalizing
-  const shifted = base.map((_, i) => Math.sin(i * 2.3 + 1.7));
-  // Gram-Schmidt: orth = shifted - (shifted·base)*base
-  const dot = shifted.reduce((s, v, i) => s + v * base[i]!, 0);
-  const orthRaw = shifted.map((v, i) => v - dot * base[i]!);
-  const orthNorm = Math.sqrt(orthRaw.reduce((s, v) => s + v * v, 0));
-  const orth = orthRaw.map((v) => v / orthNorm);
-  // Combine
-  const result = base.map((v, i) => Math.cos(angle) * v + Math.sin(angle) * orth[i]!);
-  const resultNorm = Math.sqrt(result.reduce((s, v) => s + v * v, 0));
-  return result.map((v) => v / resultNorm);
-}
-
-describe("Graph Store", () => {
-  let tmpDir: string;
-  let db: ReturnType<typeof createDatabaseManager>;
-  let graphStore: ReturnType<typeof createGraphStore>;
-  let learningStore: ReturnType<typeof createLearningStore>;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "graph-test-"));
-    db = createDatabaseManager({ stateDir: tmpDir, config: TEST_CONFIG, logger });
-    graphStore = createGraphStore({ db });
-    learningStore = createLearningStore({ db, graphStore });
-
-    // Insert runs for FK constraints
-    db.insertRun(makeRun("run-1"), testScore);
-    db.insertRun(makeRun("run-2"), testScore);
-    db.insertRun(makeRun("run-3"), testScore);
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  // Test 1: Edge CRUD
-  describe("Edge CRUD", () => {
-    it("should add and retrieve edges", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-a", "lrn-c", "T", 0.5);
-
-      const edges = graphStore.getEdges("lrn-a");
-      expect(edges).toHaveLength(2);
-      expect(edges.map((e) => e.edgeType).sort()).toEqual(["S", "T"]);
-    });
-
-    it("should upsert edge weight", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "R", 0.3);
-      graphStore.upsertEdge("lrn-a", "lrn-b", "R", 0.5);
-
-      const edges = graphStore.getEdges("lrn-a", { typeFilter: ["R"] });
-      expect(edges).toHaveLength(1);
-      expect(edges[0]!.weight).toBeCloseTo(0.5);
-    });
-
-    it("should filter edges by type", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-a", "lrn-c", "T", 0.5);
-      graphStore.addEdge("lrn-a", "lrn-d", "C", 0.6);
-
-      const semantic = graphStore.getEdges("lrn-a", { typeFilter: ["S"] });
-      expect(semantic).toHaveLength(1);
-      expect(semantic[0]!.edgeType).toBe("S");
-    });
-
-    it("should remove edges for a learning", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-a", "lrn-c", "T", 0.5);
-      graphStore.addEdge("lrn-d", "lrn-a", "C", 0.6);
-
-      graphStore.removeEdgesFor("lrn-a");
-
-      expect(graphStore.getEdges("lrn-a")).toHaveLength(0);
-      // Edges that referenced lrn-a from other nodes are also gone
-      expect(graphStore.getEdges("lrn-d")).toHaveLength(0);
-    });
-  });
-
-  // Test 2: Centrality
-  describe("Centrality", () => {
-    it("should track incremental centrality on edge add", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-
-      const centralityA = graphStore.getCentrality("lrn-a");
-      const centralityB = graphStore.getCentrality("lrn-b");
-
-      const expected = Math.log2(1 + 0.8);
-      expect(centralityA).toBeCloseTo(expected);
-      expect(centralityB).toBeCloseTo(expected);
-    });
-
-    it("should accumulate centrality across multiple edges", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-a", "lrn-c", "T", 0.5);
-      graphStore.addEdge("lrn-a", "lrn-d", "C", 0.6);
-
-      const centralityA = graphStore.getCentrality("lrn-a");
-      const expected = Math.log2(1.8) + Math.log2(1.5) + Math.log2(1.6);
-      expect(centralityA).toBeCloseTo(expected, 5);
-    });
-
-    it("should update centrality on edge upsert", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "R", 0.3);
-      const before = graphStore.getCentrality("lrn-a");
-
-      graphStore.upsertEdge("lrn-a", "lrn-b", "R", 0.7);
-      const after = graphStore.getCentrality("lrn-a");
-
-      expect(after).toBeGreaterThan(before);
-      expect(after).toBeCloseTo(Math.log2(1.7));
-    });
-
-    it("should recompute neighbors on removeEdgesFor", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-b", "lrn-c", "T", 0.5);
-
-      // lrn-b has centrality from both edges
-      const beforeB = graphStore.getCentrality("lrn-b");
-      expect(beforeB).toBeCloseTo(Math.log2(1.8) + Math.log2(1.5));
-
-      // Remove lrn-a edges
-      graphStore.removeEdgesFor("lrn-a");
-
-      // lrn-b should only have centrality from edge to lrn-c
-      const afterB = graphStore.getCentrality("lrn-b");
-      expect(afterB).toBeCloseTo(Math.log2(1.5));
-    });
-  });
-
-  // Test 3: Neighbors / hop expansion
-  describe("Neighbors", () => {
-    it("should get 1-hop neighbors", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-a", "lrn-c", "T", 0.5);
-
-      const neighbors = graphStore.getNeighbors("lrn-a", 1);
-      expect(neighbors.size).toBe(2);
-      expect(neighbors.has("lrn-b")).toBe(true);
-      expect(neighbors.has("lrn-c")).toBe(true);
-    });
-
-    it("should get 2-hop neighbors", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-b", "lrn-c", "T", 0.5);
-
-      const neighbors = graphStore.getNeighbors("lrn-a", 2);
-      expect(neighbors.size).toBe(2);
-      expect(neighbors.has("lrn-b")).toBe(true);
-      expect(neighbors.has("lrn-c")).toBe(true);
-    });
-
-    it("should not include self in neighbors", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      const neighbors = graphStore.getNeighbors("lrn-a", 1);
-      expect(neighbors.has("lrn-a")).toBe(false);
-    });
-
-    it("should filter by edge type", () => {
-      graphStore.addEdge("lrn-a", "lrn-b", "S", 0.8);
-      graphStore.addEdge("lrn-a", "lrn-c", "T", 0.5);
-
-      const neighbors = graphStore.getNeighbors("lrn-a", 1, ["S"]);
-      expect(neighbors.size).toBe(1);
-      expect(neighbors.has("lrn-b")).toBe(true);
-    });
-  });
-
-  // Test 4: Temporal inference
-  describe("Edge Inference - Temporal", () => {
-    it("should create T-edges for learnings from same run", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Pattern alpha",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-
-      const id2 = learningStore.addLearning({
-        runId: "run-1",
-        category: "error_recovery",
-        content: "Recovery beta",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      const learning2 = learningStore.getLearning(id2)!;
-      edgeInference.onLearningCreated(learning2, "run-1");
-
-      const edges = graphStore.getEdges(id2, { typeFilter: ["T"] });
-      expect(edges.length).toBeGreaterThanOrEqual(1);
-      // Should have T-edge connecting id1 and id2
-      const hasTemporalEdge = edges.some(
-        (e) =>
-          (e.sourceId === id1 && e.targetId === id2) || (e.sourceId === id2 && e.targetId === id1),
-      );
-      expect(hasTemporalEdge).toBe(true);
-    });
-  });
-
-  // Test 5: Semantic inference
-  describe("Edge Inference - Semantic", () => {
-    it("should create S-edges for similar embeddings", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-      const baseEmb = makeEmbedding(1);
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Use grep for code searching patterns",
-        embedding: baseEmb,
-        confidence: 0.8,
-      })!;
-
-      // Cosine ~0.75: above 0.6 threshold, below 0.92 dedup
-      const similarEmb = makeEmbeddingWithSimilarity(baseEmb, 0.75);
-      const id2 = learningStore.addLearning({
-        runId: "run-2",
-        category: "tool_pattern",
-        content: "Grep is useful for finding code patterns",
-        embedding: similarEmb,
-        confidence: 0.7,
-      })!;
-
-      expect(id2).not.toBeNull();
-      const learning2 = learningStore.getLearning(id2)!;
-      edgeInference.onLearningCreated(learning2, "run-2");
-
-      const edges = graphStore.getEdges(id2, { typeFilter: ["S"] });
-      expect(edges.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it("should not create S-edges for dissimilar embeddings", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Pattern about databases",
-        embedding: makeEmbedding(1),
-        confidence: 0.8,
-      })!;
-
-      // Very different embedding
-      const id2 = learningStore.addLearning({
-        runId: "run-2",
-        category: "error_recovery",
-        content: "Totally different topic about UI rendering",
-        embedding: makeEmbedding(100),
-        confidence: 0.7,
-      })!;
-
-      const learning2 = learningStore.getLearning(id2)!;
-      edgeInference.onLearningCreated(learning2, "run-2");
-
-      const edges = graphStore.getEdges(id2, { typeFilter: ["S"] });
-      // Low cosine similarity should produce no S-edge
-      expect(edges).toHaveLength(0);
-    });
-  });
-
-  // Test 6: Supersession
-  describe("Edge Inference - Supersession", () => {
-    it("should create U-edge when new learning supersedes old one", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-      const baseEmb = makeEmbedding(42);
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Tool X works well with param A",
-        embedding: baseEmb,
-        confidence: 0.5,
-      })!;
-
-      // Same category, cosine ~0.85 (>= 0.8 for supersession, < 0.92 for dedup), higher confidence
-      const id2 = learningStore.addLearning({
-        runId: "run-2",
-        category: "tool_pattern",
-        content: "Tool X works even better with param A and B",
-        embedding: makeEmbeddingWithSimilarity(baseEmb, 0.85),
-        confidence: 0.9,
-      })!;
-
-      expect(id2).not.toBeNull();
-      const learning2 = learningStore.getLearning(id2)!;
-      edgeInference.onLearningCreated(learning2, "run-2");
-
-      const edges = graphStore.getEdges(id1, { typeFilter: ["U"] });
-      const hasSupersession = edges.some(
-        (e) => e.sourceId === id1 && e.targetId === id2 && e.weight === 1.0,
-      );
-      expect(hasSupersession).toBe(true);
-    });
-  });
-
-  // Test 7: Contradiction
-  describe("Edge Inference - Contradiction", () => {
-    it("should detect contradiction via negation density", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Tool grep works effectively for searching code",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-
-      const id2 = learningStore.addLearning({
-        runId: "run-2",
-        category: "tool_pattern",
-        content: "Tool grep does not work effectively for searching code",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      const learning2 = learningStore.getLearning(id2)!;
-      edgeInference.onLearningCreated(learning2, "run-2");
-
-      const contradictions = graphStore.getContradictions(id2);
-      expect(contradictions.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it("should detect contradiction via category opposition", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-      const baseEmb = makeEmbedding(5);
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Tool X is reliable and fast",
-        embedding: baseEmb,
-        confidence: 0.8,
-      })!;
-
-      // Cosine ~0.78: above 0.7 for contradiction detection, below 0.92 for dedup
-      const id2 = learningStore.addLearning({
-        runId: "run-2",
-        category: "anti_pattern",
-        content: "Tool X is unreliable and slow",
-        embedding: makeEmbeddingWithSimilarity(baseEmb, 0.78),
-        confidence: 0.7,
-      })!;
-
-      expect(id2).not.toBeNull();
-      const learning2 = learningStore.getLearning(id2)!;
-      edgeInference.onLearningCreated(learning2, "run-2");
-
-      const contradictions = graphStore.getContradictions();
-      expect(contradictions.length).toBeGreaterThanOrEqual(1);
-    });
-  });
-
-  // Test 8: Reinforcement
-  describe("Edge Inference - Reinforcement", () => {
-    it("should create R-edges for co-applied learnings", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Learning A",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const id2 = learningStore.addLearning({
-        runId: "run-1",
-        category: "error_recovery",
-        content: "Learning B",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      edgeInference.onRunScored("run-2", [id1, id2], []);
-
-      const [source, target] = id1 < id2 ? [id1, id2] : [id2, id1];
-      const edges = graphStore.getEdges(source, { typeFilter: ["R"] });
-      expect(edges).toHaveLength(1);
-      expect(edges[0]!.weight).toBeCloseTo(0.3);
-    });
-
-    it("should increment R-edge weight on repeated co-application", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Learning C",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const id2 = learningStore.addLearning({
-        runId: "run-1",
-        category: "error_recovery",
-        content: "Learning D",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      edgeInference.onRunScored("run-2", [id1, id2], []);
-      edgeInference.onRunScored("run-3", [id1, id2], []);
-
-      const [source, target] = id1 < id2 ? [id1, id2] : [id2, id1];
-      const edges = graphStore.getEdges(source, { typeFilter: ["R"] });
-      expect(edges).toHaveLength(1);
-      expect(edges[0]!.weight).toBeCloseTo(0.4); // 0.3 + 0.1
-    });
-
-    it("should create C-edges from injected to extracted learnings", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-
-      const injectedId = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Injected learning",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const extractedId = learningStore.addLearning({
-        runId: "run-2",
-        category: "error_recovery",
-        content: "Extracted learning",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      edgeInference.onRunScored("run-2", [injectedId], [extractedId]);
-
-      const edges = graphStore.getEdges(injectedId, { typeFilter: ["C"] });
-      const hasCausal = edges.some((e) => e.sourceId === injectedId && e.targetId === extractedId);
-      expect(hasCausal).toBe(true);
-      expect(edges.find((e) => e.targetId === extractedId)!.weight).toBeCloseTo(0.6);
-    });
-  });
-
-  // Test 9: Hop expansion in retrieval
-  describe("Graph Retrieval", () => {
-    it("should expand seeds to include graph neighbors", () => {
-      const graphRetrieval = createGraphRetrieval({
-        graphStore,
-        learningStore,
-        config: TEST_CONFIG,
-      });
-
-      // Create learnings
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Seed learning about tool usage",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const id2 = learningStore.addLearning({
-        runId: "run-1",
-        category: "error_recovery",
-        content: "Neighbor learning about error handling",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      // Create S-edge between them
-      graphStore.addEdge(id1, id2, "S", 0.8);
-
-      const learning1 = learningStore.getLearning(id1)!;
-      const seeds: RetrievalResult[] = [{ learning: learning1, score: 0.9, decayedScore: 0.85 }];
-
-      const results = graphRetrieval.expandWithGraph(seeds, 5);
-      expect(results.length).toBe(2);
-
-      const neighborResult = results.find((r) => r.learning.id === id2);
-      expect(neighborResult).toBeDefined();
-      expect(neighborResult!.decayedScore).toBeLessThan(0.85); // Decayed by hop
-    });
-
-    it("should apply hop decay correctly", () => {
-      const graphRetrieval = createGraphRetrieval({
-        graphStore,
-        learningStore,
-        config: TEST_CONFIG,
-      });
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Seed learning",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const id2 = learningStore.addLearning({
-        runId: "run-1",
-        category: "error_recovery",
-        content: "1-hop neighbor",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      graphStore.addEdge(id1, id2, "C", 0.9); // Causal edge, multiplier = 1.0
-
-      const learning1 = learningStore.getLearning(id1)!;
-      const seeds: RetrievalResult[] = [{ learning: learning1, score: 1.0, decayedScore: 1.0 }];
-
-      const results = graphRetrieval.expandWithGraph(seeds, 5);
-      const neighbor = results.find((r) => r.learning.id === id2)!;
-
-      // Score = seedScore * hopDecay * typeMultiplier(C=1.0) * centralityBoost
-      // centralityBoost = 1.0 + 0.1 * log2(1 + centrality(id2))
-      const centrality = graphStore.getCentrality(id2);
-      const expectedCentralityBoost = 1.0 + 0.1 * Math.log2(1 + centrality);
-      const expectedScore = 1.0 * 0.6 * 1.0 * expectedCentralityBoost;
-      expect(neighbor.decayedScore).toBeCloseTo(expectedScore, 2);
-    });
-
-    it("should annotate contested results with X-edges", () => {
-      const graphRetrieval = createGraphRetrieval({
-        graphStore,
-        learningStore,
-        config: TEST_CONFIG,
-      });
-
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Contested seed learning",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const id2 = learningStore.addLearning({
-        runId: "run-2",
-        category: "anti_pattern",
-        content: "Contradicting learning",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      // Create X-edge (contradiction)
-      graphStore.addEdge(id1, id2, "X", 0.8);
-
-      const learning1 = learningStore.getLearning(id1)!;
-      const seeds: RetrievalResult[] = [{ learning: learning1, score: 0.9, decayedScore: 0.85 }];
-
-      const results = graphRetrieval.expandWithGraph(seeds, 5);
-      const contestedResult = results.find((r) => r.learning.id === id1);
-      expect(contestedResult).toBeDefined();
-      expect(contestedResult!.contested).toBe(true);
-
-      // Contradiction neighbor should NOT be expanded (X multiplier = 0.0)
-      const contradictionNeighbor = results.find((r) => r.learning.id === id2);
-      expect(contradictionNeighbor).toBeUndefined();
-    });
-  });
-
-  // Test 10: Integration -- full cycle
-  describe("Integration", () => {
-    it("should handle full cycle: create learnings, infer edges, retrieve with expansion", () => {
-      const edgeInference = createEdgeInference({ graphStore, learningStore });
-      const graphRetrieval = createGraphRetrieval({
-        graphStore,
-        learningStore,
-        config: TEST_CONFIG,
-      });
-
-      // Create learnings from same run
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Grep is efficient for finding patterns in code",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const learning1 = learningStore.getLearning(id1)!;
-      edgeInference.onLearningCreated(learning1, "run-1");
-
-      const id2 = learningStore.addLearning({
-        runId: "run-1",
-        category: "error_recovery",
-        content: "When grep fails use broader search terms",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-      const learning2 = learningStore.getLearning(id2)!;
-      edgeInference.onLearningCreated(learning2, "run-1");
-
-      // Verify T-edges were created (same run)
-      const edges = graphStore.getEdges(id1, { typeFilter: ["T"] });
-      expect(edges.length).toBeGreaterThanOrEqual(1);
-
-      // Simulate run scoring with both applied
-      edgeInference.onRunScored("run-2", [id1, id2], []);
-
-      // Verify R-edges were created
-      const rEdges = graphStore.getEdges(id1, { typeFilter: ["R"] });
-      expect(rEdges.length).toBeGreaterThanOrEqual(1);
-
-      // Retrieve with graph expansion
-      const seeds: RetrievalResult[] = [{ learning: learning1, score: 0.9, decayedScore: 0.85 }];
-
-      const results = graphRetrieval.expandWithGraph(seeds, 5);
-      expect(results.length).toBe(2); // Seed + neighbor
-      expect(results.map((r) => r.learning.id).sort()).toEqual([id1, id2].sort());
-    });
-
-    it("should clean up graph edges when learning is removed", () => {
-      const id1 = learningStore.addLearning({
-        runId: "run-1",
-        category: "tool_pattern",
-        content: "Removable learning",
-        embedding: null,
-        confidence: 0.8,
-      })!;
-      const id2 = learningStore.addLearning({
-        runId: "run-1",
-        category: "error_recovery",
-        content: "Connected learning",
-        embedding: null,
-        confidence: 0.7,
-      })!;
-
-      graphStore.addEdge(id1, id2, "S", 0.8);
-      expect(graphStore.getEdges(id1)).toHaveLength(1);
-
-      // Remove learning -- should also clean up edges
-      learningStore.removeLearning(id1);
-
-      expect(graphStore.getEdges(id1)).toHaveLength(0);
-      expect(graphStore.getEdges(id2, { typeFilter: ["S"] })).toHaveLength(0);
-    });
-  });
-});