@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/pending-violations.test.js

@@ -1,112 +0,0 @@
-/**
- * Sprint 7.3: Pending Violation Store tests.
- */
-import { describe, expect, it } from "vitest";
-import { PendingViolationStore } from "../tracking/pending-violations.js";
-function makeViolation(file, rule, message, line) {
-    return {
-        ruleKey: `rule-${rule}`,
-        ruleName: rule,
-        severity: "warning",
-        message,
-        filePath: file,
-        line,
-    };
-}
-describe("PendingViolationStore", () => {
-    it("starts empty", () => {
-        const store = new PendingViolationStore();
-        expect(store.hasPending).toBe(false);
-        expect(store.count).toBe(0);
-        expect(store.drain()).toBeUndefined();
-    });
-    it("stores and drains violations", () => {
-        const store = new PendingViolationStore();
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "bad name", 10),
-        ]);
-        expect(store.hasPending).toBe(true);
-        expect(store.count).toBe(1);
-        const drained = store.drain();
-        expect(drained).toBeDefined();
-        expect(drained).toHaveLength(1);
-        expect(drained?.[0]?.file).toBe("src/a.ts");
-        expect(drained?.[0]?.rule).toBe("naming");
-        expect(drained?.[0]?.message).toBe("bad name");
-        expect(drained?.[0]?.line).toBe(10);
-        // After drain, empty
-        expect(store.hasPending).toBe(false);
-        expect(store.drain()).toBeUndefined();
-    });
-    it("replaces violations for same file", () => {
-        const store = new PendingViolationStore();
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "v1"),
-        ]);
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "v2"),
-            makeViolation("src/a.ts", "structure", "v3"),
-        ]);
-        expect(store.count).toBe(2);
-        const drained = store.drain();
-        expect(drained).toHaveLength(2);
-        expect(drained?.[0]?.message).toBe("v2");
-    });
-    it("removes file entry when adding empty violations", () => {
-        const store = new PendingViolationStore();
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "v1"),
-        ]);
-        store.addViolations("src/a.ts", []);
-        expect(store.hasPending).toBe(false);
-        expect(store.count).toBe(0);
-    });
-    it("aggregates violations across multiple files", () => {
-        const store = new PendingViolationStore();
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "a1"),
-        ]);
-        store.addViolations("src/b.ts", [
-            makeViolation("src/b.ts", "naming", "b1"),
-            makeViolation("src/b.ts", "structure", "b2"),
-        ]);
-        expect(store.count).toBe(3);
-        const drained = store.drain();
-        expect(drained).toHaveLength(3);
-    });
-    it("drains for specific files only", () => {
-        const store = new PendingViolationStore();
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "a1"),
-        ]);
-        store.addViolations("src/b.ts", [
-            makeViolation("src/b.ts", "naming", "b1"),
-        ]);
-        const drained = store.drainForFiles(["src/a.ts"]);
-        expect(drained).toHaveLength(1);
-        expect(drained?.[0]?.file).toBe("src/a.ts");
-        // src/b.ts should still be pending
-        expect(store.hasPending).toBe(true);
-        expect(store.count).toBe(1);
-    });
-    it("drainForFiles returns undefined when no matching files", () => {
-        const store = new PendingViolationStore();
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "a1"),
-        ]);
-        expect(store.drainForFiles(["src/b.ts"])).toBeUndefined();
-        expect(store.hasPending).toBe(true);
-    });
-    it("clear removes everything", () => {
-        const store = new PendingViolationStore();
-        store.addViolations("src/a.ts", [
-            makeViolation("src/a.ts", "naming", "a1"),
-        ]);
-        store.addViolations("src/b.ts", [
-            makeViolation("src/b.ts", "naming", "b1"),
-        ]);
-        store.clear();
-        expect(store.hasPending).toBe(false);
-        expect(store.count).toBe(0);
-    });
-});

package/dist/__tests__/persistence-effectiveness.test.js

@@ -1,143 +0,0 @@
-import { mkdirSync, rmSync } from "node:fs";
-import os from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { PersistenceEffectivenessTracker } from "../tracking/persistence-effectiveness.js";
-import { TokenFlowWriter, readTokenFlowEvents, } from "../tracking/token-flow.js";
-function verdicts(unerrDir) {
-    return readTokenFlowEvents(unerrDir)
-        .filter((e) => e.mechanism === "persistent_memory")
-        .map((e) => (e.detail ?? {}));
-}
-describe("PersistenceEffectivenessTracker", () => {
-    let tmpDir;
-    let unerrDir;
-    let writer;
-    let tracker;
-    beforeEach(() => {
-        tmpDir = join(os.tmpdir(), `unerr-eff-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-        unerrDir = join(tmpDir, ".unerr");
-        mkdirSync(unerrDir, { recursive: true });
-        writer = new TokenFlowWriter(unerrDir, "test-session");
-        tracker = new PersistenceEffectivenessTracker(writer, { windowTurns: 5 });
-    });
-    afterEach(() => {
-        rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it("emits a fired verdict when a signal first fires", () => {
-        tracker.recordSignalFired({
-            kind: "fact_injected",
-            signal_id: "fact-1",
-            entity_key: "EntityA",
-            turn: 1,
-        });
-        const v = verdicts(unerrDir);
-        expect(v).toHaveLength(1);
-        expect(v[0]?.kind).toBe("fact_injected");
-        expect(v[0]?.verdict).toBe("fired");
-        expect(v[0]?.signal_id).toBe("fact-1");
-    });
-    it("re-firing within window counts as a reinforcement, not a new fired event", () => {
-        tracker.recordSignalFired({
-            kind: "fact_injected",
-            signal_id: "fact-1",
-            entity_key: "EntityA",
-            turn: 1,
-        });
-        tracker.recordSignalFired({
-            kind: "fact_injected",
-            signal_id: "fact-1",
-            entity_key: "EntityA",
-            turn: 2,
-        });
-        const fired = verdicts(unerrDir).filter((v) => v.verdict === "fired");
-        expect(fired).toHaveLength(1);
-    });
-    it("classifies a re-fired signal with no correction as reinforced on close", () => {
-        tracker.recordSignalFired({
-            kind: "fact_injected",
-            signal_id: "fact-1",
-            entity_key: "EntityA",
-            turn: 1,
-        });
-        tracker.recordSignalFired({
-            kind: "fact_injected",
-            signal_id: "fact-1",
-            entity_key: "EntityA",
-            turn: 2,
-        });
-        tracker.closeWindow(7);
-        const resolved = verdicts(unerrDir).find((v) => v.verdict === "reinforced");
-        expect(resolved?.signal_id).toBe("fact-1");
-    });
-    it("classifies as acted_on when entity received an edit and no correction", () => {
-        tracker.recordSignalFired({
-            kind: "convention_injected",
-            signal_id: "conv-1",
-            entity_key: "EntityB",
-            turn: 1,
-        });
-        tracker.recordEdit("EntityB");
-        tracker.closeWindow(7);
-        const resolved = verdicts(unerrDir).find((v) => v.verdict === "acted_on");
-        expect(resolved?.signal_id).toBe("conv-1");
-    });
-    it("classifies as corrected when a correction fires for the entity", () => {
-        tracker.recordSignalFired({
-            kind: "convention_injected",
-            signal_id: "conv-2",
-            entity_key: "EntityC",
-            turn: 1,
-        });
-        tracker.recordEdit("EntityC");
-        tracker.recordCorrection("EntityC", "circuit_breaker");
-        tracker.closeWindow(7);
-        const resolved = verdicts(unerrDir).find((v) => v.verdict === "corrected");
-        expect(resolved?.signal_id).toBe("conv-2");
-    });
-    it("classifies negative_warned with no correction as caught", () => {
-        tracker.recordSignalFired({
-            kind: "negative_warned",
-            signal_id: "neg-1",
-            entity_key: "EntityD",
-            turn: 1,
-        });
-        tracker.closeWindow(7);
-        const resolved = verdicts(unerrDir).find((v) => v.verdict === "caught");
-        expect(resolved?.signal_id).toBe("neg-1");
-    });
-    it("classifies as ignored when nothing happens in the window", () => {
-        tracker.recordSignalFired({
-            kind: "fact_injected",
-            signal_id: "fact-99",
-            entity_key: "EntityZ",
-            turn: 1,
-        });
-        tracker.closeWindow(7);
-        const resolved = verdicts(unerrDir).find((v) => v.verdict === "ignored");
-        expect(resolved?.signal_id).toBe("fact-99");
-    });
-    it("does not close windows still inside the K-turn observation period", () => {
-        tracker.recordSignalFired({
-            kind: "fact_injected",
-            signal_id: "fact-young",
-            entity_key: null,
-            turn: 5,
-        });
-        tracker.closeWindow(7); // delta 2 < 5
-        expect(tracker.openCount()).toBe(1);
-        expect(verdicts(unerrDir).filter((v) => v.verdict !== "fired")).toHaveLength(0);
-    });
-    it("closeAll forces verdicts regardless of turn distance", () => {
-        tracker.recordSignalFired({
-            kind: "resume_injected",
-            signal_id: "session-X",
-            entity_key: null,
-            turn: 50,
-        });
-        tracker.closeAll(50);
-        expect(tracker.openCount()).toBe(0);
-        const resolved = verdicts(unerrDir).filter((v) => v.signal_id === "session-X" && v.verdict !== "fired");
-        expect(resolved).toHaveLength(1);
-    });
-});

package/dist/__tests__/provider-factory.test.js

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveProviderConfig } from "../core/provider-factory.js";
-describe("resolveProviderConfig", () => {
-    it("defaults to anthropic with claude-sonnet-4-20250514", () => {
-        const config = resolveProviderConfig({});
-        expect(config.provider).toBe("anthropic");
-        expect(config.model).toBe("claude-sonnet-4-20250514");
-    });
-    it("resolves openai provider with gpt-4o default model", () => {
-        const config = resolveProviderConfig({ provider: "openai" });
-        expect(config.provider).toBe("openai");
-        expect(config.model).toBe("gpt-4o");
-    });
-    it("resolves google provider with gemini default model", () => {
-        const config = resolveProviderConfig({ provider: "google" });
-        expect(config.provider).toBe("google");
-        expect(config.model).toBe("gemini-2.0-flash");
-    });
-    it("resolves ollama with llama3 default", () => {
-        const config = resolveProviderConfig({ provider: "ollama" });
-        expect(config.provider).toBe("ollama");
-        expect(config.model).toBe("llama3");
-    });
-    it("passes through custom model and apiKey", () => {
-        const config = resolveProviderConfig({
-            provider: "openai",
-            model: "gpt-4-turbo",
-            apiKey: "sk-test",
-        });
-        expect(config.model).toBe("gpt-4-turbo");
-        expect(config.apiKey).toBe("sk-test");
-    });
-    it("passes through baseUrl for openai-compatible", () => {
-        const config = resolveProviderConfig({
-            provider: "openai-compatible",
-            model: "mistral-7b",
-            baseUrl: "http://localhost:8080/v1",
-        });
-        expect(config.provider).toBe("openai-compatible");
-        expect(config.baseUrl).toBe("http://localhost:8080/v1");
-    });
-});

package/dist/__tests__/providers.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SUPPORTED_PROVIDERS } from "../core/providers.js";
-describe("Provider Registry", () => {
-    it("lists all supported providers", () => {
-        expect(SUPPORTED_PROVIDERS).toContain("anthropic");
-        expect(SUPPORTED_PROVIDERS).toContain("openai");
-        expect(SUPPORTED_PROVIDERS).toContain("google");
-        expect(SUPPORTED_PROVIDERS).toContain("ollama");
-        expect(SUPPORTED_PROVIDERS).toContain("openai-compatible");
-        expect(SUPPORTED_PROVIDERS).toHaveLength(5);
-    });
-    it("provider names are string literals", () => {
-        const names = [
-            "anthropic",
-            "openai",
-            "google",
-            "ollama",
-            "openai-compatible",
-        ];
-        for (const name of names) {
-            expect(SUPPORTED_PROVIDERS).toContain(name);
-        }
-    });
-});

package/dist/__tests__/proxy.test.js

@@ -1,314 +0,0 @@
-/**
- * P10-TEST-01: Proxy Lifecycle Tests
- *
- * Tests PID lock, session stats, health grade computation.
- * Note: Full MCP server integration tests require cozo-node and stdio — kept as
- * focused unit tests for the core proxy subsystems.
- */
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { PidLock } from "../proxy/pid-lock.js";
-import { computePercentiles, createSessionStats, formatSessionStats, recordLatency, recordRiskWarning, recordToolCall, recordViolation, } from "../proxy/session-stats.js";
-let tempDir;
-beforeEach(() => {
-    tempDir = join(tmpdir(), `unerr-proxy-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(tempDir, { recursive: true });
-});
-afterEach(() => {
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-// ── PID Lock Tests ────────────────────────────────────────────────
-describe("PidLock", () => {
-    it("acquires lock when no PID file exists", async () => {
-        const lock = new PidLock(tempDir);
-        const result = await lock.acquire();
-        expect(result.acquired).toBe(true);
-        expect(result.outcome).toBe("primary");
-        expect(existsSync(join(tempDir, "proxy.pid"))).toBe(true);
-        lock.release();
-    });
-    it("writes JSON PID data to file", async () => {
-        const lock = new PidLock(tempDir);
-        await lock.acquire();
-        const content = readFileSync(join(tempDir, "proxy.pid"), "utf-8").trim();
-        const data = JSON.parse(content);
-        expect(data.pid).toBe(process.pid);
-        expect(data.startedAt).toBeTruthy();
-        expect(typeof data.healthPort).toBe("number");
-        expect(data.healthPort).toBeGreaterThan(0);
-        lock.release();
-    });
-    it("rejects second lock when PID is alive", async () => {
-        const lock1 = new PidLock(tempDir);
-        await lock1.acquire();
-        const lock2 = new PidLock(tempDir);
-        const result = await lock2.acquire();
-        expect(result.acquired).toBe(false);
-        expect(result.outcome).toBe("secondary");
-        expect(result.existingPid).toBe(process.pid);
-        lock1.release();
-    });
-    it("cleans up stale PID (legacy format) and acquires lock", async () => {
-        // Write a dead PID in legacy plain number format
-        writeFileSync(join(tempDir, "proxy.pid"), "9999999", "utf-8");
-        const lock = new PidLock(tempDir);
-        const result = await lock.acquire();
-        expect(result.acquired).toBe(true);
-        expect(result.outcome).toBe("stale_recovered");
-        lock.release();
-    });
-    it("cleans up stale PID (JSON format) and acquires lock", async () => {
-        // Write a dead PID in JSON format
-        writeFileSync(join(tempDir, "proxy.pid"), JSON.stringify({
-            pid: 9999999,
-            startedAt: new Date().toISOString(),
-            healthPort: 0,
-        }), "utf-8");
-        const lock = new PidLock(tempDir);
-        const result = await lock.acquire();
-        expect(result.acquired).toBe(true);
-        expect(result.outcome).toBe("stale_recovered");
-        lock.release();
-    });
-    it("release removes PID file", async () => {
-        const lock = new PidLock(tempDir);
-        await lock.acquire();
-        expect(existsSync(join(tempDir, "proxy.pid"))).toBe(true);
-        lock.release();
-        expect(existsSync(join(tempDir, "proxy.pid"))).toBe(false);
-    });
-    it("release only removes own PID", () => {
-        // Write someone else's PID in JSON format
-        writeFileSync(join(tempDir, "proxy.pid"), JSON.stringify({ pid: 1, startedAt: "", healthPort: 0 }), "utf-8");
-        const lock = new PidLock(tempDir);
-        // Don't acquire — just try to release
-        lock.release();
-        // File should still exist (PID 1 is not our PID)
-        expect(existsSync(join(tempDir, "proxy.pid"))).toBe(true);
-    });
-    it("isLocked reports correctly", async () => {
-        const lock = new PidLock(tempDir);
-        expect(lock.isLocked().locked).toBe(false);
-        await lock.acquire();
-        expect(lock.isLocked().locked).toBe(true);
-        expect(lock.isLocked().pid).toBe(process.pid);
-        expect(lock.isLocked().healthPort).toBeGreaterThan(0);
-        lock.release();
-        expect(lock.isLocked().locked).toBe(false);
-    });
-    it("health endpoint responds with status", async () => {
-        const lock = new PidLock(tempDir);
-        const result = await lock.acquire();
-        expect(result.healthPort).toBeGreaterThan(0);
-        lock.recordToolCall();
-        lock.recordToolCall();
-        lock.setMode("local");
-        const res = await fetch(`http://127.0.0.1:${result.healthPort}/health`);
-        expect(res.ok).toBe(true);
-        const body = (await res.json());
-        expect(body.status).toBe("ok");
-        expect(body.tool_calls).toBe(2);
-        expect(body.mode).toBe("local");
-        expect(body.pid).toBe(process.pid);
-        lock.release();
-    });
-    it("readPidFile returns data for running process", async () => {
-        const lock = new PidLock(tempDir);
-        await lock.acquire();
-        const data = PidLock.readPidFile(tempDir);
-        expect(data).not.toBeNull();
-        expect(data?.pid).toBe(process.pid);
-        expect(data?.healthPort).toBeGreaterThan(0);
-        lock.release();
-    });
-});
-// ── Session Stats Tests ───────────────────────────────────────────
-describe("SessionStats", () => {
-    it("creates stats with zero counters", () => {
-        const stats = createSessionStats();
-        expect(stats.toolCallsLocal).toBe(0);
-        expect(stats.estimatedTokensSaved).toBe(0);
-        expect(stats.violationsCaught).toBe(0);
-        expect(stats.riskWarningsIssued).toBe(0);
-    });
-    it("increments local tool calls", () => {
-        const stats = createSessionStats();
-        recordToolCall(stats);
-        recordToolCall(stats);
-        expect(stats.toolCallsLocal).toBe(2);
-        expect(stats.estimatedTokensSaved).toBeGreaterThan(0);
-    });
-    it("tracks violations and risk warnings", () => {
-        const stats = createSessionStats();
-        recordViolation(stats);
-        recordViolation(stats);
-        recordRiskWarning(stats);
-        expect(stats.violationsCaught).toBe(2);
-        expect(stats.riskWarningsIssued).toBe(1);
-    });
-    it("returns null format when no calls made", () => {
-        const stats = createSessionStats();
-        expect(formatSessionStats(stats)).toBeNull();
-    });
-    it("formats stats with local percentage and savings", () => {
-        const stats = createSessionStats();
-        recordToolCall(stats);
-        recordToolCall(stats);
-        recordToolCall(stats);
-        const output = formatSessionStats(stats);
-        expect(output).not.toBeNull();
-        expect(output).toContain("3 (all local)");
-        expect(output).toContain("Tokens saved");
-    });
-    it("includes violations and risk warnings in output", () => {
-        const stats = createSessionStats();
-        recordToolCall(stats);
-        recordViolation(stats);
-        recordRiskWarning(stats);
-        const output = formatSessionStats(stats);
-        expect(output).toContain("Violations");
-        expect(output).toContain("Risk warnings");
-    });
-});
-// ── Latency Tracking Tests ────────────────────────────────────────
-describe("LatencyTracker", () => {
-    it("records latency samples and computes percentiles", () => {
-        const stats = createSessionStats();
-        // Simulate 100 local tool calls with increasing latency
-        for (let i = 1; i <= 100; i++) {
-            recordLatency(stats.latency, i * 0.05); // 0.05ms to 5.0ms
-        }
-        const p = computePercentiles(stats.latency.localSamples, stats.latency.localTotalSamples);
-        expect(p).not.toBeNull();
-        expect(p?.count).toBe(100);
-        expect(p?.min).toBeCloseTo(0.05, 1);
-        expect(p?.max).toBeCloseTo(5.0, 1);
-        expect(p?.p50).toBeGreaterThan(0);
-        expect(p?.p95).toBeGreaterThan(p.p50);
-        expect(p?.p99).toBeGreaterThanOrEqual(p.p95);
-    });
-    it("records all samples as local", () => {
-        const stats = createSessionStats();
-        recordLatency(stats.latency, 1.5);
-        recordLatency(stats.latency, 1.8);
-        recordLatency(stats.latency, 2.5);
-        expect(stats.latency.localTotalSamples).toBe(3);
-        expect(stats.latency.totalSamples).toBe(3);
-        const localP = computePercentiles(stats.latency.localSamples, stats.latency.localTotalSamples);
-        expect(localP?.max).toBeLessThan(5);
-    });
-    it("returns null percentiles for zero samples", () => {
-        const stats = createSessionStats();
-        const p = computePercentiles(stats.latency.localSamples, 0);
-        expect(p).toBeNull();
-    });
-    it("circular buffer wraps correctly at capacity", () => {
-        const stats = createSessionStats();
-        // Fill past capacity (1000) — buffer should wrap
-        for (let i = 0; i < 1200; i++) {
-            recordLatency(stats.latency, i < 1000 ? 1.0 : 50.0);
-        }
-        expect(stats.latency.localTotalSamples).toBe(1200);
-        // Percentiles should reflect the circular nature
-        // Buffer has 200 samples of 50ms + 800 samples of 1ms
-        const p = computePercentiles(stats.latency.localSamples, stats.latency.localTotalSamples);
-        expect(p?.count).toBe(1200);
-        // p50 should be 1.0ms (800/1000 are 1ms)
-        expect(p?.p50).toBe(1.0);
-    });
-    it("formatSessionStats includes latency section", () => {
-        const stats = createSessionStats();
-        recordToolCall(stats);
-        recordLatency(stats.latency, 2.3);
-        recordToolCall(stats);
-        recordLatency(stats.latency, 280);
-        const output = formatSessionStats(stats);
-        expect(output).toContain("Latency");
-        expect(output).toContain("p50=");
-        expect(output).toContain("p95=");
-        expect(output).toContain("p99=");
-    });
-});
-// ── Health Grade Tests ────────────────────────────────────────────
-describe("HealthGrade", () => {
-    it("computeHealthGrade works with mock CozoDB", async () => {
-        const { computeHealthGrade } = await import("../intelligence/health-grade.js");
-        // Mock CozoDB that returns empty results
-        const mockDb = {
-            run: async (query) => {
-                if (query.includes("count(key)") && query.includes("entities"))
-                    return { rows: [[50]] };
-                if (query.includes("count(from_key)"))
-                    return { rows: [[100]] };
-                if (query.includes("count(key)") && query.includes("rules"))
-                    return { rows: [[5]] };
-                if (query.includes("fan_in == 0"))
-                    return { rows: [] };
-                if (query.includes('risk_level == "high"'))
-                    return { rows: [] };
-                return { rows: [] };
-            },
-        };
-        const result = await computeHealthGrade(mockDb);
-        expect(result.grade).toBeDefined();
-        expect(result.totalEntities).toBe(50);
-        expect(result.totalEdges).toBe(100);
-        expect(result.totalRules).toBe(5);
-        expect(result.score).toBeGreaterThan(0);
-    });
-    it("formatHealthGrade produces readable output", async () => {
-        const { formatHealthGrade } = await import("../intelligence/health-grade.js");
-        const result = {
-            grade: "B+",
-            totalEntities: 250,
-            totalEdges: 800,
-            totalRules: 12,
-            deadFunctionCount: 15,
-            highRiskEntities: [
-                {
-                    name: "processPayment",
-                    kind: "function",
-                    file_path: "src/billing.ts",
-                    fan_in: 23,
-                    fan_out: 8,
-                },
-            ],
-            score: 82,
-        };
-        const output = formatHealthGrade(result);
-        expect(output).toContain("B+");
-        expect(output).toContain("82/100");
-        expect(output).toContain("250");
-        expect(output).toContain("processPayment");
-        expect(output).toContain("23 callers");
-    });
-    it("assigns correct grades for edge scores", async () => {
-        const { computeHealthGrade } = await import("../intelligence/health-grade.js");
-        // High score (few entities, no dead, no risk, has rules)
-        const goodDb = {
-            run: async (query) => {
-                if (query.includes("count(key)") && query.includes("entities"))
-                    return { rows: [[30]] };
-                if (query.includes("count(from_key)"))
-                    return { rows: [[50]] };
-                if (query.includes("count(key)") && query.includes("rules"))
-                    return { rows: [[3]] };
-                if (query.includes("fan_in == 0"))
-                    return { rows: [] };
-                if (query.includes('risk_level == "high"'))
-                    return { rows: [] };
-                return { rows: [] };
-            },
-        };
-        const good = await computeHealthGrade(goodDb);
-        expect(good.score).toBeGreaterThanOrEqual(85);
-        expect(["A", "B+"]).toContain(good.grade);
-    });
-});