@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/shell-tee.test.js

@@ -1,133 +0,0 @@
-import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { cleanupOldTees, teeShellOutput } from "../proxy/shell-tee.js";
-function makeTempDir() {
-    const dir = join(tmpdir(), `shell-tee-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-describe("teeShellOutput", () => {
-    const dirs = [];
-    afterEach(() => {
-        for (const d of dirs) {
-            try {
-                rmSync(d, { recursive: true, force: true });
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        dirs.length = 0;
-    });
-    it("saves output when ratio > 30% and raw > 1KB", () => {
-        const cwd = makeTempDir();
-        dirs.push(cwd);
-        const raw = "x".repeat(2000);
-        const compressed = "x".repeat(500); // 75% ratio
-        const result = teeShellOutput(cwd, "pnpm test", raw, compressed);
-        expect(result).not.toBeNull();
-        expect(result.filePath).toContain(".unerr/tee/");
-        expect(result.filePath).toContain("pnpm-test");
-        expect(result.sizeBytes).toBeGreaterThan(raw.length);
-        const content = readFileSync(result.filePath, "utf8");
-        expect(content).toContain("# command: pnpm test");
-        expect(content).toContain("# raw_bytes: 2000");
-        expect(content).toContain("ratio: 75.0%");
-        expect(content).toContain(raw);
-    });
-    it("returns null when raw is too small (< 1KB)", () => {
-        const cwd = makeTempDir();
-        dirs.push(cwd);
-        const raw = "x".repeat(500);
-        const compressed = "y".repeat(100);
-        expect(teeShellOutput(cwd, "echo hi", raw, compressed)).toBeNull();
-    });
-    it("returns null when compression ratio < 30%", () => {
-        const cwd = makeTempDir();
-        dirs.push(cwd);
-        const raw = "x".repeat(2000);
-        const compressed = "x".repeat(1800); // only 10% ratio
-        expect(teeShellOutput(cwd, "ls", raw, compressed)).toBeNull();
-    });
-    it("generates sanitized slug from command", () => {
-        const cwd = makeTempDir();
-        dirs.push(cwd);
-        const raw = "x".repeat(2000);
-        const compressed = "x".repeat(500);
-        const result = teeShellOutput(cwd, "kubectl describe pod/my-app", raw, compressed);
-        expect(result).not.toBeNull();
-        expect(result.filePath).toContain("kubectl-describe");
-    });
-    it("includes metadata header in tee file", () => {
-        const cwd = makeTempDir();
-        dirs.push(cwd);
-        const raw = "line\n".repeat(500);
-        const compressed = "summary";
-        const result = teeShellOutput(cwd, "git log --stat", raw, compressed);
-        expect(result).not.toBeNull();
-        const content = readFileSync(result.filePath, "utf8");
-        expect(content).toMatch(/^# unerr tee/);
-        expect(content).toContain("# command: git log --stat");
-        expect(content).toContain("# captured:");
-        expect(content).toContain("# raw_bytes:");
-        expect(content).toContain("# ---");
-    });
-});
-describe("cleanupOldTees", () => {
-    const dirs = [];
-    afterEach(() => {
-        for (const d of dirs) {
-            try {
-                rmSync(d, { recursive: true, force: true });
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        dirs.length = 0;
-    });
-    it("deletes files older than maxAge", () => {
-        const teeDir = makeTempDir();
-        dirs.push(teeDir);
-        // Create an "old" file with mtime in the past
-        const oldFile = join(teeDir, "old-file.txt");
-        writeFileSync(oldFile, "old content");
-        // Set mtime to 48h ago
-        const fs = require("node:fs");
-        const past = new Date(Date.now() - 48 * 60 * 60 * 1000);
-        fs.utimesSync(oldFile, past, past);
-        // Create a "new" file
-        writeFileSync(join(teeDir, "new-file.txt"), "new content");
-        const deleted = cleanupOldTees(teeDir, 24 * 60 * 60 * 1000);
-        expect(deleted).toBe(1);
-        const remaining = readdirSync(teeDir).filter((f) => f.endsWith(".txt"));
-        expect(remaining).toHaveLength(1);
-        expect(remaining[0]).toBe("new-file.txt");
-    });
-    it("enforces MAX_TEE_FILES limit (keeps newest)", () => {
-        const teeDir = makeTempDir();
-        dirs.push(teeDir);
-        // Create 55 files with staggered mtimes
-        const fs = require("node:fs");
-        for (let i = 0; i < 55; i++) {
-            const f = join(teeDir, `file-${String(i).padStart(3, "0")}.txt`);
-            writeFileSync(f, `content ${i}`);
-            const t = new Date(Date.now() - (55 - i) * 1000); // newer files have higher i
-            fs.utimesSync(f, t, t);
-        }
-        const deleted = cleanupOldTees(teeDir, 24 * 60 * 60 * 1000);
-        expect(deleted).toBe(5); // 55 - 50 = 5
-        const remaining = readdirSync(teeDir).filter((f) => f.endsWith(".txt"));
-        expect(remaining).toHaveLength(50);
-    });
-    it("returns 0 for empty directory", () => {
-        const teeDir = makeTempDir();
-        dirs.push(teeDir);
-        expect(cleanupOldTees(teeDir)).toBe(0);
-    });
-    it("returns 0 for nonexistent directory", () => {
-        expect(cleanupOldTees("/tmp/nonexistent-tee-dir-12345")).toBe(0);
-    });
-});

package/dist/__tests__/signal-dedup.test.js

@@ -1,158 +0,0 @@
-/**
- * Signal dedup — policy matrix coverage for shouldEmit + wouldEmit.
- *
- * Three policies under test:
- *   - always: every call emits (hlt/dft/hth)
- *   - on_change: first call emits, repeats with same content suppress, content
- *     change re-emits (rsk/fct/hnt/...)
- *   - once_per_session: first call emits, all subsequent calls suppress (wrn)
- *   - drop: never emits (ctx)
- *
- * wouldEmit is the non-mutating peek used by upstream rankers. It MUST return
- * the same boolean as shouldEmit would, without recording the emission.
- */
-import { describe, expect, it } from "vitest";
-import { DEFAULT_POLICY, createSignalDedup } from "../proxy/signal-dedup.js";
-describe("signal-dedup", () => {
-    describe("shouldEmit", () => {
-        it("always-policy tags emit every call", () => {
-            const d = createSignalDedup();
-            for (const tag of ["hlt", "dft", "hth"]) {
-                expect(d.shouldEmit(tag, "e", "msg")).toBe(true);
-                expect(d.shouldEmit(tag, "e", "msg")).toBe(true);
-                expect(d.shouldEmit(tag, "e", "msg")).toBe(true);
-            }
-        });
-        it("on_change emits first, suppresses repeats, re-emits on content change", () => {
-            const d = createSignalDedup();
-            expect(d.shouldEmit("rsk", "fn", "fan_in=24")).toBe(true);
-            expect(d.shouldEmit("rsk", "fn", "fan_in=24")).toBe(false);
-            expect(d.shouldEmit("rsk", "fn", "fan_in=24")).toBe(false);
-            expect(d.shouldEmit("rsk", "fn", "fan_in=30")).toBe(true);
-            expect(d.shouldEmit("rsk", "fn", "fan_in=30")).toBe(false);
-        });
-        it("on_change scopes by entity — different entities are independent", () => {
-            const d = createSignalDedup();
-            expect(d.shouldEmit("rsk", "a", "msg")).toBe(true);
-            expect(d.shouldEmit("rsk", "b", "msg")).toBe(true);
-            expect(d.shouldEmit("rsk", "a", "msg")).toBe(false);
-            expect(d.shouldEmit("rsk", "b", "msg")).toBe(false);
-        });
-        it("on_change with null entity uses 'global' scope", () => {
-            const d = createSignalDedup();
-            expect(d.shouldEmit("fct", null, "x")).toBe(true);
-            expect(d.shouldEmit("fct", null, "x")).toBe(false);
-        });
-        it("wrn uses on_change — same content suppressed, different content/scope re-emits", () => {
-            const d = createSignalDedup();
-            // Same (scope, content) — suppressed.
-            expect(d.shouldEmit("wrn", "e", "anti-pattern")).toBe(true);
-            expect(d.shouldEmit("wrn", "e", "anti-pattern")).toBe(false);
-            // Different content on same scope — emits.
-            expect(d.shouldEmit("wrn", "e", "different message")).toBe(true);
-            // Different scope, same content — emits.
-            expect(d.shouldEmit("wrn", "other", "anti-pattern")).toBe(true);
-        });
-        it("once_per_session via policy override suppresses regardless of content", () => {
-            const d = createSignalDedup({ wrn: "once_per_session" });
-            expect(d.shouldEmit("wrn", "e", "anti-pattern")).toBe(true);
-            expect(d.shouldEmit("wrn", "e", "anti-pattern")).toBe(false);
-            expect(d.shouldEmit("wrn", "e", "different message")).toBe(false);
-        });
-        it("drop policy never emits (ctx)", () => {
-            const d = createSignalDedup();
-            expect(d.shouldEmit("ctx", "e", "context")).toBe(false);
-            expect(d.shouldEmit("ctx", null, "context")).toBe(false);
-        });
-        it("unknown tags default to on_change", () => {
-            const d = createSignalDedup();
-            expect(d.shouldEmit("xyz", "e", "msg")).toBe(true);
-            expect(d.shouldEmit("xyz", "e", "msg")).toBe(false);
-            expect(d.shouldEmit("xyz", "e", "msg2")).toBe(true);
-        });
-        it("policy override changes behavior per-tag", () => {
-            const d = createSignalDedup({ rsk: "always" });
-            expect(d.shouldEmit("rsk", "e", "msg")).toBe(true);
-            expect(d.shouldEmit("rsk", "e", "msg")).toBe(true);
-            expect(d.shouldEmit("rsk", "e", "msg")).toBe(true);
-        });
-    });
-    describe("wouldEmit (non-mutating peek)", () => {
-        it("returns same boolean as shouldEmit on fresh state", () => {
-            const d = createSignalDedup();
-            expect(d.wouldEmit("rsk", "e", "x")).toBe(true);
-            expect(d.wouldEmit("wrn", "e", "x")).toBe(true);
-            expect(d.wouldEmit("ctx", "e", "x")).toBe(false);
-            expect(d.wouldEmit("hlt", "e", "x")).toBe(true);
-        });
-        it("does NOT record emission — multiple peeks still return true", () => {
-            const d = createSignalDedup();
-            expect(d.wouldEmit("rsk", "e", "x")).toBe(true);
-            expect(d.wouldEmit("rsk", "e", "x")).toBe(true);
-            expect(d.wouldEmit("rsk", "e", "x")).toBe(true);
-            // And the subsequent real emit still succeeds — proves no mutation.
-            expect(d.shouldEmit("rsk", "e", "x")).toBe(true);
-        });
-        it("reflects on_change state after shouldEmit recorded it", () => {
-            const d = createSignalDedup();
-            d.shouldEmit("rsk", "e", "x");
-            expect(d.wouldEmit("rsk", "e", "x")).toBe(false);
-            expect(d.wouldEmit("rsk", "e", "y")).toBe(true);
-        });
-        it("reflects on_change state for wrn after shouldEmit recorded it", () => {
-            const d = createSignalDedup();
-            d.shouldEmit("wrn", "e", "x");
-            expect(d.wouldEmit("wrn", "e", "x")).toBe(false); // same content — suppressed
-            expect(d.wouldEmit("wrn", "e", "y")).toBe(true); // different content — emits
-        });
-        it("reflects once_per_session state via policy override", () => {
-            const d = createSignalDedup({ wrn: "once_per_session" });
-            d.shouldEmit("wrn", "e", "x");
-            expect(d.wouldEmit("wrn", "e", "x")).toBe(false);
-            expect(d.wouldEmit("wrn", "e", "y")).toBe(false);
-        });
-        it("always-policy tags always peek true regardless of state", () => {
-            const d = createSignalDedup();
-            d.shouldEmit("hlt", "e", "x");
-            d.shouldEmit("hlt", "e", "x");
-            expect(d.wouldEmit("hlt", "e", "x")).toBe(true);
-        });
-        it("drop-policy tags always peek false", () => {
-            const d = createSignalDedup();
-            expect(d.wouldEmit("ctx", "e", "x")).toBe(false);
-            d.shouldEmit("ctx", "e", "x");
-            expect(d.wouldEmit("ctx", "e", "x")).toBe(false);
-        });
-    });
-    describe("reset and size", () => {
-        it("size grows with on_change emissions, reset clears", () => {
-            const d = createSignalDedup();
-            expect(d.size()).toBe(0);
-            d.shouldEmit("rsk", "a", "x");
-            d.shouldEmit("rsk", "b", "x");
-            expect(d.size()).toBe(2);
-            d.reset();
-            expect(d.size()).toBe(0);
-            // After reset, re-emission is allowed.
-            expect(d.shouldEmit("rsk", "a", "x")).toBe(true);
-        });
-        it("always-policy emissions do not grow the table", () => {
-            const d = createSignalDedup();
-            d.shouldEmit("hlt", "a", "x");
-            d.shouldEmit("hlt", "b", "y");
-            expect(d.size()).toBe(0);
-        });
-    });
-    describe("DEFAULT_POLICY snapshot", () => {
-        it("matches expected per-tag policies", () => {
-            expect(DEFAULT_POLICY.hlt).toBe("always");
-            expect(DEFAULT_POLICY.dft).toBe("always");
-            expect(DEFAULT_POLICY.hth).toBe("always");
-            expect(DEFAULT_POLICY.rsk).toBe("on_change");
-            expect(DEFAULT_POLICY.fct).toBe("on_change");
-            expect(DEFAULT_POLICY.hnt).toBe("on_change");
-            expect(DEFAULT_POLICY.wrn).toBe("on_change");
-            expect(DEFAULT_POLICY.ctx).toBe("drop");
-        });
-    });
-});

package/dist/__tests__/signal-reinforcer.test.js

@@ -1,77 +0,0 @@
-/**
- * ST-5: Signal reinforcement + decay. Confirms facts.db is NEVER touched.
- */
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { pruneStaleSignals, reinforceSignal, } from "../timeline/signal-reinforcer.js";
-import { CozoTimelineStore } from "../timeline/timeline-store.js";
-let tempDir;
-let store;
-beforeEach(async () => {
-    tempDir = join(tmpdir(), `unerr-sr-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(tempDir, ".unerr"), { recursive: true });
-    store = await CozoTimelineStore.create(tempDir);
-});
-afterEach(() => {
-    try {
-        store.close();
-    }
-    catch {
-        /* ignore */
-    }
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-describe("reinforceSignal", () => {
-    it("creates a signal on first call and writes a reinforcement event", async () => {
-        const sig = await reinforceSignal(store, { type: "hot_file", scope: "src/auth.ts" }, 0.2, "loop_miner", { nowMs: 1_000 });
-        expect(sig.signal_id).toBeTruthy();
-        expect(sig.confidence).toBeCloseTo(0.7);
-        const history = await store.getReinforcementHistory(sig.signal_id);
-        expect(history).toHaveLength(1);
-        expect(history[0]?.delta).toBe(0.2);
-        expect(history[0]?.source).toBe("loop_miner");
-    });
-    it("reinforces an existing signal — confidence clamps to [0, 1]", async () => {
-        const a = await reinforceSignal(store, { type: "hot_file", scope: "src/auth.ts" }, 0.3, "src", { nowMs: 1_000 });
-        const b = await reinforceSignal(store, { type: "hot_file", scope: "src/auth.ts" }, 0.6, "src", { nowMs: 2_000 });
-        expect(b.signal_id).toBe(a.signal_id);
-        expect(b.confidence).toBeLessThanOrEqual(1);
-        expect(b.confidence).toBeCloseTo(1); // 0.8 + 0.6 → clamped to 1
-        const c = await reinforceSignal(store, { type: "hot_file", scope: "src/auth.ts" }, -0.7, "contradiction", { nowMs: 3_000 });
-        expect(c.confidence).toBeCloseTo(0.3);
-        const history = await store.getReinforcementHistory(c.signal_id);
-        expect(history).toHaveLength(3);
-    });
-    it("does not write to facts.db", async () => {
-        await reinforceSignal(store, { type: "hot_file", scope: "src/auth.ts" }, 0.1, "src", { nowMs: 1_000 });
-        // facts.db must not have been created by anything in the reinforcer path.
-        expect(existsSync(join(tempDir, ".unerr", "facts.db"))).toBe(false);
-    });
-});
-describe("pruneStaleSignals", () => {
-    it("removes signals last seen before the cutoff", async () => {
-        await reinforceSignal(store, { type: "hot_file", scope: "src/old.ts" }, 0.2, "src", { nowMs: 1_000 });
-        await reinforceSignal(store, { type: "hot_file", scope: "src/new.ts" }, 0.2, "src", { nowMs: 30 * 24 * 60 * 60_000 });
-        const removed = await pruneStaleSignals(store, {
-            staleAfterMs: 14 * 24 * 60 * 60_000,
-            nowMs: 30 * 24 * 60 * 60_000 + 1_000,
-        });
-        expect(removed).toBe(1);
-        const remaining = await store.listSignals();
-        expect(remaining).toHaveLength(1);
-        expect(remaining[0]?.scope).toBe("src/new.ts");
-    });
-    it("returns 0 when nothing is stale", async () => {
-        const now = Date.now();
-        await reinforceSignal(store, { type: "loop", scope: "src/x.ts" }, 0.1, "src", { nowMs: now });
-        const removed = await pruneStaleSignals(store, { nowMs: now });
-        expect(removed).toBe(0);
-    });
-});

package/dist/__tests__/signal-scorer.test.js

@@ -1,251 +0,0 @@
-// @ts-nocheck — test file, array index access is intentional
-/**
- * Signal Scorer tests — scoring formula, ranking, burst multipliers, convention signals.
- */
-import { describe, expect, it } from "vitest";
-import { SignalScorer, getSignalScorer, } from "../intelligence/signal-scorer.js";
-describe("SignalScorer", () => {
-    const scorer = new SignalScorer();
-    describe("contextToSignals", () => {
-        it("converts blast_radius to warning signal", () => {
-            const raw = {
-                blast_radius: "5 direct callers, 3 callees",
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            expect(signals).toHaveLength(1);
-            expect(signals[0].type).toBe("warning");
-            expect(signals[0].content).toContain("5 direct callers");
-            expect(signals[0].actionability).toBe(0.9);
-            expect(signals[0].source).toBe("graph");
-            expect(signals[0].action).toBeDefined();
-        });
-        it("converts pending_violations to warning signals (max 3)", () => {
-            const raw = {
-                pending_violations: [
-                    { file: "a.ts", rule: "naming", message: "bad name", line: 10 },
-                    { file: "b.ts", rule: "style", message: "wrong indent" },
-                    { file: "c.ts", rule: "error", message: "missing catch", line: 5 },
-                    { file: "d.ts", rule: "extra", message: "should be capped" },
-                ],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            expect(signals).toHaveLength(3); // capped at 3
-            expect(signals.every((s) => s.type === "warning")).toBe(true);
-            expect(signals[0].content).toContain("a.ts");
-            expect(signals[0].action).toContain("naming");
-            expect(signals[0].action).toContain("line 10");
-            // Second violation has no line
-            expect(signals[1].action).toBe("Fix: style");
-        });
-        it("converts conventions to guidance signals (max 3)", () => {
-            const raw = {
-                conventions: [
-                    "Error handler: wrap in try/catch (90% adherence)",
-                    "Naming: camelCase (85% adherence)",
-                ],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            expect(signals).toHaveLength(2);
-            expect(signals.every((s) => s.type === "guidance")).toBe(true);
-            expect(signals[0].actionability).toBe(0.7);
-            expect(signals[0].source).toBe("graph");
-        });
-        it("converts relevant_facts with episodic prefix to history signal", () => {
-            const raw = {
-                relevant_facts: ["[episodic] Modified doStuff to add error handling"],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            expect(signals).toHaveLength(1);
-            expect(signals[0].type).toBe("history");
-            expect(signals[0].actionability).toBe(0.7);
-            // Episodic fact action now names the concrete tool call to make
-            // divergence visible in the timeline.
-            expect(signals[0].action).toContain("mark_decision");
-        });
-        it("converts relevant_facts with negative prefix to warning signal", () => {
-            const raw = {
-                relevant_facts: ["[negative] This pattern caused bugs before"],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            expect(signals).toHaveLength(1);
-            expect(signals[0].type).toBe("warning");
-            // Negative facts boosted to 0.85 (Issue #4 fix — anti-pattern facts must
-            // outrank co-change hnt even at low decision level cap=2).
-            expect(signals[0].actionability).toBe(0.85);
-        });
-        it("converts drift_alert to warning signal", () => {
-            const raw = {
-                drift_alert: "WARNING: entity modified since last index",
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            expect(signals).toHaveLength(1);
-            expect(signals[0].type).toBe("warning");
-            expect(signals[0].source).toBe("graph");
-        });
-        it("converts community to context signal", () => {
-            const raw = {
-                community: "Part of auth module (12 entities)",
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            expect(signals).toHaveLength(1);
-            expect(signals[0].type).toBe("context");
-            expect(signals[0].actionability).toBe(0.4);
-        });
-        it("handles empty raw context", () => {
-            const signals = scorer.contextToSignals({}, "get_entity", {});
-            expect(signals).toHaveLength(0);
-        });
-        it("handles all fields simultaneously", () => {
-            const raw = {
-                blast_radius: "3 callers",
-                conventions: ["naming: camelCase"],
-                drift_alert: "WARNING: drift",
-                corrections: ["fix this"],
-                community: "auth module",
-                reminder: "previously queried",
-                history: ["changed last session"],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            // blast_radius(1) + conventions(1) + drift(1) + corrections(1) + community(1) + reminder(1) + history(1) = 7
-            expect(signals.length).toBe(7);
-        });
-    });
-    describe("composite score formula", () => {
-        it("computes actionability^1.5 * relevance * confidence", () => {
-            const raw = {
-                blast_radius: "test",
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const s = signals[0];
-            const expected = s.actionability ** 1.5 * s.relevance * s.confidence;
-            expect(s.composite_score).toBeCloseTo(expected, 10);
-        });
-        it("higher actionability gives disproportionately higher score", () => {
-            // Warning (actionability 0.9) vs context (actionability 0.4)
-            const raw = {
-                blast_radius: "test",
-                community: "test",
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const warning = signals.find((s) => s.type === "warning");
-            const context = signals.find((s) => s.type === "context");
-            // Ratio should be > 0.9/0.4 due to exponent
-            expect(warning.composite_score).toBeGreaterThan(context.composite_score * 2);
-        });
-    });
-    describe("rank", () => {
-        it("returns top N signals by composite score", () => {
-            const raw = {
-                blast_radius: "3 callers",
-                conventions: ["naming: camelCase", "style: semicolons"],
-                community: "auth module",
-                reminder: "previously queried",
-                history: ["session 1", "session 2"],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const ranked = scorer.rank(signals, 3);
-            expect(ranked).toHaveLength(3);
-            // Should be sorted descending by composite_score
-            expect(ranked[0].composite_score).toBeGreaterThanOrEqual(ranked[1].composite_score);
-            expect(ranked[1].composite_score).toBeGreaterThanOrEqual(ranked[2].composite_score);
-        });
-        it("returns empty array for empty input", () => {
-            expect(scorer.rank([], 3)).toHaveLength(0);
-        });
-        it("returns all signals when fewer than maxSignals", () => {
-            const raw = { blast_radius: "test" };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const ranked = scorer.rank(signals, 5);
-            expect(ranked).toHaveLength(1);
-        });
-        it("defaults to max 3 signals", () => {
-            const raw = {
-                blast_radius: "test",
-                drift_alert: "test",
-                conventions: ["a", "b", "c"],
-                community: "test",
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const ranked = scorer.rank(signals);
-            expect(ranked).toHaveLength(3);
-        });
-    });
-    describe("applyBurstMultipliers", () => {
-        it("does not modify signals for non-high decision level", () => {
-            const raw = { blast_radius: "test" };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const original = signals[0].composite_score;
-            const boosted = scorer.applyBurstMultipliers(signals, "medium");
-            expect(boosted[0].composite_score).toBe(original);
-        });
-        it("boosts warning relevance at high decision level", () => {
-            const raw = { blast_radius: "test" };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const original = signals[0].composite_score;
-            const boosted = scorer.applyBurstMultipliers(signals, "high");
-            expect(boosted[0].composite_score).toBeGreaterThan(original);
-            expect(boosted[0].relevance).toBeGreaterThan(signals[0].relevance);
-        });
-        it("boosts history signals more than warnings at high decision level", () => {
-            const raw = {
-                blast_radius: "test",
-                history: ["changed last session"],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            const warning = signals.find((s) => s.type === "warning");
-            const history = signals.find((s) => s.type === "history");
-            const boosted = scorer.applyBurstMultipliers(signals, "high");
-            const boostedWarning = boosted.find((s) => s.type === "warning");
-            const boostedHistory = boosted.find((s) => s.type === "history");
-            // History gets 1.5x, warning gets 1.3x
-            const warningBoostRatio = boostedWarning.relevance / warning.relevance;
-            const historyBoostRatio = boostedHistory.relevance / history.relevance;
-            expect(historyBoostRatio).toBeGreaterThan(warningBoostRatio);
-        });
-        it("caps boosted relevance at 1.0", () => {
-            const raw = {
-                pending_violations: [{ file: "a.ts", rule: "r", message: "m" }],
-            };
-            const signals = scorer.contextToSignals(raw, "get_entity", {});
-            // pending_violations have relevance 0.95, * 1.3 = 1.235 → capped at 1.0
-            const boosted = scorer.applyBurstMultipliers(signals, "high");
-            expect(boosted[0].relevance).toBeLessThanOrEqual(1.0);
-        });
-    });
-    describe("conventionToSignal", () => {
-        const convention = {
-            name: "camelCase naming",
-            rule: "Use camelCase for functions",
-            adherence_pct: 87,
-            kind: "function",
-        };
-        it("generates prescriptive signal for entity tools", () => {
-            const signal = scorer.conventionToSignal(convention, "get_entity");
-            expect(signal.type).toBe("guidance");
-            expect(signal.content).toContain("Follow");
-            expect(signal.content).toContain("87%");
-            expect(signal.action).toContain("Apply pattern");
-            expect(signal.actionability).toBe(0.8);
-        });
-        it("generates descriptive signal for get_conventions", () => {
-            const signal = scorer.conventionToSignal(convention, "get_conventions");
-            expect(signal.type).toBe("guidance");
-            expect(signal.content).toContain("camelCase naming");
-            expect(signal.content).toContain("87%");
-            expect(signal.action).toBeUndefined();
-            expect(signal.actionability).toBe(0.5);
-        });
-        it("uses adherence_pct for relevance and confidence", () => {
-            const signal = scorer.conventionToSignal(convention, "get_entity");
-            expect(signal.relevance).toBe(0.87);
-            expect(signal.confidence).toBe(0.87);
-        });
-    });
-    describe("getSignalScorer singleton", () => {
-        it("returns same instance", () => {
-            const a = getSignalScorer();
-            const b = getSignalScorer();
-            expect(a).toBe(b);
-        });
-    });
-});