fix: enforce aggregation confidence floor minimum

src/constant/protocol.ts

@@ -0,0 +1,2 @@
+export const MIN_AGGREGATION_CONFIDENCE =
+  0.5;

src/utils/confidence.ts

@@ -0,0 +1,35 @@
+import {
+  MIN_AGGREGATION_CONFIDENCE,
+} from '../constants/protocol';
+
+export function applyConfidenceFloor(
+  confidence: number,
+): number {
+  if (
+    Number.isNaN(confidence)
+  ) {
+    return (
+      MIN_AGGREGATION_CONFIDENCE
+    );
+  }
+
+  return Math.max(
+    confidence,
+    MIN_AGGREGATION_CONFIDENCE,
+  );
+}
+
+export function normalizeConfidence(
+  confidence: number,
+): number {
+  if (
+    !Number.isFinite(confidence)
+  ) {
+    return 0.5;
+  }
+
+  return Math.min(
+    1,
+    Math.max(confidence, 0.5),
+  );
+}

test/aggregationConfidence.test.ts

@@ -0,0 +1,60 @@
+describe(
+  'aggregation confidence floor',
+  () => {
+    it(
+      'clamps confidence below 0.5',
+      () => {
+        expect(
+          applyConfidenceFloor(
+            0.2,
+          ),
+        ).toBe(0.5);
+      },
+    );
+  },
+);
+
+it(
+  'preserves confidence above floor',
+  () => {
+    expect(
+      applyConfidenceFloor(
+        0.91,
+      ),
+    ).toBe(0.91);
+  },
+);
+
+it(
+  'handles NaN safely',
+  () => {
+    expect(
+      applyConfidenceFloor(
+        NaN,
+      ),
+    ).toBe(0.5);
+  },
+);
+
+it(
+  'clamps negative values',
+  () => {
+    expect(
+      applyConfidenceFloor(
+        -5,
+      ),
+    ).toBe(0.5);
+  },
+);
+
+it(
+  'handles infinite values safely',
+  () => {
+    expect(
+      normalizeConfidence(
+        Infinity,
+      ),
+    ).toBe(1);
+  },
+);
+

test/claims.e2e-spec.ts

@@ -0,0 +1,34 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { INestApplication } from "@nestjs/common";
+import * as request from "supertest";
+
+import { AppModule } from "@/src/app.module";
+
+describe("Claims (e2e)", () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule =
+      await Test.createTestingModule({
+        imports: [AppModule],
+      }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it("GET /claims/:id should return 404 for unknown id", async () => {
+    const unknownId = "non-existent-id";
+
+    await request(app.getHttpServer())
+      .get(`/claims/${unknownId}`)
+      .expect(404)
+      .expect((res) => {
+        expect(res.body.message).toContain("not found");
+      });
+  });
+});