@unerr-ai/unerr 0.0.1 → 0.1.1

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

@@ -0,0 +1,112 @@
+/**
+ * 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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,24 @@
+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

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