test(metrics): add tests for loop bounds, array spreading, and divergence

- add EMD loop bound validation test with exact calculation
- add KL divergence comparison test for smoothing
- add degree array spreading validation (kills 1 mutant)
- add intersection vs false positive validation
- final mutation score: 90.83% (metrics: 94.41%)

Author: Mearman

src/experiments/evaluation/metrics/degree-distribution.unit.test.ts

@@ -125,6 +125,32 @@ describe("klDivergence", () => {
 		expect(result).toBeGreaterThan(0);
 		expect(isFinite(result)).toBe(true);
 	});
+
+	it("should produce different results for different distributions with smoothing", () => {
+		// Different distributions should have different KL divergences
+		// This catches if smoothing arithmetic is wrong (+ vs -)
+		const p = new Map([
+			[1, 0.8],
+			[2, 0.2],
+		]);
+		const q1 = new Map([
+			[1, 0.2],
+			[2, 0.8],
+		]);
+		const q2 = new Map([
+			[1, 0.5],
+			[2, 0.5],
+		]);
+
+		const kl1 = klDivergence(p, q1, 0.001);
+		const kl2 = klDivergence(p, q2, 0.001);
+
+		// q2 is closer to p than q1, so KL(p||q2) < KL(p||q1)
+		expect(kl2).toBeLessThan(kl1);
+		// Both should be positive
+		expect(kl1).toBeGreaterThan(0);
+		expect(kl2).toBeGreaterThan(0);
+	});
 });
 
 describe("jsDivergence", () => {
@@ -210,6 +236,29 @@ describe("earthMoversDistance", () => {
 		// Farther distribution should have higher EMD
 		expect(emd2).toBeGreaterThan(emd1);
 	});
+
+	it("should compute exact EMD for multi-degree distributions (validates loop bounds)", () => {
+		// P: 50% at degree 1, 50% at degree 3
+		// Q: 100% at degree 2
+		const p = new Map([
+			[1, 0.5],
+			[3, 0.5],
+		]);
+		const q = new Map([[2, 1]]);
+
+		// Manual calculation:
+		// Sorted degrees: [1, 2, 3]
+		// At degree 1: cdfP=0.5, cdfQ=0,   width=1, contrib=0.5*1=0.5
+		// At degree 2: cdfP=0.5, cdfQ=1.0, width=1, contrib=0.5*1=0.5
+		// At degree 3: cdfP=1.0, cdfQ=1.0, width=1, contrib=0*1=0
+		// EMD = 0.5 + 0.5 + 0 = 1.0
+		const emd = earthMoversDistance(p, q);
+		expect(emd).toBeCloseTo(1, 5);
+
+		// If loop runs one extra iteration (index <= length), EMD would be different
+		expect(emd).not.toBeCloseTo(2, 5);
+		expect(emd).not.toBeCloseTo(1.5, 5);
+	});
 });
 
 describe("compareDegreeDistributions", () => {

src/experiments/evaluation/metrics/structural-representativeness.unit.test.ts

@@ -318,6 +318,67 @@ describe("computeStructuralRepresentativeness", () => {
 
 		expect(result.communityCoverage).toBe(1); // Both communities covered
 	});
+
+	it("should compute non-zero degree divergence from degree arrays (validates array spreading)", () => {
+		// Different degree distributions should produce non-zero KL/JS
+		const sampled = new Set(["A", "B", "C"]);
+		const groundTruth = new Set(["A", "B", "C"]);
+		const sampledDegrees = new Map([
+			["A", 10], // Two nodes with degree 10
+			["B", 10],
+			["C", 1], // One node with degree 1
+		]);
+		const gtDegrees = new Map([
+			["A", 5], // All nodes with degree 5
+			["B", 5],
+			["C", 5],
+		]);
+
+		const result = computeStructuralRepresentativeness(
+			sampled,
+			groundTruth,
+			sampledDegrees,
+			gtDegrees
+		);
+
+		// sampledDegreeArray = [10, 10, 1] → distribution: {10: 2/3, 1: 1/3}
+		// gtDegreeArray = [5, 5, 5] → distribution: {5: 1.0}
+		// These are different distributions, so KL/JS should be > 0
+		// If degree arrays are emptied (mutation), these would be 0
+		expect(result.degreeKL).toBeGreaterThan(0);
+		expect(result.degreeJS).toBeGreaterThan(0);
+	});
+
+	it("should correctly identify intersection vs false positives (validates has() check)", () => {
+		// Explicit test for the groundTruthNodes.has(node) logic
+		const sampled = new Set(["A", "B", "C", "X", "Y"]);
+		const groundTruth = new Set(["A", "B", "C"]);
+		const sampledDegrees = new Map([
+			["A", 1],
+			["B", 1],
+			["C", 1],
+			["X", 1],
+			["Y", 1],
+		]);
+		const gtDegrees = new Map([
+			["A", 1],
+			["B", 1],
+			["C", 1],
+		]);
+
+		const result = computeStructuralRepresentativeness(
+			sampled,
+			groundTruth,
+			sampledDegrees,
+			gtDegrees
+		);
+
+		// Intersection: A, B, C
+		expect(result.intersectionSize).toBe(3);
+		// False positives: X, Y (in sampled but not in ground truth)
+		expect(result.falsePositives).toBe(2);
+		// If has() is flipped, these counts would be wrong
+	});
 });
 
 describe("aggregateRepresentativenessResults", () => {